import java.util.UUID;
import java.util.stream.Collectors;
import lombok.AllArgsConstructor;
+import lombok.NonNull;
import org.onap.policy.clamp.acm.runtime.main.parameters.AcRuntimeParameterGroup;
import org.onap.policy.clamp.acm.runtime.participants.AcmParticipantProvider;
import org.onap.policy.clamp.acm.runtime.supervision.SupervisionAcHandler;
public InstantiationResponse updateDeployedAutomationComposition(UUID compositionId,
AutomationComposition automationComposition, AutomationComposition acToBeUpdated) {
+ if (automationComposition.getCompositionTargetId() != null
+ && !DeployState.DEPLOYED.equals(acToBeUpdated.getDeployState())) {
+ throw new PfModelRuntimeException(Response.Status.BAD_REQUEST,
+ "Not allowed to migrate in the state " + acToBeUpdated.getDeployState());
+ }
+
// Iterate and update the element property values
for (var dbAcElement : acToBeUpdated.getElements().entrySet()) {
var elementId = dbAcElement.getKey();
if (automationComposition.getRestarting() != null) {
throw new PfModelRuntimeException(Status.BAD_REQUEST, "There is a restarting process, Update not allowed");
}
- var validationResult = validateAutomationComposition(acToBeUpdated);
- if (!validationResult.isValid()) {
- throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, validationResult.getResult());
- }
- // Publish property update event to the participants
- supervisionAcHandler.update(acToBeUpdated);
+ if (automationComposition.getCompositionTargetId() != null) {
+ var validationResult =
+ validateAutomationComposition(acToBeUpdated, automationComposition.getCompositionTargetId());
+ if (!validationResult.isValid()) {
+ throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, validationResult.getResult());
+ }
+ acToBeUpdated.setCompositionTargetId(automationComposition.getCompositionTargetId());
+
+ // Publish migrate event to the participants
+ supervisionAcHandler.migrate(acToBeUpdated, automationComposition.getCompositionTargetId());
+ } else {
+ var validationResult = validateAutomationComposition(acToBeUpdated);
+ if (!validationResult.isValid()) {
+ throw new PfModelRuntimeException(Response.Status.BAD_REQUEST, validationResult.getResult());
+ }
+ // Publish property update event to the participants
+ supervisionAcHandler.update(acToBeUpdated);
+ }
automationComposition = automationCompositionProvider.updateAutomationComposition(acToBeUpdated);
var response = new InstantiationResponse();
return response;
}
+ private BeanValidationResult validateAutomationComposition(AutomationComposition automationComposition) {
+ return validateAutomationComposition(automationComposition, automationComposition.getCompositionId());
+ }
+
/**
* Validate AutomationComposition.
*
* @param automationComposition AutomationComposition to validate
+ * @param compositionId the composition id
* @return the result of validation
*/
- private BeanValidationResult validateAutomationComposition(AutomationComposition automationComposition) {
+ private BeanValidationResult validateAutomationComposition(AutomationComposition automationComposition,
+ UUID compositionId) {
var result = new BeanValidationResult("AutomationComposition", automationComposition);
- var acDefinitionOpt = acDefinitionProvider.findAcDefinition(automationComposition.getCompositionId());
+ var acDefinitionOpt = acDefinitionProvider.findAcDefinition(compositionId);
if (acDefinitionOpt.isEmpty()) {
- result.addResult(new ObjectValidationResult("ServiceTemplate", "", ValidationStatus.INVALID,
+ result.addResult(new ObjectValidationResult("ServiceTemplate", compositionId, ValidationStatus.INVALID,
"Commissioned automation composition definition not found"));
return result;
}
* @return the Automation Composition
*/
@Transactional(readOnly = true)
- public AutomationComposition getAutomationComposition(UUID compositionId, UUID instanceId) {
+ public AutomationComposition getAutomationComposition(@NonNull UUID compositionId, UUID instanceId) {
var automationComposition = automationCompositionProvider.getAutomationComposition(instanceId);
- if (!automationComposition.getCompositionId().equals(compositionId)) {
+ if (!compositionId.equals(automationComposition.getCompositionId())
+ && !compositionId.equals(automationComposition.getCompositionTargetId())) {
throw new PfModelRuntimeException(Response.Status.BAD_REQUEST,
automationComposition.getCompositionId() + DO_NOT_MATCH + compositionId);
}
throw new PfModelRuntimeException(Status.BAD_REQUEST, "There is a restarting process, Delete not allowed");
}
var acDefinition = acDefinitionProvider.getAcDefinition(automationComposition.getCompositionId());
- if (acDefinition != null) {
- var participantIds = acDefinition.getElementStateMap().values().stream()
- .map(NodeTemplateState::getParticipantId).collect(Collectors.toSet());
- acmParticipantProvider.verifyParticipantState(participantIds);
- }
+ var participantIds = acDefinition.getElementStateMap().values().stream()
+ .map(NodeTemplateState::getParticipantId).collect(Collectors.toSet());
+ acmParticipantProvider.verifyParticipantState(participantIds);
supervisionAcHandler.delete(automationComposition, acDefinition);
var response = new InstantiationResponse();
response.setInstanceId(automationComposition.getInstanceId());
import lombok.AllArgsConstructor;
import org.onap.policy.clamp.acm.runtime.supervision.comm.AcElementPropertiesPublisher;
import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionDeployPublisher;
+import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionMigrationPublisher;
import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionStateChangePublisher;
import org.onap.policy.clamp.models.acm.concepts.AcElementDeployAck;
import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
private final AutomationCompositionDeployPublisher automationCompositionDeployPublisher;
private final AutomationCompositionStateChangePublisher automationCompositionStateChangePublisher;
private final AcElementPropertiesPublisher acElementPropertiesPublisher;
+ private final AutomationCompositionMigrationPublisher acCompositionMigrationPublisher;
/**
* Handle Deploy an AutomationComposition instance.
return updated;
}
+
+ /**
+ * Handle Migration of an AutomationComposition instance to other ACM Definition.
+ *
+ * @param automationComposition the AutomationComposition
+ * @param compositionTargetId the ACM Definition Id
+ */
+ public void migrate(AutomationComposition automationComposition, UUID compositionTargetId) {
+ AcmUtils.setCascadedState(automationComposition, DeployState.MIGRATING, LockState.LOCKED);
+ automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
+ acCompositionMigrationPublisher.send(automationComposition, compositionTargetId);
+ }
}
LOGGER.debug("automation composition scan: transition from state {} to {} not completed",
automationComposition.getDeployState(), automationComposition.getLockState());
- if (DeployState.UPDATING.equals(automationComposition.getDeployState())) {
+ if (DeployState.UPDATING.equals(automationComposition.getDeployState())
+ || DeployState.MIGRATING.equals(automationComposition.getDeployState())) {
// UPDATING do not need phases
handleTimeout(automationComposition);
return;
private void complete(final AutomationComposition automationComposition) {
var deployState = automationComposition.getDeployState();
+ if (DeployState.MIGRATING.equals(automationComposition.getDeployState())) {
+ // migration scenario
+ automationComposition.setCompositionId(automationComposition.getCompositionTargetId());
+ automationComposition.setCompositionTargetId(null);
+ }
automationComposition.setDeployState(AcmUtils.deployCompleted(deployState));
automationComposition.setLockState(AcmUtils.lockCompleted(deployState, automationComposition.getLockState()));
if (StateChangeResult.TIMEOUT.equals(automationComposition.getStateChangeResult())) {
import io.micrometer.core.annotation.Timed;
import java.time.Instant;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
import java.util.UUID;
import lombok.AllArgsConstructor;
-import org.onap.policy.clamp.models.acm.concepts.AcElementDeploy;
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.dmaap.participant.PropertiesUpdate;
import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
import org.onap.policy.clamp.models.acm.utils.AcmUtils;
*
* @param automationComposition the AutomationComposition
*/
- @Timed(value = "publisher.properties_update",
- description = "AC Element Properties Update published")
+ @Timed(value = "publisher.properties_update", description = "AC Element Properties Update published")
public void send(AutomationComposition automationComposition) {
- Map<UUID, List<AcElementDeploy>> map = new HashMap<>();
- for (var element : automationComposition.getElements().values()) {
- var acElementDeploy = AcmUtils.createAcElementDeploy(element, DeployOrder.UPDATE);
- map.putIfAbsent(element.getParticipantId(), new ArrayList<>());
- map.get(element.getParticipantId()).add(acElementDeploy);
- }
- List<ParticipantDeploy> participantDeploys = new ArrayList<>();
- for (var entry : map.entrySet()) {
- var participantDeploy = new ParticipantDeploy();
- participantDeploy.setParticipantId(entry.getKey());
- participantDeploy.setAcElementList(entry.getValue());
- participantDeploys.add(participantDeploy);
- }
-
var propertiesUpdate = new PropertiesUpdate();
propertiesUpdate.setCompositionId(automationComposition.getCompositionId());
propertiesUpdate.setAutomationCompositionId(automationComposition.getInstanceId());
propertiesUpdate.setMessageId(UUID.randomUUID());
propertiesUpdate.setTimestamp(Instant.now());
- propertiesUpdate.setParticipantUpdatesList(participantDeploys);
+ propertiesUpdate.setParticipantUpdatesList(
+ AcmUtils.createParticipantDeployList(automationComposition, DeployOrder.UPDATE));
LOGGER.debug("AC Element properties update sent {}", propertiesUpdate);
super.send(propertiesUpdate);
--- /dev/null
+/*-
+ * ============LICENSE_START=======================================================
+ * Copyright (C) 2023 Nordix Foundation.
+ * ================================================================================
+ * 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 io.micrometer.core.annotation.Timed;
+import java.util.UUID;
+import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
+import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionMigration;
+import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
+import org.onap.policy.clamp.models.acm.utils.AcmUtils;
+import org.springframework.stereotype.Component;
+
+@Component
+public class AutomationCompositionMigrationPublisher
+ extends AbstractParticipantPublisher<AutomationCompositionMigration> {
+
+ /**
+ * Send AutomationCompositionMigration message to Participant.
+ *
+ * @param automationComposition the AutomationComposition
+ * @param compositionTargetId the Composition Definition Target
+ */
+ @Timed(
+ value = "publisher.automation_composition_migration",
+ description = "AUTOMATION_COMPOSITION_MIGRATION messages published")
+ public void send(AutomationComposition automationComposition, UUID compositionTargetId) {
+ var acsc = new AutomationCompositionMigration();
+ acsc.setCompositionId(automationComposition.getCompositionId());
+ acsc.setAutomationCompositionId(automationComposition.getInstanceId());
+ acsc.setMessageId(UUID.randomUUID());
+ acsc.setCompositionTargetId(compositionTargetId);
+ acsc.setParticipantUpdatesList(
+ AcmUtils.createParticipantDeployList(automationComposition, DeployOrder.MIGRATE));
+
+ super.send(acsc);
+ }
+}
post:
tags:
- Automation Composition Instance
- summary: Create or Update automation composition instance
- description: Creates or updates an automation composition instance that uses the specified automation composition definition. The ID of the created
+ summary: Create, Update or Migrate an automation composition instance
+ description: Create, Update or Migrate an automation composition instance that uses the specified automation composition definition. The ID of the created
automation composition instance is returned. In the case of an update, the instanceId should be included in the request body.
+ In the case of a migrate, the instanceId and the compositionTargetId should be included in the request body.
operationId: createCompositionInstance
parameters:
- name : compositionId
+ " \"entry org.onap.domain.pmsh.PMSH_MonitoringPolicyAutomationCompositionElement\""
+ " INVALID, Not found\n";
private static final String AC_DEFINITION_NOT_FOUND = "\"AutomationComposition\" INVALID, item has status INVALID\n"
- + " item \"ServiceTemplate\" value \"\" INVALID,"
+ + " item \"ServiceTemplate\" value \"%s\" INVALID,"
+ " Commissioned automation composition definition not found\n";
private static final String DO_NOT_MATCH = " do not match with ";
}
@Test
- void testInstantiationCrud() throws AutomationCompositionException {
+ void testInstantiationCrud() {
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 acProvider = mock(AutomationCompositionProvider.class);
var supervisionAcHandler = mock(SupervisionAcHandler.class);
var acmParticipantProvider = mock(AcmParticipantProvider.class);
() -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
.hasMessageMatching(
"Not allowed to update in the state " + automationCompositionUpdate.getDeployState());
+
+ automationCompositionUpdate.setDeployState(DeployState.UPDATING);
+ automationCompositionUpdate.setLockState(LockState.LOCKED);
+ automationCompositionUpdate.setCompositionTargetId(UUID.randomUUID());
+ assertThatThrownBy(
+ () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
+ .hasMessageMatching(
+ "Not allowed to migrate in the state " + automationCompositionUpdate.getDeployState());
}
@Test
+ " There is a restarting process in composition\n");
}
+ @Test
+ void testInstantiationMigration() {
+ var acDefinitionProvider = mock(AcDefinitionProvider.class);
+ var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
+ var compositionId = acDefinition.getCompositionId();
+ when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
+
+ var automationComposition =
+ InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
+ automationComposition.setCompositionId(compositionId);
+ automationComposition.setDeployState(DeployState.DEPLOYED);
+ automationComposition.setLockState(LockState.LOCKED);
+ automationComposition.setCompositionTargetId(UUID.randomUUID());
+ var acProvider = mock(AutomationCompositionProvider.class);
+ when(acProvider.getAutomationComposition(automationComposition.getInstanceId()))
+ .thenReturn(automationComposition);
+ when(acProvider.updateAutomationComposition(automationComposition)).thenReturn(automationComposition);
+
+ var supervisionAcHandler = mock(SupervisionAcHandler.class);
+ var acmParticipantProvider = mock(AcmParticipantProvider.class);
+ var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
+ null, supervisionAcHandler, acmParticipantProvider, new AcRuntimeParameterGroup());
+
+ 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));
+
+ automationComposition.setCompositionTargetId(compositionTargetId);
+
+ var instantiationResponse = instantiationProvider
+ .updateAutomationComposition(automationComposition.getCompositionId(), automationComposition);
+
+ verify(supervisionAcHandler).migrate(any(), any());
+ verify(acProvider).updateAutomationComposition(automationComposition);
+ InstantiationUtils.assertInstantiationResponse(instantiationResponse, automationComposition);
+ }
+
@Test
void testInstantiationDelete() {
var automationComposition =
automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
var acProvider = mock(AutomationCompositionProvider.class);
var acDefinitionProvider = mock(AcDefinitionProvider.class);
+ var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
+ var compositionId = acDefinition.getCompositionId();
+ when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
+ automationComposition.setCompositionId(compositionId);
var supervisionAcHandler = mock(SupervisionAcHandler.class);
var acmParticipantProvider = mock(AcmParticipantProvider.class);
var acRuntimeParameterGroup = mock(AcRuntimeParameterGroup.class);
var wrongCompositionId = UUID.randomUUID();
var instanceId = automationComposition.getInstanceId();
- var compositionId = automationComposition.getCompositionId();
assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(wrongCompositionId, instanceId))
.hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
var compositionId = automationComposition.getCompositionId();
assertThatThrownBy(() -> provider.createAutomationComposition(compositionId, automationComposition))
- .hasMessageMatching(AC_DEFINITION_NOT_FOUND);
+ .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionId));
assertThatThrownBy(() -> provider.updateAutomationComposition(compositionId, automationComposition))
- .hasMessageMatching(AC_DEFINITION_NOT_FOUND);
+ .hasMessageMatching(String.format(AC_DEFINITION_NOT_FOUND, compositionId));
}
@Test
assertThatThrownBy(() -> provider.compositionInstanceState(wrongCompositionId,
automationComposition.getInstanceId(), new AcInstanceStateUpdate()))
.hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
+
+ var compositionTargetId = UUID.randomUUID();
+ automationComposition.setCompositionTargetId(compositionTargetId);
+ assertThatThrownBy(
+ () -> provider.getAutomationComposition(wrongCompositionId, automationComposition.getInstanceId()))
+ .hasMessageMatching(compositionId + DO_NOT_MATCH + wrongCompositionId);
+
+ var result = provider.getAutomationComposition(compositionTargetId, automationComposition.getInstanceId());
+ assertThat(result).isNotNull();
}
@Test
import org.onap.policy.clamp.acm.runtime.instantiation.InstantiationUtils;
import org.onap.policy.clamp.acm.runtime.supervision.comm.AcElementPropertiesPublisher;
import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionDeployPublisher;
+import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionMigrationPublisher;
import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionStateChangePublisher;
import org.onap.policy.clamp.acm.runtime.util.CommonTestData;
import org.onap.policy.clamp.models.acm.concepts.AcElementDeployAck;
var handler = new SupervisionAcHandler(automationCompositionProvider,
mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
- mock(AcElementPropertiesPublisher.class));
+ mock(AcElementPropertiesPublisher.class), null);
var automationCompositionAckMessage =
getAutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK,
var handler = new SupervisionAcHandler(automationCompositionProvider,
mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
- mock(AcElementPropertiesPublisher.class));
+ mock(AcElementPropertiesPublisher.class), null);
handler.handleAutomationCompositionUpdateAckMessage(automationCompositionAckMessage);
var automationCompositionStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
var handler = new SupervisionAcHandler(automationCompositionProvider,
- mock(AutomationCompositionDeployPublisher.class), automationCompositionStateChangePublisher, null);
+ mock(AutomationCompositionDeployPublisher.class), automationCompositionStateChangePublisher, null,
+ null);
handler.handleAutomationCompositionUpdateAckMessage(automationCompositionAckMessage);
var automationCompositionDeployPublisher = mock(AutomationCompositionDeployPublisher.class);
var automationCompositionProvider = mock(AutomationCompositionProvider.class);
var handler = new SupervisionAcHandler(automationCompositionProvider, automationCompositionDeployPublisher,
- mock(AutomationCompositionStateChangePublisher.class), mock(AcElementPropertiesPublisher.class));
+ mock(AutomationCompositionStateChangePublisher.class), mock(AcElementPropertiesPublisher.class), null);
var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
var handler = new SupervisionAcHandler(automationCompositionProvider,
mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
- mock(AcElementPropertiesPublisher.class));
+ mock(AcElementPropertiesPublisher.class), null);
var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var automationComposition =
var automationCompositionProvider = mock(AutomationCompositionProvider.class);
var handler = new SupervisionAcHandler(automationCompositionProvider,
mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
- mock(AcElementPropertiesPublisher.class));
+ mock(AcElementPropertiesPublisher.class), null);
var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
var handler = new SupervisionAcHandler(automationCompositionProvider,
mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
- mock(AcElementPropertiesPublisher.class));
+ mock(AcElementPropertiesPublisher.class), null);
var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var automationComposition =
var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
var handler = new SupervisionAcHandler(automationCompositionProvider,
mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
- mock(AcElementPropertiesPublisher.class));
+ mock(AcElementPropertiesPublisher.class), null);
var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var automationComposition =
var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
var handler = new SupervisionAcHandler(automationCompositionProvider,
mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
- mock(AcElementPropertiesPublisher.class));
+ mock(AcElementPropertiesPublisher.class), null);
var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var automationComposition =
var acStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
var handler = new SupervisionAcHandler(automationCompositionProvider,
mock(AutomationCompositionDeployPublisher.class), acStateChangePublisher,
- mock(AcElementPropertiesPublisher.class));
+ mock(AcElementPropertiesPublisher.class), null);
var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
var automationComposition =
var handler = new SupervisionAcHandler(automationCompositionProvider,
mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
- mock(AcElementPropertiesPublisher.class));
+ mock(AcElementPropertiesPublisher.class), null);
handler.handleAutomationCompositionUpdateAckMessage(automationCompositionAckMessage);
var acElementPropertiesPublisher = mock(AcElementPropertiesPublisher.class);
var handler = new SupervisionAcHandler(mock(AutomationCompositionProvider.class),
mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
- acElementPropertiesPublisher);
+ acElementPropertiesPublisher, null);
var automationComposition =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Lock");
handler.update(automationComposition);
verify(acElementPropertiesPublisher).send(any(AutomationComposition.class));
}
+
+ @Test
+ void testMigrate() {
+ var automationCompositionProvider = mock(AutomationCompositionProvider.class);
+ var acCompositionMigrationPublisher = mock(AutomationCompositionMigrationPublisher.class);
+ var handler = new SupervisionAcHandler(automationCompositionProvider, null, null, null,
+ acCompositionMigrationPublisher);
+ var automationComposition =
+ InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Migrate");
+ handler.migrate(automationComposition, UUID.randomUUID());
+ verify(acCompositionMigrationPublisher).send(any(AutomationComposition.class), any());
+ }
}
package org.onap.policy.clamp.acm.runtime.supervision;
+import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyInt;
automationCompositionStateChangePublisher, automationCompositionDeployPublisher,
acRuntimeParameterGroup);
+ automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
scannerObj2.run();
verify(automationCompositionProvider, times(1)).updateAutomationComposition(any(AutomationComposition.class));
+ assertEquals(StateChangeResult.TIMEOUT, automationComposition.getStateChangeResult());
+ for (Map.Entry<UUID, AutomationCompositionElement> entry : automationComposition.getElements().entrySet()) {
+ entry.getValue().setDeployState(DeployState.DEPLOYED);
+ }
+ scannerObj2.run();
+ assertEquals(StateChangeResult.NO_ERROR, automationComposition.getStateChangeResult());
}
@Test
- void testSendAutomationCompositionMsgUpdate() {
+ void testSendAutomationCompositionMsgStartPhase() {
var automationComposition = InstantiationUtils.getAutomationCompositionFromResource(AC_JSON, "Crud");
automationComposition.setDeployState(DeployState.DEPLOYING);
automationComposition.setLockState(LockState.NONE);
any(ToscaServiceTemplate.class), anyInt(), anyBoolean());
}
+ @Test
+ void testSendAutomationCompositionMigrate() {
+ var automationComposition = InstantiationUtils.getAutomationCompositionFromResource(AC_JSON, "Crud");
+ automationComposition.setDeployState(DeployState.MIGRATING);
+ var compositionTargetId = UUID.randomUUID();
+ automationComposition.setCompositionTargetId(compositionTargetId);
+ automationComposition.setLockState(LockState.LOCKED);
+ for (var element : automationComposition.getElements().values()) {
+ element.setDeployState(DeployState.DEPLOYED);
+ element.setLockState(LockState.LOCKED);
+ }
+
+ var automationCompositionProvider = mock(AutomationCompositionProvider.class);
+ when(automationCompositionProvider.getAcInstancesByCompositionId(compositionId))
+ .thenReturn(List.of(automationComposition));
+
+ var automationCompositionDeployPublisher = mock(AutomationCompositionDeployPublisher.class);
+ var automationCompositionStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
+ var acRuntimeParameterGroup = CommonTestData.geParameterGroup("dbScanner");
+
+ var supervisionScanner = new SupervisionScanner(automationCompositionProvider, createAcDefinitionProvider(),
+ automationCompositionStateChangePublisher, automationCompositionDeployPublisher,
+ acRuntimeParameterGroup);
+
+ supervisionScanner.run();
+ verify(automationCompositionProvider, times(1)).updateAutomationComposition(any(AutomationComposition.class));
+ assertEquals(DeployState.DEPLOYED, automationComposition.getDeployState());
+ assertEquals(compositionTargetId, automationComposition.getCompositionId());
+ }
+
@Test
void testSendAutomationCompositionMsgUnlocking() {
var automationComposition = InstantiationUtils.getAutomationCompositionFromResource(AC_JSON, "Crud");
verify(topicSink).send(anyString());
}
+ @Test
+ void testAutomationCompositionMigrationPublisher() {
+ var publisher = new AutomationCompositionMigrationPublisher();
+ var topicSink = mock(TopicSink.class);
+ publisher.active(List.of(topicSink));
+ var automationComposition =
+ InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
+ publisher.send(automationComposition, UUID.randomUUID());
+ verify(topicSink).send(anyString());
+ }
+
@Test
void testParticipantRestartPublisher() {
var publisher = new ParticipantRestartPublisher(CommonTestData.getTestParamaterGroup());
acStateChangeAckListener.onTopicEvent(INFRA, TOPIC, null, automationCompositionAck);
verify(supervisionHandler).handleAutomationCompositionStateChangeAckMessage(automationCompositionAck);
}
-
}
Code Review / policy / clamp.git / commitdiff