}
private Mono<Object> assertRicStateIdle(Ric ric) {
- if (ric.getState() == Ric.RicState.IDLE) {
+ if (ric.getState() == Ric.RicState.AVAILABLE) {
return Mono.just("OK");
} else {
RejectionException e = new RejectionException(
@ApiModelProperty(value = "supported policy types")
public final Collection<String> policyTypes;
- RicInfo(String name, Collection<String> managedElementIds, Collection<String> policyTypes) {
+ @ApiModelProperty(value = "state info")
+ public final String state;
+
+ RicInfo(String name, Collection<String> managedElementIds, Collection<String> policyTypes, String state) {
this.ricName = name;
this.managedElementIds = managedElementIds;
this.policyTypes = policyTypes;
+ this.state = state;
}
}
List<RicInfo> result = new ArrayList<>();
for (Ric ric : rics.getRics()) {
if (supportingPolicyType == null || ric.isSupportingType(supportingPolicyType)) {
- result.add(new RicInfo(ric.name(), ric.getManagedElementIds(), ric.getSupportedPolicyTypeNames()));
+ result.add(new RicInfo(ric.name(), ric.getManagedElementIds(), ric.getSupportedPolicyTypeNames(),
+ ric.getState().toString()));
}
}
@Setter
private RicConfig ricConfig;
- private RicState state = RicState.UNDEFINED;
+ private RicState state = RicState.UNAVAILABLE;
private Map<String, PolicyType> supportedPolicyTypes = new HashMap<>();
@Getter
@Setter
/**
* The agent view of the Ric may be inconsistent.
*/
- UNDEFINED,
+ UNAVAILABLE,
/**
* The normal state. Policies can be configured.
*/
- IDLE,
+ AVAILABLE,
/**
* The agent is synchronizing the view of the Ric.
*/
}
private Mono<RicData> checkRicState(RicData ric) {
- if (ric.ric.getState() == RicState.UNDEFINED) {
+ if (ric.ric.getState() == RicState.UNAVAILABLE) {
return startSynchronization(ric) //
.onErrorResume(t -> Mono.empty());
} else if (ric.ric.getState() == RicState.SYNCHRONIZING) {
@Override
protected void hookOnError(Throwable throwable) {
logger.warn("Synchronization failure for ric: {}, reason: {}", ric.name(), throwable.getMessage());
- ric.setState(RicState.UNDEFINED);
+ ric.setState(RicState.UNAVAILABLE);
}
@Override
private void onSynchronizationComplete(Ric ric) {
logger.debug("Synchronization completed for: {}", ric.name());
- ric.setState(RicState.IDLE);
+ ric.setState(RicState.AVAILABLE);
notifyAllServices("Synchronization completed for:" + ric.name());
}
ric.getLock().lockBlocking(LockType.EXCLUSIVE);
ric.getLock().unlockBlocking();
assertThat(ric.getLock().getLockCounter()).isEqualTo(0);
- assertThat(ric.getState()).isEqualTo(Ric.RicState.IDLE);
+ assertThat(ric.getState()).isEqualTo(Ric.RicState.AVAILABLE);
}
}
@Test
public void testSynchronization() throws Exception {
- addRic("ric").setState(Ric.RicState.UNDEFINED);
+ addRic("ric").setState(Ric.RicState.UNAVAILABLE);
String ricName = "ric";
Policy policy2 = addPolicy("policyId2", "typeName", "service", ricName);
Policy policy = addPolicy(policyId, "typeName", "service", ricName); // This should be created in the RIC
supervision.checkAllRics(); // The created policy should be put in the RIC
await().untilAsserted(() -> RicState.SYNCHRONIZING.equals(rics.getRic(ricName).getState()));
- await().untilAsserted(() -> RicState.IDLE.equals(rics.getRic(ricName).getState()));
+ await().untilAsserted(() -> RicState.AVAILABLE.equals(rics.getRic(ricName).getState()));
Policies ricPolicies = getA1Client(ricName).getPolicies();
assertThat(ricPolicies.size()).isEqualTo(1);
String url = putPolicyUrl(serviceName, ricName, policyTypeName, policyInstanceId);
final String policyBody = jsonString();
- this.rics.getRic(ricName).setState(Ric.RicState.IDLE);
+ this.rics.getRic(ricName).setState(Ric.RicState.AVAILABLE);
restClient().put(url, policyBody).block();
url = putPolicyUrl(serviceName, ricName, policyTypeName, policyInstanceId);
this.rics.getRic(ricName).setState(Ric.RicState.SYNCHRONIZING);
testErrorCode(restClient().put(url, policyBody), HttpStatus.LOCKED);
- this.rics.getRic(ricName).setState(Ric.RicState.IDLE);
+ this.rics.getRic(ricName).setState(Ric.RicState.AVAILABLE);
}
@Test
.controllerName("") //
.build();
Ric ric = new Ric(conf);
- ric.setState(Ric.RicState.IDLE);
+ ric.setState(Ric.RicState.AVAILABLE);
this.rics.put(ric);
return ric;
}
types.clear();
policies.clear();
rics.clear();
- RIC_1.setState(RicState.UNDEFINED);
+ RIC_1.setState(RicState.UNAVAILABLE);
RIC_1.clearSupportedPolicyTypes();
}
@Test
public void whenRicIdleAndNoChangedPoliciesOrPolicyTypes_thenNoSynchronization() {
- RIC_1.setState(RicState.IDLE);
+ RIC_1.setState(RicState.AVAILABLE);
RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
rics.put(RIC_1);
@Test
public void whenRicUndefined_thenSynchronization() {
- RIC_1.setState(RicState.UNDEFINED);
+ RIC_1.setState(RicState.UNAVAILABLE);
rics.put(RIC_1);
RicSupervision supervisorUnderTest = spy(new RicSupervision(rics, policies, a1ClientFactory, types, null));
@Test
public void whenRicIdleAndErrorGettingPolicyIdentities_thenNoSynchronization() {
- RIC_1.setState(RicState.IDLE);
+ RIC_1.setState(RicState.AVAILABLE);
RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
rics.put(RIC_1);
@Test
public void whenRicIdleAndNotSameAmountOfPolicies_thenSynchronization() {
- RIC_1.setState(RicState.IDLE);
+ RIC_1.setState(RicState.AVAILABLE);
rics.put(RIC_1);
policies.put(POLICY_1);
@Test
public void whenRicIdleAndSameAmountOfPoliciesButNotSamePolicies_thenSynchronization() {
- RIC_1.setState(RicState.IDLE);
+ RIC_1.setState(RicState.AVAILABLE);
rics.put(RIC_1);
policies.put(POLICY_1);
@Test
public void whenRicIdleAndErrorGettingPolicyTypes_thenNoSynchronization() {
- RIC_1.setState(RicState.IDLE);
+ RIC_1.setState(RicState.AVAILABLE);
RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
rics.put(RIC_1);
@Test
public void whenRicIdleAndNotSameAmountOfPolicyTypes_thenSynchronization() {
- RIC_1.setState(RicState.IDLE);
+ RIC_1.setState(RicState.AVAILABLE);
RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
rics.put(RIC_1);
.schema("") //
.build();
- RIC_1.setState(RicState.IDLE);
+ RIC_1.setState(RicState.AVAILABLE);
RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
RIC_1.addSupportedPolicyType(policyType2);
rics.put(RIC_1);
policyTypes = new PolicyTypes();
policies = new Policies();
services = new Services();
- RIC_1.setState(RicState.UNDEFINED);
+ RIC_1.setState(RicState.UNAVAILABLE);
RIC_1.clearSupportedPolicyTypes();
}
@Test
public void ricIdlePolicyTypeInRepo_thenSynchronizationWithReuseOfTypeFromRepoAndCorrectServiceNotified() {
- RIC_1.setState(RicState.IDLE);
+ RIC_1.setState(RicState.AVAILABLE);
policyTypes.put(POLICY_TYPE_1);
assertThat(policyTypes.size()).isEqualTo(1);
assertThat(policies.size()).isEqualTo(0);
- assertThat(RIC_1.getState()).isEqualTo(RicState.IDLE);
+ assertThat(RIC_1.getState()).isEqualTo(RicState.AVAILABLE);
}
@Test
public void ricIdlePolicyTypeNotInRepo_thenSynchronizationWithTypeFromRic() throws Exception {
- RIC_1.setState(RicState.IDLE);
+ RIC_1.setState(RicState.AVAILABLE);
setUpCreationOfA1Client();
simulateRicWithOnePolicyType();
assertThat(policyTypes.size()).isEqualTo(1);
assertThat(policyTypes.getType(POLICY_TYPE_1_NAME).schema()).isEqualTo(typeSchema);
assertThat(policies.size()).isEqualTo(0);
- assertThat(RIC_1.getState()).isEqualTo(RicState.IDLE);
+ assertThat(RIC_1.getState()).isEqualTo(RicState.AVAILABLE);
}
@Test
public void ricIdleAndHavePolicies_thenSynchronizationWithRecreationOfPolicies() {
- RIC_1.setState(RicState.IDLE);
+ RIC_1.setState(RicState.AVAILABLE);
policies.put(POLICY_1);
assertThat(policyTypes.size()).isEqualTo(0);
assertThat(policies.size()).isEqualTo(1);
- assertThat(RIC_1.getState()).isEqualTo(RicState.IDLE);
+ assertThat(RIC_1.getState()).isEqualTo(RicState.AVAILABLE);
}
@Test
public void ricIdleAndErrorDeletingPoliciesFirstTime_thenSynchronizationWithDeletionOfPolicies() {
- RIC_1.setState(RicState.IDLE);
+ RIC_1.setState(RicState.AVAILABLE);
policies.put(POLICY_1);
assertThat(policyTypes.size()).isEqualTo(0);
assertThat(policies.size()).isEqualTo(0);
- assertThat(RIC_1.getState()).isEqualTo(RicState.IDLE);
+ assertThat(RIC_1.getState()).isEqualTo(RicState.AVAILABLE);
}
@Test
public void ricIdleAndErrorDeletingPoliciesAllTheTime_thenSynchronizationWithFailedRecovery() {
- RIC_1.setState(RicState.IDLE);
+ RIC_1.setState(RicState.AVAILABLE);
policies.put(POLICY_1);
assertThat(policyTypes.size()).isEqualTo(0);
assertThat(policies.size()).isEqualTo(0);
- assertThat(RIC_1.getState()).isEqualTo(RicState.UNDEFINED);
+ assertThat(RIC_1.getState()).isEqualTo(RicState.UNAVAILABLE);
}
@Test
public void ricIdlePolicyTypeInRepo_thenSynchronizationWithErrorOnServiceNotificationErrorLogged() {
- RIC_1.setState(RicState.IDLE);
+ RIC_1.setState(RicState.AVAILABLE);
policyTypes.put(POLICY_TYPE_1);