2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights
7 * ================================================================================
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 * ============LICENSE_END=========================================================
22 package org.onap.sdnc.vnfapi;
24 import com.google.common.util.concurrent.CheckedFuture;
25 import com.google.common.util.concurrent.FutureCallback;
26 import com.google.common.util.concurrent.Futures;
27 import com.google.common.util.concurrent.ListenableFuture;
28 import com.google.common.base.Optional;
29 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
30 import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
31 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
32 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
33 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
34 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
35 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
36 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
37 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
38 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
39 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
40 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationInput;
41 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationInputBuilder;
42 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationOutput;
43 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationOutputBuilder;
44 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationInput;
45 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationInputBuilder;
46 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationOutput;
47 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationOutputBuilder;
48 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationInput;
49 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationInputBuilder;
50 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationOutput;
51 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationOutputBuilder;
52 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModules;
53 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModulesBuilder;
54 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationInput;
55 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationInputBuilder;
56 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationOutput;
57 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationOutputBuilder;
58 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstances;
59 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstancesBuilder;
60 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationInput;
61 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationInputBuilder;
62 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationOutput;
63 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationOutputBuilder;
64 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfs;
65 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfsBuilder;
66 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VNFAPIService;
67 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationInput;
68 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationInputBuilder;
69 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationOutput;
70 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationOutputBuilder;
71 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModules;
72 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModulesBuilder;
73 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationInput;
74 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationInputBuilder;
75 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationOutput;
76 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationOutputBuilder;
77 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstances;
78 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstancesBuilder;
79 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationInput;
80 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationInputBuilder;
81 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationOutput;
82 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationOutputBuilder;
83 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.Vnfs;
84 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfsBuilder;
85 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.network.information.NetworkInformationBuilder;
86 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.data.PreloadData;
87 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.data.PreloadDataBuilder;
88 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadList;
89 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadListBuilder;
90 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadListKey;
91 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadList;
92 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadListBuilder;
93 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadListKey;
94 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadList;
95 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadListBuilder;
96 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadListKey;
97 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.request.information.RequestInformation;
98 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.sdnc.request.header.SdncRequestHeader;
99 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.sdnc.request.header.SdncRequestHeader.SvcAction;
100 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.data.ServiceData;
101 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.data.ServiceDataBuilder;
102 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus;
103 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RequestStatus;
104 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RpcAction;
105 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RpcName;
106 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.VnfsdnAction;
107 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.VnfsdnSubaction;
108 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatusBuilder;
109 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.information.VfModuleInformationBuilder;
110 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleList;
111 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleListBuilder;
112 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleListKey;
113 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.preload.data.VfModulePreloadData;
114 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.preload.data.VfModulePreloadDataBuilder;
115 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.service.data.VfModuleServiceData;
116 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.service.data.VfModuleServiceDataBuilder;
117 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.information.VnfInformationBuilder;
118 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.information.VnfInstanceInformationBuilder;
119 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceList;
120 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceListBuilder;
121 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceListKey;
122 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.preload.data.VnfInstancePreloadData;
123 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.preload.data.VnfInstancePreloadDataBuilder;
124 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.service.data.VnfInstanceServiceData;
125 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.service.data.VnfInstanceServiceDataBuilder;
126 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfList;
127 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfListBuilder;
128 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfListKey;
129 import org.opendaylight.yangtools.yang.binding.DataObject;
130 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
131 import org.opendaylight.yangtools.yang.common.RpcResult;
132 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
133 import org.opendaylight.yangtools.yang.data.api.schema.tree.ModifiedNodeDoesNotExistException;
134 import org.onap.ccsdk.sli.core.sli.SvcLogicException;
135 import org.slf4j.Logger;
136 import org.slf4j.LoggerFactory;
137 import org.slf4j.MDC;
140 import java.text.DateFormat;
141 import java.text.SimpleDateFormat;
142 import java.util.Date;
143 import java.util.Properties;
144 import java.util.TimeZone;
145 import java.util.concurrent.ExecutionException;
146 import java.util.concurrent.ExecutorService;
147 import java.util.concurrent.Executors;
148 import java.util.ArrayList;
149 import java.util.Collection;
150 import java.util.concurrent.Future;
153 * Defines a base implementation for your provider. This class extends from a helper class which provides storage for
154 * the most commonly used components of the MD-SAL. Additionally the base class provides some basic logging and
155 * initialization / clean up methods.
158 public class VnfApiProvider implements AutoCloseable, VNFAPIService {
159 protected DataBroker dataBroker;
160 protected NotificationPublishService notificationService;
161 protected RpcProviderRegistry rpcRegistry;
162 protected BindingAwareBroker.RpcRegistration<VNFAPIService> rpcRegistration;
163 private final Logger log = LoggerFactory.getLogger(VnfApiProvider.class);
164 private final ExecutorService executor;
166 private static final String PRELOAD_DATA = "] PreloadData: ";
167 private static final String SENDING_SUCCESS_RPC = "Sending Success rpc result due to external error";
168 public static final String REASON = "', Reason: '";
169 public static final String ERROR_CODE = "] error code: '";
170 public static final String INVALID_INPUT_INVALID_PRELOAD_TYPE = "invalid input, invalid preload-type";
171 public static final String BECAUSE_OF_INVALID_PRELOAD_TYPE = " because of invalid preload-type";
172 public static final String INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID = "invalid input, null or empty service-instance-id";
173 public static final String BECAUSE_OF_INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID = " because of invalid input, null or empty service-instance-id";
174 private static final String APP_NAME = "vnfapi";
175 private static final String VNF_API = "VNF-API";
176 private static final String OPERATIONAL_DATA = "operational-data";
177 private static final String READ_MD_SAL_STR = "Read MD-SAL (";
178 private static final String DATA_FOR_STR = ") data for [";
179 private static final String SERVICE_DATA_STR = "] ServiceData: ";
180 private static final String NO_DATA_FOUND_STR = "No data found in MD-SAL (";
181 private static final String EXCEPTION_READING_MD_SAL_STR = "Caught Exception reading MD-SAL (";
182 private static final String FOR_STR = ") for [";
183 private static final String INVALID_INPUT_VF_MODULE_STR = "invalid input, null or empty vf-module-id";
184 private static final String UPDATED_MD_SAL_STR = "Updated MD-SAL for ";
185 private static final String RETURNED_SUCCESS_STR = "Returned SUCCESS for ";
186 private static final String UPDATING_OPERATIONAL_TREE_STR = "Updating OPERATIONAL tree.";
187 private static final String UPDATING_MD_SAL_STR = "Updating MD-SAL for ";
188 private static final String CAUGHT_EXCEPTION_STR = "Caught Exception updating MD-SAL for ";
189 private static final String RETURNED_FAILED_STR = "Returned FAILED for ";
190 private static final String ADDING_INPUT_DATA_STR = "Adding INPUT data for ";
191 private static final String ADDING_OPERATIONAL_DATA_STR = "Adding OPERATIONAL data for ";
192 private static final String OPERATIONAL_DATA_STR = "] operational-data: ";
193 private static final String ADDING_CONFIG_DATA_STR = "Adding CONFIG data for ";
194 private static final String INPUT_STR = "] input: ";
195 private static final String CALLED_STR = " called.";
196 private static final String EXITING_STR = "exiting ";
197 private static final String INVALID_INPUT_VNF_INSTANCE_STR = "invalid input, null or empty vnf-instance-id";
199 private VNFSDNSvcLogicServiceClient svcLogicClient;
201 public VnfApiProvider(DataBroker dataBroker2, NotificationPublishService notificationPublishService,
202 RpcProviderRegistry rpcProviderRegistry, VNFSDNSvcLogicServiceClient client) {
203 log.info("Creating provider for " + APP_NAME);
204 executor = Executors.newFixedThreadPool(1);
205 dataBroker = dataBroker2;
206 notificationService = notificationPublishService;
207 rpcRegistry = rpcProviderRegistry;
208 svcLogicClient = client;
212 private void initialize() {
213 log.info("Initializing provider for " + APP_NAME);
214 // Create the top level containers
217 VnfSdnUtil.loadProperties();
218 } catch (Exception e) {
219 log.error("Caught Exception while trying to load properties file: ", e);
222 log.info("Initialization complete for " + APP_NAME);
225 private void createContainers() {
226 final WriteTransaction t = dataBroker.newReadWriteTransaction();
228 // Create the Vnfs container
229 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
230 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
232 // Create the PreloadVnfs container
233 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
234 new PreloadVnfsBuilder().build());
235 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
236 new PreloadVnfsBuilder().build());
238 // 1610 Create the PreloadVnfInstances container
239 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfInstances.class),
240 new PreloadVnfInstancesBuilder().build());
241 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfInstances.class),
242 new PreloadVnfInstancesBuilder().build());
244 // 1610 Create the VnfInstances container
245 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VnfInstances.class),
246 new VnfInstancesBuilder().build());
247 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VnfInstances.class),
248 new VnfInstancesBuilder().build());
250 // 1610 Create the PreloadVfModules container
251 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVfModules.class),
252 new PreloadVfModulesBuilder().build());
253 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVfModules.class),
254 new PreloadVfModulesBuilder().build());
256 // 1610 Create the VfModules container
257 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VfModules.class),
258 new VfModulesBuilder().build());
259 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VfModules.class),
260 new VfModulesBuilder().build());
263 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
265 log.info("Create Containers succeeded!: ");
267 } catch (InterruptedException | ExecutionException e) {
268 log.error("Create Containers Failed: " + e);
273 public void close() throws Exception {
274 log.info("Closing provider for " + APP_NAME);
276 rpcRegistration.close();
277 log.info("Successfully closed provider for " + APP_NAME);
282 private static class Iso8601Util {
285 private static TimeZone tz = TimeZone.getTimeZone("UTC");
286 private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
288 private Iso8601Util() {
295 private static String now() {
296 return df.format(new Date());
300 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
302 serviceStatusBuilder.setResponseCode(errorCode);
303 serviceStatusBuilder.setResponseMessage(errorMessage);
304 serviceStatusBuilder.setFinalIndicator(ackFinal);
305 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
308 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
309 if (requestInformation != null && requestInformation.getRequestAction() != null) {
310 switch (requestInformation.getRequestAction()) {
311 case VNFActivateRequest:
312 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VNFActivateRequest);
314 case ChangeVNFActivateRequest:
315 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVNFActivateRequest);
317 case DisconnectVNFRequest:
318 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVNFRequest);
320 case PreloadVNFRequest:
321 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVNFRequest);
323 case DeletePreloadVNFRequest:
324 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DeletePreloadVNFRequest);
326 // 1610 vnf-instance Requests
327 case VnfInstanceActivateRequest:
328 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VnfInstanceActivateRequest);
330 case ChangeVnfInstanceActivateRequest:
331 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVnfInstanceActivateRequest);
333 case DisconnectVnfInstanceRequest:
334 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVnfInstanceRequest);
336 case PreloadVnfInstanceRequest:
337 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVnfInstanceRequest);
339 // 1610 vf-module Requests
340 case VfModuleActivateRequest:
341 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VfModuleActivateRequest);
343 case ChangeVfModuleActivateRequest:
344 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVfModuleActivateRequest);
346 case DisconnectVfModuleRequest:
347 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVfModuleRequest);
349 case PreloadVfModuleRequest:
350 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVfModuleRequest);
353 log.error("Unknown RequestAction: " + requestInformation.getRequestAction());
357 if (requestInformation != null && requestInformation.getRequestSubAction() != null) {
358 switch (requestInformation.getRequestSubAction()) {
360 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP);
363 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
366 log.error("Unknown RequestSubAction: " + requestInformation.getRequestSubAction());
372 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
373 if (requestHeader != null && requestHeader.getSvcAction() != null) {
374 switch (requestHeader.getSvcAction()) {
376 serviceStatusBuilder.setRpcAction(RpcAction.Reserve);
379 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
382 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
385 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
388 serviceStatusBuilder.setRpcAction(RpcAction.Changeassign);
391 serviceStatusBuilder.setRpcAction(RpcAction.Changedelete);
394 serviceStatusBuilder.setRpcAction(RpcAction.Rollback);
397 log.error("Unknown SvcAction: " + requestHeader.getSvcAction());
403 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
405 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
409 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
410 // See if any data exists yet for this siid, if so grab it.
411 InstanceIdentifier<VnfList> serviceInstanceIdentifier = InstanceIdentifier
413 .child(VnfList.class, new VnfListKey(siid))
416 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
417 Optional<VnfList> data = Optional.absent();
419 data = readTx.read(type, serviceInstanceIdentifier).get();
420 } catch (InterruptedException | ExecutionException e) {
421 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
424 if (data.isPresent()) {
425 ServiceData serviceData = (ServiceData) data.get().getServiceData();
426 if (serviceData != null) {
427 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + siid + SERVICE_DATA_STR + serviceData);
428 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
429 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
430 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
431 serviceDataBuilder.setVnfRequestInformation(serviceData.getVnfRequestInformation());
432 serviceDataBuilder.setVnfId(serviceData.getVnfId());
433 serviceDataBuilder.setVnfTopologyInformation(serviceData.getVnfTopologyInformation());
434 serviceDataBuilder.setOperStatus(serviceData.getOperStatus());
436 log.info("No service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
439 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
444 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder) {
446 getVnfInstanceServiceData(siid, vnfInstanceServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
450 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder,
451 LogicalDatastoreType type) {
452 // See if any data exists yet for this siid, if so grab it.
453 InstanceIdentifier<VnfInstanceList> vnfInstanceIdentifier = InstanceIdentifier
454 .builder(VnfInstances.class)
455 .child(VnfInstanceList.class, new VnfInstanceListKey(siid))
458 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
459 Optional<VnfInstanceList> data = Optional.absent();
461 data = readTx.read(type, vnfInstanceIdentifier).get();
462 } catch (InterruptedException | ExecutionException e) {
463 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
466 if (data.isPresent()) {
467 VnfInstanceServiceData vnfInstanceServiceData = data.get().getVnfInstanceServiceData();
468 if (vnfInstanceServiceData != null) {
469 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + siid + "] VnfInstanceServiceData: "
470 + vnfInstanceServiceData);
471 vnfInstanceServiceDataBuilder.setSdncRequestHeader(vnfInstanceServiceData.getSdncRequestHeader());
472 vnfInstanceServiceDataBuilder.setRequestInformation(vnfInstanceServiceData.getRequestInformation());
473 vnfInstanceServiceDataBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
474 vnfInstanceServiceDataBuilder
475 .setVnfInstanceRequestInformation(vnfInstanceServiceData.getVnfInstanceRequestInformation());
476 vnfInstanceServiceDataBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
477 vnfInstanceServiceDataBuilder
478 .setVnfInstanceTopologyInformation(vnfInstanceServiceData.getVnfInstanceTopologyInformation());
479 vnfInstanceServiceDataBuilder.setOperStatus(vnfInstanceServiceData.getOperStatus());
481 log.info("No vnf-instance-service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
484 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
489 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder) {
491 getVfModuleServiceData(siid, vfModuleServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
495 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder,
496 LogicalDatastoreType type) {
497 // See if any data exists yet for this siid, if so grab it.
498 InstanceIdentifier<VfModuleList> vfModuleIdentifier = InstanceIdentifier
499 .builder(VfModules.class)
500 .child(VfModuleList.class, new VfModuleListKey(siid))
503 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
504 Optional<VfModuleList> data = Optional.absent();
506 data = readTx.read(type, vfModuleIdentifier).get();
507 } catch (InterruptedException | ExecutionException e) {
508 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
511 if (data.isPresent()) {
512 VfModuleServiceData vfModuleServiceData = data.get().getVfModuleServiceData();
513 if (vfModuleServiceData != null) {
515 READ_MD_SAL_STR + type + DATA_FOR_STR + siid + "] VfModuleServiceData: " + vfModuleServiceData);
516 vfModuleServiceDataBuilder.setSdncRequestHeader(vfModuleServiceData.getSdncRequestHeader());
517 vfModuleServiceDataBuilder.setRequestInformation(vfModuleServiceData.getRequestInformation());
518 vfModuleServiceDataBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
519 vfModuleServiceDataBuilder
520 .setVfModuleRequestInformation(vfModuleServiceData.getVfModuleRequestInformation());
521 vfModuleServiceDataBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
522 vfModuleServiceDataBuilder
523 .setVfModuleTopologyInformation(vfModuleServiceData.getVfModuleTopologyInformation());
524 vfModuleServiceDataBuilder.setOperStatus(vfModuleServiceData.getOperStatus());
526 log.info("No vf-module-service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
529 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
534 private void getPreloadData(String vnfName, String vnfType, PreloadDataBuilder preloadDataBuilder) {
536 getPreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
539 private void getPreloadData(String preloadName, String preloadType, PreloadDataBuilder preloadDataBuilder,
540 LogicalDatastoreType type) {
541 // See if any data exists yet for this name/type, if so grab it.
542 InstanceIdentifier<VnfPreloadList> preloadInstanceIdentifier = InstanceIdentifier
543 .builder(PreloadVnfs.class)
544 .child(VnfPreloadList.class, new VnfPreloadListKey(preloadName, preloadType))
547 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
548 Optional<VnfPreloadList> data = Optional.absent();
550 data = readTx.read(type, preloadInstanceIdentifier).get();
551 } catch (InterruptedException | ExecutionException e) {
552 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ",
556 if (data.isPresent()) {
557 PreloadData preloadData = (PreloadData) data.get().getPreloadData();
558 if (preloadData != null) {
559 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType + PRELOAD_DATA
561 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
562 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
563 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
566 "No preload-data found in MD-SAL (" + type + FOR_STR + preloadName + "," + preloadType + "] ");
569 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
573 //1610 preload-vnf-instance
574 private void getVnfInstancePreloadData(String vnfName, String vnfType,
575 VnfInstancePreloadDataBuilder preloadDataBuilder) {
577 getVnfInstancePreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
580 //1610 preload-vnf-instance
581 private void getVnfInstancePreloadData(String preloadName, String preloadType,
582 VnfInstancePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
583 // See if any data exists yet for this name/type, if so grab it.
584 InstanceIdentifier<VnfInstancePreloadList> preloadInstanceIdentifier = InstanceIdentifier
585 .builder(PreloadVnfInstances.class)
586 .child(VnfInstancePreloadList.class, new VnfInstancePreloadListKey(preloadName, preloadType))
589 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
590 Optional<VnfInstancePreloadList> data = Optional.absent();
592 data = readTx.read(type, preloadInstanceIdentifier).get();
593 } catch (InterruptedException | ExecutionException e) {
594 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ",
598 if (data.isPresent()) {
599 VnfInstancePreloadData preloadData = (VnfInstancePreloadData) data.get().getVnfInstancePreloadData();
600 if (preloadData != null) {
601 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType
602 + "] VnfInstancePreloadData: " + preloadData);
603 preloadDataBuilder.setVnfInstanceTopologyInformation(preloadData.getVnfInstanceTopologyInformation());
604 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
606 log.info("No vnf-instance-preload-data found in MD-SAL (" + type + FOR_STR + preloadName + ","
607 + preloadType + "] ");
610 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
614 // 1610 preload-vf-module
615 private void getVfModulePreloadData(String vnfName, String vnfType,
616 VfModulePreloadDataBuilder preloadDataBuilder) {
618 getVfModulePreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
621 private void getVfModulePreloadData(String preloadName, String preloadType,
622 VfModulePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
623 // See if any data exists yet for this name/type, if so grab it.
624 InstanceIdentifier<VfModulePreloadList> preloadInstanceIdentifier = InstanceIdentifier
625 .builder(PreloadVfModules.class)
626 .child(VfModulePreloadList.class, new VfModulePreloadListKey(preloadName, preloadType))
629 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
630 Optional<VfModulePreloadList> data = Optional.absent();
633 data = readTx.read(type, preloadInstanceIdentifier).get();
634 } catch (InterruptedException | ExecutionException e) {
635 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ",
639 if (data.isPresent()) {
640 VfModulePreloadData preloadData = (VfModulePreloadData) data.get().getVfModulePreloadData();
641 if (preloadData != null) {
642 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType
643 + "] VfModulePreloadData: " + preloadData);
644 preloadDataBuilder.setVfModuleTopologyInformation(preloadData.getVfModuleTopologyInformation());
645 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
648 "No preload-data found in MD-SAL (" + type + FOR_STR + preloadName + "," + preloadType + "] ");
651 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
655 private void deleteVnfList(final VnfList entry, LogicalDatastoreType storeType) {
656 // Each entry will be identifiable by a unique key, we have to create that identifier
657 InstanceIdentifier<VnfList> path = InstanceIdentifier
659 .child(VnfList.class, entry.key())
662 int optimisticLockTries = 2;
663 boolean tryAgain = true;
667 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
668 tx.delete(storeType, path);
669 tx.submit().checkedGet();
670 log.debug("DataStore delete succeeded");
671 } catch (OptimisticLockFailedException e) {
672 if (--optimisticLockTries <= 0) {
673 log.debug("Got OptimisticLockFailedException on last try - failing ");
674 throw new IllegalStateException(e);
676 log.debug("Got OptimisticLockFailedException - trying again ");
679 } catch (final TransactionCommitFailedException e) {
680 Throwable eCause = e.getCause();
683 if (eCause instanceof org.opendaylight.mdsal.common.api.TransactionCommitFailedException) {
684 log.debug("Nested TransactionCommitFailed exception - getting next cause");
685 eCause = eCause.getCause();
687 log.debug("Got TransactionCommitFailedException, caused by {}", eCause.getClass().getName());
690 if (eCause instanceof ModifiedNodeDoesNotExistException) {
691 log.debug("Ignoring ModifiedNodeDoesNotExistException");
695 log.debug("Delete DataStore failed due to exception", eCause);
696 throw new IllegalStateException(e);
701 private void saveVnfList(final VnfList entry, boolean merge, LogicalDatastoreType storeType) {
702 // Each entry will be identifiable by a unique key, we have to create that identifier
703 InstanceIdentifier<VnfList> path = InstanceIdentifier
705 .child(VnfList.class, entry.key())
708 tryUpdateDataStore(entry, merge, storeType, path);
712 private void saveVnfInstanceList(final VnfInstanceList entry, boolean merge, LogicalDatastoreType storeType) {
713 // Each entry will be identifiable by a unique key, we have to create that identifier
714 InstanceIdentifier<VnfInstanceList> path = InstanceIdentifier
715 .builder(VnfInstances.class)
716 .child(VnfInstanceList.class, entry.key())
719 tryUpdateDataStore(entry, merge, storeType, path);
723 private void saveVfModuleList(final VfModuleList entry, boolean merge, LogicalDatastoreType storeType) {
724 // Each entry will be identifiable by a unique key, we have to create that identifier
725 InstanceIdentifier<VfModuleList> path = InstanceIdentifier
726 .builder(VfModules.class)
727 .child(VfModuleList.class, entry.key())
730 tryUpdateDataStore(entry, merge, storeType, path);
733 private void savePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) {
735 // Each entry will be identifiable by a unique key, we have to create that identifier
736 InstanceIdentifier<VnfPreloadList> path = InstanceIdentifier
737 .builder(PreloadVnfs.class)
738 .child(VnfPreloadList.class, entry.key())
741 tryUpdateDataStore(entry, merge, storeType, path);
744 //1610 preload vnf-instance
745 private void saveVnfInstancePreloadList(final VnfInstancePreloadList entry, boolean merge,
746 LogicalDatastoreType storeType) {
748 // Each entry will be identifiable by a unique key, we have to create that identifier
749 InstanceIdentifier<VnfInstancePreloadList> path = InstanceIdentifier
750 .builder(PreloadVnfInstances.class)
751 .child(VnfInstancePreloadList.class, entry.key())
754 tryUpdateDataStore(entry, merge, storeType, path);
757 //1610 preload vf-module
758 private void saveVfModulePreloadList(final VfModulePreloadList entry, boolean merge,
759 LogicalDatastoreType storeType) {
761 // Each entry will be identifiable by a unique key, we have to create that identifier
762 InstanceIdentifier<VfModulePreloadList> path = InstanceIdentifier
763 .builder(PreloadVfModules.class)
764 .child(VfModulePreloadList.class, entry.key())
767 tryUpdateDataStore(entry, merge, storeType, path);
770 private <T extends DataObject> void tryUpdateDataStore(T entry, boolean merge, LogicalDatastoreType storeType,
771 InstanceIdentifier<T> path) {
776 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
778 tx.merge(storeType, path, entry);
780 tx.put(storeType, path, entry);
782 tx.submit().checkedGet();
783 log.debug("Update DataStore succeeded");
785 } catch (OptimisticLockFailedException e) {
787 log.debug("Got OptimisticLockFailedException on last try - failing ");
788 throw new IllegalStateException(e);
790 log.debug("Got OptimisticLockFailedException - trying again ");
791 } catch (final TransactionCommitFailedException e) {
792 log.debug("Update DataStore failed");
793 throw new IllegalStateException(e);
798 //Save the requestId into MDC
799 private void setRequestIdAsMDC(String requestId) {
800 MDC.put("RequestId", requestId);
803 //1610 vnf-instance-topology-operation
805 private Boolean validateVnfInstanceTopologyOperationInput(VnfInstanceTopologyOperationInput input) {
807 && input.getVnfInstanceRequestInformation() != null
808 && input.getVnfInstanceRequestInformation().getVnfInstanceId() != null
809 && input.getVnfInstanceRequestInformation().getVnfInstanceId().length() != 0;
812 private ListenableFuture<RpcResult<VnfInstanceTopologyOperationOutput>> buildVnfInstanceTopologyOperationOutputWithtError(
813 String responseCode, String responseMessage, String ackFinalIndicator) {
814 VnfInstanceTopologyOperationOutputBuilder responseBuilder = new VnfInstanceTopologyOperationOutputBuilder();
815 responseBuilder.setResponseCode(responseCode);
816 responseBuilder.setResponseMessage(responseMessage);
817 responseBuilder.setAckFinalIndicator(ackFinalIndicator);
818 return Futures.immediateFuture(RpcResultBuilder
819 .<VnfInstanceTopologyOperationOutput>status(true)
820 .withResult(responseBuilder.build())
825 public ListenableFuture<RpcResult<VnfInstanceTopologyOperationOutput>> vnfInstanceTopologyOperation(
826 VnfInstanceTopologyOperationInput input) {
828 final String svcOperation = "vnf-instance-topology-operation";
829 VnfInstanceServiceData vnfInstanceServiceData;
830 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
831 Properties parms = new Properties();
833 log.info(svcOperation + CALLED_STR);
834 // create a new response object
835 VnfInstanceTopologyOperationOutputBuilder responseBuilder = new VnfInstanceTopologyOperationOutputBuilder();
837 if (!validateVnfInstanceTopologyOperationInput(input)) {
838 log.debug(EXITING_STR + svcOperation + " because of " + INVALID_INPUT_VNF_INSTANCE_STR);
839 return buildVnfInstanceTopologyOperationOutputWithtError("403",
840 INVALID_INPUT_VNF_INSTANCE_STR,
844 // Grab the service instance ID from the input buffer
845 String viid = input.getVnfInstanceRequestInformation().getVnfInstanceId();
846 String preloadName = input.getVnfInstanceRequestInformation().getVnfInstanceName();
847 String preloadType = input.getVnfInstanceRequestInformation().getVnfModelId();
849 if (input.getSdncRequestHeader() != null) {
850 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
851 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
854 // Get vnf-instance-preload-data
855 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
856 getVnfInstancePreloadData(preloadName, preloadType, vnfInstancePreloadDataBuilder);
859 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
860 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
862 // Get operational-data
863 VnfInstanceServiceDataBuilder operDataBuilder = new VnfInstanceServiceDataBuilder();
864 getVnfInstanceServiceData(viid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
866 // Set the serviceStatus based on input
867 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
868 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
871 // setup a service-data object builder
872 // ACTION vnf-topology-operationa
874 // USES sdnc-request-header;
875 // USES request-information;
876 // USES service-information;
877 // USES vnf-request-information
879 // USES vnf-topology-response-body;
880 // USES vnf-information
881 // USES service-information
883 // container service-data
884 // uses vnf-configuration-information;
887 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + viid + INPUT_STR + input);
888 VnfInstanceTopologyOperationInputBuilder inputBuilder = new VnfInstanceTopologyOperationInputBuilder(input);
889 VnfSdnUtil.toProperties(parms, inputBuilder.build());
891 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + viid + OPERATIONAL_DATA_STR + operDataBuilder
893 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
896 ADDING_CONFIG_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preload-data: "
897 + vnfInstancePreloadDataBuilder.build());
898 VnfSdnUtil.toProperties(parms, "vnf-instance-preload-data", vnfInstancePreloadDataBuilder);
900 // Call SLI sync method
901 // Get SvcLogicService reference
902 Properties respProps = null;
903 String errorCode = "200";
904 String errorMessage = null;
905 String ackFinal = "Y";
908 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
909 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", vnfInstanceServiceDataBuilder, parms);
911 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
914 } catch (SvcLogicException e) {
915 log.error("Caught exception executing service logic for " + svcOperation, e);
916 errorMessage = e.getMessage();
918 } catch (Exception e) {
920 errorMessage = e.getMessage();
921 log.error("Caught exception looking for service logic", e);
924 if (respProps != null) {
925 errorCode = respProps.getProperty("error-code");
926 errorMessage = respProps.getProperty("error-message");
927 ackFinal = respProps.getProperty("ack-final", "Y");
930 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
931 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
932 serviceStatusBuilder.setRpcName(RpcName.VnfInstanceTopologyOperation);
934 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
935 responseBuilder.setResponseCode(errorCode);
936 responseBuilder.setResponseMessage(errorMessage);
937 responseBuilder.setAckFinalIndicator(ackFinal);
938 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
939 vnfInstanceListBuilder.setVnfInstanceId(viid);
940 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
942 saveVnfInstanceList(vnfInstanceListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
943 } catch (Exception e) {
944 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + viid + "] \n", e);
946 log.error(RETURNED_FAILED_STR + svcOperation + " [" + viid + "] " + responseBuilder.build());
947 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
948 .<VnfInstanceTopologyOperationOutput>status(true)
949 .withResult(responseBuilder.build())
952 return Futures.immediateFuture(rpcResult);
955 // Got success from SLI
957 vnfInstanceServiceData = vnfInstanceServiceDataBuilder.build();
958 log.info(UPDATING_MD_SAL_STR + svcOperation + " [" + viid + "] VnfInstanceServiceData: "
959 + vnfInstanceServiceData);
960 // svc-configuration-list
961 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
962 vnfInstanceListBuilder.setVnfInstanceServiceData(vnfInstanceServiceData);
963 vnfInstanceListBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
964 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
965 saveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
966 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
967 // Only update operational tree on Delete or Activate
968 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
969 .getSvcAction().equals(SvcAction.Activate)) {
970 log.info(UPDATING_OPERATIONAL_TREE_STR);
971 saveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
974 VnfInstanceInformationBuilder vnfInstanceInformationBuilder = new VnfInstanceInformationBuilder();
975 vnfInstanceInformationBuilder.setVnfInstanceId(viid);
976 responseBuilder.setVnfInstanceInformation(vnfInstanceInformationBuilder.build());
977 responseBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
978 } catch (Exception e) {
979 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + viid + "] \n", e);
980 responseBuilder.setResponseCode("500");
981 responseBuilder.setResponseMessage(e.toString());
982 responseBuilder.setAckFinalIndicator("Y");
983 log.error(RETURNED_FAILED_STR + svcOperation + " [" + viid + "] " + responseBuilder.build());
984 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
985 .<VnfInstanceTopologyOperationOutput>status(true)
986 .withResult(responseBuilder.build())
989 return Futures.immediateFuture(rpcResult);
993 responseBuilder.setResponseCode(errorCode);
994 responseBuilder.setAckFinalIndicator(ackFinal);
995 if (errorMessage != null) {
996 responseBuilder.setResponseMessage(errorMessage);
998 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + viid + "] ");
999 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + viid + "] " + responseBuilder.build());
1001 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
1002 .<VnfInstanceTopologyOperationOutput>status(true)
1003 .withResult(responseBuilder.build())
1006 return Futures.immediateFuture(rpcResult);
1009 //1610 vf-module-topology-operation
1011 public ListenableFuture<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1012 VfModuleTopologyOperationInput input) {
1014 final String svcOperation = "vf-module-topology-operation";
1015 VfModuleServiceData vfModuleServiceData;
1016 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1017 Properties parms = new Properties();
1019 log.info(svcOperation + CALLED_STR);
1020 // create a new response object
1021 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1023 // Validate vf-module-id from vf-module-request-information
1024 if (input == null || input.getVfModuleRequestInformation() == null
1025 || input.getVfModuleRequestInformation().getVfModuleId() == null) {
1026 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty vf-module-id");
1027 responseBuilder.setResponseCode("403");
1028 responseBuilder.setResponseMessage(INVALID_INPUT_VF_MODULE_STR);
1029 responseBuilder.setAckFinalIndicator("Y");
1030 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1031 .<VfModuleTopologyOperationOutput>status(true)
1032 .withResult(responseBuilder.build())
1035 return Futures.immediateFuture(rpcResult);
1038 // Grab the vf-module-request-information.vf-module-id from the input buffer
1039 String vfid = input.getVfModuleRequestInformation().getVfModuleId();
1040 String preloadName = input.getVfModuleRequestInformation().getVfModuleName();
1041 String preloadType = input.getVfModuleRequestInformation().getVfModuleModelId();
1043 // Make sure we have a valid siid
1044 if (vfid == null || vfid.length() == 0) {
1045 log.debug(EXITING_STR + svcOperation + " because of invalid vf-module-id");
1046 responseBuilder.setResponseCode("403");
1047 responseBuilder.setResponseMessage(INVALID_INPUT_VF_MODULE_STR);
1048 responseBuilder.setAckFinalIndicator("Y");
1049 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1050 .<VfModuleTopologyOperationOutput>status(true)
1051 .withResult(responseBuilder.build())
1054 return Futures.immediateFuture(rpcResult);
1057 // 1610 add vf-module-id to vnf-instance-list.vf-module-relationship-list
1058 String viid = input.getVfModuleRequestInformation().getVnfInstanceId();
1060 if (viid == null || viid.length() == 0) {
1061 log.debug(EXITING_STR + svcOperation + " because of invalid vnf-instance-id");
1062 responseBuilder.setResponseCode("403");
1063 responseBuilder.setResponseMessage(INVALID_INPUT_VNF_INSTANCE_STR);
1064 responseBuilder.setAckFinalIndicator("Y");
1065 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1066 .<VfModuleTopologyOperationOutput>status(true)
1067 .withResult(responseBuilder.build())
1070 return Futures.immediateFuture(rpcResult);
1073 if (input.getSdncRequestHeader() != null) {
1074 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1075 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1078 // Get vf-module-preload-data
1079 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
1080 getVfModulePreloadData(preloadName, preloadType, vfModulePreloadDataBuilder);
1082 // Get vf-module-service-data
1083 VfModuleServiceDataBuilder vfModuleServiceDataBuilder = new VfModuleServiceDataBuilder();
1084 getVfModuleServiceData(vfid, vfModuleServiceDataBuilder);
1086 // Get vf-module operation-data
1087 VfModuleServiceDataBuilder operDataBuilder = new VfModuleServiceDataBuilder();
1088 getVfModuleServiceData(vfid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1090 // 1610 Need to pull vnf-instance-list.vf-module-relationship-list from MD-SAL
1091 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1092 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1094 // vnf-instance operational-data
1095 VnfInstanceServiceDataBuilder vnfInstanceOperDataBuilder = new VnfInstanceServiceDataBuilder();
1096 getVnfInstanceServiceData(viid, vnfInstanceOperDataBuilder, LogicalDatastoreType.OPERATIONAL);
1098 // Set the serviceStatus based on input
1099 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1100 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1103 // setup a service-data object builder
1104 // ACTION vnf-topology-operation
1106 // USES request-information;
1107 // USES service-information;
1108 // USES vnf-request-information
1110 // USES vnf-information
1111 // USES service-information
1113 // container service-data
1115 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + vfid + INPUT_STR + input);
1116 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1117 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1119 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + vfid + "] vf-module operational-data: "
1120 + operDataBuilder.build());
1121 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1123 log.info(ADDING_CONFIG_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
1124 + "] vf-module-preload-data: " + vfModulePreloadDataBuilder.build());
1125 VnfSdnUtil.toProperties(parms, "vf-module-preload-data", vfModulePreloadDataBuilder);
1127 log.info("Adding vnf-instance CONFIG data for " + svcOperation + " [" + viid + "] vnf-instance-service-data: "
1128 + vnfInstanceServiceDataBuilder.build());
1129 VnfSdnUtil.toProperties(parms, "vnf-instance-service-data", vnfInstanceServiceDataBuilder);
1131 log.info("Adding vnf-instance OPERATIONAL data for " + svcOperation + " [" + viid
1132 + "] vnf-instance operational-data: " + vnfInstanceOperDataBuilder.build());
1133 VnfSdnUtil.toProperties(parms, "vnf-instance-operational-data", vnfInstanceOperDataBuilder);
1135 // Call SLI sync method
1136 // Get SvcLogicService reference
1138 Properties respProps = null;
1139 String errorCode = "200";
1140 String errorMessage = null;
1141 String ackFinal = "Y";
1144 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1145 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", vfModuleServiceDataBuilder, parms);
1147 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1150 } catch (SvcLogicException e) {
1151 log.error("Caught exception executing service logic for " + svcOperation, e);
1152 errorMessage = e.getMessage();
1154 } catch (Exception e) {
1156 errorMessage = e.getMessage();
1157 log.error("Caught exception looking for service logic", e);
1160 if (respProps != null) {
1161 errorCode = respProps.getProperty("error-code");
1162 errorMessage = respProps.getProperty("error-message");
1163 ackFinal = respProps.getProperty("ack-final", "Y");
1166 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1167 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1168 serviceStatusBuilder.setRpcName(RpcName.VfModuleTopologyOperation);
1170 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1171 responseBuilder.setResponseCode(errorCode);
1172 responseBuilder.setResponseMessage(errorMessage);
1173 responseBuilder.setAckFinalIndicator(ackFinal);
1174 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1175 vfModuleListBuilder.setVfModuleId(vfid);
1176 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1178 saveVfModuleList(vfModuleListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1179 } catch (Exception e) {
1180 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + vfid + "] \n", e);
1182 log.error(RETURNED_FAILED_STR + svcOperation + " [" + vfid + "] " + responseBuilder.build());
1183 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1184 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1187 return Futures.immediateFuture(rpcResult);
1190 // Got success from SLI
1191 // save vf-module-service-data in MD-SAL
1193 vfModuleServiceData = vfModuleServiceDataBuilder.build();
1195 UPDATING_MD_SAL_STR + svcOperation + " [" + vfid + "] VfModuleServiceData: " + vfModuleServiceData);
1197 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1198 vfModuleListBuilder.setVfModuleServiceData(vfModuleServiceData);
1199 vfModuleListBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
1200 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1201 saveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1202 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1203 // Only update operational tree on Delete or Activate
1204 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1205 .getSvcAction().equals(SvcAction.Activate)) {
1206 log.info(UPDATING_OPERATIONAL_TREE_STR);
1207 saveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1210 VfModuleInformationBuilder vfModuleInformationBuilder = new VfModuleInformationBuilder();
1211 vfModuleInformationBuilder.setVfModuleId(vfid);
1212 responseBuilder.setVfModuleInformation(vfModuleInformationBuilder.build());
1213 responseBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
1214 } catch (Exception e) {
1215 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + vfid + "] \n", e);
1216 responseBuilder.setResponseCode("500");
1217 responseBuilder.setResponseMessage(e.toString());
1218 responseBuilder.setAckFinalIndicator("Y");
1219 log.error(RETURNED_FAILED_STR + svcOperation + " [" + vfid + "] " + responseBuilder.build());
1220 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1221 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1224 return Futures.immediateFuture(rpcResult);
1228 responseBuilder.setResponseCode(errorCode);
1229 responseBuilder.setAckFinalIndicator(ackFinal);
1230 if (errorMessage != null) {
1231 responseBuilder.setResponseMessage(errorMessage);
1233 log.info("Updated vf-module in MD-SAL for " + svcOperation + " [" + vfid + "] ");
1234 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + vfid + "] " + responseBuilder.build());
1236 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1237 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1239 return Futures.immediateFuture(rpcResult);
1243 public ListenableFuture<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
1244 final String svcOperation = "vnf-topology-operation";
1245 ServiceData serviceData;
1246 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1247 Properties parms = new Properties();
1249 log.info(svcOperation + CALLED_STR);
1250 // create a new response object
1251 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1253 if (input == null || input.getServiceInformation() == null
1254 || input.getServiceInformation().getServiceInstanceId() == null
1255 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1256 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty service-instance-id");
1257 responseBuilder.setResponseCode("403");
1258 responseBuilder.setResponseMessage(INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID);
1259 responseBuilder.setAckFinalIndicator("Y");
1260 RpcResult<VnfTopologyOperationOutput> rpcResult =
1261 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1263 return Futures.immediateFuture(rpcResult);
1266 if (input.getVnfRequestInformation() == null || input.getVnfRequestInformation().getVnfId() == null
1267 || input.getVnfRequestInformation().getVnfId().length() == 0) {
1268 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty vf-module-id");
1269 responseBuilder.setResponseCode("403");
1270 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1271 responseBuilder.setAckFinalIndicator("Y");
1272 RpcResult<VnfTopologyOperationOutput> rpcResult =
1273 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1275 return Futures.immediateFuture(rpcResult);
1278 // Grab the service instance ID from the input buffer
1279 String siid = input.getVnfRequestInformation().getVnfId();
1280 String preloadName = input.getVnfRequestInformation().getVnfName();
1281 String preloadType = input.getVnfRequestInformation().getVnfType();
1283 if (input.getSdncRequestHeader() != null) {
1284 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1285 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1288 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1289 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1291 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1292 getServiceData(siid, serviceDataBuilder);
1294 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1295 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1297 // Set the serviceStatus based on input
1298 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1299 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1302 // setup a service-data object builder
1303 // ACTION vnf-topology-operation
1305 // USES request-information;
1306 // USES vnf-request-information
1308 // USES vnf-information
1309 // USES service-information
1311 // container service-data
1312 // uses oper-status;
1314 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + siid + INPUT_STR + input);
1315 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1316 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1318 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + siid + OPERATIONAL_DATA_STR + operDataBuilder
1320 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1323 "Adding CONFIG data for " + svcOperation + " [" + preloadName + "," + preloadType + "] preload-data: "
1324 + preloadDataBuilder.build());
1325 VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1327 // Call SLI sync method
1328 // Get SvcLogicService reference
1329 Properties respProps = null;
1330 String errorCode = "200";
1331 String errorMessage = null;
1332 String ackFinal = "Y";
1335 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1336 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", serviceDataBuilder, parms);
1338 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1341 } catch (SvcLogicException e) {
1342 log.error("Caught exception executing service logic for " + siid, e);
1343 errorMessage = e.getMessage();
1345 } catch (Exception e) {
1347 errorMessage = e.getMessage();
1348 log.error("Caught exception looking for service logic", e);
1351 if (respProps != null) {
1352 errorCode = respProps.getProperty("error-code");
1353 errorMessage = respProps.getProperty("error-message");
1354 ackFinal = respProps.getProperty("ack-final", "Y");
1357 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1358 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1359 serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
1361 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1362 responseBuilder.setResponseCode(errorCode);
1363 responseBuilder.setResponseMessage(errorMessage);
1364 responseBuilder.setAckFinalIndicator(ackFinal);
1365 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1366 vnfListBuilder.setVnfId(siid);
1367 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1369 saveVnfList(vnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1370 } catch (Exception e) {
1371 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + siid + "] \n", e);
1373 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1374 RpcResult<VnfTopologyOperationOutput> rpcResult =
1375 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1377 return Futures.immediateFuture(rpcResult);
1380 // Got success from SLI
1382 serviceData = serviceDataBuilder.build();
1383 log.info(UPDATING_MD_SAL_STR + svcOperation + " [" + siid + "] ServiceData: " + serviceData);
1384 // svc-configuration-list
1385 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1386 vnfListBuilder.setServiceData(serviceData);
1387 vnfListBuilder.setVnfId(serviceData.getVnfId());
1388 siid = serviceData.getVnfId();
1389 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1390 saveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1391 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1392 // Only update operational tree on Delete or Activate
1393 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1394 log.info(UPDATING_OPERATIONAL_TREE_STR);
1395 saveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1396 } else if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input
1397 .getSdncRequestHeader().getSvcAction().equals(SvcAction.Rollback)) {
1398 log.info("Delete OPERATIONAL tree.");
1399 deleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
1400 deleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
1403 VnfInformationBuilder vnfInformationBuilder = new VnfInformationBuilder();
1404 vnfInformationBuilder.setVnfId(siid);
1405 responseBuilder.setVnfInformation(vnfInformationBuilder.build());
1406 responseBuilder.setServiceInformation(serviceData.getServiceInformation());
1407 } catch (Exception e) {
1408 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + siid + "] \n", e);
1409 responseBuilder.setResponseCode("500");
1410 responseBuilder.setResponseMessage(e.toString());
1411 responseBuilder.setAckFinalIndicator("Y");
1412 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1413 RpcResult<VnfTopologyOperationOutput> rpcResult =
1414 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1416 return Futures.immediateFuture(rpcResult);
1420 responseBuilder.setResponseCode(errorCode);
1421 responseBuilder.setAckFinalIndicator(ackFinal);
1422 if (errorMessage != null) {
1423 responseBuilder.setResponseMessage(errorMessage);
1425 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + siid + "] ");
1426 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1428 RpcResult<VnfTopologyOperationOutput> rpcResult =
1429 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1431 return Futures.immediateFuture(rpcResult);
1435 public ListenableFuture<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1436 NetworkTopologyOperationInput input) {
1438 final String svcOperation = "network-topology-operation";
1439 ServiceData serviceData;
1440 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1441 Properties parms = new Properties();
1443 log.info(svcOperation + CALLED_STR);
1444 // create a new response object
1445 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1447 if (input == null || input.getServiceInformation() == null
1448 || input.getServiceInformation().getServiceInstanceId() == null
1449 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1450 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty service-instance-id");
1451 responseBuilder.setResponseCode("403");
1452 responseBuilder.setResponseMessage(INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID);
1453 responseBuilder.setAckFinalIndicator("Y");
1454 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1455 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1458 return Futures.immediateFuture(rpcResult);
1461 if (input.getNetworkRequestInformation() == null
1462 || input.getNetworkRequestInformation().getNetworkName() == null) {
1463 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty service-instance-id");
1464 responseBuilder.setResponseCode("403");
1465 responseBuilder.setResponseMessage(INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID);
1466 responseBuilder.setAckFinalIndicator("Y");
1467 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1468 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1471 return Futures.immediateFuture(rpcResult);
1474 // Grab the service instance ID from the input buffer
1476 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Assign)) {
1477 siid = input.getNetworkRequestInformation().getNetworkName();
1479 siid = input.getNetworkRequestInformation().getNetworkId();
1481 String preloadName = input.getNetworkRequestInformation().getNetworkName();
1482 String preloadType = input.getNetworkRequestInformation().getNetworkType();
1484 if (input.getSdncRequestHeader() != null) {
1485 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1486 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1489 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1490 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1492 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + siid + INPUT_STR + input);
1493 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1494 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1496 // Call SLI sync method
1497 // Get SvcLogicService reference
1498 Properties respProps = null;
1499 String errorCode = "200";
1500 String errorMessage = null;
1501 String ackFinal = "Y";
1502 String networkId = "error";
1505 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1506 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", preloadDataBuilder, parms);
1508 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1511 } catch (SvcLogicException e) {
1512 log.error("Caught exception executing service logic for " + svcOperation, e);
1513 errorMessage = e.getMessage();
1515 } catch (Exception e) {
1517 errorMessage = e.getMessage();
1518 log.error("Caught exception looking for service logic", e);
1521 if (respProps != null) {
1522 errorCode = respProps.getProperty("error-code");
1523 errorMessage = respProps.getProperty("error-message");
1524 ackFinal = respProps.getProperty("ack-final", "Y");
1525 networkId = respProps.getProperty("networkId", "0");
1528 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1529 responseBuilder.setResponseCode(errorCode);
1530 responseBuilder.setResponseMessage(errorMessage);
1531 responseBuilder.setAckFinalIndicator(ackFinal);
1533 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1535 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1536 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1539 return Futures.immediateFuture(rpcResult);
1542 // Got success from SLI
1544 NetworkInformationBuilder networkInformationBuilder = new NetworkInformationBuilder();
1545 networkInformationBuilder.setNetworkId(networkId);
1546 responseBuilder.setNetworkInformation(networkInformationBuilder.build());
1547 responseBuilder.setServiceInformation(input.getServiceInformation());
1548 } catch (IllegalStateException e) {
1549 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + siid + "] \n", e);
1550 responseBuilder.setResponseCode("500");
1551 responseBuilder.setResponseMessage(e.toString());
1552 responseBuilder.setAckFinalIndicator("Y");
1553 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1554 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1555 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1558 return Futures.immediateFuture(rpcResult);
1562 responseBuilder.setResponseCode(errorCode);
1563 responseBuilder.setAckFinalIndicator(ackFinal);
1564 if (errorMessage != null) {
1565 responseBuilder.setResponseMessage(errorMessage);
1567 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + siid + "] ");
1568 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1570 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1571 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1573 return Futures.immediateFuture(rpcResult);
1577 public ListenableFuture<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1578 PreloadVnfTopologyOperationInput input) {
1580 final String svcOperation = "preload-vnf-topology-operation";
1581 PreloadData preloadData;
1582 Properties parms = new Properties();
1584 log.info(svcOperation + CALLED_STR);
1585 // create a new response object
1586 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1588 // Result from savePreloadData
1590 if (input == null || input.getVnfTopologyInformation() == null
1591 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null
1592 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName() == null
1593 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType() == null) {
1594 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty vnf-name or vnf-type");
1595 responseBuilder.setResponseCode("403");
1596 responseBuilder.setResponseMessage("invalid input, null or empty vnf-name or vnf-type");
1597 responseBuilder.setAckFinalIndicator("Y");
1598 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1599 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1601 return Futures.immediateFuture(rpcResult);
1604 // Grab the name and type from the input buffer
1605 String preloadName = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1606 String preloadType = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1608 // Make sure we have a preload_name and preload_type
1609 if (preloadName == null || preloadName.length() == 0) {
1610 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
1611 responseBuilder.setResponseCode("403");
1612 responseBuilder.setResponseMessage(INVALID_INPUT_INVALID_PRELOAD_TYPE);
1613 responseBuilder.setAckFinalIndicator("Y");
1614 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1615 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1617 return Futures.immediateFuture(rpcResult);
1620 if (preloadType == null || preloadType.length() == 0) {
1621 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
1622 responseBuilder.setResponseCode("403");
1623 responseBuilder.setResponseMessage(INVALID_INPUT_INVALID_PRELOAD_TYPE);
1624 responseBuilder.setAckFinalIndicator("Y");
1625 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1626 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1628 return Futures.immediateFuture(rpcResult);
1631 if (input.getSdncRequestHeader() != null) {
1632 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1633 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1636 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1637 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1638 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1639 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1642 // setup a preload-data object builder
1643 // ACTION vnf-topology-operation
1645 // USES request-information;
1646 // uses vnf-topology-information;
1649 // container preload-data
1651 ADDING_INPUT_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
1652 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1653 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1654 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
1655 + OPERATIONAL_DATA_STR + operDataBuilder.build());
1656 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1658 // Call SLI sync method
1659 // Get SvcLogicService reference
1660 Properties respProps = null;
1661 String errorCode = "200";
1662 String errorMessage = null;
1663 String ackFinal = "Y";
1666 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1667 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", preloadDataBuilder, parms);
1669 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1672 } catch (SvcLogicException e) {
1673 log.error("Caught exception executing service logic for " + svcOperation, e);
1674 errorMessage = e.getMessage();
1676 } catch (Exception e) {
1678 errorMessage = e.getMessage();
1679 log.error("Caught exception looking for service logic", e);
1682 if (respProps != null) {
1683 errorCode = respProps.getProperty("error-code");
1684 errorMessage = respProps.getProperty("error-message");
1685 ackFinal = respProps.getProperty("ack-final", "Y");
1688 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1690 responseBuilder.setResponseCode(errorCode);
1691 responseBuilder.setResponseMessage(errorMessage);
1692 responseBuilder.setAckFinalIndicator(ackFinal);
1694 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1695 preloadVnfListBuilder.setVnfName(preloadName);
1696 preloadVnfListBuilder.setVnfType(preloadType);
1697 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1699 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
1700 + errorCode + "', Reason: '" + errorMessage + "'");
1702 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1703 } catch (Exception e) {
1705 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
1708 log.debug(SENDING_SUCCESS_RPC);
1709 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1710 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1712 return Futures.immediateFuture(rpcResult);
1715 // Got success from SLI
1717 preloadData = preloadDataBuilder.build();
1719 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
1721 // svc-configuration-list
1722 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1723 preloadVnfListBuilder.setVnfName(preloadName);
1724 preloadVnfListBuilder.setVnfType(preloadType);
1725 preloadVnfListBuilder.setPreloadData(preloadData);
1727 // SDNGC-989 set merge flag to false
1728 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1729 log.info(UPDATING_OPERATIONAL_TREE_STR);
1730 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1731 } catch (Exception e) {
1732 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
1734 responseBuilder.setResponseCode("500");
1735 responseBuilder.setResponseMessage(e.toString());
1736 responseBuilder.setAckFinalIndicator("Y");
1737 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
1738 + responseBuilder.build());
1739 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1740 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(false).withResult(responseBuilder.build())
1742 return Futures.immediateFuture(rpcResult);
1746 responseBuilder.setResponseCode(errorCode);
1747 responseBuilder.setAckFinalIndicator(ackFinal);
1748 if (errorMessage != null) {
1749 responseBuilder.setResponseMessage(errorMessage);
1751 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
1753 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
1756 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1757 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1759 return Futures.immediateFuture(rpcResult);
1762 //1610 preload-vnf-instance-topology-operation
1764 public ListenableFuture<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> preloadVnfInstanceTopologyOperation(
1765 PreloadVnfInstanceTopologyOperationInput input) {
1767 final String svcOperation = "preload-vnf-instance-topology-operation";
1768 VnfInstancePreloadData vnfInstancePreloadData;
1769 Properties parms = new Properties();
1771 log.info(svcOperation + CALLED_STR);
1772 // create a new response object
1773 PreloadVnfInstanceTopologyOperationOutputBuilder responseBuilder =
1774 new PreloadVnfInstanceTopologyOperationOutputBuilder();
1776 if (input == null || input.getVnfInstanceTopologyInformation() == null
1777 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName() == null
1778 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId() == null) {
1779 log.debug(EXITING_STR + svcOperation
1780 + " because of invalid input, null or empty vnf-instance-name or vnf-model-id");
1781 responseBuilder.setResponseCode("403");
1782 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name or vnf-model-id");
1783 responseBuilder.setAckFinalIndicator("Y");
1784 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1785 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1786 .withResult(responseBuilder.build()).build();
1787 return Futures.immediateFuture(rpcResult);
1790 // Grab the name and type from the input buffer
1791 String preloadName =
1792 input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName();
1793 String preloadType = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId();
1795 // Make sure we have a preloadName and preloadType
1796 if (preloadName == null || preloadName.length() == 0) {
1797 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
1798 responseBuilder.setResponseCode("403");
1799 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1800 responseBuilder.setAckFinalIndicator("Y");
1801 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1802 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1803 .withResult(responseBuilder.build()).build();
1804 return Futures.immediateFuture(rpcResult);
1807 if (preloadType == null || preloadType.length() == 0) {
1808 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
1809 responseBuilder.setResponseCode("403");
1810 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1811 responseBuilder.setAckFinalIndicator("Y");
1812 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1813 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1814 .withResult(responseBuilder.build()).build();
1815 return Futures.immediateFuture(rpcResult);
1818 if (input.getSdncRequestHeader() != null) {
1819 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1820 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1823 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
1824 getVnfInstancePreloadData(preloadName, preloadType, vnfInstancePreloadDataBuilder);
1825 VnfInstancePreloadDataBuilder operDataBuilder = new VnfInstancePreloadDataBuilder();
1826 getVnfInstancePreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1829 // setup a preload-data object builder
1830 // ACTION vnf-topology-operation
1832 // uses vnf-topology-information;
1834 // container preload-data
1836 ADDING_CONFIG_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
1837 PreloadVnfInstanceTopologyOperationInputBuilder inputBuilder =
1838 new PreloadVnfInstanceTopologyOperationInputBuilder(input);
1839 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1840 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
1841 + OPERATIONAL_DATA_STR + operDataBuilder.build());
1842 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1844 // Call SLI sync method
1845 // Get SvcLogicService reference
1846 Properties respProps = null;
1847 String errorCode = "200";
1848 String errorMessage = null;
1849 String ackFinal = "Y";
1852 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1853 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", vnfInstancePreloadDataBuilder, parms);
1855 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1858 } catch (SvcLogicException e) {
1859 log.error("Caught exception executing service logic for " + svcOperation, e);
1860 errorMessage = e.getMessage();
1862 } catch (Exception e) {
1864 errorMessage = e.getMessage();
1865 log.error("Caught exception looking for service logic", e);
1868 if (respProps != null) {
1869 errorCode = respProps.getProperty("error-code");
1870 errorMessage = respProps.getProperty("error-message");
1871 ackFinal = respProps.getProperty("ack-final", "Y");
1874 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1876 responseBuilder.setResponseCode(errorCode);
1877 responseBuilder.setResponseMessage(errorMessage);
1878 responseBuilder.setAckFinalIndicator(ackFinal);
1880 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
1881 vnfInstancePreloadListBuilder.setVnfInstanceName(preloadName);
1882 vnfInstancePreloadListBuilder.setVnfModelId(preloadType);
1883 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadDataBuilder.build());
1885 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
1886 + errorCode + "', Reason: '" + errorMessage + "'");
1888 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), true,
1889 LogicalDatastoreType.CONFIGURATION);
1890 } catch (Exception e) {
1892 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
1895 log.debug(SENDING_SUCCESS_RPC);
1896 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1897 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1898 .withResult(responseBuilder.build()).build();
1899 return Futures.immediateFuture(rpcResult);
1902 // Got success from SLI
1904 vnfInstancePreloadData = vnfInstancePreloadDataBuilder.build();
1906 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
1907 + vnfInstancePreloadData);
1908 // svc-configuration-list
1909 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
1910 vnfInstancePreloadListBuilder.setVnfInstanceName(preloadName);
1911 vnfInstancePreloadListBuilder.setVnfModelId(preloadType);
1912 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadData);
1914 // SDNGC-989 set merge flag to false
1915 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false,
1916 LogicalDatastoreType.CONFIGURATION);
1917 log.info(UPDATING_OPERATIONAL_TREE_STR);
1918 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1919 } catch (Exception e) {
1920 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
1922 responseBuilder.setResponseCode("500");
1923 responseBuilder.setResponseMessage(e.toString());
1924 responseBuilder.setAckFinalIndicator("Y");
1925 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
1926 + responseBuilder.build());
1927 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1928 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(false)
1929 .withResult(responseBuilder.build()).build();
1930 return Futures.immediateFuture(rpcResult);
1934 responseBuilder.setResponseCode(errorCode);
1935 responseBuilder.setAckFinalIndicator(ackFinal);
1936 if (errorMessage != null) {
1937 responseBuilder.setResponseMessage(errorMessage);
1939 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
1941 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
1944 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1945 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1947 return Futures.immediateFuture(rpcResult);
1951 //1610 preload-vf-module-topology-operation
1953 public ListenableFuture<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
1954 PreloadVfModuleTopologyOperationInput input) {
1956 final String svcOperation = "preload-vf-module-topology-operation";
1957 VfModulePreloadData vfModulePreloadData;
1958 Properties parms = new Properties();
1960 log.info(svcOperation + CALLED_STR);
1961 // create a new response object
1962 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder =
1963 new PreloadVfModuleTopologyOperationOutputBuilder();
1965 // Result from savePreloadData
1967 if (input == null || input.getVfModuleTopologyInformation() == null
1968 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName() == null
1969 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId() == null) {
1970 log.debug(EXITING_STR + svcOperation
1971 + " because of invalid input, null or empty vf-module-name or vf-module-model-id");
1972 responseBuilder.setResponseCode("403");
1973 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-name or vf-module-model-id");
1974 responseBuilder.setAckFinalIndicator("Y");
1975 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
1976 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
1977 .withResult(responseBuilder.build()).build();
1978 return Futures.immediateFuture(rpcResult);
1981 // Grab the name and type from the input buffer
1982 String preloadName = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName();
1983 String preloadType = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId();
1985 // Make sure we have a preloadName and preloadType
1986 if (preloadName == null || preloadName.length() == 0) {
1987 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
1988 responseBuilder.setResponseCode("403");
1989 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1990 responseBuilder.setAckFinalIndicator("Y");
1991 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
1992 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
1993 .withResult(responseBuilder.build()).build();
1994 return Futures.immediateFuture(rpcResult);
1996 if (preloadType == null || preloadType.length() == 0) {
1997 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
1998 responseBuilder.setResponseCode("403");
1999 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2000 responseBuilder.setAckFinalIndicator("Y");
2001 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2002 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2003 .withResult(responseBuilder.build()).build();
2004 return Futures.immediateFuture(rpcResult);
2007 if (input.getSdncRequestHeader() != null) {
2008 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2009 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2012 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
2013 getVfModulePreloadData(preloadName, preloadType, vfModulePreloadDataBuilder);
2014 VfModulePreloadDataBuilder operDataBuilder = new VfModulePreloadDataBuilder();
2015 getVfModulePreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2018 // setup a preload-data object builder
2019 // ACTION vnf-topology-operation
2021 // USES request-information;
2022 // uses vnf-topology-information;
2025 // container preload-data
2028 ADDING_INPUT_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
2029 PreloadVfModuleTopologyOperationInputBuilder inputBuilder =
2030 new PreloadVfModuleTopologyOperationInputBuilder(input);
2031 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2032 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
2033 + OPERATIONAL_DATA_STR + operDataBuilder.build());
2034 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
2036 // Call SLI sync method
2037 // Get SvcLogicService reference
2038 Properties respProps = null;
2039 String errorCode = "200";
2040 String errorMessage = null;
2041 String ackFinal = "Y";
2044 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
2045 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", vfModulePreloadDataBuilder, parms);
2047 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
2050 } catch (SvcLogicException e) {
2051 log.error("Caught exception executing service logic for " + svcOperation, e);
2052 errorMessage = e.getMessage();
2055 } catch (Exception e) {
2057 errorMessage = e.getMessage();
2058 log.error("Caught exception looking for service logic", e);
2061 if (respProps != null) {
2062 errorCode = respProps.getProperty("error-code");
2063 errorMessage = respProps.getProperty("error-message");
2064 ackFinal = respProps.getProperty("ack-final", "Y");
2067 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2069 responseBuilder.setResponseCode(errorCode);
2070 responseBuilder.setResponseMessage(errorMessage);
2071 responseBuilder.setAckFinalIndicator(ackFinal);
2073 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2074 vfModulePreloadListBuilder.setVfModuleName(preloadName);
2075 vfModulePreloadListBuilder.setVfModuleModelId(preloadType);
2076 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadDataBuilder.build());
2078 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
2079 + errorCode + "', Reason: '" + errorMessage + "'");
2081 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2082 } catch (Exception e) {
2084 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2087 log.debug(SENDING_SUCCESS_RPC);
2088 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2089 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2090 .withResult(responseBuilder.build()).build();
2091 return Futures.immediateFuture(rpcResult);
2094 // Got success from SLI
2096 vfModulePreloadData = vfModulePreloadDataBuilder.build();
2098 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
2099 + vfModulePreloadData);
2100 // svc-configuration-list
2101 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2102 vfModulePreloadListBuilder.setVfModuleName(preloadName);
2103 vfModulePreloadListBuilder.setVfModuleModelId(preloadType);
2104 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadData);
2106 // SDNGC-989 set merge flag to false
2107 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2108 log.info(UPDATING_OPERATIONAL_TREE_STR);
2109 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2110 } catch (Exception e) {
2111 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2113 responseBuilder.setResponseCode("500");
2114 responseBuilder.setResponseMessage(e.toString());
2115 responseBuilder.setAckFinalIndicator("Y");
2116 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
2117 + responseBuilder.build());
2118 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2119 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(false)
2120 .withResult(responseBuilder.build()).build();
2121 return Futures.immediateFuture(rpcResult);
2125 responseBuilder.setResponseCode(errorCode);
2126 responseBuilder.setAckFinalIndicator(ackFinal);
2127 if (errorMessage != null) {
2128 responseBuilder.setResponseMessage(errorMessage);
2130 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
2132 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
2135 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2136 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2138 return Futures.immediateFuture(rpcResult);
2143 public ListenableFuture<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2144 PreloadNetworkTopologyOperationInput input) {
2146 final String svcOperation = "preload-network-topology-operation";
2147 PreloadData preloadData = null;
2148 Properties parms = new Properties();
2150 log.info(svcOperation + CALLED_STR);
2151 // create a new response object
2152 PreloadNetworkTopologyOperationOutputBuilder responseBuilder =
2153 new PreloadNetworkTopologyOperationOutputBuilder();
2155 // Result from savePreloadData
2157 if (input == null || input.getNetworkTopologyInformation() == null
2158 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null
2159 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName() == null
2160 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType() == null) {
2161 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or" +
2162 " empty network-name or network-type");
2163 responseBuilder.setResponseCode("403");
2164 responseBuilder.setResponseMessage("input, null or empty network-name or network-type");
2165 responseBuilder.setAckFinalIndicator("Y");
2166 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2167 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2169 return Futures.immediateFuture(rpcResult);
2172 // Grab the name and type from the input buffer
2173 String preloadName = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2174 String preloadType = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2176 // Make sure we have a preloadName and preloadType
2177 if (preloadName == null || preloadName.length() == 0) {
2178 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
2179 responseBuilder.setResponseCode("403");
2180 responseBuilder.setResponseMessage("input, invalid preload-name");
2181 responseBuilder.setAckFinalIndicator("Y");
2182 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2183 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2185 return Futures.immediateFuture(rpcResult);
2189 if (preloadType == null || preloadType.length() == 0) {
2190 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
2191 responseBuilder.setResponseCode("403");
2192 responseBuilder.setResponseMessage("input, invalid preload-type");
2193 responseBuilder.setAckFinalIndicator("Y");
2194 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2195 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2197 return Futures.immediateFuture(rpcResult);
2200 if (input.getSdncRequestHeader() != null) {
2201 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2202 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2205 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2206 getPreloadData(preloadName, preloadType, preloadDataBuilder);
2208 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2209 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2212 // setup a preload-data object builder
2213 // ACTION vnf-topology-operation
2215 // USES request-information;
2216 // uses vnf-topology-information;
2219 // container preload-data
2221 ADDING_INPUT_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
2222 PreloadNetworkTopologyOperationInputBuilder inputBuilder =
2223 new PreloadNetworkTopologyOperationInputBuilder(input);
2224 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2225 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
2226 + OPERATIONAL_DATA_STR + operDataBuilder.build());
2227 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
2229 // Call SLI sync method
2230 // Get SvcLogicService reference
2231 Properties respProps = null;
2232 String errorCode = "200";
2233 String errorMessage = null;
2234 String ackFinal = "Y";
2237 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
2238 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", preloadDataBuilder, parms);
2240 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
2243 } catch (SvcLogicException e) {
2244 log.error("Caught exception executing service logic for " + svcOperation, e);
2245 errorMessage = e.getMessage();
2247 } catch (Exception e) {
2249 errorMessage = e.getMessage();
2250 log.error("Caught exception looking for service logic", e);
2253 if (respProps != null) {
2254 errorCode = respProps.getProperty("error-code");
2255 errorMessage = respProps.getProperty("error-message");
2256 ackFinal = respProps.getProperty("ack-final", "Y");
2259 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2260 responseBuilder.setResponseCode(errorCode);
2261 responseBuilder.setResponseMessage(errorMessage);
2262 responseBuilder.setAckFinalIndicator(ackFinal);
2264 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2265 preloadVnfListBuilder.setVnfName(preloadName);
2266 preloadVnfListBuilder.setVnfType(preloadType);
2267 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2269 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
2270 + errorCode + "', Reason: '" + errorMessage + "'");
2272 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2273 } catch (Exception e) {
2275 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2279 log.debug(SENDING_SUCCESS_RPC);
2280 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2281 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2283 return Futures.immediateFuture(rpcResult);
2286 // Got success from SLI
2288 preloadData = preloadDataBuilder.build();
2290 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
2292 // svc-configuration-list
2293 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2294 preloadVnfListBuilder.setVnfName(preloadName);
2295 preloadVnfListBuilder.setVnfType(preloadType);
2296 preloadVnfListBuilder.setPreloadData(preloadData);
2298 // SDNGC-989 set merge flag to false
2299 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2300 log.info(UPDATING_OPERATIONAL_TREE_STR);
2301 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2302 } catch (Exception e) {
2303 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2305 responseBuilder.setResponseCode("500");
2306 responseBuilder.setResponseMessage(e.toString());
2307 responseBuilder.setAckFinalIndicator("Y");
2308 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
2309 + responseBuilder.build());
2310 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2311 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(false)
2312 .withResult(responseBuilder.build()).build();
2313 return Futures.immediateFuture(rpcResult);
2317 responseBuilder.setResponseCode(errorCode);
2318 responseBuilder.setAckFinalIndicator(ackFinal);
2319 if (errorMessage != null) {
2320 responseBuilder.setResponseMessage(errorMessage);
2322 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
2324 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
2327 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2328 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2330 return Futures.immediateFuture(rpcResult);