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 // 1610 Need to pull vnf-instance-list.vf-module-relationship-list from MD-SAL
1241 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1242 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1244 // vnf-instance operational-data
1245 VnfInstanceServiceDataBuilder vnfInstanceOperDataBuilder = new VnfInstanceServiceDataBuilder();
1246 getVnfInstanceServiceData(viid, vnfInstanceOperDataBuilder, LogicalDatastoreType.OPERATIONAL);
1249 // Set the serviceStatus based on input
1250 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1251 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1254 // setup a service-data object builder
1255 // ACTION vnf-topology-operation
1257 // USES request-information;
1258 // USES service-information;
1259 // USES vnf-request-information
1261 // USES vnf-information
1262 // USES service-information
1264 // container service-data
1266 log.info(ADDING_INPUT_DATA_STR + SVC_OPERATION + " [" + vfid + INPUT_STR + input);
1267 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1268 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1270 log.info(ADDING_OPERATIONAL_DATA_STR + SVC_OPERATION + " [" + vfid + "] vf-module operational-data: "
1271 + operDataBuilder.build());
1272 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1274 log.info(ADDING_CONFIG_DATA_STR + SVC_OPERATION + " [" + preloadName + "," + preloadType
1275 + "] vf-module-preload-data: " + vfModulePreloadDataBuilder.build());
1276 VnfSdnUtil.toProperties(parms, "vf-module-preload-data", vfModulePreloadDataBuilder);
1278 log.info("Adding vnf-instance CONFIG data for " + SVC_OPERATION + " [" + viid + "] vnf-instance-service-data: "
1279 + vnfInstanceServiceDataBuilder.build());
1280 VnfSdnUtil.toProperties(parms, "vnf-instance-service-data", vnfInstanceServiceDataBuilder);
1282 log.info("Adding vnf-instance OPERATIONAL data for " + SVC_OPERATION + " [" + viid
1283 + "] vnf-instance operational-data: " + vnfInstanceOperDataBuilder.build());
1284 VnfSdnUtil.toProperties(parms, "vnf-instance-operational-data", vnfInstanceOperDataBuilder);
1286 // Call SLI sync method
1287 // Get SvcLogicService reference
1289 Properties respProps = null;
1290 String errorCode = "200";
1291 String errorMessage = null;
1292 String ackFinal = "Y";
1295 if (svcLogicClient.hasGraph(VNF_API, SVC_OPERATION, null, "sync")) {
1298 respProps = svcLogicClient
1299 .execute(VNF_API, SVC_OPERATION, null, "sync", vfModuleServiceDataBuilder, parms);
1300 } catch (Exception e) {
1301 log.error("Caught exception executing service logic on vf-module for " + SVC_OPERATION, e);
1302 errorMessage = e.getMessage();
1307 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1310 } catch (Exception e) {
1312 errorMessage = e.getMessage();
1313 log.error("Caught exception looking for service logic", e);
1316 if (respProps != null) {
1317 errorCode = respProps.getProperty("error-code");
1318 errorMessage = respProps.getProperty("error-message");
1319 ackFinal = respProps.getProperty("ack-final", "Y");
1322 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1323 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1324 serviceStatusBuilder.setRpcName(RpcName.VfModuleTopologyOperation);
1326 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1327 responseBuilder.setResponseCode(errorCode);
1328 responseBuilder.setResponseMessage(errorMessage);
1329 responseBuilder.setAckFinalIndicator(ackFinal);
1330 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1331 vfModuleListBuilder.setVfModuleId(vfid);
1332 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1334 saveVfModuleList(vfModuleListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1335 } catch (Exception e) {
1336 log.error(CAUGHT_EXCEPTION_STR + SVC_OPERATION + " [" + vfid + "] \n", e);
1338 log.error(RETURNED_FAILED_STR + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1339 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1340 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1343 return Futures.immediateFuture(rpcResult);
1346 // Got success from SLI
1347 // save vf-module-service-data in MD-SAL
1349 vfModuleServiceData = vfModuleServiceDataBuilder.build();
1351 UPDATING_MD_SAL_STR + SVC_OPERATION + " [" + vfid + "] VfModuleServiceData: " + vfModuleServiceData);
1353 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1354 vfModuleListBuilder.setVfModuleServiceData(vfModuleServiceData);
1355 vfModuleListBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
1356 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1357 saveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1358 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1359 // Only update operational tree on Delete or Activate
1360 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1361 .getSvcAction().equals(SvcAction.Activate)) {
1362 log.info(UPDATING_OPERATIONAL_TREE_STR);
1363 saveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1366 VfModuleInformationBuilder vfModuleInformationBuilder = new VfModuleInformationBuilder();
1367 vfModuleInformationBuilder.setVfModuleId(vfid);
1368 responseBuilder.setVfModuleInformation(vfModuleInformationBuilder.build());
1369 responseBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
1370 } catch (Exception e) {
1371 log.error(CAUGHT_EXCEPTION_STR + SVC_OPERATION + " [" + vfid + "] \n", e);
1372 responseBuilder.setResponseCode("500");
1373 responseBuilder.setResponseMessage(e.toString());
1374 responseBuilder.setAckFinalIndicator("Y");
1375 log.error(RETURNED_FAILED_STR + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1376 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1377 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1380 return Futures.immediateFuture(rpcResult);
1384 responseBuilder.setResponseCode(errorCode);
1385 responseBuilder.setAckFinalIndicator(ackFinal);
1386 if (errorMessage != null) {
1387 responseBuilder.setResponseMessage(errorMessage);
1389 log.info("Updated vf-module in MD-SAL for " + SVC_OPERATION + " [" + vfid + "] ");
1390 log.info(RETURNED_SUCCESS_STR + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1392 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1393 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1395 return Futures.immediateFuture(rpcResult);
1399 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
1400 final String SVC_OPERATION = "vnf-topology-operation";
1401 ServiceData serviceData;
1402 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1403 Properties parms = new Properties();
1405 log.info(SVC_OPERATION + " called.");
1406 // create a new response object
1407 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1409 if (input == null || input.getServiceInformation() == null
1410 || input.getServiceInformation().getServiceInstanceId() == null
1411 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1412 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1413 responseBuilder.setResponseCode("403");
1414 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1415 responseBuilder.setAckFinalIndicator("Y");
1416 RpcResult<VnfTopologyOperationOutput> rpcResult =
1417 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1419 return Futures.immediateFuture(rpcResult);
1422 if (input.getVnfRequestInformation() == null || input.getVnfRequestInformation().getVnfId() == null
1423 || input.getVnfRequestInformation().getVnfId().length() == 0) {
1424 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vf-module-id");
1425 responseBuilder.setResponseCode("403");
1426 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1427 responseBuilder.setAckFinalIndicator("Y");
1428 RpcResult<VnfTopologyOperationOutput> rpcResult =
1429 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1431 return Futures.immediateFuture(rpcResult);
1434 // Grab the service instance ID from the input buffer
1435 String siid = input.getVnfRequestInformation().getVnfId();
1436 String preload_name = input.getVnfRequestInformation().getVnfName();
1437 String preload_type = input.getVnfRequestInformation().getVnfType();
1439 if (input.getSdncRequestHeader() != null) {
1440 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1441 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1444 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1445 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1447 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1448 getServiceData(siid, serviceDataBuilder);
1450 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1451 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1453 // Set the serviceStatus based on input
1454 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1455 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1458 // setup a service-data object builder
1459 // ACTION vnf-topology-operation
1461 // USES request-information;
1462 // USES vnf-request-information
1464 // USES vnf-information
1465 // USES service-information
1467 // container service-data
1468 // uses oper-status;
1470 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + siid + "] input: " + input);
1471 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1472 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1474 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + siid + "] operational-data: " + operDataBuilder
1476 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1479 "Adding CONFIG data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preload-data: "
1480 + preloadDataBuilder.build());
1481 VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1483 // Call SLI sync method
1484 // Get SvcLogicService reference
1485 Properties respProps = null;
1486 String errorCode = "200";
1487 String errorMessage = null;
1488 String ackFinal = "Y";
1491 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1495 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1496 } catch (Exception e) {
1497 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1498 errorMessage = e.getMessage();
1502 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1505 } catch (Exception e) {
1507 errorMessage = e.getMessage();
1508 log.error("Caught exception looking for service logic", e);
1511 if (respProps != null) {
1512 errorCode = respProps.getProperty("error-code");
1513 errorMessage = respProps.getProperty("error-message");
1514 ackFinal = respProps.getProperty("ack-final", "Y");
1517 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1518 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1519 serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
1521 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1522 responseBuilder.setResponseCode(errorCode);
1523 responseBuilder.setResponseMessage(errorMessage);
1524 responseBuilder.setAckFinalIndicator(ackFinal);
1525 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1526 vnfListBuilder.setVnfId(siid);
1527 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1529 saveVnfList(vnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1530 } catch (Exception e) {
1531 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1533 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1534 RpcResult<VnfTopologyOperationOutput> rpcResult =
1535 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1537 return Futures.immediateFuture(rpcResult);
1540 // Got success from SLI
1542 serviceData = serviceDataBuilder.build();
1543 log.info("Updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] ServiceData: " + serviceData);
1544 // svc-configuration-list
1545 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1546 vnfListBuilder.setServiceData(serviceData);
1547 vnfListBuilder.setVnfId(serviceData.getVnfId());
1548 siid = serviceData.getVnfId();
1549 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1550 saveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1551 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1552 // Only update operational tree on Delete or Activate
1553 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1554 log.info("Updating OPERATIONAL tree.");
1555 saveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1556 } else if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input
1557 .getSdncRequestHeader().getSvcAction().equals(SvcAction.Rollback)) {
1558 log.info("Delete OPERATIONAL tree.");
1559 deleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
1560 deleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
1563 VnfInformationBuilder vnfInformationBuilder = new VnfInformationBuilder();
1564 vnfInformationBuilder.setVnfId(siid);
1565 responseBuilder.setVnfInformation(vnfInformationBuilder.build());
1566 responseBuilder.setServiceInformation(serviceData.getServiceInformation());
1567 } catch (Exception e) {
1568 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1569 responseBuilder.setResponseCode("500");
1570 responseBuilder.setResponseMessage(e.toString());
1571 responseBuilder.setAckFinalIndicator("Y");
1572 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1573 RpcResult<VnfTopologyOperationOutput> rpcResult =
1574 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1576 return Futures.immediateFuture(rpcResult);
1580 responseBuilder.setResponseCode(errorCode);
1581 responseBuilder.setAckFinalIndicator(ackFinal);
1582 if (errorMessage != null) {
1583 responseBuilder.setResponseMessage(errorMessage);
1585 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + siid + "] ");
1586 log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1588 RpcResult<VnfTopologyOperationOutput> rpcResult =
1589 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1591 return Futures.immediateFuture(rpcResult);
1594 @Override public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1595 NetworkTopologyOperationInput input) {
1597 final String SVC_OPERATION = "network-topology-operation";
1598 Properties parms = new Properties();
1600 log.info(SVC_OPERATION + " called.");
1601 // create a new response object
1602 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1604 if (input == null || input.getServiceInformation() == null
1605 || input.getServiceInformation().getServiceInstanceId() == null
1606 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1607 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1608 responseBuilder.setResponseCode("403");
1609 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1610 responseBuilder.setAckFinalIndicator("Y");
1611 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1612 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1615 return Futures.immediateFuture(rpcResult);
1618 if (input.getNetworkRequestInformation() == null
1619 || input.getNetworkRequestInformation().getNetworkName() == null) {
1620 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1621 responseBuilder.setResponseCode("403");
1622 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1623 responseBuilder.setAckFinalIndicator("Y");
1624 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1625 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1628 return Futures.immediateFuture(rpcResult);
1631 // Grab the service instance ID from the input buffer
1633 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Assign)) {
1634 siid = input.getNetworkRequestInformation().getNetworkName();
1636 siid = input.getNetworkRequestInformation().getNetworkId();
1638 String preload_name = input.getNetworkRequestInformation().getNetworkName();
1639 String preload_type = input.getNetworkRequestInformation().getNetworkType();
1641 if (input.getSdncRequestHeader() != null) {
1642 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1643 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1646 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1647 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1649 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + siid + "] input: " + input);
1650 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1651 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1653 // Call SLI sync method
1654 // Get SvcLogicService reference
1655 Properties respProps = null;
1656 String errorCode = "200";
1657 String errorMessage = null;
1658 String ackFinal = "Y";
1659 String networkId = "error";
1662 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1666 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1667 } catch (Exception e) {
1668 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1669 errorMessage = e.getMessage();
1673 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1676 } catch (Exception e) {
1678 errorMessage = e.getMessage();
1679 log.error("Caught exception looking for service logic", e);
1682 if (respProps != null) {
1683 errorCode = respProps.getProperty("error-code");
1684 errorMessage = respProps.getProperty("error-message");
1685 ackFinal = respProps.getProperty("ack-final", "Y");
1686 networkId = respProps.getProperty("networkId", "0");
1689 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1690 responseBuilder.setResponseCode(errorCode);
1691 responseBuilder.setResponseMessage(errorMessage);
1692 responseBuilder.setAckFinalIndicator(ackFinal);
1694 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1696 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1697 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1700 return Futures.immediateFuture(rpcResult);
1703 // Got success from SLI
1705 NetworkInformationBuilder networkInformationBuilder = new NetworkInformationBuilder();
1706 networkInformationBuilder.setNetworkId(networkId);
1707 responseBuilder.setNetworkInformation(networkInformationBuilder.build());
1708 responseBuilder.setServiceInformation(input.getServiceInformation());
1709 } catch (IllegalStateException e) {
1710 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1711 responseBuilder.setResponseCode("500");
1712 responseBuilder.setResponseMessage(e.toString());
1713 responseBuilder.setAckFinalIndicator("Y");
1714 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1715 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1716 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1719 return Futures.immediateFuture(rpcResult);
1723 responseBuilder.setResponseCode(errorCode);
1724 responseBuilder.setAckFinalIndicator(ackFinal);
1725 if (errorMessage != null) {
1726 responseBuilder.setResponseMessage(errorMessage);
1728 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + siid + "] ");
1729 log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1731 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1732 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1734 return Futures.immediateFuture(rpcResult);
1737 @Override public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1738 PreloadVnfTopologyOperationInput input) {
1740 final String SVC_OPERATION = "preload-vnf-topology-operation";
1741 PreloadData preloadData;
1742 Properties parms = new Properties();
1744 log.info(SVC_OPERATION + " called.");
1745 // create a new response object
1746 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1748 // Result from savePreloadData
1750 if (input == null || input.getVnfTopologyInformation() == null
1751 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null
1752 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName() == null
1753 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType() == null) {
1754 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vnf-name or vnf-type");
1755 responseBuilder.setResponseCode("403");
1756 responseBuilder.setResponseMessage("invalid input, null or empty vnf-name or vnf-type");
1757 responseBuilder.setAckFinalIndicator("Y");
1758 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1759 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1761 return Futures.immediateFuture(rpcResult);
1764 // Grab the name and type from the input buffer
1765 String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1766 String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1768 // Make sure we have a preload_name and preload_type
1769 if (preload_name == null || preload_name.length() == 0) {
1770 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
1771 responseBuilder.setResponseCode("403");
1772 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1773 responseBuilder.setAckFinalIndicator("Y");
1774 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1775 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1777 return Futures.immediateFuture(rpcResult);
1779 if (preload_type == null || preload_type.length() == 0) {
1780 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
1781 responseBuilder.setResponseCode("403");
1782 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1783 responseBuilder.setAckFinalIndicator("Y");
1784 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1785 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1787 return Futures.immediateFuture(rpcResult);
1790 if (input.getSdncRequestHeader() != null) {
1791 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1792 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1795 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1796 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1798 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1799 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1802 // setup a preload-data object builder
1803 // ACTION vnf-topology-operation
1805 // USES request-information;
1806 // uses vnf-topology-information;
1809 // container preload-data
1811 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
1812 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1813 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1814 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1815 + "] operational-data: " + operDataBuilder.build());
1816 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1818 // Call SLI sync method
1819 // Get SvcLogicService reference
1820 Properties respProps = null;
1821 String errorCode = "200";
1822 String errorMessage = null;
1823 String ackFinal = "Y";
1826 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1830 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1831 } catch (Exception e) {
1832 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1833 errorMessage = e.getMessage();
1837 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1840 } catch (Exception e) {
1842 errorMessage = e.getMessage();
1843 log.error("Caught exception looking for service logic", e);
1846 if (respProps != null) {
1847 errorCode = respProps.getProperty("error-code");
1848 errorMessage = respProps.getProperty("error-message");
1849 ackFinal = respProps.getProperty("ack-final", "Y");
1852 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1854 responseBuilder.setResponseCode(errorCode);
1855 responseBuilder.setResponseMessage(errorMessage);
1856 responseBuilder.setAckFinalIndicator(ackFinal);
1858 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1859 preloadVnfListBuilder.setVnfName(preload_name);
1860 preloadVnfListBuilder.setVnfType(preload_type);
1861 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1863 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
1864 + errorCode + "', Reason: '" + errorMessage + "'");
1866 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1867 } catch (Exception e) {
1869 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1872 log.debug("Sending Success rpc result due to external error");
1873 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1874 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1876 return Futures.immediateFuture(rpcResult);
1879 // Got success from SLI
1881 preloadData = preloadDataBuilder.build();
1883 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
1885 // svc-configuration-list
1886 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1887 preloadVnfListBuilder.setVnfName(preload_name);
1888 preloadVnfListBuilder.setVnfType(preload_type);
1889 preloadVnfListBuilder.setPreloadData(preloadData);
1891 // SDNGC-989 set merge flag to false
1892 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1893 log.info("Updating OPERATIONAL tree.");
1894 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1895 } catch (Exception e) {
1896 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1898 responseBuilder.setResponseCode("500");
1899 responseBuilder.setResponseMessage(e.toString());
1900 responseBuilder.setAckFinalIndicator("Y");
1901 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
1902 + responseBuilder.build());
1903 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1904 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(false).withResult(responseBuilder.build())
1906 return Futures.immediateFuture(rpcResult);
1910 responseBuilder.setResponseCode(errorCode);
1911 responseBuilder.setAckFinalIndicator(ackFinal);
1912 if (errorMessage != null) {
1913 responseBuilder.setResponseMessage(errorMessage);
1915 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
1917 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
1920 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1921 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1923 return Futures.immediateFuture(rpcResult);
1926 //1610 preload-vnf-instance-topology-operation
1927 @Override public Future<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> preloadVnfInstanceTopologyOperation(
1928 PreloadVnfInstanceTopologyOperationInput input) {
1930 final String SVC_OPERATION = "preload-vnf-instance-topology-operation";
1931 VnfInstancePreloadData vnfInstancePreloadData;
1932 Properties parms = new Properties();
1934 log.info(SVC_OPERATION + " called.");
1935 // create a new response object
1936 PreloadVnfInstanceTopologyOperationOutputBuilder responseBuilder =
1937 new PreloadVnfInstanceTopologyOperationOutputBuilder();
1940 if (input == null || input.getVnfInstanceTopologyInformation() == null
1941 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName() == null
1942 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId() == null) {
1943 log.debug("exiting " + SVC_OPERATION
1944 + " because of invalid input, null or empty vnf-instance-name or vnf-model-id");
1945 responseBuilder.setResponseCode("403");
1946 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name or vnf-model-id");
1947 responseBuilder.setAckFinalIndicator("Y");
1948 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1949 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1950 .withResult(responseBuilder.build()).build();
1951 return Futures.immediateFuture(rpcResult);
1954 // Grab the name and type from the input buffer
1955 String preload_name =
1956 input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName();
1957 String preload_type = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId();
1959 // Make sure we have a preload_name and preload_type
1960 if (preload_name == null || preload_name.length() == 0) {
1961 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
1962 responseBuilder.setResponseCode("403");
1963 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1964 responseBuilder.setAckFinalIndicator("Y");
1965 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1966 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1967 .withResult(responseBuilder.build()).build();
1968 return Futures.immediateFuture(rpcResult);
1970 if (preload_type == null || preload_type.length() == 0) {
1971 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
1972 responseBuilder.setResponseCode("403");
1973 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1974 responseBuilder.setAckFinalIndicator("Y");
1975 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1976 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1977 .withResult(responseBuilder.build()).build();
1978 return Futures.immediateFuture(rpcResult);
1981 if (input.getSdncRequestHeader() != null) {
1982 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1983 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1986 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
1987 getVnfInstancePreloadData(preload_name, preload_type, vnfInstancePreloadDataBuilder);
1990 VnfInstancePreloadDataBuilder operDataBuilder = new VnfInstancePreloadDataBuilder();
1991 getVnfInstancePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1994 // setup a preload-data object builder
1995 // ACTION vnf-topology-operation
1997 // uses vnf-topology-information;
1999 // container preload-data
2001 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2002 PreloadVnfInstanceTopologyOperationInputBuilder inputBuilder =
2003 new PreloadVnfInstanceTopologyOperationInputBuilder(input);
2004 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2005 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2006 + "] operational-data: " + operDataBuilder.build());
2007 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2009 // Call SLI sync method
2010 // Get SvcLogicService reference
2011 Properties respProps = null;
2012 String errorCode = "200";
2013 String errorMessage = null;
2014 String ackFinal = "Y";
2017 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2020 respProps = svcLogicClient
2021 .execute("VNF-API", SVC_OPERATION, null, "sync", vnfInstancePreloadDataBuilder, parms);
2022 } catch (Exception e) {
2023 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2024 errorMessage = e.getMessage();
2028 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2031 } catch (Exception e) {
2033 errorMessage = e.getMessage();
2034 log.error("Caught exception looking for service logic", e);
2037 if (respProps != null) {
2038 errorCode = respProps.getProperty("error-code");
2039 errorMessage = respProps.getProperty("error-message");
2040 ackFinal = respProps.getProperty("ack-final", "Y");
2043 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2045 responseBuilder.setResponseCode(errorCode);
2046 responseBuilder.setResponseMessage(errorMessage);
2047 responseBuilder.setAckFinalIndicator(ackFinal);
2049 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2050 vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2051 vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2052 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadDataBuilder.build());
2054 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2055 + errorCode + "', Reason: '" + errorMessage + "'");
2057 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), true,
2058 LogicalDatastoreType.CONFIGURATION);
2059 } catch (Exception e) {
2061 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2064 log.debug("Sending Success rpc result due to external error");
2065 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2066 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2067 .withResult(responseBuilder.build()).build();
2068 return Futures.immediateFuture(rpcResult);
2071 // Got success from SLI
2073 vnfInstancePreloadData = vnfInstancePreloadDataBuilder.build();
2075 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2076 + vnfInstancePreloadData);
2077 // svc-configuration-list
2078 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2079 vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2080 vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2081 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadData);
2083 // SDNGC-989 set merge flag to false
2084 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false,
2085 LogicalDatastoreType.CONFIGURATION);
2086 log.info("Updating OPERATIONAL tree.");
2087 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2088 } catch (Exception e) {
2089 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2091 responseBuilder.setResponseCode("500");
2092 responseBuilder.setResponseMessage(e.toString());
2093 responseBuilder.setAckFinalIndicator("Y");
2094 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2095 + responseBuilder.build());
2096 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2097 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(false)
2098 .withResult(responseBuilder.build()).build();
2099 return Futures.immediateFuture(rpcResult);
2103 responseBuilder.setResponseCode(errorCode);
2104 responseBuilder.setAckFinalIndicator(ackFinal);
2105 if (errorMessage != null) {
2106 responseBuilder.setResponseMessage(errorMessage);
2108 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2110 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2113 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2114 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2116 return Futures.immediateFuture(rpcResult);
2120 //1610 preload-vf-module-topology-operation
2121 @Override public Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2122 PreloadVfModuleTopologyOperationInput input) {
2124 final String SVC_OPERATION = "preload-vf-module-topology-operation";
2125 VfModulePreloadData vfModulePreloadData;
2126 Properties parms = new Properties();
2128 log.info(SVC_OPERATION + " called.");
2129 // create a new response object
2130 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder =
2131 new PreloadVfModuleTopologyOperationOutputBuilder();
2133 // Result from savePreloadData
2135 if (input == null || input.getVfModuleTopologyInformation() == null
2136 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName() == null
2137 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId() == null) {
2138 log.debug("exiting " + SVC_OPERATION
2139 + " because of invalid input, null or empty vf-module-name or vf-module-model-id");
2140 responseBuilder.setResponseCode("403");
2141 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-name or vf-module-model-id");
2142 responseBuilder.setAckFinalIndicator("Y");
2143 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2144 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2145 .withResult(responseBuilder.build()).build();
2146 return Futures.immediateFuture(rpcResult);
2149 // Grab the name and type from the input buffer
2150 String preload_name = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName();
2151 String preload_type = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId();
2153 // Make sure we have a preload_name and preload_type
2154 if (preload_name == null || preload_name.length() == 0) {
2155 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
2156 responseBuilder.setResponseCode("403");
2157 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2158 responseBuilder.setAckFinalIndicator("Y");
2159 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2160 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2161 .withResult(responseBuilder.build()).build();
2162 return Futures.immediateFuture(rpcResult);
2164 if (preload_type == null || preload_type.length() == 0) {
2165 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
2166 responseBuilder.setResponseCode("403");
2167 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2168 responseBuilder.setAckFinalIndicator("Y");
2169 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2170 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2171 .withResult(responseBuilder.build()).build();
2172 return Futures.immediateFuture(rpcResult);
2175 if (input.getSdncRequestHeader() != null) {
2176 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2177 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2180 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
2181 getVfModulePreloadData(preload_name, preload_type, vfModulePreloadDataBuilder);
2183 VfModulePreloadDataBuilder operDataBuilder = new VfModulePreloadDataBuilder();
2184 getVfModulePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2187 // setup a preload-data object builder
2188 // ACTION vnf-topology-operation
2190 // USES request-information;
2191 // uses vnf-topology-information;
2194 // container preload-data
2197 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2198 PreloadVfModuleTopologyOperationInputBuilder inputBuilder =
2199 new PreloadVfModuleTopologyOperationInputBuilder(input);
2200 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2201 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2202 + "] operational-data: " + operDataBuilder.build());
2203 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2205 // Call SLI sync method
2206 // Get SvcLogicService reference
2207 Properties respProps = null;
2208 String errorCode = "200";
2209 String errorMessage = null;
2210 String ackFinal = "Y";
2213 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2215 respProps = svcLogicClient
2216 .execute("VNF-API", SVC_OPERATION, null, "sync", vfModulePreloadDataBuilder, parms);
2217 } catch (Exception e) {
2218 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2219 errorMessage = e.getMessage();
2223 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2226 } catch (Exception e) {
2228 errorMessage = e.getMessage();
2229 log.error("Caught exception looking for service logic", e);
2232 if (respProps != null) {
2233 errorCode = respProps.getProperty("error-code");
2234 errorMessage = respProps.getProperty("error-message");
2235 ackFinal = respProps.getProperty("ack-final", "Y");
2238 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2240 responseBuilder.setResponseCode(errorCode);
2241 responseBuilder.setResponseMessage(errorMessage);
2242 responseBuilder.setAckFinalIndicator(ackFinal);
2244 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2245 vfModulePreloadListBuilder.setVfModuleName(preload_name);
2246 vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2247 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadDataBuilder.build());
2249 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2250 + errorCode + "', Reason: '" + errorMessage + "'");
2252 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2253 } catch (Exception e) {
2255 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2258 log.debug("Sending Success rpc result due to external error");
2259 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2260 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2261 .withResult(responseBuilder.build()).build();
2262 return Futures.immediateFuture(rpcResult);
2265 // Got success from SLI
2267 vfModulePreloadData = vfModulePreloadDataBuilder.build();
2269 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2270 + vfModulePreloadData);
2271 // svc-configuration-list
2272 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2273 vfModulePreloadListBuilder.setVfModuleName(preload_name);
2274 vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2275 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadData);
2277 // SDNGC-989 set merge flag to false
2278 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2279 log.info("Updating OPERATIONAL tree.");
2280 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2281 } catch (Exception e) {
2282 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2284 responseBuilder.setResponseCode("500");
2285 responseBuilder.setResponseMessage(e.toString());
2286 responseBuilder.setAckFinalIndicator("Y");
2287 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2288 + responseBuilder.build());
2289 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2290 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(false)
2291 .withResult(responseBuilder.build()).build();
2292 return Futures.immediateFuture(rpcResult);
2296 responseBuilder.setResponseCode(errorCode);
2297 responseBuilder.setAckFinalIndicator(ackFinal);
2298 if (errorMessage != null) {
2299 responseBuilder.setResponseMessage(errorMessage);
2301 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2303 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2306 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2307 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2309 return Futures.immediateFuture(rpcResult);
2313 @Override public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2314 PreloadNetworkTopologyOperationInput input) {
2316 final String SVC_OPERATION = "preload-network-topology-operation";
2317 PreloadData preloadData;
2318 Properties parms = new Properties();
2320 log.info(SVC_OPERATION + " called.");
2321 // create a new response object
2322 PreloadNetworkTopologyOperationOutputBuilder responseBuilder =
2323 new PreloadNetworkTopologyOperationOutputBuilder();
2325 // Result from savePreloadData
2327 if (input == null || input.getNetworkTopologyInformation() == null
2328 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null
2329 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName() == null
2330 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType() == null) {
2331 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or" +
2332 " empty network-name or network-type");
2333 responseBuilder.setResponseCode("403");
2334 responseBuilder.setResponseMessage("input, null or empty network-name or network-type");
2335 responseBuilder.setAckFinalIndicator("Y");
2336 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2337 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2339 return Futures.immediateFuture(rpcResult);
2342 // Grab the name and type from the input buffer
2343 String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2344 String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2346 // Make sure we have a preload_name and preload_type
2347 if (preload_name == null || preload_name.length() == 0) {
2348 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
2349 responseBuilder.setResponseCode("403");
2350 responseBuilder.setResponseMessage("input, invalid preload-name");
2351 responseBuilder.setAckFinalIndicator("Y");
2352 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2353 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2355 return Futures.immediateFuture(rpcResult);
2358 if (preload_type == null || preload_type.length() == 0) {
2359 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
2360 responseBuilder.setResponseCode("403");
2361 responseBuilder.setResponseMessage("input, invalid preload-type");
2362 responseBuilder.setAckFinalIndicator("Y");
2363 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2364 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2366 return Futures.immediateFuture(rpcResult);
2369 if (input.getSdncRequestHeader() != null) {
2370 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2371 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2374 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2375 getPreloadData(preload_name, preload_type, preloadDataBuilder);
2377 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2378 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2381 // setup a preload-data object builder
2382 // ACTION vnf-topology-operation
2384 // USES request-information;
2385 // uses vnf-topology-information;
2388 // container preload-data
2390 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2391 PreloadNetworkTopologyOperationInputBuilder inputBuilder =
2392 new PreloadNetworkTopologyOperationInputBuilder(input);
2393 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2394 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2395 + "] operational-data: " + operDataBuilder.build());
2396 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2398 // Call SLI sync method
2399 // Get SvcLogicService reference
2400 Properties respProps = null;
2401 String errorCode = "200";
2402 String errorMessage = null;
2403 String ackFinal = "Y";
2406 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2409 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2410 } catch (Exception e) {
2411 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2412 errorMessage = e.getMessage();
2416 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2419 } catch (Exception e) {
2421 errorMessage = e.getMessage();
2422 log.error("Caught exception looking for service logic", e);
2426 if (respProps != null) {
2427 errorCode = respProps.getProperty("error-code");
2428 errorMessage = respProps.getProperty("error-message");
2429 ackFinal = respProps.getProperty("ack-final", "Y");
2432 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2433 responseBuilder.setResponseCode(errorCode);
2434 responseBuilder.setResponseMessage(errorMessage);
2435 responseBuilder.setAckFinalIndicator(ackFinal);
2437 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2438 preloadVnfListBuilder.setVnfName(preload_name);
2439 preloadVnfListBuilder.setVnfType(preload_type);
2440 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2442 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2443 + errorCode + "', Reason: '" + errorMessage + "'");
2445 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2446 } catch (Exception e) {
2448 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2452 log.debug("Sending Success rpc result due to external error");
2453 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2454 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2456 return Futures.immediateFuture(rpcResult);
2459 // Got success from SLI
2461 preloadData = preloadDataBuilder.build();
2463 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2465 // svc-configuration-list
2466 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2467 preloadVnfListBuilder.setVnfName(preload_name);
2468 preloadVnfListBuilder.setVnfType(preload_type);
2469 preloadVnfListBuilder.setPreloadData(preloadData);
2471 // SDNGC-989 set merge flag to false
2472 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2473 log.info("Updating OPERATIONAL tree.");
2474 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2475 } catch (Exception e) {
2476 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2478 responseBuilder.setResponseCode("500");
2479 responseBuilder.setResponseMessage(e.toString());
2480 responseBuilder.setAckFinalIndicator("Y");
2481 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2482 + responseBuilder.build());
2483 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2484 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(false)
2485 .withResult(responseBuilder.build()).build();
2486 return Futures.immediateFuture(rpcResult);
2490 responseBuilder.setResponseCode(errorCode);
2491 responseBuilder.setAckFinalIndicator(ackFinal);
2492 if (errorMessage != null) {
2493 responseBuilder.setResponseMessage(errorMessage);
2495 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2497 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2500 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2501 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2503 return Futures.immediateFuture(rpcResult);