gerrit.onap Code Review - policy/clamp.git/blob

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  *  Copyright (C) 2021-2023 Nordix Foundation.
   4  *  Modifications Copyright (C) 2021 AT&T Intellectual Property. All rights reserved.
   5  * ================================================================================
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *      http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  * SPDX-License-Identifier: Apache-2.0
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.onap.policy.clamp.acm.participant.intermediary.handler;
  23
  24 import java.util.ArrayList;
  25 import java.util.HashMap;
  26 import java.util.LinkedHashMap;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.UUID;
  30 import java.util.stream.Collectors;
  31 import lombok.Getter;
  32 import org.onap.policy.clamp.acm.participant.intermediary.api.AutomationCompositionElementListener;
  33 import org.onap.policy.clamp.acm.participant.intermediary.comm.ParticipantMessagePublisher;
  34 import org.onap.policy.clamp.acm.participant.intermediary.parameters.ParticipantParameters;
  35 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
  36 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElement;
  37 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementAck;
  38 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionElementDefinition;
  39 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionOrderedState;
  40 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionState;
  41 import org.onap.policy.clamp.models.acm.concepts.ParticipantUpdates;
  42 import org.onap.policy.clamp.models.acm.concepts.ParticipantUtils;
  43 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionAck;
  44 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionStateChange;
  45 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.AutomationCompositionUpdate;
  46 import org.onap.policy.clamp.models.acm.messages.dmaap.participant.ParticipantMessageType;
  47 import org.onap.policy.models.base.PfModelException;
  48 import org.onap.policy.models.tosca.authorative.concepts.ToscaConceptIdentifier;
  49 import org.onap.policy.models.tosca.authorative.concepts.ToscaNodeTemplate;
  50 import org.slf4j.Logger;
  51 import org.slf4j.LoggerFactory;
  52 import org.springframework.stereotype.Component;
  53
  54 /*
  55  * This class is responsible for managing the state of all automation compositions in the participant.
  56  */
  57 @Component
  58 public class AutomationCompositionHandler {
  59     private static final Logger LOGGER = LoggerFactory.getLogger(AutomationCompositionHandler.class);
  60
  61     private final UUID participantId;
  62     private final ParticipantMessagePublisher publisher;
  63
  64     @Getter
  65     private final Map<UUID, AutomationComposition> automationCompositionMap = new LinkedHashMap<>();
  66
  67     @Getter
  68     private final Map<UUID, AutomationCompositionElement> elementsOnThisParticipant = new LinkedHashMap<>();
  69
  70     @Getter
  71     private List<AutomationCompositionElementListener> listeners = new ArrayList<>();
  72
  73     /**
  74      * Constructor, set the participant ID and messageSender.
  75      *
  76      * @param parameters the parameters of the participant
  77      * @param publisher the ParticipantMessage Publisher
  78      */
  79     public AutomationCompositionHandler(ParticipantParameters parameters, ParticipantMessagePublisher publisher) {
  80         this.participantId = parameters.getIntermediaryParameters().getParticipantId();
  81         this.publisher = publisher;
  82     }
  83
  84     public void registerAutomationCompositionElementListener(AutomationCompositionElementListener listener) {
  85         listeners.add(listener);
  86     }
  87
  88     /**
  89      * Handle a automation composition element state change message.
  90      *
  91      * @param automationCompositionId the automationComposition Id
  92      * @param id the automationComposition UUID
  93      * @param orderedState the current state
  94      * @param newState the ordered state
  95      * @return automationCompositionElement the updated automation composition element
  96      */
  97     public AutomationCompositionElement updateAutomationCompositionElementState(UUID automationCompositionId, UUID id,
  98             AutomationCompositionOrderedState orderedState, AutomationCompositionState newState) {
  99
 100         if (id == null) {
 101             LOGGER.warn("Cannot update Automation composition element state, id is null");
 102             return null;
 103         }
 104
 105         // Update states of AutomationCompositionElement in automationCompositionMap
 106         for (var automationComposition : automationCompositionMap.values()) {
 107             var element = automationComposition.getElements().get(id);
 108             if (element != null) {
 109                 element.setOrderedState(orderedState);
 110                 element.setState(newState);
 111             }
 112             var checkOpt = automationComposition.getElements().values().stream()
 113                     .filter(acElement -> !newState.equals(acElement.getState())).findAny();
 114             if (checkOpt.isEmpty()) {
 115                 automationComposition.setState(newState);
 116                 automationComposition.setOrderedState(orderedState);
 117             }
 118         }
 119
 120         // Update states of AutomationCompositionElement in elementsOnThisParticipant
 121         var acElement = elementsOnThisParticipant.get(id);
 122         if (acElement != null) {
 123             var automationCompositionStateChangeAck =
 124                     new AutomationCompositionAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK);
 125             automationCompositionStateChangeAck.setParticipantId(participantId);
 126             automationCompositionStateChangeAck.setAutomationCompositionId(automationCompositionId);
 127             acElement.setOrderedState(orderedState);
 128             acElement.setState(newState);
 129             automationCompositionStateChangeAck.getAutomationCompositionResultMap().put(acElement.getId(),
 130                     new AutomationCompositionElementAck(newState, true,
 131                             "Automation composition element {} state changed to {}\", id, newState)"));
 132             LOGGER.debug("Automation composition element {} state changed to {}", id, newState);
 133             automationCompositionStateChangeAck
 134                     .setMessage("AutomationCompositionElement state changed to {} " + newState);
 135             automationCompositionStateChangeAck.setResult(true);
 136             publisher.sendAutomationCompositionAck(automationCompositionStateChangeAck);
 137             return acElement;
 138         }
 139         return null;
 140     }
 141
 142     /**
 143      * Handle a automation composition state change message.
 144      *
 145      * @param stateChangeMsg the state change message
 146      * @param acElementDefinitions the list of AutomationCompositionElementDefinition
 147      */
 148     public void handleAutomationCompositionStateChange(AutomationCompositionStateChange stateChangeMsg,
 149             List<AutomationCompositionElementDefinition> acElementDefinitions) {
 150         if (stateChangeMsg.getAutomationCompositionId() == null) {
 151             return;
 152         }
 153
 154         var automationComposition = automationCompositionMap.get(stateChangeMsg.getAutomationCompositionId());
 155
 156         if (automationComposition == null) {
 157             var automationCompositionAck =
 158                     new AutomationCompositionAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK);
 159             automationCompositionAck.setParticipantId(participantId);
 160             automationCompositionAck.setMessage("Automation composition " + stateChangeMsg.getAutomationCompositionId()
 161                     + " does not use this participant " + participantId);
 162             automationCompositionAck.setResult(false);
 163             automationCompositionAck.setResponseTo(stateChangeMsg.getMessageId());
 164             automationCompositionAck.setAutomationCompositionId(stateChangeMsg.getAutomationCompositionId());
 165             publisher.sendAutomationCompositionAck(automationCompositionAck);
 166             LOGGER.debug("Automation composition {} does not use this participant",
 167                     stateChangeMsg.getAutomationCompositionId());
 168             return;
 169         }
 170
 171         handleState(automationComposition, stateChangeMsg.getOrderedState(), stateChangeMsg.getStartPhase(),
 172                 acElementDefinitions);
 173     }
 174
 175     /**
 176      * Method to handle state changes.
 177      *
 178      * @param automationComposition participant response
 179      * @param orderedState automation composition ordered state
 180      * @param startPhaseMsg startPhase from message
 181      * @param acElementDefinitions the list of AutomationCompositionElementDefinition
 182      */
 183     private void handleState(final AutomationComposition automationComposition,
 184             AutomationCompositionOrderedState orderedState, Integer startPhaseMsg,
 185             List<AutomationCompositionElementDefinition> acElementDefinitions) {
 186         switch (orderedState) {
 187             case UNINITIALISED:
 188                 handleUninitialisedState(automationComposition, orderedState, startPhaseMsg, acElementDefinitions);
 189                 break;
 190             case PASSIVE:
 191                 handlePassiveState(automationComposition, orderedState, startPhaseMsg, acElementDefinitions);
 192                 break;
 193             case RUNNING:
 194                 handleRunningState(automationComposition, orderedState, startPhaseMsg, acElementDefinitions);
 195                 break;
 196             default:
 197                 LOGGER.debug("StateChange message has no state, state is null {}", automationComposition.getKey());
 198                 break;
 199         }
 200     }
 201
 202     /**
 203      * Handle a automation composition update message.
 204      *
 205      * @param updateMsg the update message
 206      * @param acElementDefinitions the list of AutomationCompositionElementDefinition
 207      */
 208     public void handleAutomationCompositionUpdate(AutomationCompositionUpdate updateMsg,
 209             List<AutomationCompositionElementDefinition> acElementDefinitions) {
 210
 211         if (!updateMsg.appliesTo(participantId)) {
 212             return;
 213         }
 214
 215         if (0 == updateMsg.getStartPhase()) {
 216             handleAcUpdatePhase0(updateMsg, acElementDefinitions);
 217         } else {
 218             handleAcUpdatePhaseN(updateMsg, acElementDefinitions);
 219         }
 220     }
 221
 222     private void handleAcUpdatePhase0(AutomationCompositionUpdate updateMsg,
 223             List<AutomationCompositionElementDefinition> acElementDefinitions) {
 224         var automationComposition = automationCompositionMap.get(updateMsg.getAutomationCompositionId());
 225
 226         // TODO: Updates to existing AutomationCompositions are not supported yet (Addition/Removal of
 227         // AutomationComposition
 228         // elements to existing AutomationComposition has to be supported).
 229         if (automationComposition != null) {
 230             var automationCompositionUpdateAck =
 231                     new AutomationCompositionAck(ParticipantMessageType.AUTOMATION_COMPOSITION_UPDATE_ACK);
 232             automationCompositionUpdateAck.setParticipantId(participantId);
 233
 234             automationCompositionUpdateAck.setMessage("Automation composition " + updateMsg.getAutomationCompositionId()
 235                     + " already defined on participant " + participantId);
 236             automationCompositionUpdateAck.setResult(false);
 237             automationCompositionUpdateAck.setResponseTo(updateMsg.getMessageId());
 238             automationCompositionUpdateAck.setAutomationCompositionId(updateMsg.getAutomationCompositionId());
 239             publisher.sendAutomationCompositionAck(automationCompositionUpdateAck);
 240             return;
 241         }
 242
 243         if (updateMsg.getParticipantUpdatesList().isEmpty()) {
 244             LOGGER.warn("No AutomationCompositionElement updates in message {}",
 245                     updateMsg.getAutomationCompositionId());
 246             return;
 247         }
 248
 249         automationComposition = new AutomationComposition();
 250         automationComposition.setInstanceId(updateMsg.getAutomationCompositionId());
 251         var acElements = storeElementsOnThisParticipant(updateMsg.getParticipantUpdatesList());
 252         var acElementMap = prepareAcElementMap(acElements);
 253         automationComposition.setElements(acElementMap);
 254         automationCompositionMap.put(updateMsg.getAutomationCompositionId(), automationComposition);
 255
 256         handleAutomationCompositionElementUpdate(acElements, acElementDefinitions, updateMsg.getStartPhase(),
 257                 updateMsg.getAutomationCompositionId());
 258     }
 259
 260     private void handleAcUpdatePhaseN(AutomationCompositionUpdate updateMsg,
 261             List<AutomationCompositionElementDefinition> acElementDefinitions) {
 262
 263         var acElementList = updateMsg.getParticipantUpdatesList().stream()
 264                 .flatMap(participantUpdate -> participantUpdate.getAutomationCompositionElementList().stream())
 265                 .filter(element -> participantId.equals(element.getParticipantId())).collect(Collectors.toList());
 266
 267         handleAutomationCompositionElementUpdate(acElementList, acElementDefinitions, updateMsg.getStartPhase(),
 268                 updateMsg.getAutomationCompositionId());
 269     }
 270
 271     private void handleAutomationCompositionElementUpdate(List<AutomationCompositionElement> acElements,
 272             List<AutomationCompositionElementDefinition> acElementDefinitions, Integer startPhaseMsg,
 273             UUID automationCompositionId) {
 274         try {
 275             for (var element : acElements) {
 276                 var acElementNodeTemplate = getAcElementNodeTemplate(acElementDefinitions, element.getDefinition());
 277                 if (acElementNodeTemplate != null) {
 278                     int startPhase = ParticipantUtils.findStartPhase(acElementNodeTemplate.getProperties());
 279                     if (startPhaseMsg.equals(startPhase)) {
 280                         for (var acElementListener : listeners) {
 281                             var map = new HashMap<>(acElementNodeTemplate.getProperties());
 282                             map.putAll(element.getProperties());
 283                             acElementListener.automationCompositionElementUpdate(automationCompositionId, element, map);
 284                         }
 285                     }
 286                 }
 287             }
 288         } catch (PfModelException e) {
 289             LOGGER.debug("Automation composition element update failed {}", automationCompositionId);
 290         }
 291
 292     }
 293
 294     private ToscaNodeTemplate getAcElementNodeTemplate(
 295             List<AutomationCompositionElementDefinition> acElementDefinitions, ToscaConceptIdentifier acElementDefId) {
 296
 297         for (var acElementDefinition : acElementDefinitions) {
 298             if (acElementDefId.getName().contains(acElementDefinition.getAcElementDefinitionId().getName())) {
 299                 return acElementDefinition.getAutomationCompositionElementToscaNodeTemplate();
 300             }
 301         }
 302         return null;
 303     }
 304
 305     private List<AutomationCompositionElement> storeElementsOnThisParticipant(
 306             List<ParticipantUpdates> participantUpdates) {
 307         var acElementList = participantUpdates.stream()
 308                 .flatMap(participantUpdate -> participantUpdate.getAutomationCompositionElementList().stream())
 309                 .filter(element -> participantId.equals(element.getParticipantId())).collect(Collectors.toList());
 310
 311         for (var element : acElementList) {
 312             elementsOnThisParticipant.put(element.getId(), element);
 313         }
 314         return acElementList;
 315     }
 316
 317     private Map<UUID, AutomationCompositionElement> prepareAcElementMap(List<AutomationCompositionElement> acElements) {
 318         Map<UUID, AutomationCompositionElement> acElementMap = new LinkedHashMap<>();
 319         for (var element : acElements) {
 320             acElementMap.put(element.getId(), element);
 321         }
 322         return acElementMap;
 323     }
 324
 325     /**
 326      * Method to handle when the new state from participant is UNINITIALISED state.
 327      *
 328      * @param automationComposition participant response
 329      * @param orderedState orderedState
 330      * @param startPhaseMsg startPhase from message
 331      * @param acElementDefinitions the list of AutomationCompositionElementDefinition
 332      */
 333     private void handleUninitialisedState(final AutomationComposition automationComposition,
 334             final AutomationCompositionOrderedState orderedState, Integer startPhaseMsg,
 335             List<AutomationCompositionElementDefinition> acElementDefinitions) {
 336         handleStateChange(automationComposition, orderedState, startPhaseMsg, acElementDefinitions);
 337         boolean isAllUninitialised = automationComposition.getElements().values().stream()
 338                 .filter(element -> !AutomationCompositionState.UNINITIALISED.equals(element.getState())).findAny()
 339                 .isEmpty();
 340         if (isAllUninitialised) {
 341             automationCompositionMap.remove(automationComposition.getInstanceId());
 342             automationComposition.getElements().values()
 343                     .forEach(element -> elementsOnThisParticipant.remove(element.getId()));
 344         }
 345     }
 346
 347     /**
 348      * Method to handle when the new state from participant is PASSIVE state.
 349      *
 350      * @param automationComposition participant response
 351      * @param orderedState orderedState
 352      * @param startPhaseMsg startPhase from message
 353      * @param acElementDefinitions the list of AutomationCompositionElementDefinition
 354      */
 355     private void handlePassiveState(final AutomationComposition automationComposition,
 356             final AutomationCompositionOrderedState orderedState, Integer startPhaseMsg,
 357             List<AutomationCompositionElementDefinition> acElementDefinitions) {
 358         handleStateChange(automationComposition, orderedState, startPhaseMsg, acElementDefinitions);
 359     }
 360
 361     /**
 362      * Method to handle when the new state from participant is RUNNING state.
 363      *
 364      * @param automationComposition participant response
 365      * @param orderedState orderedState
 366      * @param startPhaseMsg startPhase from message
 367      * @param acElementDefinitions the list of AutomationCompositionElementDefinition
 368      */
 369     private void handleRunningState(final AutomationComposition automationComposition,
 370             final AutomationCompositionOrderedState orderedState, Integer startPhaseMsg,
 371             List<AutomationCompositionElementDefinition> acElementDefinitions) {
 372         handleStateChange(automationComposition, orderedState, startPhaseMsg, acElementDefinitions);
 373     }
 374
 375     /**
 376      * Method to update the state of automation composition elements.
 377      *
 378      * @param automationComposition participant status in memory
 379      * @param orderedState orderedState the new ordered state the participant should have
 380      * @param startPhaseMsg startPhase from message
 381      * @param acElementDefinitions the list of AutomationCompositionElementDefinition
 382      */
 383     private void handleStateChange(AutomationComposition automationComposition,
 384             final AutomationCompositionOrderedState orderedState, Integer startPhaseMsg,
 385             List<AutomationCompositionElementDefinition> acElementDefinitions) {
 386
 387         if (orderedState.equals(automationComposition.getOrderedState())) {
 388             var automationCompositionAck =
 389                     new AutomationCompositionAck(ParticipantMessageType.AUTOMATION_COMPOSITION_STATECHANGE_ACK);
 390             automationCompositionAck.setParticipantId(participantId);
 391             automationCompositionAck.setMessage("Automation composition is already in state " + orderedState);
 392             automationCompositionAck.setResult(false);
 393             automationCompositionAck.setAutomationCompositionId(automationComposition.getInstanceId());
 394             publisher.sendAutomationCompositionAck(automationCompositionAck);
 395             return;
 396         }
 397
 398         automationComposition.getElements().values().stream()
 399                 .forEach(acElement -> automationCompositionElementStateChange(automationComposition, orderedState,
 400                         acElement, startPhaseMsg, acElementDefinitions));
 401     }
 402
 403     private void automationCompositionElementStateChange(AutomationComposition automationComposition,
 404             AutomationCompositionOrderedState orderedState, AutomationCompositionElement acElement,
 405             Integer startPhaseMsg, List<AutomationCompositionElementDefinition> acElementDefinitions) {
 406         var acElementNodeTemplate = getAcElementNodeTemplate(acElementDefinitions, acElement.getDefinition());
 407         if (acElementNodeTemplate != null) {
 408             int startPhase = ParticipantUtils.findStartPhase(acElementNodeTemplate.getProperties());
 409             if (startPhaseMsg.equals(startPhase)) {
 410                 for (var acElementListener : listeners) {
 411                     try {
 412                         acElementListener.automationCompositionElementStateChange(automationComposition.getInstanceId(),
 413                                 acElement.getId(), acElement.getState(), orderedState);
 414                     } catch (PfModelException e) {
 415                         LOGGER.debug("Automation composition element update failed {}",
 416                                 automationComposition.getInstanceId());
 417                     }
 418                 }
 419             }
 420         }
 421     }
 422 }