private UUID compositionTargetId;
- private Boolean restarting;
-
private Boolean precheck;
@NonNull
this.instanceId = otherAutomationComposition.instanceId;
this.compositionId = otherAutomationComposition.compositionId;
this.compositionTargetId = otherAutomationComposition.compositionTargetId;
- this.restarting = otherAutomationComposition.restarting;
this.precheck = otherAutomationComposition.precheck;
this.deployState = otherAutomationComposition.deployState;
this.lockState = otherAutomationComposition.lockState;
@NonNull
private ToscaServiceTemplate serviceTemplate;
- private Boolean restarting;
-
@NonNull
private AcTypeState state;
public AutomationCompositionDefinition(final AutomationCompositionDefinition otherAcmDefinition) {
this.compositionId = otherAcmDefinition.compositionId;
this.serviceTemplate = new ToscaServiceTemplate(otherAcmDefinition.serviceTemplate);
- this.restarting = otherAcmDefinition.restarting;
this.state = otherAcmDefinition.state;
this.lastMsg = otherAcmDefinition.lastMsg;
this.elementStateMap = PfUtils.mapMap(otherAcmDefinition.elementStateMap, NodeTemplateState::new);
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * Copyright (C) 2023-2024 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.models.acm.messages.kafka.participant;
-
-import java.util.ArrayList;
-import java.util.List;
-import lombok.Getter;
-import lombok.Setter;
-import lombok.ToString;
-import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
-import org.onap.policy.clamp.models.acm.concepts.ParticipantDefinition;
-import org.onap.policy.clamp.models.acm.concepts.ParticipantRestartAc;
-import org.onap.policy.models.base.PfUtils;
-
-@Getter
-@Setter
-@ToString(callSuper = true)
-public class ParticipantRestart extends ParticipantMessage {
-
- // composition state
- private AcTypeState state;
-
- // element definition
- private List<ParticipantDefinition> participantDefinitionUpdates = new ArrayList<>();
-
- // automation composition instances list
- private List<ParticipantRestartAc> automationcompositionList = new ArrayList<>();
-
- /**
- * Constructor.
- */
- public ParticipantRestart() {
- super(ParticipantMessageType.PARTICIPANT_RESTART);
- }
-
- /**
- * Constructor with message type.
- * @param messageType messageType
- */
- public ParticipantRestart(ParticipantMessageType messageType) {
- super(messageType);
- }
-
- /**
- * Constructs the object, making a deep copy.
- *
- * @param source source from which to copy
- */
- public ParticipantRestart(ParticipantRestart source) {
- super(source);
- this.state = source.state;
- this.participantDefinitionUpdates =
- PfUtils.mapList(source.participantDefinitionUpdates, ParticipantDefinition::new);
- this.automationcompositionList = PfUtils.mapList(source.automationcompositionList, ParticipantRestartAc::new);
- }
-}
package org.onap.policy.clamp.models.acm.messages.kafka.participant;
+import java.util.ArrayList;
import java.util.HashSet;
+import java.util.List;
import java.util.Set;
import java.util.UUID;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
+import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
+import org.onap.policy.clamp.models.acm.concepts.ParticipantDefinition;
+import org.onap.policy.clamp.models.acm.concepts.ParticipantRestartAc;
+import org.onap.policy.models.base.PfUtils;
@Getter
@Setter
@ToString(callSuper = true)
-public class ParticipantSync extends ParticipantRestart {
+public class ParticipantSync extends ParticipantMessage {
+
+ // composition state
+ private AcTypeState state;
+
+ // element definition
+ private List<ParticipantDefinition> participantDefinitionUpdates = new ArrayList<>();
+
+ // automation composition instances list
+ private List<ParticipantRestartAc> automationcompositionList = new ArrayList<>();
private Set<UUID> excludeReplicas = new HashSet<>();
private boolean restarting = false;
*/
public ParticipantSync(ParticipantSync source) {
super(source);
+ this.state = source.state;
+ this.participantDefinitionUpdates =
+ PfUtils.mapList(source.participantDefinitionUpdates, ParticipantDefinition::new);
+ this.automationcompositionList = PfUtils.mapList(source.automationcompositionList, ParticipantRestartAc::new);
this.excludeReplicas = new HashSet<>(source.excludeReplicas);
this.restarting = source.restarting;
this.delete = source.delete;
@Column
private String compositionTargetId;
- @Column
- private Boolean restarting;
-
@Column
@NotNull
private DeployState deployState;
this.version = copyConcept.version;
this.compositionId = copyConcept.compositionId;
this.compositionTargetId = copyConcept.compositionTargetId;
- this.restarting = copyConcept.restarting;
this.deployState = copyConcept.deployState;
this.lockState = copyConcept.lockState;
this.lastMsg = copyConcept.lastMsg;
if (compositionTargetId != null) {
automationComposition.setCompositionTargetId(UUID.fromString(compositionTargetId));
}
- automationComposition.setRestarting(restarting);
automationComposition.setDeployState(deployState);
automationComposition.setLockState(lockState);
automationComposition.setLastMsg(lastMsg.toString());
if (automationComposition.getCompositionTargetId() != null) {
this.compositionTargetId = automationComposition.getCompositionTargetId().toString();
}
- this.restarting = automationComposition.getRestarting();
this.deployState = automationComposition.getDeployState();
this.lockState = automationComposition.getLockState();
this.lastMsg = TimestampHelper.toTimestamp(automationComposition.getLastMsg());
return result;
}
- result = ObjectUtils.compare(restarting, other.restarting);
- if (result != 0) {
- return result;
- }
-
result = ObjectUtils.compare(deployState, other.deployState);
if (result != 0) {
return result;
@Pattern(regexp = PfKey.VERSION_REGEXP)
private String version;
- @Column
- private Boolean restarting;
-
@Column
@NotNull
private AcTypeState state;
public AutomationCompositionDefinition toAuthorative() {
var acmDefinition = new AutomationCompositionDefinition();
acmDefinition.setCompositionId(UUID.fromString(this.compositionId));
- acmDefinition.setRestarting(this.restarting);
acmDefinition.setState(this.state);
acmDefinition.setStateChangeResult(this.stateChangeResult);
acmDefinition.setLastMsg(this.lastMsg.toString());
@Override
public void fromAuthorative(final AutomationCompositionDefinition copyConcept) {
this.compositionId = copyConcept.getCompositionId().toString();
- this.restarting = copyConcept.getRestarting();
this.state = copyConcept.getState();
this.stateChangeResult = copyConcept.getStateChangeResult();
this.lastMsg = TimestampHelper.toTimestamp(copyConcept.getLastMsg());
* @param compositionId The UUID of the automation composition definition to update
* @param state the AcTypeState
* @param stateChangeResult the StateChangeResult
- * @param restarting restarting process
*/
- public void updateAcDefinitionState(UUID compositionId, AcTypeState state, StateChangeResult stateChangeResult,
- Boolean restarting) {
+ public void updateAcDefinitionState(UUID compositionId, AcTypeState state, StateChangeResult stateChangeResult) {
var jpaUpdate = acmDefinitionRepository.findById(compositionId.toString());
if (jpaUpdate.isEmpty()) {
String errorMessage = "update of Automation Composition Definition \"" + compositionId
var acDefinition = jpaUpdate.get();
acDefinition.setState(state);
acDefinition.setStateChangeResult(stateChangeResult);
- acDefinition.setRestarting(restarting);
acmDefinitionRepository.save(acDefinition);
acmDefinitionRepository.flush();
}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * Copyright (C) 2023-2024 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.models.acm.messages.kafka.participant;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantMessageUtils.assertSerializable;
-import static org.onap.policy.clamp.models.acm.messages.kafka.participant.ParticipantMessageUtils.removeVariableFields;
-
-import java.time.Instant;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-import org.junit.jupiter.api.Test;
-import org.onap.policy.clamp.models.acm.concepts.AcElementRestart;
-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.ParticipantDefinition;
-import org.onap.policy.clamp.models.acm.concepts.ParticipantRestartAc;
-import org.onap.policy.clamp.models.acm.utils.CommonTestData;
-import org.onap.policy.common.utils.coder.CoderException;
-import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
-
-class ParticipantRestartTest {
-
- @Test
- void testCopyConstructor() throws CoderException {
-
- final var orig = new ParticipantRestart();
- // verify with null values
- assertEquals(removeVariableFields(orig.toString()),
- removeVariableFields(new ParticipantRestart(orig).toString()));
-
- orig.setMessageId(UUID.randomUUID());
- orig.setCompositionId(UUID.randomUUID());
- orig.setTimestamp(Instant.ofEpochMilli(3000));
- orig.setParticipantId(CommonTestData.getParticipantId());
-
- var participantDefinitionUpdate = new ParticipantDefinition();
- var type = new ToscaConceptIdentifier("id", "1.2.3");
- var acDefinition = CommonTestData.getAcElementDefinition(type);
- participantDefinitionUpdate.setAutomationCompositionElementDefinitionList(List.of(acDefinition));
- orig.setParticipantDefinitionUpdates(List.of(participantDefinitionUpdate));
-
- var acElement = new AcElementRestart();
- acElement.setId(UUID.randomUUID());
- var id = new ToscaConceptIdentifier("id", "1.2.3");
- acElement.setDefinition(id);
- acElement.setDeployState(DeployState.DEPLOYED);
- acElement.setLockState(LockState.LOCKED);
- acElement.setOperationalState("OperationalState");
- acElement.setUseState("UseState");
- acElement.setProperties(Map.of("key", "value"));
- acElement.setOutProperties(Map.of("keyOut", "valueOut"));
-
- var acRestart = new ParticipantRestartAc();
- acRestart.setAcElementList(List.of(acElement));
- acRestart.setAutomationCompositionId(UUID.randomUUID());
-
- orig.setAutomationcompositionList(List.of(acRestart));
-
- assertEquals(removeVariableFields(orig.toString()),
- removeVariableFields(new ParticipantRestart(orig).toString()));
-
- assertSerializable(orig, ParticipantRestart.class);
- }
-}
jpaAutomationComposition.setDescription(null);
assertEquals(0, jpaAutomationComposition.compareTo(otherJpaAutomationComposition));
- jpaAutomationComposition.setRestarting(true);
- assertNotEquals(0, jpaAutomationComposition.compareTo(otherJpaAutomationComposition));
- jpaAutomationComposition.setRestarting(null);
- assertEquals(0, jpaAutomationComposition.compareTo(otherJpaAutomationComposition));
-
jpaAutomationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
assertNotEquals(0, jpaAutomationComposition.compareTo(otherJpaAutomationComposition));
jpaAutomationComposition.setStateChangeResult(null);
.hasMessageStartingWith("\"AutomationCompositionDefinition\" INVALID, item has status INVALID");
assertThatThrownBy(() -> acDefinitionProvider.updateAcDefinitionState(compositionId, AcTypeState.PRIMED,
- StateChangeResult.NO_ERROR, false))
+ StateChangeResult.NO_ERROR))
.hasMessageStartingWith("update of Automation Composition Definition");
}
when(acmDefinitionRepository.findById(acmDefinition.getCompositionId().toString()))
.thenReturn(Optional.of(jpa));
acDefinitionProvider.updateAcDefinitionState(acmDefinition.getCompositionId(), AcTypeState.PRIMED,
- StateChangeResult.NO_ERROR, false);
+ StateChangeResult.NO_ERROR);
verify(acmDefinitionRepository).save(jpa);
}
throw new PfModelRuntimeException(Status.BAD_REQUEST, "There are instances, Priming/Depriming not allowed");
}
var acmDefinition = acDefinitionProvider.getAcDefinition(compositionId);
- if (acmDefinition.getRestarting() != null) {
- throw new PfModelRuntimeException(Status.BAD_REQUEST,
- "There is a restarting process, Priming/Depriming not allowed");
- }
var stateOrdered = acTypeStateResolver.resolve(acTypeStateUpdate.getPrimeOrder(), acmDefinition.getState(),
acmDefinition.getStateChangeResult());
switch (stateOrdered) {
}
- if (automationComposition.getRestarting() != null) {
- throw new PfModelRuntimeException(Status.BAD_REQUEST, "There is a restarting process, Update not allowed");
- }
-
var deployOrder = DeployOrder.UPDATE;
var subOrder = SubOrder.NONE;
ValidationStatus.INVALID, "Commissioned automation composition definition not primed"));
return result;
}
- if (acDefinitionOpt.get().getRestarting() != null) {
- result.addResult(
- new ObjectValidationResult("ServiceTemplate.restarting", acDefinitionOpt.get().getRestarting(),
- ValidationStatus.INVALID, "There is a restarting process in composition"));
- return result;
- }
var participantIds = acDefinitionOpt.get().getElementStateMap().values().stream()
.map(NodeTemplateState::getParticipantId).collect(Collectors.toSet());
throw new PfModelRuntimeException(Status.BAD_REQUEST,
"Automation composition state is still " + automationComposition.getDeployState());
}
- if (automationComposition.getRestarting() != null) {
- throw new PfModelRuntimeException(Status.BAD_REQUEST, "There is a restarting process, Delete not allowed");
- }
var acDefinition = acDefinitionProvider.getAcDefinition(automationComposition.getCompositionId());
var participantIds = acDefinition.getElementStateMap().values().stream()
.map(NodeTemplateState::getParticipantId).collect(Collectors.toSet());
}
if (toUpdate) {
acDefinitionProvider.updateAcDefinitionState(acDefinition.getCompositionId(), acDefinition.getState(),
- acDefinition.getStateChangeResult(), null);
+ acDefinition.getStateChangeResult());
if (!participantPrimeAckMessage.getParticipantId().equals(participantPrimeAckMessage.getReplicaId())) {
participantSyncPublisher.sendSync(acDefinition, participantPrimeAckMessage.getReplicaId());
}
import org.onap.policy.clamp.acm.runtime.main.parameters.AcRuntimeParameterGroup;
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.ParticipantRestartPublisher;
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.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.StateChangeResult;
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.ParticipantStatus;
private final ParticipantDeregisterAckPublisher participantDeregisterAckPublisher;
private final AutomationCompositionProvider automationCompositionProvider;
private final AcDefinitionProvider acDefinitionProvider;
- private final ParticipantRestartPublisher participantRestartPublisher;
private final ParticipantSyncPublisher participantSyncPublisher;
private final AcRuntimeParameterGroup acRuntimeParameterGroup;
private void handleRestart(UUID participantId, UUID replicaId) {
var compositionIds = participantProvider.getCompositionIds(participantId);
- var oldParticipant = participantId.equals(replicaId);
for (var compositionId : compositionIds) {
var acDefinition = acDefinitionProvider.getAcDefinition(compositionId);
LOGGER.debug("Scan Composition {} for restart", acDefinition.getCompositionId());
- if (oldParticipant) {
- handleRestart(participantId, acDefinition);
- } else {
- handleSyncRestart(participantId, replicaId, acDefinition);
- }
- }
- }
-
- private void handleRestart(final UUID participantId, AutomationCompositionDefinition acDefinition) {
- if (AcTypeState.COMMISSIONED.equals(acDefinition.getState())) {
- LOGGER.debug("Composition {} COMMISSIONED", acDefinition.getCompositionId());
- return;
- }
- LOGGER.debug("Composition to be send in Restart message {}", acDefinition.getCompositionId());
- for (var elementState : acDefinition.getElementStateMap().values()) {
- if (participantId.equals(elementState.getParticipantId())) {
- elementState.setRestarting(true);
- }
- }
- // expected final state
- if (StateChangeResult.TIMEOUT.equals(acDefinition.getStateChangeResult())) {
- acDefinition.setStateChangeResult(StateChangeResult.NO_ERROR);
- }
- acDefinition.setRestarting(true);
- acDefinitionProvider.updateAcDefinition(acDefinition,
- acRuntimeParameterGroup.getAcmParameters().getToscaCompositionName());
-
- var automationCompositionList =
- automationCompositionProvider.getAcInstancesByCompositionId(acDefinition.getCompositionId());
- var automationCompositions = automationCompositionList.stream()
- .filter(ac -> isAcToBeRestarted(participantId, ac)).toList();
- participantRestartPublisher.send(participantId, acDefinition, automationCompositions);
- }
-
- private boolean isAcToBeRestarted(UUID participantId, AutomationComposition automationComposition) {
- boolean toAdd = false;
- for (var element : automationComposition.getElements().values()) {
- if (participantId.equals(element.getParticipantId())) {
- element.setRestarting(true);
- toAdd = true;
- }
- }
- if (toAdd) {
- automationComposition.setRestarting(true);
- // expected final state
- if (StateChangeResult.TIMEOUT.equals(automationComposition.getStateChangeResult())) {
- automationComposition.setStateChangeResult(StateChangeResult.NO_ERROR);
- }
- automationCompositionProvider.updateAutomationComposition(automationComposition);
+ handleSyncRestart(participantId, replicaId, acDefinition);
}
- return toAdd;
}
private void handleSyncRestart(final UUID participantId, UUID replicaId,
}
if (completed) {
acDefinitionProvider.updateAcDefinitionState(acDefinition.getCompositionId(), finalState,
- StateChangeResult.NO_ERROR, null);
+ StateChangeResult.NO_ERROR);
participantSyncPublisher.sendSync(acDefinition, null);
} else {
handleTimeout(acDefinition);
LOGGER.debug("Report timeout for the ac definition {}", acDefinition.getCompositionId());
acDefinition.setStateChangeResult(StateChangeResult.TIMEOUT);
acDefinitionProvider.updateAcDefinitionState(acDefinition.getCompositionId(),
- acDefinition.getState(), acDefinition.getStateChangeResult(), acDefinition.getRestarting());
+ acDefinition.getState(), acDefinition.getStateChangeResult());
}
}
+++ /dev/null
-/*-
- * ============LICENSE_START=======================================================
- * Copyright (C) 2023-2024 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.time.Instant;
-import java.util.List;
-import java.util.UUID;
-import lombok.AllArgsConstructor;
-import org.onap.policy.clamp.acm.runtime.main.parameters.AcRuntimeParameterGroup;
-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.messages.kafka.participant.ParticipantRestart;
-import org.onap.policy.clamp.models.acm.utils.AcmUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.stereotype.Component;
-
-@Component
-@AllArgsConstructor
-public class ParticipantRestartPublisher extends AbstractParticipantPublisher<ParticipantRestart> {
-
- private static final Logger LOGGER = LoggerFactory.getLogger(ParticipantRestartPublisher.class);
- private final AcRuntimeParameterGroup acRuntimeParameterGroup;
-
- /**
- * Send Restart to Participant.
- *
- * @param participantId the ParticipantId
- * @param acmDefinition the AutomationComposition Definition
- * @param automationCompositions the list of automationCompositions
- */
- @Timed(value = "publisher.participant_restart", description = "Participant Restart published")
- public void send(UUID participantId, AutomationCompositionDefinition acmDefinition,
- List<AutomationComposition> automationCompositions) {
-
- var message = new ParticipantRestart();
- message.setParticipantId(participantId);
- message.setCompositionId(acmDefinition.getCompositionId());
- message.setMessageId(UUID.randomUUID());
- message.setTimestamp(Instant.now());
- message.setState(acmDefinition.getState());
- message.setParticipantDefinitionUpdates(
- AcmUtils.prepareParticipantRestarting(participantId, acmDefinition,
- acRuntimeParameterGroup.getAcmParameters().getToscaElementName()));
- var toscaServiceTemplateFragment = AcmUtils.getToscaServiceTemplateFragment(acmDefinition.getServiceTemplate());
-
- for (var automationComposition : automationCompositions) {
- var restartAc = AcmUtils
- .createAcRestart(automationComposition, participantId, toscaServiceTemplateFragment);
- message.getAutomationcompositionList().add(restartAc);
- }
-
- LOGGER.debug("Participant Restart sent {}", message.getMessageId());
- super.send(message);
- }
-}
assertThatThrownBy(() -> provider.deleteAutomationCompositionDefinition(compositionId))
.hasMessageMatching("ACM not in COMMISSIONED state, Delete of ACM Definition not allowed");
}
-
- @Test
- void testPrimingBadRequest() {
- var acDefinitionProvider = mock(AcDefinitionProvider.class);
- var toscaServiceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
- var acmDefinition = CommonTestData.createAcDefinition(toscaServiceTemplate, AcTypeState.PRIMED);
- acmDefinition.setRestarting(true);
- var compositionId = acmDefinition.getCompositionId();
- when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acmDefinition);
-
- var provider = new CommissioningProvider(acDefinitionProvider, mock(AutomationCompositionProvider.class),
- mock(ParticipantProvider.class), new AcTypeStateResolver(), mock(ParticipantPrimePublisher.class),
- mock(AcRuntimeParameterGroup.class));
-
- var acTypeStateUpdate = new AcTypeStateUpdate();
- assertThatThrownBy(() -> provider.compositionDefinitionPriming(compositionId, acTypeStateUpdate))
- .hasMessageMatching("There is a restarting process, Priming/Depriming not allowed");
- }
}
"Not allowed to MIGRATE in the state " + automationCompositionUpdate.getDeployState());
}
- @Test
- void testUpdateRestartedBadRequest() {
- var automationCompositionUpdate =
- InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
- automationCompositionUpdate.setDeployState(DeployState.DEPLOYED);
- automationCompositionUpdate.setLockState(LockState.LOCKED);
- automationCompositionUpdate.setRestarting(true);
- var acProvider = mock(AutomationCompositionProvider.class);
- when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
- .thenReturn(automationCompositionUpdate);
-
- var instantiationProvider =
- new AutomationCompositionInstantiationProvider(acProvider, mock(AcDefinitionProvider.class), null,
- mock(SupervisionAcHandler.class), mock(ParticipantProvider.class),
- mock(AcRuntimeParameterGroup.class));
-
- var compositionId = automationCompositionUpdate.getCompositionId();
- assertThatThrownBy(
- () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
- .hasMessageMatching("There is a restarting process, Update not allowed");
-
- automationCompositionUpdate.setCompositionTargetId(UUID.randomUUID());
- assertThatThrownBy(
- () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
- .hasMessageMatching("There is a restarting process, Update not allowed");
-
- automationCompositionUpdate.setDeployState(DeployState.UNDEPLOYED);
- automationCompositionUpdate.setLockState(LockState.NONE);
-
- var instanceId = automationCompositionUpdate.getInstanceId();
- assertThatThrownBy(() -> instantiationProvider.deleteAutomationComposition(compositionId, instanceId))
- .hasMessageMatching("There is a restarting process, Delete not allowed");
- }
-
- @Test
- void testUpdateCompositionRestartedBadRequest() {
- var acDefinitionProvider = mock(AcDefinitionProvider.class);
- var acDefinition = CommonTestData.createAcDefinition(serviceTemplate, AcTypeState.PRIMED);
- acDefinition.setRestarting(true);
- var compositionId = acDefinition.getCompositionId();
- when(acDefinitionProvider.findAcDefinition(compositionId)).thenReturn(Optional.of(acDefinition));
-
- var automationCompositionUpdate =
- InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
- automationCompositionUpdate.setCompositionId(compositionId);
- automationCompositionUpdate.setDeployState(DeployState.DEPLOYED);
- automationCompositionUpdate.setLockState(LockState.LOCKED);
- var acProvider = mock(AutomationCompositionProvider.class);
- when(acProvider.getAutomationComposition(automationCompositionUpdate.getInstanceId()))
- .thenReturn(automationCompositionUpdate);
- when(acProvider.updateAutomationComposition(automationCompositionUpdate))
- .thenReturn(automationCompositionUpdate);
-
- var supervisionAcHandler = mock(SupervisionAcHandler.class);
- var participantProvider = mock(ParticipantProvider.class);
- var instantiationProvider = new AutomationCompositionInstantiationProvider(acProvider, acDefinitionProvider,
- new AcInstanceStateResolver(), supervisionAcHandler, participantProvider,
- mock(AcRuntimeParameterGroup.class));
- var message =
- """
- "AutomationComposition" INVALID, item has status INVALID
- item "ServiceTemplate.restarting" value "true" INVALID, There is a restarting process in composition
- """;
-
- assertThatThrownBy(
- () -> instantiationProvider.updateAutomationComposition(compositionId, automationCompositionUpdate))
- .hasMessageMatching(message);
- }
-
@Test
void testMigrationAddRemoveElements() {
var acDefinitionProvider = mock(AcDefinitionProvider.class);
verify(acDefinitionProvider, times(acDefinition.getElementStateMap().size()))
.updateAcDefinitionElement(any(), any());
verify(acDefinitionProvider).updateAcDefinitionState(acDefinition.getCompositionId(), AcTypeState.PRIMED,
- StateChangeResult.NO_ERROR, null);
+ StateChangeResult.NO_ERROR);
}
@Test
verify(acDefinitionProvider).findAcDefinition(any());
verify(acDefinitionProvider).updateAcDefinitionElement(any(), any());
verify(acDefinitionProvider).updateAcDefinitionState(acDefinition.getCompositionId(), AcTypeState.PRIMING,
- StateChangeResult.FAILED, null);
+ StateChangeResult.FAILED);
}
}
import org.onap.policy.clamp.acm.runtime.main.parameters.AcRuntimeParameterGroup;
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.ParticipantRestartPublisher;
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;
var handler =
new SupervisionParticipantHandler(participantProvider, mock(ParticipantRegisterAckPublisher.class),
participantDeregisterAckPublisher, mock(AutomationCompositionProvider.class),
- mock(AcDefinitionProvider.class), mock(ParticipantRestartPublisher.class),
- mock(ParticipantSyncPublisher.class), mock(AcRuntimeParameterGroup.class));
+ mock(AcDefinitionProvider.class), mock(ParticipantSyncPublisher.class),
+ mock(AcRuntimeParameterGroup.class));
handler.handleParticipantMessage(participantDeregisterMessage);
var participantRegisterAckPublisher = mock(ParticipantRegisterAckPublisher.class);
var handler = new SupervisionParticipantHandler(participantProvider, participantRegisterAckPublisher,
mock(ParticipantDeregisterAckPublisher.class), mock(AutomationCompositionProvider.class),
- mock(AcDefinitionProvider.class), mock(ParticipantRestartPublisher.class),
- mock(ParticipantSyncPublisher.class), mock(AcRuntimeParameterGroup.class));
+ mock(AcDefinitionProvider.class), mock(ParticipantSyncPublisher.class),
+ mock(AcRuntimeParameterGroup.class));
handler.handleParticipantMessage(participantRegisterMessage);
verify(participantProvider).saveParticipant(any());
CommonTestData.getParticipantId(), null);
}
- @Test
- void testHandleParticipantRestart() {
- var participantRegisterMessage = new ParticipantRegister();
- participantRegisterMessage.setMessageId(UUID.randomUUID());
- var participantId = CommonTestData.getParticipantId();
- participantRegisterMessage.setParticipantId(participantId);
- participantRegisterMessage.setReplicaId(participantId);
- var supportedElementType = CommonTestData.createParticipantSupportedElementType();
- participantRegisterMessage.setParticipantSupportedElementType(List.of(supportedElementType));
-
- var participant = new Participant();
- var replica = new ParticipantReplica();
- replica.setReplicaId(participantId);
- participant.setParticipantId(participantId);
- participant.getReplicas().put(replica.getReplicaId(), replica);
- var participantProvider = mock(ParticipantProvider.class);
- when(participantProvider.findParticipant(participantId)).thenReturn(Optional.of(participant));
- when(participantProvider.findParticipantReplica(participantId)).thenReturn(Optional.of(replica));
- var compositionId = UUID.randomUUID();
- var composition2Id = UUID.randomUUID();
- when(participantProvider.getCompositionIds(participantId)).thenReturn(Set.of(compositionId, composition2Id));
-
- var acDefinitionProvider = mock(AcDefinitionProvider.class);
- var acDefinition = new AutomationCompositionDefinition();
- acDefinition.setState(AcTypeState.COMMISSIONED);
- acDefinition.setCompositionId(composition2Id);
- when(acDefinitionProvider.getAcDefinition(composition2Id)).thenReturn(acDefinition);
-
- acDefinition = new AutomationCompositionDefinition();
- acDefinition.setCompositionId(compositionId);
- acDefinition.setState(AcTypeState.PRIMED);
- var nodeTemplateState = new NodeTemplateState();
- nodeTemplateState.setParticipantId(participantId);
- acDefinition.setElementStateMap(Map.of("code", nodeTemplateState));
- when(acDefinitionProvider.getAcDefinition(compositionId)).thenReturn(acDefinition);
-
- var automationComposition =
- InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
- automationComposition.getElements().values().iterator().next().setParticipantId(participantId);
- var automationCompositionProvider = mock(AutomationCompositionProvider.class);
- when(automationCompositionProvider.getAcInstancesByCompositionId(compositionId))
- .thenReturn(List.of(automationComposition));
-
- var participantRegisterAckPublisher = mock(ParticipantRegisterAckPublisher.class);
- var participantRestartPublisher = mock(ParticipantRestartPublisher.class);
- var handler = new SupervisionParticipantHandler(participantProvider, participantRegisterAckPublisher,
- mock(ParticipantDeregisterAckPublisher.class), automationCompositionProvider, acDefinitionProvider,
- participantRestartPublisher, mock(ParticipantSyncPublisher.class),
- CommonTestData.getTestParamaterGroup());
- handler.handleParticipantMessage(participantRegisterMessage);
-
- verify(participantRegisterAckPublisher)
- .send(participantRegisterMessage.getMessageId(), participantId, participantId);
- verify(acDefinitionProvider).updateAcDefinition(any(AutomationCompositionDefinition.class),
- eq(CommonTestData.TOSCA_COMP_NAME));
- verify(participantRestartPublisher).send(any(), any(AutomationCompositionDefinition.class), any());
- }
-
@Test
void testHandleParticipantSyncRestart() {
var participantRegisterMessage = new ParticipantRegister();
var participantSyncPublisher = mock(ParticipantSyncPublisher.class);
var handler = new SupervisionParticipantHandler(participantProvider, participantRegisterAckPublisher,
mock(ParticipantDeregisterAckPublisher.class), automationCompositionProvider, acDefinitionProvider,
- mock(ParticipantRestartPublisher.class), participantSyncPublisher,
- CommonTestData.getTestParamaterGroup());
+ participantSyncPublisher, CommonTestData.getTestParamaterGroup());
handler.handleParticipantMessage(participantRegisterMessage);
verify(participantRegisterAckPublisher)
var handler =
new SupervisionParticipantHandler(participantProvider, mock(ParticipantRegisterAckPublisher.class),
mock(ParticipantDeregisterAckPublisher.class), automationCompositionProvider,
- mock(AcDefinitionProvider.class), mock(ParticipantRestartPublisher.class),
- mock(ParticipantSyncPublisher.class), mock(AcRuntimeParameterGroup.class));
+ mock(AcDefinitionProvider.class), mock(ParticipantSyncPublisher.class),
+ mock(AcRuntimeParameterGroup.class));
var participant = CommonTestData.createParticipant(CommonTestData.getParticipantId());
when(participantProvider.findParticipant(CommonTestData.getParticipantId()))
.thenReturn(Optional.of(participant));
var handler =
new SupervisionParticipantHandler(participantProvider, mock(ParticipantRegisterAckPublisher.class),
mock(ParticipantDeregisterAckPublisher.class), mock(AutomationCompositionProvider.class),
- acDefinitionProvider, mock(ParticipantRestartPublisher.class),
- mock(ParticipantSyncPublisher.class), CommonTestData.getTestParamaterGroup());
+ acDefinitionProvider, mock(ParticipantSyncPublisher.class),
+ CommonTestData.getTestParamaterGroup());
handler.handleParticipantMessage(participantStatusMessage);
verify(acDefinitionProvider).updateAcDefinition(acDefinition, CommonTestData.TOSCA_COMP_NAME);
var handler =
new SupervisionParticipantHandler(participantProvider, mock(ParticipantRegisterAckPublisher.class),
mock(ParticipantDeregisterAckPublisher.class), automationCompositionProvider,
- mock(AcDefinitionProvider.class), mock(ParticipantRestartPublisher.class),
- mock(ParticipantSyncPublisher.class), mock(AcRuntimeParameterGroup.class));
+ mock(AcDefinitionProvider.class), mock(ParticipantSyncPublisher.class),
+ mock(AcRuntimeParameterGroup.class));
handler.handleParticipantMessage(participantStatusMessage);
verify(participantProvider).saveParticipant(any());
var handler =
new SupervisionParticipantHandler(participantProvider, mock(ParticipantRegisterAckPublisher.class),
mock(ParticipantDeregisterAckPublisher.class), automationCompositionProvider,
- mock(AcDefinitionProvider.class), mock(ParticipantRestartPublisher.class),
- mock(ParticipantSyncPublisher.class), mock(AcRuntimeParameterGroup.class));
+ mock(AcDefinitionProvider.class), mock(ParticipantSyncPublisher.class),
+ mock(AcRuntimeParameterGroup.class));
var participant = CommonTestData.createParticipant(CommonTestData.getParticipantId());
when(participantProvider.findParticipant(CommonTestData.getParticipantId()))
.thenReturn(Optional.of(participant));
mock(AutomationCompositionStateChangePublisher.class), mock(AutomationCompositionDeployPublisher.class),
mock(ParticipantSyncPublisher.class), null, acRuntimeParameterGroup);
supervisionScanner.run();
- verify(acDefinitionProvider, times(0)).updateAcDefinitionState(any(), any(), any(), any());
+ verify(acDefinitionProvider, times(0)).updateAcDefinitionState(any(), any(), any());
}
@Test
mock(ParticipantSyncPublisher.class), null, acRuntimeParameterGroup);
supervisionScanner.run();
// Ac Definition in Priming state
- verify(acDefinitionProvider, times(0)).updateAcDefinitionState(any(), any(), any(), any());
+ verify(acDefinitionProvider, times(0)).updateAcDefinitionState(any(), any(), any());
acRuntimeParameterGroup.getParticipantParameters().setMaxStatusWaitMs(-1);
supervisionScanner = new SupervisionScanner(mock(AutomationCompositionProvider.class), acDefinitionProvider,
supervisionScanner.run();
// set Timeout
verify(acDefinitionProvider).updateAcDefinitionState(acDefinition.getCompositionId(), acDefinition.getState(),
- StateChangeResult.TIMEOUT, null);
+ StateChangeResult.TIMEOUT);
clearInvocations(acDefinitionProvider);
acDefinition.setStateChangeResult(StateChangeResult.TIMEOUT);
supervisionScanner.run();
// already in Timeout
- verify(acDefinitionProvider, times(0)).updateAcDefinitionState(any(), any(), any(), any());
+ verify(acDefinitionProvider, times(0)).updateAcDefinitionState(any(), any(), any());
clearInvocations(acDefinitionProvider);
// retry by the user
supervisionScanner.run();
// set Timeout
verify(acDefinitionProvider).updateAcDefinitionState(acDefinition.getCompositionId(), acDefinition.getState(),
- StateChangeResult.TIMEOUT, null);
+ StateChangeResult.TIMEOUT);
clearInvocations(acDefinitionProvider);
for (var element : acDefinition.getElementStateMap().values()) {
supervisionScanner.run();
// completed
verify(acDefinitionProvider).updateAcDefinitionState(acDefinition.getCompositionId(), AcTypeState.PRIMED,
- StateChangeResult.NO_ERROR, null);
+ StateChangeResult.NO_ERROR);
}
@Test
verify(topicSink).send(anyString());
}
- @Test
- void testParticipantRestartPublisher() {
- var publisher = new ParticipantRestartPublisher(CommonTestData.getTestParamaterGroup());
- var topicSink = mock(TopicSink.class);
- publisher.active(topicSink);
-
- var serviceTemplate = InstantiationUtils.getToscaServiceTemplate(TOSCA_SERVICE_TEMPLATE_YAML);
- var acmDefinition = new AutomationCompositionDefinition();
- acmDefinition.setCompositionId(UUID.randomUUID());
- acmDefinition.setServiceTemplate(serviceTemplate);
- var acElements = AcmUtils
- .extractAcElementsFromServiceTemplate(serviceTemplate, "");
- acmDefinition.setElementStateMap(AcmUtils.createElementStateMap(acElements, AcTypeState.PRIMED));
-
- var automationComposition =
- InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_UPDATE_JSON, "Crud");
-
- var participantId = automationComposition.getElements().values().iterator().next().getParticipantId();
- acmDefinition.getElementStateMap().values().iterator().next().setParticipantId(participantId);
-
- publisher.send(participantId, acmDefinition, List.of(automationComposition));
- verify(topicSink).send(anyString());
- }
-
@Test
void testParticipantSyncPublisherAutomationComposition() {
var publisher = new ParticipantSyncPublisher(CommonTestData.getTestParamaterGroup());
Code Review / policy / clamp.git / commitdiff