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.base.Optional;
25 import com.google.common.util.concurrent.CheckedFuture;
26 import com.google.common.util.concurrent.FutureCallback;
27 import com.google.common.util.concurrent.Futures;
28 import com.google.common.util.concurrent.SettableFuture;
29 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
30 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
31 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
32 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
33 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
34 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
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.concepts.ListenerRegistration;
130 import org.opendaylight.yangtools.yang.binding.DataObject;
131 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
132 import org.opendaylight.yangtools.yang.common.RpcResult;
133 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
134 import org.opendaylight.yangtools.yang.data.api.schema.tree.ModifiedNodeDoesNotExistException;
135 import org.slf4j.Logger;
136 import org.slf4j.LoggerFactory;
137 import org.slf4j.MDC;
139 import java.text.DateFormat;
140 import java.text.SimpleDateFormat;
141 import java.util.ArrayList;
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.concurrent.Future;
151 * Defines a base implementation for your provider. This class extends from a helper class
152 * which provides storage for the most commonly used components of the MD-SAL. Additionally the
153 * base class provides some basic logging and initialization / clean up methods.
155 public class vnfapiProvider implements AutoCloseable, VNFAPIService, DataChangeListener {
156 protected DataBroker dataBroker;
157 protected NotificationPublishService notificationService;
158 protected RpcProviderRegistry rpcRegistry;
159 protected BindingAwareBroker.RpcRegistration<VNFAPIService> rpcRegistration;
161 private final Logger log = LoggerFactory.getLogger(vnfapiProvider.class);
162 private final String appName = "vnfapi";
163 private final ExecutorService executor;
165 private VNFSDNSvcLogicServiceClient svcLogicClient;
166 private ListenerRegistration<DataChangeListener> dclServices;
168 public vnfapiProvider(DataBroker dataBroker2, NotificationPublishService notificationPublishService,
169 RpcProviderRegistry rpcProviderRegistry, VNFSDNSvcLogicServiceClient client) {
170 this.log.info("Creating provider for " + appName);
171 executor = Executors.newFixedThreadPool(1);
172 dataBroker = dataBroker2;
173 notificationService = notificationPublishService;
174 rpcRegistry = rpcProviderRegistry;
175 this.svcLogicClient = client;
179 public void initialize() {
180 log.info("Initializing provider for " + appName);
181 // Create the top level containers
184 VnfSdnUtil.loadProperties();
185 } catch (Exception e) {
186 log.error("Caught Exception while trying to load properties file: ", e);
189 log.info("Initialization complete for " + appName);
192 private void createContainers() {
193 final WriteTransaction t = dataBroker.newReadWriteTransaction();
195 // Create the Vnfs container
196 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
197 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
199 // Create the PreloadVnfs container
200 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
201 new PreloadVnfsBuilder().build());
202 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
203 new PreloadVnfsBuilder().build());
205 // 1610 Create the PreloadVnfInstances container
206 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfInstances.class),
207 new PreloadVnfInstancesBuilder().build());
208 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfInstances.class),
209 new PreloadVnfInstancesBuilder().build());
211 // 1610 Create the VnfInstances container
212 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VnfInstances.class),
213 new VnfInstancesBuilder().build());
214 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VnfInstances.class),
215 new VnfInstancesBuilder().build());
217 // 1610 Create the PreloadVfModules container
218 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVfModules.class),
219 new PreloadVfModulesBuilder().build());
220 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVfModules.class),
221 new PreloadVfModulesBuilder().build());
223 // 1610 Create the VfModules container
224 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VfModules.class),
225 new VfModulesBuilder().build());
226 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VfModules.class),
227 new VfModulesBuilder().build());
230 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
232 log.info("Create Containers succeeded!: ");
234 } catch (InterruptedException | ExecutionException e) {
235 log.error("Create Containers Failed: " + e);
239 @Override public void close() throws Exception {
240 log.info("Closing provider for " + appName);
242 rpcRegistration.close();
243 log.info("Successfully closed provider for " + appName);
246 // On data change not used
247 @Override public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
248 boolean changed = false;
249 log.info(" IN ON DATA CHANGE: ");
250 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
252 DataObject updatedSubTree = change.getUpdatedSubtree();
254 if (updatedSubTree != null) {
255 if (log.isDebugEnabled()) {
256 log.debug("updatedSubTree was non-null:" + updatedSubTree);
258 if (updatedSubTree instanceof Vnfs) {
259 ArrayList<VnfList> vnfList = (ArrayList<VnfList>) ((Vnfs) updatedSubTree).getVnfList();
260 if (vnfList != null) {
261 for (VnfList entry : vnfList) {
262 ServiceData serviceData = entry.getServiceData();
263 ServiceStatus serviceStatus = entry.getServiceStatus();
264 if (serviceData != null && serviceStatus != null) {
266 // ServiceData change detected, check the AckFinal indicator and request-status to see if we need to proceed.
268 if ((!"Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete
269 .equals(serviceStatus.getRequestStatus()))) {
270 if (log.isDebugEnabled()) {
271 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
273 //handleServiceDataUpdated(serviceData, serviceStatus, writeTransaction);
280 if (updatedSubTree instanceof PreloadVnfs) {
281 ArrayList<VnfPreloadList> vnfList =
282 (ArrayList<VnfPreloadList>) ((PreloadVnfs) updatedSubTree).getVnfPreloadList();
283 if (vnfList != null) {
284 for (VnfPreloadList entry : vnfList) {
285 PreloadData preloadData = entry.getPreloadData();
286 if (preloadData != null) {
293 if (updatedSubTree instanceof PreloadVnfInstances) {
294 ArrayList<VnfInstancePreloadList> vnfInstanceList =
295 (ArrayList<VnfInstancePreloadList>) ((PreloadVnfInstances) updatedSubTree)
296 .getVnfInstancePreloadList();
297 if (vnfInstanceList != null) {
298 for (VnfInstancePreloadList entry : vnfInstanceList) {
299 VnfInstancePreloadData vnfInstancePreloadData = entry.getVnfInstancePreloadData();
300 if (vnfInstancePreloadData != null) {
307 if (updatedSubTree instanceof VnfInstances) {
308 ArrayList<VnfInstanceList> vnfInstanceList =
309 (ArrayList<VnfInstanceList>) ((VnfInstances) updatedSubTree).getVnfInstanceList();
310 if (vnfInstanceList != null) {
311 for (VnfInstanceList entry : vnfInstanceList) {
312 VnfInstanceServiceData vnfInstanceServiceData = entry.getVnfInstanceServiceData();
313 ServiceStatus serviceStatus = entry.getServiceStatus();
314 if (vnfInstanceServiceData != null && serviceStatus != null) {
315 // VnfInstanceServiceData change detected, check the AckFinal indicator and request-status
316 // to see if we need to proceed.
317 if ((!"Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete
318 .equals(serviceStatus.getRequestStatus()))) {
319 if (log.isDebugEnabled()) {
320 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
329 if (updatedSubTree instanceof PreloadVfModules) {
330 ArrayList<VfModulePreloadList> vnfInstanceList =
331 (ArrayList<VfModulePreloadList>) ((PreloadVfModules) updatedSubTree).getVfModulePreloadList();
332 if (vnfInstanceList != null) {
333 for (VfModulePreloadList entry : vnfInstanceList) {
334 VfModulePreloadData vnfInstancePreloadData = entry.getVfModulePreloadData();
335 if (vnfInstancePreloadData != null) {
342 if (updatedSubTree instanceof VfModules) {
343 ArrayList<VfModuleList> vfModuleList =
344 (ArrayList<VfModuleList>) ((VfModules) updatedSubTree).getVfModuleList();
345 if (vfModuleList != null) {
346 for (VfModuleList entry : vfModuleList) {
347 VfModuleServiceData vfModuleServiceData = entry.getVfModuleServiceData();
348 ServiceStatus serviceStatus = entry.getServiceStatus();
349 if (vfModuleServiceData != null && serviceStatus != null) {
350 // VfModuleServiceData change detected, check the AckFinal indicator and request-status to
351 // see if we need to proceed.
352 if ((!"Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete
353 .equals(serviceStatus.getRequestStatus()))) {
354 if (log.isDebugEnabled()) {
355 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
364 // Do the write transaction only if something changed.
366 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = writeTransaction.submit();
367 Futures.addCallback(checkedFuture, new FutureCallback<Void>() {
369 @Override public void onSuccess(Void arg0) {
370 log.debug("Successfully updated Service Status");
373 @Override public void onFailure(Throwable ex) {
374 log.debug("Failed updating Service Status", ex);
380 private static class Iso8601Util {
381 private static TimeZone tz = TimeZone.getTimeZone("UTC");
382 private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
388 private static String now() {
389 return df.format(new Date());
393 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
395 serviceStatusBuilder.setResponseCode(errorCode);
396 serviceStatusBuilder.setResponseMessage(errorMessage);
397 serviceStatusBuilder.setFinalIndicator(ackFinal);
398 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
401 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
402 if (requestInformation != null && requestInformation.getRequestAction() != null) {
403 switch (requestInformation.getRequestAction()) {
404 case VNFActivateRequest:
405 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VNFActivateRequest);
407 case ChangeVNFActivateRequest:
408 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVNFActivateRequest);
410 case DisconnectVNFRequest:
411 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVNFRequest);
413 case PreloadVNFRequest:
414 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVNFRequest);
416 case DeletePreloadVNFRequest:
417 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DeletePreloadVNFRequest);
419 // 1610 vnf-instance Requests
420 case VnfInstanceActivateRequest:
421 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VnfInstanceActivateRequest);
423 case ChangeVnfInstanceActivateRequest:
424 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVnfInstanceActivateRequest);
426 case DisconnectVnfInstanceRequest:
427 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVnfInstanceRequest);
429 case PreloadVnfInstanceRequest:
430 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVnfInstanceRequest);
432 // 1610 vf-module Requests
433 case VfModuleActivateRequest:
434 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VfModuleActivateRequest);
436 case ChangeVfModuleActivateRequest:
437 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVfModuleActivateRequest);
439 case DisconnectVfModuleRequest:
440 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVfModuleRequest);
442 case PreloadVfModuleRequest:
443 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVfModuleRequest);
446 log.error("Unknown RequestAction: " + requestInformation.getRequestAction());
450 if (requestInformation != null && requestInformation.getRequestSubAction() != null) {
451 switch (requestInformation.getRequestSubAction()) {
453 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP);
456 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
459 log.error("Unknown RequestSubAction: " + requestInformation.getRequestSubAction());
465 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
466 if (requestHeader != null && requestHeader.getSvcAction() != null) {
467 switch (requestHeader.getSvcAction()) {
469 serviceStatusBuilder.setRpcAction(RpcAction.Reserve);
472 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
475 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
478 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
481 serviceStatusBuilder.setRpcAction(RpcAction.Changeassign);
484 serviceStatusBuilder.setRpcAction(RpcAction.Changedelete);
487 serviceStatusBuilder.setRpcAction(RpcAction.Rollback);
490 log.error("Unknown SvcAction: " + requestHeader.getSvcAction());
496 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
498 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
502 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
503 // See if any data exists yet for this siid, if so grab it.
504 InstanceIdentifier serviceInstanceIdentifier =
505 InstanceIdentifier.<Vnfs>builder(Vnfs.class).child(VnfList.class, new VnfListKey(siid)).build();
506 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
507 Optional<VnfList> data = null;
509 data = (Optional<VnfList>) readTx.read(type, serviceInstanceIdentifier).get();
510 } catch (InterruptedException | ExecutionException e) {
511 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + siid + "] ", e);
514 if (data != null && data.isPresent()) {
515 ServiceData serviceData = (ServiceData) data.get().getServiceData();
516 if (serviceData != null) {
517 log.info("Read MD-SAL (" + type + ") data for [" + siid + "] ServiceData: " + serviceData);
518 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
519 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
520 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
521 serviceDataBuilder.setVnfRequestInformation(serviceData.getVnfRequestInformation());
522 serviceDataBuilder.setVnfId(serviceData.getVnfId());
523 serviceDataBuilder.setVnfTopologyInformation(serviceData.getVnfTopologyInformation());
524 serviceDataBuilder.setOperStatus(serviceData.getOperStatus());
526 log.info("No service-data found in MD-SAL (" + type + ") for [" + siid + "] ");
529 log.info("No data found in MD-SAL (" + type + ") for [" + siid + "] ");
534 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder) {
536 getVnfInstanceServiceData(siid, vnfInstanceServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
540 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder,
541 LogicalDatastoreType type) {
542 // See if any data exists yet for this siid, if so grab it.
543 InstanceIdentifier vnfInstanceIdentifier = InstanceIdentifier.<VnfInstances>builder(VnfInstances.class)
544 .child(VnfInstanceList.class, new VnfInstanceListKey(siid)).build();
545 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
546 Optional<VnfInstanceList> data = null;
548 data = (Optional<VnfInstanceList>) readTx.read(type, vnfInstanceIdentifier).get();
549 } catch (InterruptedException | ExecutionException e) {
550 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + siid + "] ", e);
553 if (data != null && data.isPresent()) {
554 VnfInstanceServiceData vnfInstanceServiceData =
555 (VnfInstanceServiceData) data.get().getVnfInstanceServiceData();
556 if (vnfInstanceServiceData != null) {
557 log.info("Read MD-SAL (" + type + ") data for [" + siid + "] VnfInstanceServiceData: "
558 + vnfInstanceServiceData);
559 vnfInstanceServiceDataBuilder.setSdncRequestHeader(vnfInstanceServiceData.getSdncRequestHeader());
560 vnfInstanceServiceDataBuilder.setRequestInformation(vnfInstanceServiceData.getRequestInformation());
561 vnfInstanceServiceDataBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
562 vnfInstanceServiceDataBuilder
563 .setVnfInstanceRequestInformation(vnfInstanceServiceData.getVnfInstanceRequestInformation());
564 vnfInstanceServiceDataBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
565 vnfInstanceServiceDataBuilder
566 .setVnfInstanceTopologyInformation(vnfInstanceServiceData.getVnfInstanceTopologyInformation());
567 vnfInstanceServiceDataBuilder.setOperStatus(vnfInstanceServiceData.getOperStatus());
569 log.info("No vnf-instance-service-data found in MD-SAL (" + type + ") for [" + siid + "] ");
572 log.info("No data found in MD-SAL (" + type + ") for [" + siid + "] ");
577 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder) {
579 getVfModuleServiceData(siid, vfModuleServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
583 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder,
584 LogicalDatastoreType type) {
585 // See if any data exists yet for this siid, if so grab it.
586 InstanceIdentifier vfModuleIdentifier =
587 InstanceIdentifier.<VfModules>builder(VfModules.class).child(VfModuleList.class, new VfModuleListKey(siid))
589 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
590 Optional<VfModuleList> data = null;
592 data = (Optional<VfModuleList>) readTx.read(type, vfModuleIdentifier).get();
593 } catch (InterruptedException | ExecutionException e) {
594 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + siid + "] ", e);
597 if (data != null && data.isPresent()) {
598 VfModuleServiceData vfModuleServiceData = data.get().getVfModuleServiceData();
599 if (vfModuleServiceData != null) {
601 "Read MD-SAL (" + type + ") data for [" + siid + "] VfModuleServiceData: " + vfModuleServiceData);
602 vfModuleServiceDataBuilder.setSdncRequestHeader(vfModuleServiceData.getSdncRequestHeader());
603 vfModuleServiceDataBuilder.setRequestInformation(vfModuleServiceData.getRequestInformation());
604 vfModuleServiceDataBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
605 vfModuleServiceDataBuilder
606 .setVfModuleRequestInformation(vfModuleServiceData.getVfModuleRequestInformation());
607 vfModuleServiceDataBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
608 vfModuleServiceDataBuilder
609 .setVfModuleTopologyInformation(vfModuleServiceData.getVfModuleTopologyInformation());
610 vfModuleServiceDataBuilder.setOperStatus(vfModuleServiceData.getOperStatus());
612 log.info("No vf-module-service-data found in MD-SAL (" + type + ") for [" + siid + "] ");
615 log.info("No data found in MD-SAL (" + type + ") for [" + siid + "] ");
620 private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder) {
622 getPreloadData(vnf_name, vnf_type, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
625 private void getPreloadData(String preload_name, String preload_type, PreloadDataBuilder preloadDataBuilder,
626 LogicalDatastoreType type) {
627 // See if any data exists yet for this name/type, if so grab it.
628 InstanceIdentifier preloadInstanceIdentifier = InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
629 .child(VnfPreloadList.class, new VnfPreloadListKey(preload_name, preload_type)).build();
630 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
631 Optional<VnfPreloadList> data = null;
633 data = (Optional<VnfPreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
634 } catch (InterruptedException | ExecutionException e) {
635 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ",
639 if (data != null && data.isPresent()) {
640 PreloadData preloadData = (PreloadData) data.get().getPreloadData();
641 if (preloadData != null) {
642 log.info("Read MD-SAL (" + type + ") data for [" + preload_name + "," + preload_type + "] PreloadData: "
644 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
645 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
646 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
649 "No preload-data found in MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ");
652 log.info("No data found in MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ");
656 //1610 preload-vnf-instance
657 private void getVnfInstancePreloadData(String vnf_name, String vnf_type,
658 VnfInstancePreloadDataBuilder preloadDataBuilder) {
660 getVnfInstancePreloadData(vnf_name, vnf_type, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
663 //1610 preload-vnf-instance
664 private void getVnfInstancePreloadData(String preload_name, String preload_type,
665 VnfInstancePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
666 // See if any data exists yet for this name/type, if so grab it.
667 InstanceIdentifier preloadInstanceIdentifier =
668 InstanceIdentifier.<PreloadVnfInstances>builder(PreloadVnfInstances.class)
669 .child(VnfInstancePreloadList.class, new VnfInstancePreloadListKey(preload_name, preload_type)).build();
670 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
671 Optional<VnfInstancePreloadList> data = null;
673 data = (Optional<VnfInstancePreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
674 } catch (InterruptedException | ExecutionException e) {
675 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ",
679 if (data != null && data.isPresent()) {
680 VnfInstancePreloadData preloadData = (VnfInstancePreloadData) data.get().getVnfInstancePreloadData();
681 if (preloadData != null) {
682 log.info("Read MD-SAL (" + type + ") data for [" + preload_name + "," + preload_type
683 + "] VnfInstancePreloadData: " + preloadData);
684 preloadDataBuilder.setVnfInstanceTopologyInformation(preloadData.getVnfInstanceTopologyInformation());
685 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
687 log.info("No vnf-instance-preload-data found in MD-SAL (" + type + ") for [" + preload_name + ","
688 + preload_type + "] ");
691 log.info("No data found in MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ");
695 // 1610 preload-vf-module
696 private void getVfModulePreloadData(String vnf_name, String vnf_type,
697 VfModulePreloadDataBuilder preloadDataBuilder) {
699 getVfModulePreloadData(vnf_name, vnf_type, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
702 private void getVfModulePreloadData(String preload_name, String preload_type,
703 VfModulePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
704 // See if any data exists yet for this name/type, if so grab it.
705 InstanceIdentifier preloadInstanceIdentifier =
706 InstanceIdentifier.<PreloadVfModules>builder(PreloadVfModules.class)
707 .child(VfModulePreloadList.class, new VfModulePreloadListKey(preload_name, preload_type)).build();
708 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
709 Optional<VfModulePreloadList> data = null;
711 data = (Optional<VfModulePreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
712 } catch (InterruptedException | ExecutionException e) {
713 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ",
717 if (data != null && data.isPresent()) {
718 VfModulePreloadData preloadData = (VfModulePreloadData) data.get().getVfModulePreloadData();
719 if (preloadData != null) {
720 log.info("Read MD-SAL (" + type + ") data for [" + preload_name + "," + preload_type
721 + "] VfModulePreloadData: " + preloadData);
722 preloadDataBuilder.setVfModuleTopologyInformation(preloadData.getVfModuleTopologyInformation());
723 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
726 "No preload-data found in MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ");
729 log.info("No data found in MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ");
733 private void SaveVnfList(final VnfList entry, boolean merge, LogicalDatastoreType storeType)
734 throws IllegalStateException {
735 // Each entry will be identifiable by a unique key, we have to create that identifier
736 InstanceIdentifier.InstanceIdentifierBuilder<VnfList> vnfListIdBuilder =
737 InstanceIdentifier.<Vnfs>builder(Vnfs.class).child(VnfList.class, entry.getKey());
738 InstanceIdentifier<VnfList> path = vnfListIdBuilder.build();
743 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
745 tx.merge(storeType, path, entry);
747 tx.put(storeType, path, entry);
749 tx.submit().checkedGet();
750 log.debug("Update DataStore succeeded");
752 } catch (final TransactionCommitFailedException e) {
753 if (e instanceof OptimisticLockFailedException) {
755 log.debug("Got OptimisticLockFailedException on last try - failing ");
756 throw new IllegalStateException(e);
758 log.debug("Got OptimisticLockFailedException - trying again ");
760 log.debug("Update DataStore failed");
761 throw new IllegalStateException(e);
768 private void DeleteVnfList(final VnfList entry, LogicalDatastoreType storeType) throws IllegalStateException {
769 // Each entry will be identifiable by a unique key, we have to create that identifier
770 InstanceIdentifier.InstanceIdentifierBuilder<VnfList> vnfListIdBuilder =
771 InstanceIdentifier.<Vnfs>builder(Vnfs.class).child(VnfList.class, entry.getKey());
772 InstanceIdentifier<VnfList> path = vnfListIdBuilder.build();
774 int optimisticLockTries = 2;
775 boolean tryAgain =true;
779 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
780 tx.delete(storeType, path);
781 tx.submit().checkedGet();
782 log.debug("DataStore delete succeeded");
783 } catch (final TransactionCommitFailedException e) {
784 if (e instanceof OptimisticLockFailedException) {
785 if (--optimisticLockTries <= 0) {
786 log.debug("Got OptimisticLockFailedException on last try - failing ");
787 throw new IllegalStateException(e);
789 log.debug("Got OptimisticLockFailedException - trying again ");
794 if (e.getCause() instanceof ModifiedNodeDoesNotExistException) {
795 log.debug("Ignoring MpdifiedNodeDoesNotExistException");
799 log.debug("Delete DataStore failed");
800 throw new IllegalStateException(e);
806 private void SaveVnfInstanceList(final VnfInstanceList entry, boolean merge, LogicalDatastoreType storeType)
807 throws IllegalStateException {
808 // Each entry will be identifiable by a unique key, we have to create that identifier
809 InstanceIdentifier.InstanceIdentifierBuilder<VnfInstanceList> vnfInstanceListIdBuilder =
810 InstanceIdentifier.<VnfInstances>builder(VnfInstances.class).child(VnfInstanceList.class, entry.getKey());
811 InstanceIdentifier<VnfInstanceList> path = vnfInstanceListIdBuilder.build();
816 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
818 tx.merge(storeType, path, entry);
820 tx.put(storeType, path, entry);
822 tx.submit().checkedGet();
823 log.debug("Update DataStore succeeded");
825 } catch (final TransactionCommitFailedException e) {
826 if (e instanceof OptimisticLockFailedException) {
828 log.debug("Got OptimisticLockFailedException on last try - failing ");
829 throw new IllegalStateException(e);
831 log.debug("Got OptimisticLockFailedException - trying again ");
833 log.debug("Update DataStore failed");
834 throw new IllegalStateException(e);
841 private void SaveVfModuleList(final VfModuleList entry, boolean merge, LogicalDatastoreType storeType)
842 throws IllegalStateException {
843 // Each entry will be identifiable by a unique key, we have to create that identifier
844 InstanceIdentifier.InstanceIdentifierBuilder<VfModuleList> vfModuleListIdBuilder =
845 InstanceIdentifier.<VfModules>builder(VfModules.class).child(VfModuleList.class, entry.getKey());
846 InstanceIdentifier<VfModuleList> path = vfModuleListIdBuilder.build();
851 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
853 tx.merge(storeType, path, entry);
855 tx.put(storeType, path, entry);
857 tx.submit().checkedGet();
858 log.debug("Update DataStore succeeded");
860 } catch (final TransactionCommitFailedException e) {
861 if (e instanceof OptimisticLockFailedException) {
863 log.debug("Got OptimisticLockFailedException on last try - failing ");
864 throw new IllegalStateException(e);
866 log.debug("Got OptimisticLockFailedException - trying again ");
868 log.debug("Update DataStore failed");
869 throw new IllegalStateException(e);
875 private void SavePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType)
876 throws IllegalStateException {
878 // Each entry will be identifiable by a unique key, we have to create that identifier
879 InstanceIdentifier.InstanceIdentifierBuilder<VnfPreloadList> vnfListIdBuilder =
880 InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class).child(VnfPreloadList.class, entry.getKey());
881 InstanceIdentifier<VnfPreloadList> path = vnfListIdBuilder.build();
885 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
887 tx.merge(storeType, path, entry);
889 tx.put(storeType, path, entry);
891 tx.submit().checkedGet();
892 log.debug("Update DataStore succeeded");
894 } catch (final TransactionCommitFailedException e) {
895 if (e instanceof OptimisticLockFailedException) {
897 log.debug("Got OptimisticLockFailedException on last try - failing ");
898 throw new IllegalStateException(e);
900 log.debug("Got OptimisticLockFailedException - trying again ");
902 log.debug("Update DataStore failed");
903 throw new IllegalStateException(e);
909 //1610 preload vnf-instance
910 private void SaveVnfInstancePreloadList(final VnfInstancePreloadList entry, boolean merge,
911 LogicalDatastoreType storeType) throws IllegalStateException {
913 // Each entry will be identifiable by a unique key, we have to create that identifier
914 InstanceIdentifier.InstanceIdentifierBuilder<VnfInstancePreloadList> vnfInstanceListIdBuilder =
915 InstanceIdentifier.<PreloadVnfInstances>builder(PreloadVnfInstances.class)
916 .child(VnfInstancePreloadList.class, entry.getKey());
917 InstanceIdentifier<VnfInstancePreloadList> path = vnfInstanceListIdBuilder.build();
921 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
923 tx.merge(storeType, path, entry);
925 tx.put(storeType, path, entry);
927 tx.submit().checkedGet();
928 log.debug("Update DataStore succeeded");
930 } catch (final TransactionCommitFailedException e) {
931 if (e instanceof OptimisticLockFailedException) {
933 log.debug("Got OptimisticLockFailedException on last try - failing ");
934 throw new IllegalStateException(e);
936 log.debug("Got OptimisticLockFailedException - trying again ");
938 log.debug("Update DataStore failed");
939 throw new IllegalStateException(e);
945 //1610 preload vf-module
946 private void SaveVfModulePreloadList(final VfModulePreloadList entry, boolean merge, LogicalDatastoreType storeType)
947 throws IllegalStateException {
949 // Each entry will be identifiable by a unique key, we have to create that identifier
950 InstanceIdentifier.InstanceIdentifierBuilder<VfModulePreloadList> vfModuleListIdBuilder =
951 InstanceIdentifier.<PreloadVfModules>builder(PreloadVfModules.class)
952 .child(VfModulePreloadList.class, entry.getKey());
953 InstanceIdentifier<VfModulePreloadList> path = vfModuleListIdBuilder.build();
957 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
959 tx.merge(storeType, path, entry);
961 tx.put(storeType, path, entry);
963 tx.submit().checkedGet();
964 log.debug("Update DataStore succeeded");
966 } catch (final TransactionCommitFailedException e) {
967 if (e instanceof OptimisticLockFailedException) {
969 log.debug("Got OptimisticLockFailedException on last try - failing ");
970 throw new IllegalStateException(e);
972 log.debug("Got OptimisticLockFailedException - trying again ");
974 log.debug("Update DataStore failed");
975 throw new IllegalStateException(e);
981 //Save the requestId into MDC
982 private void setRequestIdAsMDC(String requestId) {
983 MDC.put("RequestId", requestId);
986 //1610 vnf-instance-topology-operation
987 @Override public Future<RpcResult<VnfInstanceTopologyOperationOutput>> vnfInstanceTopologyOperation(
988 VnfInstanceTopologyOperationInput input) {
990 final String SVC_OPERATION = "vnf-instance-topology-operation";
991 VnfInstanceServiceData vnfInstanceServiceData = null;
992 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
993 Properties parms = new Properties();
995 log.info(SVC_OPERATION + " called.");
996 // create a new response object
997 VnfInstanceTopologyOperationOutputBuilder responseBuilder = new VnfInstanceTopologyOperationOutputBuilder();
999 //if(input == null || input.getVnfInstanceRequestInformation().getVnfInstanceTopologyIdentifier().getVnfInstanceId() == null )
1000 if (input == null || input.getVnfInstanceRequestInformation() == null
1001 || input.getVnfInstanceRequestInformation().getVnfInstanceId() == null) {
1002 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vnf-instance-id");
1003 responseBuilder.setResponseCode("403");
1004 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1005 responseBuilder.setAckFinalIndicator("Y");
1006 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1007 RpcResultBuilder.<VnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1010 return Futures.immediateFuture(rpcResult);
1013 // Grab the service instance ID from the input buffer
1014 String viid = input.getVnfInstanceRequestInformation().getVnfInstanceId();
1015 String preload_name = input.getVnfInstanceRequestInformation().getVnfInstanceName();
1016 String preload_type = input.getVnfInstanceRequestInformation().getVnfModelId();
1018 // Make sure we have a valid viid
1019 if (viid == null || viid.length() == 0) {
1020 log.debug("exiting " + SVC_OPERATION + " because of invalid vnf-instance-id");
1021 responseBuilder.setResponseCode("403");
1022 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1023 responseBuilder.setAckFinalIndicator("Y");
1024 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1025 RpcResultBuilder.<VnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1028 return Futures.immediateFuture(rpcResult);
1031 if (input.getSdncRequestHeader() != null) {
1032 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1033 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1036 // Get vnf-instance-preload-data
1037 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
1038 getVnfInstancePreloadData(preload_name, preload_type, vnfInstancePreloadDataBuilder);
1041 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1042 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1044 // Get operational-data
1045 VnfInstanceServiceDataBuilder operDataBuilder = new VnfInstanceServiceDataBuilder();
1046 getVnfInstanceServiceData(viid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1048 // Set the serviceStatus based on input
1049 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1050 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1053 // setup a service-data object builder
1054 // ACTION vnf-topology-operation
1056 // USES sdnc-request-header;
1057 // USES request-information;
1058 // USES service-information;
1059 // USES vnf-request-information
1061 // USES vnf-topology-response-body;
1062 // USES vnf-information
1063 // USES service-information
1065 // container service-data
1066 // uses vnf-configuration-information;
1067 // uses oper-status;
1069 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + viid + "] input: " + input);
1070 VnfInstanceTopologyOperationInputBuilder inputBuilder = new VnfInstanceTopologyOperationInputBuilder(input);
1071 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1073 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + viid + "] operational-data: " + operDataBuilder
1075 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1078 "Adding CONFIG data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preload-data: "
1079 + vnfInstancePreloadDataBuilder.build());
1080 VnfSdnUtil.toProperties(parms, "vnf-instance-preload-data", vnfInstancePreloadDataBuilder);
1082 // Call SLI sync method
1083 // Get SvcLogicService reference
1084 Properties respProps = null;
1085 String errorCode = "200";
1086 String errorMessage = null;
1087 String ackFinal = "Y";
1090 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1093 respProps = svcLogicClient
1094 .execute("VNF-API", SVC_OPERATION, null, "sync", vnfInstanceServiceDataBuilder, parms);
1095 } catch (Exception e) {
1096 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1097 errorMessage = e.getMessage();
1101 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1104 } catch (Exception e) {
1106 errorMessage = e.getMessage();
1107 log.error("Caught exception looking for service logic", e);
1110 if (respProps != null) {
1111 errorCode = respProps.getProperty("error-code");
1112 errorMessage = respProps.getProperty("error-message");
1113 ackFinal = respProps.getProperty("ack-final", "Y");
1116 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1117 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1118 serviceStatusBuilder.setRpcName(RpcName.VnfInstanceTopologyOperation);
1120 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1121 responseBuilder.setResponseCode(errorCode);
1122 responseBuilder.setResponseMessage(errorMessage);
1123 responseBuilder.setAckFinalIndicator(ackFinal);
1124 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1125 vnfInstanceListBuilder.setVnfInstanceId(viid);
1126 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1128 SaveVnfInstanceList(vnfInstanceListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1129 } catch (Exception e) {
1130 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + viid + "] \n", e);
1132 log.error("Returned FAILED for " + SVC_OPERATION + " [" + viid + "] " + responseBuilder.build());
1133 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1134 RpcResultBuilder.<VnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1137 return Futures.immediateFuture(rpcResult);
1140 // Got success from SLI
1142 vnfInstanceServiceData = vnfInstanceServiceDataBuilder.build();
1143 log.info("Updating MD-SAL for " + SVC_OPERATION + " [" + viid + "] VnfInstanceServiceData: "
1144 + vnfInstanceServiceData);
1145 // svc-configuration-list
1146 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1147 vnfInstanceListBuilder.setVnfInstanceServiceData(vnfInstanceServiceData);
1148 vnfInstanceListBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
1149 //siid = vnfInstanceServiceData.getVnfInstanceId();
1150 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1151 SaveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1152 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1153 // Only update operational tree on Delete or Activate
1154 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1155 .getSvcAction().equals(SvcAction.Activate)) {
1156 log.info("Updating OPERATIONAL tree.");
1157 SaveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1160 VnfInstanceInformationBuilder vnfInstanceInformationBuilder = new VnfInstanceInformationBuilder();
1161 vnfInstanceInformationBuilder.setVnfInstanceId(viid);
1162 responseBuilder.setVnfInstanceInformation(vnfInstanceInformationBuilder.build());
1163 responseBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
1164 } catch (Exception e) {
1165 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + viid + "] \n", e);
1166 responseBuilder.setResponseCode("500");
1167 responseBuilder.setResponseMessage(e.toString());
1168 responseBuilder.setAckFinalIndicator("Y");
1169 log.error("Returned FAILED for " + SVC_OPERATION + " [" + viid + "] " + responseBuilder.build());
1170 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1171 RpcResultBuilder.<VnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1174 return Futures.immediateFuture(rpcResult);
1178 responseBuilder.setResponseCode(errorCode);
1179 responseBuilder.setAckFinalIndicator(ackFinal);
1180 if (errorMessage != null) {
1181 responseBuilder.setResponseMessage(errorMessage);
1183 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + viid + "] ");
1184 log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + viid + "] " + responseBuilder.build());
1186 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1187 RpcResultBuilder.<VnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1190 return Futures.immediateFuture(rpcResult);
1193 //1610 vf-module-topology-operation
1194 @Override public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1195 VfModuleTopologyOperationInput input) {
1197 final String SVC_OPERATION = "vf-module-topology-operation";
1198 VfModuleServiceData vfModuleServiceData = null;
1199 VnfInstanceServiceData vnfInstanceServiceData = null;
1200 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1201 Properties parms = new Properties();
1203 log.info(SVC_OPERATION + " called.");
1204 // create a new response object
1205 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1207 // Validate vf-module-id from vf-module-request-information
1208 if (input == null || input.getVfModuleRequestInformation() == null
1209 || input.getVfModuleRequestInformation().getVfModuleId() == null) {
1210 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vf-module-id");
1211 responseBuilder.setResponseCode("403");
1212 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1213 responseBuilder.setAckFinalIndicator("Y");
1214 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1215 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1218 return Futures.immediateFuture(rpcResult);
1221 // Grab the vf-module-request-information.vf-module-id from the input buffer
1222 String vfid = input.getVfModuleRequestInformation().getVfModuleId();
1223 String preload_name = input.getVfModuleRequestInformation().getVfModuleName();
1224 String preload_type = input.getVfModuleRequestInformation().getVfModuleModelId();
1226 // Make sure we have a valid siid
1227 if (vfid == null || vfid.length() == 0) {
1228 log.debug("exiting " + SVC_OPERATION + " because of invalid vf-module-id");
1229 responseBuilder.setResponseCode("403");
1230 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1231 responseBuilder.setAckFinalIndicator("Y");
1232 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1233 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1236 return Futures.immediateFuture(rpcResult);
1239 // 1610 add vf-module-id to vnf-instance-list.vf-module-relationship-list
1240 String viid = input.getVfModuleRequestInformation().getVnfInstanceId();
1242 if (viid == null || viid.length() == 0) {
1243 log.debug("exiting " + SVC_OPERATION + " because of invalid vnf-instance-id");
1244 responseBuilder.setResponseCode("403");
1245 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1246 responseBuilder.setAckFinalIndicator("Y");
1247 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1248 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1251 return Futures.immediateFuture(rpcResult);
1254 if (input.getSdncRequestHeader() != null) {
1255 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1256 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1259 // Get vf-module-preload-data
1260 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
1261 getVfModulePreloadData(preload_name, preload_type, vfModulePreloadDataBuilder);
1263 // Get vf-module-service-data
1264 VfModuleServiceDataBuilder vfModuleServiceDataBuilder = new VfModuleServiceDataBuilder();
1265 getVfModuleServiceData(vfid, vfModuleServiceDataBuilder);
1267 // Get vf-module operation-data
1268 VfModuleServiceDataBuilder operDataBuilder = new VfModuleServiceDataBuilder();
1269 getVfModuleServiceData(vfid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1271 // save service-data builder object for rollback
1272 VfModuleServiceDataBuilder rb_vfModuleServiceDataBuilder = vfModuleServiceDataBuilder;
1273 VfModuleServiceDataBuilder rb_operDataBuilder = operDataBuilder;
1275 // 1610 Need to pull vnf-instance-list.vf-module-relationship-list from MD-SAL
1276 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1277 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1279 // vnf-instance operational-data
1280 VnfInstanceServiceDataBuilder vnfInstanceOperDataBuilder = new VnfInstanceServiceDataBuilder();
1281 getVnfInstanceServiceData(viid, vnfInstanceOperDataBuilder, LogicalDatastoreType.OPERATIONAL);
1283 // save operational builder object for rollback
1284 VnfInstanceServiceDataBuilder rb_vnfInstanceServiceDataBuilder = vnfInstanceServiceDataBuilder;
1285 VnfInstanceServiceDataBuilder rb_vnfInstanceOperDataBuilder = vnfInstanceOperDataBuilder;
1287 // Set the serviceStatus based on input
1288 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1289 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1292 // setup a service-data object builder
1293 // ACTION vnf-topology-operation
1295 // USES sdnc-request-header;
1296 // USES request-information;
1297 // USES service-information;
1298 // USES vnf-request-information
1300 // USES vnf-topology-response-body;
1301 // USES vnf-information
1302 // USES service-information
1304 // container service-data
1305 // uses vnf-configuration-information;
1306 // uses oper-status;
1308 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + vfid + "] input: " + input);
1309 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1310 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1312 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + vfid + "] vf-module operational-data: "
1313 + operDataBuilder.build());
1314 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1316 log.info("Adding CONFIG data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1317 + "] vf-module-preload-data: " + vfModulePreloadDataBuilder.build());
1318 VnfSdnUtil.toProperties(parms, "vf-module-preload-data", vfModulePreloadDataBuilder);
1320 log.info("Adding vnf-instance CONFIG data for " + SVC_OPERATION + " [" + viid + "] vnf-instance-service-data: "
1321 + vnfInstanceServiceDataBuilder.build());
1322 VnfSdnUtil.toProperties(parms, "vnf-instance-service-data", vnfInstanceServiceDataBuilder);
1324 log.info("Adding vnf-instance OPERATIONAL data for " + SVC_OPERATION + " [" + viid
1325 + "] vnf-instance operational-data: " + vnfInstanceOperDataBuilder.build());
1326 VnfSdnUtil.toProperties(parms, "vnf-instance-operational-data", vnfInstanceOperDataBuilder);
1328 // Call SLI sync method
1329 // Get SvcLogicService reference
1331 Properties respProps = null;
1332 String errorCode = "200";
1333 String errorMessage = null;
1334 String ackFinal = "Y";
1337 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1340 respProps = svcLogicClient
1341 .execute("VNF-API", SVC_OPERATION, null, "sync", vfModuleServiceDataBuilder, parms);
1342 } catch (Exception e) {
1343 log.error("Caught exception executing service logic on vf-module for " + SVC_OPERATION, e);
1344 errorMessage = e.getMessage();
1349 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1352 } catch (Exception e) {
1354 errorMessage = e.getMessage();
1355 log.error("Caught exception looking for service logic", e);
1359 if (respProps != null) {
1360 errorCode = respProps.getProperty("error-code");
1361 errorMessage = respProps.getProperty("error-message");
1362 ackFinal = respProps.getProperty("ack-final", "Y");
1365 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1366 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1367 serviceStatusBuilder.setRpcName(RpcName.VfModuleTopologyOperation);
1369 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1370 responseBuilder.setResponseCode(errorCode);
1371 responseBuilder.setResponseMessage(errorMessage);
1372 responseBuilder.setAckFinalIndicator(ackFinal);
1373 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1374 vfModuleListBuilder.setVfModuleId(vfid);
1375 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1377 SaveVfModuleList(vfModuleListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1378 } catch (Exception e) {
1379 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + vfid + "] \n", e);
1381 log.error("Returned FAILED for " + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1382 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1383 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1386 return Futures.immediateFuture(rpcResult);
1389 // Got success from SLI
1390 // save vf-module-service-data in MD-SAL
1392 vfModuleServiceData = vfModuleServiceDataBuilder.build();
1394 "Updating MD-SAL for " + SVC_OPERATION + " [" + vfid + "] VfModuleServiceData: " + vfModuleServiceData);
1396 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1397 vfModuleListBuilder.setVfModuleServiceData(vfModuleServiceData);
1398 vfModuleListBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
1399 //vfid = vfModuleServiceData.getVfModuleId();
1400 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1401 SaveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1402 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1403 // Only update operational tree on Delete or Activate
1404 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1405 .getSvcAction().equals(SvcAction.Activate)) {
1406 log.info("Updating OPERATIONAL tree.");
1407 SaveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1410 VfModuleInformationBuilder vfModuleInformationBuilder = new VfModuleInformationBuilder();
1411 vfModuleInformationBuilder.setVfModuleId(vfid);
1412 responseBuilder.setVfModuleInformation(vfModuleInformationBuilder.build());
1413 responseBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
1414 } catch (Exception e) {
1415 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + vfid + "] \n", e);
1416 responseBuilder.setResponseCode("500");
1417 responseBuilder.setResponseMessage(e.toString());
1418 responseBuilder.setAckFinalIndicator("Y");
1419 log.error("Returned FAILED for " + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1420 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1421 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1424 return Futures.immediateFuture(rpcResult);
1428 responseBuilder.setResponseCode(errorCode);
1429 responseBuilder.setAckFinalIndicator(ackFinal);
1430 if (errorMessage != null) {
1431 responseBuilder.setResponseMessage(errorMessage);
1433 log.info("Updated vf-module in MD-SAL for " + SVC_OPERATION + " [" + vfid + "] ");
1434 log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1436 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1437 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1439 return Futures.immediateFuture(rpcResult);
1444 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
1445 final String SVC_OPERATION = "vnf-topology-operation";
1446 ServiceData serviceData = null;
1447 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1448 Properties parms = new Properties();
1450 log.info(SVC_OPERATION + " called.");
1451 // create a new response object
1452 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1454 if (input == null || input.getServiceInformation() == null
1455 || input.getServiceInformation().getServiceInstanceId() == null
1456 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1457 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1458 responseBuilder.setResponseCode("403");
1459 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1460 responseBuilder.setAckFinalIndicator("Y");
1461 RpcResult<VnfTopologyOperationOutput> rpcResult =
1462 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1464 return Futures.immediateFuture(rpcResult);
1467 if (input.getVnfRequestInformation() == null || input.getVnfRequestInformation().getVnfId() == null
1468 || input.getVnfRequestInformation().getVnfId().length() == 0) {
1469 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vf-module-id");
1470 responseBuilder.setResponseCode("403");
1471 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1472 responseBuilder.setAckFinalIndicator("Y");
1473 RpcResult<VnfTopologyOperationOutput> rpcResult =
1474 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1476 return Futures.immediateFuture(rpcResult);
1479 // Grab the service instance ID from the input buffer
1480 String siid = input.getVnfRequestInformation().getVnfId();
1481 String preload_name = input.getVnfRequestInformation().getVnfName();
1482 String preload_type = input.getVnfRequestInformation().getVnfType();
1484 if (input.getSdncRequestHeader() != null) {
1485 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1486 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1489 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1490 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1492 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1493 getServiceData(siid, serviceDataBuilder);
1495 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1496 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1498 // Set the serviceStatus based on input
1499 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1500 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1503 // setup a service-data object builder
1504 // ACTION vnf-topology-operation
1506 // USES sdnc-request-header;
1507 // USES request-information;
1508 // USES service-information;
1509 // USES vnf-request-information
1511 // USES vnf-topology-response-body;
1512 // USES vnf-information
1513 // USES service-information
1515 // container service-data
1516 // uses vnf-configuration-information;
1517 // uses oper-status;
1519 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + siid + "] input: " + input);
1520 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1521 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1523 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + siid + "] operational-data: " + operDataBuilder
1525 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1528 "Adding CONFIG data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preload-data: "
1529 + preloadDataBuilder.build());
1530 VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1532 // Call SLI sync method
1533 // Get SvcLogicService reference
1534 Properties respProps = null;
1535 String errorCode = "200";
1536 String errorMessage = null;
1537 String ackFinal = "Y";
1540 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1544 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1545 } catch (Exception e) {
1546 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1547 errorMessage = e.getMessage();
1551 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1554 } catch (Exception e) {
1556 errorMessage = e.getMessage();
1557 log.error("Caught exception looking for service logic", e);
1560 if (respProps != null) {
1561 errorCode = respProps.getProperty("error-code");
1562 errorMessage = respProps.getProperty("error-message");
1563 ackFinal = respProps.getProperty("ack-final", "Y");
1566 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1567 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1568 serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
1570 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1571 responseBuilder.setResponseCode(errorCode);
1572 responseBuilder.setResponseMessage(errorMessage);
1573 responseBuilder.setAckFinalIndicator(ackFinal);
1574 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1575 vnfListBuilder.setVnfId(siid);
1576 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1578 SaveVnfList(vnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1579 } catch (Exception e) {
1580 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1582 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1583 RpcResult<VnfTopologyOperationOutput> rpcResult =
1584 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1586 return Futures.immediateFuture(rpcResult);
1589 // Got success from SLI
1591 serviceData = serviceDataBuilder.build();
1592 log.info("Updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] ServiceData: " + serviceData);
1593 // svc-configuration-list
1594 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1595 vnfListBuilder.setServiceData(serviceData);
1596 vnfListBuilder.setVnfId(serviceData.getVnfId());
1597 siid = serviceData.getVnfId();
1598 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1599 SaveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1600 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1601 // Only update operational tree on Delete or Activate
1602 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1603 log.info("Updating OPERATIONAL tree.");
1604 SaveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1605 } else if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input
1606 .getSdncRequestHeader().getSvcAction().equals(SvcAction.Rollback)) {
1607 log.info("Delete OPERATIONAL tree.");
1608 DeleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
1609 DeleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
1612 VnfInformationBuilder vnfInformationBuilder = new VnfInformationBuilder();
1613 vnfInformationBuilder.setVnfId(siid);
1614 responseBuilder.setVnfInformation(vnfInformationBuilder.build());
1615 responseBuilder.setServiceInformation(serviceData.getServiceInformation());
1616 } catch (Exception e) {
1617 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1618 responseBuilder.setResponseCode("500");
1619 responseBuilder.setResponseMessage(e.toString());
1620 responseBuilder.setAckFinalIndicator("Y");
1621 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1622 RpcResult<VnfTopologyOperationOutput> rpcResult =
1623 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1625 return Futures.immediateFuture(rpcResult);
1629 responseBuilder.setResponseCode(errorCode);
1630 responseBuilder.setAckFinalIndicator(ackFinal);
1631 if (errorMessage != null) {
1632 responseBuilder.setResponseMessage(errorMessage);
1634 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + siid + "] ");
1635 log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1637 RpcResult<VnfTopologyOperationOutput> rpcResult =
1638 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1640 return Futures.immediateFuture(rpcResult);
1643 @Override public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1644 NetworkTopologyOperationInput input) {
1646 final String SVC_OPERATION = "network-topology-operation";
1647 ServiceData serviceData = null;
1648 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1649 Properties parms = new Properties();
1651 log.info(SVC_OPERATION + " called.");
1652 // create a new response object
1653 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1655 if (input == null || input.getServiceInformation() == null
1656 || input.getServiceInformation().getServiceInstanceId() == null
1657 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1658 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1659 responseBuilder.setResponseCode("403");
1660 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1661 responseBuilder.setAckFinalIndicator("Y");
1662 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1663 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1666 return Futures.immediateFuture(rpcResult);
1669 if (input.getNetworkRequestInformation() == null
1670 || input.getNetworkRequestInformation().getNetworkName() == null) {
1671 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1672 responseBuilder.setResponseCode("403");
1673 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1674 responseBuilder.setAckFinalIndicator("Y");
1675 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1676 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1679 return Futures.immediateFuture(rpcResult);
1682 // Grab the service instance ID from the input buffer
1684 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Assign)) {
1685 siid = input.getNetworkRequestInformation().getNetworkName();
1687 siid = input.getNetworkRequestInformation().getNetworkId();
1689 String preload_name = input.getNetworkRequestInformation().getNetworkName();
1690 String preload_type = input.getNetworkRequestInformation().getNetworkType();
1692 if (input.getSdncRequestHeader() != null) {
1693 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1694 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1697 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1698 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1700 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + siid + "] input: " + input);
1701 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1702 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1704 // Call SLI sync method
1705 // Get SvcLogicService reference
1706 Properties respProps = null;
1707 String errorCode = "200";
1708 String errorMessage = null;
1709 String ackFinal = "Y";
1710 String networkId = "error";
1713 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1717 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1718 } catch (Exception e) {
1719 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1720 errorMessage = e.getMessage();
1724 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1727 } catch (Exception e) {
1729 errorMessage = e.getMessage();
1730 log.error("Caught exception looking for service logic", e);
1733 if (respProps != null) {
1734 errorCode = respProps.getProperty("error-code");
1735 errorMessage = respProps.getProperty("error-message");
1736 ackFinal = respProps.getProperty("ack-final", "Y");
1737 networkId = respProps.getProperty("networkId", "0");
1740 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1741 responseBuilder.setResponseCode(errorCode);
1742 responseBuilder.setResponseMessage(errorMessage);
1743 responseBuilder.setAckFinalIndicator(ackFinal);
1745 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1747 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1748 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1751 return Futures.immediateFuture(rpcResult);
1754 // Got success from SLI
1756 NetworkInformationBuilder networkInformationBuilder = new NetworkInformationBuilder();
1757 networkInformationBuilder.setNetworkId(networkId);
1758 responseBuilder.setNetworkInformation(networkInformationBuilder.build());
1759 responseBuilder.setServiceInformation(input.getServiceInformation());
1760 } catch (IllegalStateException e) {
1761 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1762 responseBuilder.setResponseCode("500");
1763 responseBuilder.setResponseMessage(e.toString());
1764 responseBuilder.setAckFinalIndicator("Y");
1765 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1766 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1767 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1770 return Futures.immediateFuture(rpcResult);
1774 responseBuilder.setResponseCode(errorCode);
1775 responseBuilder.setAckFinalIndicator(ackFinal);
1776 if (errorMessage != null) {
1777 responseBuilder.setResponseMessage(errorMessage);
1779 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + siid + "] ");
1780 log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1782 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1783 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1785 return Futures.immediateFuture(rpcResult);
1788 @Override public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1789 PreloadVnfTopologyOperationInput input) {
1791 final String SVC_OPERATION = "preload-vnf-topology-operation";
1792 PreloadData preloadData = null;
1793 Properties parms = new Properties();
1795 log.info(SVC_OPERATION + " called.");
1796 // create a new response object
1797 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1799 // Result from savePreloadData
1800 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1802 if (input == null || input.getVnfTopologyInformation() == null
1803 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null
1804 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName() == null
1805 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType() == null) {
1806 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vnf-name or vnf-type");
1807 responseBuilder.setResponseCode("403");
1808 responseBuilder.setResponseMessage("invalid input, null or empty vnf-name or vnf-type");
1809 responseBuilder.setAckFinalIndicator("Y");
1810 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1811 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1813 return Futures.immediateFuture(rpcResult);
1816 // Grab the name and type from the input buffer
1817 String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1818 String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1820 // Make sure we have a preload_name and preload_type
1821 if (preload_name == null || preload_name.length() == 0) {
1822 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
1823 responseBuilder.setResponseCode("403");
1824 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1825 responseBuilder.setAckFinalIndicator("Y");
1826 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1827 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1829 return Futures.immediateFuture(rpcResult);
1831 if (preload_type == null || preload_type.length() == 0) {
1832 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
1833 responseBuilder.setResponseCode("403");
1834 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1835 responseBuilder.setAckFinalIndicator("Y");
1836 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1837 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1839 return Futures.immediateFuture(rpcResult);
1842 if (input.getSdncRequestHeader() != null) {
1843 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1844 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1847 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1848 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1849 //preloadData = preloadDataBuilder.build();
1851 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1852 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1855 // setup a preload-data object builder
1856 // ACTION vnf-topology-operation
1858 // USES sdnc-request-header;
1859 // USES request-information;
1860 // uses vnf-topology-information;
1862 // USES vnf-topology-response-body;
1864 // container preload-data
1865 // uses vnf-configuration-information;
1867 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
1868 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1869 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1870 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1871 + "] operational-data: " + operDataBuilder.build());
1872 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1874 // Call SLI sync method
1875 // Get SvcLogicService reference
1876 Properties respProps = null;
1877 String errorCode = "200";
1878 String errorMessage = null;
1879 String ackFinal = "Y";
1882 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1886 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1887 } catch (Exception e) {
1888 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1889 errorMessage = e.getMessage();
1893 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1896 } catch (Exception e) {
1898 errorMessage = e.getMessage();
1899 log.error("Caught exception looking for service logic", e);
1902 if (respProps != null) {
1903 errorCode = respProps.getProperty("error-code");
1904 errorMessage = respProps.getProperty("error-message");
1905 ackFinal = respProps.getProperty("ack-final", "Y");
1906 // internalError = respProps.getProperty("internal-error", "false");
1909 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1911 responseBuilder.setResponseCode(errorCode);
1912 responseBuilder.setResponseMessage(errorMessage);
1913 responseBuilder.setAckFinalIndicator(ackFinal);
1915 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1916 preloadVnfListBuilder.setVnfName(preload_name);
1917 preloadVnfListBuilder.setVnfType(preload_type);
1918 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1920 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
1921 + errorCode + "', Reason: '" + errorMessage + "'");
1923 SavePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1924 } catch (Exception e) {
1926 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1929 log.debug("Sending Success rpc result due to external error");
1930 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1931 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1933 return Futures.immediateFuture(rpcResult);
1936 // Got success from SLI
1938 preloadData = preloadDataBuilder.build();
1940 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
1942 // svc-configuration-list
1943 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1944 preloadVnfListBuilder.setVnfName(preload_name);
1945 preloadVnfListBuilder.setVnfType(preload_type);
1946 preloadVnfListBuilder.setPreloadData(preloadData);
1948 // SDNGC-989 set merge flag to false
1949 SavePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1950 log.info("Updating OPERATIONAL tree.");
1951 SavePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1952 } catch (Exception e) {
1953 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1955 responseBuilder.setResponseCode("500");
1956 responseBuilder.setResponseMessage(e.toString());
1957 responseBuilder.setAckFinalIndicator("Y");
1958 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
1959 + responseBuilder.build());
1960 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1961 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(false).withResult(responseBuilder.build())
1963 return Futures.immediateFuture(rpcResult);
1967 responseBuilder.setResponseCode(errorCode);
1968 responseBuilder.setAckFinalIndicator(ackFinal);
1969 if (errorMessage != null) {
1970 responseBuilder.setResponseMessage(errorMessage);
1972 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
1974 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
1977 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1978 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1980 return Futures.immediateFuture(rpcResult);
1983 //1610 preload-vnf-instance-topology-operation
1984 @Override public Future<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> preloadVnfInstanceTopologyOperation(
1985 PreloadVnfInstanceTopologyOperationInput input) {
1987 final String SVC_OPERATION = "preload-vnf-instance-topology-operation";
1988 VnfInstancePreloadData vnfInstancePreloadData = null;
1989 Properties parms = new Properties();
1991 log.info(SVC_OPERATION + " called.");
1992 // create a new response object
1993 PreloadVnfInstanceTopologyOperationOutputBuilder responseBuilder =
1994 new PreloadVnfInstanceTopologyOperationOutputBuilder();
1996 // Result from savePreloadData
1997 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1999 if (input == null || input.getVnfInstanceTopologyInformation() == null
2000 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName() == null
2001 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId() == null) {
2002 log.debug("exiting " + SVC_OPERATION
2003 + " because of invalid input, null or empty vnf-instance-name or vnf-model-id");
2004 responseBuilder.setResponseCode("403");
2005 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name or vnf-model-id");
2006 responseBuilder.setAckFinalIndicator("Y");
2007 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2008 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2009 .withResult(responseBuilder.build()).build();
2010 return Futures.immediateFuture(rpcResult);
2013 // Grab the name and type from the input buffer
2014 String preload_name =
2015 input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName();
2016 String preload_type = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId();
2018 // Make sure we have a preload_name and preload_type
2019 if (preload_name == null || preload_name.length() == 0) {
2020 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
2021 responseBuilder.setResponseCode("403");
2022 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2023 responseBuilder.setAckFinalIndicator("Y");
2024 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2025 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2026 .withResult(responseBuilder.build()).build();
2027 return Futures.immediateFuture(rpcResult);
2029 if (preload_type == null || preload_type.length() == 0) {
2030 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
2031 responseBuilder.setResponseCode("403");
2032 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2033 responseBuilder.setAckFinalIndicator("Y");
2034 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2035 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2036 .withResult(responseBuilder.build()).build();
2037 return Futures.immediateFuture(rpcResult);
2040 if (input.getSdncRequestHeader() != null) {
2041 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2042 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2045 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
2046 getVnfInstancePreloadData(preload_name, preload_type, vnfInstancePreloadDataBuilder);
2047 //preloadData = preloadDataBuilder.build();
2049 VnfInstancePreloadDataBuilder operDataBuilder = new VnfInstancePreloadDataBuilder();
2050 getVnfInstancePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2053 // setup a preload-data object builder
2054 // ACTION vnf-topology-operation
2056 // USES sdnc-request-header;
2057 // USES request-information;
2058 // uses vnf-topology-information;
2060 // USES vnf-topology-response-body;
2062 // container preload-data
2063 // uses vnf-configuration-information;
2065 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2066 PreloadVnfInstanceTopologyOperationInputBuilder inputBuilder =
2067 new PreloadVnfInstanceTopologyOperationInputBuilder(input);
2068 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2069 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2070 + "] operational-data: " + operDataBuilder.build());
2071 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2073 // Call SLI sync method
2074 // Get SvcLogicService reference
2075 Properties respProps = null;
2076 String errorCode = "200";
2077 String errorMessage = null;
2078 String ackFinal = "Y";
2081 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2084 respProps = svcLogicClient
2085 .execute("VNF-API", SVC_OPERATION, null, "sync", vnfInstancePreloadDataBuilder, parms);
2086 } catch (Exception e) {
2087 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2088 errorMessage = e.getMessage();
2092 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2095 } catch (Exception e) {
2097 errorMessage = e.getMessage();
2098 log.error("Caught exception looking for service logic", e);
2101 if (respProps != null) {
2102 errorCode = respProps.getProperty("error-code");
2103 errorMessage = respProps.getProperty("error-message");
2104 ackFinal = respProps.getProperty("ack-final", "Y");
2105 // internalError = respProps.getProperty("internal-error", "false");
2108 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2110 responseBuilder.setResponseCode(errorCode);
2111 responseBuilder.setResponseMessage(errorMessage);
2112 responseBuilder.setAckFinalIndicator(ackFinal);
2114 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2115 vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2116 vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2117 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadDataBuilder.build());
2119 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2120 + errorCode + "', Reason: '" + errorMessage + "'");
2122 SaveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), true,
2123 LogicalDatastoreType.CONFIGURATION);
2124 } catch (Exception e) {
2126 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2129 log.debug("Sending Success rpc result due to external error");
2130 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2131 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2132 .withResult(responseBuilder.build()).build();
2133 return Futures.immediateFuture(rpcResult);
2136 // Got success from SLI
2138 vnfInstancePreloadData = vnfInstancePreloadDataBuilder.build();
2140 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2141 + vnfInstancePreloadData);
2142 // svc-configuration-list
2143 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2144 vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2145 vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2146 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadData);
2148 // SDNGC-989 set merge flag to false
2149 SaveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false,
2150 LogicalDatastoreType.CONFIGURATION);
2151 log.info("Updating OPERATIONAL tree.");
2152 SaveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2153 } catch (Exception e) {
2154 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2156 responseBuilder.setResponseCode("500");
2157 responseBuilder.setResponseMessage(e.toString());
2158 responseBuilder.setAckFinalIndicator("Y");
2159 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2160 + responseBuilder.build());
2161 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2162 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(false)
2163 .withResult(responseBuilder.build()).build();
2164 return Futures.immediateFuture(rpcResult);
2168 responseBuilder.setResponseCode(errorCode);
2169 responseBuilder.setAckFinalIndicator(ackFinal);
2170 if (errorMessage != null) {
2171 responseBuilder.setResponseMessage(errorMessage);
2173 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2175 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2178 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2179 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2181 return Futures.immediateFuture(rpcResult);
2185 //1610 preload-vf-module-topology-operation
2186 @Override public Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2187 PreloadVfModuleTopologyOperationInput input) {
2189 final String SVC_OPERATION = "preload-vf-module-topology-operation";
2190 VfModulePreloadData vfModulePreloadData = null;
2191 Properties parms = new Properties();
2193 log.info(SVC_OPERATION + " called.");
2194 // create a new response object
2195 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder =
2196 new PreloadVfModuleTopologyOperationOutputBuilder();
2198 // Result from savePreloadData
2199 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2201 if (input == null || input.getVfModuleTopologyInformation() == null
2202 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName() == null
2203 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId() == null) {
2204 log.debug("exiting " + SVC_OPERATION
2205 + " because of invalid input, null or empty vf-module-name or vf-module-model-id");
2206 responseBuilder.setResponseCode("403");
2207 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-name or vf-module-model-id");
2208 responseBuilder.setAckFinalIndicator("Y");
2209 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2210 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2211 .withResult(responseBuilder.build()).build();
2212 return Futures.immediateFuture(rpcResult);
2215 // Grab the name and type from the input buffer
2216 String preload_name = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName();
2217 String preload_type = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId();
2219 // Make sure we have a preload_name and preload_type
2220 if (preload_name == null || preload_name.length() == 0) {
2221 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
2222 responseBuilder.setResponseCode("403");
2223 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2224 responseBuilder.setAckFinalIndicator("Y");
2225 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2226 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2227 .withResult(responseBuilder.build()).build();
2228 return Futures.immediateFuture(rpcResult);
2230 if (preload_type == null || preload_type.length() == 0) {
2231 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
2232 responseBuilder.setResponseCode("403");
2233 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2234 responseBuilder.setAckFinalIndicator("Y");
2235 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2236 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2237 .withResult(responseBuilder.build()).build();
2238 return Futures.immediateFuture(rpcResult);
2241 if (input.getSdncRequestHeader() != null) {
2242 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2243 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2246 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
2247 getVfModulePreloadData(preload_name, preload_type, vfModulePreloadDataBuilder);
2248 //preloadData = preloadDataBuilder.build();
2250 VfModulePreloadDataBuilder operDataBuilder = new VfModulePreloadDataBuilder();
2251 getVfModulePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2254 // setup a preload-data object builder
2255 // ACTION vnf-topology-operation
2257 // USES sdnc-request-header;
2258 // USES request-information;
2259 // uses vnf-topology-information;
2261 // USES vnf-topology-response-body;
2263 // container preload-data
2264 // uses vnf-configuration-information;
2267 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2268 PreloadVfModuleTopologyOperationInputBuilder inputBuilder =
2269 new PreloadVfModuleTopologyOperationInputBuilder(input);
2270 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2271 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2272 + "] operational-data: " + operDataBuilder.build());
2273 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2275 // Call SLI sync method
2276 // Get SvcLogicService reference
2277 Properties respProps = null;
2278 String errorCode = "200";
2279 String errorMessage = null;
2280 String ackFinal = "Y";
2283 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2285 respProps = svcLogicClient
2286 .execute("VNF-API", SVC_OPERATION, null, "sync", vfModulePreloadDataBuilder, parms);
2287 } catch (Exception e) {
2288 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2289 errorMessage = e.getMessage();
2293 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2296 } catch (Exception e) {
2298 errorMessage = e.getMessage();
2299 log.error("Caught exception looking for service logic", e);
2302 if (respProps != null) {
2303 errorCode = respProps.getProperty("error-code");
2304 errorMessage = respProps.getProperty("error-message");
2305 ackFinal = respProps.getProperty("ack-final", "Y");
2306 // internalError = respProps.getProperty("internal-error", "false");
2309 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2311 responseBuilder.setResponseCode(errorCode);
2312 responseBuilder.setResponseMessage(errorMessage);
2313 responseBuilder.setAckFinalIndicator(ackFinal);
2315 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2316 vfModulePreloadListBuilder.setVfModuleName(preload_name);
2317 vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2318 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadDataBuilder.build());
2320 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2321 + errorCode + "', Reason: '" + errorMessage + "'");
2323 SaveVfModulePreloadList(vfModulePreloadListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2324 } catch (Exception e) {
2326 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2329 log.debug("Sending Success rpc result due to external error");
2330 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2331 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2332 .withResult(responseBuilder.build()).build();
2333 return Futures.immediateFuture(rpcResult);
2336 // Got success from SLI
2338 vfModulePreloadData = vfModulePreloadDataBuilder.build();
2340 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2341 + vfModulePreloadData);
2342 // svc-configuration-list
2343 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2344 vfModulePreloadListBuilder.setVfModuleName(preload_name);
2345 vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2346 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadData);
2348 // SDNGC-989 set merge flag to false
2349 SaveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2350 log.info("Updating OPERATIONAL tree.");
2351 SaveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2352 } catch (Exception e) {
2353 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2355 responseBuilder.setResponseCode("500");
2356 responseBuilder.setResponseMessage(e.toString());
2357 responseBuilder.setAckFinalIndicator("Y");
2358 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2359 + responseBuilder.build());
2360 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2361 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(false)
2362 .withResult(responseBuilder.build()).build();
2363 return Futures.immediateFuture(rpcResult);
2367 responseBuilder.setResponseCode(errorCode);
2368 responseBuilder.setAckFinalIndicator(ackFinal);
2369 if (errorMessage != null) {
2370 responseBuilder.setResponseMessage(errorMessage);
2372 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2374 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2377 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2378 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2380 return Futures.immediateFuture(rpcResult);
2384 @Override public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2385 PreloadNetworkTopologyOperationInput input) {
2387 final String SVC_OPERATION = "preload-network-topology-operation";
2388 PreloadData preloadData = null;
2389 Properties parms = new Properties();
2391 log.info(SVC_OPERATION + " called.");
2392 // create a new response object
2393 PreloadNetworkTopologyOperationOutputBuilder responseBuilder =
2394 new PreloadNetworkTopologyOperationOutputBuilder();
2396 // Result from savePreloadData
2397 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2399 if (input == null || input.getNetworkTopologyInformation() == null
2400 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null
2401 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName() == null
2402 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType() == null) {
2403 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or" +
2404 " empty network-name or network-type");
2405 responseBuilder.setResponseCode("403");
2406 responseBuilder.setResponseMessage("input, null or empty network-name or network-type");
2407 responseBuilder.setAckFinalIndicator("Y");
2408 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2409 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2411 return Futures.immediateFuture(rpcResult);
2414 // Grab the name and type from the input buffer
2415 String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2416 String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2418 // Make sure we have a preload_name and preload_type
2419 if (preload_name == null || preload_name.length() == 0) {
2420 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
2421 responseBuilder.setResponseCode("403");
2422 responseBuilder.setResponseMessage("input, invalid preload-name");
2423 responseBuilder.setAckFinalIndicator("Y");
2424 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2425 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2427 return Futures.immediateFuture(rpcResult);
2430 if (preload_type == null || preload_type.length() == 0) {
2431 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
2432 responseBuilder.setResponseCode("403");
2433 responseBuilder.setResponseMessage("input, invalid preload-type");
2434 responseBuilder.setAckFinalIndicator("Y");
2435 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2436 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2438 return Futures.immediateFuture(rpcResult);
2441 if (input.getSdncRequestHeader() != null) {
2442 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2443 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2446 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2447 getPreloadData(preload_name, preload_type, preloadDataBuilder);
2449 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2450 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2453 // setup a preload-data object builder
2454 // ACTION vnf-topology-operation
2456 // USES sdnc-request-header;
2457 // USES request-information;
2458 // uses vnf-topology-information;
2460 // USES vnf-topology-response-body;
2462 // container preload-data
2463 // uses vnf-configuration-information;
2465 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2466 PreloadNetworkTopologyOperationInputBuilder inputBuilder =
2467 new PreloadNetworkTopologyOperationInputBuilder(input);
2468 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2469 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2470 + "] operational-data: " + operDataBuilder.build());
2471 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2473 // Call SLI sync method
2474 // Get SvcLogicService reference
2475 Properties respProps = null;
2476 String errorCode = "200";
2477 String errorMessage = null;
2478 String ackFinal = "Y";
2481 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2484 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2485 } catch (Exception e) {
2486 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2487 errorMessage = e.getMessage();
2491 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2494 } catch (Exception e) {
2496 errorMessage = e.getMessage();
2497 log.error("Caught exception looking for service logic", e);
2501 if (respProps != null) {
2502 errorCode = respProps.getProperty("error-code");
2503 errorMessage = respProps.getProperty("error-message");
2504 ackFinal = respProps.getProperty("ack-final", "Y");
2505 // internalError = respProps.getProperty("internal-error", "false");
2508 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2509 responseBuilder.setResponseCode(errorCode);
2510 responseBuilder.setResponseMessage(errorMessage);
2511 responseBuilder.setAckFinalIndicator(ackFinal);
2513 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2514 preloadVnfListBuilder.setVnfName(preload_name);
2515 preloadVnfListBuilder.setVnfType(preload_type);
2516 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2518 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2519 + errorCode + "', Reason: '" + errorMessage + "'");
2521 SavePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2522 } catch (Exception e) {
2524 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2528 log.debug("Sending Success rpc result due to external error");
2529 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2530 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2532 return Futures.immediateFuture(rpcResult);
2535 // Got success from SLI
2537 preloadData = preloadDataBuilder.build();
2539 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2541 // svc-configuration-list
2542 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2543 preloadVnfListBuilder.setVnfName(preload_name);
2544 preloadVnfListBuilder.setVnfType(preload_type);
2545 preloadVnfListBuilder.setPreloadData(preloadData);
2547 // SDNGC-989 set merge flag to false
2548 SavePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2549 log.info("Updating OPERATIONAL tree.");
2550 SavePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2551 } catch (Exception e) {
2552 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2554 responseBuilder.setResponseCode("500");
2555 responseBuilder.setResponseMessage(e.toString());
2556 responseBuilder.setAckFinalIndicator("Y");
2557 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2558 + responseBuilder.build());
2559 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2560 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(false)
2561 .withResult(responseBuilder.build()).build();
2562 return Futures.immediateFuture(rpcResult);
2566 responseBuilder.setResponseCode(errorCode);
2567 responseBuilder.setAckFinalIndicator(ackFinal);
2568 if (errorMessage != null) {
2569 responseBuilder.setResponseMessage(errorMessage);
2571 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2573 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2576 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2577 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2579 return Futures.immediateFuture(rpcResult);