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.base.Optional;
28 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
29 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
30 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
31 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
32 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
33 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
34 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
35 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
36 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
37 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
38 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
39 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationInput;
40 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationInputBuilder;
41 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationOutput;
42 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationOutputBuilder;
43 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationInput;
44 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationInputBuilder;
45 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationOutput;
46 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationOutputBuilder;
47 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationInput;
48 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationInputBuilder;
49 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationOutput;
50 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationOutputBuilder;
51 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModules;
52 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModulesBuilder;
53 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationInput;
54 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationInputBuilder;
55 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationOutput;
56 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationOutputBuilder;
57 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstances;
58 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstancesBuilder;
59 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationInput;
60 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationInputBuilder;
61 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationOutput;
62 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationOutputBuilder;
63 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfs;
64 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfsBuilder;
65 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VNFAPIService;
66 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationInput;
67 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationInputBuilder;
68 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationOutput;
69 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationOutputBuilder;
70 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModules;
71 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModulesBuilder;
72 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationInput;
73 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationInputBuilder;
74 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationOutput;
75 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationOutputBuilder;
76 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstances;
77 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstancesBuilder;
78 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationInput;
79 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationInputBuilder;
80 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationOutput;
81 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationOutputBuilder;
82 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.Vnfs;
83 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfsBuilder;
84 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.network.information.NetworkInformationBuilder;
85 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.data.PreloadData;
86 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.data.PreloadDataBuilder;
87 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadList;
88 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadListBuilder;
89 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadListKey;
90 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadList;
91 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadListBuilder;
92 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadListKey;
93 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadList;
94 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadListBuilder;
95 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadListKey;
96 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.request.information.RequestInformation;
97 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.sdnc.request.header.SdncRequestHeader;
98 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.sdnc.request.header.SdncRequestHeader.SvcAction;
99 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.data.ServiceData;
100 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.data.ServiceDataBuilder;
101 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus;
102 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RequestStatus;
103 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RpcAction;
104 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RpcName;
105 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.VnfsdnAction;
106 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.VnfsdnSubaction;
107 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatusBuilder;
108 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.information.VfModuleInformationBuilder;
109 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleList;
110 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleListBuilder;
111 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleListKey;
112 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.preload.data.VfModulePreloadData;
113 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.preload.data.VfModulePreloadDataBuilder;
114 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.service.data.VfModuleServiceData;
115 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.service.data.VfModuleServiceDataBuilder;
116 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.information.VnfInformationBuilder;
117 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.information.VnfInstanceInformationBuilder;
118 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceList;
119 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceListBuilder;
120 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceListKey;
121 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.preload.data.VnfInstancePreloadData;
122 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.preload.data.VnfInstancePreloadDataBuilder;
123 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.service.data.VnfInstanceServiceData;
124 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.service.data.VnfInstanceServiceDataBuilder;
125 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfList;
126 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfListBuilder;
127 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfListKey;
128 import org.opendaylight.yangtools.yang.binding.DataObject;
129 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
130 import org.opendaylight.yangtools.yang.common.RpcResult;
131 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
132 import org.opendaylight.yangtools.yang.data.api.schema.tree.ModifiedNodeDoesNotExistException;
133 import org.slf4j.Logger;
134 import org.slf4j.LoggerFactory;
135 import org.slf4j.MDC;
138 import java.text.DateFormat;
139 import java.text.SimpleDateFormat;
140 import java.util.Date;
141 import java.util.Properties;
142 import java.util.TimeZone;
143 import java.util.concurrent.ExecutionException;
144 import java.util.concurrent.ExecutorService;
145 import java.util.concurrent.Executors;
146 import java.util.ArrayList;
147 import java.util.concurrent.Future;
150 * Defines a base implementation for your provider. This class extends from a helper class which provides storage for
151 * the most commonly used components of the MD-SAL. Additionally the base class provides some basic logging and
152 * initialization / clean up methods.
154 public class VnfApiProvider implements AutoCloseable, VNFAPIService, DataChangeListener {
156 private final Logger log = LoggerFactory.getLogger(VnfApiProvider.class);
157 private final ExecutorService executor;
159 private static final String APP_NAME = "vnfapi";
160 private static final String VNF_API = "VNF-API";
161 private static final String OPERATIONAL_DATA = "operational-data";
163 private static final String READ_MD_SAL_STR = "Read MD-SAL (";
164 private static final String DATA_FOR_STR = ") data for [";
165 private static final String SERVICE_DATA_STR = "] ServiceData: ";
166 private static final String NO_DATA_FOUND_STR = "No data found in MD-SAL (";
167 private static final String EXCEPTION_READING_MD_SAL_STR = "Caught Exception reading MD-SAL (";
168 private static final String FOR_STR = ") for [";
169 private static final String INVALID_INPUT_VF_MODULE_STR = "invalid input, null or empty vf-module-id";
170 private static final String UPDATED_MD_SAL_STR = "Updated MD-SAL for ";
171 private static final String RETURNED_SUCCESS_STR = "Returned SUCCESS for ";
172 private static final String UPDATING_OPERATIONAL_TREE_STR = "Updating OPERATIONAL tree.";
173 private static final String UPDATING_MD_SAL_STR = "Updating MD-SAL for ";
174 private static final String CAUGHT_EXCEPTION_STR = "Caught Exception updating MD-SAL for ";
175 private static final String RETURNED_FAILED_STR = "Returned FAILED for ";
176 private static final String ADDING_INPUT_DATA_STR = "Adding INPUT data for ";
177 private static final String ADDING_OPERATIONAL_DATA_STR = "Adding OPERATIONAL data for ";
178 private static final String OPERATIONAL_DATA_STR = "] operational-data: ";
179 private static final String ADDING_CONFIG_DATA_STR = "Adding CONFIG data for ";
180 private static final String INPUT_STR = "] input: ";
181 private static final String CALLED_STR = " called.";
182 private static final String EXITING_STR = "exiting ";
183 private static final String INVALID_INPUT_VNF_INSTANCE_STR = "invalid input, null or empty vnf-instance-id";
185 private VNFSDNSvcLogicServiceClient svcLogicClient;
186 protected DataBroker dataBroker;
187 protected NotificationPublishService notificationService;
188 protected RpcProviderRegistry rpcRegistry;
189 protected BindingAwareBroker.RpcRegistration<VNFAPIService> rpcRegistration;
191 public VnfApiProvider(DataBroker dataBroker2, NotificationPublishService notificationPublishService,
192 RpcProviderRegistry rpcProviderRegistry, VNFSDNSvcLogicServiceClient client) {
193 log.info("Creating provider for " + APP_NAME);
194 executor = Executors.newFixedThreadPool(1);
195 dataBroker = dataBroker2;
196 notificationService = notificationPublishService;
197 rpcRegistry = rpcProviderRegistry;
198 svcLogicClient = client;
202 private void initialize() {
203 log.info("Initializing provider for " + APP_NAME);
204 // Create the top level containers
207 VnfSdnUtil.loadProperties();
208 } catch (Exception e) {
209 log.error("Caught Exception while trying to load properties file: ", e);
212 log.info("Initialization complete for " + APP_NAME);
215 private void createContainers() {
216 final WriteTransaction t = dataBroker.newReadWriteTransaction();
218 // Create the Vnfs container
219 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
220 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
222 // Create the PreloadVnfs container
223 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
224 new PreloadVnfsBuilder().build());
225 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
226 new PreloadVnfsBuilder().build());
228 // 1610 Create the PreloadVnfInstances container
229 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfInstances.class),
230 new PreloadVnfInstancesBuilder().build());
231 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfInstances.class),
232 new PreloadVnfInstancesBuilder().build());
234 // 1610 Create the VnfInstances container
235 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VnfInstances.class),
236 new VnfInstancesBuilder().build());
237 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VnfInstances.class),
238 new VnfInstancesBuilder().build());
240 // 1610 Create the PreloadVfModules container
241 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVfModules.class),
242 new PreloadVfModulesBuilder().build());
243 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVfModules.class),
244 new PreloadVfModulesBuilder().build());
246 // 1610 Create the VfModules container
247 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VfModules.class),
248 new VfModulesBuilder().build());
249 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VfModules.class),
250 new VfModulesBuilder().build());
253 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
255 log.info("Create Containers succeeded!: ");
257 } catch (InterruptedException | ExecutionException e) {
258 log.error("Create Containers Failed: " + e);
263 public void close() throws Exception {
264 log.info("Closing provider for " + APP_NAME);
266 rpcRegistration.close();
267 log.info("Successfully closed provider for " + APP_NAME);
270 // On data change not used
272 public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
274 log.info(" IN ON DATA CHANGE: ");
276 boolean changed = false;
277 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
278 DataObject updatedSubTree = change.getUpdatedSubtree();
280 if (updatedSubTree != null) {
281 if (log.isDebugEnabled()) {
282 log.debug("updatedSubTree was non-null:" + updatedSubTree);
284 if (updatedSubTree instanceof Vnfs) {
285 changed = isChanged(changed, (Vnfs) updatedSubTree);
287 if (updatedSubTree instanceof PreloadVnfs) {
288 changed = isChanged(changed, (PreloadVnfs) updatedSubTree);
291 if (updatedSubTree instanceof PreloadVnfInstances) {
292 changed = isChanged(changed, (PreloadVnfInstances) updatedSubTree);
295 if (updatedSubTree instanceof VnfInstances) {
296 changed = isChanged(changed, (VnfInstances) updatedSubTree);
299 if (updatedSubTree instanceof PreloadVfModules) {
300 changed = isChanged(changed, (PreloadVfModules) updatedSubTree);
303 if (updatedSubTree instanceof VfModules) {
304 changed = isChanged(changed, (VfModules) updatedSubTree);
308 // Do the write transaction only if something changed.
310 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = writeTransaction.submit();
311 Futures.addCallback(checkedFuture, new FutureCallback<Void>() {
314 public void onSuccess(Void arg0) {
315 log.debug("Successfully updated Service Status");
319 public void onFailure(Throwable e) {
320 log.debug("Failed updating Service Status", e);
326 private boolean isChanged(boolean changed, VfModules updatedSubTree) {
327 ArrayList<VfModuleList> vfModuleList =
328 (ArrayList<VfModuleList>) updatedSubTree.getVfModuleList();
329 if (vfModuleList != null) {
330 for (VfModuleList entry : vfModuleList) {
331 VfModuleServiceData vfModuleServiceData = entry.getVfModuleServiceData();
332 ServiceStatus serviceStatus = entry.getServiceStatus();
333 if (vfModuleServiceData != null && serviceStatus != null) {
334 // VfModuleServiceData change detected, check the AckFinal indicator and request-status to
335 // see if we need to proceed.
336 return isChanged(changed, serviceStatus);
343 private boolean isChanged(boolean changed, PreloadVfModules updatedSubTree) {
344 ArrayList<VfModulePreloadList> vnfInstanceList =
345 (ArrayList<VfModulePreloadList>) updatedSubTree.getVfModulePreloadList();
346 if (vnfInstanceList != null) {
347 for (VfModulePreloadList entry : vnfInstanceList) {
348 VfModulePreloadData vnfInstancePreloadData = entry.getVfModulePreloadData();
349 if (vnfInstancePreloadData != null) {
357 private boolean isChanged(boolean changed, VnfInstances updatedSubTree) {
358 ArrayList<VnfInstanceList> vnfInstanceList =
359 (ArrayList<VnfInstanceList>) updatedSubTree.getVnfInstanceList();
360 if (vnfInstanceList != null) {
361 for (VnfInstanceList entry : vnfInstanceList) {
362 VnfInstanceServiceData vnfInstanceServiceData = entry.getVnfInstanceServiceData();
363 ServiceStatus serviceStatus = entry.getServiceStatus();
364 if (vnfInstanceServiceData != null && serviceStatus != null) {
365 // VnfInstanceServiceData change detected, check the AckFinal indicator and request-status
366 // to see if we need to proceed.
367 return isChanged(changed, serviceStatus);
374 private boolean isChanged(boolean changed, PreloadVnfInstances updatedSubTree) {
375 ArrayList<VnfInstancePreloadList> vnfInstanceList =
376 (ArrayList<VnfInstancePreloadList>) updatedSubTree
377 .getVnfInstancePreloadList();
378 if (vnfInstanceList != null) {
379 for (VnfInstancePreloadList entry : vnfInstanceList) {
380 VnfInstancePreloadData vnfInstancePreloadData = entry.getVnfInstancePreloadData();
381 if (vnfInstancePreloadData != null) {
389 private boolean isChanged(boolean changed, PreloadVnfs updatedSubTree) {
390 ArrayList<VnfPreloadList> vnfList =
391 (ArrayList<VnfPreloadList>) updatedSubTree.getVnfPreloadList();
392 if (vnfList != null) {
393 for (VnfPreloadList entry : vnfList) {
394 PreloadData preloadData = entry.getPreloadData();
395 if (preloadData != null) {
403 private boolean isChanged(boolean changed, Vnfs updatedSubTree) {
404 ArrayList<VnfList> vnfList = (ArrayList<VnfList>) updatedSubTree.getVnfList();
405 if (vnfList != null) {
406 for (VnfList entry : vnfList) {
407 ServiceData serviceData = entry.getServiceData();
408 ServiceStatus serviceStatus = entry.getServiceStatus();
409 if (serviceData != null && serviceStatus != null) {
411 // ServiceData change detected, check the AckFinal indicator and request-status to see if we need to proceed.
413 return isChanged(changed, serviceStatus);
420 private boolean isChanged(boolean changed, ServiceStatus serviceStatus) {
421 if ((!"Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete
422 .equals(serviceStatus.getRequestStatus()))) {
423 if (log.isDebugEnabled()) {
424 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
431 private static class Iso8601Util {
434 private static TimeZone tz = TimeZone.getTimeZone("UTC");
435 private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
437 private Iso8601Util() {
444 private static String now() {
445 return df.format(new Date());
449 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
451 serviceStatusBuilder.setResponseCode(errorCode);
452 serviceStatusBuilder.setResponseMessage(errorMessage);
453 serviceStatusBuilder.setFinalIndicator(ackFinal);
454 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
457 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
458 if (requestInformation != null && requestInformation.getRequestAction() != null) {
459 switch (requestInformation.getRequestAction()) {
460 case VNFActivateRequest:
461 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VNFActivateRequest);
463 case ChangeVNFActivateRequest:
464 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVNFActivateRequest);
466 case DisconnectVNFRequest:
467 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVNFRequest);
469 case PreloadVNFRequest:
470 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVNFRequest);
472 case DeletePreloadVNFRequest:
473 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DeletePreloadVNFRequest);
475 // 1610 vnf-instance Requests
476 case VnfInstanceActivateRequest:
477 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VnfInstanceActivateRequest);
479 case ChangeVnfInstanceActivateRequest:
480 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVnfInstanceActivateRequest);
482 case DisconnectVnfInstanceRequest:
483 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVnfInstanceRequest);
485 case PreloadVnfInstanceRequest:
486 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVnfInstanceRequest);
488 // 1610 vf-module Requests
489 case VfModuleActivateRequest:
490 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VfModuleActivateRequest);
492 case ChangeVfModuleActivateRequest:
493 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVfModuleActivateRequest);
495 case DisconnectVfModuleRequest:
496 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVfModuleRequest);
498 case PreloadVfModuleRequest:
499 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVfModuleRequest);
502 log.error("Unknown RequestAction: " + requestInformation.getRequestAction());
506 if (requestInformation != null && requestInformation.getRequestSubAction() != null) {
507 switch (requestInformation.getRequestSubAction()) {
509 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP);
512 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
515 log.error("Unknown RequestSubAction: " + requestInformation.getRequestSubAction());
521 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
522 if (requestHeader != null && requestHeader.getSvcAction() != null) {
523 switch (requestHeader.getSvcAction()) {
525 serviceStatusBuilder.setRpcAction(RpcAction.Reserve);
528 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
531 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
534 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
537 serviceStatusBuilder.setRpcAction(RpcAction.Changeassign);
540 serviceStatusBuilder.setRpcAction(RpcAction.Changedelete);
543 serviceStatusBuilder.setRpcAction(RpcAction.Rollback);
546 log.error("Unknown SvcAction: " + requestHeader.getSvcAction());
552 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
554 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
558 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
559 // See if any data exists yet for this siid, if so grab it.
560 InstanceIdentifier<VnfList> serviceInstanceIdentifier = InstanceIdentifier
562 .child(VnfList.class, new VnfListKey(siid))
565 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
566 Optional<VnfList> data = Optional.absent();
568 data = readTx.read(type, serviceInstanceIdentifier).get();
569 } catch (InterruptedException | ExecutionException e) {
570 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
573 if (data.isPresent()) {
574 ServiceData serviceData = (ServiceData) data.get().getServiceData();
575 if (serviceData != null) {
576 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + siid + SERVICE_DATA_STR + serviceData);
577 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
578 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
579 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
580 serviceDataBuilder.setVnfRequestInformation(serviceData.getVnfRequestInformation());
581 serviceDataBuilder.setVnfId(serviceData.getVnfId());
582 serviceDataBuilder.setVnfTopologyInformation(serviceData.getVnfTopologyInformation());
583 serviceDataBuilder.setOperStatus(serviceData.getOperStatus());
585 log.info("No service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
588 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
593 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder) {
595 getVnfInstanceServiceData(siid, vnfInstanceServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
599 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder,
600 LogicalDatastoreType type) {
601 // See if any data exists yet for this siid, if so grab it.
602 InstanceIdentifier<VnfInstanceList> vnfInstanceIdentifier = InstanceIdentifier
603 .builder(VnfInstances.class)
604 .child(VnfInstanceList.class, new VnfInstanceListKey(siid))
607 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
608 Optional<VnfInstanceList> data = Optional.absent();
610 data = readTx.read(type, vnfInstanceIdentifier).get();
611 } catch (InterruptedException | ExecutionException e) {
612 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
615 if (data.isPresent()) {
616 VnfInstanceServiceData vnfInstanceServiceData = data.get().getVnfInstanceServiceData();
617 if (vnfInstanceServiceData != null) {
618 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + siid + "] VnfInstanceServiceData: "
619 + vnfInstanceServiceData);
620 vnfInstanceServiceDataBuilder.setSdncRequestHeader(vnfInstanceServiceData.getSdncRequestHeader());
621 vnfInstanceServiceDataBuilder.setRequestInformation(vnfInstanceServiceData.getRequestInformation());
622 vnfInstanceServiceDataBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
623 vnfInstanceServiceDataBuilder
624 .setVnfInstanceRequestInformation(vnfInstanceServiceData.getVnfInstanceRequestInformation());
625 vnfInstanceServiceDataBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
626 vnfInstanceServiceDataBuilder
627 .setVnfInstanceTopologyInformation(vnfInstanceServiceData.getVnfInstanceTopologyInformation());
628 vnfInstanceServiceDataBuilder.setOperStatus(vnfInstanceServiceData.getOperStatus());
630 log.info("No vnf-instance-service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
633 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
638 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder) {
640 getVfModuleServiceData(siid, vfModuleServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
644 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder,
645 LogicalDatastoreType type) {
646 // See if any data exists yet for this siid, if so grab it.
647 InstanceIdentifier<VfModuleList> vfModuleIdentifier = InstanceIdentifier
648 .builder(VfModules.class)
649 .child(VfModuleList.class, new VfModuleListKey(siid))
652 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
653 Optional<VfModuleList> data = Optional.absent();
655 data = readTx.read(type, vfModuleIdentifier).get();
656 } catch (InterruptedException | ExecutionException e) {
657 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
660 if (data.isPresent()) {
661 VfModuleServiceData vfModuleServiceData = data.get().getVfModuleServiceData();
662 if (vfModuleServiceData != null) {
664 READ_MD_SAL_STR + type + DATA_FOR_STR + siid + "] VfModuleServiceData: " + vfModuleServiceData);
665 vfModuleServiceDataBuilder.setSdncRequestHeader(vfModuleServiceData.getSdncRequestHeader());
666 vfModuleServiceDataBuilder.setRequestInformation(vfModuleServiceData.getRequestInformation());
667 vfModuleServiceDataBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
668 vfModuleServiceDataBuilder
669 .setVfModuleRequestInformation(vfModuleServiceData.getVfModuleRequestInformation());
670 vfModuleServiceDataBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
671 vfModuleServiceDataBuilder
672 .setVfModuleTopologyInformation(vfModuleServiceData.getVfModuleTopologyInformation());
673 vfModuleServiceDataBuilder.setOperStatus(vfModuleServiceData.getOperStatus());
675 log.info("No vf-module-service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
678 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
683 private void getPreloadData(String vnfName, String vnfType, PreloadDataBuilder preloadDataBuilder) {
685 getPreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
688 private void getPreloadData(String preloadName, String preloadType, PreloadDataBuilder preloadDataBuilder,
689 LogicalDatastoreType type) {
690 // See if any data exists yet for this name/type, if so grab it.
691 InstanceIdentifier<VnfPreloadList> preloadInstanceIdentifier = InstanceIdentifier
692 .builder(PreloadVnfs.class)
693 .child(VnfPreloadList.class, new VnfPreloadListKey(preloadName, preloadType))
696 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
697 Optional<VnfPreloadList> data = Optional.absent();
699 data = readTx.read(type, preloadInstanceIdentifier).get();
700 } catch (InterruptedException | ExecutionException e) {
701 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ",
705 if (data.isPresent()) {
706 PreloadData preloadData = (PreloadData) data.get().getPreloadData();
707 if (preloadData != null) {
708 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType + "] PreloadData: "
710 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
711 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
712 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
715 "No preload-data found in MD-SAL (" + type + FOR_STR + preloadName + "," + preloadType + "] ");
718 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
722 //1610 preload-vnf-instance
723 private void getVnfInstancePreloadData(String vnfName, String vnfType,
724 VnfInstancePreloadDataBuilder preloadDataBuilder) {
726 getVnfInstancePreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
729 //1610 preload-vnf-instance
730 private void getVnfInstancePreloadData(String preloadName, String preloadType,
731 VnfInstancePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
732 // See if any data exists yet for this name/type, if so grab it.
733 InstanceIdentifier<VnfInstancePreloadList> preloadInstanceIdentifier = InstanceIdentifier
734 .builder(PreloadVnfInstances.class)
735 .child(VnfInstancePreloadList.class, new VnfInstancePreloadListKey(preloadName, preloadType))
738 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
739 Optional<VnfInstancePreloadList> data = Optional.absent();
741 data = readTx.read(type, preloadInstanceIdentifier).get();
742 } catch (InterruptedException | ExecutionException e) {
743 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ",
747 if (data.isPresent()) {
748 VnfInstancePreloadData preloadData = (VnfInstancePreloadData) data.get().getVnfInstancePreloadData();
749 if (preloadData != null) {
750 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType
751 + "] VnfInstancePreloadData: " + preloadData);
752 preloadDataBuilder.setVnfInstanceTopologyInformation(preloadData.getVnfInstanceTopologyInformation());
753 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
755 log.info("No vnf-instance-preload-data found in MD-SAL (" + type + FOR_STR + preloadName + ","
756 + preloadType + "] ");
759 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
763 // 1610 preload-vf-module
764 private void getVfModulePreloadData(String vnfName, String vnfType,
765 VfModulePreloadDataBuilder preloadDataBuilder) {
767 getVfModulePreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
770 private void getVfModulePreloadData(String preloadName, String preloadType,
771 VfModulePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
772 // See if any data exists yet for this name/type, if so grab it.
773 InstanceIdentifier<VfModulePreloadList> preloadInstanceIdentifier = InstanceIdentifier
774 .builder(PreloadVfModules.class)
775 .child(VfModulePreloadList.class, new VfModulePreloadListKey(preloadName, preloadType))
778 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
779 Optional<VfModulePreloadList> data = Optional.absent();
782 data = readTx.read(type, preloadInstanceIdentifier).get();
783 } catch (InterruptedException | ExecutionException e) {
784 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ",
788 if (data.isPresent()) {
789 VfModulePreloadData preloadData = (VfModulePreloadData) data.get().getVfModulePreloadData();
790 if (preloadData != null) {
791 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType
792 + "] VfModulePreloadData: " + preloadData);
793 preloadDataBuilder.setVfModuleTopologyInformation(preloadData.getVfModuleTopologyInformation());
794 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
797 "No preload-data found in MD-SAL (" + type + FOR_STR + preloadName + "," + preloadType + "] ");
800 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
804 private void deleteVnfList(final VnfList entry, LogicalDatastoreType storeType) {
805 // Each entry will be identifiable by a unique key, we have to create that identifier
806 InstanceIdentifier<VnfList> path = InstanceIdentifier
808 .child(VnfList.class, entry.getKey())
811 int optimisticLockTries = 2;
812 boolean tryAgain = true;
816 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
817 tx.delete(storeType, path);
818 tx.submit().checkedGet();
819 log.debug("DataStore delete succeeded");
820 } catch (OptimisticLockFailedException e) {
821 if (--optimisticLockTries <= 0) {
822 log.debug("Got OptimisticLockFailedException on last try - failing ");
823 throw new IllegalStateException(e);
825 log.debug("Got OptimisticLockFailedException - trying again ");
828 } catch (final TransactionCommitFailedException e) {
830 if (e.getCause() instanceof ModifiedNodeDoesNotExistException) {
831 log.debug("Ignoring MpdifiedNodeDoesNotExistException");
835 log.debug("Delete DataStore failed");
836 throw new IllegalStateException(e);
841 private void saveVnfList(final VnfList entry, boolean merge, LogicalDatastoreType storeType) {
842 // Each entry will be identifiable by a unique key, we have to create that identifier
843 InstanceIdentifier<VnfList> path = InstanceIdentifier
845 .child(VnfList.class, entry.getKey())
848 tryUpdateDataStore(entry, merge, storeType, path);
852 private void saveVnfInstanceList(final VnfInstanceList entry, boolean merge, LogicalDatastoreType storeType) {
853 // Each entry will be identifiable by a unique key, we have to create that identifier
854 InstanceIdentifier<VnfInstanceList> path = InstanceIdentifier
855 .builder(VnfInstances.class)
856 .child(VnfInstanceList.class, entry.getKey())
859 tryUpdateDataStore(entry, merge, storeType, path);
863 private void saveVfModuleList(final VfModuleList entry, boolean merge, LogicalDatastoreType storeType) {
864 // Each entry will be identifiable by a unique key, we have to create that identifier
865 InstanceIdentifier<VfModuleList> path = InstanceIdentifier
866 .builder(VfModules.class)
867 .child(VfModuleList.class, entry.getKey())
870 tryUpdateDataStore(entry, merge, storeType, path);
873 private void savePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) {
875 // Each entry will be identifiable by a unique key, we have to create that identifier
876 InstanceIdentifier<VnfPreloadList> path = InstanceIdentifier
877 .builder(PreloadVnfs.class)
878 .child(VnfPreloadList.class, entry.getKey())
881 tryUpdateDataStore(entry, merge, storeType, path);
884 //1610 preload vnf-instance
885 private void saveVnfInstancePreloadList(final VnfInstancePreloadList entry, boolean merge,
886 LogicalDatastoreType storeType) {
888 // Each entry will be identifiable by a unique key, we have to create that identifier
889 InstanceIdentifier<VnfInstancePreloadList> path = InstanceIdentifier
890 .builder(PreloadVnfInstances.class)
891 .child(VnfInstancePreloadList.class, entry.getKey())
894 tryUpdateDataStore(entry, merge, storeType, path);
897 //1610 preload vf-module
898 private void saveVfModulePreloadList(final VfModulePreloadList entry, boolean merge,
899 LogicalDatastoreType storeType) {
901 // Each entry will be identifiable by a unique key, we have to create that identifier
902 InstanceIdentifier<VfModulePreloadList> path = InstanceIdentifier
903 .builder(PreloadVfModules.class)
904 .child(VfModulePreloadList.class, entry.getKey())
907 tryUpdateDataStore(entry, merge, storeType, path);
910 private <T extends DataObject> void tryUpdateDataStore(T entry, boolean merge, LogicalDatastoreType storeType,
911 InstanceIdentifier<T> path) {
916 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
918 tx.merge(storeType, path, entry);
920 tx.put(storeType, path, entry);
922 tx.submit().checkedGet();
923 log.debug("Update DataStore succeeded");
925 } catch (OptimisticLockFailedException e) {
927 log.debug("Got OptimisticLockFailedException on last try - failing ");
928 throw new IllegalStateException(e);
930 log.debug("Got OptimisticLockFailedException - trying again ");
931 } catch (final TransactionCommitFailedException e) {
932 log.debug("Update DataStore failed");
933 throw new IllegalStateException(e);
938 //Save the requestId into MDC
939 private void setRequestIdAsMDC(String requestId) {
940 MDC.put("RequestId", requestId);
943 //1610 vnf-instance-topology-operation
945 public Future<RpcResult<VnfInstanceTopologyOperationOutput>> vnfInstanceTopologyOperation(
946 VnfInstanceTopologyOperationInput input) {
948 final String svcOperation = "vnf-instance-topology-operation";
949 VnfInstanceServiceData vnfInstanceServiceData;
950 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
951 Properties parms = new Properties();
953 log.info(svcOperation + CALLED_STR);
954 // create a new response object
955 VnfInstanceTopologyOperationOutputBuilder responseBuilder = new VnfInstanceTopologyOperationOutputBuilder();
957 if (input == null || input.getVnfInstanceRequestInformation() == null
958 || input.getVnfInstanceRequestInformation().getVnfInstanceId() == null) {
959 log.debug(EXITING_STR + svcOperation + " because of " + INVALID_INPUT_VNF_INSTANCE_STR);
960 responseBuilder.setResponseCode("403");
961 responseBuilder.setResponseMessage(INVALID_INPUT_VNF_INSTANCE_STR);
962 responseBuilder.setAckFinalIndicator("Y");
963 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
964 .<VnfInstanceTopologyOperationOutput>status(true)
965 .withResult(responseBuilder.build())
968 return Futures.immediateFuture(rpcResult);
971 // Grab the service instance ID from the input buffer
972 String viid = input.getVnfInstanceRequestInformation().getVnfInstanceId();
973 String preloadName = input.getVnfInstanceRequestInformation().getVnfInstanceName();
974 String preloadType = input.getVnfInstanceRequestInformation().getVnfModelId();
976 // Make sure we have a valid viid
977 if (viid == null || viid.length() == 0) {
978 log.debug(EXITING_STR + svcOperation + " because of invalid vnf-instance-id");
979 responseBuilder.setResponseCode("403");
980 responseBuilder.setResponseMessage(INVALID_INPUT_VNF_INSTANCE_STR);
981 responseBuilder.setAckFinalIndicator("Y");
982 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
983 .<VnfInstanceTopologyOperationOutput>status(true)
984 .withResult(responseBuilder.build())
987 return Futures.immediateFuture(rpcResult);
990 if (input.getSdncRequestHeader() != null) {
991 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
992 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
995 // Get vnf-instance-preload-data
996 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
997 getVnfInstancePreloadData(preloadName, preloadType, vnfInstancePreloadDataBuilder);
1000 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1001 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1003 // Get operational-data
1004 VnfInstanceServiceDataBuilder operDataBuilder = new VnfInstanceServiceDataBuilder();
1005 getVnfInstanceServiceData(viid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1007 // Set the serviceStatus based on input
1008 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1009 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1012 // setup a service-data object builder
1013 // ACTION vnf-topology-operationa
1015 // USES sdnc-request-header;
1016 // USES request-information;
1017 // USES service-information;
1018 // USES vnf-request-information
1020 // USES vnf-topology-response-body;
1021 // USES vnf-information
1022 // USES service-information
1024 // container service-data
1025 // uses vnf-configuration-information;
1026 // uses oper-status;
1028 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + viid + INPUT_STR + input);
1029 VnfInstanceTopologyOperationInputBuilder inputBuilder = new VnfInstanceTopologyOperationInputBuilder(input);
1030 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1032 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + viid + OPERATIONAL_DATA_STR + operDataBuilder
1034 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1037 ADDING_CONFIG_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preload-data: "
1038 + vnfInstancePreloadDataBuilder.build());
1039 VnfSdnUtil.toProperties(parms, "vnf-instance-preload-data", vnfInstancePreloadDataBuilder);
1041 // Call SLI sync method
1042 // Get SvcLogicService reference
1043 Properties respProps = null;
1044 String errorCode = "200";
1045 String errorMessage = null;
1046 String ackFinal = "Y";
1049 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1052 respProps = svcLogicClient
1053 .execute(VNF_API, svcOperation, null, "sync", vnfInstanceServiceDataBuilder, parms);
1054 } catch (Exception e) {
1055 log.error("Caught exception executing service logic for " + svcOperation, e);
1056 errorMessage = e.getMessage();
1060 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1063 } catch (Exception e) {
1065 errorMessage = e.getMessage();
1066 log.error("Caught exception looking for service logic", e);
1069 if (respProps != null) {
1070 errorCode = respProps.getProperty("error-code");
1071 errorMessage = respProps.getProperty("error-message");
1072 ackFinal = respProps.getProperty("ack-final", "Y");
1075 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1076 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1077 serviceStatusBuilder.setRpcName(RpcName.VnfInstanceTopologyOperation);
1079 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1080 responseBuilder.setResponseCode(errorCode);
1081 responseBuilder.setResponseMessage(errorMessage);
1082 responseBuilder.setAckFinalIndicator(ackFinal);
1083 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1084 vnfInstanceListBuilder.setVnfInstanceId(viid);
1085 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1087 saveVnfInstanceList(vnfInstanceListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1088 } catch (Exception e) {
1089 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + viid + "] \n", e);
1091 log.error(RETURNED_FAILED_STR + svcOperation + " [" + viid + "] " + responseBuilder.build());
1092 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
1093 .<VnfInstanceTopologyOperationOutput>status(true)
1094 .withResult(responseBuilder.build())
1097 return Futures.immediateFuture(rpcResult);
1100 // Got success from SLI
1102 vnfInstanceServiceData = vnfInstanceServiceDataBuilder.build();
1103 log.info(UPDATING_MD_SAL_STR + svcOperation + " [" + viid + "] VnfInstanceServiceData: "
1104 + vnfInstanceServiceData);
1105 // svc-configuration-list
1106 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1107 vnfInstanceListBuilder.setVnfInstanceServiceData(vnfInstanceServiceData);
1108 vnfInstanceListBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
1109 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1110 saveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1111 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1112 // Only update operational tree on Delete or Activate
1113 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1114 .getSvcAction().equals(SvcAction.Activate)) {
1115 log.info(UPDATING_OPERATIONAL_TREE_STR);
1116 saveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1119 VnfInstanceInformationBuilder vnfInstanceInformationBuilder = new VnfInstanceInformationBuilder();
1120 vnfInstanceInformationBuilder.setVnfInstanceId(viid);
1121 responseBuilder.setVnfInstanceInformation(vnfInstanceInformationBuilder.build());
1122 responseBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
1123 } catch (Exception e) {
1124 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + viid + "] \n", e);
1125 responseBuilder.setResponseCode("500");
1126 responseBuilder.setResponseMessage(e.toString());
1127 responseBuilder.setAckFinalIndicator("Y");
1128 log.error(RETURNED_FAILED_STR + svcOperation + " [" + viid + "] " + responseBuilder.build());
1129 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
1130 .<VnfInstanceTopologyOperationOutput>status(true)
1131 .withResult(responseBuilder.build())
1134 return Futures.immediateFuture(rpcResult);
1138 responseBuilder.setResponseCode(errorCode);
1139 responseBuilder.setAckFinalIndicator(ackFinal);
1140 if (errorMessage != null) {
1141 responseBuilder.setResponseMessage(errorMessage);
1143 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + viid + "] ");
1144 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + viid + "] " + responseBuilder.build());
1146 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
1147 .<VnfInstanceTopologyOperationOutput>status(true)
1148 .withResult(responseBuilder.build())
1151 return Futures.immediateFuture(rpcResult);
1154 //1610 vf-module-topology-operation
1156 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1157 VfModuleTopologyOperationInput input) {
1159 final String svcOperation = "vf-module-topology-operation";
1160 VfModuleServiceData vfModuleServiceData;
1161 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1162 Properties parms = new Properties();
1164 log.info(svcOperation + CALLED_STR);
1165 // create a new response object
1166 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1168 // Validate vf-module-id from vf-module-request-information
1169 if (input == null || input.getVfModuleRequestInformation() == null
1170 || input.getVfModuleRequestInformation().getVfModuleId() == null) {
1171 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty vf-module-id");
1172 responseBuilder.setResponseCode("403");
1173 responseBuilder.setResponseMessage(INVALID_INPUT_VF_MODULE_STR);
1174 responseBuilder.setAckFinalIndicator("Y");
1175 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1176 .<VfModuleTopologyOperationOutput>status(true)
1177 .withResult(responseBuilder.build())
1180 return Futures.immediateFuture(rpcResult);
1183 // Grab the vf-module-request-information.vf-module-id from the input buffer
1184 String vfid = input.getVfModuleRequestInformation().getVfModuleId();
1185 String preloadName = input.getVfModuleRequestInformation().getVfModuleName();
1186 String preloadType = input.getVfModuleRequestInformation().getVfModuleModelId();
1188 // Make sure we have a valid siid
1189 if (vfid == null || vfid.length() == 0) {
1190 log.debug(EXITING_STR + svcOperation + " because of invalid vf-module-id");
1191 responseBuilder.setResponseCode("403");
1192 responseBuilder.setResponseMessage(INVALID_INPUT_VF_MODULE_STR);
1193 responseBuilder.setAckFinalIndicator("Y");
1194 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1195 .<VfModuleTopologyOperationOutput>status(true)
1196 .withResult(responseBuilder.build())
1199 return Futures.immediateFuture(rpcResult);
1202 // 1610 add vf-module-id to vnf-instance-list.vf-module-relationship-list
1203 String viid = input.getVfModuleRequestInformation().getVnfInstanceId();
1205 if (viid == null || viid.length() == 0) {
1206 log.debug(EXITING_STR + svcOperation + " because of invalid vnf-instance-id");
1207 responseBuilder.setResponseCode("403");
1208 responseBuilder.setResponseMessage(INVALID_INPUT_VNF_INSTANCE_STR);
1209 responseBuilder.setAckFinalIndicator("Y");
1210 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1211 .<VfModuleTopologyOperationOutput>status(true)
1212 .withResult(responseBuilder.build())
1215 return Futures.immediateFuture(rpcResult);
1218 if (input.getSdncRequestHeader() != null) {
1219 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1220 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1223 // Get vf-module-preload-data
1224 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
1225 getVfModulePreloadData(preloadName, preloadType, vfModulePreloadDataBuilder);
1227 // Get vf-module-service-data
1228 VfModuleServiceDataBuilder vfModuleServiceDataBuilder = new VfModuleServiceDataBuilder();
1229 getVfModuleServiceData(vfid, vfModuleServiceDataBuilder);
1231 // Get vf-module operation-data
1232 VfModuleServiceDataBuilder operDataBuilder = new VfModuleServiceDataBuilder();
1233 getVfModuleServiceData(vfid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1235 // 1610 Need to pull vnf-instance-list.vf-module-relationship-list from MD-SAL
1236 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1237 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1239 // vnf-instance operational-data
1240 VnfInstanceServiceDataBuilder vnfInstanceOperDataBuilder = new VnfInstanceServiceDataBuilder();
1241 getVnfInstanceServiceData(viid, vnfInstanceOperDataBuilder, LogicalDatastoreType.OPERATIONAL);
1243 // Set the serviceStatus based on input
1244 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1245 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1248 // setup a service-data object builder
1249 // ACTION vnf-topology-operation
1251 // USES request-information;
1252 // USES service-information;
1253 // USES vnf-request-information
1255 // USES vnf-information
1256 // USES service-information
1258 // container service-data
1260 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + vfid + INPUT_STR + input);
1261 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1262 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1264 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + vfid + "] vf-module operational-data: "
1265 + operDataBuilder.build());
1266 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1268 log.info(ADDING_CONFIG_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
1269 + "] vf-module-preload-data: " + vfModulePreloadDataBuilder.build());
1270 VnfSdnUtil.toProperties(parms, "vf-module-preload-data", vfModulePreloadDataBuilder);
1272 log.info("Adding vnf-instance CONFIG data for " + svcOperation + " [" + viid + "] vnf-instance-service-data: "
1273 + vnfInstanceServiceDataBuilder.build());
1274 VnfSdnUtil.toProperties(parms, "vnf-instance-service-data", vnfInstanceServiceDataBuilder);
1276 log.info("Adding vnf-instance OPERATIONAL data for " + svcOperation + " [" + viid
1277 + "] vnf-instance operational-data: " + vnfInstanceOperDataBuilder.build());
1278 VnfSdnUtil.toProperties(parms, "vnf-instance-operational-data", vnfInstanceOperDataBuilder);
1280 // Call SLI sync method
1281 // Get SvcLogicService reference
1283 Properties respProps = null;
1284 String errorCode = "200";
1285 String errorMessage = null;
1286 String ackFinal = "Y";
1289 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1292 respProps = svcLogicClient
1293 .execute(VNF_API, svcOperation, null, "sync", vfModuleServiceDataBuilder, parms);
1294 } catch (Exception e) {
1295 log.error("Caught exception executing service logic on vf-module for " + svcOperation, e);
1296 errorMessage = e.getMessage();
1301 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1304 } catch (Exception e) {
1306 errorMessage = e.getMessage();
1307 log.error("Caught exception looking for service logic", e);
1310 if (respProps != null) {
1311 errorCode = respProps.getProperty("error-code");
1312 errorMessage = respProps.getProperty("error-message");
1313 ackFinal = respProps.getProperty("ack-final", "Y");
1316 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1317 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1318 serviceStatusBuilder.setRpcName(RpcName.VfModuleTopologyOperation);
1320 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1321 responseBuilder.setResponseCode(errorCode);
1322 responseBuilder.setResponseMessage(errorMessage);
1323 responseBuilder.setAckFinalIndicator(ackFinal);
1324 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1325 vfModuleListBuilder.setVfModuleId(vfid);
1326 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1328 saveVfModuleList(vfModuleListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1329 } catch (Exception e) {
1330 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + vfid + "] \n", e);
1332 log.error(RETURNED_FAILED_STR + svcOperation + " [" + vfid + "] " + responseBuilder.build());
1333 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1334 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1337 return Futures.immediateFuture(rpcResult);
1340 // Got success from SLI
1341 // save vf-module-service-data in MD-SAL
1343 vfModuleServiceData = vfModuleServiceDataBuilder.build();
1345 UPDATING_MD_SAL_STR + svcOperation + " [" + vfid + "] VfModuleServiceData: " + vfModuleServiceData);
1347 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1348 vfModuleListBuilder.setVfModuleServiceData(vfModuleServiceData);
1349 vfModuleListBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
1350 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1351 saveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1352 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1353 // Only update operational tree on Delete or Activate
1354 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1355 .getSvcAction().equals(SvcAction.Activate)) {
1356 log.info(UPDATING_OPERATIONAL_TREE_STR);
1357 saveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1360 VfModuleInformationBuilder vfModuleInformationBuilder = new VfModuleInformationBuilder();
1361 vfModuleInformationBuilder.setVfModuleId(vfid);
1362 responseBuilder.setVfModuleInformation(vfModuleInformationBuilder.build());
1363 responseBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
1364 } catch (Exception e) {
1365 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + vfid + "] \n", e);
1366 responseBuilder.setResponseCode("500");
1367 responseBuilder.setResponseMessage(e.toString());
1368 responseBuilder.setAckFinalIndicator("Y");
1369 log.error(RETURNED_FAILED_STR + svcOperation + " [" + vfid + "] " + responseBuilder.build());
1370 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1371 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1374 return Futures.immediateFuture(rpcResult);
1378 responseBuilder.setResponseCode(errorCode);
1379 responseBuilder.setAckFinalIndicator(ackFinal);
1380 if (errorMessage != null) {
1381 responseBuilder.setResponseMessage(errorMessage);
1383 log.info("Updated vf-module in MD-SAL for " + svcOperation + " [" + vfid + "] ");
1384 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + vfid + "] " + responseBuilder.build());
1386 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1387 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1389 return Futures.immediateFuture(rpcResult);
1393 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
1394 final String svcOperation = "vnf-topology-operation";
1395 ServiceData serviceData;
1396 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1397 Properties parms = new Properties();
1399 log.info(svcOperation + CALLED_STR);
1400 // create a new response object
1401 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1403 if (input == null || input.getServiceInformation() == null
1404 || input.getServiceInformation().getServiceInstanceId() == null
1405 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1406 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty service-instance-id");
1407 responseBuilder.setResponseCode("403");
1408 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1409 responseBuilder.setAckFinalIndicator("Y");
1410 RpcResult<VnfTopologyOperationOutput> rpcResult =
1411 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1413 return Futures.immediateFuture(rpcResult);
1416 if (input.getVnfRequestInformation() == null || input.getVnfRequestInformation().getVnfId() == null
1417 || input.getVnfRequestInformation().getVnfId().length() == 0) {
1418 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty vf-module-id");
1419 responseBuilder.setResponseCode("403");
1420 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1421 responseBuilder.setAckFinalIndicator("Y");
1422 RpcResult<VnfTopologyOperationOutput> rpcResult =
1423 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1425 return Futures.immediateFuture(rpcResult);
1428 // Grab the service instance ID from the input buffer
1429 String siid = input.getVnfRequestInformation().getVnfId();
1430 String preloadName = input.getVnfRequestInformation().getVnfName();
1431 String preloadType = input.getVnfRequestInformation().getVnfType();
1433 if (input.getSdncRequestHeader() != null) {
1434 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1435 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1438 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1439 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1441 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1442 getServiceData(siid, serviceDataBuilder);
1444 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1445 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1447 // Set the serviceStatus based on input
1448 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1449 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1452 // setup a service-data object builder
1453 // ACTION vnf-topology-operation
1455 // USES request-information;
1456 // USES vnf-request-information
1458 // USES vnf-information
1459 // USES service-information
1461 // container service-data
1462 // uses oper-status;
1464 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + siid + INPUT_STR + input);
1465 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1466 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1468 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + siid + OPERATIONAL_DATA_STR + operDataBuilder
1470 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1473 "Adding CONFIG data for " + svcOperation + " [" + preloadName + "," + preloadType + "] preload-data: "
1474 + preloadDataBuilder.build());
1475 VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1477 // Call SLI sync method
1478 // Get SvcLogicService reference
1479 Properties respProps = null;
1480 String errorCode = "200";
1481 String errorMessage = null;
1482 String ackFinal = "Y";
1485 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1489 svcLogicClient.execute(VNF_API, svcOperation, null, "sync", serviceDataBuilder, parms);
1490 } catch (Exception e) {
1491 log.error("Caught exception executing service logic for " + svcOperation, e);
1492 errorMessage = e.getMessage();
1496 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1499 } catch (Exception e) {
1501 errorMessage = e.getMessage();
1502 log.error("Caught exception looking for service logic", e);
1505 if (respProps != null) {
1506 errorCode = respProps.getProperty("error-code");
1507 errorMessage = respProps.getProperty("error-message");
1508 ackFinal = respProps.getProperty("ack-final", "Y");
1511 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1512 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1513 serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
1515 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1516 responseBuilder.setResponseCode(errorCode);
1517 responseBuilder.setResponseMessage(errorMessage);
1518 responseBuilder.setAckFinalIndicator(ackFinal);
1519 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1520 vnfListBuilder.setVnfId(siid);
1521 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1523 saveVnfList(vnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1524 } catch (Exception e) {
1525 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + siid + "] \n", e);
1527 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1528 RpcResult<VnfTopologyOperationOutput> rpcResult =
1529 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1531 return Futures.immediateFuture(rpcResult);
1534 // Got success from SLI
1536 serviceData = serviceDataBuilder.build();
1537 log.info(UPDATING_MD_SAL_STR + svcOperation + " [" + siid + "] ServiceData: " + serviceData);
1538 // svc-configuration-list
1539 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1540 vnfListBuilder.setServiceData(serviceData);
1541 vnfListBuilder.setVnfId(serviceData.getVnfId());
1542 siid = serviceData.getVnfId();
1543 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1544 saveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1545 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1546 // Only update operational tree on Delete or Activate
1547 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1548 log.info(UPDATING_OPERATIONAL_TREE_STR);
1549 saveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1550 } else if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input
1551 .getSdncRequestHeader().getSvcAction().equals(SvcAction.Rollback)) {
1552 log.info("Delete OPERATIONAL tree.");
1553 deleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
1554 deleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
1557 VnfInformationBuilder vnfInformationBuilder = new VnfInformationBuilder();
1558 vnfInformationBuilder.setVnfId(siid);
1559 responseBuilder.setVnfInformation(vnfInformationBuilder.build());
1560 responseBuilder.setServiceInformation(serviceData.getServiceInformation());
1561 } catch (Exception e) {
1562 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + siid + "] \n", e);
1563 responseBuilder.setResponseCode("500");
1564 responseBuilder.setResponseMessage(e.toString());
1565 responseBuilder.setAckFinalIndicator("Y");
1566 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1567 RpcResult<VnfTopologyOperationOutput> rpcResult =
1568 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1570 return Futures.immediateFuture(rpcResult);
1574 responseBuilder.setResponseCode(errorCode);
1575 responseBuilder.setAckFinalIndicator(ackFinal);
1576 if (errorMessage != null) {
1577 responseBuilder.setResponseMessage(errorMessage);
1579 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + siid + "] ");
1580 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1582 RpcResult<VnfTopologyOperationOutput> rpcResult =
1583 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1585 return Futures.immediateFuture(rpcResult);
1589 public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1590 NetworkTopologyOperationInput input) {
1592 final String svcOperation = "network-topology-operation";
1593 ServiceData serviceData;
1594 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1595 Properties parms = new Properties();
1597 log.info(svcOperation + CALLED_STR);
1598 // create a new response object
1599 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1601 if (input == null || input.getServiceInformation() == null
1602 || input.getServiceInformation().getServiceInstanceId() == null
1603 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1604 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty service-instance-id");
1605 responseBuilder.setResponseCode("403");
1606 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1607 responseBuilder.setAckFinalIndicator("Y");
1608 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1609 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1612 return Futures.immediateFuture(rpcResult);
1615 if (input.getNetworkRequestInformation() == null
1616 || input.getNetworkRequestInformation().getNetworkName() == null) {
1617 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty service-instance-id");
1618 responseBuilder.setResponseCode("403");
1619 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1620 responseBuilder.setAckFinalIndicator("Y");
1621 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1622 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1625 return Futures.immediateFuture(rpcResult);
1628 // Grab the service instance ID from the input buffer
1630 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Assign)) {
1631 siid = input.getNetworkRequestInformation().getNetworkName();
1633 siid = input.getNetworkRequestInformation().getNetworkId();
1635 String preloadName = input.getNetworkRequestInformation().getNetworkName();
1636 String preloadType = input.getNetworkRequestInformation().getNetworkType();
1638 if (input.getSdncRequestHeader() != null) {
1639 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1640 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1643 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1644 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1646 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + siid + INPUT_STR + input);
1647 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1648 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1650 // Call SLI sync method
1651 // Get SvcLogicService reference
1652 Properties respProps = null;
1653 String errorCode = "200";
1654 String errorMessage = null;
1655 String ackFinal = "Y";
1656 String networkId = "error";
1659 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1663 svcLogicClient.execute(VNF_API, svcOperation, null, "sync", preloadDataBuilder, parms);
1664 } catch (Exception e) {
1665 log.error("Caught exception executing service logic for " + svcOperation, e);
1666 errorMessage = e.getMessage();
1670 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1673 } catch (Exception e) {
1675 errorMessage = e.getMessage();
1676 log.error("Caught exception looking for service logic", e);
1679 if (respProps != null) {
1680 errorCode = respProps.getProperty("error-code");
1681 errorMessage = respProps.getProperty("error-message");
1682 ackFinal = respProps.getProperty("ack-final", "Y");
1683 networkId = respProps.getProperty("networkId", "0");
1686 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1687 responseBuilder.setResponseCode(errorCode);
1688 responseBuilder.setResponseMessage(errorMessage);
1689 responseBuilder.setAckFinalIndicator(ackFinal);
1691 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1693 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1694 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1697 return Futures.immediateFuture(rpcResult);
1700 // Got success from SLI
1702 NetworkInformationBuilder networkInformationBuilder = new NetworkInformationBuilder();
1703 networkInformationBuilder.setNetworkId(networkId);
1704 responseBuilder.setNetworkInformation(networkInformationBuilder.build());
1705 responseBuilder.setServiceInformation(input.getServiceInformation());
1706 } catch (IllegalStateException e) {
1707 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + siid + "] \n", e);
1708 responseBuilder.setResponseCode("500");
1709 responseBuilder.setResponseMessage(e.toString());
1710 responseBuilder.setAckFinalIndicator("Y");
1711 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1712 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1713 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1716 return Futures.immediateFuture(rpcResult);
1720 responseBuilder.setResponseCode(errorCode);
1721 responseBuilder.setAckFinalIndicator(ackFinal);
1722 if (errorMessage != null) {
1723 responseBuilder.setResponseMessage(errorMessage);
1725 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + siid + "] ");
1726 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1728 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1729 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1731 return Futures.immediateFuture(rpcResult);
1735 public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1736 PreloadVnfTopologyOperationInput input) {
1738 final String svcOperation = "preload-vnf-topology-operation";
1739 PreloadData preloadData;
1740 Properties parms = new Properties();
1742 log.info(svcOperation + CALLED_STR);
1743 // create a new response object
1744 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1746 // Result from savePreloadData
1748 if (input == null || input.getVnfTopologyInformation() == null
1749 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null
1750 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName() == null
1751 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType() == null) {
1752 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty vnf-name or vnf-type");
1753 responseBuilder.setResponseCode("403");
1754 responseBuilder.setResponseMessage("invalid input, null or empty vnf-name or vnf-type");
1755 responseBuilder.setAckFinalIndicator("Y");
1756 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1757 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1759 return Futures.immediateFuture(rpcResult);
1762 // Grab the name and type from the input buffer
1763 String preloadName = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1764 String preloadType = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1766 // Make sure we have a preload_name and preload_type
1767 if (preloadName == null || preloadName.length() == 0) {
1768 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
1769 responseBuilder.setResponseCode("403");
1770 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1771 responseBuilder.setAckFinalIndicator("Y");
1772 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1773 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1775 return Futures.immediateFuture(rpcResult);
1777 if (preloadType == null || preloadType.length() == 0) {
1778 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
1779 responseBuilder.setResponseCode("403");
1780 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1781 responseBuilder.setAckFinalIndicator("Y");
1782 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1783 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1785 return Futures.immediateFuture(rpcResult);
1788 if (input.getSdncRequestHeader() != null) {
1789 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1790 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1793 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1794 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1795 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1796 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1799 // setup a preload-data object builder
1800 // ACTION vnf-topology-operation
1802 // USES request-information;
1803 // uses vnf-topology-information;
1806 // container preload-data
1808 ADDING_INPUT_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
1809 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1810 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1811 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
1812 + OPERATIONAL_DATA_STR + operDataBuilder.build());
1813 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1815 // Call SLI sync method
1816 // Get SvcLogicService reference
1817 Properties respProps = null;
1818 String errorCode = "200";
1819 String errorMessage = null;
1820 String ackFinal = "Y";
1823 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1827 svcLogicClient.execute(VNF_API, svcOperation, null, "sync", preloadDataBuilder, parms);
1828 } catch (Exception e) {
1829 log.error("Caught exception executing service logic for " + svcOperation, e);
1830 errorMessage = e.getMessage();
1834 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1837 } catch (Exception e) {
1839 errorMessage = e.getMessage();
1840 log.error("Caught exception looking for service logic", e);
1843 if (respProps != null) {
1844 errorCode = respProps.getProperty("error-code");
1845 errorMessage = respProps.getProperty("error-message");
1846 ackFinal = respProps.getProperty("ack-final", "Y");
1849 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1851 responseBuilder.setResponseCode(errorCode);
1852 responseBuilder.setResponseMessage(errorMessage);
1853 responseBuilder.setAckFinalIndicator(ackFinal);
1855 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1856 preloadVnfListBuilder.setVnfName(preloadName);
1857 preloadVnfListBuilder.setVnfType(preloadType);
1858 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1860 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
1861 + errorCode + "', Reason: '" + errorMessage + "'");
1863 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1864 } catch (Exception e) {
1866 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
1869 log.debug("Sending Success rpc result due to external error");
1870 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1871 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1873 return Futures.immediateFuture(rpcResult);
1876 // Got success from SLI
1878 preloadData = preloadDataBuilder.build();
1880 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
1882 // svc-configuration-list
1883 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1884 preloadVnfListBuilder.setVnfName(preloadName);
1885 preloadVnfListBuilder.setVnfType(preloadType);
1886 preloadVnfListBuilder.setPreloadData(preloadData);
1888 // SDNGC-989 set merge flag to false
1889 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1890 log.info(UPDATING_OPERATIONAL_TREE_STR);
1891 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1892 } catch (Exception e) {
1893 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
1895 responseBuilder.setResponseCode("500");
1896 responseBuilder.setResponseMessage(e.toString());
1897 responseBuilder.setAckFinalIndicator("Y");
1898 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
1899 + responseBuilder.build());
1900 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1901 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(false).withResult(responseBuilder.build())
1903 return Futures.immediateFuture(rpcResult);
1907 responseBuilder.setResponseCode(errorCode);
1908 responseBuilder.setAckFinalIndicator(ackFinal);
1909 if (errorMessage != null) {
1910 responseBuilder.setResponseMessage(errorMessage);
1912 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
1914 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
1917 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1918 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1920 return Futures.immediateFuture(rpcResult);
1923 //1610 preload-vnf-instance-topology-operation
1925 public Future<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> preloadVnfInstanceTopologyOperation(
1926 PreloadVnfInstanceTopologyOperationInput input) {
1928 final String svcOperation = "preload-vnf-instance-topology-operation";
1929 VnfInstancePreloadData vnfInstancePreloadData;
1930 Properties parms = new Properties();
1932 log.info(svcOperation + CALLED_STR);
1933 // create a new response object
1934 PreloadVnfInstanceTopologyOperationOutputBuilder responseBuilder =
1935 new PreloadVnfInstanceTopologyOperationOutputBuilder();
1937 if (input == null || input.getVnfInstanceTopologyInformation() == null
1938 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName() == null
1939 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId() == null) {
1940 log.debug(EXITING_STR + svcOperation
1941 + " because of invalid input, null or empty vnf-instance-name or vnf-model-id");
1942 responseBuilder.setResponseCode("403");
1943 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name or vnf-model-id");
1944 responseBuilder.setAckFinalIndicator("Y");
1945 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1946 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1947 .withResult(responseBuilder.build()).build();
1948 return Futures.immediateFuture(rpcResult);
1951 // Grab the name and type from the input buffer
1952 String preloadName =
1953 input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName();
1954 String preloadType = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId();
1956 // Make sure we have a preloadName and preloadType
1957 if (preloadName == null || preloadName.length() == 0) {
1958 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
1959 responseBuilder.setResponseCode("403");
1960 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1961 responseBuilder.setAckFinalIndicator("Y");
1962 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1963 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1964 .withResult(responseBuilder.build()).build();
1965 return Futures.immediateFuture(rpcResult);
1967 if (preloadType == null || preloadType.length() == 0) {
1968 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
1969 responseBuilder.setResponseCode("403");
1970 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1971 responseBuilder.setAckFinalIndicator("Y");
1972 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1973 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1974 .withResult(responseBuilder.build()).build();
1975 return Futures.immediateFuture(rpcResult);
1978 if (input.getSdncRequestHeader() != null) {
1979 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1980 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1983 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
1984 getVnfInstancePreloadData(preloadName, preloadType, vnfInstancePreloadDataBuilder);
1986 VnfInstancePreloadDataBuilder operDataBuilder = new VnfInstancePreloadDataBuilder();
1987 getVnfInstancePreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1990 // setup a preload-data object builder
1991 // ACTION vnf-topology-operation
1993 // uses vnf-topology-information;
1995 // container preload-data
1997 ADDING_CONFIG_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
1998 PreloadVnfInstanceTopologyOperationInputBuilder inputBuilder =
1999 new PreloadVnfInstanceTopologyOperationInputBuilder(input);
2000 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2001 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
2002 + OPERATIONAL_DATA_STR + operDataBuilder.build());
2003 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
2005 // Call SLI sync method
2006 // Get SvcLogicService reference
2007 Properties respProps = null;
2008 String errorCode = "200";
2009 String errorMessage = null;
2010 String ackFinal = "Y";
2013 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
2016 respProps = svcLogicClient
2017 .execute(VNF_API, svcOperation, null, "sync", vnfInstancePreloadDataBuilder, parms);
2018 } catch (Exception e) {
2019 log.error("Caught exception executing service logic for " + svcOperation, e);
2020 errorMessage = e.getMessage();
2024 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
2027 } catch (Exception e) {
2029 errorMessage = e.getMessage();
2030 log.error("Caught exception looking for service logic", e);
2033 if (respProps != null) {
2034 errorCode = respProps.getProperty("error-code");
2035 errorMessage = respProps.getProperty("error-message");
2036 ackFinal = respProps.getProperty("ack-final", "Y");
2039 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2041 responseBuilder.setResponseCode(errorCode);
2042 responseBuilder.setResponseMessage(errorMessage);
2043 responseBuilder.setAckFinalIndicator(ackFinal);
2045 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2046 vnfInstancePreloadListBuilder.setVnfInstanceName(preloadName);
2047 vnfInstancePreloadListBuilder.setVnfModelId(preloadType);
2048 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadDataBuilder.build());
2050 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
2051 + errorCode + "', Reason: '" + errorMessage + "'");
2053 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), true,
2054 LogicalDatastoreType.CONFIGURATION);
2055 } catch (Exception e) {
2057 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2060 log.debug("Sending Success rpc result due to external error");
2061 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2062 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2063 .withResult(responseBuilder.build()).build();
2064 return Futures.immediateFuture(rpcResult);
2067 // Got success from SLI
2069 vnfInstancePreloadData = vnfInstancePreloadDataBuilder.build();
2071 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
2072 + vnfInstancePreloadData);
2073 // svc-configuration-list
2074 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2075 vnfInstancePreloadListBuilder.setVnfInstanceName(preloadName);
2076 vnfInstancePreloadListBuilder.setVnfModelId(preloadType);
2077 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadData);
2079 // SDNGC-989 set merge flag to false
2080 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false,
2081 LogicalDatastoreType.CONFIGURATION);
2082 log.info(UPDATING_OPERATIONAL_TREE_STR);
2083 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2084 } catch (Exception e) {
2085 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2087 responseBuilder.setResponseCode("500");
2088 responseBuilder.setResponseMessage(e.toString());
2089 responseBuilder.setAckFinalIndicator("Y");
2090 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
2091 + responseBuilder.build());
2092 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2093 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(false)
2094 .withResult(responseBuilder.build()).build();
2095 return Futures.immediateFuture(rpcResult);
2099 responseBuilder.setResponseCode(errorCode);
2100 responseBuilder.setAckFinalIndicator(ackFinal);
2101 if (errorMessage != null) {
2102 responseBuilder.setResponseMessage(errorMessage);
2104 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
2106 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
2109 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2110 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2112 return Futures.immediateFuture(rpcResult);
2116 //1610 preload-vf-module-topology-operation
2118 public Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2119 PreloadVfModuleTopologyOperationInput input) {
2121 final String svcOperation = "preload-vf-module-topology-operation";
2122 VfModulePreloadData vfModulePreloadData;
2123 Properties parms = new Properties();
2125 log.info(svcOperation + CALLED_STR);
2126 // create a new response object
2127 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder =
2128 new PreloadVfModuleTopologyOperationOutputBuilder();
2130 // Result from savePreloadData
2132 if (input == null || input.getVfModuleTopologyInformation() == null
2133 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName() == null
2134 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId() == null) {
2135 log.debug(EXITING_STR + svcOperation
2136 + " because of invalid input, null or empty vf-module-name or vf-module-model-id");
2137 responseBuilder.setResponseCode("403");
2138 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-name or vf-module-model-id");
2139 responseBuilder.setAckFinalIndicator("Y");
2140 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2141 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2142 .withResult(responseBuilder.build()).build();
2143 return Futures.immediateFuture(rpcResult);
2146 // Grab the name and type from the input buffer
2147 String preloadName = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName();
2148 String preloadType = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId();
2150 // Make sure we have a preloadName and preloadType
2151 if (preloadName == null || preloadName.length() == 0) {
2152 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
2153 responseBuilder.setResponseCode("403");
2154 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2155 responseBuilder.setAckFinalIndicator("Y");
2156 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2157 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2158 .withResult(responseBuilder.build()).build();
2159 return Futures.immediateFuture(rpcResult);
2161 if (preloadType == null || preloadType.length() == 0) {
2162 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
2163 responseBuilder.setResponseCode("403");
2164 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2165 responseBuilder.setAckFinalIndicator("Y");
2166 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2167 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2168 .withResult(responseBuilder.build()).build();
2169 return Futures.immediateFuture(rpcResult);
2172 if (input.getSdncRequestHeader() != null) {
2173 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2174 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2177 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
2178 getVfModulePreloadData(preloadName, preloadType, vfModulePreloadDataBuilder);
2180 VfModulePreloadDataBuilder operDataBuilder = new VfModulePreloadDataBuilder();
2181 getVfModulePreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2184 // setup a preload-data object builder
2185 // ACTION vnf-topology-operation
2187 // USES request-information;
2188 // uses vnf-topology-information;
2191 // container preload-data
2194 ADDING_INPUT_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
2195 PreloadVfModuleTopologyOperationInputBuilder inputBuilder =
2196 new PreloadVfModuleTopologyOperationInputBuilder(input);
2197 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2198 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
2199 + OPERATIONAL_DATA_STR + operDataBuilder.build());
2200 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
2202 // Call SLI sync method
2203 // Get SvcLogicService reference
2204 Properties respProps = null;
2205 String errorCode = "200";
2206 String errorMessage = null;
2207 String ackFinal = "Y";
2210 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
2212 respProps = svcLogicClient
2213 .execute(VNF_API, svcOperation, null, "sync", vfModulePreloadDataBuilder, parms);
2214 } catch (Exception e) {
2215 log.error("Caught exception executing service logic for " + svcOperation, e);
2216 errorMessage = e.getMessage();
2220 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
2223 } catch (Exception e) {
2225 errorMessage = e.getMessage();
2226 log.error("Caught exception looking for service logic", e);
2229 if (respProps != null) {
2230 errorCode = respProps.getProperty("error-code");
2231 errorMessage = respProps.getProperty("error-message");
2232 ackFinal = respProps.getProperty("ack-final", "Y");
2235 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2237 responseBuilder.setResponseCode(errorCode);
2238 responseBuilder.setResponseMessage(errorMessage);
2239 responseBuilder.setAckFinalIndicator(ackFinal);
2241 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2242 vfModulePreloadListBuilder.setVfModuleName(preloadName);
2243 vfModulePreloadListBuilder.setVfModuleModelId(preloadType);
2244 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadDataBuilder.build());
2246 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
2247 + errorCode + "', Reason: '" + errorMessage + "'");
2249 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2250 } catch (Exception e) {
2252 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2255 log.debug("Sending Success rpc result due to external error");
2256 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2257 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2258 .withResult(responseBuilder.build()).build();
2259 return Futures.immediateFuture(rpcResult);
2262 // Got success from SLI
2264 vfModulePreloadData = vfModulePreloadDataBuilder.build();
2266 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
2267 + vfModulePreloadData);
2268 // svc-configuration-list
2269 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2270 vfModulePreloadListBuilder.setVfModuleName(preloadName);
2271 vfModulePreloadListBuilder.setVfModuleModelId(preloadType);
2272 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadData);
2274 // SDNGC-989 set merge flag to false
2275 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2276 log.info(UPDATING_OPERATIONAL_TREE_STR);
2277 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2278 } catch (Exception e) {
2279 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2281 responseBuilder.setResponseCode("500");
2282 responseBuilder.setResponseMessage(e.toString());
2283 responseBuilder.setAckFinalIndicator("Y");
2284 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
2285 + responseBuilder.build());
2286 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2287 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(false)
2288 .withResult(responseBuilder.build()).build();
2289 return Futures.immediateFuture(rpcResult);
2293 responseBuilder.setResponseCode(errorCode);
2294 responseBuilder.setAckFinalIndicator(ackFinal);
2295 if (errorMessage != null) {
2296 responseBuilder.setResponseMessage(errorMessage);
2298 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
2300 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
2303 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2304 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2306 return Futures.immediateFuture(rpcResult);
2311 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2312 PreloadNetworkTopologyOperationInput input) {
2314 final String svcOperation = "preload-network-topology-operation";
2315 PreloadData preloadData = null;
2316 Properties parms = new Properties();
2318 log.info(svcOperation + CALLED_STR);
2319 // create a new response object
2320 PreloadNetworkTopologyOperationOutputBuilder responseBuilder =
2321 new PreloadNetworkTopologyOperationOutputBuilder();
2323 // Result from savePreloadData
2325 if (input == null || input.getNetworkTopologyInformation() == null
2326 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null
2327 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName() == null
2328 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType() == null) {
2329 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or" +
2330 " empty network-name or network-type");
2331 responseBuilder.setResponseCode("403");
2332 responseBuilder.setResponseMessage("input, null or empty network-name or network-type");
2333 responseBuilder.setAckFinalIndicator("Y");
2334 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2335 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2337 return Futures.immediateFuture(rpcResult);
2340 // Grab the name and type from the input buffer
2341 String preloadName = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2342 String preloadType = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2344 // Make sure we have a preloadName and preloadType
2345 if (preloadName == null || preloadName.length() == 0) {
2346 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
2347 responseBuilder.setResponseCode("403");
2348 responseBuilder.setResponseMessage("input, invalid preload-name");
2349 responseBuilder.setAckFinalIndicator("Y");
2350 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2351 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2353 return Futures.immediateFuture(rpcResult);
2356 if (preloadType == null || preloadType.length() == 0) {
2357 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
2358 responseBuilder.setResponseCode("403");
2359 responseBuilder.setResponseMessage("input, invalid preload-type");
2360 responseBuilder.setAckFinalIndicator("Y");
2361 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2362 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2364 return Futures.immediateFuture(rpcResult);
2367 if (input.getSdncRequestHeader() != null) {
2368 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2369 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2372 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2373 getPreloadData(preloadName, preloadType, preloadDataBuilder);
2375 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2376 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2379 // setup a preload-data object builder
2380 // ACTION vnf-topology-operation
2382 // USES request-information;
2383 // uses vnf-topology-information;
2386 // container preload-data
2388 ADDING_INPUT_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
2389 PreloadNetworkTopologyOperationInputBuilder inputBuilder =
2390 new PreloadNetworkTopologyOperationInputBuilder(input);
2391 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2392 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
2393 + OPERATIONAL_DATA_STR + operDataBuilder.build());
2394 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
2396 // Call SLI sync method
2397 // Get SvcLogicService reference
2398 Properties respProps = null;
2399 String errorCode = "200";
2400 String errorMessage = null;
2401 String ackFinal = "Y";
2404 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
2407 svcLogicClient.execute(VNF_API, svcOperation, null, "sync", preloadDataBuilder, parms);
2408 } catch (Exception e) {
2409 log.error("Caught exception executing service logic for " + svcOperation, e);
2410 errorMessage = e.getMessage();
2414 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
2417 } catch (Exception e) {
2419 errorMessage = e.getMessage();
2420 log.error("Caught exception looking for service logic", e);
2423 if (respProps != null) {
2424 errorCode = respProps.getProperty("error-code");
2425 errorMessage = respProps.getProperty("error-message");
2426 ackFinal = respProps.getProperty("ack-final", "Y");
2429 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2430 responseBuilder.setResponseCode(errorCode);
2431 responseBuilder.setResponseMessage(errorMessage);
2432 responseBuilder.setAckFinalIndicator(ackFinal);
2434 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2435 preloadVnfListBuilder.setVnfName(preloadName);
2436 preloadVnfListBuilder.setVnfType(preloadType);
2437 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2439 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
2440 + errorCode + "', Reason: '" + errorMessage + "'");
2442 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2443 } catch (Exception e) {
2445 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2449 log.debug("Sending Success rpc result due to external error");
2450 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2451 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2453 return Futures.immediateFuture(rpcResult);
2456 // Got success from SLI
2458 preloadData = preloadDataBuilder.build();
2460 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
2462 // svc-configuration-list
2463 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2464 preloadVnfListBuilder.setVnfName(preloadName);
2465 preloadVnfListBuilder.setVnfType(preloadType);
2466 preloadVnfListBuilder.setPreloadData(preloadData);
2468 // SDNGC-989 set merge flag to false
2469 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2470 log.info(UPDATING_OPERATIONAL_TREE_STR);
2471 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2472 } catch (Exception e) {
2473 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2475 responseBuilder.setResponseCode("500");
2476 responseBuilder.setResponseMessage(e.toString());
2477 responseBuilder.setAckFinalIndicator("Y");
2478 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
2479 + responseBuilder.build());
2480 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2481 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(false)
2482 .withResult(responseBuilder.build()).build();
2483 return Futures.immediateFuture(rpcResult);
2487 responseBuilder.setResponseCode(errorCode);
2488 responseBuilder.setAckFinalIndicator(ackFinal);
2489 if (errorMessage != null) {
2490 responseBuilder.setResponseMessage(errorMessage);
2492 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
2494 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
2497 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2498 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2500 return Futures.immediateFuture(rpcResult);