acRuntimeParameterGroup.getAcmParameters().getToscaCompositionName());
executor.execute(
- () -> participantPrimePublisher.sendPriming(preparation, acmDefinition.getCompositionId(), null));
+ () -> participantPrimePublisher.sendPriming(
+ preparation, acmDefinition.getCompositionId(), acmDefinition.getRevisionId()));
}
private void deprime(AutomationCompositionDefinition acmDefinition) {
acDefinitionProvider.updateAcDefinition(acmDefinition,
acRuntimeParameterGroup.getAcmParameters().getToscaCompositionName());
- executor.execute(() -> participantPrimePublisher.sendDepriming(acmDefinition.getCompositionId()));
+ executor.execute(() -> participantPrimePublisher.sendDepriming(
+ acmDefinition.getCompositionId(), participantIds, acmDefinition.getRevisionId()));
}
-
}
import org.onap.policy.clamp.acm.runtime.main.parameters.AcRuntimeParameterGroup;
import org.onap.policy.clamp.acm.runtime.main.utils.EncryptionUtils;
import org.onap.policy.clamp.acm.runtime.supervision.SupervisionAcHandler;
-import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElement;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositions;
import org.onap.policy.clamp.models.acm.concepts.DeployState;
import org.onap.policy.clamp.models.acm.concepts.LockState;
-import org.onap.policy.clamp.models.acm.concepts.NodeTemplateState;
import org.onap.policy.clamp.models.acm.concepts.ParticipantUtils;
import org.onap.policy.clamp.models.acm.concepts.StateChangeResult;
import org.onap.policy.clamp.models.acm.concepts.SubState;
import org.onap.policy.clamp.models.acm.persistence.provider.ParticipantProvider;
import org.onap.policy.clamp.models.acm.utils.AcmUtils;
import org.onap.policy.common.parameters.BeanValidationResult;
-import org.onap.policy.common.parameters.ObjectValidationResult;
-import org.onap.policy.common.parameters.ValidationStatus;
import org.onap.policy.models.base.PfModelRuntimeException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
AutomationCompositionProvider.validateInstanceEndpoint(compositionId, automationComposition);
automationCompositionProvider.validateNameVersion(automationComposition.getKey().asIdentifier());
- var validationResult = validateAutomationComposition(automationComposition);
+ var acDefinition = acDefinitionProvider.getAcDefinition(compositionId);
+ AcDefinitionProvider.checkPrimedComposition(acDefinition);
+ var validationResult = validateAutomationComposition(automationComposition, acDefinition);
if (!validationResult.isValid()) {
throw new PfModelRuntimeException(Status.BAD_REQUEST, validationResult.getResult());
}
var instanceId = automationComposition.getInstanceId();
var acToUpdate = automationCompositionProvider.getAutomationComposition(instanceId);
AutomationCompositionProvider.validateInstanceEndpoint(compositionId, acToUpdate);
+ var acDefinition = acDefinitionProvider.getAcDefinition(compositionId);
+ AcDefinitionProvider.checkPrimedComposition(acDefinition);
if (DeployState.UNDEPLOYED.equals(acToUpdate.getDeployState())) {
acToUpdate.setElements(automationComposition.getElements());
acToUpdate.setName(automationComposition.getName());
acToUpdate.setVersion(automationComposition.getVersion());
acToUpdate.setDescription(automationComposition.getDescription());
acToUpdate.setDerivedFrom(automationComposition.getDerivedFrom());
- var validationResult = validateAutomationComposition(acToUpdate);
+ var validationResult = validateAutomationComposition(acToUpdate, acDefinition);
if (!validationResult.isValid()) {
throw new PfModelRuntimeException(Status.BAD_REQUEST, validationResult.getResult());
}
acToUpdate.getDeployState(), acToUpdate.getLockState(), acToUpdate.getSubState(),
acToUpdate.getStateChangeResult());
return switch (result) {
- case "UPDATE" -> updateDeployedAutomationComposition(automationComposition, acToUpdate);
+ case "UPDATE" -> updateDeployedAutomationComposition(automationComposition, acToUpdate, acDefinition);
- case "MIGRATE" -> migrateAutomationComposition(automationComposition, acToUpdate);
+ case "MIGRATE" -> migrateAutomationComposition(automationComposition, acToUpdate, acDefinition);
- case "MIGRATE_PRECHECK" -> migratePrecheckAc(automationComposition, acToUpdate);
+ case "MIGRATE_PRECHECK" -> migratePrecheckAc(automationComposition, acToUpdate, acDefinition);
default -> throw new PfModelRuntimeException(Status.BAD_REQUEST,
"Not allowed to " + deployOrder + " in the state " + acToUpdate.getDeployState());
* @return the result of the update
*/
private InstantiationResponse updateDeployedAutomationComposition(
- AutomationComposition automationComposition, AutomationComposition acToBeUpdated) {
+ AutomationComposition automationComposition, AutomationComposition acToBeUpdated,
+ AutomationCompositionDefinition acDefinition) {
// save copy in case of a rollback
automationCompositionProvider.copyAcElementsBeforeUpdate(acToBeUpdated);
AcmUtils.recursiveMerge(dbAcElement.getProperties(), element.getValue().getProperties());
}
- var validationResult = validateAutomationComposition(acToBeUpdated);
+ var validationResult = validateAutomationComposition(acToBeUpdated, acDefinition);
if (!validationResult.isValid()) {
throw new PfModelRuntimeException(Status.BAD_REQUEST, validationResult.getResult());
}
updateAcForProperties(acToBeUpdated);
var acToPublish = new AutomationComposition(acToBeUpdated);
-
encryptInstanceProperties(acToBeUpdated, acToBeUpdated.getCompositionId());
automationComposition = automationCompositionProvider.updateAutomationComposition(acToBeUpdated);
// Publish property update event to the participants
- supervisionAcHandler.update(acToPublish);
+ supervisionAcHandler.update(acToPublish, acDefinition.getRevisionId());
return createInstantiationResponse(automationComposition);
}
private InstantiationResponse migrateAutomationComposition(
- AutomationComposition automationComposition, AutomationComposition acToBeUpdated) {
+ AutomationComposition automationComposition, AutomationComposition acToBeUpdated,
+ AutomationCompositionDefinition acDefinition) {
if (!DeployState.DEPLOYED.equals(acToBeUpdated.getDeployState())) {
throw new PfModelRuntimeException(Status.BAD_REQUEST,
// make copy for rollback
automationCompositionProvider.copyAcElementsBeforeUpdate(acToBeUpdated);
+ var acDefinitionTarget = acDefinitionProvider.getAcDefinition(automationComposition.getCompositionTargetId());
+ AcDefinitionProvider.checkPrimedComposition(acDefinitionTarget);
// Iterate and update the element property values
- var elementsRemoved = updateElementsProperties(automationComposition, acToBeUpdated);
- var acDefinition = acDefinitionProvider.getAcDefinition(automationComposition.getCompositionTargetId());
+ var elementsRemoved = updateElementsProperties(automationComposition, acToBeUpdated, acDefinitionTarget);
- updateAcForMigration(acToBeUpdated, acDefinition, DeployState.MIGRATING);
+ updateAcForMigration(acToBeUpdated, acDefinitionTarget, DeployState.MIGRATING);
var acToPublish = new AutomationComposition(acToBeUpdated);
-
encryptInstanceProperties(acToBeUpdated, acToBeUpdated.getCompositionTargetId());
var ac = automationCompositionProvider.updateAutomationComposition(acToBeUpdated);
elementsRemoved.forEach(automationCompositionProvider::deleteAutomationCompositionElement);
// Publish migrate event to the participants
- supervisionAcHandler.migrate(acToPublish);
+ supervisionAcHandler.migrate(acToPublish, acDefinition.getRevisionId(), acDefinitionTarget.getRevisionId());
return createInstantiationResponse(ac);
}
.filter(id -> acFromMigration.getElements().get(id) == null).toList();
}
+
private InstantiationResponse migratePrecheckAc(
- AutomationComposition automationComposition, AutomationComposition acToBeUpdated) {
+ AutomationComposition automationComposition, AutomationComposition acToBeUpdated,
+ AutomationCompositionDefinition acDefinition) {
acToBeUpdated.setPrecheck(true);
var copyAc = new AutomationComposition(acToBeUpdated);
+ var acDefinitionTarget = acDefinitionProvider.getAcDefinition(automationComposition.getCompositionTargetId());
+ AcDefinitionProvider.checkPrimedComposition(acDefinitionTarget);
// Iterate and update the element property values
- updateElementsProperties(automationComposition, copyAc);
+ updateElementsProperties(automationComposition, copyAc, acDefinitionTarget);
// Publish migrate event to the participants
- supervisionAcHandler.migratePrecheck(copyAc);
+ supervisionAcHandler.migratePrecheck(copyAc, acDefinition.getRevisionId(), acDefinitionTarget.getRevisionId());
AcmUtils.setCascadedState(acToBeUpdated, DeployState.DEPLOYED, LockState.LOCKED,
SubState.MIGRATION_PRECHECKING);
return createInstantiationResponse(automationCompositionProvider.updateAutomationComposition(acToBeUpdated));
}
- private BeanValidationResult validateAutomationComposition(AutomationComposition automationComposition) {
- return validateAutomationComposition(automationComposition, automationComposition.getCompositionId());
- }
-
/**
* Validate AutomationComposition.
*
* @param automationComposition AutomationComposition to validate
- * @param compositionId the composition id
+ * @param acDefinition the Composition Definition
* @return the result of validation
*/
private BeanValidationResult validateAutomationComposition(AutomationComposition automationComposition,
- UUID compositionId) {
-
+ AutomationCompositionDefinition acDefinition) {
var result = new BeanValidationResult("AutomationComposition", automationComposition);
- var acDefinitionOpt = acDefinitionProvider.findAcDefinition(compositionId);
- if (acDefinitionOpt.isEmpty()) {
- result.addResult(new ObjectValidationResult("ServiceTemplate", compositionId, ValidationStatus.INVALID,
- "Commissioned automation composition definition not found"));
- return result;
- }
- if (!AcTypeState.PRIMED.equals(acDefinitionOpt.get().getState())) {
- result.addResult(new ObjectValidationResult("ServiceTemplate.state", acDefinitionOpt.get().getState(),
- ValidationStatus.INVALID, "Commissioned automation composition definition not primed"));
- return result;
- }
- var participantIds = acDefinitionOpt.get().getElementStateMap().values().stream()
- .map(NodeTemplateState::getParticipantId).collect(Collectors.toSet());
-
- participantProvider.verifyParticipantState(participantIds);
-
+ participantProvider.checkRegisteredParticipant(acDefinition);
result.addResult(AcmUtils.validateAutomationComposition(automationComposition,
- acDefinitionOpt.get().getServiceTemplate(),
+ acDefinition.getServiceTemplate(),
acRuntimeParameterGroup.getAcmParameters().getToscaCompositionName()));
result.addResult(automationCompositionProvider.validateElementIds(automationComposition));
if (result.isValid()) {
for (var element : automationComposition.getElements().values()) {
var name = element.getDefinition().getName();
- var participantId = acDefinitionOpt.get().getElementStateMap().get(name).getParticipantId();
+ var participantId = acDefinition.getElementStateMap().get(name).getParticipantId();
element.setParticipantId(participantId);
}
}
break;
case "REVIEW":
- supervisionAcHandler.review(automationComposition);
+ supervisionAcHandler.review(automationComposition, acDefinition);
break;
default:
acToBeUpdated.setElements(automationCompositionToRollback.getElements().values().stream()
.collect(Collectors.toMap(AutomationCompositionElement::getId, AutomationCompositionElement::new)));
- var acDefinition = acDefinitionProvider.getAcDefinition(acToBeUpdated.getCompositionTargetId());
- var validationResult =
- validateAutomationComposition(acToBeUpdated, acToBeUpdated.getCompositionTargetId());
+ var acDefinitionTarget = acDefinitionProvider.getAcDefinition(acToBeUpdated.getCompositionTargetId());
+ var validationResult = validateAutomationComposition(acToBeUpdated, acDefinitionTarget);
if (!validationResult.isValid()) {
throw new PfModelRuntimeException(Status.BAD_REQUEST, validationResult.getResult());
}
- updateAcForMigration(acToBeUpdated, acDefinition, DeployState.MIGRATION_REVERTING);
+ updateAcForMigration(acToBeUpdated, acDefinitionTarget, DeployState.MIGRATION_REVERTING);
var elementsRemoved = getElementRemoved(automationComposition, acToBeUpdated);
automationCompositionProvider.updateAutomationComposition(acToBeUpdated);
elementsRemoved.forEach(automationCompositionProvider::deleteAutomationCompositionElement);
- supervisionAcHandler.migrate(acToBeUpdated);
+ var acDefinition = acDefinitionProvider.getAcDefinition(acToBeUpdated.getCompositionId());
+ supervisionAcHandler.migrate(acToBeUpdated, acDefinition.getRevisionId(), acDefinitionTarget.getRevisionId());
}
private List<UUID> updateElementsProperties(AutomationComposition automationComposition,
- AutomationComposition acToBeUpdated) {
+ AutomationComposition acToBeUpdated, AutomationCompositionDefinition acDefinitionTarget) {
for (var element : automationComposition.getElements().entrySet()) {
var elementId = element.getKey();
var dbAcElement = acToBeUpdated.getElements().get(elementId);
AcmUtils.recursiveMerge(dbAcElement.getProperties(), element.getValue().getProperties());
var newDefinition = element.getValue().getDefinition().asConceptKey();
var dbElementDefinition = dbAcElement.getDefinition().asConceptKey();
- AutomationCompositionProvider
- .checkCompatibility(newDefinition, dbElementDefinition, automationComposition.getInstanceId());
+ AutomationCompositionProvider.checkCompatibility(
+ newDefinition, dbElementDefinition, automationComposition.getInstanceId());
dbAcElement.setDefinition(element.getValue().getDefinition());
}
}
var elementsRemoved = getElementRemoved(acToBeUpdated, automationComposition);
elementsRemoved.forEach(uuid -> acToBeUpdated.getElements().remove(uuid));
- var validationResult =
- validateAutomationComposition(acToBeUpdated, automationComposition.getCompositionTargetId());
+ var validationResult = validateAutomationComposition(acToBeUpdated, acDefinitionTarget);
if (!validationResult.isValid()) {
throw new PfModelRuntimeException(Status.BAD_REQUEST, validationResult.getResult());
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2025 Nordix Foundation.
+ * Copyright (C) 2025 OpenInfra Foundation Europe. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
}
}
-
- /**
- * Find and decrypt sensitive fields in an AC instance.
- * @param automationComposition acInstance
- */
- public void findAndDecryptSensitiveData(AutomationComposition automationComposition) {
+ private void findAndDecryptSensitiveData(AutomationComposition automationComposition) {
for (var acInstanceElement: automationComposition.getElements().values()) {
for (var property : acInstanceElement.getProperties().entrySet()) {
var propertyVal = property.getValue();
}
}
+
+ /**
+ * Find and decrypt sensitive fields in an AC instance.
+ *
+ * @param automationComposition acInstance
+ */
+ public void decryptInstanceProperties(AutomationComposition automationComposition) {
+ if (encryptionEnabled()) {
+ findAndDecryptSensitiveData(automationComposition);
+ }
+ }
+
+ /**
+ * Find and decrypt sensitive fields in an AC instance list.
+ *
+ * @param automationCompositionList acInstance list
+ */
+ public void decryptInstanceProperties(List<AutomationComposition> automationCompositionList) {
+ if (encryptionEnabled()) {
+ automationCompositionList.forEach(this::findAndDecryptSensitiveData);
+ }
+ }
}
import io.opentelemetry.context.Context;
import java.util.HashMap;
import java.util.Map;
+import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import lombok.AllArgsConstructor;
executor.execute(
() -> {
var acToSend = new AutomationComposition(automationComposition);
- decryptInstanceProperties(acToSend);
- automationCompositionDeployPublisher.send(acToSend, startPhase, true);
+ encryptionUtils.decryptInstanceProperties(acToSend);
+ automationCompositionDeployPublisher.send(acToSend, startPhase, true, acDefinition.getRevisionId());
});
}
automationComposition.setPhase(startPhase);
automationCompositionProvider.updateAutomationComposition(automationComposition);
executor.execute(
- () -> automationCompositionStateChangePublisher.send(automationComposition, startPhase, true));
+ () -> automationCompositionStateChangePublisher.send(
+ automationComposition, startPhase, true, acDefinition.getRevisionId()));
}
/**
automationComposition.setPhase(startPhase);
automationCompositionProvider.updateAutomationComposition(automationComposition);
executor.execute(
- () -> automationCompositionStateChangePublisher.send(automationComposition, startPhase, true));
+ () -> automationCompositionStateChangePublisher.send(
+ automationComposition, startPhase, true, acDefinition.getRevisionId()));
}
/**
automationCompositionProvider.updateAutomationComposition(automationComposition);
executor.execute(() -> {
var acToSend = new AutomationComposition(automationComposition);
- decryptInstanceProperties(acToSend);
- acPreparePublisher.sendPrepare(acToSend, stage);
+ encryptionUtils.decryptInstanceProperties(acToSend);
+ acPreparePublisher.sendPrepare(acToSend, stage, acDefinition.getRevisionId());
});
}
* Handle prepare Post Deploy an AutomationComposition instance.
*
* @param automationComposition the AutomationComposition
+ * @param acDefinition the AutomationCompositionDefinition
*/
- public void review(AutomationComposition automationComposition) {
+ public void review(AutomationComposition automationComposition, AutomationCompositionDefinition acDefinition) {
AcmUtils.setCascadedState(automationComposition, DeployState.DEPLOYED, LockState.LOCKED, SubState.REVIEWING);
automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
automationCompositionProvider.updateAutomationComposition(automationComposition);
- executor.execute(() -> acPreparePublisher.sendRevew(automationComposition));
+ executor.execute(() -> acPreparePublisher.sendReview(automationComposition, acDefinition.getRevisionId()));
}
/**
automationComposition.setPhase(startPhase);
automationCompositionProvider.updateAutomationComposition(automationComposition);
executor.execute(
- () -> automationCompositionStateChangePublisher.send(automationComposition, startPhase, true));
+ () -> automationCompositionStateChangePublisher.send(
+ automationComposition, startPhase, true, acDefinition.getRevisionId()));
}
/**
* Handle Element property update on a deployed instance.
*
* @param automationComposition the AutomationComposition
+ * @param revisionIdComposition the last Update from Composition
*/
- public void update(AutomationComposition automationComposition) {
+ public void update(AutomationComposition automationComposition, UUID revisionIdComposition) {
executor.execute(
() -> {
- decryptInstanceProperties(automationComposition);
- acElementPropertiesPublisher.send(automationComposition);
+ encryptionUtils.decryptInstanceProperties(automationComposition);
+ acElementPropertiesPublisher.send(automationComposition, revisionIdComposition);
});
}
automationComposition.setPhase(startPhase);
automationCompositionProvider.updateAutomationComposition(automationComposition);
executor.execute(
- () -> automationCompositionStateChangePublisher.send(automationComposition, startPhase, true));
+ () -> automationCompositionStateChangePublisher.send(
+ automationComposition, startPhase, true, acDefinition.getRevisionId()));
}
/**
* Handle Migration of an AutomationComposition instance to other ACM Definition.
*
* @param automationComposition the AutomationComposition
+ * @param revisionIdComposition the last Update from Composition
+ * @param revisionIdCompositionTarget the last Update from Composition Target
*/
- public void migrate(AutomationComposition automationComposition) {
+ public void migrate(AutomationComposition automationComposition, UUID revisionIdComposition,
+ UUID revisionIdCompositionTarget) {
executor.execute(() -> {
- decryptInstanceProperties(automationComposition);
- acCompositionMigrationPublisher.send(automationComposition, automationComposition.getPhase());
+ encryptionUtils.decryptInstanceProperties(automationComposition);
+ acCompositionMigrationPublisher.send(automationComposition, automationComposition.getPhase(),
+ revisionIdComposition, revisionIdCompositionTarget);
});
}
* Handle Migration precheck of an AutomationComposition instance to other ACM Definition.
*
* @param automationComposition the AutomationComposition
+ * @param revisionIdComposition the last Update from Composition
+ * @param revisionIdCompositionTarget the last Update from Composition Target
*/
- public void migratePrecheck(AutomationComposition automationComposition) {
- executor.execute(() -> acCompositionMigrationPublisher.send(automationComposition, 0));
- }
-
- private void decryptInstanceProperties(AutomationComposition automationComposition) {
- if (encryptionUtils.encryptionEnabled()) {
- encryptionUtils.findAndDecryptSensitiveData(automationComposition);
- }
+ public void migratePrecheck(AutomationComposition automationComposition, UUID revisionIdComposition,
+ UUID revisionIdCompositionTarget) {
+ executor.execute(() -> acCompositionMigrationPublisher.send(automationComposition, 0,
+ revisionIdComposition, revisionIdCompositionTarget));
}
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2023-2025 Nordix Foundation.
+ * Copyright (C) 2023-2025 OpenInfra Foundation Europe. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import java.util.stream.Collectors;
import lombok.AllArgsConstructor;
import org.apache.commons.collections4.MapUtils;
+import org.onap.policy.clamp.acm.runtime.main.utils.EncryptionUtils;
import org.onap.policy.clamp.acm.runtime.supervision.comm.ParticipantDeregisterAckPublisher;
import org.onap.policy.clamp.acm.runtime.supervision.comm.ParticipantRegisterAckPublisher;
import org.onap.policy.clamp.acm.runtime.supervision.comm.ParticipantSyncPublisher;
import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
+import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElement;
+import org.onap.policy.clamp.models.acm.concepts.DeployState;
import org.onap.policy.clamp.models.acm.concepts.NodeTemplateState;
import org.onap.policy.clamp.models.acm.concepts.Participant;
import org.onap.policy.clamp.models.acm.concepts.ParticipantReplica;
import org.onap.policy.clamp.models.acm.concepts.ParticipantState;
import org.onap.policy.clamp.models.acm.concepts.ParticipantSupportedElementType;
+import org.onap.policy.clamp.models.acm.concepts.ParticipantUtils;
import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantDeregister;
import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantRegister;
+import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantReqSync;
import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantStatus;
import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
private final AcDefinitionProvider acDefinitionProvider;
private final ParticipantSyncPublisher participantSyncPublisher;
private final MessageProvider messageProvider;
+ private final EncryptionUtils encryptionUtils;
/**
* Handle a ParticipantRegister message from a participant.
*/
@Timed(value = "listener.participant_register", description = "PARTICIPANT_REGISTER messages received")
public void handleParticipantMessage(ParticipantRegister participantRegisterMsg) {
- saveIfNotPresent(participantRegisterMsg.getReplicaId(),
- participantRegisterMsg.getParticipantId(),
+ saveIfNotPresent(participantRegisterMsg.getReplicaId(), participantRegisterMsg.getParticipantId(),
participantRegisterMsg.getParticipantSupportedElementType(), true);
participantRegisterAckPublisher.send(participantRegisterMsg.getMessageId(),
&& participantStatusMsg.getCompositionId() != null) {
var acDefinition = acDefinitionProvider.findAcDefinition(participantStatusMsg.getCompositionId());
if (acDefinition.isPresent()) {
- var map = acDefinition.get().getElementStateMap()
- .values().stream().collect(Collectors.toMap(NodeTemplateState::getNodeTemplateId,
- UnaryOperator.identity()));
+ var map = acDefinition.get().getElementStateMap().values().stream()
+ .collect(Collectors.toMap(NodeTemplateState::getNodeTemplateId, UnaryOperator.identity()));
messageProvider.saveCompositionOutProperties(participantStatusMsg, map);
} else {
LOGGER.error("Not valid ParticipantStatus message");
LOGGER.debug("Composition to be send in Restart message {}", acDefinition.getCompositionId());
var automationCompositionList =
automationCompositionProvider.getAcInstancesByCompositionId(acDefinition.getCompositionId());
- var automationCompositions = automationCompositionList.stream()
- .filter(ac -> isAcToBeSyncRestarted(participantId, ac)).toList();
+ encryptionUtils.decryptInstanceProperties(automationCompositionList);
+ var automationCompositions =
+ automationCompositionList.stream().filter(ac -> isAcToBeSyncRestarted(participantId, ac)).toList();
participantSyncPublisher.sendRestartMsg(participantId, replicaId, acDefinition, automationCompositions);
}
MapUtils.populateMap(map, elementList, ParticipantSupportedElementType::getId);
return map;
}
+
+ /**
+ * Handle a participantReqSync message from a participant.
+ *
+ * @param participantReqSync the message received from a participant
+ */
+ @Timed(value = "listener.participant_req_sync", description = "PARTICIPANT_REQ_SYNC_MSG messages received")
+ public void handleParticipantReqSync(ParticipantReqSync participantReqSync) {
+ if (participantReqSync.getCompositionTargetId() != null) {
+ // outdated Composition Target
+ var acDefinition = acDefinitionProvider.getAcDefinition(participantReqSync.getCompositionTargetId());
+ participantSyncPublisher.sendRestartMsg(participantReqSync.getParticipantId(),
+ participantReqSync.getReplicaId(), acDefinition, List.of());
+ }
+ if (participantReqSync.getCompositionId() == null
+ && participantReqSync.getAutomationCompositionId() != null) {
+ // outdated AutomationComposition
+ var automationComposition =
+ getAutomationCompositionForSync(participantReqSync.getAutomationCompositionId());
+ participantSyncPublisher.sendSync(automationComposition);
+ }
+ if (participantReqSync.getCompositionId() != null) {
+ // outdated Composition
+ var acDefinition = acDefinitionProvider.getAcDefinition(participantReqSync.getCompositionId());
+ var automationCompositions = participantReqSync.getAutomationCompositionId() != null
+ ? List.of(getAutomationCompositionForSync(participantReqSync.getAutomationCompositionId())) :
+ List.<AutomationComposition>of();
+ participantSyncPublisher.sendRestartMsg(participantReqSync.getParticipantId(),
+ participantReqSync.getReplicaId(), acDefinition, automationCompositions);
+ }
+ }
+
+ private AutomationComposition getAutomationCompositionForSync(UUID automationCompositionId) {
+ var automationComposition = automationCompositionProvider.getAutomationComposition(automationCompositionId);
+ encryptionUtils.decryptInstanceProperties(automationComposition);
+ if (DeployState.MIGRATING.equals(automationComposition.getDeployState())) {
+ var acDefinition = acDefinitionProvider.getAcDefinition(automationComposition.getCompositionTargetId());
+ var stage = ParticipantUtils.getFirstStage(automationComposition, acDefinition.getServiceTemplate());
+ if (automationComposition.getPhase().equals(stage)) {
+ // scenario first stage migration
+ var rollback = automationCompositionProvider.getAutomationCompositionRollback(automationCompositionId);
+ automationComposition.setElements(rollback.getElements().values().stream()
+ .collect(Collectors.toMap(AutomationCompositionElement::getId, AutomationCompositionElement::new)));
+ }
+ }
+ return automationComposition;
+ }
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2023-2024 Nordix Foundation.
+ * Copyright (C) 2023-2025 OpenInfra Foundation Europe. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import io.micrometer.core.annotation.Timed;
import java.time.Instant;
import java.util.UUID;
+import java.util.stream.Collectors;
import lombok.AllArgsConstructor;
import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
+import org.onap.policy.clamp.models.acm.concepts.ParticipantDeploy;
import org.onap.policy.clamp.models.acm.messages.kafka.participant.PropertiesUpdate;
import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
import org.onap.policy.clamp.models.acm.utils.AcmUtils;
* Send ACElementPropertiesUpdate to Participant.
*
* @param automationComposition the AutomationComposition
+ * @param revisionIdComposition the last Update from Composition
*/
@Timed(value = "publisher.properties_update", description = "AC Element Properties Update published")
- public void send(AutomationComposition automationComposition) {
+ public void send(AutomationComposition automationComposition, UUID revisionIdComposition) {
var propertiesUpdate = new PropertiesUpdate();
propertiesUpdate.setCompositionId(automationComposition.getCompositionId());
propertiesUpdate.setAutomationCompositionId(automationComposition.getInstanceId());
propertiesUpdate.setMessageId(UUID.randomUUID());
propertiesUpdate.setTimestamp(Instant.now());
- propertiesUpdate.setParticipantUpdatesList(
- AcmUtils.createParticipantDeployList(automationComposition, DeployOrder.UPDATE));
-
+ propertiesUpdate.setRevisionIdInstance(automationComposition.getRevisionId());
+ propertiesUpdate.setRevisionIdComposition(revisionIdComposition);
+ var participantUpdatesList = AcmUtils.createParticipantDeployList(automationComposition, DeployOrder.UPDATE);
+ propertiesUpdate.setParticipantUpdatesList(participantUpdatesList);
+ propertiesUpdate.setParticipantIdList(participantUpdatesList.stream()
+ .map(ParticipantDeploy::getParticipantId).collect(Collectors.toSet()));
LOGGER.debug("AC Element properties update sent {}", propertiesUpdate.getMessageId());
super.send(propertiesUpdate);
}
import io.micrometer.core.annotation.Timed;
import java.time.Instant;
import java.util.UUID;
+import java.util.stream.Collectors;
import lombok.AllArgsConstructor;
import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
+import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElement;
+import org.onap.policy.clamp.models.acm.concepts.ParticipantDeploy;
import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionPrepare;
import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
import org.onap.policy.clamp.models.acm.utils.AcmUtils;
*
* @param automationComposition the AutomationComposition
* @param stage the stage
+ * @param revisionIdComposition the last Update from Composition
*/
@Timed(value = "publisher.prepare", description = "AC Prepare Pre Deploy published")
- public void sendPrepare(AutomationComposition automationComposition, int stage) {
+ public void sendPrepare(AutomationComposition automationComposition, int stage, UUID revisionIdComposition) {
var acPrepare = createAutomationCompositionPrepare(automationComposition.getCompositionId(),
automationComposition.getInstanceId());
acPrepare.setStage(stage);
- acPrepare.setParticipantList(
- AcmUtils.createParticipantDeployList(automationComposition, DeployOrder.NONE));
+ var participantUpdatesList = AcmUtils.createParticipantDeployList(automationComposition, DeployOrder.NONE);
+ acPrepare.setParticipantList(participantUpdatesList);
+ acPrepare.setParticipantIdList(participantUpdatesList.stream()
+ .map(ParticipantDeploy::getParticipantId).collect(Collectors.toSet()));
+ acPrepare.setRevisionIdInstance(automationComposition.getRevisionId());
+ acPrepare.setRevisionIdComposition(revisionIdComposition);
LOGGER.debug("AC Prepare sent {}", acPrepare);
super.send(acPrepare);
}
* Send AutomationCompositionPrepare Review message to Participant.
*
* @param automationComposition the AutomationComposition
+ * @param revisionIdComposition the last Update from Composition
*/
@Timed(value = "publisher.review", description = "AC Review Post Deploy published")
- public void sendRevew(AutomationComposition automationComposition) {
+ public void sendReview(AutomationComposition automationComposition, UUID revisionIdComposition) {
var acPrepare = createAutomationCompositionPrepare(automationComposition.getCompositionId(),
automationComposition.getInstanceId());
acPrepare.setPreDeploy(false);
+ acPrepare.setParticipantIdList(automationComposition.getElements().values().stream()
+ .map(AutomationCompositionElement::getParticipantId).collect(Collectors.toSet()));
+ acPrepare.setRevisionIdComposition(revisionIdComposition);
+ acPrepare.setRevisionIdInstance(automationComposition.getRevisionId());
LOGGER.debug("AC Review sent {}", acPrepare);
super.send(acPrepare);
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2021,2023-2024 Nordix Foundation.
+ * Copyright (C) 2021,2023-2025 OpenInfra Foundation Europe. All rights reserved.
* ================================================================================
* Modifications Copyright (C) 2021 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* @param automationComposition the AutomationComposition
* @param startPhase the Start Phase
* @param firstStartPhase true if the first StartPhase
+ * @param revisionIdComposition the last Update from Composition
*/
@Timed(value = "publisher.automation_composition_deploy",
description = "AUTOMATION_COMPOSITION_DEPLOY messages published")
- public void send(AutomationComposition automationComposition, int startPhase, boolean firstStartPhase) {
+ public void send(AutomationComposition automationComposition, int startPhase, boolean firstStartPhase,
+ UUID revisionIdComposition) {
Map<UUID, List<AcElementDeploy>> map = new HashMap<>();
for (var element : automationComposition.getElements().values()) {
var acElementDeploy = AcmUtils.createAcElementDeploy(element, DeployOrder.DEPLOY);
map.get(element.getParticipantId()).add(acElementDeploy);
}
List<ParticipantDeploy> participantDeploys = new ArrayList<>();
+ var acDeployMsg = new AutomationCompositionDeploy();
for (var entry : map.entrySet()) {
var participantDeploy = new ParticipantDeploy();
participantDeploy.setParticipantId(entry.getKey());
+ acDeployMsg.getParticipantIdList().add(entry.getKey());
participantDeploy.setAcElementList(entry.getValue());
participantDeploys.add(participantDeploy);
}
- var acDeployMsg = new AutomationCompositionDeploy();
acDeployMsg.setCompositionId(automationComposition.getCompositionId());
acDeployMsg.setStartPhase(startPhase);
acDeployMsg.setFirstStartPhase(firstStartPhase);
acDeployMsg.setAutomationCompositionId(automationComposition.getInstanceId());
acDeployMsg.setMessageId(UUID.randomUUID());
acDeployMsg.setTimestamp(Instant.now());
+ acDeployMsg.setRevisionIdInstance(automationComposition.getRevisionId());
+ acDeployMsg.setRevisionIdComposition(revisionIdComposition);
acDeployMsg.setParticipantUpdatesList(participantDeploys);
LOGGER.debug("AutomationCompositionDeploy message sent {}", acDeployMsg.getMessageId());
import io.micrometer.core.annotation.Timed;
import java.util.UUID;
+import java.util.stream.Collectors;
import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
import org.onap.policy.clamp.models.acm.concepts.DeployState;
+import org.onap.policy.clamp.models.acm.concepts.ParticipantDeploy;
import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionMigration;
import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
import org.onap.policy.clamp.models.acm.utils.AcmUtils;
*
* @param automationComposition the AutomationComposition
* @param stage the stage to execute
+ * @param revisionIdComposition the last Update from Composition
+ * @param revisionIdCompositionTarget the last Update from Composition Target
*/
@Timed(
value = "publisher.automation_composition_migration",
description = "AUTOMATION_COMPOSITION_MIGRATION messages published")
- public void send(AutomationComposition automationComposition, int stage) {
+ public void send(AutomationComposition automationComposition, int stage, UUID revisionIdComposition,
+ UUID revisionIdCompositionTarget) {
var acMigration = new AutomationCompositionMigration();
acMigration.setRollback(DeployState.MIGRATION_REVERTING.equals(automationComposition.getDeployState()));
acMigration.setPrecheck(Boolean.TRUE.equals(automationComposition.getPrecheck()));
acMigration.setMessageId(UUID.randomUUID());
acMigration.setCompositionTargetId(automationComposition.getCompositionTargetId());
acMigration.setStage(stage);
- acMigration.setParticipantUpdatesList(
- AcmUtils.createParticipantDeployList(automationComposition, DeployOrder.MIGRATE));
+ acMigration.setRevisionIdInstance(automationComposition.getRevisionId());
+ acMigration.setRevisionIdComposition(revisionIdComposition);
+ acMigration.setRevisionIdCompositionTarget(revisionIdCompositionTarget);
+ var participantUpdatesList = AcmUtils.createParticipantDeployList(automationComposition, DeployOrder.MIGRATE);
+ acMigration.setParticipantUpdatesList(participantUpdatesList);
+ acMigration.setParticipantIdList(participantUpdatesList.stream()
+ .map(ParticipantDeploy::getParticipantId).collect(Collectors.toSet()));
+
super.send(acMigration);
}
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2021-2024 Nordix Foundation.
+ * Copyright (C) 2021-2025 OpenInfra Foundation Europe. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import io.micrometer.core.annotation.Timed;
import java.util.UUID;
+import java.util.stream.Collectors;
import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
+import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElement;
import org.onap.policy.clamp.models.acm.messages.kafka.participant.AutomationCompositionStateChange;
import org.onap.policy.clamp.models.acm.utils.AcmUtils;
import org.springframework.stereotype.Component;
*
* @param automationComposition the AutomationComposition
* @param startPhase the startPhase
+ * @param revisionIdComposition the last Update from Composition
*/
@Timed(
value = "publisher.automation_composition_state_change",
description = "AUTOMATION_COMPOSITION_STATE_CHANGE messages published")
- public void send(AutomationComposition automationComposition, int startPhase, boolean firstStartPhase) {
+ public void send(AutomationComposition automationComposition, int startPhase, boolean firstStartPhase,
+ UUID revisionIdComposition) {
var acsc = new AutomationCompositionStateChange();
acsc.setCompositionId(automationComposition.getCompositionId());
acsc.setAutomationCompositionId(automationComposition.getInstanceId());
acsc.setLockOrderedState(AcmUtils.stateLockToOrder(automationComposition.getLockState()));
acsc.setStartPhase(startPhase);
acsc.setFirstStartPhase(firstStartPhase);
+ acsc.setRevisionIdInstance(automationComposition.getRevisionId());
+ acsc.setRevisionIdComposition(revisionIdComposition);
+ acsc.setParticipantIdList(automationComposition.getElements().values().stream()
+ .map(AutomationCompositionElement::getParticipantId).collect(Collectors.toSet()));
super.send(acsc);
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2021-2024 Nordix Foundation.
+ * Copyright (C) 2021-2025 OpenInfra Foundation Europe. All rights reserved.
* ================================================================================
* Modifications Copyright (C) 2021 AT&T Intellectual Property. All rights reserved.
* ================================================================================
import java.util.HashSet;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import java.util.UUID;
+import java.util.stream.Collectors;
import lombok.AllArgsConstructor;
import org.onap.policy.clamp.acm.runtime.main.parameters.AcRuntimeParameterGroup;
import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
*
* @param participantDefinitions the list of ParticipantDefinition to send
* @param compositionId the compositionId
- * @param participantId the ParticipantId
+ * @param revisionId last update
*/
@Timed(value = "publisher.participant_update", description = "PARTICIPANT_UPDATE messages published")
public void sendPriming(List<ParticipantDefinition> participantDefinitions, UUID compositionId,
- UUID participantId) {
+ UUID revisionId) {
var message = new ParticipantPrime();
message.setCompositionId(compositionId);
- message.setParticipantId(participantId);
+ message.setParticipantIdList(participantDefinitions.stream()
+ .map(ParticipantDefinition::getParticipantId).collect(Collectors.toSet()));
message.setTimestamp(Instant.now());
+ message.setRevisionIdComposition(revisionId);
message.setParticipantDefinitionUpdates(participantDefinitions);
LOGGER.debug("Participant Update sent {}", message.getMessageId());
super.send(message);
public List<ParticipantDefinition> prepareParticipantPriming(AutomationCompositionDefinition acmDefinition) {
acmDefinition.setStateChangeResult(StateChangeResult.NO_ERROR);
acmDefinition.setState(AcTypeState.PRIMING);
+ acmDefinition.setRevisionId(UUID.randomUUID());
acmDefinition.setLastMsg(TimestampHelper.now());
var acElements = AcmUtils.extractAcElementsFromServiceTemplate(acmDefinition.getServiceTemplate(),
acRuntimeParameterGroup.getAcmParameters().getToscaElementName());
* Send ParticipantPrime to Participant after that commissioning has been removed.
*/
@Timed(value = "publisher.participant_update", description = "PARTICIPANT_UPDATE messages published")
- public void sendDepriming(UUID compositionId) {
+ public void sendDepriming(UUID compositionId, Set<UUID> participantIds, UUID revisionId) {
var message = new ParticipantPrime();
message.setCompositionId(compositionId);
+ message.setParticipantIdList(participantIds);
message.setTimestamp(Instant.now());
+ message.setRevisionIdComposition(revisionId);
// DeCommission the automation composition but deleting participantdefinitions on participants
message.setParticipantDefinitionUpdates(null);
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2025 OpenInfra Foundation Europe. All rights reserved.
+ * ================================================================================
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ * ============LICENSE_END=========================================================
+ */
+
+package org.onap.policy.clamp.acm.runtime.supervision.comm;
+
+import org.onap.policy.clamp.acm.runtime.config.messaging.Listener;
+import org.onap.policy.clamp.acm.runtime.main.utils.NetLoggerUtil;
+import org.onap.policy.clamp.acm.runtime.supervision.SupervisionParticipantHandler;
+import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantMessageType;
+import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantReqSync;
+import org.onap.policy.common.endpoints.listeners.ScoListener;
+import org.onap.policy.common.message.bus.event.Topic;
+import org.onap.policy.common.utils.coder.StandardCoderObject;
+import org.springframework.stereotype.Component;
+
+@Component
+public class ParticipantReqSyncListener extends ScoListener<ParticipantReqSync>
+ implements Listener<ParticipantReqSync> {
+
+ private final SupervisionParticipantHandler supervisionParticipantHandler;
+
+ public ParticipantReqSyncListener(SupervisionParticipantHandler supervisionParticipantHandler) {
+ super(ParticipantReqSync.class);
+ this.supervisionParticipantHandler = supervisionParticipantHandler;
+ }
+
+ @Override
+ public String getType() {
+ return ParticipantMessageType.PARTICIPANT_REQ_SYNC_MSG.name();
+ }
+
+ @Override
+ public ScoListener<ParticipantReqSync> getScoListener() {
+ return this;
+ }
+
+ @Override
+ public void onTopicEvent(final Topic.CommInfrastructure infra, final String topic, final StandardCoderObject sco,
+ ParticipantReqSync participantReqSync) {
+ NetLoggerUtil.log(NetLoggerUtil.EventType.IN, infra, topic, participantReqSync.toString());
+ supervisionParticipantHandler.handleParticipantReqSync(participantReqSync);
+ }
+}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2024 Nordix Foundation.
+ * Copyright (C) 2024-2025 OpenInfra Foundation Europe. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
message.setMessageId(UUID.randomUUID());
message.setTimestamp(Instant.now());
message.setState(acmDefinition.getState());
+ message.setRevisionIdComposition(acmDefinition.getRevisionId());
message.setParticipantDefinitionUpdates(AcmUtils.prepareParticipantRestarting(participantId, acmDefinition,
acRuntimeParameterGroup.getAcmParameters().getToscaElementName()));
message.setStateChangeResult(acDefinition.getStateChangeResult());
message.setMessageId(UUID.randomUUID());
message.setTimestamp(Instant.now());
+ message.setRevisionIdComposition(acDefinition.getRevisionId());
if (AcTypeState.COMMISSIONED.equals(acDefinition.getState())) {
message.setDelete(true);
} else {
message.setTimestamp(Instant.now());
var syncAc = new ParticipantRestartAc();
syncAc.setAutomationCompositionId(automationComposition.getInstanceId());
+ syncAc.setRevisionId(automationComposition.getRevisionId());
syncAc.setDeployState(automationComposition.getDeployState());
syncAc.setLockState(automationComposition.getLockState());
syncAc.setStateChangeResult(automationComposition.getStateChangeResult());
package org.onap.policy.clamp.acm.runtime.supervision.scanner;
+import java.util.UUID;
import org.onap.policy.clamp.acm.runtime.main.parameters.AcRuntimeParameterGroup;
import org.onap.policy.clamp.acm.runtime.main.utils.EncryptionUtils;
import org.onap.policy.clamp.acm.runtime.supervision.comm.ParticipantSyncPublisher;
*/
public void saveAndSync(AutomationComposition automationComposition, UpdateSync updateSync) {
if (updateSync.isUpdated()) {
+ if (updateSync.isToBeSync()) {
+ automationComposition.setRevisionId(UUID.randomUUID());
+ }
acProvider.updateAutomationComposition(automationComposition);
}
if (updateSync.isToBeDelete()) {
}
protected void decryptInstanceProperties(AutomationComposition automationComposition) {
- if (encryptionUtils.encryptionEnabled()) {
- encryptionUtils.findAndDecryptSensitiveData(automationComposition);
- }
+ encryptionUtils.decryptInstanceProperties(automationComposition);
}
}
package org.onap.policy.clamp.acm.runtime.supervision.scanner;
+import java.util.UUID;
import org.onap.policy.clamp.acm.runtime.main.parameters.AcRuntimeParameterGroup;
import org.onap.policy.clamp.acm.runtime.supervision.comm.ParticipantSyncPublisher;
import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
private void updateAcDefinitionState(AutomationCompositionDefinition acDefinition,
UpdateSync updateSync) {
if (updateSync.isUpdated()) {
+ acDefinition.setRevisionId(UUID.randomUUID());
acDefinitionProvider.updateAcDefinitionState(acDefinition);
}
if (updateSync.isToBeSync()) {
import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
import org.onap.policy.clamp.models.acm.persistence.provider.MessageProvider;
import org.onap.policy.clamp.models.acm.utils.AcmUtils;
-import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
}
if (automationCompositionOpt.isPresent()) {
var automationComposition = automationCompositionOpt.get();
- var compositionId = automationComposition.getCompositionTargetId() != null
- ? automationComposition.getCompositionTargetId() : automationComposition.getCompositionId();
- var acDefinition = acDefinitionMap.computeIfAbsent(compositionId, acDefinitionProvider::getAcDefinition);
- scanAutomationComposition(automationComposition, acDefinition.getServiceTemplate(), updateSync);
+ if (automationComposition.getCompositionTargetId() != null) {
+ var acDefinitionTarget = acDefinitionMap.computeIfAbsent(automationComposition.getCompositionTargetId(),
+ acDefinitionProvider::getAcDefinition);
+ var acDefinition = acDefinitionMap.computeIfAbsent(automationComposition.getCompositionId(),
+ acDefinitionProvider::getAcDefinition);
+ scanAutomationComposition(automationComposition, acDefinitionTarget, updateSync,
+ acDefinition.getRevisionId());
+ } else {
+ var acDefinition = acDefinitionMap.computeIfAbsent(automationComposition.getCompositionId(),
+ acDefinitionProvider::getAcDefinition);
+ scanAutomationComposition(automationComposition, acDefinition, updateSync,
+ acDefinition.getRevisionId());
+ }
}
}
private void scanAutomationComposition(final AutomationComposition automationComposition,
- ToscaServiceTemplate serviceTemplate, UpdateSync updateSync) {
+ AutomationCompositionDefinition acDefinition, UpdateSync updateSync, UUID revisionIdComposition) {
LOGGER.debug("scanning automation composition {} . . .", automationComposition.getInstanceId());
if (!AcmUtils.isInTransitionalState(automationComposition.getDeployState(),
if (DeployState.MIGRATING.equals(automationComposition.getDeployState())
|| DeployState.MIGRATION_REVERTING.equals(automationComposition.getDeployState())
|| SubState.PREPARING.equals(automationComposition.getSubState())) {
- stageScanner.scanStage(automationComposition, serviceTemplate, updateSync);
+ stageScanner.scanStage(automationComposition, acDefinition, updateSync, revisionIdComposition);
} else if (DeployState.UPDATING.equals(automationComposition.getDeployState())
|| SubState.REVIEWING.equals(automationComposition.getSubState())
|| SubState.MIGRATION_PRECHECKING.equals(automationComposition.getSubState())) {
simpleScanner.simpleScan(automationComposition, updateSync);
} else {
- phaseScanner.scanWithPhase(automationComposition, serviceTemplate, updateSync);
+ phaseScanner.scanWithPhase(automationComposition, acDefinition, updateSync);
}
}
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2025 Nordix Foundation.
+ * Copyright (C) 2025 Nordix OpenInfra Foundation Europe. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionStateChangePublisher;
import org.onap.policy.clamp.acm.runtime.supervision.comm.ParticipantSyncPublisher;
import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
+import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
import org.onap.policy.clamp.models.acm.concepts.DeployState;
import org.onap.policy.clamp.models.acm.concepts.ParticipantUtils;
import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
import org.onap.policy.clamp.models.acm.utils.AcmUtils;
-import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
import org.springframework.stereotype.Component;
@Component
* Scan with startPhase: DEPLOY, UNDEPLOY, LOCK and UNLOCK.
*
* @param automationComposition the AutomationComposition
- * @param serviceTemplate the ToscaServiceTemplate
+ * @param acDefinition the AutomationComposition Definition
* @param updateSync the update/sync information
*/
public void scanWithPhase(final AutomationComposition automationComposition,
- ToscaServiceTemplate serviceTemplate, UpdateSync updateSync) {
+ AutomationCompositionDefinition acDefinition, UpdateSync updateSync) {
var completed = true;
var minSpNotCompleted = 1000; // min startPhase not completed
var maxSpNotCompleted = 0; // max startPhase not completed
var defaultMin = 1000; // min startPhase
var defaultMax = 0; // max startPhase
for (var element : automationComposition.getElements().values()) {
- var toscaNodeTemplate = serviceTemplate.getToscaTopologyTemplate().getNodeTemplates()
+ var toscaNodeTemplate = acDefinition.getServiceTemplate().getToscaTopologyTemplate().getNodeTemplates()
.get(element.getDefinition().getName());
int startPhase = toscaNodeTemplate != null
&& element.getDefinition().getVersion().equals(toscaNodeTemplate.getVersion())
var nextSpNotCompleted = isForward ? minSpNotCompleted : maxSpNotCompleted;
if (nextSpNotCompleted != automationComposition.getPhase()) {
- sendAutomationCompositionMsg(automationComposition, nextSpNotCompleted, updateSync);
+ sendAutomationCompositionMsg(automationComposition, nextSpNotCompleted, updateSync, acDefinition);
} else {
handleTimeout(automationComposition, updateSync);
}
}
private void sendAutomationCompositionMsg(AutomationComposition automationComposition, int startPhase,
- UpdateSync updateSync) {
+ UpdateSync updateSync, AutomationCompositionDefinition acDefinition) {
savePhase(automationComposition, startPhase);
updateSync.setUpdated(true);
saveAndSync(automationComposition, updateSync);
LOGGER.debug("retry message AutomationCompositionDeploy");
var acToSend = new AutomationComposition(automationComposition);
decryptInstanceProperties(acToSend);
- acDeployPublisher.send(acToSend, startPhase, false);
+ acDeployPublisher.send(acToSend, startPhase, false, acDefinition.getRevisionId());
} else {
LOGGER.debug("retry message AutomationCompositionStateChange");
- acStateChangePublisher.send(automationComposition, startPhase, false);
+ acStateChangePublisher.send(automationComposition, startPhase, false, acDefinition.getRevisionId());
}
}
}
package org.onap.policy.clamp.acm.runtime.supervision.scanner;
import java.util.Comparator;
+import java.util.UUID;
import org.onap.policy.clamp.acm.runtime.main.parameters.AcRuntimeParameterGroup;
import org.onap.policy.clamp.acm.runtime.main.utils.EncryptionUtils;
import org.onap.policy.clamp.acm.runtime.supervision.comm.AcPreparePublisher;
import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionMigrationPublisher;
import org.onap.policy.clamp.acm.runtime.supervision.comm.ParticipantSyncPublisher;
import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
+import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
import org.onap.policy.clamp.models.acm.concepts.DeployState;
import org.onap.policy.clamp.models.acm.concepts.ParticipantUtils;
import org.onap.policy.clamp.models.acm.concepts.SubState;
import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
import org.onap.policy.clamp.models.acm.utils.AcmUtils;
-import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
import org.springframework.stereotype.Component;
@Component
* Scan with stage: MIGRATE.
*
* @param automationComposition the AutomationComposition
- * @param serviceTemplate the ToscaServiceTemplate
+ * @param acDefinition the Composition Definition and for migration is the Composition target
* @param updateSync the update/sync information
+ * @param revisionIdComposition the last Update from Composition
*/
- public void scanStage(final AutomationComposition automationComposition, ToscaServiceTemplate serviceTemplate,
- UpdateSync updateSync) {
+ public void scanStage(final AutomationComposition automationComposition,
+ AutomationCompositionDefinition acDefinition, UpdateSync updateSync, UUID revisionIdComposition) {
var completed = true;
var minStageNotCompleted = 1000; // min stage not completed
for (var element : automationComposition.getElements().values()) {
if (AcmUtils.isInTransitionalState(element.getDeployState(), element.getLockState(),
element.getSubState())) {
- var toscaNodeTemplate = serviceTemplate.getToscaTopologyTemplate().getNodeTemplates()
+ var toscaNodeTemplate = acDefinition.getServiceTemplate().getToscaTopologyTemplate().getNodeTemplates()
.get(element.getDefinition().getName());
var stageSet = DeployState.MIGRATING.equals(automationComposition.getDeployState())
|| DeployState.MIGRATION_REVERTING.equals(automationComposition.getDeployState())
LOGGER.debug("retry message AutomationCompositionMigration");
var acToSend = new AutomationComposition(automationComposition);
decryptInstanceProperties(acToSend);
- sendNextStage(acToSend, minStageNotCompleted);
+ sendNextStage(acToSend, minStageNotCompleted, revisionIdComposition, acDefinition);
} else {
handleTimeout(automationComposition, updateSync);
}
}
}
- private void sendNextStage(final AutomationComposition automationComposition, int minStageNotCompleted) {
+ private void sendNextStage(final AutomationComposition automationComposition, int minStageNotCompleted,
+ UUID revisionIdComposition, AutomationCompositionDefinition acDefinition) {
if (DeployState.MIGRATING.equals(automationComposition.getDeployState())
|| DeployState.MIGRATION_REVERTING.equals(automationComposition.getDeployState())) {
LOGGER.debug("retry message AutomationCompositionMigration");
- acMigrationPublisher.send(automationComposition, minStageNotCompleted);
+ // acDefinition for migration is the Composition target
+ acMigrationPublisher.send(automationComposition, minStageNotCompleted, revisionIdComposition,
+ acDefinition.getRevisionId());
}
if (SubState.PREPARING.equals(automationComposition.getSubState())) {
LOGGER.debug("retry message AutomationCompositionPrepare");
- acPreparePublisher.sendPrepare(automationComposition, minStageNotCompleted);
+ acPreparePublisher.sendPrepare(automationComposition, minStageNotCompleted, acDefinition.getRevisionId());
}
}
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2021-2025 Nordix Foundation.
+ * Copyright (C) 2021-2025 OpenInfra Foundation Europe. All rights reserved.
* Modifications Copyright (C) 2021 AT&T Intellectual Property. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
import java.util.List;
import java.util.UUID;
+import java.util.stream.Collectors;
import org.junit.jupiter.api.Test;
import org.onap.policy.clamp.acm.runtime.instantiation.InstantiationUtils;
import org.onap.policy.clamp.acm.runtime.main.parameters.AcRuntimeParameterGroup;
import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
+import org.onap.policy.clamp.models.acm.concepts.NodeTemplateState;
import org.onap.policy.clamp.models.acm.messages.rest.commissioning.AcTypeStateUpdate;
import org.onap.policy.clamp.models.acm.messages.rest.commissioning.PrimeOrder;
import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
var acTypeStateUpdate = new AcTypeStateUpdate();
acTypeStateUpdate.setPrimeOrder(PrimeOrder.DEPRIME);
- doNothing().when(participantProvider).verifyParticipantState(any());
+ var participantIds = acmDefinition.getElementStateMap().values().stream()
+ .map(NodeTemplateState::getParticipantId).collect(Collectors.toSet());
+ doNothing().when(participantProvider).verifyParticipantState(participantIds);
provider.compositionDefinitionPriming(compositionId, acTypeStateUpdate);
- verify(participantPrimePublisher, timeout(1000).times(1)).sendDepriming(compositionId);
+ verify(participantPrimePublisher, timeout(1000).times(1))
+ .sendDepriming(compositionId, participantIds, acmDefinition.getRevisionId());
}
@Test
import static org.mockito.Mockito.when;
import static org.onap.policy.clamp.acm.runtime.util.CommonTestData.TOSCA_SERVICE_TEMPLATE_YAML;
+import jakarta.ws.rs.core.Response;
import jakarta.ws.rs.core.Response.Status;
import java.util.ArrayList;
import java.util.List;
-import java.util.Optional;
import java.util.UUID;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
var acDefinitionProvider = mock(AcDefinitionProvider.class);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var compositionId = acDefinition.getCompositionId();
- when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
+ when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
var acProvider = mock(AutomationCompositionProvider.class);
var supervisionAcHandler = mock(SupervisionAcHandler.class);
var acDefinitionProvider = mock(AcDefinitionProvider.class);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var compositionId = acDefinition.getCompositionId();
- when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
+ when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
var automationCompositionUpdate =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
var instantiationResponse = instantiationProvider.updateAutomationComposition(
automationCompositionUpdate.getCompositionId(), automationCompositionUpdate);
- verify(supervisionAcHandler).update(any());
+ verify(supervisionAcHandler).update(any(), any());
verify(acProvider).updateAutomationComposition(acmFromDb);
InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionUpdate);
@Test
void testUpdateBadRequest() {
+ var acDefinitionProvider = mock(AcDefinitionProvider.class);
+ var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
+ var compositionId = acDefinition.getCompositionId();
+ when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
+
var automationCompositionUpdate =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
automationCompositionUpdate.setDeployState(DeployState.DEPLOYING);
automationCompositionUpdate.setLockState(LockState.NONE);
+ automationCompositionUpdate.setCompositionId(compositionId);
var acProvider = mock(AutomationCompositionProvider.class);
var encryptionUtils = mock(EncryptionUtils.class);
when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
.thenReturn(automationCompositionUpdate);
var instantiationProvider =
- new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class),
+ new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
new AcInstanceStateResolver(), mock(SupervisionAcHandler.class),
mock(ParticipantProvider.class),
mock(AcRuntimeParameterGroup.class), encryptionUtils);
- var compositionId = automationCompositionUpdate.getCompositionId();
+
assertThatThrownBy(
() -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
.hasMessageMatching(
var acDefinitionProvider = mock(AcDefinitionProvider.class);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var compositionId = acDefinition.getCompositionId();
- when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
+ when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
var instanceId = UUID.randomUUID();
var automationComposition =
var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplateMigration, AcTypeState.PRIMED);
var compositionTargetId = acDefinitionTarget.getCompositionId();
automationCompositionTarget.setCompositionTargetId(compositionTargetId);
- when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
+ when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
when(acProvider.updateAutomationComposition(any())).thenReturn(automationCompositionTarget);
automationCompositionTarget.setPrecheck(true);
var preCheckResponse = instantiationProvider.updateAutomationComposition(compositionId,
automationCompositionTarget);
- verify(supervisionAcHandler).migratePrecheck(any());
+ verify(supervisionAcHandler).migratePrecheck(any(), any(), any());
InstantiationUtils.assertInstantiationResponse(preCheckResponse, automationCompositionTarget);
automationCompositionTarget.setPrecheck(false);
var instantiationResponse = instantiationProvider.updateAutomationComposition(compositionId,
automationCompositionTarget);
- verify(supervisionAcHandler).migrate(any());
+ verify(supervisionAcHandler).migrate(any(), any(), any());
InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionTarget);
}
var acDefinitionProvider = mock(AcDefinitionProvider.class);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var compositionId = acDefinition.getCompositionId();
- when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
+ when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
var automationComposition =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
automationComposition.setDeployState(DeployState.DEPLOYED);
automationComposition.setLockState(LockState.LOCKED);
automationComposition.setCompositionTargetId(UUID.randomUUID());
+ when(acDefinitionProvider.getAcDefinition(automationComposition.getCompositionTargetId()))
+ .thenThrow(new PfModelRuntimeException(Status.NOT_FOUND,
+ String.format(AC_DEFINITION_NOT_FOUND, automationComposition.getCompositionTargetId())));
var acProvider = mock(AutomationCompositionProvider.class);
when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
.thenReturn(automationComposition);
var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var compositionTargetId = acDefinitionTarget.getCompositionId();
- when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
automationComposition.setCompositionTargetId(compositionTargetId);
var instantiationResponse = instantiationProvider
.updateAutomationComposition(automationComposition.getCompositionId(), automationComposition);
- verify(supervisionAcHandler).migrate(any());
+ verify(supervisionAcHandler).migrate(any(), any(), any());
verify(acProvider).updateAutomationComposition(automationComposition);
InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationComposition);
}
var acDefinitionProvider = mock(AcDefinitionProvider.class);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var compositionId = acDefinition.getCompositionId();
- when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
+ when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
var automationComposition =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
new AcInstanceStateResolver(), supervisionAcHandler, acmParticipantProvider,
new AcRuntimeParameterGroup(), encryptionUtils);
- assertThatThrownBy(() -> instantiationProvider
- .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition))
- .hasMessageMatching(
- String.format(AC_DEFINITION_NOT_FOUND, automationComposition.getCompositionTargetId()));
-
var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var compositionTargetId = acDefinitionTarget.getCompositionId();
- when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
-
+ when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
automationComposition.setCompositionTargetId(compositionTargetId);
var instantiationResponse = instantiationProvider
.updateAutomationComposition(automationComposition.getCompositionId(), automationComposition);
- verify(supervisionAcHandler).migratePrecheck(any());
+ verify(supervisionAcHandler).migratePrecheck(any(), any(), any());
verify(acProvider).updateAutomationComposition(automationComposition);
InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationComposition);
+
+ automationComposition.setSubState(SubState.NONE);
+ when(acDefinitionProvider.getAcDefinition(compositionTargetId))
+ .thenThrow(new PfModelRuntimeException(Status.NOT_FOUND,
+ String.format(AC_DEFINITION_NOT_FOUND, compositionTargetId)));
+ assertThatThrownBy(() -> instantiationProvider
+ .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition))
+ .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionTargetId));
}
@Test
var acDefinitionProvider = mock(AcDefinitionProvider.class);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var compositionId = acDefinition.getCompositionId();
- when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
+ when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
var automationComposition =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var compositionTargetId = acDefinitionTarget.getCompositionId();
- when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
+ when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
var acMigrate = new AutomationComposition(automationComposition);
acMigrate.setCompositionTargetId(compositionTargetId);
var acDefinitionProvider = mock(AcDefinitionProvider.class);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var compositionId = acDefinition.getCompositionId();
- when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
+ when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
var automationComposition =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var compositionTargetId = acDefinitionTarget.getCompositionId();
- when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
+ when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
var acMigrate = new AutomationComposition(automationComposition);
acMigrate.setCompositionTargetId(compositionTargetId);
var acDefinitionProvider = mock(AcDefinitionProvider.class);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplateMigration, AcTypeState.PRIMED);
var compositionId = acDefinition.getCompositionId();
- when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
+ when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
var automationComposition =
InstantiationUtils.getAutomationCompositionFromResource(AC_MIGRATE_JSON, "Crud");
var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
new AcInstanceStateResolver(), supervisionAcHandler, participantProvider, new AcRuntimeParameterGroup(),
encryptionUtils);
- assertThatThrownBy(() -> instantiationProvider.rollback(compositionId, instanceId))
- .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionTargetId));
-
var acDefinitionTarget = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
- when(acDefinitionProvider.findAcDefinition(compositionTargetId)).thenReturn(Optional.of(acDefinitionTarget));
when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
instantiationProvider.rollback(compositionId, automationComposition.getInstanceId());
verify(acProvider).updateAutomationComposition(any(AutomationComposition.class));
+
+ when(acDefinitionProvider.getAcDefinition(compositionTargetId))
+ .thenThrow(new PfModelRuntimeException(Response.Status.NOT_FOUND,
+ String.format(AC_DEFINITION_NOT_FOUND, compositionTargetId)));
+ assertThatThrownBy(() -> instantiationProvider.rollback(compositionId, instanceId))
+ .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionTargetId));
}
private void assertThatDeleteThrownBy(AutomationComposition automationComposition, DeployState deployState,
var acDefinitionProvider = mock(AcDefinitionProvider.class);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var compositionId = acDefinition.getCompositionId();
- when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
+ when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
var automationCompositionCreate =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "NoDuplicates");
var acProvider = mock(AutomationCompositionProvider.class);
when(acProvider.createAutomationComposition(automationCompositionCreate))
.thenReturn(automationCompositionCreate);
+ var acIdentifier = automationCompositionCreate.getKey().asIdentifier();
var participantProvider = mock(ParticipantProvider.class);
var encryptionUtils = new EncryptionUtils(CommonTestData.getTestParamaterGroup());
var instantiationResponse = instantiationProvider.createAutomationComposition(
automationCompositionCreate.getCompositionId(), automationCompositionCreate);
InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationCompositionCreate);
- var acIdentifier = automationCompositionCreate.getKey().asIdentifier();
+
doThrow(new PfModelRuntimeException(Status.BAD_REQUEST, acIdentifier + " already defined"))
.when(acProvider).validateNameVersion(acIdentifier);
-
assertThatThrownBy(
() -> instantiationProvider.createAutomationComposition(compositionId, automationCompositionCreate))
- .hasMessageMatching(automationCompositionCreate.getKey().asIdentifier() + " already defined");
+ .hasMessageMatching(acIdentifier + " already defined");
}
@Test
var participantProvider = mock(ParticipantProvider.class);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var compositionId = acDefinition.getCompositionId();
- when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
+ when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
var automationComposition = InstantiationUtils.getAutomationCompositionFromResource(
AC_INSTANTIATION_DEFINITION_NAME_NOT_FOUND_JSON, "AcElementNotFound");
automationComposition.setCompositionId(compositionId);
var acProvider = mock(AutomationCompositionProvider.class);
when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
.thenReturn(automationComposition);
- var provider = new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class),
+ var acDefinitionProvider = mock(AcDefinitionProvider.class);
+ var provider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
null, null, null,
mock(AcRuntimeParameterGroup.class), null);
var compositionId = automationComposition.getCompositionId();
+ when(acDefinitionProvider.getAcDefinition(automationComposition.getCompositionId()))
+ .thenThrow(new PfModelRuntimeException(Status.NOT_FOUND,
+ String.format(AC_DEFINITION_NOT_FOUND, automationComposition.getCompositionId())));
assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
.hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionId));
var acDefinitionProvider = mock(AcDefinitionProvider.class);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.COMMISSIONED);
var compositionId = acDefinition.getCompositionId();
- when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
+ when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
var acProvider = mock(AutomationCompositionProvider.class);
var provider =
new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider, null, null, null,
var automationComposition =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
automationComposition.setCompositionId(compositionId);
- var message = """
- "AutomationComposition" INVALID, item has status INVALID
- item "ServiceTemplate.state" value "COMMISSIONED" INVALID, Commissioned automation composition \
- definition not primed
- """;
+ var message = compositionId + " Commissioned automation composition definition not primed";
assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
.hasMessageMatching(message);
acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
acInstanceStateUpdate.setSubOrder(SubOrder.PREPARE);
provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
- verify(supervisionAcHandler).prepare(any(AutomationComposition.class), any());
+ verify(supervisionAcHandler).prepare(any(AutomationComposition.class),
+ any(AutomationCompositionDefinition.class));
automationComposition.setDeployState(DeployState.DEPLOYED);
automationComposition.setLockState(LockState.LOCKED);
acInstanceStateUpdate.setLockOrder(LockOrder.NONE);
acInstanceStateUpdate.setSubOrder(SubOrder.REVIEW);
provider.compositionInstanceState(compositionId, instanceId, acInstanceStateUpdate);
- verify(supervisionAcHandler).review(any(AutomationComposition.class));
+ verify(supervisionAcHandler).review(any(AutomationComposition.class),
+ any(AutomationCompositionDefinition.class));
}
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2025 Nordix Foundation.
+ * Copyright (C) 2025 OpenInfra Foundation Europe. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.security.InvalidAlgorithmParameterException;
+import java.util.List;
import javax.crypto.Cipher;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
import org.onap.policy.clamp.models.acm.persistence.provider.ProviderUtils;
-import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
import org.onap.policy.models.tosca.simple.concepts.JpaToscaServiceTemplate;
class EncryptionUtilTest {
- private static ToscaServiceTemplate serviceTemplateEncrypt;
- public static final String TOSCA_TEMPLATE_YAML = "src/test/resources/providers/AcDefinitionEncryptTest.yaml";
- public static final String INSTANTIATE_JSON = "src/test/resources/providers/AcInstantiateEncryptTest.json";
+ private static final String TOSCA_TEMPLATE_YAML = "src/test/resources/providers/AcDefinitionEncryptTest.yaml";
+ private static final String INSTANTIATE_JSON = "src/test/resources/providers/AcInstantiateEncryptTest.json";
private static AutomationCompositionDefinition acDefinition;
@BeforeAll
static void setUpBeforeClass() {
- serviceTemplateEncrypt = InstantiationUtils.getToscaServiceTemplate(TOSCA_TEMPLATE_YAML);
+ var serviceTemplateEncrypt = InstantiationUtils.getToscaServiceTemplate(TOSCA_TEMPLATE_YAML);
var jpa2 = ProviderUtils.getJpaAndValidate(serviceTemplateEncrypt, JpaToscaServiceTemplate::new,
"toscaServiceTemplate");
serviceTemplateEncrypt = jpa2.toAuthorative();
InstantiationUtils.getAutomationCompositionFromResource(INSTANTIATE_JSON, "Crud");
var encryptionUtils = new EncryptionUtils(CommonTestData.getEncryptionParameterGroup());
assertTrue(encryptionUtils.encryptionEnabled());
- assertDoesNotThrow(()
- -> {
- assert automationComposition != null;
- encryptionUtils.findAndEncryptSensitiveData(acDefinition, automationComposition);
- });
-
assert automationComposition != null;
+ assertDoesNotThrow(() -> encryptionUtils.findAndEncryptSensitiveData(acDefinition, automationComposition));
+
automationComposition.getElements().values().forEach(element -> {
assertTrue(element.getProperties().get("secret").toString().startsWith("ENCRYPTED:"));
assertTrue(element.getProperties().get("password").toString().startsWith("ENCRYPTED:"));
});
var encryptionUtil2 = new EncryptionUtils(CommonTestData.getEncryptionParameterGroup());
- assertDoesNotThrow(() -> {
- encryptionUtil2.findAndDecryptSensitiveData(automationComposition);
- });
+ assertDoesNotThrow(() -> encryptionUtil2.decryptInstanceProperties(automationComposition));
+ assertDoesNotThrow(() -> encryptionUtil2.decryptInstanceProperties(List.of(automationComposition)));
automationComposition.getElements().values().forEach(element -> {
assertEquals("mysecret", element.getProperties().get("secret").toString());
assertEquals("mypass", element.getProperties().get("password").toString());
assert automationComposition != null;
assertThrows(AutomationCompositionRuntimeException.class,
- () -> encryptionUtils.findAndDecryptSensitiveData(automationComposition));
-
+ () -> encryptionUtils.decryptInstanceProperties(automationComposition));
}
}
import org.onap.policy.clamp.models.acm.concepts.AcElementDeployAck;
import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
+import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
import org.onap.policy.clamp.models.acm.concepts.DeployState;
import org.onap.policy.clamp.models.acm.concepts.LockState;
import org.onap.policy.clamp.models.acm.concepts.StateChangeResult;
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
handler.deploy(automationComposition, acDefinition);
verify(acProvider).updateAutomationComposition(automationComposition);
- verify(acDeployPublisher, timeout(1000)).send(automationComposition, 0, true);
+ verify(acDeployPublisher, timeout(1000)).send(automationComposition, 0, true, acDefinition.getRevisionId());
}
@Test
handler.undeploy(automationComposition, acDefinition);
verify(automationCompositionProvider).updateAutomationComposition(any(AutomationComposition.class));
- verify(acStateChangePublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt(), anyBoolean());
+ verify(acStateChangePublisher, timeout(1000))
+ .send(any(AutomationComposition.class), anyInt(), anyBoolean(), any(UUID.class));
}
@Test
handler.unlock(automationComposition, acDefinition);
verify(acProvider).updateAutomationComposition(any(AutomationComposition.class));
- verify(acStateChangePublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt(), anyBoolean());
+ verify(acStateChangePublisher, timeout(1000))
+ .send(any(AutomationComposition.class), anyInt(), anyBoolean(), any(UUID.class));
}
@Test
handler.lock(automationComposition, acDefinition);
verify(automationCompositionProvider).updateAutomationComposition(any(AutomationComposition.class));
- verify(acStateChangePublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt(), anyBoolean());
+ verify(acStateChangePublisher, timeout(1000))
+ .send(any(AutomationComposition.class), anyInt(), anyBoolean(), any(UUID.class));
}
@Test
mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
var automationComposition =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Lock");
- handler.update(automationComposition);
- verify(acElementPropertiesPublisher, timeout(1000)).send(any(AutomationComposition.class));
+ handler.update(automationComposition, UUID.randomUUID());
+ verify(acElementPropertiesPublisher, timeout(1000)).send(any(AutomationComposition.class),
+ any(UUID.class));
}
@Test
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Migrate");
assert automationComposition != null;
automationComposition.setPhase(0);
- handler.migrate(automationComposition);
- verify(acCompositionMigrationPublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt());
+ handler.migrate(automationComposition, UUID.randomUUID(), UUID.randomUUID());
+ verify(acCompositionMigrationPublisher, timeout(1000))
+ .send(any(AutomationComposition.class), anyInt(), any(UUID.class), any(UUID.class));
}
@Test
mock(AcPreparePublisher.class), mock(MessageProvider.class), mock(EncryptionUtils.class));
var automationComposition =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Migrate");
- handler.migratePrecheck(automationComposition);
- verify(acCompositionMigrationPublisher, timeout(1000)).send(any(AutomationComposition.class), anyInt());
+ handler.migratePrecheck(automationComposition, UUID.randomUUID(), UUID.randomUUID());
+ verify(acCompositionMigrationPublisher, timeout(1000))
+ .send(any(AutomationComposition.class), anyInt(), any(UUID.class), any(UUID.class));
}
@Test
var automationComposition =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Migrate");
handler.prepare(automationComposition, acDefinition);
- verify(acPreparePublisher, timeout(1000)).sendPrepare(any(AutomationComposition.class), anyInt());
+ verify(acPreparePublisher, timeout(1000)).sendPrepare(any(AutomationComposition.class), anyInt(),
+ any(UUID.class));
}
@Test
acPreparePublisher, mock(MessageProvider.class), mock(EncryptionUtils.class));
var automationComposition =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Migrate");
- handler.review(automationComposition);
- verify(acPreparePublisher, timeout(1000)).sendRevew(any(AutomationComposition.class));
+ handler.review(automationComposition, new AutomationCompositionDefinition());
+ verify(acPreparePublisher, timeout(1000)).sendReview(any(AutomationComposition.class), any(UUID.class));
}
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2023-2025 Nordix Foundation.
+ * Copyright (C) 2023-2025 OpenInfra Foundation Europe. All rights reserved.
* ================================================================================
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
import java.util.UUID;
import org.junit.jupiter.api.Test;
import org.onap.policy.clamp.acm.runtime.instantiation.InstantiationUtils;
+import org.onap.policy.clamp.acm.runtime.main.utils.EncryptionUtils;
import org.onap.policy.clamp.acm.runtime.supervision.comm.ParticipantDeregisterAckPublisher;
import org.onap.policy.clamp.acm.runtime.supervision.comm.ParticipantRegisterAckPublisher;
import org.onap.policy.clamp.acm.runtime.supervision.comm.ParticipantSyncPublisher;
import org.onap.policy.clamp.acm.runtime.util.CommonTestData;
import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
+import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementDefinition;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionInfo;
+import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionRollback;
+import org.onap.policy.clamp.models.acm.concepts.DeployState;
import org.onap.policy.clamp.models.acm.concepts.NodeTemplateState;
import org.onap.policy.clamp.models.acm.concepts.Participant;
import org.onap.policy.clamp.models.acm.concepts.ParticipantDefinition;
import org.onap.policy.clamp.models.acm.concepts.ParticipantState;
import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantDeregister;
import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantRegister;
+import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantReqSync;
import org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantStatus;
import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
import org.onap.policy.clamp.models.acm.persistence.provider.MessageProvider;
import org.onap.policy.clamp.models.acm.persistence.provider.ParticipantProvider;
import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaTopologyTemplate;
class SupervisionParticipantHandlerTest {
new SupervisionParticipantHandler(participantProvider, mock(ParticipantRegisterAckPublisher.class),
participantDeregisterAckPublisher, mock(AutomationCompositionProvider.class),
mock(AcDefinitionProvider.class), mock(ParticipantSyncPublisher.class),
- mock(MessageProvider.class));
+ mock(MessageProvider.class), mock(EncryptionUtils.class));
handler.handleParticipantMessage(participantDeregisterMessage);
verify(participantDeregisterAckPublisher).send(participantDeregisterMessage.getMessageId());
var handler = new SupervisionParticipantHandler(participantProvider, participantRegisterAckPublisher,
mock(ParticipantDeregisterAckPublisher.class), mock(AutomationCompositionProvider.class),
mock(AcDefinitionProvider.class), mock(ParticipantSyncPublisher.class),
- mock(MessageProvider.class));
+ mock(MessageProvider.class), mock(EncryptionUtils.class));
handler.handleParticipantMessage(participantRegisterMessage);
verify(participantProvider).saveParticipant(any());
var participantSyncPublisher = mock(ParticipantSyncPublisher.class);
var handler = new SupervisionParticipantHandler(participantProvider, participantRegisterAckPublisher,
mock(ParticipantDeregisterAckPublisher.class), automationCompositionProvider, acDefinitionProvider,
- participantSyncPublisher, mock(MessageProvider.class));
+ participantSyncPublisher, mock(MessageProvider.class), mock(EncryptionUtils.class));
handler.handleParticipantMessage(participantRegisterMessage);
verify(participantRegisterAckPublisher)
var automationCompositionProvider = mock(AutomationCompositionProvider.class);
var messageProvider = mock(MessageProvider.class);
var acDefinitionProvider = mock(AcDefinitionProvider.class);
- var handler =
- new SupervisionParticipantHandler(participantProvider, mock(ParticipantRegisterAckPublisher.class),
- mock(ParticipantDeregisterAckPublisher.class), automationCompositionProvider,
- acDefinitionProvider, mock(ParticipantSyncPublisher.class), messageProvider);
+ var handler = new SupervisionParticipantHandler(participantProvider,
+ mock(ParticipantRegisterAckPublisher.class), mock(ParticipantDeregisterAckPublisher.class),
+ automationCompositionProvider, acDefinitionProvider, mock(ParticipantSyncPublisher.class),
+ messageProvider, mock(EncryptionUtils.class));
handler.handleParticipantMessage(participantStatusMessage);
verify(messageProvider).saveInstanceOutProperties(any(ParticipantStatus.class));
when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
var participantProvider = mock(ParticipantProvider.class);
- var handler =
- new SupervisionParticipantHandler(participantProvider, mock(ParticipantRegisterAckPublisher.class),
- mock(ParticipantDeregisterAckPublisher.class), mock(AutomationCompositionProvider.class),
- acDefinitionProvider, mock(ParticipantSyncPublisher.class), messageProvider);
+ var handler = new SupervisionParticipantHandler(participantProvider,
+ mock(ParticipantRegisterAckPublisher.class), mock(ParticipantDeregisterAckPublisher.class),
+ mock(AutomationCompositionProvider.class), acDefinitionProvider, mock(ParticipantSyncPublisher.class),
+ messageProvider, mock(EncryptionUtils.class));
handler.handleParticipantMessage(participantStatusMessage);
verify(messageProvider).saveCompositionOutProperties(any(), any());
}
var acDefinitionProvider = mock(AcDefinitionProvider.class);
var messageProvider = mock(MessageProvider.class);
var participantProvider = mock(ParticipantProvider.class);
- var handler =
- new SupervisionParticipantHandler(participantProvider, mock(ParticipantRegisterAckPublisher.class),
- mock(ParticipantDeregisterAckPublisher.class), mock(AutomationCompositionProvider.class),
- acDefinitionProvider, mock(ParticipantSyncPublisher.class), messageProvider);
+ var handler = new SupervisionParticipantHandler(participantProvider,
+ mock(ParticipantRegisterAckPublisher.class), mock(ParticipantDeregisterAckPublisher.class),
+ mock(AutomationCompositionProvider.class), acDefinitionProvider, mock(ParticipantSyncPublisher.class),
+ messageProvider, mock(EncryptionUtils.class));
handler.handleParticipantMessage(participantStatusMessage);
verify(messageProvider, times(0)).saveCompositionOutProperties(any(), any());
}
new SupervisionParticipantHandler(participantProvider, mock(ParticipantRegisterAckPublisher.class),
mock(ParticipantDeregisterAckPublisher.class), mock(AutomationCompositionProvider.class),
mock(AcDefinitionProvider.class), mock(ParticipantSyncPublisher.class),
- mock(MessageProvider.class));
+ mock(MessageProvider.class), mock(EncryptionUtils.class));
handler.handleParticipantMessage(participantStatusMessage);
verify(participantProvider).saveParticipant(any());
var participantProvider = mock(ParticipantProvider.class);
var automationCompositionProvider = mock(AutomationCompositionProvider.class);
var messageProvider = mock(MessageProvider.class);
- var handler =
- new SupervisionParticipantHandler(participantProvider, mock(ParticipantRegisterAckPublisher.class),
- mock(ParticipantDeregisterAckPublisher.class), automationCompositionProvider,
- acDefinitionProvider, mock(ParticipantSyncPublisher.class), messageProvider);
+ var handler = new SupervisionParticipantHandler(participantProvider,
+ mock(ParticipantRegisterAckPublisher.class), mock(ParticipantDeregisterAckPublisher.class),
+ automationCompositionProvider, acDefinitionProvider, mock(ParticipantSyncPublisher.class),
+ messageProvider, mock(EncryptionUtils.class));
var participant = CommonTestData.createParticipant(CommonTestData.getParticipantId());
when(participantProvider.findParticipant(CommonTestData.getParticipantId()))
.thenReturn(Optional.of(participant));
statusMessage.setParticipantSupportedElementType(List.of(supportedElementType));
return statusMessage;
}
+
+ @Test
+ void testHandleParticipantReqSyncComposition() {
+ var acDefinitionProvider = mock(AcDefinitionProvider.class);
+ var acDefinition = new AutomationCompositionDefinition();
+ var compositionId = UUID.randomUUID();
+ acDefinition.setCompositionId(compositionId);
+ when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
+
+ var participantSyncPublisher = mock(ParticipantSyncPublisher.class);
+ var automationCompositionProvider = mock(AutomationCompositionProvider.class);
+ var handler =
+ new SupervisionParticipantHandler(mock(ParticipantProvider.class),
+ mock(ParticipantRegisterAckPublisher.class), mock(ParticipantDeregisterAckPublisher.class),
+ automationCompositionProvider, acDefinitionProvider, participantSyncPublisher,
+ mock(MessageProvider.class), mock(EncryptionUtils.class));
+ var participantReqSync = createParticipantReqSync(compositionId);
+ handler.handleParticipantReqSync(participantReqSync);
+ verify(participantSyncPublisher).sendRestartMsg(CommonTestData.getParticipantId(),
+ CommonTestData.getReplicaId(), acDefinition, List.of());
+
+ clearInvocations(participantSyncPublisher);
+ var automationComposition =
+ InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
+ automationComposition.setCompositionId(compositionId);
+ automationComposition.setInstanceId(UUID.randomUUID());
+ automationComposition.setDeployState(DeployState.DEPLOYED);
+ when(automationCompositionProvider.getAutomationComposition(automationComposition.getInstanceId()))
+ .thenReturn(automationComposition);
+
+ participantReqSync.setAutomationCompositionId(automationComposition.getInstanceId());
+ handler.handleParticipantReqSync(participantReqSync);
+ verify(participantSyncPublisher).sendRestartMsg(CommonTestData.getParticipantId(),
+ CommonTestData.getReplicaId(), acDefinition, List.of(automationComposition));
+ }
+
+ @Test
+ void testHandleParticipantReqSyncCompositionTarget() {
+ var acDefinitionProvider = mock(AcDefinitionProvider.class);
+ var acDefinition = new AutomationCompositionDefinition();
+ var compositionId = UUID.randomUUID();
+ acDefinition.setCompositionId(compositionId);
+ when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
+
+ var participantSyncPublisher = mock(ParticipantSyncPublisher.class);
+ var handler = new SupervisionParticipantHandler(mock(ParticipantProvider.class),
+ mock(ParticipantRegisterAckPublisher.class), mock(ParticipantDeregisterAckPublisher.class),
+ mock(AutomationCompositionProvider.class), acDefinitionProvider,
+ participantSyncPublisher, mock(MessageProvider.class), mock(EncryptionUtils.class));
+ var participantReqSync = createParticipantReqSync(null);
+ participantReqSync.setCompositionTargetId(compositionId);
+ handler.handleParticipantReqSync(participantReqSync);
+ verify(participantSyncPublisher).sendRestartMsg(CommonTestData.getParticipantId(),
+ CommonTestData.getReplicaId(), acDefinition, List.of());
+ }
+
+
+ @Test
+ void testHandleParticipantReqSyncAutomationComposition() {
+ var acDefinition = new AutomationCompositionDefinition();
+ acDefinition.setServiceTemplate(new ToscaServiceTemplate());
+ acDefinition.getServiceTemplate().setToscaTopologyTemplate(new ToscaTopologyTemplate());
+ var compositionId = UUID.randomUUID();
+ acDefinition.setCompositionId(compositionId);
+ var acDefinitionProvider = mock(AcDefinitionProvider.class);
+ when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
+ var automationComposition = new AutomationComposition();
+ automationComposition.setElements(Map.of());
+ automationComposition.setPhase(1);
+ automationComposition.setCompositionTargetId(compositionId);
+ automationComposition.setInstanceId(UUID.randomUUID());
+ automationComposition.setDeployState(DeployState.MIGRATING);
+ var automationCompositionProvider = mock(AutomationCompositionProvider.class);
+ when(automationCompositionProvider.getAutomationComposition(automationComposition.getInstanceId()))
+ .thenReturn(automationComposition);
+
+ var participantSyncPublisher = mock(ParticipantSyncPublisher.class);
+ var handler =
+ new SupervisionParticipantHandler(mock(ParticipantProvider.class),
+ mock(ParticipantRegisterAckPublisher.class), mock(ParticipantDeregisterAckPublisher.class),
+ automationCompositionProvider, acDefinitionProvider, participantSyncPublisher,
+ mock(MessageProvider.class), mock(EncryptionUtils.class));
+ var participantReqSync = createParticipantReqSync(null);
+ participantReqSync.setAutomationCompositionId(automationComposition.getInstanceId());
+
+ handler.handleParticipantReqSync(participantReqSync);
+ verify(participantSyncPublisher).sendSync(automationComposition);
+
+ clearInvocations(participantSyncPublisher);
+ automationComposition.setPhase(0);
+ when(automationCompositionProvider.getAutomationCompositionRollback(automationComposition.getInstanceId()))
+ .thenReturn(new AutomationCompositionRollback());
+ handler.handleParticipantReqSync(participantReqSync);
+ verify(participantSyncPublisher).sendSync(automationComposition);
+ }
+
+ private ParticipantReqSync createParticipantReqSync(UUID compositionId) {
+ var participantReqSync = new ParticipantReqSync();
+ participantReqSync.setCompositionId(compositionId);
+ participantReqSync.setParticipantId(CommonTestData.getParticipantId());
+ participantReqSync.setReplicaId(CommonTestData.getReplicaId());
+ return participantReqSync;
+ }
}
private void verifyNoInteraction(
StageScanner stageScanner, SimpleScanner simpleScanner, PhaseScanner phaseScanner) {
- verify(stageScanner, times(0)).scanStage(any(), any(), any());
+ verify(stageScanner, times(0)).scanStage(any(), any(), any(), any());
verify(simpleScanner, times(0)).simpleScan(any(), any());
verify(phaseScanner, times(0)).scanWithPhase(any(), any(), any());
}
messageProvider, monitoringScanner);
supervisionScanner.run();
- verify(stageScanner, times(0)).scanStage(any(), any(), any());
+ verify(stageScanner, times(0)).scanStage(any(), any(), any(), any());
verify(simpleScanner, times(0)).simpleScan(any(), any());
verify(phaseScanner).scanWithPhase(any(), any(), any());
verify(messageProvider).removeMessage(message.getMessageId());
when(automationCompositionProvider.findAutomationComposition(automationComposition.getInstanceId()))
.thenReturn(Optional.of(automationComposition));
- var definitionTarget = createAutomationCompositionDefinition(AcTypeState.PRIMED);
- definitionTarget.setCompositionId(compositionTargetId);
+ var acDefinitionTarget = createAutomationCompositionDefinition(AcTypeState.PRIMED);
+ acDefinitionTarget.setCompositionId(compositionTargetId);
var acDefinitionProvider = createAcDefinitionProvider(AcTypeState.PRIMED);
- when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(definitionTarget);
+ when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(acDefinitionTarget);
+ var acDefinition = new AutomationCompositionDefinition();
+ acDefinition.setCompositionId(COMPOSITION_ID);
+ when(acDefinitionProvider.getAcDefinition(COMPOSITION_ID)).thenReturn(acDefinition);
var stageScanner = mock(StageScanner.class);
var messageProvider = mock(MessageProvider.class);
messageProvider, monitoringScanner);
supervisionScanner.run();
- verify(stageScanner).scanStage(automationComposition, definitionTarget.getServiceTemplate(),
- new UpdateSync());
+ verify(stageScanner).scanStage(automationComposition, acDefinitionTarget, new UpdateSync(),
+ acDefinition.getRevisionId());
verify(messageProvider).removeJob(JOB_ID);
}
definitionTarget.setCompositionId(compositionTargetId);
var acDefinitionProvider = createAcDefinitionProvider(AcTypeState.PRIMED);
when(acDefinitionProvider.getAcDefinition(compositionTargetId)).thenReturn(definitionTarget);
+ var acDefinition = new AutomationCompositionDefinition();
+ acDefinition.setCompositionId(COMPOSITION_ID);
+ when(acDefinitionProvider.getAcDefinition(COMPOSITION_ID)).thenReturn(acDefinition);
var stageScanner = mock(StageScanner.class);
var messageProvider = mock(MessageProvider.class);
messageProvider, monitoringScanner);
supervisionScanner.run();
- verify(stageScanner).scanStage(automationComposition, definitionTarget.getServiceTemplate(),
- new UpdateSync());
+ verify(stageScanner).scanStage(automationComposition, definitionTarget, new UpdateSync(),
+ acDefinition.getRevisionId());
verify(messageProvider).removeJob(JOB_ID);
}
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import java.util.Set;
import java.util.UUID;
import org.junit.jupiter.api.Test;
import org.onap.policy.clamp.acm.runtime.instantiation.InstantiationUtils;
@Test
void testSendAutomationCompositionStateChangePublisherNotActive() {
var publisher = new AutomationCompositionStateChangePublisher();
- assertThatThrownBy(() -> publisher.send(getAutomationComposition(), 0, true)).hasMessage(NOT_ACTIVE);
+ assertThatThrownBy(() -> publisher.send(getAutomationComposition(), 0, true, UUID.randomUUID()))
+ .hasMessage(NOT_ACTIVE);
}
private AutomationComposition getAutomationComposition() {
automationComposition.setVersion("0.0.1");
automationComposition.setDeployState(DeployState.DEPLOYED);
automationComposition.setLockState(LockState.UNLOCKING);
+ automationComposition.setElements(new HashMap<>());
return automationComposition;
}
var publisher = new AutomationCompositionStateChangePublisher();
var topicSink = mock(TopicSink.class);
publisher.active(topicSink);
- publisher.send(getAutomationComposition(), 0, true);
+ publisher.send(getAutomationComposition(), 0, true, UUID.randomUUID());
verify(topicSink).send(anyString());
publisher.stop();
}
mock(AcRuntimeParameterGroup.class));
var topicSink = mock(TopicSink.class);
publisher.active(topicSink);
- publisher.sendDepriming(UUID.randomUUID());
+ publisher.sendDepriming(UUID.randomUUID(), Set.of(UUID.randomUUID()), UUID.randomUUID());
verify(topicSink).send(anyString());
}
.extractAcElementsFromServiceTemplate(serviceTemplate, TOSCA_ELEMENT_NAME);
acmDefinition.setElementStateMap(AcmUtils.createElementStateMap(acElements, AcTypeState.COMMISSIONED));
var preparation = publisher.prepareParticipantPriming(acmDefinition);
- publisher.sendPriming(preparation, acmDefinition.getCompositionId(), null);
+ publisher.sendPriming(preparation, acmDefinition.getCompositionId(), acmDefinition.getRevisionId());
verify(topicSink).send(anyString());
}
publisher.active(topicSink);
var automationComposition =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
- publisher.send(automationComposition);
+ publisher.send(automationComposition, UUID.randomUUID());
verify(topicSink).send(anyString());
}
publisher.active(topicSink);
var automationComposition =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
- publisher.send(automationComposition, 0);
+ publisher.send(automationComposition, 0, UUID.randomUUID(), UUID.randomUUID());
verify(topicSink).send(anyString());
}
publisher.active(topicSink);
var automationComposition =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
- publisher.sendPrepare(automationComposition, 0);
+ publisher.sendPrepare(automationComposition, 0, UUID.randomUUID());
verify(topicSink).send(anyString());
}
publisher.active(topicSink);
var automationComposition =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
- publisher.sendRevew(automationComposition);
+ publisher.sendReview(automationComposition, UUID.randomUUID());
verify(topicSink).send(anyString());
}
import org.onap.policy.clamp.acm.runtime.supervision.comm.ParticipantSyncPublisher;
import org.onap.policy.clamp.acm.runtime.util.CommonTestData;
import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
+import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElement;
import org.onap.policy.clamp.models.acm.concepts.DeployState;
import org.onap.policy.clamp.models.acm.concepts.LockState;
var phaseScanner = new PhaseScanner(automationCompositionProvider, mock(ParticipantSyncPublisher.class),
acStateChangePublisher, acDeployPublisher, acRuntimeParameterGroup, encryptionUtils);
- var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
- phaseScanner.scanWithPhase(automationComposition, serviceTemplate, new UpdateSync());
+ var acDefinition = new AutomationCompositionDefinition();
+ acDefinition.setServiceTemplate(InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML));
+ phaseScanner.scanWithPhase(automationComposition, acDefinition, new UpdateSync());
verify(automationCompositionProvider).updateAutomationComposition(any(AutomationComposition.class));
}
var phaseScanner = new PhaseScanner(automationCompositionProvider, mock(ParticipantSyncPublisher.class),
acStateChangePublisher, acDeployPublisher, acRuntimeParameterGroup, encryptionUtils);
- var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
- phaseScanner.scanWithPhase(automationComposition, serviceTemplate, new UpdateSync());
+ var acDefinition = new AutomationCompositionDefinition();
+ acDefinition.setServiceTemplate(InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML));
+ phaseScanner.scanWithPhase(automationComposition, acDefinition, new UpdateSync());
verify(automationCompositionProvider).deleteAutomationComposition(automationComposition.getInstanceId());
}
var automationCompositionProvider = mock(AutomationCompositionProvider.class);
when(automationCompositionProvider.updateAutomationComposition(any())).thenReturn(automationComposition);
- var acDeployPublisher = mock(AutomationCompositionDeployPublisher.class);
- var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
- var participantSyncPublisher = mock(ParticipantSyncPublisher.class);
var acRuntimeParameterGroup = CommonTestData.geParameterGroup("dbScanner");
acRuntimeParameterGroup.getParticipantParameters().setMaxOperationWaitMs(-1);
- var encryptionUtils = new EncryptionUtils(acRuntimeParameterGroup);
// verify timeout scenario
+ automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
+ automationComposition.setLastMsg(TimestampHelper.now());
+ var acDefinition = new AutomationCompositionDefinition();
+ acDefinition.setServiceTemplate(InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML));
+ var acDeployPublisher = mock(AutomationCompositionDeployPublisher.class);
+ var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
+ var encryptionUtils = new EncryptionUtils(acRuntimeParameterGroup);
+ var participantSyncPublisher = mock(ParticipantSyncPublisher.class);
var phaseScanner = new PhaseScanner(automationCompositionProvider, participantSyncPublisher,
acStateChangePublisher, acDeployPublisher, acRuntimeParameterGroup, encryptionUtils);
- automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
- automationComposition.setLastMsg(TimestampHelper.now());
- var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
- phaseScanner.scanWithPhase(automationComposition, serviceTemplate, new UpdateSync());
+ phaseScanner.scanWithPhase(automationComposition, acDefinition, new UpdateSync());
verify(automationCompositionProvider).updateAutomationComposition(any(AutomationComposition.class));
verify(participantSyncPublisher).sendSync(any(AutomationComposition.class));
assertEquals(StateChangeResult.TIMEOUT, automationComposition.getStateChangeResult());
//already in TIMEOUT
clearInvocations(automationCompositionProvider);
clearInvocations(participantSyncPublisher);
- phaseScanner.scanWithPhase(automationComposition, serviceTemplate, new UpdateSync());
+ phaseScanner.scanWithPhase(automationComposition, acDefinition, new UpdateSync());
verify(automationCompositionProvider, times(0)).updateAutomationComposition(any(AutomationComposition.class));
verify(participantSyncPublisher, times(0))
.sendSync(any(AutomationComposition.class));
for (Map.Entry<UUID, AutomationCompositionElement> entry : automationComposition.getElements().entrySet()) {
entry.getValue().setDeployState(DeployState.DEPLOYED);
}
- phaseScanner.scanWithPhase(automationComposition, serviceTemplate, new UpdateSync());
+ phaseScanner.scanWithPhase(automationComposition, acDefinition, new UpdateSync());
verify(automationCompositionProvider).updateAutomationComposition(any(AutomationComposition.class));
verify(participantSyncPublisher).sendSync(any(AutomationComposition.class));
assertEquals(StateChangeResult.NO_ERROR, automationComposition.getStateChangeResult());
var phaseScanner = new PhaseScanner(automationCompositionProvider, mock(ParticipantSyncPublisher.class),
acStateChangePublisher, acDeployPublisher, acRuntimeParameterGroup, encryptionUtils);
- var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
- phaseScanner.scanWithPhase(automationComposition, serviceTemplate, new UpdateSync());
+ var acDefinition = new AutomationCompositionDefinition();
+ acDefinition.setServiceTemplate(InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML));
+ phaseScanner.scanWithPhase(automationComposition, acDefinition, new UpdateSync());
- verify(acDeployPublisher).send(any(AutomationComposition.class), anyInt(), anyBoolean());
+ verify(acDeployPublisher).send(any(AutomationComposition.class), anyInt(), anyBoolean(), any(UUID.class));
}
@Test
mock(AutomationCompositionStateChangePublisher.class), acDeployPublisher,
acRuntimeParameterGroup, encryptionUtils);
- var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
- phaseScanner.scanWithPhase(automationComposition, serviceTemplate, new UpdateSync());
+ var acDefinition = new AutomationCompositionDefinition();
+ acDefinition.setServiceTemplate(InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML));
+ phaseScanner.scanWithPhase(automationComposition, acDefinition, new UpdateSync());
verify(acDeployPublisher, times(0))
- .send(any(AutomationComposition.class), anyInt(), anyBoolean());
+ .send(any(AutomationComposition.class), anyInt(), anyBoolean(), any(UUID.class));
}
@Test
var phaseScanner = new PhaseScanner(acProvider, mock(ParticipantSyncPublisher.class),
acStateChangePublisher, acDeployPublisher, acRuntimeParameterGroup, encryptionUtils);
- var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
- phaseScanner.scanWithPhase(automationComposition, serviceTemplate, new UpdateSync());
+ var acDefinition = new AutomationCompositionDefinition();
+ acDefinition.setServiceTemplate(InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML));
+ phaseScanner.scanWithPhase(automationComposition, acDefinition, new UpdateSync());
verify(acStateChangePublisher).send(any(AutomationComposition.class), anyInt(),
- anyBoolean());
+ anyBoolean(), any(UUID.class));
}
}
import org.onap.policy.clamp.acm.runtime.supervision.comm.ParticipantSyncPublisher;
import org.onap.policy.clamp.acm.runtime.util.CommonTestData;
import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
+import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
import org.onap.policy.clamp.models.acm.concepts.DeployState;
import org.onap.policy.clamp.models.acm.concepts.LockState;
import org.onap.policy.clamp.models.acm.concepts.SubState;
mock(AutomationCompositionMigrationPublisher.class), mock(AcPreparePublisher.class),
acRuntimeParameterGroup, encryptionUtils);
var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
- supervisionScanner.scanStage(automationComposition, serviceTemplate, new UpdateSync());
+ var acDefinition = new AutomationCompositionDefinition();
+ acDefinition.setServiceTemplate(serviceTemplate);
+ supervisionScanner.scanStage(automationComposition, acDefinition, new UpdateSync(), UUID.randomUUID());
verify(acProvider, times(0)).updateAutomationComposition(any(AutomationComposition.class));
assertEquals(DeployState.MIGRATING, automationComposition.getDeployState());
.get(element.getDefinition().getName());
toscaNodeTemplate.setProperties(Map.of("stage", List.of(1)));
- supervisionScanner.scanStage(automationComposition, serviceTemplate, new UpdateSync());
+ supervisionScanner.scanStage(automationComposition, acDefinition, new UpdateSync(), UUID.randomUUID());
verify(acProvider).updateAutomationComposition(any(AutomationComposition.class));
assertEquals(DeployState.MIGRATING, automationComposition.getDeployState());
// first element is migrated
clearInvocations(acProvider);
element.setDeployState(DeployState.DEPLOYED);
- supervisionScanner.scanStage(automationComposition, serviceTemplate, new UpdateSync());
+ supervisionScanner.scanStage(automationComposition, acDefinition, new UpdateSync(), UUID.randomUUID());
verify(acProvider).updateAutomationComposition(any(AutomationComposition.class));
assertEquals(DeployState.DEPLOYED, automationComposition.getDeployState());
mock(AutomationCompositionMigrationPublisher.class), mock(AcPreparePublisher.class),
acRuntimeParameterGroup, encryptionUtils);
var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
- supervisionScanner.scanStage(automationComposition, serviceTemplate, new UpdateSync());
+ var acDefinition = new AutomationCompositionDefinition();
+ acDefinition.setServiceTemplate(serviceTemplate);
+ supervisionScanner.scanStage(automationComposition, acDefinition, new UpdateSync(), UUID.randomUUID());
verify(acProvider, times(0)).updateAutomationComposition(any(AutomationComposition.class));
assertEquals(DeployState.MIGRATION_REVERTING, automationComposition.getDeployState());
.get(element.getDefinition().getName());
toscaNodeTemplate.setProperties(Map.of("stage", List.of(1)));
- supervisionScanner.scanStage(automationComposition, serviceTemplate, new UpdateSync());
+ supervisionScanner.scanStage(automationComposition, acDefinition, new UpdateSync(), UUID.randomUUID());
verify(acProvider).updateAutomationComposition(any(AutomationComposition.class));
assertEquals(DeployState.MIGRATION_REVERTING, automationComposition.getDeployState());
// first element is migrated
clearInvocations(acProvider);
element.setDeployState(DeployState.DEPLOYED);
- supervisionScanner.scanStage(automationComposition, serviceTemplate, new UpdateSync());
+ supervisionScanner.scanStage(automationComposition, acDefinition, new UpdateSync(), UUID.randomUUID());
verify(acProvider).updateAutomationComposition(any(AutomationComposition.class));
assertEquals(DeployState.DEPLOYED, automationComposition.getDeployState());
acRuntimeParameterGroup, encryptionUtils);
var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
- supervisionScanner.scanStage(automationComposition, serviceTemplate, new UpdateSync());
+ var acDefinition = new AutomationCompositionDefinition();
+ acDefinition.setServiceTemplate(serviceTemplate);
+ supervisionScanner.scanStage(automationComposition, acDefinition, new UpdateSync(), UUID.randomUUID());
verify(acProvider, times(0)).updateAutomationComposition(any(AutomationComposition.class));
assertEquals(SubState.PREPARING, automationComposition.getSubState());
var prepare = Map.of("prepare", List.of(1));
toscaNodeTemplate.setProperties(Map.of("stage", prepare));
- supervisionScanner.scanStage(automationComposition, serviceTemplate, new UpdateSync());
+ supervisionScanner.scanStage(automationComposition, acDefinition, new UpdateSync(), UUID.randomUUID());
verify(acProvider).updateAutomationComposition(any(AutomationComposition.class));
assertEquals(SubState.PREPARING, automationComposition.getSubState());
// first element is prepared
clearInvocations(acProvider);
element.setSubState(SubState.NONE);
- supervisionScanner.scanStage(automationComposition, serviceTemplate, new UpdateSync());
+ supervisionScanner.scanStage(automationComposition, acDefinition, new UpdateSync(), UUID.randomUUID());
verify(acProvider).updateAutomationComposition(any(AutomationComposition.class));
assertEquals(SubState.NONE, automationComposition.getSubState());
Code Review / policy / clamp.git / commitdiff