2 * Copyright 2016-2017, Nokia Corporation
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
16 package org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.notification;
18 import com.google.common.annotations.VisibleForTesting;
19 import com.google.common.collect.Ordering;
20 import com.google.gson.Gson;
21 import com.google.gson.JsonElement;
22 import com.google.gson.JsonObject;
23 import com.nokia.cbam.lcm.v32.api.OperationExecutionsApi;
24 import com.nokia.cbam.lcm.v32.api.VnfsApi;
25 import com.nokia.cbam.lcm.v32.model.*;
26 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.api.INotificationSender;
27 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.SystemFunctions;
28 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider;
29 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.DriverProperties;
30 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.ILifecycleChangeNotificationManager;
31 import org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.LifecycleManager;
32 import org.slf4j.Logger;
33 import org.springframework.beans.factory.annotation.Autowired;
34 import org.springframework.stereotype.Component;
36 import java.util.List;
37 import java.util.Optional;
40 import static com.google.common.collect.Iterables.find;
41 import static com.google.common.collect.Iterables.tryFind;
42 import static com.google.common.collect.Sets.newConcurrentHashSet;
43 import static com.google.common.collect.Sets.newHashSet;
44 import static com.nokia.cbam.lcm.v32.model.OperationType.INSTANTIATE;
45 import static java.util.Optional.empty;
46 import static java.util.Optional.of;
47 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.buildFatalFailure;
48 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.util.CbamUtils.childElement;
49 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCM_API_VERSION;
50 import static org.onap.vfc.nfvo.driver.vnfm.svnfm.nokia.vnfm.CbamRestApiProvider.NOKIA_LCN_API_VERSION;
51 import static org.slf4j.LoggerFactory.getLogger;
54 * Responsible for handling lifecycle change notifications from CBAM.
55 * The received LCNs are transformed into ONAP LCNs.
56 * The following CBAM LCNs are processed:
61 * The current limitations
62 * - if a LCN can not be be processed due to VNF having been deleted the problem is logged and CBAM is notified that
63 * the LCN has been processed (even if not in reality) because the signaling of failed LCN delivery blocks the delivery
64 * on all LCN deliveries. The consequence of this is that the information known by VF-C / A&AI may be inconsistent with
65 * reality (VNF having been deleted)
68 public class LifecycleChangeNotificationManager implements ILifecycleChangeNotificationManager {
70 public static final String PROBLEM = "All operations must return the { \"operationResult\" : { \"cbam_pre\" : [<fillMeOut>], \"cbam_post\" : [<fillMeOut>] } } structure";
72 * Order the operations by start time (latest first)
74 public static final Ordering<OperationExecution> NEWEST_OPERATIONS_FIRST = new Ordering<OperationExecution>() {
76 public int compare(OperationExecution left, OperationExecution right) {
77 return right.getStartTime().toLocalDate().compareTo(left.getStartTime().toLocalDate());
81 * < Separates the VNF id and the resource id within a VNF
83 private static final Set<OperationStatus> terminalStatus = newHashSet(OperationStatus.FINISHED, OperationStatus.FAILED);
84 private static Logger logger = getLogger(LifecycleChangeNotificationManager.class);
86 private final CbamRestApiProvider restApiProvider;
87 private final DriverProperties driverProperties;
88 private final INotificationSender notificationSender;
89 private Set<ProcessedNotification> processedNotifications = newConcurrentHashSet();
92 LifecycleChangeNotificationManager(CbamRestApiProvider restApiProvider, DriverProperties driverProperties, INotificationSender notificationSender) {
93 this.notificationSender = notificationSender;
94 this.driverProperties = driverProperties;
95 this.restApiProvider = restApiProvider;
99 * @param status the status of the operation
100 * @return has the operation finished
102 public static boolean isTerminal(OperationStatus status) {
103 return terminalStatus.contains(status);
107 static OperationExecution findLastInstantiationBefore(List<OperationExecution> operationExecutions, OperationExecution currentOperation) {
108 return find(NEWEST_OPERATIONS_FIRST.sortedCopy(operationExecutions), (OperationExecution opex2) ->
109 !opex2.getStartTime().isAfter(currentOperation.getStartTime())
110 && INSTANTIATE.equals(opex2.getOperationType()));
114 public void handleLcn(VnfLifecycleChangeNotification receivedNotification) {
115 if (logger.isInfoEnabled()) {
116 logger.info("Received LCN: {}", new Gson().toJson(receivedNotification));
118 VnfsApi cbamLcmApi = restApiProvider.getCbamLcmApi(driverProperties.getVnfmId());
120 List<VnfInfo> vnfs = cbamLcmApi.vnfsGet(NOKIA_LCM_API_VERSION).blockingFirst();
121 com.google.common.base.Optional<VnfInfo> currentVnf = tryFind(vnfs, vnf -> vnf.getId().equals(receivedNotification.getVnfInstanceId()));
122 String vnfHeader = "The VNF with " + receivedNotification.getVnfInstanceId() + " identifier";
123 if (!currentVnf.isPresent()) {
124 logger.warn(vnfHeader + " disappeared before being able to process the LCN");
128 VnfInfo vnf = cbamLcmApi.vnfsVnfInstanceIdGet(receivedNotification.getVnfInstanceId(), NOKIA_LCN_API_VERSION).blockingFirst();
129 com.google.common.base.Optional<VnfProperty> externalVnfmId = tryFind(vnf.getExtensions(), prop -> prop.getName().equals(LifecycleManager.EXTERNAL_VNFM_ID));
130 if (!externalVnfmId.isPresent()) {
131 logger.warn(vnfHeader + " is not a managed VNF");
134 if (!externalVnfmId.get().getValue().equals(driverProperties.getVnfmId())) {
135 logger.warn(vnfHeader + " is not a managed by the VNFM with id " + externalVnfmId.get().getValue());
139 } catch (Exception e) {
140 throw buildFatalFailure(logger, "Unable to list VNFs / query VNF", e);
142 OperationExecutionsApi cbamOperationExecutionApi = restApiProvider.getCbamOperationExecutionApi(driverProperties.getVnfmId());
143 List<OperationExecution> operationExecutions;
145 operationExecutions = cbamLcmApi.vnfsVnfInstanceIdOperationExecutionsGet(receivedNotification.getVnfInstanceId(), NOKIA_LCM_API_VERSION).blockingFirst();
146 } catch (Exception e) {
147 throw buildFatalFailure(logger, "Unable to retrieve the operation executions for the VNF " + receivedNotification.getVnfInstanceId(), e);
149 OperationExecution operationExecution;
151 operationExecution = cbamOperationExecutionApi.operationExecutionsOperationExecutionIdGet(receivedNotification.getLifecycleOperationOccurrenceId(), NOKIA_LCM_API_VERSION).blockingFirst();
152 } catch (Exception e) {
153 throw buildFatalFailure(logger, "Unable to retrieve the operation execution with " + receivedNotification.getLifecycleOperationOccurrenceId() + " identifier", e);
155 OperationExecution closestInstantiationToOperation = findLastInstantiationBefore(operationExecutions, operationExecution);
156 String vimId = getVimId(cbamOperationExecutionApi, closestInstantiationToOperation);
157 notificationSender.processNotification(receivedNotification, operationExecution, buildAffectedCps(operationExecution), vimId);
158 if (isTerminationFinished(receivedNotification)) {
159 //signal LifecycleManager to continue the deletion of the VNF
160 processedNotifications.add(new ProcessedNotification(receivedNotification.getLifecycleOperationOccurrenceId(), receivedNotification.getStatus()));
164 private boolean isTerminationFinished(VnfLifecycleChangeNotification receivedNotification) {
165 return OperationType.TERMINATE.equals(receivedNotification.getOperation()) && terminalStatus.contains(receivedNotification.getStatus());
168 private String getVimId(OperationExecutionsApi cbamOperationExecutionApi, OperationExecution closestInstantiationToOperation) {
170 Object operationParams = cbamOperationExecutionApi.operationExecutionsOperationExecutionIdOperationParamsGet(closestInstantiationToOperation.getId(), NOKIA_LCM_API_VERSION).blockingFirst();
171 return getVimId(operationParams);
172 } catch (Exception e) {
173 throw buildFatalFailure(logger, "Unable to detect last instantiation operation", e);
178 public void waitForTerminationToBeProcessed(String operationExecutionId) {
180 com.google.common.base.Optional<ProcessedNotification> notification = tryFind(processedNotifications, processedNotification -> processedNotification.getOperationExecutionId().equals(operationExecutionId));
181 if (notification.isPresent()) {
182 processedNotifications.remove(notification.get());
185 SystemFunctions.systemFunctions().sleep(500);
189 private String getVimId(Object instantiationParameters) {
190 InstantiateVnfRequest request = new Gson().fromJson(new Gson().toJson(instantiationParameters), InstantiateVnfRequest.class);
191 return request.getVims().get(0).getId();
194 private Optional<ReportedAffectedConnectionPoints> buildAffectedCps(OperationExecution operationExecution) {
195 if (operationExecution.getOperationType() == OperationType.TERMINATE) {
196 String terminationType = childElement(new Gson().toJsonTree(operationExecution.getOperationParams()).getAsJsonObject(), "terminationType").getAsString();
197 if (TerminationType.FORCEFUL.name().equals(terminationType)) {
198 //in case of force full termination the Ansible is not executed, so the connection points can not be
199 //calculated from operation execution result
200 logger.warn("Unable to send information related to affected connection points during forceful termination");
205 JsonElement root = new Gson().toJsonTree(operationExecution.getAdditionalData());
206 if (root.getAsJsonObject().has("operationResult")) {
207 JsonObject operationResult = root.getAsJsonObject().get("operationResult").getAsJsonObject();
208 if (isAbsent(operationResult, "cbam_pre") ||
209 isAbsent(operationResult, "cbam_post")) {
210 return handleFailure(operationExecution, null);
212 return of(new Gson().fromJson(operationResult, ReportedAffectedConnectionPoints.class));
215 return handleFailure(operationExecution, null);
217 } catch (Exception e) {
218 return handleFailure(operationExecution, e);
222 private boolean isAbsent(JsonObject operationResult, String key) {
223 return !operationResult.has(key) || !operationResult.get(key).isJsonArray();
226 private Optional<ReportedAffectedConnectionPoints> handleFailure(OperationExecution operationExecution, Exception e) {
227 if (operationExecution.getStatus() == OperationStatus.FAILED) {
228 logger.warn("The operation failed and the affected connection points were not reported");
232 throw buildFatalFailure(logger, PROBLEM, e);
234 throw buildFatalFailure(logger, PROBLEM);