Merge "Removed the duplicate dependency"
[nonrtric.git] / policy-agent / src / main / java / org / oransc / policyagent / repository / Ric.java
1 /*-
2  * ========================LICENSE_START=================================
3  * O-RAN-SC
4  * %%
5  * Copyright (C) 2019 Nordix Foundation
6  * %%
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  *      http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  * ========================LICENSE_END===================================
19  */
20
21 package org.oransc.policyagent.repository;
22
23 import java.util.Collection;
24 import java.util.HashMap;
25 import java.util.Map;
26 import java.util.Vector;
27
28 import org.oransc.policyagent.configuration.RicConfig;
29
30 /**
31  * Represents the dynamic information about a NearRealtime-RIC.
32  */
33 public class Ric {
34     private final RicConfig ricConfig;
35     private RicState state = RicState.NOT_INITIATED;
36     private Map<String, PolicyType> supportedPolicyTypes = new HashMap<>();
37
38     /**
39      * Creates the Ric. Initial state is {@link RicState.NOT_INITIATED}.
40      *
41      * @param ricConfig The {@link RicConfig} for this Ric.
42      */
43     public Ric(RicConfig ricConfig) {
44         this.ricConfig = ricConfig;
45     }
46
47     public String name() {
48         return ricConfig.name();
49     }
50
51     public RicState state() {
52         return state;
53     }
54
55     public void setState(RicState newState) {
56         state = newState;
57     }
58
59     public RicConfig getConfig() {
60         return this.ricConfig;
61     }
62
63     /**
64      * Gets the nodes managed by this Ric.
65      *
66      * @return a vector containing the nodes managed by this Ric.
67      */
68     public Vector<String> getManagedNodes() {
69         return ricConfig.managedElementIds();
70     }
71
72     /**
73      * Determines if the given node is managed by this Ric.
74      *
75      * @param nodeName the node name to check.
76      * @return true if the given node is managed by this Ric.
77      */
78     public boolean isManaging(String nodeName) {
79         return ricConfig.managedElementIds().contains(nodeName);
80     }
81
82     /**
83      * Adds the given node as managed by this Ric.
84      *
85      * @param nodeName the node to add.
86      */
87     public void addManagedNode(String nodeName) {
88         if (!ricConfig.managedElementIds().contains(nodeName)) {
89             ricConfig.managedElementIds().add(nodeName);
90         }
91     }
92
93     /**
94      * Removes the given node as managed by this Ric.
95      *
96      * @param nodeName the node to remove.
97      */
98     public void removeManagedNode(String nodeName) {
99         ricConfig.managedElementIds().remove(nodeName);
100     }
101
102     /**
103      * Gets the policy types supported by this Ric.
104      *
105      * @return the policy types supported by this Ric in an unmodifiable list.
106      */
107     public Collection<PolicyType> getSupportedPolicyTypes() {
108         return supportedPolicyTypes.values();
109     }
110
111     public Collection<String> getSupportedPolicyTypeNames() {
112         return supportedPolicyTypes.keySet();
113     }
114
115     /**
116      * Adds a policy type as supported by this Ric.
117      *
118      * @param type the policy type to support.
119      */
120     public void addSupportedPolicyType(PolicyType type) {
121         supportedPolicyTypes.put(type.name(), type);
122     }
123
124     /**
125      * Adds policy types as supported by this Ric.
126      *
127      * @param types the policy types to support.
128      */
129     public void addSupportedPolicyTypes(Collection<PolicyType> types) {
130         for (PolicyType type : types) {
131             addSupportedPolicyType(type);
132         }
133     }
134
135     /**
136      * Removes a policy type as supported by this Ric.
137      *
138      * @param type the policy type to remove as supported by this Ric.
139      */
140     public void removeSupportedPolicyType(PolicyType type) {
141         supportedPolicyTypes.remove(type.name());
142     }
143
144     /**
145      * Checks if a type is supported by this Ric.
146      *
147      * @param typeName the name of the type to check if it is supported.
148      *
149      * @return true if the given type is supported by this Ric, false otherwise.
150      */
151     public boolean isSupportingType(String typeName) {
152         return supportedPolicyTypes.containsKey(typeName);
153     }
154
155     @Override
156     public String toString() {
157         return Ric.class.getSimpleName() + ": " + "name: " + name() + ", state: " + state + ", baseUrl: "
158             + ricConfig.baseUrl() + ", managedNodes: " + ricConfig.managedElementIds();
159     }
160
161     /**
162      * Represents the states possible for a Ric.
163      */
164     public static enum RicState {
165         /**
166          * The Ric has not been initiated yet.
167          */
168         NOT_INITIATED,
169         /**
170          * The Ric is working fine.
171          */
172         ACTIVE,
173         /**
174          * The Ric cannot be contacted.
175          */
176         NOT_REACHABLE
177     }
178 }