2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights
7 * ================================================================================
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 * ============LICENSE_END=========================================================
22 package org.onap.sdnc.vnfapi;
24 import com.google.common.util.concurrent.CheckedFuture;
25 import com.google.common.util.concurrent.FutureCallback;
26 import com.google.common.util.concurrent.Futures;
27 import com.google.common.util.concurrent.SettableFuture;
28 import com.google.common.base.Optional;
29 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
30 import org.opendaylight.controller.md.sal.binding.api.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.yang.binding.DataObject;
130 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
131 import org.opendaylight.yangtools.yang.common.RpcResult;
132 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
133 import org.opendaylight.yangtools.yang.data.api.schema.tree.ModifiedNodeDoesNotExistException;
134 import org.slf4j.Logger;
135 import org.slf4j.LoggerFactory;
136 import org.slf4j.MDC;
139 import java.text.DateFormat;
140 import java.text.SimpleDateFormat;
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.ArrayList;
148 import java.util.concurrent.Future;
151 * Defines a base implementation for your provider. This class extends from a helper class which provides storage for
152 * the most commonly used components of the MD-SAL. Additionally the base class provides some basic logging and
153 * initialization / clean up methods.
155 public class VnfApiProvider implements AutoCloseable, VNFAPIService, DataChangeListener {
157 private final Logger log = LoggerFactory.getLogger(VnfApiProvider.class);
158 private final ExecutorService executor;
160 private static final String APP_NAME = "vnfapi";
161 private static final String VNF_API = "VNF-API";
162 private static final String OPERATIONAL_DATA = "operational-data";
163 private static final String SVC_OPERATION = "vf-module-topology-operation";
165 private static final String READ_MD_SAL_STR = "Read MD-SAL (";
166 private static final String DATA_FOR_STR = ") data for [";
167 private static final String SERVICE_DATA_STR = "] ServiceData: ";
168 private static final String NO_DATA_FOUND_STR = "No data found in MD-SAL (";
169 private static final String EXCEPTION_READING_MD_SAL_STR = "Caught Exception reading MD-SAL (";
170 private static final String FOR_STR = ") for [";
171 private static final String INVALID_INPUT_VF_MODULE_STR = "invalid input, null or empty vf-module-id";
172 private static final String UPDATED_MD_SAL_STR = "Updated MD-SAL for ";
173 private static final String RETURNED_SUCCESS_STR = "Returned SUCCESS for ";
174 private static final String UPDATING_OPERATIONAL_TREE_STR = "Updating OPERATIONAL tree.";
175 private static final String UPDATING_MD_SAL_STR = "Updating MD-SAL for ";
176 private static final String CAUGHT_EXCEPTION_STR = "Caught Exception updating MD-SAL for ";
177 private static final String RETURNED_FAILED_STR = "Returned FAILED for ";
178 private static final String ADDING_INPUT_DATA_STR = "Adding INPUT data for ";
179 private static final String ADDING_OPERATIONAL_DATA_STR = "Adding OPERATIONAL data for ";
180 private static final String OPERATIONAL_DATA_STR = "] operational-data: ";
181 private static final String ADDING_CONFIG_DATA_STR = "Adding CONFIG data for ";
182 private static final String INPUT_STR = "] input: ";
183 private static final String CALLED_STR = " called.";
184 private static final String EXITING_STR = "exiting ";
185 private static final String INVALID_INPUT_VNF_INSTANCE_STR = "invalid input, null or empty vnf-instance-id";
187 private VNFSDNSvcLogicServiceClient svcLogicClient;
189 protected DataBroker dataBroker;
190 protected NotificationPublishService notificationService;
191 protected RpcProviderRegistry rpcRegistry;
192 protected BindingAwareBroker.RpcRegistration<VNFAPIService> rpcRegistration;
194 public VnfApiProvider(DataBroker dataBroker2, NotificationPublishService notificationPublishService,
195 RpcProviderRegistry rpcProviderRegistry, VNFSDNSvcLogicServiceClient client) {
196 log.info("Creating provider for " + APP_NAME);
197 executor = Executors.newFixedThreadPool(1);
198 dataBroker = dataBroker2;
199 notificationService = notificationPublishService;
200 rpcRegistry = rpcProviderRegistry;
201 svcLogicClient = client;
205 private void initialize() {
206 log.info("Initializing provider for " + APP_NAME);
207 // Create the top level containers
210 VnfSdnUtil.loadProperties();
211 } catch (Exception e) {
212 log.error("Caught Exception while trying to load properties file: ", e);
215 log.info("Initialization complete for " + APP_NAME);
218 private void createContainers() {
219 final WriteTransaction t = dataBroker.newReadWriteTransaction();
221 // Create the Vnfs container
222 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
223 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
225 // Create the PreloadVnfs container
226 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
227 new PreloadVnfsBuilder().build());
228 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
229 new PreloadVnfsBuilder().build());
231 // 1610 Create the PreloadVnfInstances container
232 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfInstances.class),
233 new PreloadVnfInstancesBuilder().build());
234 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfInstances.class),
235 new PreloadVnfInstancesBuilder().build());
237 // 1610 Create the VnfInstances container
238 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VnfInstances.class),
239 new VnfInstancesBuilder().build());
240 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VnfInstances.class),
241 new VnfInstancesBuilder().build());
243 // 1610 Create the PreloadVfModules container
244 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVfModules.class),
245 new PreloadVfModulesBuilder().build());
246 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVfModules.class),
247 new PreloadVfModulesBuilder().build());
249 // 1610 Create the VfModules container
250 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VfModules.class),
251 new VfModulesBuilder().build());
252 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VfModules.class),
253 new VfModulesBuilder().build());
256 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
258 log.info("Create Containers succeeded!: ");
260 } catch (InterruptedException | ExecutionException e) {
261 log.error("Create Containers Failed: " + e);
266 public void close() throws Exception {
267 log.info("Closing provider for " + APP_NAME);
269 rpcRegistration.close();
270 log.info("Successfully closed provider for " + APP_NAME);
273 // On data change not used
275 public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
277 log.info(" IN ON DATA CHANGE: ");
279 boolean changed = false;
280 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
281 DataObject updatedSubTree = change.getUpdatedSubtree();
283 if (updatedSubTree != null) {
284 if (log.isDebugEnabled()) {
285 log.debug("updatedSubTree was non-null:" + updatedSubTree);
287 if (updatedSubTree instanceof Vnfs) {
288 changed = isChanged(changed, (Vnfs) updatedSubTree);
290 if (updatedSubTree instanceof PreloadVnfs) {
291 changed = isChanged(changed, (PreloadVnfs) updatedSubTree);
294 if (updatedSubTree instanceof PreloadVnfInstances) {
295 changed = isChanged(changed, (PreloadVnfInstances) updatedSubTree);
298 if (updatedSubTree instanceof VnfInstances) {
299 changed = isChanged(changed, (VnfInstances) updatedSubTree);
302 if (updatedSubTree instanceof PreloadVfModules) {
303 changed = isChanged(changed, (PreloadVfModules) updatedSubTree);
306 if (updatedSubTree instanceof VfModules) {
307 changed = isChanged(changed, (VfModules) updatedSubTree);
311 // Do the write transaction only if something changed.
313 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = writeTransaction.submit();
314 Futures.addCallback(checkedFuture, new FutureCallback<Void>() {
317 public void onSuccess(Void arg0) {
318 log.debug("Successfully updated Service Status");
322 public void onFailure(Throwable e) {
323 log.debug("Failed updating Service Status", e);
329 private boolean isChanged(boolean changed, VfModules updatedSubTree) {
330 ArrayList<VfModuleList> vfModuleList =
331 (ArrayList<VfModuleList>) updatedSubTree.getVfModuleList();
332 if (vfModuleList != null) {
333 for (VfModuleList entry : vfModuleList) {
334 VfModuleServiceData vfModuleServiceData = entry.getVfModuleServiceData();
335 ServiceStatus serviceStatus = entry.getServiceStatus();
336 if (vfModuleServiceData != null && serviceStatus != null) {
337 // VfModuleServiceData change detected, check the AckFinal indicator and request-status to
338 // see if we need to proceed.
339 return isChanged(changed, serviceStatus);
346 private boolean isChanged(boolean changed, PreloadVfModules updatedSubTree) {
347 ArrayList<VfModulePreloadList> vnfInstanceList =
348 (ArrayList<VfModulePreloadList>) updatedSubTree.getVfModulePreloadList();
349 if (vnfInstanceList != null) {
350 for (VfModulePreloadList entry : vnfInstanceList) {
351 VfModulePreloadData vnfInstancePreloadData = entry.getVfModulePreloadData();
352 if (vnfInstancePreloadData != null) {
360 private boolean isChanged(boolean changed, VnfInstances updatedSubTree) {
361 ArrayList<VnfInstanceList> vnfInstanceList =
362 (ArrayList<VnfInstanceList>) updatedSubTree.getVnfInstanceList();
363 if (vnfInstanceList != null) {
364 for (VnfInstanceList entry : vnfInstanceList) {
365 VnfInstanceServiceData vnfInstanceServiceData = entry.getVnfInstanceServiceData();
366 ServiceStatus serviceStatus = entry.getServiceStatus();
367 if (vnfInstanceServiceData != null && serviceStatus != null) {
368 // VnfInstanceServiceData change detected, check the AckFinal indicator and request-status
369 // to see if we need to proceed.
370 return isChanged(changed, serviceStatus);
377 private boolean isChanged(boolean changed, PreloadVnfInstances updatedSubTree) {
378 ArrayList<VnfInstancePreloadList> vnfInstanceList =
379 (ArrayList<VnfInstancePreloadList>) updatedSubTree
380 .getVnfInstancePreloadList();
381 if (vnfInstanceList != null) {
382 for (VnfInstancePreloadList entry : vnfInstanceList) {
383 VnfInstancePreloadData vnfInstancePreloadData = entry.getVnfInstancePreloadData();
384 if (vnfInstancePreloadData != null) {
392 private boolean isChanged(boolean changed, PreloadVnfs updatedSubTree) {
393 ArrayList<VnfPreloadList> vnfList =
394 (ArrayList<VnfPreloadList>) updatedSubTree.getVnfPreloadList();
395 if (vnfList != null) {
396 for (VnfPreloadList entry : vnfList) {
397 PreloadData preloadData = entry.getPreloadData();
398 if (preloadData != null) {
406 private boolean isChanged(boolean changed, Vnfs updatedSubTree) {
407 ArrayList<VnfList> vnfList = (ArrayList<VnfList>) updatedSubTree.getVnfList();
408 if (vnfList != null) {
409 for (VnfList entry : vnfList) {
410 ServiceData serviceData = entry.getServiceData();
411 ServiceStatus serviceStatus = entry.getServiceStatus();
412 if (serviceData != null && serviceStatus != null) {
414 // ServiceData change detected, check the AckFinal indicator and request-status to see if we need to proceed.
416 return isChanged(changed, serviceStatus);
423 private boolean isChanged(boolean changed, ServiceStatus serviceStatus) {
424 if ((!"Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete
425 .equals(serviceStatus.getRequestStatus()))) {
426 if (log.isDebugEnabled()) {
427 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
434 private static class Iso8601Util {
437 private static TimeZone tz = TimeZone.getTimeZone("UTC");
438 private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
440 private Iso8601Util() {
447 private static String now() {
448 return df.format(new Date());
452 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
454 serviceStatusBuilder.setResponseCode(errorCode);
455 serviceStatusBuilder.setResponseMessage(errorMessage);
456 serviceStatusBuilder.setFinalIndicator(ackFinal);
457 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
460 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
461 if (requestInformation != null && requestInformation.getRequestAction() != null) {
462 switch (requestInformation.getRequestAction()) {
463 case VNFActivateRequest:
464 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VNFActivateRequest);
466 case ChangeVNFActivateRequest:
467 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVNFActivateRequest);
469 case DisconnectVNFRequest:
470 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVNFRequest);
472 case PreloadVNFRequest:
473 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVNFRequest);
475 case DeletePreloadVNFRequest:
476 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DeletePreloadVNFRequest);
478 // 1610 vnf-instance Requests
479 case VnfInstanceActivateRequest:
480 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VnfInstanceActivateRequest);
482 case ChangeVnfInstanceActivateRequest:
483 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVnfInstanceActivateRequest);
485 case DisconnectVnfInstanceRequest:
486 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVnfInstanceRequest);
488 case PreloadVnfInstanceRequest:
489 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVnfInstanceRequest);
491 // 1610 vf-module Requests
492 case VfModuleActivateRequest:
493 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VfModuleActivateRequest);
495 case ChangeVfModuleActivateRequest:
496 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVfModuleActivateRequest);
498 case DisconnectVfModuleRequest:
499 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVfModuleRequest);
501 case PreloadVfModuleRequest:
502 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVfModuleRequest);
505 log.error("Unknown RequestAction: " + requestInformation.getRequestAction());
509 if (requestInformation != null && requestInformation.getRequestSubAction() != null) {
510 switch (requestInformation.getRequestSubAction()) {
512 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP);
515 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
518 log.error("Unknown RequestSubAction: " + requestInformation.getRequestSubAction());
524 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
525 if (requestHeader != null && requestHeader.getSvcAction() != null) {
526 switch (requestHeader.getSvcAction()) {
528 serviceStatusBuilder.setRpcAction(RpcAction.Reserve);
531 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
534 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
537 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
540 serviceStatusBuilder.setRpcAction(RpcAction.Changeassign);
543 serviceStatusBuilder.setRpcAction(RpcAction.Changedelete);
546 serviceStatusBuilder.setRpcAction(RpcAction.Rollback);
549 log.error("Unknown SvcAction: " + requestHeader.getSvcAction());
555 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
557 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
561 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
562 // See if any data exists yet for this siid, if so grab it.
563 InstanceIdentifier<VnfList> serviceInstanceIdentifier = InstanceIdentifier
565 .child(VnfList.class, new VnfListKey(siid))
568 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
569 Optional<VnfList> data = Optional.absent();
571 data = readTx.read(type, serviceInstanceIdentifier).get();
572 } catch (InterruptedException | ExecutionException e) {
573 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
576 if (data.isPresent()) {
577 ServiceData serviceData = (ServiceData) data.get().getServiceData();
578 if (serviceData != null) {
579 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + siid + SERVICE_DATA_STR + serviceData);
580 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
581 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
582 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
583 serviceDataBuilder.setVnfRequestInformation(serviceData.getVnfRequestInformation());
584 serviceDataBuilder.setVnfId(serviceData.getVnfId());
585 serviceDataBuilder.setVnfTopologyInformation(serviceData.getVnfTopologyInformation());
586 serviceDataBuilder.setOperStatus(serviceData.getOperStatus());
588 log.info("No service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
591 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
596 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder) {
598 getVnfInstanceServiceData(siid, vnfInstanceServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
602 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder,
603 LogicalDatastoreType type) {
604 // See if any data exists yet for this siid, if so grab it.
605 InstanceIdentifier<VnfInstanceList> vnfInstanceIdentifier = InstanceIdentifier
606 .builder(VnfInstances.class)
607 .child(VnfInstanceList.class, new VnfInstanceListKey(siid))
610 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
611 Optional<VnfInstanceList> data = Optional.absent();
613 data = readTx.read(type, vnfInstanceIdentifier).get();
614 } catch (InterruptedException | ExecutionException e) {
615 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
618 if (data.isPresent()) {
619 VnfInstanceServiceData vnfInstanceServiceData =
620 (VnfInstanceServiceData) data.get().getVnfInstanceServiceData();
621 if (vnfInstanceServiceData != null) {
622 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + siid + "] VnfInstanceServiceData: "
623 + vnfInstanceServiceData);
624 vnfInstanceServiceDataBuilder.setSdncRequestHeader(vnfInstanceServiceData.getSdncRequestHeader());
625 vnfInstanceServiceDataBuilder.setRequestInformation(vnfInstanceServiceData.getRequestInformation());
626 vnfInstanceServiceDataBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
627 vnfInstanceServiceDataBuilder
628 .setVnfInstanceRequestInformation(vnfInstanceServiceData.getVnfInstanceRequestInformation());
629 vnfInstanceServiceDataBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
630 vnfInstanceServiceDataBuilder
631 .setVnfInstanceTopologyInformation(vnfInstanceServiceData.getVnfInstanceTopologyInformation());
632 vnfInstanceServiceDataBuilder.setOperStatus(vnfInstanceServiceData.getOperStatus());
634 log.info("No vnf-instance-service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
637 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
642 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder) {
644 getVfModuleServiceData(siid, vfModuleServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
648 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder,
649 LogicalDatastoreType type) {
650 // See if any data exists yet for this siid, if so grab it.
651 InstanceIdentifier<VfModuleList> vfModuleIdentifier = InstanceIdentifier
652 .builder(VfModules.class)
653 .child(VfModuleList.class, new VfModuleListKey(siid))
656 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
657 Optional<VfModuleList> data = Optional.absent();
659 data = readTx.read(type, vfModuleIdentifier).get();
660 } catch (InterruptedException | ExecutionException e) {
661 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
664 if (data.isPresent()) {
665 VfModuleServiceData vfModuleServiceData = data.get().getVfModuleServiceData();
666 if (vfModuleServiceData != null) {
668 READ_MD_SAL_STR + type + DATA_FOR_STR + siid + "] VfModuleServiceData: " + vfModuleServiceData);
669 vfModuleServiceDataBuilder.setSdncRequestHeader(vfModuleServiceData.getSdncRequestHeader());
670 vfModuleServiceDataBuilder.setRequestInformation(vfModuleServiceData.getRequestInformation());
671 vfModuleServiceDataBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
672 vfModuleServiceDataBuilder
673 .setVfModuleRequestInformation(vfModuleServiceData.getVfModuleRequestInformation());
674 vfModuleServiceDataBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
675 vfModuleServiceDataBuilder
676 .setVfModuleTopologyInformation(vfModuleServiceData.getVfModuleTopologyInformation());
677 vfModuleServiceDataBuilder.setOperStatus(vfModuleServiceData.getOperStatus());
679 log.info("No vf-module-service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
682 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
687 private void getPreloadData(String vnfName, String vnfType, PreloadDataBuilder preloadDataBuilder) {
689 getPreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
692 private void getPreloadData(String preloadName, String preloadType, PreloadDataBuilder preloadDataBuilder,
693 LogicalDatastoreType type) {
694 // See if any data exists yet for this name/type, if so grab it.
695 InstanceIdentifier<VnfPreloadList> preloadInstanceIdentifier = InstanceIdentifier
696 .builder(PreloadVnfs.class)
697 .child(VnfPreloadList.class, new VnfPreloadListKey(preloadName, preloadType))
700 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
701 Optional<VnfPreloadList> data = Optional.absent();
703 data = readTx.read(type, preloadInstanceIdentifier).get();
704 } catch (InterruptedException | ExecutionException e) {
705 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ",
709 if (data.isPresent()) {
710 PreloadData preloadData = (PreloadData) data.get().getPreloadData();
711 if (preloadData != null) {
712 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType + "] PreloadData: "
714 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
715 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
716 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
719 "No preload-data found in MD-SAL (" + type + FOR_STR + preloadName + "," + preloadType + "] ");
722 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
726 //1610 preload-vnf-instance
727 private void getVnfInstancePreloadData(String vnfName, String vnfType,
728 VnfInstancePreloadDataBuilder preloadDataBuilder) {
730 getVnfInstancePreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
733 //1610 preload-vnf-instance
734 private void getVnfInstancePreloadData(String preloadName, String preloadType,
735 VnfInstancePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
736 // See if any data exists yet for this name/type, if so grab it.
737 InstanceIdentifier<VnfInstancePreloadList> preloadInstanceIdentifier = InstanceIdentifier
738 .builder(PreloadVnfInstances.class)
739 .child(VnfInstancePreloadList.class, new VnfInstancePreloadListKey(preloadName, preloadType))
742 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
743 Optional<VnfInstancePreloadList> data = Optional.absent();
745 data = readTx.read(type, preloadInstanceIdentifier).get();
746 } catch (InterruptedException | ExecutionException e) {
747 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ",
751 if (data.isPresent()) {
752 VnfInstancePreloadData preloadData = (VnfInstancePreloadData) data.get().getVnfInstancePreloadData();
753 if (preloadData != null) {
754 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType
755 + "] VnfInstancePreloadData: " + preloadData);
756 preloadDataBuilder.setVnfInstanceTopologyInformation(preloadData.getVnfInstanceTopologyInformation());
757 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
759 log.info("No vnf-instance-preload-data found in MD-SAL (" + type + FOR_STR + preloadName + ","
760 + preloadType + "] ");
763 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
767 // 1610 preload-vf-module
768 private void getVfModulePreloadData(String vnfName, String vnfType,
769 VfModulePreloadDataBuilder preloadDataBuilder) {
771 getVfModulePreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
774 private void getVfModulePreloadData(String preloadName, String preloadType,
775 VfModulePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
776 // See if any data exists yet for this name/type, if so grab it.
777 InstanceIdentifier<VfModulePreloadList> preloadInstanceIdentifier = InstanceIdentifier
778 .builder(PreloadVfModules.class)
779 .child(VfModulePreloadList.class, new VfModulePreloadListKey(preloadName, preloadType))
782 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
783 Optional<VfModulePreloadList> data = Optional.absent();
786 data = readTx.read(type, preloadInstanceIdentifier).get();
787 } catch (InterruptedException | ExecutionException e) {
788 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ",
792 if (data.isPresent()) {
793 VfModulePreloadData preloadData = (VfModulePreloadData) data.get().getVfModulePreloadData();
794 if (preloadData != null) {
795 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType
796 + "] VfModulePreloadData: " + preloadData);
797 preloadDataBuilder.setVfModuleTopologyInformation(preloadData.getVfModuleTopologyInformation());
798 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
801 "No preload-data found in MD-SAL (" + type + FOR_STR + preloadName + "," + preloadType + "] ");
804 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
808 private void deleteVnfList(final VnfList entry, LogicalDatastoreType storeType) {
809 // Each entry will be identifiable by a unique key, we have to create that identifier
810 InstanceIdentifier<VnfList> path = InstanceIdentifier
812 .child(VnfList.class, entry.getKey())
816 int optimisticLockTries = 2;
817 boolean tryAgain = true;
821 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
822 tx.delete(storeType, path);
823 tx.submit().checkedGet();
824 log.debug("DataStore delete succeeded");
825 } catch (OptimisticLockFailedException e) {
826 if (--optimisticLockTries <= 0) {
827 log.debug("Got OptimisticLockFailedException on last try - failing ");
828 throw new IllegalStateException(e);
830 log.debug("Got OptimisticLockFailedException - trying again ");
833 } catch (final TransactionCommitFailedException e) {
835 if (e.getCause() instanceof ModifiedNodeDoesNotExistException) {
836 log.debug("Ignoring MpdifiedNodeDoesNotExistException");
840 log.debug("Delete DataStore failed");
841 throw new IllegalStateException(e);
846 private void saveVnfList(final VnfList entry, boolean merge, LogicalDatastoreType storeType) {
847 // Each entry will be identifiable by a unique key, we have to create that identifier
848 InstanceIdentifier<VnfList> path = InstanceIdentifier
850 .child(VnfList.class, entry.getKey())
853 tryUpdateDataStore(entry, merge, storeType, path);
857 private void saveVnfInstanceList(final VnfInstanceList entry, boolean merge, LogicalDatastoreType storeType) {
858 // Each entry will be identifiable by a unique key, we have to create that identifier
859 InstanceIdentifier<VnfInstanceList> path = InstanceIdentifier
860 .builder(VnfInstances.class)
861 .child(VnfInstanceList.class, entry.getKey())
865 tryUpdateDataStore(entry, merge, storeType, path);
869 private void saveVfModuleList(final VfModuleList entry, boolean merge, LogicalDatastoreType storeType) {
870 // Each entry will be identifiable by a unique key, we have to create that identifier
871 InstanceIdentifier<VfModuleList> path = InstanceIdentifier
872 .builder(VfModules.class)
873 .child(VfModuleList.class, entry.getKey())
876 tryUpdateDataStore(entry, merge, storeType, path);
879 private void savePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) {
881 // Each entry will be identifiable by a unique key, we have to create that identifier
882 InstanceIdentifier<VnfPreloadList> path = InstanceIdentifier
883 .builder(PreloadVnfs.class)
884 .child(VnfPreloadList.class, entry.getKey())
887 tryUpdateDataStore(entry, merge, storeType, path);
890 //1610 preload vnf-instance
891 private void saveVnfInstancePreloadList(final VnfInstancePreloadList entry, boolean merge,
892 LogicalDatastoreType storeType) {
894 // Each entry will be identifiable by a unique key, we have to create that identifier
895 InstanceIdentifier<VnfInstancePreloadList> path = InstanceIdentifier
896 .builder(PreloadVnfInstances.class)
897 .child(VnfInstancePreloadList.class, entry.getKey())
900 tryUpdateDataStore(entry, merge, storeType, path);
903 //1610 preload vf-module
904 private void saveVfModulePreloadList(final VfModulePreloadList entry, boolean merge,
905 LogicalDatastoreType storeType) {
907 // Each entry will be identifiable by a unique key, we have to create that identifier
908 InstanceIdentifier<VfModulePreloadList> path = InstanceIdentifier
909 .builder(PreloadVfModules.class)
910 .child(VfModulePreloadList.class, entry.getKey())
913 tryUpdateDataStore(entry, merge, storeType, path);
916 private <T extends DataObject> void tryUpdateDataStore(T entry, boolean merge, LogicalDatastoreType storeType,
917 InstanceIdentifier<T> path) {
922 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
924 tx.merge(storeType, path, entry);
926 tx.put(storeType, path, entry);
928 tx.submit().checkedGet();
929 log.debug("Update DataStore succeeded");
931 } catch (OptimisticLockFailedException e) {
933 log.debug("Got OptimisticLockFailedException on last try - failing ");
934 throw new IllegalStateException(e);
936 log.debug("Got OptimisticLockFailedException - trying again ");
937 } catch (final TransactionCommitFailedException e) {
938 log.debug("Update DataStore failed");
939 throw new IllegalStateException(e);
944 //Save the requestId into MDC
945 private void setRequestIdAsMDC(String requestId) {
946 MDC.put("RequestId", requestId);
949 //1610 vnf-instance-topology-operation
951 public Future<RpcResult<VnfInstanceTopologyOperationOutput>> vnfInstanceTopologyOperation(
952 VnfInstanceTopologyOperationInput input) {
954 VnfInstanceServiceData vnfInstanceServiceData;
955 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
956 Properties parms = new Properties();
958 log.info(SVC_OPERATION + CALLED_STR);
959 // create a new response object
960 VnfInstanceTopologyOperationOutputBuilder responseBuilder = new VnfInstanceTopologyOperationOutputBuilder();
962 if (input == null || input.getVnfInstanceRequestInformation() == null
963 || input.getVnfInstanceRequestInformation().getVnfInstanceId() == null) {
964 log.debug(EXITING_STR + SVC_OPERATION + " because of " + INVALID_INPUT_VNF_INSTANCE_STR);
965 responseBuilder.setResponseCode("403");
966 responseBuilder.setResponseMessage(INVALID_INPUT_VNF_INSTANCE_STR);
967 responseBuilder.setAckFinalIndicator("Y");
968 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
969 .<VnfInstanceTopologyOperationOutput>status(true)
970 .withResult(responseBuilder.build())
973 return Futures.immediateFuture(rpcResult);
976 // Grab the service instance ID from the input buffer
977 String viid = input.getVnfInstanceRequestInformation().getVnfInstanceId();
978 String preloadName = input.getVnfInstanceRequestInformation().getVnfInstanceName();
979 String preloadType = input.getVnfInstanceRequestInformation().getVnfModelId();
981 // Make sure we have a valid viid
982 if (viid == null || viid.length() == 0) {
983 log.debug(EXITING_STR + SVC_OPERATION + " because of invalid vnf-instance-id");
984 responseBuilder.setResponseCode("403");
985 responseBuilder.setResponseMessage(INVALID_INPUT_VNF_INSTANCE_STR);
986 responseBuilder.setAckFinalIndicator("Y");
987 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
988 .<VnfInstanceTopologyOperationOutput>status(true)
989 .withResult(responseBuilder.build())
992 return Futures.immediateFuture(rpcResult);
995 if (input.getSdncRequestHeader() != null) {
996 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
997 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1000 // Get vnf-instance-preload-data
1001 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
1002 getVnfInstancePreloadData(preloadName, preloadType, vnfInstancePreloadDataBuilder);
1005 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1006 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1008 // Get operational-data
1009 VnfInstanceServiceDataBuilder operDataBuilder = new VnfInstanceServiceDataBuilder();
1010 getVnfInstanceServiceData(viid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1012 // Set the serviceStatus based on input
1013 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1014 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1017 // setup a service-data object builder
1018 // ACTION vnf-topology-operation
1020 // USES sdnc-request-header;
1021 // USES request-information;
1022 // USES service-information;
1023 // USES vnf-request-information
1025 // USES vnf-topology-response-body;
1026 // USES vnf-information
1027 // USES service-information
1029 // container service-data
1030 // uses vnf-configuration-information;
1031 // uses oper-status;
1033 log.info(ADDING_INPUT_DATA_STR + SVC_OPERATION + " [" + viid + INPUT_STR + input);
1034 VnfInstanceTopologyOperationInputBuilder inputBuilder = new VnfInstanceTopologyOperationInputBuilder(input);
1035 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1037 log.info(ADDING_OPERATIONAL_DATA_STR + SVC_OPERATION + " [" + viid + OPERATIONAL_DATA_STR + operDataBuilder
1039 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1042 ADDING_CONFIG_DATA_STR + SVC_OPERATION + " [" + preloadName + "," + preloadType + "] preload-data: "
1043 + vnfInstancePreloadDataBuilder.build());
1044 VnfSdnUtil.toProperties(parms, "vnf-instance-preload-data", vnfInstancePreloadDataBuilder);
1046 // Call SLI sync method
1047 // Get SvcLogicService reference
1048 Properties respProps = null;
1049 String errorCode = "200";
1050 String errorMessage = null;
1051 String ackFinal = "Y";
1054 if (svcLogicClient.hasGraph(VNF_API, SVC_OPERATION, null, "sync")) {
1057 respProps = svcLogicClient
1058 .execute(VNF_API, SVC_OPERATION, null, "sync", vnfInstanceServiceDataBuilder, parms);
1059 } catch (Exception e) {
1060 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1061 errorMessage = e.getMessage();
1065 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1068 } catch (Exception e) {
1070 errorMessage = e.getMessage();
1071 log.error("Caught exception looking for service logic", e);
1074 if (respProps != null) {
1075 errorCode = respProps.getProperty("error-code");
1076 errorMessage = respProps.getProperty("error-message");
1077 ackFinal = respProps.getProperty("ack-final", "Y");
1080 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1081 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1082 serviceStatusBuilder.setRpcName(RpcName.VnfInstanceTopologyOperation);
1084 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1085 responseBuilder.setResponseCode(errorCode);
1086 responseBuilder.setResponseMessage(errorMessage);
1087 responseBuilder.setAckFinalIndicator(ackFinal);
1088 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1089 vnfInstanceListBuilder.setVnfInstanceId(viid);
1090 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1092 saveVnfInstanceList(vnfInstanceListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1093 } catch (Exception e) {
1094 log.error(CAUGHT_EXCEPTION_STR + SVC_OPERATION + " [" + viid + "] \n", e);
1096 log.error(RETURNED_FAILED_STR + SVC_OPERATION + " [" + viid + "] " + responseBuilder.build());
1097 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
1098 .<VnfInstanceTopologyOperationOutput>status(true)
1099 .withResult(responseBuilder.build())
1102 return Futures.immediateFuture(rpcResult);
1105 // Got success from SLI
1107 vnfInstanceServiceData = vnfInstanceServiceDataBuilder.build();
1108 log.info(UPDATING_MD_SAL_STR + SVC_OPERATION + " [" + viid + "] VnfInstanceServiceData: "
1109 + vnfInstanceServiceData);
1110 // svc-configuration-list
1111 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1112 vnfInstanceListBuilder.setVnfInstanceServiceData(vnfInstanceServiceData);
1113 vnfInstanceListBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
1114 //siid = vnfInstanceServiceData.getVnfInstanceId();
1115 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1116 saveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1117 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1118 // Only update operational tree on Delete or Activate
1119 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1120 .getSvcAction().equals(SvcAction.Activate)) {
1121 log.info(UPDATING_OPERATIONAL_TREE_STR);
1122 saveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1125 VnfInstanceInformationBuilder vnfInstanceInformationBuilder = new VnfInstanceInformationBuilder();
1126 vnfInstanceInformationBuilder.setVnfInstanceId(viid);
1127 responseBuilder.setVnfInstanceInformation(vnfInstanceInformationBuilder.build());
1128 responseBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
1129 } catch (Exception e) {
1130 log.error(CAUGHT_EXCEPTION_STR + SVC_OPERATION + " [" + viid + "] \n", e);
1131 responseBuilder.setResponseCode("500");
1132 responseBuilder.setResponseMessage(e.toString());
1133 responseBuilder.setAckFinalIndicator("Y");
1134 log.error(RETURNED_FAILED_STR + SVC_OPERATION + " [" + viid + "] " + responseBuilder.build());
1135 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
1136 .<VnfInstanceTopologyOperationOutput>status(true)
1137 .withResult(responseBuilder.build())
1140 return Futures.immediateFuture(rpcResult);
1144 responseBuilder.setResponseCode(errorCode);
1145 responseBuilder.setAckFinalIndicator(ackFinal);
1146 if (errorMessage != null) {
1147 responseBuilder.setResponseMessage(errorMessage);
1149 log.info(UPDATED_MD_SAL_STR + SVC_OPERATION + " [" + viid + "] ");
1150 log.info(RETURNED_SUCCESS_STR + SVC_OPERATION + " [" + viid + "] " + responseBuilder.build());
1152 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
1153 .<VnfInstanceTopologyOperationOutput>status(true)
1154 .withResult(responseBuilder.build())
1157 return Futures.immediateFuture(rpcResult);
1160 //1610 vf-module-topology-operation
1162 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1163 VfModuleTopologyOperationInput input) {
1165 VfModuleServiceData vfModuleServiceData;
1166 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1167 Properties parms = new Properties();
1169 log.info(SVC_OPERATION + CALLED_STR);
1170 // create a new response object
1171 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1173 // Validate vf-module-id from vf-module-request-information
1174 if (input == null || input.getVfModuleRequestInformation() == null
1175 || input.getVfModuleRequestInformation().getVfModuleId() == null) {
1176 log.debug(EXITING_STR + SVC_OPERATION + " because of invalid input, null or empty vf-module-id");
1177 responseBuilder.setResponseCode("403");
1178 responseBuilder.setResponseMessage(INVALID_INPUT_VF_MODULE_STR);
1179 responseBuilder.setAckFinalIndicator("Y");
1180 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1181 .<VfModuleTopologyOperationOutput>status(true)
1182 .withResult(responseBuilder.build())
1185 return Futures.immediateFuture(rpcResult);
1188 // Grab the vf-module-request-information.vf-module-id from the input buffer
1189 String vfid = input.getVfModuleRequestInformation().getVfModuleId();
1190 String preloadName = input.getVfModuleRequestInformation().getVfModuleName();
1191 String preloadType = input.getVfModuleRequestInformation().getVfModuleModelId();
1193 // Make sure we have a valid siid
1194 if (vfid == null || vfid.length() == 0) {
1195 log.debug(EXITING_STR + SVC_OPERATION + " because of invalid vf-module-id");
1196 responseBuilder.setResponseCode("403");
1197 responseBuilder.setResponseMessage(INVALID_INPUT_VF_MODULE_STR);
1198 responseBuilder.setAckFinalIndicator("Y");
1199 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1200 .<VfModuleTopologyOperationOutput>status(true)
1201 .withResult(responseBuilder.build())
1204 return Futures.immediateFuture(rpcResult);
1207 // 1610 add vf-module-id to vnf-instance-list.vf-module-relationship-list
1208 String viid = input.getVfModuleRequestInformation().getVnfInstanceId();
1210 if (viid == null || viid.length() == 0) {
1211 log.debug(EXITING_STR + SVC_OPERATION + " because of invalid vnf-instance-id");
1212 responseBuilder.setResponseCode("403");
1213 responseBuilder.setResponseMessage(INVALID_INPUT_VNF_INSTANCE_STR);
1214 responseBuilder.setAckFinalIndicator("Y");
1215 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1216 .<VfModuleTopologyOperationOutput>status(true)
1217 .withResult(responseBuilder.build())
1220 return Futures.immediateFuture(rpcResult);
1223 if (input.getSdncRequestHeader() != null) {
1224 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1225 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1228 // Get vf-module-preload-data
1229 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
1230 getVfModulePreloadData(preloadName, preloadType, vfModulePreloadDataBuilder);
1232 // Get vf-module-service-data
1233 VfModuleServiceDataBuilder vfModuleServiceDataBuilder = new VfModuleServiceDataBuilder();
1234 getVfModuleServiceData(vfid, vfModuleServiceDataBuilder);
1236 // Get vf-module operation-data
1237 VfModuleServiceDataBuilder operDataBuilder = new VfModuleServiceDataBuilder();
1238 getVfModuleServiceData(vfid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1240 // save service-data builder object for rollback
1241 VfModuleServiceDataBuilder rb_vfModuleServiceDataBuilder = vfModuleServiceDataBuilder;
1242 VfModuleServiceDataBuilder rb_operDataBuilder = operDataBuilder;
1244 // 1610 Need to pull vnf-instance-list.vf-module-relationship-list from MD-SAL
1245 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1246 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1248 // vnf-instance operational-data
1249 VnfInstanceServiceDataBuilder vnfInstanceOperDataBuilder = new VnfInstanceServiceDataBuilder();
1250 getVnfInstanceServiceData(viid, vnfInstanceOperDataBuilder, LogicalDatastoreType.OPERATIONAL);
1252 // save operational builder object for rollback
1253 VnfInstanceServiceDataBuilder rb_vnfInstanceServiceDataBuilder = vnfInstanceServiceDataBuilder;
1254 VnfInstanceServiceDataBuilder rb_vnfInstanceOperDataBuilder = vnfInstanceOperDataBuilder;
1256 // Set the serviceStatus based on input
1257 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1258 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1261 // setup a service-data object builder
1262 // ACTION vnf-topology-operation
1264 // USES sdnc-request-header;
1265 // USES request-information;
1266 // USES service-information;
1267 // USES vnf-request-information
1269 // USES vnf-topology-response-body;
1270 // USES vnf-information
1271 // USES service-information
1273 // container service-data
1274 // uses vnf-configuration-information;
1275 // uses oper-status;
1277 log.info(ADDING_INPUT_DATA_STR + SVC_OPERATION + " [" + vfid + INPUT_STR + input);
1278 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1279 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1281 log.info(ADDING_OPERATIONAL_DATA_STR + SVC_OPERATION + " [" + vfid + "] vf-module operational-data: "
1282 + operDataBuilder.build());
1283 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1285 log.info(ADDING_CONFIG_DATA_STR + SVC_OPERATION + " [" + preloadName + "," + preloadType
1286 + "] vf-module-preload-data: " + vfModulePreloadDataBuilder.build());
1287 VnfSdnUtil.toProperties(parms, "vf-module-preload-data", vfModulePreloadDataBuilder);
1289 log.info("Adding vnf-instance CONFIG data for " + SVC_OPERATION + " [" + viid + "] vnf-instance-service-data: "
1290 + vnfInstanceServiceDataBuilder.build());
1291 VnfSdnUtil.toProperties(parms, "vnf-instance-service-data", vnfInstanceServiceDataBuilder);
1293 log.info("Adding vnf-instance OPERATIONAL data for " + SVC_OPERATION + " [" + viid
1294 + "] vnf-instance operational-data: " + vnfInstanceOperDataBuilder.build());
1295 VnfSdnUtil.toProperties(parms, "vnf-instance-operational-data", vnfInstanceOperDataBuilder);
1297 // Call SLI sync method
1298 // Get SvcLogicService reference
1300 Properties respProps = null;
1301 String errorCode = "200";
1302 String errorMessage = null;
1303 String ackFinal = "Y";
1306 if (svcLogicClient.hasGraph(VNF_API, SVC_OPERATION, null, "sync")) {
1309 respProps = svcLogicClient
1310 .execute(VNF_API, SVC_OPERATION, null, "sync", vfModuleServiceDataBuilder, parms);
1311 } catch (Exception e) {
1312 log.error("Caught exception executing service logic on vf-module for " + SVC_OPERATION, e);
1313 errorMessage = e.getMessage();
1318 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1321 } catch (Exception e) {
1323 errorMessage = e.getMessage();
1324 log.error("Caught exception looking for service logic", e);
1327 if (respProps != null) {
1328 errorCode = respProps.getProperty("error-code");
1329 errorMessage = respProps.getProperty("error-message");
1330 ackFinal = respProps.getProperty("ack-final", "Y");
1333 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1334 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1335 serviceStatusBuilder.setRpcName(RpcName.VfModuleTopologyOperation);
1337 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1338 responseBuilder.setResponseCode(errorCode);
1339 responseBuilder.setResponseMessage(errorMessage);
1340 responseBuilder.setAckFinalIndicator(ackFinal);
1341 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1342 vfModuleListBuilder.setVfModuleId(vfid);
1343 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1345 saveVfModuleList(vfModuleListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1346 } catch (Exception e) {
1347 log.error(CAUGHT_EXCEPTION_STR + SVC_OPERATION + " [" + vfid + "] \n", e);
1349 log.error(RETURNED_FAILED_STR + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1350 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1351 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1354 return Futures.immediateFuture(rpcResult);
1357 // Got success from SLI
1358 // save vf-module-service-data in MD-SAL
1360 vfModuleServiceData = vfModuleServiceDataBuilder.build();
1362 UPDATING_MD_SAL_STR + SVC_OPERATION + " [" + vfid + "] VfModuleServiceData: " + vfModuleServiceData);
1364 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1365 vfModuleListBuilder.setVfModuleServiceData(vfModuleServiceData);
1366 vfModuleListBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
1367 //vfid = vfModuleServiceData.getVfModuleId();
1368 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1369 saveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1370 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1371 // Only update operational tree on Delete or Activate
1372 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1373 .getSvcAction().equals(SvcAction.Activate)) {
1374 log.info(UPDATING_OPERATIONAL_TREE_STR);
1375 saveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1378 VfModuleInformationBuilder vfModuleInformationBuilder = new VfModuleInformationBuilder();
1379 vfModuleInformationBuilder.setVfModuleId(vfid);
1380 responseBuilder.setVfModuleInformation(vfModuleInformationBuilder.build());
1381 responseBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
1382 } catch (Exception e) {
1383 log.error(CAUGHT_EXCEPTION_STR + SVC_OPERATION + " [" + vfid + "] \n", e);
1384 responseBuilder.setResponseCode("500");
1385 responseBuilder.setResponseMessage(e.toString());
1386 responseBuilder.setAckFinalIndicator("Y");
1387 log.error(RETURNED_FAILED_STR + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1388 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1389 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1392 return Futures.immediateFuture(rpcResult);
1396 responseBuilder.setResponseCode(errorCode);
1397 responseBuilder.setAckFinalIndicator(ackFinal);
1398 if (errorMessage != null) {
1399 responseBuilder.setResponseMessage(errorMessage);
1401 log.info("Updated vf-module in MD-SAL for " + SVC_OPERATION + " [" + vfid + "] ");
1402 log.info(RETURNED_SUCCESS_STR + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1404 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1405 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1407 return Futures.immediateFuture(rpcResult);
1411 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
1412 final String SVC_OPERATION = "vnf-topology-operation";
1413 ServiceData serviceData = null;
1414 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1415 Properties parms = new Properties();
1417 log.info(SVC_OPERATION + " called.");
1418 // create a new response object
1419 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1421 if (input == null || input.getServiceInformation() == null
1422 || input.getServiceInformation().getServiceInstanceId() == null
1423 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1424 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1425 responseBuilder.setResponseCode("403");
1426 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1427 responseBuilder.setAckFinalIndicator("Y");
1428 RpcResult<VnfTopologyOperationOutput> rpcResult =
1429 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1431 return Futures.immediateFuture(rpcResult);
1434 if (input.getVnfRequestInformation() == null || input.getVnfRequestInformation().getVnfId() == null
1435 || input.getVnfRequestInformation().getVnfId().length() == 0) {
1436 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vf-module-id");
1437 responseBuilder.setResponseCode("403");
1438 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1439 responseBuilder.setAckFinalIndicator("Y");
1440 RpcResult<VnfTopologyOperationOutput> rpcResult =
1441 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1443 return Futures.immediateFuture(rpcResult);
1446 // Grab the service instance ID from the input buffer
1447 String siid = input.getVnfRequestInformation().getVnfId();
1448 String preload_name = input.getVnfRequestInformation().getVnfName();
1449 String preload_type = input.getVnfRequestInformation().getVnfType();
1451 if (input.getSdncRequestHeader() != null) {
1452 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1453 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1456 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1457 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1459 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1460 getServiceData(siid, serviceDataBuilder);
1462 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1463 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1465 // Set the serviceStatus based on input
1466 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1467 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1470 // setup a service-data object builder
1471 // ACTION vnf-topology-operation
1473 // USES sdnc-request-header;
1474 // USES request-information;
1475 // USES service-information;
1476 // USES vnf-request-information
1478 // USES vnf-topology-response-body;
1479 // USES vnf-information
1480 // USES service-information
1482 // container service-data
1483 // uses vnf-configuration-information;
1484 // uses oper-status;
1486 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + siid + "] input: " + input);
1487 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1488 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1490 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + siid + "] operational-data: " + operDataBuilder
1492 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1495 "Adding CONFIG data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preload-data: "
1496 + preloadDataBuilder.build());
1497 VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1499 // Call SLI sync method
1500 // Get SvcLogicService reference
1501 Properties respProps = null;
1502 String errorCode = "200";
1503 String errorMessage = null;
1504 String ackFinal = "Y";
1507 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1511 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1512 } catch (Exception e) {
1513 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1514 errorMessage = e.getMessage();
1518 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1521 } catch (Exception e) {
1523 errorMessage = e.getMessage();
1524 log.error("Caught exception looking for service logic", e);
1527 if (respProps != null) {
1528 errorCode = respProps.getProperty("error-code");
1529 errorMessage = respProps.getProperty("error-message");
1530 ackFinal = respProps.getProperty("ack-final", "Y");
1533 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1534 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1535 serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
1537 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1538 responseBuilder.setResponseCode(errorCode);
1539 responseBuilder.setResponseMessage(errorMessage);
1540 responseBuilder.setAckFinalIndicator(ackFinal);
1541 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1542 vnfListBuilder.setVnfId(siid);
1543 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1545 saveVnfList(vnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1546 } catch (Exception e) {
1547 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1549 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1550 RpcResult<VnfTopologyOperationOutput> rpcResult =
1551 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1553 return Futures.immediateFuture(rpcResult);
1556 // Got success from SLI
1558 serviceData = serviceDataBuilder.build();
1559 log.info("Updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] ServiceData: " + serviceData);
1560 // svc-configuration-list
1561 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1562 vnfListBuilder.setServiceData(serviceData);
1563 vnfListBuilder.setVnfId(serviceData.getVnfId());
1564 siid = serviceData.getVnfId();
1565 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1566 saveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1567 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1568 // Only update operational tree on Delete or Activate
1569 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1570 log.info("Updating OPERATIONAL tree.");
1571 saveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1572 } else if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input
1573 .getSdncRequestHeader().getSvcAction().equals(SvcAction.Rollback)) {
1574 log.info("Delete OPERATIONAL tree.");
1575 deleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
1576 deleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
1579 VnfInformationBuilder vnfInformationBuilder = new VnfInformationBuilder();
1580 vnfInformationBuilder.setVnfId(siid);
1581 responseBuilder.setVnfInformation(vnfInformationBuilder.build());
1582 responseBuilder.setServiceInformation(serviceData.getServiceInformation());
1583 } catch (Exception e) {
1584 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1585 responseBuilder.setResponseCode("500");
1586 responseBuilder.setResponseMessage(e.toString());
1587 responseBuilder.setAckFinalIndicator("Y");
1588 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1589 RpcResult<VnfTopologyOperationOutput> rpcResult =
1590 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1592 return Futures.immediateFuture(rpcResult);
1596 responseBuilder.setResponseCode(errorCode);
1597 responseBuilder.setAckFinalIndicator(ackFinal);
1598 if (errorMessage != null) {
1599 responseBuilder.setResponseMessage(errorMessage);
1601 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + siid + "] ");
1602 log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1604 RpcResult<VnfTopologyOperationOutput> rpcResult =
1605 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1607 return Futures.immediateFuture(rpcResult);
1610 @Override public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1611 NetworkTopologyOperationInput input) {
1613 final String SVC_OPERATION = "network-topology-operation";
1614 ServiceData serviceData = null;
1615 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1616 Properties parms = new Properties();
1618 log.info(SVC_OPERATION + " called.");
1619 // create a new response object
1620 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1622 if (input == null || input.getServiceInformation() == null
1623 || input.getServiceInformation().getServiceInstanceId() == null
1624 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1625 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1626 responseBuilder.setResponseCode("403");
1627 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1628 responseBuilder.setAckFinalIndicator("Y");
1629 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1630 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1633 return Futures.immediateFuture(rpcResult);
1636 if (input.getNetworkRequestInformation() == null
1637 || input.getNetworkRequestInformation().getNetworkName() == null) {
1638 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1639 responseBuilder.setResponseCode("403");
1640 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1641 responseBuilder.setAckFinalIndicator("Y");
1642 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1643 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1646 return Futures.immediateFuture(rpcResult);
1649 // Grab the service instance ID from the input buffer
1651 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Assign)) {
1652 siid = input.getNetworkRequestInformation().getNetworkName();
1654 siid = input.getNetworkRequestInformation().getNetworkId();
1656 String preload_name = input.getNetworkRequestInformation().getNetworkName();
1657 String preload_type = input.getNetworkRequestInformation().getNetworkType();
1659 if (input.getSdncRequestHeader() != null) {
1660 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1661 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1664 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1665 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1667 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + siid + "] input: " + input);
1668 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1669 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1671 // Call SLI sync method
1672 // Get SvcLogicService reference
1673 Properties respProps = null;
1674 String errorCode = "200";
1675 String errorMessage = null;
1676 String ackFinal = "Y";
1677 String networkId = "error";
1680 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1684 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1685 } catch (Exception e) {
1686 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1687 errorMessage = e.getMessage();
1691 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1694 } catch (Exception e) {
1696 errorMessage = e.getMessage();
1697 log.error("Caught exception looking for service logic", e);
1700 if (respProps != null) {
1701 errorCode = respProps.getProperty("error-code");
1702 errorMessage = respProps.getProperty("error-message");
1703 ackFinal = respProps.getProperty("ack-final", "Y");
1704 networkId = respProps.getProperty("networkId", "0");
1707 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1708 responseBuilder.setResponseCode(errorCode);
1709 responseBuilder.setResponseMessage(errorMessage);
1710 responseBuilder.setAckFinalIndicator(ackFinal);
1712 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1714 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1715 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1718 return Futures.immediateFuture(rpcResult);
1721 // Got success from SLI
1723 NetworkInformationBuilder networkInformationBuilder = new NetworkInformationBuilder();
1724 networkInformationBuilder.setNetworkId(networkId);
1725 responseBuilder.setNetworkInformation(networkInformationBuilder.build());
1726 responseBuilder.setServiceInformation(input.getServiceInformation());
1727 } catch (IllegalStateException e) {
1728 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1729 responseBuilder.setResponseCode("500");
1730 responseBuilder.setResponseMessage(e.toString());
1731 responseBuilder.setAckFinalIndicator("Y");
1732 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1733 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1734 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1737 return Futures.immediateFuture(rpcResult);
1741 responseBuilder.setResponseCode(errorCode);
1742 responseBuilder.setAckFinalIndicator(ackFinal);
1743 if (errorMessage != null) {
1744 responseBuilder.setResponseMessage(errorMessage);
1746 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + siid + "] ");
1747 log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1749 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1750 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1752 return Futures.immediateFuture(rpcResult);
1755 @Override public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1756 PreloadVnfTopologyOperationInput input) {
1758 final String SVC_OPERATION = "preload-vnf-topology-operation";
1759 PreloadData preloadData = null;
1760 Properties parms = new Properties();
1762 log.info(SVC_OPERATION + " called.");
1763 // create a new response object
1764 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1766 // Result from savePreloadData
1767 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1769 if (input == null || input.getVnfTopologyInformation() == null
1770 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null
1771 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName() == null
1772 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType() == null) {
1773 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vnf-name or vnf-type");
1774 responseBuilder.setResponseCode("403");
1775 responseBuilder.setResponseMessage("invalid input, null or empty vnf-name or vnf-type");
1776 responseBuilder.setAckFinalIndicator("Y");
1777 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1778 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1780 return Futures.immediateFuture(rpcResult);
1783 // Grab the name and type from the input buffer
1784 String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1785 String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1787 // Make sure we have a preload_name and preload_type
1788 if (preload_name == null || preload_name.length() == 0) {
1789 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
1790 responseBuilder.setResponseCode("403");
1791 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1792 responseBuilder.setAckFinalIndicator("Y");
1793 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1794 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1796 return Futures.immediateFuture(rpcResult);
1798 if (preload_type == null || preload_type.length() == 0) {
1799 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
1800 responseBuilder.setResponseCode("403");
1801 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1802 responseBuilder.setAckFinalIndicator("Y");
1803 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1804 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1806 return Futures.immediateFuture(rpcResult);
1809 if (input.getSdncRequestHeader() != null) {
1810 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1811 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1814 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1815 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1816 //preloadData = preloadDataBuilder.build();
1818 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1819 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1822 // setup a preload-data object builder
1823 // ACTION vnf-topology-operation
1825 // USES sdnc-request-header;
1826 // USES request-information;
1827 // uses vnf-topology-information;
1829 // USES vnf-topology-response-body;
1831 // container preload-data
1832 // uses vnf-configuration-information;
1834 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
1835 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1836 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1837 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1838 + "] operational-data: " + operDataBuilder.build());
1839 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1841 // Call SLI sync method
1842 // Get SvcLogicService reference
1843 Properties respProps = null;
1844 String errorCode = "200";
1845 String errorMessage = null;
1846 String ackFinal = "Y";
1849 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1853 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1854 } catch (Exception e) {
1855 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1856 errorMessage = e.getMessage();
1860 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1863 } catch (Exception e) {
1865 errorMessage = e.getMessage();
1866 log.error("Caught exception looking for service logic", e);
1869 if (respProps != null) {
1870 errorCode = respProps.getProperty("error-code");
1871 errorMessage = respProps.getProperty("error-message");
1872 ackFinal = respProps.getProperty("ack-final", "Y");
1873 // internalError = respProps.getProperty("internal-error", "false");
1876 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1878 responseBuilder.setResponseCode(errorCode);
1879 responseBuilder.setResponseMessage(errorMessage);
1880 responseBuilder.setAckFinalIndicator(ackFinal);
1882 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1883 preloadVnfListBuilder.setVnfName(preload_name);
1884 preloadVnfListBuilder.setVnfType(preload_type);
1885 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1887 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
1888 + errorCode + "', Reason: '" + errorMessage + "'");
1890 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1891 } catch (Exception e) {
1893 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1896 log.debug("Sending Success rpc result due to external error");
1897 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1898 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1900 return Futures.immediateFuture(rpcResult);
1903 // Got success from SLI
1905 preloadData = preloadDataBuilder.build();
1907 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
1909 // svc-configuration-list
1910 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1911 preloadVnfListBuilder.setVnfName(preload_name);
1912 preloadVnfListBuilder.setVnfType(preload_type);
1913 preloadVnfListBuilder.setPreloadData(preloadData);
1915 // SDNGC-989 set merge flag to false
1916 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1917 log.info("Updating OPERATIONAL tree.");
1918 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1919 } catch (Exception e) {
1920 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1922 responseBuilder.setResponseCode("500");
1923 responseBuilder.setResponseMessage(e.toString());
1924 responseBuilder.setAckFinalIndicator("Y");
1925 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
1926 + responseBuilder.build());
1927 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1928 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(false).withResult(responseBuilder.build())
1930 return Futures.immediateFuture(rpcResult);
1934 responseBuilder.setResponseCode(errorCode);
1935 responseBuilder.setAckFinalIndicator(ackFinal);
1936 if (errorMessage != null) {
1937 responseBuilder.setResponseMessage(errorMessage);
1939 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
1941 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
1944 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1945 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1947 return Futures.immediateFuture(rpcResult);
1950 //1610 preload-vnf-instance-topology-operation
1951 @Override public Future<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> preloadVnfInstanceTopologyOperation(
1952 PreloadVnfInstanceTopologyOperationInput input) {
1954 final String SVC_OPERATION = "preload-vnf-instance-topology-operation";
1955 VnfInstancePreloadData vnfInstancePreloadData = null;
1956 Properties parms = new Properties();
1958 log.info(SVC_OPERATION + " called.");
1959 // create a new response object
1960 PreloadVnfInstanceTopologyOperationOutputBuilder responseBuilder =
1961 new PreloadVnfInstanceTopologyOperationOutputBuilder();
1963 // Result from savePreloadData
1964 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1966 if (input == null || input.getVnfInstanceTopologyInformation() == null
1967 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName() == null
1968 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId() == null) {
1969 log.debug("exiting " + SVC_OPERATION
1970 + " because of invalid input, null or empty vnf-instance-name or vnf-model-id");
1971 responseBuilder.setResponseCode("403");
1972 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name or vnf-model-id");
1973 responseBuilder.setAckFinalIndicator("Y");
1974 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1975 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1976 .withResult(responseBuilder.build()).build();
1977 return Futures.immediateFuture(rpcResult);
1980 // Grab the name and type from the input buffer
1981 String preload_name =
1982 input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName();
1983 String preload_type = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId();
1985 // Make sure we have a preload_name and preload_type
1986 if (preload_name == null || preload_name.length() == 0) {
1987 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
1988 responseBuilder.setResponseCode("403");
1989 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1990 responseBuilder.setAckFinalIndicator("Y");
1991 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1992 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1993 .withResult(responseBuilder.build()).build();
1994 return Futures.immediateFuture(rpcResult);
1996 if (preload_type == null || preload_type.length() == 0) {
1997 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
1998 responseBuilder.setResponseCode("403");
1999 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2000 responseBuilder.setAckFinalIndicator("Y");
2001 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2002 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2003 .withResult(responseBuilder.build()).build();
2004 return Futures.immediateFuture(rpcResult);
2007 if (input.getSdncRequestHeader() != null) {
2008 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2009 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2012 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
2013 getVnfInstancePreloadData(preload_name, preload_type, vnfInstancePreloadDataBuilder);
2014 //preloadData = preloadDataBuilder.build();
2016 VnfInstancePreloadDataBuilder operDataBuilder = new VnfInstancePreloadDataBuilder();
2017 getVnfInstancePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2020 // setup a preload-data object builder
2021 // ACTION vnf-topology-operation
2023 // USES sdnc-request-header;
2024 // USES request-information;
2025 // uses vnf-topology-information;
2027 // USES vnf-topology-response-body;
2029 // container preload-data
2030 // uses vnf-configuration-information;
2032 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2033 PreloadVnfInstanceTopologyOperationInputBuilder inputBuilder =
2034 new PreloadVnfInstanceTopologyOperationInputBuilder(input);
2035 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2036 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2037 + "] operational-data: " + operDataBuilder.build());
2038 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2040 // Call SLI sync method
2041 // Get SvcLogicService reference
2042 Properties respProps = null;
2043 String errorCode = "200";
2044 String errorMessage = null;
2045 String ackFinal = "Y";
2048 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2051 respProps = svcLogicClient
2052 .execute("VNF-API", SVC_OPERATION, null, "sync", vnfInstancePreloadDataBuilder, parms);
2053 } catch (Exception e) {
2054 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2055 errorMessage = e.getMessage();
2059 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2062 } catch (Exception e) {
2064 errorMessage = e.getMessage();
2065 log.error("Caught exception looking for service logic", e);
2068 if (respProps != null) {
2069 errorCode = respProps.getProperty("error-code");
2070 errorMessage = respProps.getProperty("error-message");
2071 ackFinal = respProps.getProperty("ack-final", "Y");
2072 // internalError = respProps.getProperty("internal-error", "false");
2075 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2077 responseBuilder.setResponseCode(errorCode);
2078 responseBuilder.setResponseMessage(errorMessage);
2079 responseBuilder.setAckFinalIndicator(ackFinal);
2081 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2082 vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2083 vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2084 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadDataBuilder.build());
2086 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2087 + errorCode + "', Reason: '" + errorMessage + "'");
2089 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), true,
2090 LogicalDatastoreType.CONFIGURATION);
2091 } catch (Exception e) {
2093 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2096 log.debug("Sending Success rpc result due to external error");
2097 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2098 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2099 .withResult(responseBuilder.build()).build();
2100 return Futures.immediateFuture(rpcResult);
2103 // Got success from SLI
2105 vnfInstancePreloadData = vnfInstancePreloadDataBuilder.build();
2107 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2108 + vnfInstancePreloadData);
2109 // svc-configuration-list
2110 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2111 vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2112 vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2113 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadData);
2115 // SDNGC-989 set merge flag to false
2116 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false,
2117 LogicalDatastoreType.CONFIGURATION);
2118 log.info("Updating OPERATIONAL tree.");
2119 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2120 } catch (Exception e) {
2121 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2123 responseBuilder.setResponseCode("500");
2124 responseBuilder.setResponseMessage(e.toString());
2125 responseBuilder.setAckFinalIndicator("Y");
2126 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2127 + responseBuilder.build());
2128 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2129 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(false)
2130 .withResult(responseBuilder.build()).build();
2131 return Futures.immediateFuture(rpcResult);
2135 responseBuilder.setResponseCode(errorCode);
2136 responseBuilder.setAckFinalIndicator(ackFinal);
2137 if (errorMessage != null) {
2138 responseBuilder.setResponseMessage(errorMessage);
2140 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2142 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2145 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2146 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2148 return Futures.immediateFuture(rpcResult);
2152 //1610 preload-vf-module-topology-operation
2153 @Override public Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2154 PreloadVfModuleTopologyOperationInput input) {
2156 final String SVC_OPERATION = "preload-vf-module-topology-operation";
2157 VfModulePreloadData vfModulePreloadData = null;
2158 Properties parms = new Properties();
2160 log.info(SVC_OPERATION + " called.");
2161 // create a new response object
2162 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder =
2163 new PreloadVfModuleTopologyOperationOutputBuilder();
2165 // Result from savePreloadData
2166 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2168 if (input == null || input.getVfModuleTopologyInformation() == null
2169 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName() == null
2170 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId() == null) {
2171 log.debug("exiting " + SVC_OPERATION
2172 + " because of invalid input, null or empty vf-module-name or vf-module-model-id");
2173 responseBuilder.setResponseCode("403");
2174 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-name or vf-module-model-id");
2175 responseBuilder.setAckFinalIndicator("Y");
2176 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2177 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2178 .withResult(responseBuilder.build()).build();
2179 return Futures.immediateFuture(rpcResult);
2182 // Grab the name and type from the input buffer
2183 String preload_name = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName();
2184 String preload_type = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId();
2186 // Make sure we have a preload_name and preload_type
2187 if (preload_name == null || preload_name.length() == 0) {
2188 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
2189 responseBuilder.setResponseCode("403");
2190 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2191 responseBuilder.setAckFinalIndicator("Y");
2192 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2193 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2194 .withResult(responseBuilder.build()).build();
2195 return Futures.immediateFuture(rpcResult);
2197 if (preload_type == null || preload_type.length() == 0) {
2198 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
2199 responseBuilder.setResponseCode("403");
2200 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2201 responseBuilder.setAckFinalIndicator("Y");
2202 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2203 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2204 .withResult(responseBuilder.build()).build();
2205 return Futures.immediateFuture(rpcResult);
2208 if (input.getSdncRequestHeader() != null) {
2209 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2210 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2213 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
2214 getVfModulePreloadData(preload_name, preload_type, vfModulePreloadDataBuilder);
2215 //preloadData = preloadDataBuilder.build();
2217 VfModulePreloadDataBuilder operDataBuilder = new VfModulePreloadDataBuilder();
2218 getVfModulePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2221 // setup a preload-data object builder
2222 // ACTION vnf-topology-operation
2224 // USES sdnc-request-header;
2225 // USES request-information;
2226 // uses vnf-topology-information;
2228 // USES vnf-topology-response-body;
2230 // container preload-data
2231 // uses vnf-configuration-information;
2234 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2235 PreloadVfModuleTopologyOperationInputBuilder inputBuilder =
2236 new PreloadVfModuleTopologyOperationInputBuilder(input);
2237 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2238 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2239 + "] operational-data: " + operDataBuilder.build());
2240 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2242 // Call SLI sync method
2243 // Get SvcLogicService reference
2244 Properties respProps = null;
2245 String errorCode = "200";
2246 String errorMessage = null;
2247 String ackFinal = "Y";
2250 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2252 respProps = svcLogicClient
2253 .execute("VNF-API", SVC_OPERATION, null, "sync", vfModulePreloadDataBuilder, parms);
2254 } catch (Exception e) {
2255 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2256 errorMessage = e.getMessage();
2260 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2263 } catch (Exception e) {
2265 errorMessage = e.getMessage();
2266 log.error("Caught exception looking for service logic", e);
2269 if (respProps != null) {
2270 errorCode = respProps.getProperty("error-code");
2271 errorMessage = respProps.getProperty("error-message");
2272 ackFinal = respProps.getProperty("ack-final", "Y");
2273 // internalError = respProps.getProperty("internal-error", "false");
2276 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2278 responseBuilder.setResponseCode(errorCode);
2279 responseBuilder.setResponseMessage(errorMessage);
2280 responseBuilder.setAckFinalIndicator(ackFinal);
2282 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2283 vfModulePreloadListBuilder.setVfModuleName(preload_name);
2284 vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2285 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadDataBuilder.build());
2287 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2288 + errorCode + "', Reason: '" + errorMessage + "'");
2290 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2291 } catch (Exception e) {
2293 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2296 log.debug("Sending Success rpc result due to external error");
2297 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2298 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2299 .withResult(responseBuilder.build()).build();
2300 return Futures.immediateFuture(rpcResult);
2303 // Got success from SLI
2305 vfModulePreloadData = vfModulePreloadDataBuilder.build();
2307 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2308 + vfModulePreloadData);
2309 // svc-configuration-list
2310 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2311 vfModulePreloadListBuilder.setVfModuleName(preload_name);
2312 vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2313 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadData);
2315 // SDNGC-989 set merge flag to false
2316 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2317 log.info("Updating OPERATIONAL tree.");
2318 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2319 } catch (Exception e) {
2320 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2322 responseBuilder.setResponseCode("500");
2323 responseBuilder.setResponseMessage(e.toString());
2324 responseBuilder.setAckFinalIndicator("Y");
2325 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2326 + responseBuilder.build());
2327 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2328 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(false)
2329 .withResult(responseBuilder.build()).build();
2330 return Futures.immediateFuture(rpcResult);
2334 responseBuilder.setResponseCode(errorCode);
2335 responseBuilder.setAckFinalIndicator(ackFinal);
2336 if (errorMessage != null) {
2337 responseBuilder.setResponseMessage(errorMessage);
2339 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2341 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2344 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2345 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2347 return Futures.immediateFuture(rpcResult);
2351 @Override public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2352 PreloadNetworkTopologyOperationInput input) {
2354 final String SVC_OPERATION = "preload-network-topology-operation";
2355 PreloadData preloadData = null;
2356 Properties parms = new Properties();
2358 log.info(SVC_OPERATION + " called.");
2359 // create a new response object
2360 PreloadNetworkTopologyOperationOutputBuilder responseBuilder =
2361 new PreloadNetworkTopologyOperationOutputBuilder();
2363 // Result from savePreloadData
2364 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2366 if (input == null || input.getNetworkTopologyInformation() == null
2367 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null
2368 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName() == null
2369 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType() == null) {
2370 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or" +
2371 " empty network-name or network-type");
2372 responseBuilder.setResponseCode("403");
2373 responseBuilder.setResponseMessage("input, null or empty network-name or network-type");
2374 responseBuilder.setAckFinalIndicator("Y");
2375 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2376 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2378 return Futures.immediateFuture(rpcResult);
2381 // Grab the name and type from the input buffer
2382 String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2383 String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2385 // Make sure we have a preload_name and preload_type
2386 if (preload_name == null || preload_name.length() == 0) {
2387 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
2388 responseBuilder.setResponseCode("403");
2389 responseBuilder.setResponseMessage("input, invalid preload-name");
2390 responseBuilder.setAckFinalIndicator("Y");
2391 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2392 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2394 return Futures.immediateFuture(rpcResult);
2397 if (preload_type == null || preload_type.length() == 0) {
2398 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
2399 responseBuilder.setResponseCode("403");
2400 responseBuilder.setResponseMessage("input, invalid preload-type");
2401 responseBuilder.setAckFinalIndicator("Y");
2402 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2403 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2405 return Futures.immediateFuture(rpcResult);
2408 if (input.getSdncRequestHeader() != null) {
2409 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2410 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2413 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2414 getPreloadData(preload_name, preload_type, preloadDataBuilder);
2416 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2417 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2420 // setup a preload-data object builder
2421 // ACTION vnf-topology-operation
2423 // USES sdnc-request-header;
2424 // USES request-information;
2425 // uses vnf-topology-information;
2427 // USES vnf-topology-response-body;
2429 // container preload-data
2430 // uses vnf-configuration-information;
2432 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2433 PreloadNetworkTopologyOperationInputBuilder inputBuilder =
2434 new PreloadNetworkTopologyOperationInputBuilder(input);
2435 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2436 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2437 + "] operational-data: " + operDataBuilder.build());
2438 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2440 // Call SLI sync method
2441 // Get SvcLogicService reference
2442 Properties respProps = null;
2443 String errorCode = "200";
2444 String errorMessage = null;
2445 String ackFinal = "Y";
2448 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2451 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2452 } catch (Exception e) {
2453 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2454 errorMessage = e.getMessage();
2458 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2461 } catch (Exception e) {
2463 errorMessage = e.getMessage();
2464 log.error("Caught exception looking for service logic", e);
2468 if (respProps != null) {
2469 errorCode = respProps.getProperty("error-code");
2470 errorMessage = respProps.getProperty("error-message");
2471 ackFinal = respProps.getProperty("ack-final", "Y");
2472 // internalError = respProps.getProperty("internal-error", "false");
2475 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2476 responseBuilder.setResponseCode(errorCode);
2477 responseBuilder.setResponseMessage(errorMessage);
2478 responseBuilder.setAckFinalIndicator(ackFinal);
2480 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2481 preloadVnfListBuilder.setVnfName(preload_name);
2482 preloadVnfListBuilder.setVnfType(preload_type);
2483 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2485 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2486 + errorCode + "', Reason: '" + errorMessage + "'");
2488 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2489 } catch (Exception e) {
2491 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2495 log.debug("Sending Success rpc result due to external error");
2496 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2497 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2499 return Futures.immediateFuture(rpcResult);
2502 // Got success from SLI
2504 preloadData = preloadDataBuilder.build();
2506 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2508 // svc-configuration-list
2509 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2510 preloadVnfListBuilder.setVnfName(preload_name);
2511 preloadVnfListBuilder.setVnfType(preload_type);
2512 preloadVnfListBuilder.setPreloadData(preloadData);
2514 // SDNGC-989 set merge flag to false
2515 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2516 log.info("Updating OPERATIONAL tree.");
2517 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2518 } catch (Exception e) {
2519 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2521 responseBuilder.setResponseCode("500");
2522 responseBuilder.setResponseMessage(e.toString());
2523 responseBuilder.setAckFinalIndicator("Y");
2524 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2525 + responseBuilder.build());
2526 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2527 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(false)
2528 .withResult(responseBuilder.build()).build();
2529 return Futures.immediateFuture(rpcResult);
2533 responseBuilder.setResponseCode(errorCode);
2534 responseBuilder.setAckFinalIndicator(ackFinal);
2535 if (errorMessage != null) {
2536 responseBuilder.setResponseMessage(errorMessage);
2538 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2540 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2543 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2544 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2546 return Futures.immediateFuture(rpcResult);