import static org.oransc.policyagent.repository.Ric.RicState;
-import java.util.Collection;
import java.util.Vector;
import org.oransc.policyagent.clients.A1Client;
import org.oransc.policyagent.clients.A1ClientFactory;
import org.oransc.policyagent.clients.AsyncRestClient;
import org.oransc.policyagent.repository.ImmutablePolicyType;
+import org.oransc.policyagent.repository.Lock;
+import org.oransc.policyagent.repository.Lock.LockType;
import org.oransc.policyagent.repository.Policies;
import org.oransc.policyagent.repository.Policy;
import org.oransc.policyagent.repository.PolicyType;
import reactor.core.publisher.Mono;
/**
- * Synchronizes the content of a RIC with the content in the repository.
- * This means:
- * - load all policy types
- * - send all policy instances to the RIC
- * --- if that fails remove all policy instances
- * - Notify subscribing services
+ * Synchronizes the content of a RIC with the content in the repository. This
+ * means:
+ * <p>
+ * load all policy types
+ * <p>
+ * send all policy instances to the RIC
+ * <p>
+ * if that fails remove all policy instances
+ * <p>
+ * Notify subscribing services
*/
+@SuppressWarnings("squid:S2629") // Invoke method(s) only conditionally
public class RicSynchronizationTask {
private static final Logger logger = LoggerFactory.getLogger(RicSynchronizationTask.class);
this.services = services;
}
- @SuppressWarnings("squid:S2629")
+ @SuppressWarnings("squid:S2445") // Blocks should be synchronized on "private final" fields
public void run(Ric ric) {
logger.debug("Handling ric: {}", ric.getConfig().name());
}
ric.setState(RicState.SYNCHRONIZING);
}
- this.a1ClientFactory.createA1Client(ric)//
+
+ ric.getLock().lock(LockType.EXCLUSIVE) // Make sure no NBI updates are running
+ .flatMap(Lock::unlock) //
+ .flatMap(lock -> this.a1ClientFactory.createA1Client(ric)) //
.flatMapMany(client -> startSynchronization(ric, client)) //
.subscribe(x -> logger.debug("Synchronize: {}", x), //
throwable -> onSynchronizationError(ric, throwable), //
private Flux<Object> startSynchronization(Ric ric, A1Client a1Client) {
Flux<PolicyType> recoverTypes = synchronizePolicyTypes(ric, a1Client);
- Collection<Policy> policiesForRic = policies.getForRic(ric.name());
- Flux<?> policiesDeletedInRic = Flux.empty();
- Flux<?> policiesRecreatedInRic = Flux.empty();
- if (!policiesForRic.isEmpty()) {
- policiesDeletedInRic = a1Client.deleteAllPolicies();
- policiesRecreatedInRic = recreateAllPoliciesInRic(ric, a1Client);
- }
+ Flux<?> policiesDeletedInRic = a1Client.deleteAllPolicies();
+ Flux<?> policiesRecreatedInRic = recreateAllPoliciesInRic(ric, a1Client);
+
return Flux.concat(recoverTypes, policiesDeletedInRic, policiesRecreatedInRic);
}
- @SuppressWarnings("squid:S2629")
private void onSynchronizationComplete(Ric ric) {
- logger.debug("Synchronization completed for: {}", ric.name());
+ logger.info("Synchronization completed for: {}", ric.name());
ric.setState(RicState.IDLE);
notifyAllServices("Synchronization completed for:" + ric.name());
}
}
}
- @SuppressWarnings("squid:S2629")
private void onSynchronizationError(Ric ric, Throwable t) {
logger.warn("Synchronization failed for ric: {}, reason: {}", ric.name(), t.getMessage());
+ // If synchronization fails, try to remove all instances
deleteAllPoliciesInRepository(ric);
- Flux<PolicyType> typesRecoveredForRic = this.a1ClientFactory.createA1Client(ric) //
+ Flux<PolicyType> recoverTypes = this.a1ClientFactory.createA1Client(ric) //
.flatMapMany(a1Client -> synchronizePolicyTypes(ric, a1Client));
+ Flux<?> deletePoliciesInRic = this.a1ClientFactory.createA1Client(ric) //
+ .flatMapMany(A1Client::deleteAllPolicies) //
+ .doOnComplete(() -> deleteAllPoliciesInRepository(ric));
- // If recovery fails, try to remove all instances
- Flux<?> policiesDeletedInRic = this.a1ClientFactory.createA1Client(ric) //
- .flatMapMany(A1Client::deleteAllPolicies);
-
- Flux.merge(typesRecoveredForRic, policiesDeletedInRic) //
+ Flux.concat(recoverTypes, deletePoliciesInRic) //
.subscribe(x -> logger.debug("Brute recover: {}", x), //
throwable -> onRecoveryError(ric, throwable), //
() -> onSynchronizationComplete(ric));
}
- @SuppressWarnings("squid:S2629")
private void onRecoveryError(Ric ric, Throwable t) {
logger.warn("Synchronization failure recovery failed for ric: {}, reason: {}", ric.name(), t.getMessage());
ric.setState(RicState.UNDEFINED);
}
private Flux<PolicyType> synchronizePolicyTypes(Ric ric, A1Client a1Client) {
- ric.clearSupportedPolicyTypes();
return a1Client.getPolicyTypeIdentities() //
+ .doOnNext(x -> ric.clearSupportedPolicyTypes()) //
.flatMapMany(Flux::fromIterable) //
.doOnNext(typeId -> logger.debug("For ric: {}, handling type: {}", ric.getConfig().name(), typeId)) //
.flatMap(policyTypeId -> getPolicyType(policyTypeId, a1Client)) //