2 * ============LICENSE_START======================================================================
3 * Copyright (C) 2023 Nordix Foundation. All rights reserved.
4 * Copyright (C) 2023-2024 OpenInfra Foundation Europe. 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
10 * http://www.apache.org/licenses/LICENSE-2.0
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 * ============LICENSE_END========================================================================
20 package com.oransc.rappmanager.acm.service;
22 import com.google.gson.Gson;
23 import com.oransc.rappmanager.acm.configuration.ACMConfiguration;
24 import com.oransc.rappmanager.acm.rest.AutomationCompositionDefinitionApiClient;
25 import com.oransc.rappmanager.acm.rest.AutomationCompositionInstanceApiClient;
26 import com.oransc.rappmanager.dme.service.DmeAcmInterceptor;
27 import com.oransc.rappmanager.models.RappDeployer;
28 import com.oransc.rappmanager.models.csar.RappCsarConfigurationHandler;
29 import com.oransc.rappmanager.models.rapp.Rapp;
30 import com.oransc.rappmanager.models.rapp.RappEvent;
31 import com.oransc.rappmanager.models.rappinstance.RappACMInstance;
32 import com.oransc.rappmanager.models.rappinstance.RappInstance;
33 import com.oransc.rappmanager.models.statemachine.RappInstanceStateMachine;
34 import java.util.UUID;
35 import java.util.concurrent.TimeUnit;
36 import lombok.RequiredArgsConstructor;
37 import org.onap.policy.clamp.models.acm.concepts.AcTypeState;
38 import org.onap.policy.clamp.models.acm.concepts.AutomationComposition;
39 import org.onap.policy.clamp.models.acm.concepts.DeployState;
40 import org.onap.policy.clamp.models.acm.concepts.LockState;
41 import org.onap.policy.clamp.models.acm.messages.rest.commissioning.AcTypeStateUpdate;
42 import org.onap.policy.clamp.models.acm.messages.rest.commissioning.CommissioningResponse;
43 import org.onap.policy.clamp.models.acm.messages.rest.commissioning.PrimeOrder;
44 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.AcInstanceStateUpdate;
45 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.DeployOrder;
46 import org.onap.policy.clamp.models.acm.messages.rest.instantiation.InstantiationResponse;
47 import org.onap.policy.models.tosca.authorative.concepts.ToscaServiceTemplate;
48 import org.slf4j.Logger;
49 import org.slf4j.LoggerFactory;
50 import org.springframework.stereotype.Service;
51 import org.springframework.web.client.RestClientException;
54 @RequiredArgsConstructor
55 public class AcmDeployer implements RappDeployer {
57 Logger logger = LoggerFactory.getLogger(AcmDeployer.class);
59 private final AutomationCompositionDefinitionApiClient automationCompositionDefinitionApiClient;
60 private final AutomationCompositionInstanceApiClient automationCompositionInstanceApiClient;
61 private final RappCsarConfigurationHandler rappCsarConfigurationHandler;
62 private final RappInstanceStateMachine rappInstanceStateMachine;
63 private final ACMConfiguration acmConfiguration;
64 private final Gson gson;
65 private final DmeAcmInterceptor dmeAcmInterceptor;
67 void updateACMInstanceState(UUID compositionId, RappACMInstance rappACMInstance, DeployOrder deployOrder) {
68 AcInstanceStateUpdate acInstanceStateUpdate = new AcInstanceStateUpdate();
69 acInstanceStateUpdate.setDeployOrder(deployOrder);
70 automationCompositionInstanceApiClient.compositionInstanceState(compositionId,
71 rappACMInstance.getAcmInstanceId(), acInstanceStateUpdate, UUID.randomUUID());
74 public void primeACMComposition(UUID compositionId, PrimeOrder primeOrder) {
75 AcTypeStateUpdate acTypeStateUpdate = new AcTypeStateUpdate();
76 acTypeStateUpdate.setPrimeOrder(primeOrder);
77 automationCompositionDefinitionApiClient.compositionDefinitionPriming(compositionId, UUID.randomUUID(),
81 public CommissioningResponse createComposition(String compositionPayload) {
82 CommissioningResponse commissioningResponse = null;
84 ToscaServiceTemplate toscaServiceTemplate = gson.fromJson(compositionPayload, ToscaServiceTemplate.class);
85 dmeAcmInterceptor.injectToscaServiceTemplate(toscaServiceTemplate);
86 commissioningResponse = automationCompositionDefinitionApiClient.createCompositionDefinitions(
87 gson.toJson(toscaServiceTemplate), UUID.randomUUID());
88 } catch (Exception e) {
89 logger.warn("Error in creating composition", e);
91 return commissioningResponse;
94 public CommissioningResponse deleteComposition(UUID compositionId) {
96 return automationCompositionDefinitionApiClient.deleteCompositionDefinition(compositionId,
98 } catch (Exception e) {
99 logger.warn("Error in deleting composition {}", compositionId, e);
104 boolean isCompositionInstanceStateEquals(UUID compositionId, UUID compositionIntanceId, DeployState deployState) {
105 return automationCompositionInstanceApiClient.getCompositionInstance(compositionId, compositionIntanceId,
106 UUID.randomUUID()).getDeployState().equals(deployState);
109 boolean waitForCompositionInstanceTargetState(UUID compositionId, RappInstance rappInstance,
110 DeployState deployState) {
111 boolean targetInstanceStateTransition = false;
113 for (int i = 0; i < acmConfiguration.getMaxRetries(); i++) {
114 logger.debug("Composition instance state check {}", i + 1);
115 if (isCompositionInstanceStateEquals(compositionId, rappInstance.getAcm().getAcmInstanceId(),
117 sendRappInstanceStateEvent(rappInstance, deployState);
118 logger.info("Composition instance {} state is {}", rappInstance.getAcm().getAcmInstanceId(),
120 targetInstanceStateTransition = true;
123 TimeUnit.SECONDS.sleep(acmConfiguration.getRetryInterval());
126 } catch (Exception e) {
127 logger.warn("Unable to get composition instance state for composition {}", compositionId, e);
128 Thread.currentThread().interrupt();
130 return targetInstanceStateTransition;
134 public boolean deployRappInstance(Rapp rapp, RappInstance rappInstance) {
136 String instantiationPayload = rappCsarConfigurationHandler.getInstantiationPayload(rapp, rappInstance,
137 rapp.getCompositionId());
138 AutomationComposition automationComposition =
139 gson.fromJson(instantiationPayload, AutomationComposition.class);
140 if (rappInstance.isDMEEnabled()) {
141 dmeAcmInterceptor.injectAutomationComposition(automationComposition, rapp, rappInstance);
144 InstantiationResponse instantiationResponse =
145 automationCompositionInstanceApiClient.createCompositionInstance(rapp.getCompositionId(),
146 gson.toJson(automationComposition), UUID.randomUUID());
147 if (instantiationResponse.getInstanceId() != null) {
148 rappInstance.getAcm().setAcmInstanceId(instantiationResponse.getInstanceId());
149 updateACMInstanceState(rapp.getCompositionId(), rappInstance.getAcm(), DeployOrder.DEPLOY);
152 } catch (Exception e) {
153 logger.warn("Error in deploying Rapp", e);
155 rappInstanceStateMachine.sendRappInstanceEvent(rappInstance, RappEvent.ACMDEPLOYFAILED);
156 rappInstance.setReason("Unable to deploy ACM");
161 public boolean undeployRappInstance(Rapp rapp, RappInstance rappInstance) {
162 AutomationComposition automationComposition =
163 automationCompositionInstanceApiClient.getCompositionInstance(rapp.getCompositionId(),
164 rappInstance.getAcm().getAcmInstanceId(), UUID.randomUUID());
165 if (automationComposition.getDeployState().equals(DeployState.DEPLOYED) && automationComposition.getLockState()
166 .equals(LockState.LOCKED)) {
167 updateACMInstanceState(rapp.getCompositionId(), rappInstance.getAcm(), DeployOrder.UNDEPLOY);
168 if (waitForCompositionInstanceTargetState(rapp.getCompositionId(), rappInstance, DeployState.UNDEPLOYED)) {
169 automationCompositionInstanceApiClient.deleteCompositionInstance(
170 automationComposition.getCompositionId(), automationComposition.getInstanceId(),
172 rappInstanceStateMachine.sendRappInstanceEvent(rappInstance, RappEvent.ACMUNDEPLOYED);
176 rappInstanceStateMachine.sendRappInstanceEvent(rappInstance, RappEvent.ACMUNDEPLOYFAILED);
177 rappInstance.setReason("Unable to undeploy ACM");
182 public boolean primeRapp(Rapp rapp) {
183 logger.info("Priming rapp {}", rapp.getName());
185 String compositionPayload = rappCsarConfigurationHandler.getAcmCompositionPayload(rapp);
186 CommissioningResponse commissioningResponse = createComposition(compositionPayload);
187 if (commissioningResponse != null && commissioningResponse.getCompositionId() != null) {
188 rapp.setCompositionId(commissioningResponse.getCompositionId());
189 logger.info("Priming automation Composition");
190 primeACMComposition(commissioningResponse.getCompositionId(), PrimeOrder.PRIME);
193 logger.warn("Failed to create automation composition");
195 } catch (Exception e) {
196 logger.warn("Error in creating automation composition", e);
198 rapp.setReason("Unable to create automation composition");
203 public boolean deprimeRapp(Rapp rapp) {
205 primeACMComposition(rapp.getCompositionId(), PrimeOrder.DEPRIME);
206 if (waitForCompositionTargetState(rapp.getCompositionId(), AcTypeState.COMMISSIONED)) {
207 CommissioningResponse commissioningResponse = deleteComposition(rapp.getCompositionId());
208 if (commissioningResponse != null) {
209 rapp.setCompositionId(null);
213 } catch (Exception e) {
214 logger.warn("Failed deprime automation composition", e);
216 rapp.setReason("Unable to delete automation composition");
220 boolean waitForCompositionTargetState(UUID compositionId, AcTypeState acTypeState) {
221 boolean targetCompositionStateTransition = false;
223 for (int i = 0; i < acmConfiguration.getMaxRetries(); i++) {
224 logger.debug("Composition state check {}", i + 1);
225 if (isCompositionStateEquals(compositionId, acTypeState)) {
226 logger.debug("Composition {} state is {}", compositionId, acTypeState);
227 targetCompositionStateTransition = true;
230 TimeUnit.SECONDS.sleep(acmConfiguration.getRetryInterval());
233 } catch (Exception e) {
234 logger.warn("Unable to get composition state for composition {}", compositionId, e);
235 Thread.currentThread().interrupt();
237 return targetCompositionStateTransition;
240 boolean isCompositionStateEquals(UUID compositionId, AcTypeState acTypeState) {
241 return automationCompositionDefinitionApiClient.getCompositionDefinition(compositionId, UUID.randomUUID())
242 .getState().equals(acTypeState);
245 public void syncRappInstanceStatus(UUID compositionId, RappInstance rappInstance) {
246 if (rappInstance.getAcm().getAcmInstanceId() != null) {
248 AutomationComposition compositionInstance =
249 automationCompositionInstanceApiClient.getCompositionInstance(compositionId,
250 rappInstance.getAcm().getAcmInstanceId(), UUID.randomUUID());
251 sendRappInstanceStateEvent(rappInstance, compositionInstance.getDeployState());
252 } catch (RestClientException exception) {
253 logger.warn("Unable to get the ACM details for rapp instance {}", rappInstance.getRappInstanceId());
258 void sendRappInstanceStateEvent(RappInstance rappInstance, DeployState deployState) {
259 if (deployState.equals(DeployState.DEPLOYED)) {
260 rappInstanceStateMachine.sendRappInstanceEvent(rappInstance, RappEvent.ACMDEPLOYED);
261 rappInstanceStateMachine.sendRappInstanceEvent(rappInstance, RappEvent.DMEDEPLOYED);
262 } else if (deployState.equals(DeployState.UNDEPLOYED)) {
263 rappInstanceStateMachine.sendRappInstanceEvent(rappInstance, RappEvent.ACMUNDEPLOYED);
264 rappInstanceStateMachine.sendRappInstanceEvent(rappInstance, RappEvent.DMEUNDEPLOYED);
265 } else if (deployState.equals(DeployState.DEPLOYING)) {
266 rappInstanceStateMachine.sendRappInstanceEvent(rappInstance, RappEvent.DEPLOYING);
267 } else if (deployState.equals(DeployState.UNDEPLOYING)) {
268 rappInstanceStateMachine.sendRappInstanceEvent(rappInstance, RappEvent.UNDEPLOYING);