}
private Flux<Object> startSynchronization(Ric ric, A1Client a1Client) {
- Flux<PolicyType> recoverTypes = synchronizePolicyTypes(ric, a1Client);
+ Flux<PolicyType> synchronizedTypes = synchronizePolicyTypes(ric, a1Client);
Flux<?> policiesDeletedInRic = a1Client.deleteAllPolicies();
Flux<?> policiesRecreatedInRic = recreateAllPoliciesInRic(ric, a1Client);
- return Flux.concat(recoverTypes, policiesDeletedInRic, policiesRecreatedInRic);
+ return Flux.concat(synchronizedTypes, policiesDeletedInRic, policiesRecreatedInRic);
}
private void onSynchronizationComplete(Ric ric) {
// If synchronization fails, try to remove all instances
deleteAllPoliciesInRepository(ric);
- Flux<PolicyType> recoverTypes = this.a1ClientFactory.createA1Client(ric) //
+ Flux<PolicyType> synchronizedTypes = this.a1ClientFactory.createA1Client(ric) //
.flatMapMany(a1Client -> synchronizePolicyTypes(ric, a1Client));
Flux<?> deletePoliciesInRic = this.a1ClientFactory.createA1Client(ric) //
.flatMapMany(A1Client::deleteAllPolicies) //
.doOnComplete(() -> deleteAllPoliciesInRepository(ric));
- Flux.concat(recoverTypes, deletePoliciesInRic) //
- .subscribe(x -> logger.debug("Brute recover: {}", x), //
- throwable -> onRecoveryError(ric, throwable), //
+ Flux.concat(synchronizedTypes, deletePoliciesInRic) //
+ .subscribe(x -> logger.debug("Brute recovery of failed synchronization: {}", x), //
+ throwable -> onSynchronizationRecoveryError(ric, throwable), //
() -> onSynchronizationComplete(ric));
}
- private void onRecoveryError(Ric ric, Throwable t) {
+ private void onSynchronizationRecoveryError(Ric ric, Throwable t) {
logger.warn("Synchronization failure recovery failed for ric: {}, reason: {}", ric.name(), t.getMessage());
ric.setState(RicState.UNDEFINED);
}
private A1ClientFactory a1ClientFactory;
@Mock
- private RicSynchronizationTask recoveryTaskMock;
+ private RicSynchronizationTask synchronizationTaskMock;
private final PolicyTypes types = new PolicyTypes();
private Policies policies = new Policies();
}
@Test
- public void whenRicIdleAndNoChangedPoliciesOrPolicyTypes_thenNoRecovery() {
+ public void whenRicIdleAndNoChangedPoliciesOrPolicyTypes_thenNoSynchronization() {
RIC_1.setState(RicState.IDLE);
RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
rics.put(RIC_1);
}
@Test
- public void whenRicUndefined_thenRecovery() {
+ public void whenRicUndefined_thenSynchronization() {
RIC_1.setState(RicState.UNDEFINED);
rics.put(RIC_1);
RicSupervision supervisorUnderTest = spy(new RicSupervision(rics, policies, a1ClientFactory, types, null));
- doReturn(recoveryTaskMock).when(supervisorUnderTest).createSynchronizationTask();
+ doReturn(synchronizationTaskMock).when(supervisorUnderTest).createSynchronizationTask();
supervisorUnderTest.checkAllRics();
verify(supervisorUnderTest).checkAllRics();
verify(supervisorUnderTest).createSynchronizationTask();
- verify(recoveryTaskMock).run(RIC_1);
+ verify(synchronizationTaskMock).run(RIC_1);
verifyNoMoreInteractions(supervisorUnderTest);
}
@Test
- public void whenRicRecovering_thenNoRecovery() {
+ public void whenRicSynchronizing_thenNoSynchronization() {
RIC_1.setState(RicState.SYNCHRONIZING);
rics.put(RIC_1);
}
@Test
- public void whenRicIdleAndErrorGettingPolicyIdentities_thenNoRecovery() {
+ public void whenRicIdleAndErrorGettingPolicyIdentities_thenNoSynchronization() {
RIC_1.setState(RicState.IDLE);
RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
rics.put(RIC_1);
}
@Test
- public void whenRicIdleAndNotSameAmountOfPolicies_thenRecovery() {
+ public void whenRicIdleAndNotSameAmountOfPolicies_thenSynchronization() {
RIC_1.setState(RicState.IDLE);
rics.put(RIC_1);
RicSupervision supervisorUnderTest = spy(new RicSupervision(rics, policies, a1ClientFactory, types, null));
- doReturn(recoveryTaskMock).when(supervisorUnderTest).createSynchronizationTask();
+ doReturn(synchronizationTaskMock).when(supervisorUnderTest).createSynchronizationTask();
supervisorUnderTest.checkAllRics();
verify(supervisorUnderTest).checkAllRics();
verify(supervisorUnderTest).createSynchronizationTask();
- verify(recoveryTaskMock).run(RIC_1);
+ verify(synchronizationTaskMock).run(RIC_1);
verifyNoMoreInteractions(supervisorUnderTest);
}
@Test
- public void whenRicIdleAndSameAmountOfPoliciesButNotSamePolicies_thenRecovery() {
+ public void whenRicIdleAndSameAmountOfPoliciesButNotSamePolicies_thenSynchronization() {
RIC_1.setState(RicState.IDLE);
rics.put(RIC_1);
RicSupervision supervisorUnderTest = spy(new RicSupervision(rics, policies, a1ClientFactory, types, null));
- doReturn(recoveryTaskMock).when(supervisorUnderTest).createSynchronizationTask();
+ doReturn(synchronizationTaskMock).when(supervisorUnderTest).createSynchronizationTask();
supervisorUnderTest.checkAllRics();
verify(supervisorUnderTest).checkAllRics();
verify(supervisorUnderTest).createSynchronizationTask();
- verify(recoveryTaskMock).run(RIC_1);
+ verify(synchronizationTaskMock).run(RIC_1);
verifyNoMoreInteractions(supervisorUnderTest);
}
@Test
- public void whenRicIdleAndErrorGettingPolicyTypes_thenNoRecovery() {
+ public void whenRicIdleAndErrorGettingPolicyTypes_thenNoSynchronization() {
RIC_1.setState(RicState.IDLE);
RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
rics.put(RIC_1);
}
@Test
- public void whenRicIdleAndNotSameAmountOfPolicyTypes_thenRecovery() {
+ public void whenRicIdleAndNotSameAmountOfPolicyTypes_thenSynchronization() {
RIC_1.setState(RicState.IDLE);
RIC_1.addSupportedPolicyType(POLICY_TYPE_1);
rics.put(RIC_1);
RicSupervision supervisorUnderTest = spy(new RicSupervision(rics, policies, a1ClientFactory, types, null));
- doReturn(recoveryTaskMock).when(supervisorUnderTest).createSynchronizationTask();
+ doReturn(synchronizationTaskMock).when(supervisorUnderTest).createSynchronizationTask();
supervisorUnderTest.checkAllRics();
verify(supervisorUnderTest).checkAllRics();
verify(supervisorUnderTest).createSynchronizationTask();
- verify(recoveryTaskMock).run(RIC_1);
+ verify(synchronizationTaskMock).run(RIC_1);
verifyNoMoreInteractions(supervisorUnderTest);
}
@Test
- public void whenRicIdleAndSameAmountOfPolicyTypesButNotSameTypes_thenRecovery() {
+ public void whenRicIdleAndSameAmountOfPolicyTypesButNotSameTypes_thenSynchronization() {
PolicyType policyType2 = ImmutablePolicyType.builder() //
.name("policyType2") //
.schema("") //
RicSupervision supervisorUnderTest = spy(new RicSupervision(rics, policies, a1ClientFactory, types, null));
- doReturn(recoveryTaskMock).when(supervisorUnderTest).createSynchronizationTask();
+ doReturn(synchronizationTaskMock).when(supervisorUnderTest).createSynchronizationTask();
supervisorUnderTest.checkAllRics();
verify(supervisorUnderTest).checkAllRics();
verify(supervisorUnderTest).createSynchronizationTask();
- verify(recoveryTaskMock).run(RIC_1);
+ verify(synchronizationTaskMock).run(RIC_1);
verifyNoMoreInteractions(supervisorUnderTest);
}