--- /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.models.acm.concepts;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.function.UnaryOperator;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.NonNull;
+import lombok.ToString;
+import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
+import org.onap.policy.models.base.PfConceptKey;
+import org.onap.policy.models.base.PfUtils;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
+import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
+
+/**
+ * Class to represent a automation composition instance to send for deploy.
+ */
+@NoArgsConstructor
+@Data
+@ToString
+public class AcElementDeploy {
+
+ @NonNull
+ private ToscaConceptIdentifier definition = new ToscaConceptIdentifier(PfConceptKey.getNullKey());
+
+ @NonNull
+ private DeployOrder orderedState = DeployOrder.DEPLOY;
+
+ private ToscaServiceTemplate toscaServiceTemplateFragment;
+
+ // A map indexed by the property name. Each map entry is the serialized value of the property,
+ // which can be deserialized into an instance of the type of the property.
+ private Map<String, Object> properties = new LinkedHashMap<>();
+
+ /**
+ * Copy constructor, does a deep copy but as all fields here are immutable, it's just a regular copy.
+ *
+ * @param otherElement the other element to copy from
+ */
+ public AcElementDeploy(final AcElementDeploy otherElement) {
+ this.definition = new ToscaConceptIdentifier(otherElement.definition);
+ this.orderedState = otherElement.orderedState;
+ this.toscaServiceTemplateFragment = otherElement.toscaServiceTemplateFragment;
+ this.properties = PfUtils.mapMap(otherElement.properties, UnaryOperator.identity());
+ }
+}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2021 Nordix Foundation.
+ * 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.
@Setter
@AllArgsConstructor
@ToString
-public class AutomationCompositionElementAck {
+public class AcElementDeployAck {
// State of the AutomationCompositionElement
private AutomationCompositionState state;
+ // State of the AutomationCompositionElement
+ private DeployState deployState;
+
// Result: Success/Fail.
private Boolean result;
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2021 Nordix Foundation.
+ * 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.
import org.onap.policy.models.base.PfUtils;
/**
- * Class to represent a participant definition update instance.
+ * Class to represent a participant definition instance for Deploy.
*/
@Getter
@NoArgsConstructor
@Data
@ToString
-public class ParticipantUpdates {
+public class ParticipantDeploy {
private UUID participantId;
// List of AutomationCompositionElement values for a particular participant
private List<AutomationCompositionElement> automationCompositionElementList = new ArrayList<>();
+ // List of Automation Composition Element Deploy for a particular participant
+ private List<AcElementDeploy> acElementList = new ArrayList<>();
+
/**
* Copy constructor, does a deep copy but as all fields here are immutable, it's just a regular copy.
*
- * @param participantUpdates the participant with updates to copy from
+ * @param copyConstructor the participant with updates to copy from
*/
- public ParticipantUpdates(final ParticipantUpdates participantUpdates) {
- this.participantId = participantUpdates.participantId;
+ public ParticipantDeploy(final ParticipantDeploy copyConstructor) {
+ this.participantId = copyConstructor.participantId;
this.automationCompositionElementList = PfUtils.mapList(
- participantUpdates.automationCompositionElementList, AutomationCompositionElement::new);
+ copyConstructor.automationCompositionElementList, AutomationCompositionElement::new);
+ this.acElementList = PfUtils.mapList(copyConstructor.acElementList, AcElementDeploy::new);
}
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2021-2022 Nordix Foundation.
+ * 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.
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
-import org.onap.policy.clamp.models.acm.concepts.ParticipantUpdates;
+import org.onap.policy.clamp.models.acm.concepts.ParticipantDeploy;
import org.onap.policy.models.base.PfUtils;
/**
- * Class to represent the AUTOMATION_COMPOSITION_UPDATE message that the automation composition runtime sends to a
+ * Class to represent the AUTOMATION_COMPOSITION_DEPLOY message that the automation composition runtime sends to a
* participant. When a participant receives this message, it creates the automation composition elements contained in
* the message and sets them to state PASSIVE. subsequent AUTOMATION_COMPOSITION_STATE_CHANGE messages are used to
* activate the automation compositions.
@Getter
@Setter
@ToString(callSuper = true)
-public class AutomationCompositionUpdate extends ParticipantMessage {
+public class AutomationCompositionDeploy extends ParticipantMessage {
// A list of ParticipantUpdates instances which carries details of an updated participant.
- private List<ParticipantUpdates> participantUpdatesList = new ArrayList<>();
+ private List<ParticipantDeploy> participantUpdatesList = new ArrayList<>();
private Integer startPhase = 0;
/**
* Constructor for instantiating class with message name.
*
*/
- public AutomationCompositionUpdate() {
- super(ParticipantMessageType.AUTOMATION_COMPOSITION_UPDATE);
+ public AutomationCompositionDeploy() {
+ super(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY);
}
/**
*
* @param source source from which to copy
*/
- public AutomationCompositionUpdate(AutomationCompositionUpdate source) {
+ public AutomationCompositionDeploy(AutomationCompositionDeploy source) {
super(source);
this.startPhase = source.startPhase;
- this.participantUpdatesList = PfUtils.mapList(source.participantUpdatesList, ParticipantUpdates::new);
+ this.participantUpdatesList = PfUtils.mapList(source.participantUpdatesList, ParticipantDeploy::new);
}
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2021-2022 Nordix Foundation.
+ * 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.
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
-import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementAck;
+import org.onap.policy.clamp.models.acm.concepts.AcElementDeployAck;
import org.onap.policy.models.base.PfUtils;
/**
@Getter
@Setter
@ToString(callSuper = true)
-public class AutomationCompositionAck extends ParticipantAckMessage {
+public class AutomationCompositionDeployAck extends ParticipantAckMessage {
private UUID automationCompositionId;
private Integer startPhase;
// A map with AutomationCompositionElementID as its key, and a pair of result and message as value per
// AutomationCompositionElement.
- private Map<UUID, AutomationCompositionElementAck> automationCompositionResultMap = new LinkedHashMap<>();
+ private Map<UUID, AcElementDeployAck> automationCompositionResultMap = new LinkedHashMap<>();
/**
* Constructor for instantiating ParticipantRegisterAck class with message name.
*
*/
- public AutomationCompositionAck(final ParticipantMessageType messageType) {
+ public AutomationCompositionDeployAck(final ParticipantMessageType messageType) {
super(messageType);
}
*
* @param source source from which to copy
*/
- public AutomationCompositionAck(final AutomationCompositionAck source) {
+ public AutomationCompositionDeployAck(final AutomationCompositionDeployAck source) {
super(source);
this.automationCompositionId = source.automationCompositionId;
+ this.startPhase = source.startPhase;
this.automationCompositionResultMap =
PfUtils.mapMap(source.automationCompositionResultMap, UnaryOperator.identity());
}
PARTICIPANT_STATE_CHANGE,
/**
- * Used by acm runtime to update the automation compositions running on participants, triggers a
- * PARTICIPANT_STATUS message with the result of the AUTOMATION_COMPOSITION_UPDATE operation.
+ * Used by acm runtime to deploy the automation compositions running on participants, triggers a
+ * PARTICIPANT_STATUS message with the result of the AUTOMATION_COMPOSITION_DEPLOY operation.
*/
- AUTOMATION_COMPOSITION_UPDATE,
+ AUTOMATION_COMPOSITION_DEPLOY,
/**
* Used by acm runtime to change the state of automation compositions in participants, triggers a
PARTICIPANT_UPDATE_ACK,
/**
- * Used by participant to acknowledge the receipt of AUTOMATION_COMPOSITION_UPDATE message
+ * Used by participant to acknowledge the receipt of AUTOMATION_COMPOSITION_DEPLOY message
* from automation composition runtime.
*/
- AUTOMATION_COMPOSITION_UPDATE_ACK,
+ AUTOMATION_COMPOSITION_DEPLOY_ACK,
/**
* Used by participant to acknowledge the receipt of AUTOMATION_COMPOSITION_STATE_CHANGE message
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementDefinition;
import org.onap.policy.clamp.models.acm.concepts.NodeTemplateState;
import org.onap.policy.clamp.models.acm.concepts.ParticipantDefinition;
-import org.onap.policy.clamp.models.acm.concepts.ParticipantUpdates;
+import org.onap.policy.clamp.models.acm.concepts.ParticipantDeploy;
import org.onap.policy.common.parameters.BeanValidationResult;
import org.onap.policy.common.parameters.ObjectValidationResult;
import org.onap.policy.common.parameters.ValidationResult;
* @param participantUpdates list of participantUpdates
*/
public static void prepareParticipantUpdate(AutomationCompositionElement acElement,
- List<ParticipantUpdates> participantUpdates) {
+ List<ParticipantDeploy> participantUpdates) {
if (participantUpdates.isEmpty()) {
participantUpdates.add(getAutomationCompositionElementList(acElement));
return;
}
var participantExists = false;
- for (ParticipantUpdates participantUpdate : participantUpdates) {
+ for (ParticipantDeploy participantUpdate : participantUpdates) {
if (participantUpdate.getParticipantId().equals(acElement.getParticipantId())) {
participantUpdate.getAutomationCompositionElementList().add(acElement);
participantExists = true;
}
}
- private static ParticipantUpdates getAutomationCompositionElementList(AutomationCompositionElement acElement) {
- var participantUpdate = new ParticipantUpdates();
+ private static ParticipantDeploy getAutomationCompositionElementList(AutomationCompositionElement acElement) {
+ var participantUpdate = new ParticipantDeploy();
participantUpdate.setParticipantId(acElement.getParticipantId());
participantUpdate.getAutomationCompositionElementList().add(acElement);
return participantUpdate;
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2021-2023 Nordix Foundation.
+ * 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.
import java.util.Map;
import java.util.UUID;
import org.junit.jupiter.api.Test;
-import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementAck;
+import org.onap.policy.clamp.models.acm.concepts.AcElementDeployAck;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionState;
import org.onap.policy.clamp.models.acm.utils.CommonTestData;
import org.onap.policy.common.utils.coder.CoderException;
-class AutomationCompositionAckTest {
+class AutomationCompositionDeployAckTest {
@Test
void testCopyConstructor() throws CoderException {
- assertThatThrownBy(() -> new AutomationCompositionAck((AutomationCompositionAck) null))
+ assertThatThrownBy(() -> new AutomationCompositionDeployAck((AutomationCompositionDeployAck) null))
.isInstanceOf(NullPointerException.class);
- final var orig = new AutomationCompositionAck(ParticipantMessageType.AUTOMATION_COMPOSITION_UPDATE);
+ final var orig = new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY);
// verify with null values
assertEquals(removeVariableFields(orig.toString()),
- removeVariableFields(new AutomationCompositionAck(orig).toString()));
+ removeVariableFields(new AutomationCompositionDeployAck(orig).toString()));
// verify with all values
orig.setAutomationCompositionId(UUID.randomUUID());
orig.setParticipantId(CommonTestData.getParticipantId());
- var acElementResult = new AutomationCompositionElementAck(AutomationCompositionState.UNINITIALISED,
+ var acElementResult = new AcElementDeployAck(AutomationCompositionState.UNINITIALISED, null,
true, "AutomationCompositionElement result");
final var automationCompositionResultMap = Map.of(UUID.randomUUID(), acElementResult);
orig.setAutomationCompositionResultMap(automationCompositionResultMap);
orig.setResponseTo(UUID.randomUUID());
orig.setResult(true);
- orig.setMessage("Successfully processed AutomationCompositionUpdate message");
+ orig.setMessage("Successfully processed AutomationCompositionDeploy message");
assertEquals(removeVariableFields(orig.toString()),
- removeVariableFields(new AutomationCompositionAck(orig).toString()));
+ removeVariableFields(new AutomationCompositionDeployAck(orig).toString()));
- assertSerializable(orig, AutomationCompositionAck.class);
+ assertSerializable(orig, AutomationCompositionDeployAck.class);
}
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2021-2023 Nordix Foundation.
+ * 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.
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElement;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionOrderedState;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionState;
-import org.onap.policy.clamp.models.acm.concepts.ParticipantUpdates;
+import org.onap.policy.clamp.models.acm.concepts.ParticipantDeploy;
import org.onap.policy.clamp.models.acm.utils.CommonTestData;
import org.onap.policy.common.utils.coder.CoderException;
import org.onap.policy.common.utils.coder.StandardCoder;
/**
* Test the copy constructor.
*/
-class AutomationCompositionUpdateTest {
+class AutomationCompositionDeployTest {
@Test
void testCopyConstructor() throws CoderException {
- assertThatThrownBy(() -> new AutomationCompositionUpdate(null)).isInstanceOf(NullPointerException.class);
+ assertThatThrownBy(() -> new AutomationCompositionDeploy(null)).isInstanceOf(NullPointerException.class);
- var orig = new AutomationCompositionUpdate();
+ var orig = new AutomationCompositionDeploy();
// verify with all values
orig.setAutomationCompositionId(UUID.randomUUID());
orig.setParticipantId(null);
var propertiesMap = Map.of("Prop1", (Object) json);
acElement.setProperties(propertiesMap);
- var participantUpdates = new ParticipantUpdates();
- participantUpdates.setParticipantId(participantId);
- participantUpdates.setAutomationCompositionElementList(List.of(acElement));
- orig.setParticipantUpdatesList(List.of(participantUpdates));
+ var participantDeploy = new ParticipantDeploy();
+ participantDeploy.setParticipantId(participantId);
+ participantDeploy.setAutomationCompositionElementList(List.of(acElement));
+ orig.setParticipantUpdatesList(List.of(participantDeploy));
- var other = new AutomationCompositionUpdate(orig);
+ var other = new AutomationCompositionDeploy(orig);
assertEquals(removeVariableFields(orig.toString()), removeVariableFields(other.toString()));
- assertSerializable(orig, AutomationCompositionUpdate.class);
+ assertSerializable(orig, AutomationCompositionDeploy.class);
}
}
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2021 Nordix Foundation.
+ * Copyright (C) 2021-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.
package org.onap.policy.clamp.models.acm.messages.dmaap.participant;
-import com.openpojo.reflection.PojoClass;
import com.openpojo.reflection.impl.PojoClassFactory;
-import com.openpojo.validation.Validator;
import com.openpojo.validation.ValidatorBuilder;
import com.openpojo.validation.rule.impl.GetterMustExistRule;
import com.openpojo.validation.rule.impl.SetterMustExistRule;
import com.openpojo.validation.test.impl.GetterTester;
import com.openpojo.validation.test.impl.SetterTester;
-import java.util.List;
import org.junit.jupiter.api.Test;
import org.onap.policy.common.utils.test.ToStringTester;
@Test
void testPojos() {
- List<PojoClass> pojoClasses =
+ var pojoClasses =
PojoClassFactory.getPojoClasses(ParticipantPojosTest.class.getPackageName());
pojoClasses.remove(PojoClassFactory.getPojoClass(ParticipantMessage.class));
pojoClasses.remove(PojoClassFactory.getPojoClass(ParticipantMessageTest.class));
pojoClasses.remove(PojoClassFactory.getPojoClass(ParticipantAckMessage.class));
pojoClasses.remove(PojoClassFactory.getPojoClass(ParticipantAckMessageTest.class));
- pojoClasses.remove(PojoClassFactory.getPojoClass(AutomationCompositionAck.class));
- pojoClasses.remove(PojoClassFactory.getPojoClass(AutomationCompositionAckTest.class));
+ pojoClasses.remove(PojoClassFactory.getPojoClass(AutomationCompositionDeployAck.class));
+ pojoClasses.remove(PojoClassFactory.getPojoClass(AutomationCompositionDeployAckTest.class));
// @formatter:off
- final Validator validator = ValidatorBuilder
+ final var validator = ValidatorBuilder
.create()
.with(new ToStringTester())
.with(new SetterMustExistRule())
import org.junit.jupiter.api.Test;
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.ParticipantUpdates;
+import org.onap.policy.clamp.models.acm.concepts.ParticipantDeploy;
import org.onap.policy.clamp.models.acm.document.concepts.DocToscaServiceTemplate;
import org.onap.policy.common.utils.coder.StandardCoder;
import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
@Test
void testCommonUtilsParticipantUpdate() {
var acElement = new AutomationCompositionElement();
- List<ParticipantUpdates> participantUpdates = new ArrayList<>();
+ List<ParticipantDeploy> participantUpdates = new ArrayList<>();
assertThat(participantUpdates).isEmpty();
AcmUtils.prepareParticipantUpdate(acElement, participantUpdates);
/*-
* ============LICENSE_START=======================================================
- * Copyright (C) 2021 Nordix Foundation.
+ * 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.
package org.onap.policy.clamp.acm.participant.intermediary.comm;
import org.onap.policy.clamp.acm.participant.intermediary.handler.ParticipantHandler;
-import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionUpdate;
+import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeploy;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantMessageType;
import org.springframework.stereotype.Component;
/**
- * Listener for Automation Composition Update messages sent by ACM.
+ * Listener for Automation Composition Deploy messages sent by ACM.
*/
@Component
-public class AutomationCompositionUpdateListener extends ParticipantListener<AutomationCompositionUpdate> {
+public class AutomationCompositionDeployListener extends ParticipantListener<AutomationCompositionDeploy> {
/**
* Constructs the object.
*
* @param participantHandler the handler for managing the state of the participant
*/
- public AutomationCompositionUpdateListener(final ParticipantHandler participantHandler) {
- super(AutomationCompositionUpdate.class, participantHandler,
- participantHandler::handleAutomationCompositionUpdate);
+ public AutomationCompositionDeployListener(final ParticipantHandler participantHandler) {
+ super(AutomationCompositionDeploy.class, participantHandler,
+ participantHandler::handleAutomationCompositionDeploy);
}
@Override
public String getType() {
- return ParticipantMessageType.AUTOMATION_COMPOSITION_UPDATE.name();
+ return ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY.name();
}
}
import javax.ws.rs.core.Response.Status;
import org.onap.policy.clamp.acm.participant.intermediary.handler.Publisher;
import org.onap.policy.clamp.common.acm.exception.AutomationCompositionRuntimeException;
-import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionAck;
+import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeployAck;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantDeregister;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantRegister;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantStatus;
*/
@Timed(value = "publisher.automation_composition_update_ack",
description = "AUTOMATION_COMPOSITION_UPDATE_ACK/AUTOMATION_COMPOSITION_STATECHANGE_ACK messages published")
- public void sendAutomationCompositionAck(final AutomationCompositionAck automationCompositionAck) {
+ public void sendAutomationCompositionAck(final AutomationCompositionDeployAck automationCompositionAck) {
validate();
topicSinkClient.send(automationCompositionAck);
LOGGER.debug("Sent AutomationComposition Update/StateChange Ack to runtime - {}", automationCompositionAck);
import org.onap.policy.clamp.acm.participant.intermediary.api.AutomationCompositionElementListener;
import org.onap.policy.clamp.acm.participant.intermediary.comm.ParticipantMessagePublisher;
import org.onap.policy.clamp.acm.participant.intermediary.parameters.ParticipantParameters;
+import org.onap.policy.clamp.models.acm.concepts.AcElementDeployAck;
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.AutomationCompositionElementAck;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementDefinition;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionOrderedState;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionState;
-import org.onap.policy.clamp.models.acm.concepts.ParticipantUpdates;
+import org.onap.policy.clamp.models.acm.concepts.ParticipantDeploy;
import org.onap.policy.clamp.models.acm.concepts.ParticipantUtils;
-import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionAck;
+import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeploy;
+import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeployAck;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionStateChange;
-import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionUpdate;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantMessageType;
import org.onap.policy.models.base.PfModelException;
import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
var acElement = elementsOnThisParticipant.get(id);
if (acElement != null) {
var automationCompositionStateChangeAck =
- new AutomationCompositionAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK);
+ new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK);
automationCompositionStateChangeAck.setParticipantId(participantId);
automationCompositionStateChangeAck.setAutomationCompositionId(automationCompositionId);
acElement.setOrderedState(orderedState);
acElement.setState(newState);
automationCompositionStateChangeAck.getAutomationCompositionResultMap().put(acElement.getId(),
- new AutomationCompositionElementAck(newState, true,
+ new AcElementDeployAck(newState, null, true,
"Automation composition element {} state changed to {}\", id, newState)"));
LOGGER.debug("Automation composition element {} state changed to {}", id, newState);
automationCompositionStateChangeAck
if (automationComposition == null) {
var automationCompositionAck =
- new AutomationCompositionAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK);
+ new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK);
automationCompositionAck.setParticipantId(participantId);
automationCompositionAck.setMessage("Automation composition " + stateChangeMsg.getAutomationCompositionId()
+ " does not use this participant " + participantId);
}
/**
- * Handle a automation composition update message.
+ * Handle a automation composition Deploy message.
*
- * @param updateMsg the update message
+ * @param updateMsg the Deploy message
* @param acElementDefinitions the list of AutomationCompositionElementDefinition
*/
- public void handleAutomationCompositionUpdate(AutomationCompositionUpdate updateMsg,
+ public void handleAutomationCompositionDeploy(AutomationCompositionDeploy updateMsg,
List<AutomationCompositionElementDefinition> acElementDefinitions) {
if (!updateMsg.appliesTo(participantId)) {
}
}
- private void handleAcUpdatePhase0(AutomationCompositionUpdate updateMsg,
+ private void handleAcUpdatePhase0(AutomationCompositionDeploy updateMsg,
List<AutomationCompositionElementDefinition> acElementDefinitions) {
var automationComposition = automationCompositionMap.get(updateMsg.getAutomationCompositionId());
// elements to existing AutomationComposition has to be supported).
if (automationComposition != null) {
var automationCompositionUpdateAck =
- new AutomationCompositionAck(ParticipantMessageType.AUTOMATION_COMPOSITION_UPDATE_ACK);
+ new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY_ACK);
automationCompositionUpdateAck.setParticipantId(participantId);
automationCompositionUpdateAck.setMessage("Automation composition " + updateMsg.getAutomationCompositionId()
updateMsg.getAutomationCompositionId());
}
- private void handleAcUpdatePhaseN(AutomationCompositionUpdate updateMsg,
+ private void handleAcUpdatePhaseN(AutomationCompositionDeploy updateMsg,
List<AutomationCompositionElementDefinition> acElementDefinitions) {
var acElementList = updateMsg.getParticipantUpdatesList().stream()
}
private List<AutomationCompositionElement> storeElementsOnThisParticipant(
- List<ParticipantUpdates> participantUpdates) {
+ List<ParticipantDeploy> participantUpdates) {
var acElementList = participantUpdates.stream()
.flatMap(participantUpdate -> participantUpdate.getAutomationCompositionElementList().stream())
.filter(element -> participantId.equals(element.getParticipantId())).collect(Collectors.toList());
if (orderedState.equals(automationComposition.getOrderedState())) {
var automationCompositionAck =
- new AutomationCompositionAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK);
+ new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK);
automationCompositionAck.setParticipantId(participantId);
automationCompositionAck.setMessage("Automation composition is already in state " + orderedState);
automationCompositionAck.setResult(false);
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.concepts.ParticipantSupportedElementType;
+import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeploy;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionStateChange;
-import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionUpdate;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantAckMessage;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantDeregister;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantDeregisterAck;
@Timed(
value = "listener.automation_composition_update",
description = "AUTOMATION_COMPOSITION_UPDATE messages received")
- public void handleAutomationCompositionUpdate(AutomationCompositionUpdate updateMsg) {
- automationCompositionHandler.handleAutomationCompositionUpdate(updateMsg,
+ public void handleAutomationCompositionDeploy(AutomationCompositionDeploy updateMsg) {
+ automationCompositionHandler.handleAutomationCompositionDeploy(updateMsg,
acElementDefsMap.get(updateMsg.getCompositionId()));
}
import org.mockito.Mockito;
import org.onap.policy.clamp.acm.participant.intermediary.main.parameters.CommonTestData;
import org.onap.policy.clamp.common.acm.exception.AutomationCompositionRuntimeException;
-import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionAck;
+import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeployAck;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantDeregister;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantMessageType;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantRegister;
var participantUpdateListener = new ParticipantUpdateListener(participantHandler);
assertEquals(ParticipantMessageType.PARTICIPANT_UPDATE.name(), participantUpdateListener.getType());
- var automationCompositionUpdateListener = new AutomationCompositionUpdateListener(participantHandler);
- assertEquals(ParticipantMessageType.AUTOMATION_COMPOSITION_UPDATE.name(),
+ var automationCompositionUpdateListener = new AutomationCompositionDeployListener(participantHandler);
+ assertEquals(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY.name(),
automationCompositionUpdateListener.getType());
var automationCompositionStateChangeListener = new AutomationCompositionStateChangeListener(participantHandler);
assertThrows(AutomationCompositionRuntimeException.class,
() -> participantMessagePublisher.sendParticipantDeregister(participantDeregister));
- var automationCompositionAck = Mockito.mock(AutomationCompositionAck.class);
+ var automationCompositionAck = Mockito.mock(AutomationCompositionDeployAck.class);
assertThrows(AutomationCompositionRuntimeException.class,
() -> participantMessagePublisher.sendAutomationCompositionAck(automationCompositionAck));
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementDefinition;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionOrderedState;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionState;
-import org.onap.policy.clamp.models.acm.concepts.ParticipantUpdates;
+import org.onap.policy.clamp.models.acm.concepts.ParticipantDeploy;
+import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeploy;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionStateChange;
-import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionUpdate;
import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate;
import org.springframework.test.context.junit.jupiter.SpringExtension;
var acd = new AutomationCompositionElementDefinition();
acd.setAcElementDefinitionId(definition);
- var updateMsg = new AutomationCompositionUpdate();
+ var updateMsg = new AutomationCompositionDeploy();
updateMsg.setAutomationCompositionId(UUID.randomUUID());
updateMsg.setMessageId(uuid);
updateMsg.setParticipantId(partecipantId);
updateMsg.setStartPhase(0);
var acElementDefinitions = List.of(acd);
- assertDoesNotThrow(() -> ach.handleAutomationCompositionUpdate(updateMsg, acElementDefinitions));
+ assertDoesNotThrow(() -> ach.handleAutomationCompositionDeploy(updateMsg, acElementDefinitions));
updateMsg.setStartPhase(1);
- assertDoesNotThrow(() -> ach.handleAutomationCompositionUpdate(updateMsg, acElementDefinitions));
+ assertDoesNotThrow(() -> ach.handleAutomationCompositionDeploy(updateMsg, acElementDefinitions));
ach.getAutomationCompositionMap().clear();
updateMsg.setStartPhase(0);
- assertDoesNotThrow(() -> ach.handleAutomationCompositionUpdate(updateMsg, acElementDefinitions));
+ assertDoesNotThrow(() -> ach.handleAutomationCompositionDeploy(updateMsg, acElementDefinitions));
updateMsg.setAutomationCompositionId(UUID.randomUUID());
- updateMsg.setParticipantUpdatesList(List.of(mock(ParticipantUpdates.class)));
- assertDoesNotThrow(() -> ach.handleAutomationCompositionUpdate(updateMsg, acElementDefinitions));
+ updateMsg.setParticipantUpdatesList(List.of(mock(ParticipantDeploy.class)));
+ assertDoesNotThrow(() -> ach.handleAutomationCompositionDeploy(updateMsg, acElementDefinitions));
updateMsg.setStartPhase(1);
- var participantUpdate = new ParticipantUpdates();
- participantUpdate.setParticipantId(partecipantId);
+ var participantDeploy = new ParticipantDeploy();
+ participantDeploy.setParticipantId(partecipantId);
var element = new AutomationCompositionElement();
element.setDefinition(definition);
- participantUpdate.setAutomationCompositionElementList(List.of(element));
- updateMsg.setParticipantUpdatesList(List.of(participantUpdate));
+ participantDeploy.setAutomationCompositionElementList(List.of(element));
+ updateMsg.setParticipantUpdatesList(List.of(participantDeploy));
var acd2 = new AutomationCompositionElementDefinition();
acd2.setAcElementDefinitionId(definition);
acd2.setAutomationCompositionElementToscaNodeTemplate(mock(ToscaNodeTemplate.class));
- assertDoesNotThrow(() -> ach.handleAutomationCompositionUpdate(updateMsg, List.of(acd2)));
+ assertDoesNotThrow(() -> ach.handleAutomationCompositionDeploy(updateMsg, List.of(acd2)));
}
void checkAppliesTo() {
var participantHandler = commonTestData.getMockParticipantHandler();
var participantAckMsg =
- new ParticipantAckMessage(ParticipantMessageType.AUTOMATION_COMPOSITION_UPDATE);
+ new ParticipantAckMessage(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY);
assertTrue(participantHandler.appliesTo(participantAckMsg));
var participantMsg =
import java.util.UUID;
import javax.ws.rs.core.Response;
import lombok.AllArgsConstructor;
+import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionDeployPublisher;
import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionStateChangePublisher;
-import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionUpdatePublisher;
import org.onap.policy.clamp.common.acm.exception.AutomationCompositionException;
+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.AutomationCompositionElementAck;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionState;
import org.onap.policy.clamp.models.acm.concepts.ParticipantUtils;
-import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionAck;
+import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeployAck;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantUpdateAck;
import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
private final AcDefinitionProvider acDefinitionProvider;
// Publishers for participant communication
- private final AutomationCompositionUpdatePublisher automationCompositionUpdatePublisher;
+ private final AutomationCompositionDeployPublisher automationCompositionDeployPublisher;
private final AutomationCompositionStateChangePublisher automationCompositionStateChangePublisher;
/**
*/
@MessageIntercept
@Timed(
- value = "listener.automation_composition_update_ack",
- description = "AUTOMATION_COMPOSITION_UPDATE_ACK messages received")
- public void handleAutomationCompositionUpdateAckMessage(AutomationCompositionAck automationCompositionAckMessage) {
+ value = "listener.automation_composition_deploy_ack",
+ description = "AUTOMATION_COMPOSITION_DEPLOY_ACK messages received")
+ public void handleAutomationCompositionUpdateAckMessage(
+ AutomationCompositionDeployAck automationCompositionAckMessage) {
LOGGER.debug("AutomationComposition Update Ack message received {}", automationCompositionAckMessage);
setAcElementStateInDb(automationCompositionAckMessage);
}
value = "listener.automation_composition_statechange_ack",
description = "AUTOMATION_COMPOSITION_STATECHANGE_ACK messages received")
public void handleAutomationCompositionStateChangeAckMessage(
- AutomationCompositionAck automationCompositionAckMessage) {
+ AutomationCompositionDeployAck automationCompositionAckMessage) {
LOGGER.debug("AutomationComposition StateChange Ack message received {}", automationCompositionAckMessage);
setAcElementStateInDb(automationCompositionAckMessage);
}
- private void setAcElementStateInDb(AutomationCompositionAck automationCompositionAckMessage) {
+ private void setAcElementStateInDb(AutomationCompositionDeployAck automationCompositionAckMessage) {
if (automationCompositionAckMessage.getAutomationCompositionResultMap() != null) {
var automationComposition = automationCompositionProvider
.findAutomationComposition(automationCompositionAckMessage.getAutomationCompositionId());
}
private boolean updateState(AutomationComposition automationComposition,
- Set<Map.Entry<UUID, AutomationCompositionElementAck>> automationCompositionResultSet) {
+ Set<Map.Entry<UUID, AcElementDeployAck>> automationCompositionResultSet) {
var updated = false;
for (var acElementAck : automationCompositionResultSet) {
var element = automationComposition.getElements().get(acElementAck.getKey());
break;
case UNINITIALISED:
automationComposition.setState(AutomationCompositionState.UNINITIALISED2PASSIVE);
- automationCompositionUpdatePublisher.send(automationComposition);
+ automationCompositionDeployPublisher.send(automationComposition);
break;
case UNINITIALISED2PASSIVE:
import java.util.Map;
import java.util.UUID;
import org.onap.policy.clamp.acm.runtime.main.parameters.AcRuntimeParameterGroup;
+import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionDeployPublisher;
import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionStateChangePublisher;
-import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionUpdatePublisher;
import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionState;
import org.onap.policy.clamp.models.acm.concepts.Participant;
private final AutomationCompositionProvider automationCompositionProvider;
private final AcDefinitionProvider acDefinitionProvider;
private final AutomationCompositionStateChangePublisher automationCompositionStateChangePublisher;
- private final AutomationCompositionUpdatePublisher automationCompositionUpdatePublisher;
+ private final AutomationCompositionDeployPublisher automationCompositionDeployPublisher;
private final ParticipantProvider participantProvider;
/**
* @param automationCompositionProvider the provider to use to read automation compositions from the database
* @param acDefinitionProvider the Policy Models Provider
* @param automationCompositionStateChangePublisher the AutomationComposition StateChange Publisher
- * @param automationCompositionUpdatePublisher the AutomationCompositionUpdate Publisher
+ * @param automationCompositionDeployPublisher the AutomationCompositionUpdate Publisher
* @param participantProvider the Participant Provider
* @param acRuntimeParameterGroup the parameters for the automation composition runtime
*/
public SupervisionScanner(final AutomationCompositionProvider automationCompositionProvider,
AcDefinitionProvider acDefinitionProvider,
final AutomationCompositionStateChangePublisher automationCompositionStateChangePublisher,
- AutomationCompositionUpdatePublisher automationCompositionUpdatePublisher,
+ AutomationCompositionDeployPublisher automationCompositionDeployPublisher,
ParticipantProvider participantProvider,
final AcRuntimeParameterGroup acRuntimeParameterGroup) {
this.automationCompositionProvider = automationCompositionProvider;
this.acDefinitionProvider = acDefinitionProvider;
this.automationCompositionStateChangePublisher = automationCompositionStateChangePublisher;
- this.automationCompositionUpdatePublisher = automationCompositionUpdatePublisher;
+ this.automationCompositionDeployPublisher = automationCompositionDeployPublisher;
this.participantProvider = participantProvider;
automationCompositionCounter.setMaxRetryCount(
private void sendAutomationCompositionMsg(AutomationComposition automationComposition, int startPhase) {
if (AutomationCompositionState.UNINITIALISED2PASSIVE.equals(automationComposition.getState())) {
LOGGER.debug("retry message AutomationCompositionUpdate");
- automationCompositionUpdatePublisher.send(automationComposition, startPhase);
+ automationCompositionDeployPublisher.send(automationComposition, startPhase);
} else {
LOGGER.debug("retry message AutomationCompositionStateChange");
automationCompositionStateChangePublisher.send(automationComposition, startPhase);
import java.util.UUID;
import lombok.AllArgsConstructor;
import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
-import org.onap.policy.clamp.models.acm.concepts.ParticipantUpdates;
-import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionUpdate;
+import org.onap.policy.clamp.models.acm.concepts.ParticipantDeploy;
+import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeploy;
import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
import org.onap.policy.clamp.models.acm.utils.AcmUtils;
import org.slf4j.Logger;
import org.springframework.stereotype.Component;
/**
- * This class is used to send AutomationCompositionUpdate messages to participants on DMaaP.
+ * This class is used to send AutomationCompositionDeploy messages to participants on DMaaP.
*/
@Component
@AllArgsConstructor
-public class AutomationCompositionUpdatePublisher extends AbstractParticipantPublisher<AutomationCompositionUpdate> {
+public class AutomationCompositionDeployPublisher extends AbstractParticipantPublisher<AutomationCompositionDeploy> {
- private static final Logger LOGGER = LoggerFactory.getLogger(AutomationCompositionUpdatePublisher.class);
+ private static final Logger LOGGER = LoggerFactory.getLogger(AutomationCompositionDeployPublisher.class);
private final AcDefinitionProvider acDefinitionProvider;
/**
- * Send AutomationCompositionUpdate to Participant.
+ * Send AutomationCompositionDeploy to Participant.
*
* @param automationComposition the AutomationComposition
*/
- @Timed(value = "publisher.automation_composition_update",
- description = "AUTOMATION_COMPOSITION_UPDATE messages published")
+ @Timed(value = "publisher.automation_composition_deploy",
+ description = "AUTOMATION_COMPOSITION_DEPLOY messages published")
public void send(AutomationComposition automationComposition) {
send(automationComposition, 0);
}
/**
- * Send AutomationCompositionUpdate to Participant.
+ * Send AutomationCompositionDeploy to Participant.
*
* @param automationComposition the AutomationComposition
* @param startPhase the Start Phase
*/
- @Timed(value = "publisher.automation_composition_update",
- description = "AUTOMATION_COMPOSITION_UPDATE messages published")
+ @Timed(value = "publisher.automation_composition_deploy",
+ description = "AUTOMATION_COMPOSITION_DEPLOY messages published")
public void send(AutomationComposition automationComposition, int startPhase) {
- var automationCompositionUpdateMsg = new AutomationCompositionUpdate();
- automationCompositionUpdateMsg.setCompositionId(automationComposition.getCompositionId());
- automationCompositionUpdateMsg.setStartPhase(startPhase);
- automationCompositionUpdateMsg.setAutomationCompositionId(automationComposition.getInstanceId());
- automationCompositionUpdateMsg.setMessageId(UUID.randomUUID());
- automationCompositionUpdateMsg.setTimestamp(Instant.now());
+ var acDeployMsg = new AutomationCompositionDeploy();
+ acDeployMsg.setCompositionId(automationComposition.getCompositionId());
+ acDeployMsg.setStartPhase(startPhase);
+ acDeployMsg.setAutomationCompositionId(automationComposition.getInstanceId());
+ acDeployMsg.setMessageId(UUID.randomUUID());
+ acDeployMsg.setTimestamp(Instant.now());
var toscaServiceTemplate =
acDefinitionProvider.getAcDefinition(automationComposition.getCompositionId()).getServiceTemplate();
- List<ParticipantUpdates> participantUpdates = new ArrayList<>();
+ List<ParticipantDeploy> participantDeploys = new ArrayList<>();
for (var element : automationComposition.getElements().values()) {
AcmUtils.setAcPolicyInfo(element, toscaServiceTemplate);
- AcmUtils.prepareParticipantUpdate(element, participantUpdates);
+ AcmUtils.prepareParticipantUpdate(element, participantDeploys);
}
- automationCompositionUpdateMsg.setParticipantUpdatesList(participantUpdates);
+ acDeployMsg.setParticipantUpdatesList(participantDeploys);
- LOGGER.debug("AutomationCompositionUpdate message sent {}", automationCompositionUpdateMsg);
- super.send(automationCompositionUpdateMsg);
+ LOGGER.debug("AutomationCompositionDeploy message sent {}", acDeployMsg);
+ super.send(acDeployMsg);
}
}
import org.onap.policy.clamp.acm.runtime.config.messaging.Listener;
import org.onap.policy.clamp.acm.runtime.supervision.SupervisionHandler;
-import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionAck;
+import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeployAck;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantMessageType;
import org.onap.policy.common.endpoints.event.comm.Topic.CommInfrastructure;
import org.onap.policy.common.endpoints.listeners.ScoListener;
* Listener for AutomationCompositionStateChangeAck messages sent by participants.
*/
@Component
-public class AutomationCompositionStateChangeAckListener extends ScoListener<AutomationCompositionAck>
- implements Listener<AutomationCompositionAck> {
+public class AutomationCompositionStateChangeAckListener extends ScoListener<AutomationCompositionDeployAck>
+ implements Listener<AutomationCompositionDeployAck> {
private static final Logger LOGGER = LoggerFactory.getLogger(AutomationCompositionStateChangeAckListener.class);
private final SupervisionHandler supervisionHandler;
* Constructs the object.
*/
public AutomationCompositionStateChangeAckListener(SupervisionHandler supervisionHandler) {
- super(AutomationCompositionAck.class);
+ super(AutomationCompositionDeployAck.class);
this.supervisionHandler = supervisionHandler;
}
@Override
public void onTopicEvent(final CommInfrastructure infra, final String topic, final StandardCoderObject sco,
- final AutomationCompositionAck automationCompositionStateChangeAckMessage) {
+ final AutomationCompositionDeployAck automationCompositionStateChangeAckMessage) {
LOGGER.debug("AutomationCompositionStateChangeAck received from participant - {}",
automationCompositionStateChangeAckMessage);
supervisionHandler.handleAutomationCompositionStateChangeAckMessage(automationCompositionStateChangeAckMessage);
}
@Override
- public ScoListener<AutomationCompositionAck> getScoListener() {
+ public ScoListener<AutomationCompositionDeployAck> getScoListener() {
return this;
}
import org.onap.policy.clamp.acm.runtime.config.messaging.Listener;
import org.onap.policy.clamp.acm.runtime.supervision.SupervisionHandler;
-import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionAck;
+import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeployAck;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantMessageType;
import org.onap.policy.common.endpoints.event.comm.Topic.CommInfrastructure;
import org.onap.policy.common.endpoints.listeners.ScoListener;
* Listener for AutomationCompositionUpdateAck messages sent by participants.
*/
@Component
-public class AutomationCompositionUpdateAckListener extends ScoListener<AutomationCompositionAck>
- implements Listener<AutomationCompositionAck> {
+public class AutomationCompositionUpdateAckListener extends ScoListener<AutomationCompositionDeployAck>
+ implements Listener<AutomationCompositionDeployAck> {
private static final Logger LOGGER = LoggerFactory.getLogger(AutomationCompositionUpdateAckListener.class);
private final SupervisionHandler supervisionHandler;
* Constructs the object.
*/
public AutomationCompositionUpdateAckListener(SupervisionHandler supervisionHandler) {
- super(AutomationCompositionAck.class);
+ super(AutomationCompositionDeployAck.class);
this.supervisionHandler = supervisionHandler;
}
@Override
public void onTopicEvent(final CommInfrastructure infra, final String topic, final StandardCoderObject sco,
- final AutomationCompositionAck automationCompositionUpdateAckMessage) {
+ final AutomationCompositionDeployAck automationCompositionUpdateAckMessage) {
LOGGER.debug("AutomationCompositionUpdateAck message received from participant - {}",
automationCompositionUpdateAckMessage);
supervisionHandler.handleAutomationCompositionUpdateAckMessage(automationCompositionUpdateAckMessage);
}
@Override
- public ScoListener<AutomationCompositionAck> getScoListener() {
+ public ScoListener<AutomationCompositionDeployAck> getScoListener() {
return this;
}
@Override
public String getType() {
- return ParticipantMessageType.AUTOMATION_COMPOSITION_UPDATE_ACK.name();
+ return ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY_ACK.name();
}
}
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import org.onap.policy.clamp.acm.runtime.instantiation.InstantiationUtils;
+import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionDeployPublisher;
import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionStateChangePublisher;
-import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionUpdatePublisher;
import org.onap.policy.clamp.acm.runtime.util.CommonTestData;
import org.onap.policy.clamp.common.acm.exception.AutomationCompositionException;
import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionOrderedState;
import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionState;
import org.onap.policy.clamp.models.acm.concepts.ParticipantState;
-import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionAck;
+import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeployAck;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantMessageType;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantUpdateAck;
import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
@Test
void testTriggerAutomationCompositionSupervision() throws AutomationCompositionException {
- var automationCompositionUpdatePublisher = mock(AutomationCompositionUpdatePublisher.class);
- var handler = createSupervisionHandlerForTrigger(automationCompositionUpdatePublisher);
+ var automationCompositionDeployPublisher = mock(AutomationCompositionDeployPublisher.class);
+ var handler = createSupervisionHandlerForTrigger(automationCompositionDeployPublisher);
var automationComposition =
InstantiationUtils.getAutomationCompositionFromResource(AC_INSTANTIATION_CREATE_JSON, "Crud");
automationComposition.setState(AutomationCompositionState.UNINITIALISED);
handler.triggerAutomationCompositionSupervision(automationComposition);
- verify(automationCompositionUpdatePublisher).send(automationComposition);
+ verify(automationCompositionDeployPublisher).send(automationComposition);
}
@Test
var automationCompositionProvider = mock(AutomationCompositionProvider.class);
var handler = new SupervisionHandler(automationCompositionProvider, acDefinitionProvider,
- mock(AutomationCompositionUpdatePublisher.class), automationCompositionStateChangePublisher);
+ mock(AutomationCompositionDeployPublisher.class), automationCompositionStateChangePublisher);
handler.triggerAutomationCompositionSupervision(automationComposition);
void testAcRunningToPassive() throws AutomationCompositionException {
var automationCompositionStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
var handler = createSupervisionHandler(mock(AutomationCompositionProvider.class),
- mock(AutomationCompositionUpdatePublisher.class), automationCompositionStateChangePublisher,
+ mock(AutomationCompositionDeployPublisher.class), automationCompositionStateChangePublisher,
AutomationCompositionOrderedState.PASSIVE, AutomationCompositionState.UNINITIALISED);
var automationComposition =
void testAcPassiveToRunning() throws AutomationCompositionException {
var automationCompositionStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
var handler = createSupervisionHandler(mock(AutomationCompositionProvider.class),
- mock(AutomationCompositionUpdatePublisher.class), automationCompositionStateChangePublisher,
+ mock(AutomationCompositionDeployPublisher.class), automationCompositionStateChangePublisher,
AutomationCompositionOrderedState.PASSIVE, AutomationCompositionState.UNINITIALISED);
var automationComposition =
void testHandleAutomationCompositionStateChangeAckMessage() {
var automationCompositionProvider = mock(AutomationCompositionProvider.class);
var handler = createSupervisionHandler(automationCompositionProvider,
- mock(AutomationCompositionUpdatePublisher.class), mock(AutomationCompositionStateChangePublisher.class),
+ mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
AutomationCompositionOrderedState.PASSIVE, AutomationCompositionState.UNINITIALISED);
var automationCompositionAckMessage =
- new AutomationCompositionAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK);
+ new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK);
automationCompositionAckMessage.setAutomationCompositionResultMap(Map.of());
automationCompositionAckMessage.setAutomationCompositionId(IDENTIFIER);
@Test
void testHandleAutomationCompositionUpdateAckMessage() {
var automationCompositionAckMessage =
- new AutomationCompositionAck(ParticipantMessageType.AUTOMATION_COMPOSITION_UPDATE_ACK);
+ new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY_ACK);
automationCompositionAckMessage.setParticipantId(CommonTestData.getParticipantId());
automationCompositionAckMessage.setAutomationCompositionResultMap(Map.of());
automationCompositionAckMessage.setAutomationCompositionId(IDENTIFIER);
var automationCompositionProvider = mock(AutomationCompositionProvider.class);
var handler = createSupervisionHandler(automationCompositionProvider,
- mock(AutomationCompositionUpdatePublisher.class), mock(AutomationCompositionStateChangePublisher.class),
+ mock(AutomationCompositionDeployPublisher.class), mock(AutomationCompositionStateChangePublisher.class),
AutomationCompositionOrderedState.PASSIVE, AutomationCompositionState.UNINITIALISED);
handler.handleAutomationCompositionUpdateAckMessage(automationCompositionAckMessage);
participantUpdateAckMessage.setState(ParticipantState.ON_LINE);
var acDefinitionProvider = mock(AcDefinitionProvider.class);
var handler = new SupervisionHandler(mock(AutomationCompositionProvider.class), acDefinitionProvider,
- mock(AutomationCompositionUpdatePublisher.class),
+ mock(AutomationCompositionDeployPublisher.class),
mock(AutomationCompositionStateChangePublisher.class));
handler.handleParticipantMessage(participantUpdateAckMessage);
.thenReturn(Optional.of(acDefinition));
var handler = new SupervisionHandler(mock(AutomationCompositionProvider.class), acDefinitionProvider,
- mock(AutomationCompositionUpdatePublisher.class),
+ mock(AutomationCompositionDeployPublisher.class),
mock(AutomationCompositionStateChangePublisher.class));
handler.handleParticipantMessage(participantUpdateAckMessage);
.thenReturn(Optional.of(acDefinition));
var handler = new SupervisionHandler(mock(AutomationCompositionProvider.class), acDefinitionProvider,
- mock(AutomationCompositionUpdatePublisher.class),
+ mock(AutomationCompositionDeployPublisher.class),
mock(AutomationCompositionStateChangePublisher.class));
handler.handleParticipantMessage(participantUpdateAckMessage);
}
private SupervisionHandler createSupervisionHandler(AutomationCompositionProvider automationCompositionProvider,
- AutomationCompositionUpdatePublisher automationCompositionUpdatePublisher,
+ AutomationCompositionDeployPublisher automationCompositionDeployPublisher,
AutomationCompositionStateChangePublisher automationCompositionStateChangePublisher,
AutomationCompositionOrderedState orderedState, AutomationCompositionState state) {
var automationComposition =
when(acDefinitionProvider.getAcDefinition(automationComposition.getCompositionId())).thenReturn(acDefinition);
return new SupervisionHandler(automationCompositionProvider, acDefinitionProvider,
- automationCompositionUpdatePublisher, automationCompositionStateChangePublisher);
+ automationCompositionDeployPublisher, automationCompositionStateChangePublisher);
}
private SupervisionHandler createSupervisionHandlerForTrigger() {
return new SupervisionHandler(mock(AutomationCompositionProvider.class), mock(AcDefinitionProvider.class),
- mock(AutomationCompositionUpdatePublisher.class),
+ mock(AutomationCompositionDeployPublisher.class),
mock(AutomationCompositionStateChangePublisher.class));
}
private SupervisionHandler createSupervisionHandlerForTrigger(
- AutomationCompositionUpdatePublisher automationCompositionUpdatePublisher) {
+ AutomationCompositionDeployPublisher automationCompositionDeployPublisher) {
return new SupervisionHandler(mock(AutomationCompositionProvider.class), mock(AcDefinitionProvider.class),
- automationCompositionUpdatePublisher, mock(AutomationCompositionStateChangePublisher.class));
+ automationCompositionDeployPublisher, mock(AutomationCompositionStateChangePublisher.class));
}
}
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.onap.policy.clamp.acm.runtime.instantiation.InstantiationUtils;
+import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionDeployPublisher;
import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionStateChangePublisher;
-import org.onap.policy.clamp.acm.runtime.supervision.comm.AutomationCompositionUpdatePublisher;
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;
void testScannerOrderedStateEqualsToState() {
var automationCompositionProvider = mock(AutomationCompositionProvider.class);
var automationCompositionStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
- var automationCompositionUpdatePublisher = mock(AutomationCompositionUpdatePublisher.class);
+ var automationCompositionDeployPublisher = mock(AutomationCompositionDeployPublisher.class);
var participantProvider = mock(ParticipantProvider.class);
var acRuntimeParameterGroup = CommonTestData.geParameterGroup("dbScanner");
.thenReturn(List.of(automationComposition));
var supervisionScanner = new SupervisionScanner(automationCompositionProvider, acDefinitionProvider,
- automationCompositionStateChangePublisher, automationCompositionUpdatePublisher, participantProvider,
+ automationCompositionStateChangePublisher, automationCompositionDeployPublisher, participantProvider,
acRuntimeParameterGroup);
supervisionScanner.run(false);
when(automationCompositionProvider.getAcInstancesByCompositionId(compositionId))
.thenReturn(List.of(automationComposition));
- var automationCompositionUpdatePublisher = mock(AutomationCompositionUpdatePublisher.class);
+ var automationCompositionDeployPublisher = mock(AutomationCompositionDeployPublisher.class);
var automationCompositionStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
var participantProvider = mock(ParticipantProvider.class);
var acRuntimeParameterGroup = CommonTestData.geParameterGroup("dbScanner");
var supervisionScanner = new SupervisionScanner(automationCompositionProvider, acDefinitionProvider,
- automationCompositionStateChangePublisher, automationCompositionUpdatePublisher, participantProvider,
+ automationCompositionStateChangePublisher, automationCompositionDeployPublisher, participantProvider,
acRuntimeParameterGroup);
supervisionScanner.run(false);
var participant = CommonTestData.createParticipant(CommonTestData.getParticipantId());
when(participantProvider.getParticipants()).thenReturn(List.of(participant));
- var automationCompositionUpdatePublisher = mock(AutomationCompositionUpdatePublisher.class);
+ var automationCompositionDeployPublisher = mock(AutomationCompositionDeployPublisher.class);
var automationCompositionStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
var acRuntimeParameterGroup = CommonTestData.geParameterGroup("dbScanner");
var supervisionScanner = new SupervisionScanner(automationCompositionProvider, acDefinitionProvider,
- automationCompositionStateChangePublisher, automationCompositionUpdatePublisher, participantProvider,
+ automationCompositionStateChangePublisher, automationCompositionDeployPublisher, participantProvider,
acRuntimeParameterGroup);
supervisionScanner.handleParticipantStatus(participant.getParticipantId());
.thenReturn(List.of(automationComposition));
var participantProvider = mock(ParticipantProvider.class);
- var automationCompositionUpdatePublisher = mock(AutomationCompositionUpdatePublisher.class);
+ var automationCompositionDeployPublisher = mock(AutomationCompositionDeployPublisher.class);
var automationCompositionStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
var acRuntimeParameterGroup = CommonTestData.geParameterGroup("dbScanner");
var supervisionScanner = new SupervisionScanner(automationCompositionProvider, acDefinitionProvider,
- automationCompositionStateChangePublisher, automationCompositionUpdatePublisher, participantProvider,
+ automationCompositionStateChangePublisher, automationCompositionDeployPublisher, participantProvider,
acRuntimeParameterGroup);
supervisionScanner.run(false);
- verify(automationCompositionUpdatePublisher).send(any(AutomationComposition.class), anyInt());
+ verify(automationCompositionDeployPublisher).send(any(AutomationComposition.class), anyInt());
}
@Test
var participantProvider = mock(ParticipantProvider.class);
when(participantProvider.getParticipants()).thenReturn(List.of(participant));
- var automationCompositionUpdatePublisher = mock(AutomationCompositionUpdatePublisher.class);
+ var automationCompositionDeployPublisher = mock(AutomationCompositionDeployPublisher.class);
var automationCompositionStateChangePublisher = mock(AutomationCompositionStateChangePublisher.class);
var supervisionScanner = new SupervisionScanner(automationCompositionProvider, acDefinitionProvider,
- automationCompositionStateChangePublisher, automationCompositionUpdatePublisher, participantProvider,
+ automationCompositionStateChangePublisher, automationCompositionDeployPublisher, participantProvider,
acRuntimeParameterGroup);
supervisionScanner.handleParticipantStatus(participant.getParticipantId());
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.AutomationCompositionState;
-import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionAck;
+import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionDeployAck;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantDeregister;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantDeregisterAck;
import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantMessageType;
@Test
void testAutomationCompositionUpdateAckListener() {
final var automationCompositionAck =
- new AutomationCompositionAck(ParticipantMessageType.AUTOMATION_COMPOSITION_UPDATE);
+ new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_DEPLOY);
var supervisionHandler = mock(SupervisionHandler.class);
var acUpdateAckListener = new AutomationCompositionUpdateAckListener(supervisionHandler);
acUpdateAckListener.onTopicEvent(INFRA, TOPIC, null, automationCompositionAck);
@Test
void testAutomationCompositionStateChangeAckListener() {
final var automationCompositionAck =
- new AutomationCompositionAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATE_CHANGE);
+ new AutomationCompositionDeployAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATE_CHANGE);
var supervisionHandler = mock(SupervisionHandler.class);
var acStateChangeAckListener = new AutomationCompositionStateChangeAckListener(supervisionHandler);
acStateChangeAckListener.onTopicEvent(INFRA, TOPIC, null, automationCompositionAck);
Code Review / policy / clamp.git / commitdiff