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.runtime.commissioning;
  23
  24 import java.util.HashSet;
  25 import java.util.UUID;
  26 import java.util.concurrent.ExecutorService;
  27 import java.util.concurrent.Executors;
  28 import java.util.stream.Collectors;
  29 import javax.ws.rs.core.Response.Status;
  30 import lombok.RequiredArgsConstructor;
  31 import org.onap.policy.clamp.acm.runtime.participants.AcmParticipantProvider;
  32 import org.onap.policy.clamp.acm.runtime.supervision.comm.ParticipantPrimePublisher;
  33 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
  34 import org.onap.policy.clamp.models.acm.concepts.AutomationCompositionDefinition;
  35 import org.onap.policy.clamp.models.acm.concepts.StateChangeResult;
  36 import org.onap.policy.clamp.models.acm.messages.rest.commissioning.AcTypeStateUpdate;
  37 import org.onap.policy.clamp.models.acm.messages.rest.commissioning.CommissioningResponse;
  38 import org.onap.policy.clamp.models.acm.persistence.provider.AcDefinitionProvider;
  39 import org.onap.policy.clamp.models.acm.persistence.provider.AcTypeStateResolver;
  40 import org.onap.policy.clamp.models.acm.persistence.provider.AutomationCompositionProvider;
  41 import org.onap.policy.models.base.PfModelException;
  42 import org.onap.policy.models.base.PfModelRuntimeException;
  43 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
  44 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplates;
  45 import org.springframework.stereotype.Service;
  46 import org.springframework.transaction.annotation.Transactional;
  47
  48 /**
  49  * This class provides the create, read and delete actions on Commissioning of automation composition concepts in the
  50  * database to the callers.
  51  */
  52 @Service
  53 @RequiredArgsConstructor
  54 public class CommissioningProvider {
  55     public static final String AUTOMATION_COMPOSITION_NODE_TYPE = "org.onap.policy.clamp.acm.AutomationComposition";
  56
  57     private final AcDefinitionProvider acDefinitionProvider;
  58     private final AutomationCompositionProvider acProvider;
  59     private final AcmParticipantProvider acmParticipantProvider;
  60     private final AcTypeStateResolver acTypeStateResolver;
  61     private final ParticipantPrimePublisher participantPrimePublisher;
  62
  63     private final ExecutorService executor = Executors.newFixedThreadPool(1);
  64
  65     private CommissioningResponse createCommissioningResponse(UUID compositionId,
  66             ToscaServiceTemplate serviceTemplate) {
  67         var response = new CommissioningResponse();
  68         response.setCompositionId(compositionId);
  69         // @formatter:off
  70         response.setAffectedAutomationCompositionDefinitions(
  71             serviceTemplate.getToscaTopologyTemplate().getNodeTemplates()
  72                 .values()
  73                 .stream()
  74                 .map(template -> template.getKey().asIdentifier())
  75                 .collect(Collectors.toList()));
  76         // @formatter:on
  77
  78         return response;
  79     }
  80
  81     /**
  82      * Create automation composition from a service template.
  83      *
  84      * @param serviceTemplate the service template
  85      * @return the result of the commissioning operation
  86      */
  87     @Transactional
  88     public CommissioningResponse createAutomationCompositionDefinition(ToscaServiceTemplate serviceTemplate) {
  89
  90         var acmDefinition = acDefinitionProvider.createAutomationCompositionDefinition(serviceTemplate);
  91         serviceTemplate = acmDefinition.getServiceTemplate();
  92         return createCommissioningResponse(acmDefinition.getCompositionId(), serviceTemplate);
  93     }
  94
  95     /**
  96      * Update Composition Definition.
  97      *
  98      * @param compositionId The UUID of the automation composition definition to update
  99      * @param serviceTemplate the service template
 100      * @return the result of the commissioning operation
 101      */
 102     @Transactional
 103     public CommissioningResponse updateCompositionDefinition(UUID compositionId, ToscaServiceTemplate serviceTemplate) {
 104         if (verifyIfInstanceExists(compositionId)) {
 105             throw new PfModelRuntimeException(Status.BAD_REQUEST,
 106                     "There are ACM instances, Update of ACM Definition not allowed");
 107         }
 108         var acDefinition = acDefinitionProvider.getAcDefinition(compositionId);
 109         if (!AcTypeState.COMMISSIONED.equals(acDefinition.getState())) {
 110             throw new PfModelRuntimeException(Status.BAD_REQUEST,
 111                     "ACM not in COMMISSIONED state, Update of ACM Definition not allowed");
 112         }
 113         acDefinitionProvider.updateServiceTemplate(compositionId, serviceTemplate);
 114
 115         return createCommissioningResponse(compositionId, serviceTemplate);
 116     }
 117
 118     /**
 119      * Delete the automation composition definition with the given name and version.
 120      *
 121      * @param compositionId The UUID of the automation composition definition to delete
 122      * @return the result of the deletion
 123      */
 124     @Transactional
 125     public CommissioningResponse deleteAutomationCompositionDefinition(UUID compositionId) {
 126         if (verifyIfInstanceExists(compositionId)) {
 127             throw new PfModelRuntimeException(Status.BAD_REQUEST,
 128                     "Delete instances, to commission automation composition definitions");
 129         }
 130         var acDefinition = acDefinitionProvider.getAcDefinition(compositionId);
 131         if (!AcTypeState.COMMISSIONED.equals(acDefinition.getState())) {
 132             throw new PfModelRuntimeException(Status.BAD_REQUEST,
 133                     "ACM not in COMMISSIONED state, Update of ACM Definition not allowed");
 134         }
 135         var serviceTemplate = acDefinitionProvider.deleteAcDefintion(compositionId);
 136         return createCommissioningResponse(compositionId, serviceTemplate);
 137     }
 138
 139     /**
 140      * Get automation composition definition.
 141      *
 142      * @param acName the name of the automation composition, null for all
 143      * @param acVersion the version of the automation composition, null for all
 144      * @return automation composition definition
 145      * @throws PfModelException on errors getting automation composition definitions
 146      */
 147     @Transactional(readOnly = true)
 148     public ToscaServiceTemplates getAutomationCompositionDefinitions(String acName, String acVersion) {
 149
 150         var result = new ToscaServiceTemplates();
 151         result.setServiceTemplates(acDefinitionProvider.getServiceTemplateList(acName, acVersion));
 152         return result;
 153     }
 154
 155     /**
 156      * Get automation composition definition.
 157      *
 158      * @param compositionId the compositionId
 159      * @return automation composition definition
 160      */
 161     @Transactional(readOnly = true)
 162     public AutomationCompositionDefinition getAutomationCompositionDefinition(UUID compositionId) {
 163
 164         return acDefinitionProvider.getAcDefinition(compositionId);
 165     }
 166
 167     /**
 168      * Validates to see if there is any instance saved.
 169      *
 170      * @return true if exists instance
 171      */
 172     private boolean verifyIfInstanceExists(UUID compositionId) {
 173         return !acProvider.getAcInstancesByCompositionId(compositionId).isEmpty();
 174     }
 175
 176     /**
 177      * Composition Definition Priming.
 178      *
 179      * @param compositionId the compositionId
 180      * @param acTypeStateUpdate the ACMTypeStateUpdate
 181      */
 182     public void compositionDefinitionPriming(UUID compositionId, AcTypeStateUpdate acTypeStateUpdate) {
 183         if (verifyIfInstanceExists(compositionId)) {
 184             throw new PfModelRuntimeException(Status.BAD_REQUEST, "There are instances, Priming/Depriming not allowed");
 185         }
 186         var acmDefinition = acDefinitionProvider.getAcDefinition(compositionId);
 187         var stateOrdered = acTypeStateResolver.resolve(acTypeStateUpdate.getPrimeOrder(), acmDefinition.getState(),
 188                 acmDefinition.getStateChangeResult());
 189         switch (stateOrdered) {
 190             case PRIME:
 191                 prime(acmDefinition);
 192                 break;
 193
 194             case DEPRIME:
 195                 deprime(acmDefinition);
 196
 197                 break;
 198
 199             default:
 200                 throw new PfModelRuntimeException(Status.BAD_REQUEST, "Not valid " + acTypeStateUpdate.getPrimeOrder());
 201         }
 202     }
 203
 204     private void prime(AutomationCompositionDefinition acmDefinition) {
 205         acmDefinition.setStateChangeResult(StateChangeResult.NO_ERROR);
 206         var preparation = participantPrimePublisher.prepareParticipantPriming(acmDefinition);
 207         acDefinitionProvider.updateAcDefinition(acmDefinition);
 208
 209         executor.execute(
 210                 () -> participantPrimePublisher.sendPriming(preparation, acmDefinition.getCompositionId(), null));
 211     }
 212
 213     private void deprime(AutomationCompositionDefinition acmDefinition) {
 214         acmDefinition.setStateChangeResult(StateChangeResult.NO_ERROR);
 215         var participantIds = new HashSet<UUID>();
 216         for (var elementState : acmDefinition.getElementStateMap().values()) {
 217             var participantId = elementState.getParticipantId();
 218             if (participantId != null) {
 219                 elementState.setState(AcTypeState.DEPRIMING);
 220                 participantIds.add(participantId);
 221             }
 222         }
 223         if (! participantIds.isEmpty()) {
 224             acmParticipantProvider.verifyParticipantState(participantIds);
 225         }
 226         acmDefinition.setState(AcTypeState.DEPRIMING);
 227         acDefinitionProvider.updateAcDefinition(acmDefinition);
 228
 229         executor.execute(() -> participantPrimePublisher.sendDepriming(acmDefinition.getCompositionId()));
 230     }
 231
 232 }