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.slf4j.Logger;
135 import org.slf4j.LoggerFactory;
136 import org.slf4j.MDC;
138 import java.text.DateFormat;
139 import java.text.SimpleDateFormat;
140 import java.util.ArrayList;
141 import java.util.Date;
142 import java.util.Properties;
143 import java.util.TimeZone;
144 import java.util.concurrent.ExecutionException;
145 import java.util.concurrent.ExecutorService;
146 import java.util.concurrent.Executors;
147 import java.util.concurrent.Future;
150 * Defines a base implementation for your provider. This class extends from a helper class
151 * which provides storage for the most commonly used components of the MD-SAL. Additionally the
152 * base class provides some basic logging and initialization / clean up methods.
154 public class vnfapiProvider implements AutoCloseable, VNFAPIService, DataChangeListener {
155 protected DataBroker dataBroker;
156 protected NotificationPublishService notificationService;
157 protected RpcProviderRegistry rpcRegistry;
158 protected BindingAwareBroker.RpcRegistration<VNFAPIService> rpcRegistration;
160 private final Logger log = LoggerFactory.getLogger(vnfapiProvider.class);
161 private final String appName = "vnfapi";
162 private final ExecutorService executor;
164 private VNFSDNSvcLogicServiceClient svcLogicClient;
165 private ListenerRegistration<DataChangeListener> dclServices;
167 public vnfapiProvider(DataBroker dataBroker2, NotificationPublishService notificationPublishService,
168 RpcProviderRegistry rpcProviderRegistry, VNFSDNSvcLogicServiceClient client) {
169 this.log.info("Creating provider for " + appName);
170 executor = Executors.newFixedThreadPool(1);
171 dataBroker = dataBroker2;
172 notificationService = notificationPublishService;
173 rpcRegistry = rpcProviderRegistry;
174 this.svcLogicClient = client;
178 public void initialize() {
179 log.info("Initializing provider for " + appName);
180 // Create the top level containers
183 VnfSdnUtil.loadProperties();
184 } catch (Exception e) {
185 log.error("Caught Exception while trying to load properties file: ", e);
188 log.info("Initialization complete for " + appName);
191 private void createContainers() {
192 final WriteTransaction t = dataBroker.newReadWriteTransaction();
194 // Create the Vnfs container
195 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
196 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
198 // Create the PreloadVnfs container
199 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
200 new PreloadVnfsBuilder().build());
201 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
202 new PreloadVnfsBuilder().build());
204 // 1610 Create the PreloadVnfInstances container
205 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfInstances.class),
206 new PreloadVnfInstancesBuilder().build());
207 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfInstances.class),
208 new PreloadVnfInstancesBuilder().build());
210 // 1610 Create the VnfInstances container
211 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VnfInstances.class),
212 new VnfInstancesBuilder().build());
213 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VnfInstances.class),
214 new VnfInstancesBuilder().build());
216 // 1610 Create the PreloadVfModules container
217 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVfModules.class),
218 new PreloadVfModulesBuilder().build());
219 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVfModules.class),
220 new PreloadVfModulesBuilder().build());
222 // 1610 Create the VfModules container
223 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VfModules.class),
224 new VfModulesBuilder().build());
225 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VfModules.class),
226 new VfModulesBuilder().build());
229 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
231 log.info("Create Containers succeeded!: ");
233 } catch (InterruptedException | ExecutionException e) {
234 log.error("Create Containers Failed: " + e);
238 @Override public void close() throws Exception {
239 log.info("Closing provider for " + appName);
241 rpcRegistration.close();
242 log.info("Successfully closed provider for " + appName);
245 // On data change not used
246 @Override public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
247 boolean changed = false;
248 log.info(" IN ON DATA CHANGE: ");
249 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
251 DataObject updatedSubTree = change.getUpdatedSubtree();
253 if (updatedSubTree != null) {
254 if (log.isDebugEnabled()) {
255 log.debug("updatedSubTree was non-null:" + updatedSubTree);
257 if (updatedSubTree instanceof Vnfs) {
258 ArrayList<VnfList> vnfList = (ArrayList<VnfList>) ((Vnfs) updatedSubTree).getVnfList();
259 if (vnfList != null) {
260 for (VnfList entry : vnfList) {
261 ServiceData serviceData = entry.getServiceData();
262 ServiceStatus serviceStatus = entry.getServiceStatus();
263 if (serviceData != null && serviceStatus != null) {
265 // ServiceData change detected, check the AckFinal indicator and request-status to see if we need to proceed.
267 if ((!"Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete
268 .equals(serviceStatus.getRequestStatus()))) {
269 if (log.isDebugEnabled()) {
270 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
272 //handleServiceDataUpdated(serviceData, serviceStatus, writeTransaction);
279 if (updatedSubTree instanceof PreloadVnfs) {
280 ArrayList<VnfPreloadList> vnfList =
281 (ArrayList<VnfPreloadList>) ((PreloadVnfs) updatedSubTree).getVnfPreloadList();
282 if (vnfList != null) {
283 for (VnfPreloadList entry : vnfList) {
284 PreloadData preloadData = entry.getPreloadData();
285 if (preloadData != null) {
292 if (updatedSubTree instanceof PreloadVnfInstances) {
293 ArrayList<VnfInstancePreloadList> vnfInstanceList =
294 (ArrayList<VnfInstancePreloadList>) ((PreloadVnfInstances) updatedSubTree)
295 .getVnfInstancePreloadList();
296 if (vnfInstanceList != null) {
297 for (VnfInstancePreloadList entry : vnfInstanceList) {
298 VnfInstancePreloadData vnfInstancePreloadData = entry.getVnfInstancePreloadData();
299 if (vnfInstancePreloadData != null) {
306 if (updatedSubTree instanceof VnfInstances) {
307 ArrayList<VnfInstanceList> vnfInstanceList =
308 (ArrayList<VnfInstanceList>) ((VnfInstances) updatedSubTree).getVnfInstanceList();
309 if (vnfInstanceList != null) {
310 for (VnfInstanceList entry : vnfInstanceList) {
311 VnfInstanceServiceData vnfInstanceServiceData = entry.getVnfInstanceServiceData();
312 ServiceStatus serviceStatus = entry.getServiceStatus();
313 if (vnfInstanceServiceData != null && serviceStatus != null) {
314 // VnfInstanceServiceData change detected, check the AckFinal indicator and request-status
315 // to see if we need to proceed.
316 if ((!"Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete
317 .equals(serviceStatus.getRequestStatus()))) {
318 if (log.isDebugEnabled()) {
319 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
328 if (updatedSubTree instanceof PreloadVfModules) {
329 ArrayList<VfModulePreloadList> vnfInstanceList =
330 (ArrayList<VfModulePreloadList>) ((PreloadVfModules) updatedSubTree).getVfModulePreloadList();
331 if (vnfInstanceList != null) {
332 for (VfModulePreloadList entry : vnfInstanceList) {
333 VfModulePreloadData vnfInstancePreloadData = entry.getVfModulePreloadData();
334 if (vnfInstancePreloadData != null) {
341 if (updatedSubTree instanceof VfModules) {
342 ArrayList<VfModuleList> vfModuleList =
343 (ArrayList<VfModuleList>) ((VfModules) updatedSubTree).getVfModuleList();
344 if (vfModuleList != null) {
345 for (VfModuleList entry : vfModuleList) {
346 VfModuleServiceData vfModuleServiceData = entry.getVfModuleServiceData();
347 ServiceStatus serviceStatus = entry.getServiceStatus();
348 if (vfModuleServiceData != null && serviceStatus != null) {
349 // VfModuleServiceData change detected, check the AckFinal indicator and request-status to
350 // see if we need to proceed.
351 if ((!"Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete
352 .equals(serviceStatus.getRequestStatus()))) {
353 if (log.isDebugEnabled()) {
354 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
363 // Do the write transaction only if something changed.
365 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = writeTransaction.submit();
366 Futures.addCallback(checkedFuture, new FutureCallback<Void>() {
368 @Override public void onSuccess(Void arg0) {
369 log.debug("Successfully updated Service Status");
372 @Override public void onFailure(Throwable ex) {
373 log.debug("Failed updating Service Status", ex);
379 private static class Iso8601Util {
380 private static TimeZone tz = TimeZone.getTimeZone("UTC");
381 private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
387 private static String now() {
388 return df.format(new Date());
392 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
394 serviceStatusBuilder.setResponseCode(errorCode);
395 serviceStatusBuilder.setResponseMessage(errorMessage);
396 serviceStatusBuilder.setFinalIndicator(ackFinal);
397 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
400 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
401 if (requestInformation != null && requestInformation.getRequestAction() != null) {
402 switch (requestInformation.getRequestAction()) {
403 case VNFActivateRequest:
404 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VNFActivateRequest);
406 case ChangeVNFActivateRequest:
407 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVNFActivateRequest);
409 case DisconnectVNFRequest:
410 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVNFRequest);
412 case PreloadVNFRequest:
413 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVNFRequest);
415 case DeletePreloadVNFRequest:
416 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DeletePreloadVNFRequest);
418 // 1610 vnf-instance Requests
419 case VnfInstanceActivateRequest:
420 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VnfInstanceActivateRequest);
422 case ChangeVnfInstanceActivateRequest:
423 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVnfInstanceActivateRequest);
425 case DisconnectVnfInstanceRequest:
426 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVnfInstanceRequest);
428 case PreloadVnfInstanceRequest:
429 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVnfInstanceRequest);
431 // 1610 vf-module Requests
432 case VfModuleActivateRequest:
433 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VfModuleActivateRequest);
435 case ChangeVfModuleActivateRequest:
436 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVfModuleActivateRequest);
438 case DisconnectVfModuleRequest:
439 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVfModuleRequest);
441 case PreloadVfModuleRequest:
442 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVfModuleRequest);
445 log.error("Unknown RequestAction: " + requestInformation.getRequestAction());
449 if (requestInformation != null && requestInformation.getRequestSubAction() != null) {
450 switch (requestInformation.getRequestSubAction()) {
452 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP);
455 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
458 log.error("Unknown RequestSubAction: " + requestInformation.getRequestSubAction());
464 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
465 if (requestHeader != null && requestHeader.getSvcAction() != null) {
466 switch (requestHeader.getSvcAction()) {
468 serviceStatusBuilder.setRpcAction(RpcAction.Reserve);
471 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
474 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
477 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
480 serviceStatusBuilder.setRpcAction(RpcAction.Changeassign);
483 serviceStatusBuilder.setRpcAction(RpcAction.Changedelete);
486 serviceStatusBuilder.setRpcAction(RpcAction.Rollback);
489 log.error("Unknown SvcAction: " + requestHeader.getSvcAction());
495 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
497 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
501 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
502 // See if any data exists yet for this siid, if so grab it.
503 InstanceIdentifier serviceInstanceIdentifier =
504 InstanceIdentifier.<Vnfs>builder(Vnfs.class).child(VnfList.class, new VnfListKey(siid)).build();
505 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
506 Optional<VnfList> data = null;
508 data = (Optional<VnfList>) readTx.read(type, serviceInstanceIdentifier).get();
509 } catch (InterruptedException | ExecutionException e) {
510 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + siid + "] ", e);
513 if (data != null && data.isPresent()) {
514 ServiceData serviceData = (ServiceData) data.get().getServiceData();
515 if (serviceData != null) {
516 log.info("Read MD-SAL (" + type + ") data for [" + siid + "] ServiceData: " + serviceData);
517 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
518 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
519 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
520 serviceDataBuilder.setVnfRequestInformation(serviceData.getVnfRequestInformation());
521 serviceDataBuilder.setVnfId(serviceData.getVnfId());
522 serviceDataBuilder.setVnfTopologyInformation(serviceData.getVnfTopologyInformation());
523 serviceDataBuilder.setOperStatus(serviceData.getOperStatus());
525 log.info("No service-data found in MD-SAL (" + type + ") for [" + siid + "] ");
528 log.info("No data found in MD-SAL (" + type + ") for [" + siid + "] ");
533 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder) {
535 getVnfInstanceServiceData(siid, vnfInstanceServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
539 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder,
540 LogicalDatastoreType type) {
541 // See if any data exists yet for this siid, if so grab it.
542 InstanceIdentifier vnfInstanceIdentifier = InstanceIdentifier.<VnfInstances>builder(VnfInstances.class)
543 .child(VnfInstanceList.class, new VnfInstanceListKey(siid)).build();
544 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
545 Optional<VnfInstanceList> data = null;
547 data = (Optional<VnfInstanceList>) readTx.read(type, vnfInstanceIdentifier).get();
548 } catch (InterruptedException | ExecutionException e) {
549 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + siid + "] ", e);
552 if (data != null && data.isPresent()) {
553 VnfInstanceServiceData vnfInstanceServiceData =
554 (VnfInstanceServiceData) data.get().getVnfInstanceServiceData();
555 if (vnfInstanceServiceData != null) {
556 log.info("Read MD-SAL (" + type + ") data for [" + siid + "] VnfInstanceServiceData: "
557 + vnfInstanceServiceData);
558 vnfInstanceServiceDataBuilder.setSdncRequestHeader(vnfInstanceServiceData.getSdncRequestHeader());
559 vnfInstanceServiceDataBuilder.setRequestInformation(vnfInstanceServiceData.getRequestInformation());
560 vnfInstanceServiceDataBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
561 vnfInstanceServiceDataBuilder
562 .setVnfInstanceRequestInformation(vnfInstanceServiceData.getVnfInstanceRequestInformation());
563 vnfInstanceServiceDataBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
564 vnfInstanceServiceDataBuilder
565 .setVnfInstanceTopologyInformation(vnfInstanceServiceData.getVnfInstanceTopologyInformation());
566 vnfInstanceServiceDataBuilder.setOperStatus(vnfInstanceServiceData.getOperStatus());
568 log.info("No vnf-instance-service-data found in MD-SAL (" + type + ") for [" + siid + "] ");
571 log.info("No data found in MD-SAL (" + type + ") for [" + siid + "] ");
576 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder) {
578 getVfModuleServiceData(siid, vfModuleServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
582 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder,
583 LogicalDatastoreType type) {
584 // See if any data exists yet for this siid, if so grab it.
585 InstanceIdentifier vfModuleIdentifier =
586 InstanceIdentifier.<VfModules>builder(VfModules.class).child(VfModuleList.class, new VfModuleListKey(siid))
588 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
589 Optional<VfModuleList> data = null;
591 data = (Optional<VfModuleList>) readTx.read(type, vfModuleIdentifier).get();
592 } catch (InterruptedException | ExecutionException e) {
593 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + siid + "] ", e);
596 if (data != null && data.isPresent()) {
597 VfModuleServiceData vfModuleServiceData = data.get().getVfModuleServiceData();
598 if (vfModuleServiceData != null) {
600 "Read MD-SAL (" + type + ") data for [" + siid + "] VfModuleServiceData: " + vfModuleServiceData);
601 vfModuleServiceDataBuilder.setSdncRequestHeader(vfModuleServiceData.getSdncRequestHeader());
602 vfModuleServiceDataBuilder.setRequestInformation(vfModuleServiceData.getRequestInformation());
603 vfModuleServiceDataBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
604 vfModuleServiceDataBuilder
605 .setVfModuleRequestInformation(vfModuleServiceData.getVfModuleRequestInformation());
606 vfModuleServiceDataBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
607 vfModuleServiceDataBuilder
608 .setVfModuleTopologyInformation(vfModuleServiceData.getVfModuleTopologyInformation());
609 vfModuleServiceDataBuilder.setOperStatus(vfModuleServiceData.getOperStatus());
611 log.info("No vf-module-service-data found in MD-SAL (" + type + ") for [" + siid + "] ");
614 log.info("No data found in MD-SAL (" + type + ") for [" + siid + "] ");
619 private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder) {
621 getPreloadData(vnf_name, vnf_type, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
624 private void getPreloadData(String preload_name, String preload_type, PreloadDataBuilder preloadDataBuilder,
625 LogicalDatastoreType type) {
626 // See if any data exists yet for this name/type, if so grab it.
627 InstanceIdentifier preloadInstanceIdentifier = InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
628 .child(VnfPreloadList.class, new VnfPreloadListKey(preload_name, preload_type)).build();
629 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
630 Optional<VnfPreloadList> data = null;
632 data = (Optional<VnfPreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
633 } catch (InterruptedException | ExecutionException e) {
634 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ",
638 if (data != null && data.isPresent()) {
639 PreloadData preloadData = (PreloadData) data.get().getPreloadData();
640 if (preloadData != null) {
641 log.info("Read MD-SAL (" + type + ") data for [" + preload_name + "," + preload_type + "] PreloadData: "
643 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
644 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
645 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
648 "No preload-data found in MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ");
651 log.info("No data found in MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ");
655 //1610 preload-vnf-instance
656 private void getVnfInstancePreloadData(String vnf_name, String vnf_type,
657 VnfInstancePreloadDataBuilder preloadDataBuilder) {
659 getVnfInstancePreloadData(vnf_name, vnf_type, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
662 //1610 preload-vnf-instance
663 private void getVnfInstancePreloadData(String preload_name, String preload_type,
664 VnfInstancePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
665 // See if any data exists yet for this name/type, if so grab it.
666 InstanceIdentifier preloadInstanceIdentifier =
667 InstanceIdentifier.<PreloadVnfInstances>builder(PreloadVnfInstances.class)
668 .child(VnfInstancePreloadList.class, new VnfInstancePreloadListKey(preload_name, preload_type)).build();
669 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
670 Optional<VnfInstancePreloadList> data = null;
672 data = (Optional<VnfInstancePreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
673 } catch (InterruptedException | ExecutionException e) {
674 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ",
678 if (data != null && data.isPresent()) {
679 VnfInstancePreloadData preloadData = (VnfInstancePreloadData) data.get().getVnfInstancePreloadData();
680 if (preloadData != null) {
681 log.info("Read MD-SAL (" + type + ") data for [" + preload_name + "," + preload_type
682 + "] VnfInstancePreloadData: " + preloadData);
683 preloadDataBuilder.setVnfInstanceTopologyInformation(preloadData.getVnfInstanceTopologyInformation());
684 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
686 log.info("No vnf-instance-preload-data found in MD-SAL (" + type + ") for [" + preload_name + ","
687 + preload_type + "] ");
690 log.info("No data found in MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ");
694 // 1610 preload-vf-module
695 private void getVfModulePreloadData(String vnf_name, String vnf_type,
696 VfModulePreloadDataBuilder preloadDataBuilder) {
698 getVfModulePreloadData(vnf_name, vnf_type, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
701 private void getVfModulePreloadData(String preload_name, String preload_type,
702 VfModulePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
703 // See if any data exists yet for this name/type, if so grab it.
704 InstanceIdentifier preloadInstanceIdentifier =
705 InstanceIdentifier.<PreloadVfModules>builder(PreloadVfModules.class)
706 .child(VfModulePreloadList.class, new VfModulePreloadListKey(preload_name, preload_type)).build();
707 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
708 Optional<VfModulePreloadList> data = null;
710 data = (Optional<VfModulePreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
711 } catch (InterruptedException | ExecutionException e) {
712 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ",
716 if (data != null && data.isPresent()) {
717 VfModulePreloadData preloadData = (VfModulePreloadData) data.get().getVfModulePreloadData();
718 if (preloadData != null) {
719 log.info("Read MD-SAL (" + type + ") data for [" + preload_name + "," + preload_type
720 + "] VfModulePreloadData: " + preloadData);
721 preloadDataBuilder.setVfModuleTopologyInformation(preloadData.getVfModuleTopologyInformation());
722 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
725 "No preload-data found in MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ");
728 log.info("No data found in MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ");
732 private void SaveVnfList(final VnfList entry, boolean merge, LogicalDatastoreType storeType)
733 throws IllegalStateException {
734 // Each entry will be identifiable by a unique key, we have to create that identifier
735 InstanceIdentifier.InstanceIdentifierBuilder<VnfList> vnfListIdBuilder =
736 InstanceIdentifier.<Vnfs>builder(Vnfs.class).child(VnfList.class, entry.getKey());
737 InstanceIdentifier<VnfList> path = vnfListIdBuilder.build();
742 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
744 tx.merge(storeType, path, entry);
746 tx.put(storeType, path, entry);
748 tx.submit().checkedGet();
749 log.debug("Update DataStore succeeded");
751 } catch (final TransactionCommitFailedException e) {
752 if (e instanceof OptimisticLockFailedException) {
754 log.debug("Got OptimisticLockFailedException on last try - failing ");
755 throw new IllegalStateException(e);
757 log.debug("Got OptimisticLockFailedException - trying again ");
759 log.debug("Update DataStore failed");
760 throw new IllegalStateException(e);
767 private void DeleteVnfList(final VnfList entry, LogicalDatastoreType storeType) throws IllegalStateException {
768 // Each entry will be identifiable by a unique key, we have to create that identifier
769 InstanceIdentifier.InstanceIdentifierBuilder<VnfList> vnfListIdBuilder =
770 InstanceIdentifier.<Vnfs>builder(Vnfs.class).child(VnfList.class, entry.getKey());
771 InstanceIdentifier<VnfList> path = vnfListIdBuilder.build();
776 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
777 tx.delete(storeType, path);
778 tx.submit().checkedGet();
779 log.debug("DataStore delete succeeded");
781 } catch (final TransactionCommitFailedException e) {
782 if (e instanceof OptimisticLockFailedException) {
784 log.debug("Got OptimisticLockFailedException on last try - failing ");
785 throw new IllegalStateException(e);
787 log.debug("Got OptimisticLockFailedException - trying again ");
789 log.debug("Delete DataStore failed");
790 throw new IllegalStateException(e);
797 private void SaveVnfInstanceList(final VnfInstanceList entry, boolean merge, LogicalDatastoreType storeType)
798 throws IllegalStateException {
799 // Each entry will be identifiable by a unique key, we have to create that identifier
800 InstanceIdentifier.InstanceIdentifierBuilder<VnfInstanceList> vnfInstanceListIdBuilder =
801 InstanceIdentifier.<VnfInstances>builder(VnfInstances.class).child(VnfInstanceList.class, entry.getKey());
802 InstanceIdentifier<VnfInstanceList> path = vnfInstanceListIdBuilder.build();
807 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
809 tx.merge(storeType, path, entry);
811 tx.put(storeType, path, entry);
813 tx.submit().checkedGet();
814 log.debug("Update DataStore succeeded");
816 } catch (final TransactionCommitFailedException e) {
817 if (e instanceof OptimisticLockFailedException) {
819 log.debug("Got OptimisticLockFailedException on last try - failing ");
820 throw new IllegalStateException(e);
822 log.debug("Got OptimisticLockFailedException - trying again ");
824 log.debug("Update DataStore failed");
825 throw new IllegalStateException(e);
832 private void SaveVfModuleList(final VfModuleList entry, boolean merge, LogicalDatastoreType storeType)
833 throws IllegalStateException {
834 // Each entry will be identifiable by a unique key, we have to create that identifier
835 InstanceIdentifier.InstanceIdentifierBuilder<VfModuleList> vfModuleListIdBuilder =
836 InstanceIdentifier.<VfModules>builder(VfModules.class).child(VfModuleList.class, entry.getKey());
837 InstanceIdentifier<VfModuleList> path = vfModuleListIdBuilder.build();
842 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
844 tx.merge(storeType, path, entry);
846 tx.put(storeType, path, entry);
848 tx.submit().checkedGet();
849 log.debug("Update DataStore succeeded");
851 } catch (final TransactionCommitFailedException e) {
852 if (e instanceof OptimisticLockFailedException) {
854 log.debug("Got OptimisticLockFailedException on last try - failing ");
855 throw new IllegalStateException(e);
857 log.debug("Got OptimisticLockFailedException - trying again ");
859 log.debug("Update DataStore failed");
860 throw new IllegalStateException(e);
866 private void SavePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType)
867 throws IllegalStateException {
869 // Each entry will be identifiable by a unique key, we have to create that identifier
870 InstanceIdentifier.InstanceIdentifierBuilder<VnfPreloadList> vnfListIdBuilder =
871 InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class).child(VnfPreloadList.class, entry.getKey());
872 InstanceIdentifier<VnfPreloadList> path = vnfListIdBuilder.build();
876 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
878 tx.merge(storeType, path, entry);
880 tx.put(storeType, path, entry);
882 tx.submit().checkedGet();
883 log.debug("Update DataStore succeeded");
885 } catch (final TransactionCommitFailedException e) {
886 if (e instanceof OptimisticLockFailedException) {
888 log.debug("Got OptimisticLockFailedException on last try - failing ");
889 throw new IllegalStateException(e);
891 log.debug("Got OptimisticLockFailedException - trying again ");
893 log.debug("Update DataStore failed");
894 throw new IllegalStateException(e);
900 //1610 preload vnf-instance
901 private void SaveVnfInstancePreloadList(final VnfInstancePreloadList entry, boolean merge,
902 LogicalDatastoreType storeType) throws IllegalStateException {
904 // Each entry will be identifiable by a unique key, we have to create that identifier
905 InstanceIdentifier.InstanceIdentifierBuilder<VnfInstancePreloadList> vnfInstanceListIdBuilder =
906 InstanceIdentifier.<PreloadVnfInstances>builder(PreloadVnfInstances.class)
907 .child(VnfInstancePreloadList.class, entry.getKey());
908 InstanceIdentifier<VnfInstancePreloadList> path = vnfInstanceListIdBuilder.build();
912 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
914 tx.merge(storeType, path, entry);
916 tx.put(storeType, path, entry);
918 tx.submit().checkedGet();
919 log.debug("Update DataStore succeeded");
921 } catch (final TransactionCommitFailedException e) {
922 if (e instanceof OptimisticLockFailedException) {
924 log.debug("Got OptimisticLockFailedException on last try - failing ");
925 throw new IllegalStateException(e);
927 log.debug("Got OptimisticLockFailedException - trying again ");
929 log.debug("Update DataStore failed");
930 throw new IllegalStateException(e);
936 //1610 preload vf-module
937 private void SaveVfModulePreloadList(final VfModulePreloadList entry, boolean merge, LogicalDatastoreType storeType)
938 throws IllegalStateException {
940 // Each entry will be identifiable by a unique key, we have to create that identifier
941 InstanceIdentifier.InstanceIdentifierBuilder<VfModulePreloadList> vfModuleListIdBuilder =
942 InstanceIdentifier.<PreloadVfModules>builder(PreloadVfModules.class)
943 .child(VfModulePreloadList.class, entry.getKey());
944 InstanceIdentifier<VfModulePreloadList> path = vfModuleListIdBuilder.build();
948 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
950 tx.merge(storeType, path, entry);
952 tx.put(storeType, path, entry);
954 tx.submit().checkedGet();
955 log.debug("Update DataStore succeeded");
957 } catch (final TransactionCommitFailedException e) {
958 if (e instanceof OptimisticLockFailedException) {
960 log.debug("Got OptimisticLockFailedException on last try - failing ");
961 throw new IllegalStateException(e);
963 log.debug("Got OptimisticLockFailedException - trying again ");
965 log.debug("Update DataStore failed");
966 throw new IllegalStateException(e);
972 //Save the requestId into MDC
973 private void setRequestIdAsMDC(String requestId) {
974 MDC.put("RequestId", requestId);
977 //1610 vnf-instance-topology-operation
978 @Override public Future<RpcResult<VnfInstanceTopologyOperationOutput>> vnfInstanceTopologyOperation(
979 VnfInstanceTopologyOperationInput input) {
981 final String SVC_OPERATION = "vnf-instance-topology-operation";
982 VnfInstanceServiceData vnfInstanceServiceData = null;
983 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
984 Properties parms = new Properties();
986 log.info(SVC_OPERATION + " called.");
987 // create a new response object
988 VnfInstanceTopologyOperationOutputBuilder responseBuilder = new VnfInstanceTopologyOperationOutputBuilder();
990 //if(input == null || input.getVnfInstanceRequestInformation().getVnfInstanceTopologyIdentifier().getVnfInstanceId() == null )
991 if (input == null || input.getVnfInstanceRequestInformation() == null
992 || input.getVnfInstanceRequestInformation().getVnfInstanceId() == null) {
993 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vnf-instance-id");
994 responseBuilder.setResponseCode("403");
995 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
996 responseBuilder.setAckFinalIndicator("Y");
997 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
998 RpcResultBuilder.<VnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1001 return Futures.immediateFuture(rpcResult);
1004 // Grab the service instance ID from the input buffer
1005 String viid = input.getVnfInstanceRequestInformation().getVnfInstanceId();
1006 String preload_name = input.getVnfInstanceRequestInformation().getVnfInstanceName();
1007 String preload_type = input.getVnfInstanceRequestInformation().getVnfModelId();
1009 // Make sure we have a valid viid
1010 if (viid == null || viid.length() == 0) {
1011 log.debug("exiting " + SVC_OPERATION + " because of invalid vnf-instance-id");
1012 responseBuilder.setResponseCode("403");
1013 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1014 responseBuilder.setAckFinalIndicator("Y");
1015 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1016 RpcResultBuilder.<VnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1019 return Futures.immediateFuture(rpcResult);
1022 if (input.getSdncRequestHeader() != null) {
1023 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1024 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1027 // Get vnf-instance-preload-data
1028 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
1029 getVnfInstancePreloadData(preload_name, preload_type, vnfInstancePreloadDataBuilder);
1032 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1033 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1035 // Get operational-data
1036 VnfInstanceServiceDataBuilder operDataBuilder = new VnfInstanceServiceDataBuilder();
1037 getVnfInstanceServiceData(viid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1039 // Set the serviceStatus based on input
1040 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1041 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1044 // setup a service-data object builder
1045 // ACTION vnf-topology-operation
1047 // USES sdnc-request-header;
1048 // USES request-information;
1049 // USES service-information;
1050 // USES vnf-request-information
1052 // USES vnf-topology-response-body;
1053 // USES vnf-information
1054 // USES service-information
1056 // container service-data
1057 // uses vnf-configuration-information;
1058 // uses oper-status;
1060 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + viid + "] input: " + input);
1061 VnfInstanceTopologyOperationInputBuilder inputBuilder = new VnfInstanceTopologyOperationInputBuilder(input);
1062 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1064 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + viid + "] operational-data: " + operDataBuilder
1066 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1069 "Adding CONFIG data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preload-data: "
1070 + vnfInstancePreloadDataBuilder.build());
1071 VnfSdnUtil.toProperties(parms, "vnf-instance-preload-data", vnfInstancePreloadDataBuilder);
1073 // Call SLI sync method
1074 // Get SvcLogicService reference
1075 Properties respProps = null;
1076 String errorCode = "200";
1077 String errorMessage = null;
1078 String ackFinal = "Y";
1081 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1084 respProps = svcLogicClient
1085 .execute("VNF-API", SVC_OPERATION, null, "sync", vnfInstanceServiceDataBuilder, parms);
1086 } catch (Exception e) {
1087 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1088 errorMessage = e.getMessage();
1092 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1095 } catch (Exception e) {
1097 errorMessage = e.getMessage();
1098 log.error("Caught exception looking for service logic", e);
1101 if (respProps != null) {
1102 errorCode = respProps.getProperty("error-code");
1103 errorMessage = respProps.getProperty("error-message");
1104 ackFinal = respProps.getProperty("ack-final", "Y");
1107 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1108 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1109 serviceStatusBuilder.setRpcName(RpcName.VnfInstanceTopologyOperation);
1111 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1112 responseBuilder.setResponseCode(errorCode);
1113 responseBuilder.setResponseMessage(errorMessage);
1114 responseBuilder.setAckFinalIndicator(ackFinal);
1115 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1116 vnfInstanceListBuilder.setVnfInstanceId(viid);
1117 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1119 SaveVnfInstanceList(vnfInstanceListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1120 } catch (Exception e) {
1121 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + viid + "] \n", e);
1123 log.error("Returned FAILED for " + SVC_OPERATION + " [" + viid + "] " + responseBuilder.build());
1124 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1125 RpcResultBuilder.<VnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1128 return Futures.immediateFuture(rpcResult);
1131 // Got success from SLI
1133 vnfInstanceServiceData = vnfInstanceServiceDataBuilder.build();
1134 log.info("Updating MD-SAL for " + SVC_OPERATION + " [" + viid + "] VnfInstanceServiceData: "
1135 + vnfInstanceServiceData);
1136 // svc-configuration-list
1137 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1138 vnfInstanceListBuilder.setVnfInstanceServiceData(vnfInstanceServiceData);
1139 vnfInstanceListBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
1140 //siid = vnfInstanceServiceData.getVnfInstanceId();
1141 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1142 SaveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1143 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1144 // Only update operational tree on Delete or Activate
1145 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1146 .getSvcAction().equals(SvcAction.Activate)) {
1147 log.info("Updating OPERATIONAL tree.");
1148 SaveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1151 VnfInstanceInformationBuilder vnfInstanceInformationBuilder = new VnfInstanceInformationBuilder();
1152 vnfInstanceInformationBuilder.setVnfInstanceId(viid);
1153 responseBuilder.setVnfInstanceInformation(vnfInstanceInformationBuilder.build());
1154 responseBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
1155 } catch (Exception e) {
1156 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + viid + "] \n", e);
1157 responseBuilder.setResponseCode("500");
1158 responseBuilder.setResponseMessage(e.toString());
1159 responseBuilder.setAckFinalIndicator("Y");
1160 log.error("Returned FAILED for " + SVC_OPERATION + " [" + viid + "] " + responseBuilder.build());
1161 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1162 RpcResultBuilder.<VnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1165 return Futures.immediateFuture(rpcResult);
1169 responseBuilder.setResponseCode(errorCode);
1170 responseBuilder.setAckFinalIndicator(ackFinal);
1171 if (errorMessage != null) {
1172 responseBuilder.setResponseMessage(errorMessage);
1174 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + viid + "] ");
1175 log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + viid + "] " + responseBuilder.build());
1177 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1178 RpcResultBuilder.<VnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1181 return Futures.immediateFuture(rpcResult);
1184 //1610 vf-module-topology-operation
1185 @Override public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1186 VfModuleTopologyOperationInput input) {
1188 final String SVC_OPERATION = "vf-module-topology-operation";
1189 VfModuleServiceData vfModuleServiceData = null;
1190 VnfInstanceServiceData vnfInstanceServiceData = null;
1191 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1192 Properties parms = new Properties();
1194 log.info(SVC_OPERATION + " called.");
1195 // create a new response object
1196 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1198 // Validate vf-module-id from vf-module-request-information
1199 if (input == null || input.getVfModuleRequestInformation() == null
1200 || input.getVfModuleRequestInformation().getVfModuleId() == null) {
1201 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vf-module-id");
1202 responseBuilder.setResponseCode("403");
1203 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1204 responseBuilder.setAckFinalIndicator("Y");
1205 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1206 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1209 return Futures.immediateFuture(rpcResult);
1212 // Grab the vf-module-request-information.vf-module-id from the input buffer
1213 String vfid = input.getVfModuleRequestInformation().getVfModuleId();
1214 String preload_name = input.getVfModuleRequestInformation().getVfModuleName();
1215 String preload_type = input.getVfModuleRequestInformation().getVfModuleModelId();
1217 // Make sure we have a valid siid
1218 if (vfid == null || vfid.length() == 0) {
1219 log.debug("exiting " + SVC_OPERATION + " because of invalid vf-module-id");
1220 responseBuilder.setResponseCode("403");
1221 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1222 responseBuilder.setAckFinalIndicator("Y");
1223 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1224 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1227 return Futures.immediateFuture(rpcResult);
1230 // 1610 add vf-module-id to vnf-instance-list.vf-module-relationship-list
1231 String viid = input.getVfModuleRequestInformation().getVnfInstanceId();
1233 if (viid == null || viid.length() == 0) {
1234 log.debug("exiting " + SVC_OPERATION + " because of invalid vnf-instance-id");
1235 responseBuilder.setResponseCode("403");
1236 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1237 responseBuilder.setAckFinalIndicator("Y");
1238 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1239 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1242 return Futures.immediateFuture(rpcResult);
1245 if (input.getSdncRequestHeader() != null) {
1246 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1247 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1250 // Get vf-module-preload-data
1251 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
1252 getVfModulePreloadData(preload_name, preload_type, vfModulePreloadDataBuilder);
1254 // Get vf-module-service-data
1255 VfModuleServiceDataBuilder vfModuleServiceDataBuilder = new VfModuleServiceDataBuilder();
1256 getVfModuleServiceData(vfid, vfModuleServiceDataBuilder);
1258 // Get vf-module operation-data
1259 VfModuleServiceDataBuilder operDataBuilder = new VfModuleServiceDataBuilder();
1260 getVfModuleServiceData(vfid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1262 // save service-data builder object for rollback
1263 VfModuleServiceDataBuilder rb_vfModuleServiceDataBuilder = vfModuleServiceDataBuilder;
1264 VfModuleServiceDataBuilder rb_operDataBuilder = operDataBuilder;
1266 // 1610 Need to pull vnf-instance-list.vf-module-relationship-list from MD-SAL
1267 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1268 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1270 // vnf-instance operational-data
1271 VnfInstanceServiceDataBuilder vnfInstanceOperDataBuilder = new VnfInstanceServiceDataBuilder();
1272 getVnfInstanceServiceData(viid, vnfInstanceOperDataBuilder, LogicalDatastoreType.OPERATIONAL);
1274 // save operational builder object for rollback
1275 VnfInstanceServiceDataBuilder rb_vnfInstanceServiceDataBuilder = vnfInstanceServiceDataBuilder;
1276 VnfInstanceServiceDataBuilder rb_vnfInstanceOperDataBuilder = vnfInstanceOperDataBuilder;
1278 // Set the serviceStatus based on input
1279 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1280 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1283 // setup a service-data object builder
1284 // ACTION vnf-topology-operation
1286 // USES sdnc-request-header;
1287 // USES request-information;
1288 // USES service-information;
1289 // USES vnf-request-information
1291 // USES vnf-topology-response-body;
1292 // USES vnf-information
1293 // USES service-information
1295 // container service-data
1296 // uses vnf-configuration-information;
1297 // uses oper-status;
1299 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + vfid + "] input: " + input);
1300 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1301 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1303 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + vfid + "] vf-module operational-data: "
1304 + operDataBuilder.build());
1305 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1307 log.info("Adding CONFIG data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1308 + "] vf-module-preload-data: " + vfModulePreloadDataBuilder.build());
1309 VnfSdnUtil.toProperties(parms, "vf-module-preload-data", vfModulePreloadDataBuilder);
1311 log.info("Adding vnf-instance CONFIG data for " + SVC_OPERATION + " [" + viid + "] vnf-instance-service-data: "
1312 + vnfInstanceServiceDataBuilder.build());
1313 VnfSdnUtil.toProperties(parms, "vnf-instance-service-data", vnfInstanceServiceDataBuilder);
1315 log.info("Adding vnf-instance OPERATIONAL data for " + SVC_OPERATION + " [" + viid
1316 + "] vnf-instance operational-data: " + vnfInstanceOperDataBuilder.build());
1317 VnfSdnUtil.toProperties(parms, "vnf-instance-operational-data", vnfInstanceOperDataBuilder);
1319 // Call SLI sync method
1320 // Get SvcLogicService reference
1322 Properties respProps = null;
1323 String errorCode = "200";
1324 String errorMessage = null;
1325 String ackFinal = "Y";
1328 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1331 respProps = svcLogicClient
1332 .execute("VNF-API", SVC_OPERATION, null, "sync", vfModuleServiceDataBuilder, parms);
1333 } catch (Exception e) {
1334 log.error("Caught exception executing service logic on vf-module for " + SVC_OPERATION, e);
1335 errorMessage = e.getMessage();
1340 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1343 } catch (Exception e) {
1345 errorMessage = e.getMessage();
1346 log.error("Caught exception looking for service logic", e);
1350 if (respProps != null) {
1351 errorCode = respProps.getProperty("error-code");
1352 errorMessage = respProps.getProperty("error-message");
1353 ackFinal = respProps.getProperty("ack-final", "Y");
1356 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1357 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1358 serviceStatusBuilder.setRpcName(RpcName.VfModuleTopologyOperation);
1360 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1361 responseBuilder.setResponseCode(errorCode);
1362 responseBuilder.setResponseMessage(errorMessage);
1363 responseBuilder.setAckFinalIndicator(ackFinal);
1364 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1365 vfModuleListBuilder.setVfModuleId(vfid);
1366 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1368 SaveVfModuleList(vfModuleListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1369 } catch (Exception e) {
1370 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + vfid + "] \n", e);
1372 log.error("Returned FAILED for " + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1373 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1374 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1377 return Futures.immediateFuture(rpcResult);
1380 // Got success from SLI
1381 // save vf-module-service-data in MD-SAL
1383 vfModuleServiceData = vfModuleServiceDataBuilder.build();
1385 "Updating MD-SAL for " + SVC_OPERATION + " [" + vfid + "] VfModuleServiceData: " + vfModuleServiceData);
1387 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1388 vfModuleListBuilder.setVfModuleServiceData(vfModuleServiceData);
1389 vfModuleListBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
1390 //vfid = vfModuleServiceData.getVfModuleId();
1391 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1392 SaveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1393 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1394 // Only update operational tree on Delete or Activate
1395 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1396 .getSvcAction().equals(SvcAction.Activate)) {
1397 log.info("Updating OPERATIONAL tree.");
1398 SaveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1401 VfModuleInformationBuilder vfModuleInformationBuilder = new VfModuleInformationBuilder();
1402 vfModuleInformationBuilder.setVfModuleId(vfid);
1403 responseBuilder.setVfModuleInformation(vfModuleInformationBuilder.build());
1404 responseBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
1405 } catch (Exception e) {
1406 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + vfid + "] \n", e);
1407 responseBuilder.setResponseCode("500");
1408 responseBuilder.setResponseMessage(e.toString());
1409 responseBuilder.setAckFinalIndicator("Y");
1410 log.error("Returned FAILED for " + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1411 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1412 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1415 return Futures.immediateFuture(rpcResult);
1419 responseBuilder.setResponseCode(errorCode);
1420 responseBuilder.setAckFinalIndicator(ackFinal);
1421 if (errorMessage != null) {
1422 responseBuilder.setResponseMessage(errorMessage);
1424 log.info("Updated vf-module in MD-SAL for " + SVC_OPERATION + " [" + vfid + "] ");
1425 log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1427 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1428 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1430 return Futures.immediateFuture(rpcResult);
1435 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
1436 final String SVC_OPERATION = "vnf-topology-operation";
1437 ServiceData serviceData = null;
1438 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1439 Properties parms = new Properties();
1441 log.info(SVC_OPERATION + " called.");
1442 // create a new response object
1443 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1445 if (input == null || input.getServiceInformation() == null
1446 || input.getServiceInformation().getServiceInstanceId() == null
1447 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1448 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1449 responseBuilder.setResponseCode("403");
1450 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1451 responseBuilder.setAckFinalIndicator("Y");
1452 RpcResult<VnfTopologyOperationOutput> rpcResult =
1453 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1455 return Futures.immediateFuture(rpcResult);
1458 if (input.getVnfRequestInformation() == null || input.getVnfRequestInformation().getVnfId() == null
1459 || input.getVnfRequestInformation().getVnfId().length() == 0) {
1460 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vf-module-id");
1461 responseBuilder.setResponseCode("403");
1462 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1463 responseBuilder.setAckFinalIndicator("Y");
1464 RpcResult<VnfTopologyOperationOutput> rpcResult =
1465 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1467 return Futures.immediateFuture(rpcResult);
1470 // Grab the service instance ID from the input buffer
1471 String siid = input.getVnfRequestInformation().getVnfId();
1472 String preload_name = input.getVnfRequestInformation().getVnfName();
1473 String preload_type = input.getVnfRequestInformation().getVnfType();
1475 if (input.getSdncRequestHeader() != null) {
1476 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1477 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1480 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1481 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1483 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1484 getServiceData(siid, serviceDataBuilder);
1486 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1487 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1489 // Set the serviceStatus based on input
1490 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1491 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1494 // setup a service-data object builder
1495 // ACTION vnf-topology-operation
1497 // USES sdnc-request-header;
1498 // USES request-information;
1499 // USES service-information;
1500 // USES vnf-request-information
1502 // USES vnf-topology-response-body;
1503 // USES vnf-information
1504 // USES service-information
1506 // container service-data
1507 // uses vnf-configuration-information;
1508 // uses oper-status;
1510 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + siid + "] input: " + input);
1511 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1512 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1514 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + siid + "] operational-data: " + operDataBuilder
1516 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1519 "Adding CONFIG data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preload-data: "
1520 + preloadDataBuilder.build());
1521 VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1523 // Call SLI sync method
1524 // Get SvcLogicService reference
1525 Properties respProps = null;
1526 String errorCode = "200";
1527 String errorMessage = null;
1528 String ackFinal = "Y";
1531 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1535 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1536 } catch (Exception e) {
1537 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1538 errorMessage = e.getMessage();
1542 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1545 } catch (Exception e) {
1547 errorMessage = e.getMessage();
1548 log.error("Caught exception looking for service logic", e);
1551 if (respProps != null) {
1552 errorCode = respProps.getProperty("error-code");
1553 errorMessage = respProps.getProperty("error-message");
1554 ackFinal = respProps.getProperty("ack-final", "Y");
1557 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1558 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1559 serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
1561 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1562 responseBuilder.setResponseCode(errorCode);
1563 responseBuilder.setResponseMessage(errorMessage);
1564 responseBuilder.setAckFinalIndicator(ackFinal);
1565 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1566 vnfListBuilder.setVnfId(siid);
1567 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1569 SaveVnfList(vnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1570 } catch (Exception e) {
1571 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1573 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1574 RpcResult<VnfTopologyOperationOutput> rpcResult =
1575 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1577 return Futures.immediateFuture(rpcResult);
1580 // Got success from SLI
1582 serviceData = serviceDataBuilder.build();
1583 log.info("Updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] ServiceData: " + serviceData);
1584 // svc-configuration-list
1585 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1586 vnfListBuilder.setServiceData(serviceData);
1587 vnfListBuilder.setVnfId(serviceData.getVnfId());
1588 siid = serviceData.getVnfId();
1589 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1590 SaveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1591 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1592 // Only update operational tree on Delete or Activate
1593 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1594 log.info("Updating OPERATIONAL tree.");
1595 SaveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1596 } else if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input
1597 .getSdncRequestHeader().getSvcAction().equals(SvcAction.Rollback)) {
1598 log.info("Delete OPERATIONAL tree.");
1599 DeleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
1600 DeleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
1603 VnfInformationBuilder vnfInformationBuilder = new VnfInformationBuilder();
1604 vnfInformationBuilder.setVnfId(siid);
1605 responseBuilder.setVnfInformation(vnfInformationBuilder.build());
1606 responseBuilder.setServiceInformation(serviceData.getServiceInformation());
1607 } catch (Exception e) {
1608 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1609 responseBuilder.setResponseCode("500");
1610 responseBuilder.setResponseMessage(e.toString());
1611 responseBuilder.setAckFinalIndicator("Y");
1612 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1613 RpcResult<VnfTopologyOperationOutput> rpcResult =
1614 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1616 return Futures.immediateFuture(rpcResult);
1620 responseBuilder.setResponseCode(errorCode);
1621 responseBuilder.setAckFinalIndicator(ackFinal);
1622 if (errorMessage != null) {
1623 responseBuilder.setResponseMessage(errorMessage);
1625 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + siid + "] ");
1626 log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1628 RpcResult<VnfTopologyOperationOutput> rpcResult =
1629 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1631 return Futures.immediateFuture(rpcResult);
1634 @Override public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1635 NetworkTopologyOperationInput input) {
1637 final String SVC_OPERATION = "network-topology-operation";
1638 ServiceData serviceData = null;
1639 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1640 Properties parms = new Properties();
1642 log.info(SVC_OPERATION + " called.");
1643 // create a new response object
1644 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1646 if (input == null || input.getServiceInformation() == null
1647 || input.getServiceInformation().getServiceInstanceId() == null
1648 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1649 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1650 responseBuilder.setResponseCode("403");
1651 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1652 responseBuilder.setAckFinalIndicator("Y");
1653 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1654 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1657 return Futures.immediateFuture(rpcResult);
1660 if (input.getNetworkRequestInformation() == null
1661 || input.getNetworkRequestInformation().getNetworkName() == null) {
1662 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1663 responseBuilder.setResponseCode("403");
1664 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1665 responseBuilder.setAckFinalIndicator("Y");
1666 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1667 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1670 return Futures.immediateFuture(rpcResult);
1673 // Grab the service instance ID from the input buffer
1675 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Assign)) {
1676 siid = input.getNetworkRequestInformation().getNetworkName();
1678 siid = input.getNetworkRequestInformation().getNetworkId();
1680 String preload_name = input.getNetworkRequestInformation().getNetworkName();
1681 String preload_type = input.getNetworkRequestInformation().getNetworkType();
1683 if (input.getSdncRequestHeader() != null) {
1684 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1685 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1688 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1689 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1691 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + siid + "] input: " + input);
1692 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1693 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1695 // Call SLI sync method
1696 // Get SvcLogicService reference
1697 Properties respProps = null;
1698 String errorCode = "200";
1699 String errorMessage = null;
1700 String ackFinal = "Y";
1701 String networkId = "error";
1704 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1708 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1709 } catch (Exception e) {
1710 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1711 errorMessage = e.getMessage();
1715 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1718 } catch (Exception e) {
1720 errorMessage = e.getMessage();
1721 log.error("Caught exception looking for service logic", e);
1724 if (respProps != null) {
1725 errorCode = respProps.getProperty("error-code");
1726 errorMessage = respProps.getProperty("error-message");
1727 ackFinal = respProps.getProperty("ack-final", "Y");
1728 networkId = respProps.getProperty("networkId", "0");
1731 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1732 responseBuilder.setResponseCode(errorCode);
1733 responseBuilder.setResponseMessage(errorMessage);
1734 responseBuilder.setAckFinalIndicator(ackFinal);
1736 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1738 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1739 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1742 return Futures.immediateFuture(rpcResult);
1745 // Got success from SLI
1747 NetworkInformationBuilder networkInformationBuilder = new NetworkInformationBuilder();
1748 networkInformationBuilder.setNetworkId(networkId);
1749 responseBuilder.setNetworkInformation(networkInformationBuilder.build());
1750 responseBuilder.setServiceInformation(input.getServiceInformation());
1751 } catch (IllegalStateException e) {
1752 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1753 responseBuilder.setResponseCode("500");
1754 responseBuilder.setResponseMessage(e.toString());
1755 responseBuilder.setAckFinalIndicator("Y");
1756 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1757 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1758 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1761 return Futures.immediateFuture(rpcResult);
1765 responseBuilder.setResponseCode(errorCode);
1766 responseBuilder.setAckFinalIndicator(ackFinal);
1767 if (errorMessage != null) {
1768 responseBuilder.setResponseMessage(errorMessage);
1770 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + siid + "] ");
1771 log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1773 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1774 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1776 return Futures.immediateFuture(rpcResult);
1779 @Override public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1780 PreloadVnfTopologyOperationInput input) {
1782 final String SVC_OPERATION = "preload-vnf-topology-operation";
1783 PreloadData preloadData = null;
1784 Properties parms = new Properties();
1786 log.info(SVC_OPERATION + " called.");
1787 // create a new response object
1788 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1790 // Result from savePreloadData
1791 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1793 if (input == null || input.getVnfTopologyInformation() == null
1794 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null
1795 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName() == null
1796 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType() == null) {
1797 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vnf-name and vnf-type");
1798 responseBuilder.setResponseCode("403");
1799 responseBuilder.setResponseMessage("invalid input, null or empty vnf-name and vnf-type");
1800 responseBuilder.setAckFinalIndicator("Y");
1801 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1802 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1804 return Futures.immediateFuture(rpcResult);
1807 // Grab the name and type from the input buffer
1808 String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1809 String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1811 // Make sure we have a preload_name and preload_type
1812 if (preload_name == null || preload_name.length() == 0) {
1813 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
1814 responseBuilder.setResponseCode("403");
1815 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1816 responseBuilder.setAckFinalIndicator("Y");
1817 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1818 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1820 return Futures.immediateFuture(rpcResult);
1822 if (preload_type == null || preload_type.length() == 0) {
1823 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
1824 responseBuilder.setResponseCode("403");
1825 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1826 responseBuilder.setAckFinalIndicator("Y");
1827 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1828 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1830 return Futures.immediateFuture(rpcResult);
1833 if (input.getSdncRequestHeader() != null) {
1834 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1835 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1838 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1839 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1840 //preloadData = preloadDataBuilder.build();
1842 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1843 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1846 // setup a preload-data object builder
1847 // ACTION vnf-topology-operation
1849 // USES sdnc-request-header;
1850 // USES request-information;
1851 // uses vnf-topology-information;
1853 // USES vnf-topology-response-body;
1855 // container preload-data
1856 // uses vnf-configuration-information;
1858 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
1859 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1860 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1861 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1862 + "] operational-data: " + operDataBuilder.build());
1863 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1865 // Call SLI sync method
1866 // Get SvcLogicService reference
1867 Properties respProps = null;
1868 String errorCode = "200";
1869 String errorMessage = null;
1870 String ackFinal = "Y";
1873 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1877 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1878 } catch (Exception e) {
1879 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1880 errorMessage = e.getMessage();
1884 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1887 } catch (Exception e) {
1889 errorMessage = e.getMessage();
1890 log.error("Caught exception looking for service logic", e);
1893 if (respProps != null) {
1894 errorCode = respProps.getProperty("error-code");
1895 errorMessage = respProps.getProperty("error-message");
1896 ackFinal = respProps.getProperty("ack-final", "Y");
1897 // internalError = respProps.getProperty("internal-error", "false");
1900 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1902 responseBuilder.setResponseCode(errorCode);
1903 responseBuilder.setResponseMessage(errorMessage);
1904 responseBuilder.setAckFinalIndicator(ackFinal);
1906 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1907 preloadVnfListBuilder.setVnfName(preload_name);
1908 preloadVnfListBuilder.setVnfType(preload_type);
1909 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1911 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
1912 + errorCode + "', Reason: '" + errorMessage + "'");
1914 SavePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1915 } catch (Exception e) {
1917 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1920 log.debug("Sending Success rpc result due to external error");
1921 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1922 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1924 return Futures.immediateFuture(rpcResult);
1927 // Got success from SLI
1929 preloadData = preloadDataBuilder.build();
1931 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
1933 // svc-configuration-list
1934 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1935 preloadVnfListBuilder.setVnfName(preload_name);
1936 preloadVnfListBuilder.setVnfType(preload_type);
1937 preloadVnfListBuilder.setPreloadData(preloadData);
1939 // SDNGC-989 set merge flag to false
1940 SavePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1941 log.info("Updating OPERATIONAL tree.");
1942 SavePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1943 } catch (Exception e) {
1944 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1946 responseBuilder.setResponseCode("500");
1947 responseBuilder.setResponseMessage(e.toString());
1948 responseBuilder.setAckFinalIndicator("Y");
1949 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
1950 + responseBuilder.build());
1951 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1952 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(false).withResult(responseBuilder.build())
1954 return Futures.immediateFuture(rpcResult);
1958 responseBuilder.setResponseCode(errorCode);
1959 responseBuilder.setAckFinalIndicator(ackFinal);
1960 if (errorMessage != null) {
1961 responseBuilder.setResponseMessage(errorMessage);
1963 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
1965 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
1968 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1969 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1971 return Futures.immediateFuture(rpcResult);
1974 //1610 preload-vnf-instance-topology-operation
1975 @Override public Future<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> preloadVnfInstanceTopologyOperation(
1976 PreloadVnfInstanceTopologyOperationInput input) {
1978 final String SVC_OPERATION = "preload-vnf-instance-topology-operation";
1979 VnfInstancePreloadData vnfInstancePreloadData = null;
1980 Properties parms = new Properties();
1982 log.info(SVC_OPERATION + " called.");
1983 // create a new response object
1984 PreloadVnfInstanceTopologyOperationOutputBuilder responseBuilder =
1985 new PreloadVnfInstanceTopologyOperationOutputBuilder();
1987 // Result from savePreloadData
1988 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1990 if (input == null || input.getVnfInstanceTopologyInformation() == null
1991 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName() == null
1992 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId() == null) {
1993 log.debug("exiting " + SVC_OPERATION
1994 + " because of invalid input, null or empty vnf-instance-name and vnf-model-id");
1995 responseBuilder.setResponseCode("403");
1996 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name and vnf-model-id");
1997 responseBuilder.setAckFinalIndicator("Y");
1998 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1999 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2000 .withResult(responseBuilder.build()).build();
2001 return Futures.immediateFuture(rpcResult);
2004 // Grab the name and type from the input buffer
2005 String preload_name =
2006 input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName();
2007 String preload_type = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId();
2009 // Make sure we have a preload_name and preload_type
2010 if (preload_name == null || preload_name.length() == 0) {
2011 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
2012 responseBuilder.setResponseCode("403");
2013 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2014 responseBuilder.setAckFinalIndicator("Y");
2015 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2016 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2017 .withResult(responseBuilder.build()).build();
2018 return Futures.immediateFuture(rpcResult);
2020 if (preload_type == null || preload_type.length() == 0) {
2021 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
2022 responseBuilder.setResponseCode("403");
2023 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2024 responseBuilder.setAckFinalIndicator("Y");
2025 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2026 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2027 .withResult(responseBuilder.build()).build();
2028 return Futures.immediateFuture(rpcResult);
2031 if (input.getSdncRequestHeader() != null) {
2032 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2033 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2036 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
2037 getVnfInstancePreloadData(preload_name, preload_type, vnfInstancePreloadDataBuilder);
2038 //preloadData = preloadDataBuilder.build();
2040 VnfInstancePreloadDataBuilder operDataBuilder = new VnfInstancePreloadDataBuilder();
2041 getVnfInstancePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2044 // setup a preload-data object builder
2045 // ACTION vnf-topology-operation
2047 // USES sdnc-request-header;
2048 // USES request-information;
2049 // uses vnf-topology-information;
2051 // USES vnf-topology-response-body;
2053 // container preload-data
2054 // uses vnf-configuration-information;
2056 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2057 PreloadVnfInstanceTopologyOperationInputBuilder inputBuilder =
2058 new PreloadVnfInstanceTopologyOperationInputBuilder(input);
2059 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2060 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2061 + "] operational-data: " + operDataBuilder.build());
2062 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2064 // Call SLI sync method
2065 // Get SvcLogicService reference
2066 Properties respProps = null;
2067 String errorCode = "200";
2068 String errorMessage = null;
2069 String ackFinal = "Y";
2072 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2075 respProps = svcLogicClient
2076 .execute("VNF-API", SVC_OPERATION, null, "sync", vnfInstancePreloadDataBuilder, parms);
2077 } catch (Exception e) {
2078 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2079 errorMessage = e.getMessage();
2083 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2086 } catch (Exception e) {
2088 errorMessage = e.getMessage();
2089 log.error("Caught exception looking for service logic", e);
2092 if (respProps != null) {
2093 errorCode = respProps.getProperty("error-code");
2094 errorMessage = respProps.getProperty("error-message");
2095 ackFinal = respProps.getProperty("ack-final", "Y");
2096 // internalError = respProps.getProperty("internal-error", "false");
2099 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2101 responseBuilder.setResponseCode(errorCode);
2102 responseBuilder.setResponseMessage(errorMessage);
2103 responseBuilder.setAckFinalIndicator(ackFinal);
2105 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2106 vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2107 vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2108 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadDataBuilder.build());
2110 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2111 + errorCode + "', Reason: '" + errorMessage + "'");
2113 SaveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), true,
2114 LogicalDatastoreType.CONFIGURATION);
2115 } catch (Exception e) {
2117 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2120 log.debug("Sending Success rpc result due to external error");
2121 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2122 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2123 .withResult(responseBuilder.build()).build();
2124 return Futures.immediateFuture(rpcResult);
2127 // Got success from SLI
2129 vnfInstancePreloadData = vnfInstancePreloadDataBuilder.build();
2131 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2132 + vnfInstancePreloadData);
2133 // svc-configuration-list
2134 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2135 vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2136 vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2137 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadData);
2139 // SDNGC-989 set merge flag to false
2140 SaveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false,
2141 LogicalDatastoreType.CONFIGURATION);
2142 log.info("Updating OPERATIONAL tree.");
2143 SaveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2144 } catch (Exception e) {
2145 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2147 responseBuilder.setResponseCode("500");
2148 responseBuilder.setResponseMessage(e.toString());
2149 responseBuilder.setAckFinalIndicator("Y");
2150 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2151 + responseBuilder.build());
2152 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2153 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(false)
2154 .withResult(responseBuilder.build()).build();
2155 return Futures.immediateFuture(rpcResult);
2159 responseBuilder.setResponseCode(errorCode);
2160 responseBuilder.setAckFinalIndicator(ackFinal);
2161 if (errorMessage != null) {
2162 responseBuilder.setResponseMessage(errorMessage);
2164 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2166 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2169 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2170 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2172 return Futures.immediateFuture(rpcResult);
2176 //1610 preload-vf-module-topology-operation
2177 @Override public Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2178 PreloadVfModuleTopologyOperationInput input) {
2180 final String SVC_OPERATION = "preload-vf-module-topology-operation";
2181 VfModulePreloadData vfModulePreloadData = null;
2182 Properties parms = new Properties();
2184 log.info(SVC_OPERATION + " called.");
2185 // create a new response object
2186 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder =
2187 new PreloadVfModuleTopologyOperationOutputBuilder();
2189 // Result from savePreloadData
2190 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2192 if (input == null || input.getVfModuleTopologyInformation() == null
2193 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName() == null
2194 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId() == null) {
2195 log.debug("exiting " + SVC_OPERATION
2196 + " because of invalid input, null or empty vnf-instance-name and vnf-model-id");
2197 responseBuilder.setResponseCode("403");
2198 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name and vnf-model-id");
2199 responseBuilder.setAckFinalIndicator("Y");
2200 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2201 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2202 .withResult(responseBuilder.build()).build();
2203 return Futures.immediateFuture(rpcResult);
2206 // Grab the name and type from the input buffer
2207 String preload_name = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName();
2208 String preload_type = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId();
2210 // Make sure we have a preload_name and preload_type
2211 if (preload_name == null || preload_name.length() == 0) {
2212 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
2213 responseBuilder.setResponseCode("403");
2214 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2215 responseBuilder.setAckFinalIndicator("Y");
2216 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2217 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2218 .withResult(responseBuilder.build()).build();
2219 return Futures.immediateFuture(rpcResult);
2221 if (preload_type == null || preload_type.length() == 0) {
2222 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
2223 responseBuilder.setResponseCode("403");
2224 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2225 responseBuilder.setAckFinalIndicator("Y");
2226 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2227 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2228 .withResult(responseBuilder.build()).build();
2229 return Futures.immediateFuture(rpcResult);
2232 if (input.getSdncRequestHeader() != null) {
2233 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2234 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2237 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
2238 getVfModulePreloadData(preload_name, preload_type, vfModulePreloadDataBuilder);
2239 //preloadData = preloadDataBuilder.build();
2241 VfModulePreloadDataBuilder operDataBuilder = new VfModulePreloadDataBuilder();
2242 getVfModulePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2245 // setup a preload-data object builder
2246 // ACTION vnf-topology-operation
2248 // USES sdnc-request-header;
2249 // USES request-information;
2250 // uses vnf-topology-information;
2252 // USES vnf-topology-response-body;
2254 // container preload-data
2255 // uses vnf-configuration-information;
2258 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2259 PreloadVfModuleTopologyOperationInputBuilder inputBuilder =
2260 new PreloadVfModuleTopologyOperationInputBuilder(input);
2261 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2262 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2263 + "] operational-data: " + operDataBuilder.build());
2264 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2266 // Call SLI sync method
2267 // Get SvcLogicService reference
2268 Properties respProps = null;
2269 String errorCode = "200";
2270 String errorMessage = null;
2271 String ackFinal = "Y";
2274 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2276 respProps = svcLogicClient
2277 .execute("VNF-API", SVC_OPERATION, null, "sync", vfModulePreloadDataBuilder, parms);
2278 } catch (Exception e) {
2279 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2280 errorMessage = e.getMessage();
2284 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2287 } catch (Exception e) {
2289 errorMessage = e.getMessage();
2290 log.error("Caught exception looking for service logic", e);
2293 if (respProps != null) {
2294 errorCode = respProps.getProperty("error-code");
2295 errorMessage = respProps.getProperty("error-message");
2296 ackFinal = respProps.getProperty("ack-final", "Y");
2297 // internalError = respProps.getProperty("internal-error", "false");
2300 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2302 responseBuilder.setResponseCode(errorCode);
2303 responseBuilder.setResponseMessage(errorMessage);
2304 responseBuilder.setAckFinalIndicator(ackFinal);
2306 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2307 vfModulePreloadListBuilder.setVfModuleName(preload_name);
2308 vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2309 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadDataBuilder.build());
2311 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2312 + errorCode + "', Reason: '" + errorMessage + "'");
2314 SaveVfModulePreloadList(vfModulePreloadListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2315 } catch (Exception e) {
2317 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2320 log.debug("Sending Success rpc result due to external error");
2321 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2322 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2323 .withResult(responseBuilder.build()).build();
2324 return Futures.immediateFuture(rpcResult);
2327 // Got success from SLI
2329 vfModulePreloadData = vfModulePreloadDataBuilder.build();
2331 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2332 + vfModulePreloadData);
2333 // svc-configuration-list
2334 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2335 vfModulePreloadListBuilder.setVfModuleName(preload_name);
2336 vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2337 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadData);
2339 // SDNGC-989 set merge flag to false
2340 SaveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2341 log.info("Updating OPERATIONAL tree.");
2342 SaveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2343 } catch (Exception e) {
2344 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2346 responseBuilder.setResponseCode("500");
2347 responseBuilder.setResponseMessage(e.toString());
2348 responseBuilder.setAckFinalIndicator("Y");
2349 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2350 + responseBuilder.build());
2351 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2352 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(false)
2353 .withResult(responseBuilder.build()).build();
2354 return Futures.immediateFuture(rpcResult);
2358 responseBuilder.setResponseCode(errorCode);
2359 responseBuilder.setAckFinalIndicator(ackFinal);
2360 if (errorMessage != null) {
2361 responseBuilder.setResponseMessage(errorMessage);
2363 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2365 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2368 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2369 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2371 return Futures.immediateFuture(rpcResult);
2375 @Override public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2376 PreloadNetworkTopologyOperationInput input) {
2378 final String SVC_OPERATION = "preload-network-topology-operation";
2379 PreloadData preloadData = null;
2380 Properties parms = new Properties();
2382 log.info(SVC_OPERATION + " called.");
2383 // create a new response object
2384 PreloadNetworkTopologyOperationOutputBuilder responseBuilder =
2385 new PreloadNetworkTopologyOperationOutputBuilder();
2387 // Result from savePreloadData
2388 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2390 if (input == null || input.getNetworkTopologyInformation() == null
2391 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null
2392 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName() == null
2393 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType() == null) {
2394 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vnf-name and vnf-type");
2395 responseBuilder.setResponseCode("403");
2396 responseBuilder.setResponseMessage("input, null or empty vnf-name and vnf-type");
2397 responseBuilder.setAckFinalIndicator("Y");
2398 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2399 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2401 return Futures.immediateFuture(rpcResult);
2404 // Grab the name and type from the input buffer
2405 String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2406 String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2408 // Make sure we have a preload_name and preload_type
2409 if (preload_name == null || preload_name.length() == 0) {
2410 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
2411 responseBuilder.setResponseCode("403");
2412 responseBuilder.setResponseMessage("input, invalid preload-name");
2413 responseBuilder.setAckFinalIndicator("Y");
2414 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2415 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2417 return Futures.immediateFuture(rpcResult);
2420 if (preload_type == null || preload_type.length() == 0) {
2421 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
2422 responseBuilder.setResponseCode("403");
2423 responseBuilder.setResponseMessage("input, invalid preload-type");
2424 responseBuilder.setAckFinalIndicator("Y");
2425 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2426 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2428 return Futures.immediateFuture(rpcResult);
2431 if (input.getSdncRequestHeader() != null) {
2432 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2433 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2436 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2437 getPreloadData(preload_name, preload_type, preloadDataBuilder);
2439 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2440 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2443 // setup a preload-data object builder
2444 // ACTION vnf-topology-operation
2446 // USES sdnc-request-header;
2447 // USES request-information;
2448 // uses vnf-topology-information;
2450 // USES vnf-topology-response-body;
2452 // container preload-data
2453 // uses vnf-configuration-information;
2455 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2456 PreloadNetworkTopologyOperationInputBuilder inputBuilder =
2457 new PreloadNetworkTopologyOperationInputBuilder(input);
2458 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2459 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2460 + "] operational-data: " + operDataBuilder.build());
2461 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2463 // Call SLI sync method
2464 // Get SvcLogicService reference
2465 Properties respProps = null;
2466 String errorCode = "200";
2467 String errorMessage = null;
2468 String ackFinal = "Y";
2471 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2474 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2475 } catch (Exception e) {
2476 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2477 errorMessage = e.getMessage();
2481 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2484 } catch (Exception e) {
2486 errorMessage = e.getMessage();
2487 log.error("Caught exception looking for service logic", e);
2491 if (respProps != null) {
2492 errorCode = respProps.getProperty("error-code");
2493 errorMessage = respProps.getProperty("error-message");
2494 ackFinal = respProps.getProperty("ack-final", "Y");
2495 // internalError = respProps.getProperty("internal-error", "false");
2498 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2499 responseBuilder.setResponseCode(errorCode);
2500 responseBuilder.setResponseMessage(errorMessage);
2501 responseBuilder.setAckFinalIndicator(ackFinal);
2503 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2504 preloadVnfListBuilder.setVnfName(preload_name);
2505 preloadVnfListBuilder.setVnfType(preload_type);
2506 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2508 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2509 + errorCode + "', Reason: '" + errorMessage + "'");
2511 SavePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2512 } catch (Exception e) {
2514 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2518 log.debug("Sending Success rpc result due to external error");
2519 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2520 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2522 return Futures.immediateFuture(rpcResult);
2525 // Got success from SLI
2527 preloadData = preloadDataBuilder.build();
2529 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2531 // svc-configuration-list
2532 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2533 preloadVnfListBuilder.setVnfName(preload_name);
2534 preloadVnfListBuilder.setVnfType(preload_type);
2535 preloadVnfListBuilder.setPreloadData(preloadData);
2537 // SDNGC-989 set merge flag to false
2538 SavePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2539 log.info("Updating OPERATIONAL tree.");
2540 SavePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2541 } catch (Exception e) {
2542 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2544 responseBuilder.setResponseCode("500");
2545 responseBuilder.setResponseMessage(e.toString());
2546 responseBuilder.setAckFinalIndicator("Y");
2547 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2548 + responseBuilder.build());
2549 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2550 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(false)
2551 .withResult(responseBuilder.build()).build();
2552 return Futures.immediateFuture(rpcResult);
2556 responseBuilder.setResponseCode(errorCode);
2557 responseBuilder.setAckFinalIndicator(ackFinal);
2558 if (errorMessage != null) {
2559 responseBuilder.setResponseMessage(errorMessage);
2561 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2563 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2566 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2567 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2569 return Futures.immediateFuture(rpcResult);