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.onap.ccsdk.sli.core.sli.SvcLogicException;
134 import org.slf4j.Logger;
135 import org.slf4j.LoggerFactory;
136 import org.slf4j.MDC;
139 import java.text.DateFormat;
140 import java.text.SimpleDateFormat;
141 import java.util.Date;
142 import java.util.Properties;
143 import java.util.TimeZone;
144 import java.util.concurrent.ExecutionException;
145 import java.util.concurrent.ExecutorService;
146 import java.util.concurrent.Executors;
147 import java.util.ArrayList;
148 import java.util.concurrent.Future;
151 * Defines a base implementation for your provider. This class extends from a helper class which provides storage for
152 * the most commonly used components of the MD-SAL. Additionally the base class provides some basic logging and
153 * initialization / clean up methods.
156 public class VnfApiProvider implements AutoCloseable, VNFAPIService, DataChangeListener {
157 protected DataBroker dataBroker;
158 protected NotificationPublishService notificationService;
159 protected RpcProviderRegistry rpcRegistry;
160 protected BindingAwareBroker.RpcRegistration<VNFAPIService> rpcRegistration;
161 private final Logger log = LoggerFactory.getLogger(VnfApiProvider.class);
162 private final ExecutorService executor;
164 private static final String PRELOAD_DATA = "] PreloadData: ";
165 private static final String SENDING_SUCCESS_RPC = "Sending Success rpc result due to external error";
166 public static final String REASON = "', Reason: '";
167 public static final String ERROR_CODE = "] error code: '";
168 public static final String INVALID_INPUT_INVALID_PRELOAD_TYPE = "invalid input, invalid preload-type";
169 public static final String BECAUSE_OF_INVALID_PRELOAD_TYPE = " because of invalid preload-type";
170 public static final String INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID = "invalid input, null or empty service-instance-id";
171 public static final String BECAUSE_OF_INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID = " because of invalid input, null or empty service-instance-id";
172 private static final String APP_NAME = "vnfapi";
173 private static final String VNF_API = "VNF-API";
174 private static final String OPERATIONAL_DATA = "operational-data";
175 private static final String READ_MD_SAL_STR = "Read MD-SAL (";
176 private static final String DATA_FOR_STR = ") data for [";
177 private static final String SERVICE_DATA_STR = "] ServiceData: ";
178 private static final String NO_DATA_FOUND_STR = "No data found in MD-SAL (";
179 private static final String EXCEPTION_READING_MD_SAL_STR = "Caught Exception reading MD-SAL (";
180 private static final String FOR_STR = ") for [";
181 private static final String INVALID_INPUT_VF_MODULE_STR = "invalid input, null or empty vf-module-id";
182 private static final String UPDATED_MD_SAL_STR = "Updated MD-SAL for ";
183 private static final String RETURNED_SUCCESS_STR = "Returned SUCCESS for ";
184 private static final String UPDATING_OPERATIONAL_TREE_STR = "Updating OPERATIONAL tree.";
185 private static final String UPDATING_MD_SAL_STR = "Updating MD-SAL for ";
186 private static final String CAUGHT_EXCEPTION_STR = "Caught Exception updating MD-SAL for ";
187 private static final String RETURNED_FAILED_STR = "Returned FAILED for ";
188 private static final String ADDING_INPUT_DATA_STR = "Adding INPUT data for ";
189 private static final String ADDING_OPERATIONAL_DATA_STR = "Adding OPERATIONAL data for ";
190 private static final String OPERATIONAL_DATA_STR = "] operational-data: ";
191 private static final String ADDING_CONFIG_DATA_STR = "Adding CONFIG data for ";
192 private static final String INPUT_STR = "] input: ";
193 private static final String CALLED_STR = " called.";
194 private static final String EXITING_STR = "exiting ";
195 private static final String INVALID_INPUT_VNF_INSTANCE_STR = "invalid input, null or empty vnf-instance-id";
197 private VNFSDNSvcLogicServiceClient svcLogicClient;
199 public VnfApiProvider(DataBroker dataBroker2, NotificationPublishService notificationPublishService,
200 RpcProviderRegistry rpcProviderRegistry, VNFSDNSvcLogicServiceClient client) {
201 log.info("Creating provider for " + APP_NAME);
202 executor = Executors.newFixedThreadPool(1);
203 dataBroker = dataBroker2;
204 notificationService = notificationPublishService;
205 rpcRegistry = rpcProviderRegistry;
206 svcLogicClient = client;
210 private void initialize() {
211 log.info("Initializing provider for " + APP_NAME);
212 // Create the top level containers
215 VnfSdnUtil.loadProperties();
216 } catch (Exception e) {
217 log.error("Caught Exception while trying to load properties file: ", e);
220 log.info("Initialization complete for " + APP_NAME);
223 private void createContainers() {
224 final WriteTransaction t = dataBroker.newReadWriteTransaction();
226 // Create the Vnfs container
227 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
228 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
230 // Create the PreloadVnfs container
231 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
232 new PreloadVnfsBuilder().build());
233 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
234 new PreloadVnfsBuilder().build());
236 // 1610 Create the PreloadVnfInstances container
237 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfInstances.class),
238 new PreloadVnfInstancesBuilder().build());
239 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfInstances.class),
240 new PreloadVnfInstancesBuilder().build());
242 // 1610 Create the VnfInstances container
243 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VnfInstances.class),
244 new VnfInstancesBuilder().build());
245 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VnfInstances.class),
246 new VnfInstancesBuilder().build());
248 // 1610 Create the PreloadVfModules container
249 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVfModules.class),
250 new PreloadVfModulesBuilder().build());
251 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVfModules.class),
252 new PreloadVfModulesBuilder().build());
254 // 1610 Create the VfModules container
255 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VfModules.class),
256 new VfModulesBuilder().build());
257 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VfModules.class),
258 new VfModulesBuilder().build());
261 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
263 log.info("Create Containers succeeded!: ");
265 } catch (InterruptedException | ExecutionException e) {
266 log.error("Create Containers Failed: " + e);
271 public void close() throws Exception {
272 log.info("Closing provider for " + APP_NAME);
274 rpcRegistration.close();
275 log.info("Successfully closed provider for " + APP_NAME);
278 // On data change not used
280 public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
282 log.info(" IN ON DATA CHANGE: ");
284 boolean changed = false;
285 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
286 DataObject updatedSubTree = change.getUpdatedSubtree();
288 if (updatedSubTree != null) {
289 if (log.isDebugEnabled()) {
290 log.debug("updatedSubTree was non-null:" + updatedSubTree);
292 if (updatedSubTree instanceof Vnfs) {
293 changed = isChanged(changed, (Vnfs) updatedSubTree);
295 if (updatedSubTree instanceof PreloadVnfs) {
296 changed = isChanged(changed, (PreloadVnfs) updatedSubTree);
299 if (updatedSubTree instanceof PreloadVnfInstances) {
300 changed = isChanged(changed, (PreloadVnfInstances) updatedSubTree);
303 if (updatedSubTree instanceof VnfInstances) {
304 changed = isChanged(changed, (VnfInstances) updatedSubTree);
307 if (updatedSubTree instanceof PreloadVfModules) {
308 changed = isChanged(changed, (PreloadVfModules) updatedSubTree);
311 if (updatedSubTree instanceof VfModules) {
312 changed = isChanged(changed, (VfModules) updatedSubTree);
316 // Do the write transaction only if something changed.
318 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = writeTransaction.submit();
319 Futures.addCallback(checkedFuture, new FutureCallback<Void>() {
322 public void onSuccess(Void arg0) {
323 log.debug("Successfully updated Service Status");
327 public void onFailure(Throwable e) {
328 log.debug("Failed updating Service Status", e);
334 private boolean isChanged(boolean changed, VfModules updatedSubTree) {
335 ArrayList<VfModuleList> vfModuleList =
336 (ArrayList<VfModuleList>) updatedSubTree.getVfModuleList();
337 if (vfModuleList != null) {
338 for (VfModuleList entry : vfModuleList) {
339 VfModuleServiceData vfModuleServiceData = entry.getVfModuleServiceData();
340 ServiceStatus serviceStatus = entry.getServiceStatus();
341 if (vfModuleServiceData != null && serviceStatus != null) {
342 // VfModuleServiceData change detected, check the AckFinal indicator and request-status to
343 // see if we need to proceed.
344 return isChanged(changed, serviceStatus);
351 private boolean isChanged(boolean changed, PreloadVfModules updatedSubTree) {
352 ArrayList<VfModulePreloadList> vnfInstanceList =
353 (ArrayList<VfModulePreloadList>) updatedSubTree.getVfModulePreloadList();
354 if (vnfInstanceList != null) {
355 for (VfModulePreloadList entry : vnfInstanceList) {
356 VfModulePreloadData vnfInstancePreloadData = entry.getVfModulePreloadData();
357 if (vnfInstancePreloadData != null) {
365 private boolean isChanged(boolean changed, VnfInstances updatedSubTree) {
366 ArrayList<VnfInstanceList> vnfInstanceList =
367 (ArrayList<VnfInstanceList>) updatedSubTree.getVnfInstanceList();
368 if (vnfInstanceList != null) {
369 for (VnfInstanceList entry : vnfInstanceList) {
370 VnfInstanceServiceData vnfInstanceServiceData = entry.getVnfInstanceServiceData();
371 ServiceStatus serviceStatus = entry.getServiceStatus();
372 if (vnfInstanceServiceData != null && serviceStatus != null) {
373 // VnfInstanceServiceData change detected, check the AckFinal indicator and request-status
374 // to see if we need to proceed.
375 return isChanged(changed, serviceStatus);
382 private boolean isChanged(boolean changed, PreloadVnfInstances updatedSubTree) {
383 ArrayList<VnfInstancePreloadList> vnfInstanceList =
384 (ArrayList<VnfInstancePreloadList>) updatedSubTree
385 .getVnfInstancePreloadList();
386 if (vnfInstanceList != null) {
387 for (VnfInstancePreloadList entry : vnfInstanceList) {
388 VnfInstancePreloadData vnfInstancePreloadData = entry.getVnfInstancePreloadData();
389 if (vnfInstancePreloadData != null) {
397 private boolean isChanged(boolean changed, PreloadVnfs updatedSubTree) {
398 ArrayList<VnfPreloadList> vnfList =
399 (ArrayList<VnfPreloadList>) updatedSubTree.getVnfPreloadList();
400 if (vnfList != null) {
401 for (VnfPreloadList entry : vnfList) {
402 PreloadData preloadData = entry.getPreloadData();
403 if (preloadData != null) {
411 private boolean isChanged(boolean changed, Vnfs updatedSubTree) {
412 ArrayList<VnfList> vnfList = (ArrayList<VnfList>) updatedSubTree.getVnfList();
413 if (vnfList != null) {
414 for (VnfList entry : vnfList) {
415 ServiceData serviceData = entry.getServiceData();
416 ServiceStatus serviceStatus = entry.getServiceStatus();
417 if (serviceData != null && serviceStatus != null) {
419 // ServiceData change detected, check the AckFinal indicator and request-status to see if we need to proceed.
421 return isChanged(changed, serviceStatus);
428 private boolean isChanged(boolean changed, ServiceStatus serviceStatus) {
429 if ((!"Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete
430 .equals(serviceStatus.getRequestStatus()))) {
431 if (log.isDebugEnabled()) {
432 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
439 private static class Iso8601Util {
442 private static TimeZone tz = TimeZone.getTimeZone("UTC");
443 private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
445 private Iso8601Util() {
452 private static String now() {
453 return df.format(new Date());
457 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
459 serviceStatusBuilder.setResponseCode(errorCode);
460 serviceStatusBuilder.setResponseMessage(errorMessage);
461 serviceStatusBuilder.setFinalIndicator(ackFinal);
462 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
465 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
466 if (requestInformation != null && requestInformation.getRequestAction() != null) {
467 switch (requestInformation.getRequestAction()) {
468 case VNFActivateRequest:
469 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VNFActivateRequest);
471 case ChangeVNFActivateRequest:
472 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVNFActivateRequest);
474 case DisconnectVNFRequest:
475 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVNFRequest);
477 case PreloadVNFRequest:
478 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVNFRequest);
480 case DeletePreloadVNFRequest:
481 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DeletePreloadVNFRequest);
483 // 1610 vnf-instance Requests
484 case VnfInstanceActivateRequest:
485 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VnfInstanceActivateRequest);
487 case ChangeVnfInstanceActivateRequest:
488 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVnfInstanceActivateRequest);
490 case DisconnectVnfInstanceRequest:
491 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVnfInstanceRequest);
493 case PreloadVnfInstanceRequest:
494 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVnfInstanceRequest);
496 // 1610 vf-module Requests
497 case VfModuleActivateRequest:
498 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VfModuleActivateRequest);
500 case ChangeVfModuleActivateRequest:
501 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVfModuleActivateRequest);
503 case DisconnectVfModuleRequest:
504 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVfModuleRequest);
506 case PreloadVfModuleRequest:
507 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVfModuleRequest);
510 log.error("Unknown RequestAction: " + requestInformation.getRequestAction());
514 if (requestInformation != null && requestInformation.getRequestSubAction() != null) {
515 switch (requestInformation.getRequestSubAction()) {
517 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP);
520 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
523 log.error("Unknown RequestSubAction: " + requestInformation.getRequestSubAction());
529 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
530 if (requestHeader != null && requestHeader.getSvcAction() != null) {
531 switch (requestHeader.getSvcAction()) {
533 serviceStatusBuilder.setRpcAction(RpcAction.Reserve);
536 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
539 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
542 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
545 serviceStatusBuilder.setRpcAction(RpcAction.Changeassign);
548 serviceStatusBuilder.setRpcAction(RpcAction.Changedelete);
551 serviceStatusBuilder.setRpcAction(RpcAction.Rollback);
554 log.error("Unknown SvcAction: " + requestHeader.getSvcAction());
560 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
562 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
566 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
567 // See if any data exists yet for this siid, if so grab it.
568 InstanceIdentifier<VnfList> serviceInstanceIdentifier = InstanceIdentifier
570 .child(VnfList.class, new VnfListKey(siid))
573 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
574 Optional<VnfList> data = Optional.absent();
576 data = readTx.read(type, serviceInstanceIdentifier).get();
577 } catch (InterruptedException | ExecutionException e) {
578 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
581 if (data.isPresent()) {
582 ServiceData serviceData = (ServiceData) data.get().getServiceData();
583 if (serviceData != null) {
584 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + siid + SERVICE_DATA_STR + serviceData);
585 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
586 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
587 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
588 serviceDataBuilder.setVnfRequestInformation(serviceData.getVnfRequestInformation());
589 serviceDataBuilder.setVnfId(serviceData.getVnfId());
590 serviceDataBuilder.setVnfTopologyInformation(serviceData.getVnfTopologyInformation());
591 serviceDataBuilder.setOperStatus(serviceData.getOperStatus());
593 log.info("No service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
596 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
601 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder) {
603 getVnfInstanceServiceData(siid, vnfInstanceServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
607 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder,
608 LogicalDatastoreType type) {
609 // See if any data exists yet for this siid, if so grab it.
610 InstanceIdentifier<VnfInstanceList> vnfInstanceIdentifier = InstanceIdentifier
611 .builder(VnfInstances.class)
612 .child(VnfInstanceList.class, new VnfInstanceListKey(siid))
615 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
616 Optional<VnfInstanceList> data = Optional.absent();
618 data = readTx.read(type, vnfInstanceIdentifier).get();
619 } catch (InterruptedException | ExecutionException e) {
620 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
623 if (data.isPresent()) {
624 VnfInstanceServiceData vnfInstanceServiceData = data.get().getVnfInstanceServiceData();
625 if (vnfInstanceServiceData != null) {
626 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + siid + "] VnfInstanceServiceData: "
627 + vnfInstanceServiceData);
628 vnfInstanceServiceDataBuilder.setSdncRequestHeader(vnfInstanceServiceData.getSdncRequestHeader());
629 vnfInstanceServiceDataBuilder.setRequestInformation(vnfInstanceServiceData.getRequestInformation());
630 vnfInstanceServiceDataBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
631 vnfInstanceServiceDataBuilder
632 .setVnfInstanceRequestInformation(vnfInstanceServiceData.getVnfInstanceRequestInformation());
633 vnfInstanceServiceDataBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
634 vnfInstanceServiceDataBuilder
635 .setVnfInstanceTopologyInformation(vnfInstanceServiceData.getVnfInstanceTopologyInformation());
636 vnfInstanceServiceDataBuilder.setOperStatus(vnfInstanceServiceData.getOperStatus());
638 log.info("No vnf-instance-service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
641 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
646 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder) {
648 getVfModuleServiceData(siid, vfModuleServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
652 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder,
653 LogicalDatastoreType type) {
654 // See if any data exists yet for this siid, if so grab it.
655 InstanceIdentifier<VfModuleList> vfModuleIdentifier = InstanceIdentifier
656 .builder(VfModules.class)
657 .child(VfModuleList.class, new VfModuleListKey(siid))
660 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
661 Optional<VfModuleList> data = Optional.absent();
663 data = readTx.read(type, vfModuleIdentifier).get();
664 } catch (InterruptedException | ExecutionException e) {
665 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
668 if (data.isPresent()) {
669 VfModuleServiceData vfModuleServiceData = data.get().getVfModuleServiceData();
670 if (vfModuleServiceData != null) {
672 READ_MD_SAL_STR + type + DATA_FOR_STR + siid + "] VfModuleServiceData: " + vfModuleServiceData);
673 vfModuleServiceDataBuilder.setSdncRequestHeader(vfModuleServiceData.getSdncRequestHeader());
674 vfModuleServiceDataBuilder.setRequestInformation(vfModuleServiceData.getRequestInformation());
675 vfModuleServiceDataBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
676 vfModuleServiceDataBuilder
677 .setVfModuleRequestInformation(vfModuleServiceData.getVfModuleRequestInformation());
678 vfModuleServiceDataBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
679 vfModuleServiceDataBuilder
680 .setVfModuleTopologyInformation(vfModuleServiceData.getVfModuleTopologyInformation());
681 vfModuleServiceDataBuilder.setOperStatus(vfModuleServiceData.getOperStatus());
683 log.info("No vf-module-service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
686 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
691 private void getPreloadData(String vnfName, String vnfType, PreloadDataBuilder preloadDataBuilder) {
693 getPreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
696 private void getPreloadData(String preloadName, String preloadType, PreloadDataBuilder preloadDataBuilder,
697 LogicalDatastoreType type) {
698 // See if any data exists yet for this name/type, if so grab it.
699 InstanceIdentifier<VnfPreloadList> preloadInstanceIdentifier = InstanceIdentifier
700 .builder(PreloadVnfs.class)
701 .child(VnfPreloadList.class, new VnfPreloadListKey(preloadName, preloadType))
704 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
705 Optional<VnfPreloadList> data = Optional.absent();
707 data = readTx.read(type, preloadInstanceIdentifier).get();
708 } catch (InterruptedException | ExecutionException e) {
709 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ",
713 if (data.isPresent()) {
714 PreloadData preloadData = (PreloadData) data.get().getPreloadData();
715 if (preloadData != null) {
716 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType + PRELOAD_DATA
718 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
719 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
720 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
723 "No preload-data found in MD-SAL (" + type + FOR_STR + preloadName + "," + preloadType + "] ");
726 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
730 //1610 preload-vnf-instance
731 private void getVnfInstancePreloadData(String vnfName, String vnfType,
732 VnfInstancePreloadDataBuilder preloadDataBuilder) {
734 getVnfInstancePreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
737 //1610 preload-vnf-instance
738 private void getVnfInstancePreloadData(String preloadName, String preloadType,
739 VnfInstancePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
740 // See if any data exists yet for this name/type, if so grab it.
741 InstanceIdentifier<VnfInstancePreloadList> preloadInstanceIdentifier = InstanceIdentifier
742 .builder(PreloadVnfInstances.class)
743 .child(VnfInstancePreloadList.class, new VnfInstancePreloadListKey(preloadName, preloadType))
746 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
747 Optional<VnfInstancePreloadList> data = Optional.absent();
749 data = readTx.read(type, preloadInstanceIdentifier).get();
750 } catch (InterruptedException | ExecutionException e) {
751 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ",
755 if (data.isPresent()) {
756 VnfInstancePreloadData preloadData = (VnfInstancePreloadData) data.get().getVnfInstancePreloadData();
757 if (preloadData != null) {
758 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType
759 + "] VnfInstancePreloadData: " + preloadData);
760 preloadDataBuilder.setVnfInstanceTopologyInformation(preloadData.getVnfInstanceTopologyInformation());
761 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
763 log.info("No vnf-instance-preload-data found in MD-SAL (" + type + FOR_STR + preloadName + ","
764 + preloadType + "] ");
767 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
771 // 1610 preload-vf-module
772 private void getVfModulePreloadData(String vnfName, String vnfType,
773 VfModulePreloadDataBuilder preloadDataBuilder) {
775 getVfModulePreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
778 private void getVfModulePreloadData(String preloadName, String preloadType,
779 VfModulePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
780 // See if any data exists yet for this name/type, if so grab it.
781 InstanceIdentifier<VfModulePreloadList> preloadInstanceIdentifier = InstanceIdentifier
782 .builder(PreloadVfModules.class)
783 .child(VfModulePreloadList.class, new VfModulePreloadListKey(preloadName, preloadType))
786 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
787 Optional<VfModulePreloadList> data = Optional.absent();
790 data = readTx.read(type, preloadInstanceIdentifier).get();
791 } catch (InterruptedException | ExecutionException e) {
792 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ",
796 if (data.isPresent()) {
797 VfModulePreloadData preloadData = (VfModulePreloadData) data.get().getVfModulePreloadData();
798 if (preloadData != null) {
799 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType
800 + "] VfModulePreloadData: " + preloadData);
801 preloadDataBuilder.setVfModuleTopologyInformation(preloadData.getVfModuleTopologyInformation());
802 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
805 "No preload-data found in MD-SAL (" + type + FOR_STR + preloadName + "," + preloadType + "] ");
808 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
812 private void deleteVnfList(final VnfList entry, LogicalDatastoreType storeType) {
813 // Each entry will be identifiable by a unique key, we have to create that identifier
814 InstanceIdentifier<VnfList> path = InstanceIdentifier
816 .child(VnfList.class, entry.getKey())
819 int optimisticLockTries = 2;
820 boolean tryAgain = true;
824 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
825 tx.delete(storeType, path);
826 tx.submit().checkedGet();
827 log.debug("DataStore delete succeeded");
828 } catch (OptimisticLockFailedException e) {
829 if (--optimisticLockTries <= 0) {
830 log.debug("Got OptimisticLockFailedException on last try - failing ");
831 throw new IllegalStateException(e);
833 log.debug("Got OptimisticLockFailedException - trying again ");
836 } catch (final TransactionCommitFailedException e) {
838 if (e.getCause() instanceof ModifiedNodeDoesNotExistException) {
839 log.debug("Ignoring MpdifiedNodeDoesNotExistException");
843 log.debug("Delete DataStore failed");
844 throw new IllegalStateException(e);
849 private void saveVnfList(final VnfList entry, boolean merge, LogicalDatastoreType storeType) {
850 // Each entry will be identifiable by a unique key, we have to create that identifier
851 InstanceIdentifier<VnfList> path = InstanceIdentifier
853 .child(VnfList.class, entry.getKey())
856 tryUpdateDataStore(entry, merge, storeType, path);
860 private void saveVnfInstanceList(final VnfInstanceList entry, boolean merge, LogicalDatastoreType storeType) {
861 // Each entry will be identifiable by a unique key, we have to create that identifier
862 InstanceIdentifier<VnfInstanceList> path = InstanceIdentifier
863 .builder(VnfInstances.class)
864 .child(VnfInstanceList.class, entry.getKey())
867 tryUpdateDataStore(entry, merge, storeType, path);
871 private void saveVfModuleList(final VfModuleList entry, boolean merge, LogicalDatastoreType storeType) {
872 // Each entry will be identifiable by a unique key, we have to create that identifier
873 InstanceIdentifier<VfModuleList> path = InstanceIdentifier
874 .builder(VfModules.class)
875 .child(VfModuleList.class, entry.getKey())
878 tryUpdateDataStore(entry, merge, storeType, path);
881 private void savePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) {
883 // Each entry will be identifiable by a unique key, we have to create that identifier
884 InstanceIdentifier<VnfPreloadList> path = InstanceIdentifier
885 .builder(PreloadVnfs.class)
886 .child(VnfPreloadList.class, entry.getKey())
889 tryUpdateDataStore(entry, merge, storeType, path);
892 //1610 preload vnf-instance
893 private void saveVnfInstancePreloadList(final VnfInstancePreloadList entry, boolean merge,
894 LogicalDatastoreType storeType) {
896 // Each entry will be identifiable by a unique key, we have to create that identifier
897 InstanceIdentifier<VnfInstancePreloadList> path = InstanceIdentifier
898 .builder(PreloadVnfInstances.class)
899 .child(VnfInstancePreloadList.class, entry.getKey())
902 tryUpdateDataStore(entry, merge, storeType, path);
905 //1610 preload vf-module
906 private void saveVfModulePreloadList(final VfModulePreloadList entry, boolean merge,
907 LogicalDatastoreType storeType) {
909 // Each entry will be identifiable by a unique key, we have to create that identifier
910 InstanceIdentifier<VfModulePreloadList> path = InstanceIdentifier
911 .builder(PreloadVfModules.class)
912 .child(VfModulePreloadList.class, entry.getKey())
915 tryUpdateDataStore(entry, merge, storeType, path);
918 private <T extends DataObject> void tryUpdateDataStore(T entry, boolean merge, LogicalDatastoreType storeType,
919 InstanceIdentifier<T> path) {
924 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
926 tx.merge(storeType, path, entry);
928 tx.put(storeType, path, entry);
930 tx.submit().checkedGet();
931 log.debug("Update DataStore succeeded");
933 } catch (OptimisticLockFailedException e) {
935 log.debug("Got OptimisticLockFailedException on last try - failing ");
936 throw new IllegalStateException(e);
938 log.debug("Got OptimisticLockFailedException - trying again ");
939 } catch (final TransactionCommitFailedException e) {
940 log.debug("Update DataStore failed");
941 throw new IllegalStateException(e);
946 //Save the requestId into MDC
947 private void setRequestIdAsMDC(String requestId) {
948 MDC.put("RequestId", requestId);
951 //1610 vnf-instance-topology-operation
953 public Future<RpcResult<VnfInstanceTopologyOperationOutput>> vnfInstanceTopologyOperation(
954 VnfInstanceTopologyOperationInput input) {
956 final String svcOperation = "vnf-instance-topology-operation";
957 VnfInstanceServiceData vnfInstanceServiceData;
958 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
959 Properties parms = new Properties();
961 log.info(svcOperation + CALLED_STR);
962 // create a new response object
963 VnfInstanceTopologyOperationOutputBuilder responseBuilder = new VnfInstanceTopologyOperationOutputBuilder();
965 if (input == null || input.getVnfInstanceRequestInformation() == null
966 || input.getVnfInstanceRequestInformation().getVnfInstanceId() == null) {
967 log.debug(EXITING_STR + svcOperation + " because of " + INVALID_INPUT_VNF_INSTANCE_STR);
968 responseBuilder.setResponseCode("403");
969 responseBuilder.setResponseMessage(INVALID_INPUT_VNF_INSTANCE_STR);
970 responseBuilder.setAckFinalIndicator("Y");
971 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
972 .<VnfInstanceTopologyOperationOutput>status(true)
973 .withResult(responseBuilder.build())
976 return Futures.immediateFuture(rpcResult);
979 // Grab the service instance ID from the input buffer
980 String viid = input.getVnfInstanceRequestInformation().getVnfInstanceId();
981 String preloadName = input.getVnfInstanceRequestInformation().getVnfInstanceName();
982 String preloadType = input.getVnfInstanceRequestInformation().getVnfModelId();
984 // Make sure we have a valid viid
985 if (viid == null || viid.length() == 0) {
986 log.debug(EXITING_STR + svcOperation + " because of invalid vnf-instance-id");
987 responseBuilder.setResponseCode("403");
988 responseBuilder.setResponseMessage(INVALID_INPUT_VNF_INSTANCE_STR);
989 responseBuilder.setAckFinalIndicator("Y");
990 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
991 .<VnfInstanceTopologyOperationOutput>status(true)
992 .withResult(responseBuilder.build())
995 return Futures.immediateFuture(rpcResult);
998 if (input.getSdncRequestHeader() != null) {
999 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1000 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1003 // Get vnf-instance-preload-data
1004 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
1005 getVnfInstancePreloadData(preloadName, preloadType, vnfInstancePreloadDataBuilder);
1008 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1009 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1011 // Get operational-data
1012 VnfInstanceServiceDataBuilder operDataBuilder = new VnfInstanceServiceDataBuilder();
1013 getVnfInstanceServiceData(viid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1015 // Set the serviceStatus based on input
1016 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1017 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1020 // setup a service-data object builder
1021 // ACTION vnf-topology-operationa
1023 // USES sdnc-request-header;
1024 // USES request-information;
1025 // USES service-information;
1026 // USES vnf-request-information
1028 // USES vnf-topology-response-body;
1029 // USES vnf-information
1030 // USES service-information
1032 // container service-data
1033 // uses vnf-configuration-information;
1034 // uses oper-status;
1036 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + viid + INPUT_STR + input);
1037 VnfInstanceTopologyOperationInputBuilder inputBuilder = new VnfInstanceTopologyOperationInputBuilder(input);
1038 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1040 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + viid + OPERATIONAL_DATA_STR + operDataBuilder
1042 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1045 ADDING_CONFIG_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preload-data: "
1046 + vnfInstancePreloadDataBuilder.build());
1047 VnfSdnUtil.toProperties(parms, "vnf-instance-preload-data", vnfInstancePreloadDataBuilder);
1049 // Call SLI sync method
1050 // Get SvcLogicService reference
1051 Properties respProps = null;
1052 String errorCode = "200";
1053 String errorMessage = null;
1054 String ackFinal = "Y";
1057 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1058 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", vnfInstanceServiceDataBuilder, parms);
1060 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1063 } catch (SvcLogicException e) {
1064 log.error("Caught exception executing service logic for " + svcOperation, e);
1065 errorMessage = e.getMessage();
1067 } catch (Exception e) {
1069 errorMessage = e.getMessage();
1070 log.error("Caught exception looking for service logic", e);
1073 if (respProps != null) {
1074 errorCode = respProps.getProperty("error-code");
1075 errorMessage = respProps.getProperty("error-message");
1076 ackFinal = respProps.getProperty("ack-final", "Y");
1079 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1080 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1081 serviceStatusBuilder.setRpcName(RpcName.VnfInstanceTopologyOperation);
1083 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1084 responseBuilder.setResponseCode(errorCode);
1085 responseBuilder.setResponseMessage(errorMessage);
1086 responseBuilder.setAckFinalIndicator(ackFinal);
1087 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1088 vnfInstanceListBuilder.setVnfInstanceId(viid);
1089 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1091 saveVnfInstanceList(vnfInstanceListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1092 } catch (Exception e) {
1093 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + viid + "] \n", e);
1095 log.error(RETURNED_FAILED_STR + svcOperation + " [" + viid + "] " + responseBuilder.build());
1096 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
1097 .<VnfInstanceTopologyOperationOutput>status(true)
1098 .withResult(responseBuilder.build())
1101 return Futures.immediateFuture(rpcResult);
1104 // Got success from SLI
1106 vnfInstanceServiceData = vnfInstanceServiceDataBuilder.build();
1107 log.info(UPDATING_MD_SAL_STR + svcOperation + " [" + viid + "] VnfInstanceServiceData: "
1108 + vnfInstanceServiceData);
1109 // svc-configuration-list
1110 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1111 vnfInstanceListBuilder.setVnfInstanceServiceData(vnfInstanceServiceData);
1112 vnfInstanceListBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
1113 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1114 saveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1115 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1116 // Only update operational tree on Delete or Activate
1117 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1118 .getSvcAction().equals(SvcAction.Activate)) {
1119 log.info(UPDATING_OPERATIONAL_TREE_STR);
1120 saveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1123 VnfInstanceInformationBuilder vnfInstanceInformationBuilder = new VnfInstanceInformationBuilder();
1124 vnfInstanceInformationBuilder.setVnfInstanceId(viid);
1125 responseBuilder.setVnfInstanceInformation(vnfInstanceInformationBuilder.build());
1126 responseBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
1127 } catch (Exception e) {
1128 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + viid + "] \n", e);
1129 responseBuilder.setResponseCode("500");
1130 responseBuilder.setResponseMessage(e.toString());
1131 responseBuilder.setAckFinalIndicator("Y");
1132 log.error(RETURNED_FAILED_STR + svcOperation + " [" + viid + "] " + responseBuilder.build());
1133 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
1134 .<VnfInstanceTopologyOperationOutput>status(true)
1135 .withResult(responseBuilder.build())
1138 return Futures.immediateFuture(rpcResult);
1142 responseBuilder.setResponseCode(errorCode);
1143 responseBuilder.setAckFinalIndicator(ackFinal);
1144 if (errorMessage != null) {
1145 responseBuilder.setResponseMessage(errorMessage);
1147 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + viid + "] ");
1148 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + viid + "] " + responseBuilder.build());
1150 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
1151 .<VnfInstanceTopologyOperationOutput>status(true)
1152 .withResult(responseBuilder.build())
1155 return Futures.immediateFuture(rpcResult);
1158 //1610 vf-module-topology-operation
1160 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1161 VfModuleTopologyOperationInput input) {
1163 final String svcOperation = "vf-module-topology-operation";
1164 VfModuleServiceData vfModuleServiceData;
1165 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1166 Properties parms = new Properties();
1168 log.info(svcOperation + CALLED_STR);
1169 // create a new response object
1170 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1172 // Validate vf-module-id from vf-module-request-information
1173 if (input == null || input.getVfModuleRequestInformation() == null
1174 || input.getVfModuleRequestInformation().getVfModuleId() == null) {
1175 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty vf-module-id");
1176 responseBuilder.setResponseCode("403");
1177 responseBuilder.setResponseMessage(INVALID_INPUT_VF_MODULE_STR);
1178 responseBuilder.setAckFinalIndicator("Y");
1179 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1180 .<VfModuleTopologyOperationOutput>status(true)
1181 .withResult(responseBuilder.build())
1184 return Futures.immediateFuture(rpcResult);
1187 // Grab the vf-module-request-information.vf-module-id from the input buffer
1188 String vfid = input.getVfModuleRequestInformation().getVfModuleId();
1189 String preloadName = input.getVfModuleRequestInformation().getVfModuleName();
1190 String preloadType = input.getVfModuleRequestInformation().getVfModuleModelId();
1192 // Make sure we have a valid siid
1193 if (vfid == null || vfid.length() == 0) {
1194 log.debug(EXITING_STR + svcOperation + " because of invalid vf-module-id");
1195 responseBuilder.setResponseCode("403");
1196 responseBuilder.setResponseMessage(INVALID_INPUT_VF_MODULE_STR);
1197 responseBuilder.setAckFinalIndicator("Y");
1198 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1199 .<VfModuleTopologyOperationOutput>status(true)
1200 .withResult(responseBuilder.build())
1203 return Futures.immediateFuture(rpcResult);
1206 // 1610 add vf-module-id to vnf-instance-list.vf-module-relationship-list
1207 String viid = input.getVfModuleRequestInformation().getVnfInstanceId();
1209 if (viid == null || viid.length() == 0) {
1210 log.debug(EXITING_STR + svcOperation + " because of invalid vnf-instance-id");
1211 responseBuilder.setResponseCode("403");
1212 responseBuilder.setResponseMessage(INVALID_INPUT_VNF_INSTANCE_STR);
1213 responseBuilder.setAckFinalIndicator("Y");
1214 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1215 .<VfModuleTopologyOperationOutput>status(true)
1216 .withResult(responseBuilder.build())
1219 return Futures.immediateFuture(rpcResult);
1222 if (input.getSdncRequestHeader() != null) {
1223 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1224 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1227 // Get vf-module-preload-data
1228 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
1229 getVfModulePreloadData(preloadName, preloadType, vfModulePreloadDataBuilder);
1231 // Get vf-module-service-data
1232 VfModuleServiceDataBuilder vfModuleServiceDataBuilder = new VfModuleServiceDataBuilder();
1233 getVfModuleServiceData(vfid, vfModuleServiceDataBuilder);
1235 // Get vf-module operation-data
1236 VfModuleServiceDataBuilder operDataBuilder = new VfModuleServiceDataBuilder();
1237 getVfModuleServiceData(vfid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1239 // 1610 Need to pull vnf-instance-list.vf-module-relationship-list from MD-SAL
1240 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1241 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1243 // vnf-instance operational-data
1244 VnfInstanceServiceDataBuilder vnfInstanceOperDataBuilder = new VnfInstanceServiceDataBuilder();
1245 getVnfInstanceServiceData(viid, vnfInstanceOperDataBuilder, LogicalDatastoreType.OPERATIONAL);
1247 // Set the serviceStatus based on input
1248 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1249 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1252 // setup a service-data object builder
1253 // ACTION vnf-topology-operation
1255 // USES request-information;
1256 // USES service-information;
1257 // USES vnf-request-information
1259 // USES vnf-information
1260 // USES service-information
1262 // container service-data
1264 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + vfid + INPUT_STR + input);
1265 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1266 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1268 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + vfid + "] vf-module operational-data: "
1269 + operDataBuilder.build());
1270 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1272 log.info(ADDING_CONFIG_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
1273 + "] vf-module-preload-data: " + vfModulePreloadDataBuilder.build());
1274 VnfSdnUtil.toProperties(parms, "vf-module-preload-data", vfModulePreloadDataBuilder);
1276 log.info("Adding vnf-instance CONFIG data for " + svcOperation + " [" + viid + "] vnf-instance-service-data: "
1277 + vnfInstanceServiceDataBuilder.build());
1278 VnfSdnUtil.toProperties(parms, "vnf-instance-service-data", vnfInstanceServiceDataBuilder);
1280 log.info("Adding vnf-instance OPERATIONAL data for " + svcOperation + " [" + viid
1281 + "] vnf-instance operational-data: " + vnfInstanceOperDataBuilder.build());
1282 VnfSdnUtil.toProperties(parms, "vnf-instance-operational-data", vnfInstanceOperDataBuilder);
1284 // Call SLI sync method
1285 // Get SvcLogicService reference
1287 Properties respProps = null;
1288 String errorCode = "200";
1289 String errorMessage = null;
1290 String ackFinal = "Y";
1293 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1294 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", vfModuleServiceDataBuilder, parms);
1296 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1299 } catch (SvcLogicException e) {
1300 log.error("Caught exception executing service logic for " + svcOperation, e);
1301 errorMessage = e.getMessage();
1303 } catch (Exception e) {
1305 errorMessage = e.getMessage();
1306 log.error("Caught exception looking for service logic", e);
1309 if (respProps != null) {
1310 errorCode = respProps.getProperty("error-code");
1311 errorMessage = respProps.getProperty("error-message");
1312 ackFinal = respProps.getProperty("ack-final", "Y");
1315 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1316 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1317 serviceStatusBuilder.setRpcName(RpcName.VfModuleTopologyOperation);
1319 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1320 responseBuilder.setResponseCode(errorCode);
1321 responseBuilder.setResponseMessage(errorMessage);
1322 responseBuilder.setAckFinalIndicator(ackFinal);
1323 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1324 vfModuleListBuilder.setVfModuleId(vfid);
1325 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1327 saveVfModuleList(vfModuleListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1328 } catch (Exception e) {
1329 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + vfid + "] \n", e);
1331 log.error(RETURNED_FAILED_STR + svcOperation + " [" + vfid + "] " + responseBuilder.build());
1332 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1333 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1336 return Futures.immediateFuture(rpcResult);
1339 // Got success from SLI
1340 // save vf-module-service-data in MD-SAL
1342 vfModuleServiceData = vfModuleServiceDataBuilder.build();
1344 UPDATING_MD_SAL_STR + svcOperation + " [" + vfid + "] VfModuleServiceData: " + vfModuleServiceData);
1346 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1347 vfModuleListBuilder.setVfModuleServiceData(vfModuleServiceData);
1348 vfModuleListBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
1349 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1350 saveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1351 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1352 // Only update operational tree on Delete or Activate
1353 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1354 .getSvcAction().equals(SvcAction.Activate)) {
1355 log.info(UPDATING_OPERATIONAL_TREE_STR);
1356 saveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1359 VfModuleInformationBuilder vfModuleInformationBuilder = new VfModuleInformationBuilder();
1360 vfModuleInformationBuilder.setVfModuleId(vfid);
1361 responseBuilder.setVfModuleInformation(vfModuleInformationBuilder.build());
1362 responseBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
1363 } catch (Exception e) {
1364 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + vfid + "] \n", e);
1365 responseBuilder.setResponseCode("500");
1366 responseBuilder.setResponseMessage(e.toString());
1367 responseBuilder.setAckFinalIndicator("Y");
1368 log.error(RETURNED_FAILED_STR + svcOperation + " [" + vfid + "] " + responseBuilder.build());
1369 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1370 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1373 return Futures.immediateFuture(rpcResult);
1377 responseBuilder.setResponseCode(errorCode);
1378 responseBuilder.setAckFinalIndicator(ackFinal);
1379 if (errorMessage != null) {
1380 responseBuilder.setResponseMessage(errorMessage);
1382 log.info("Updated vf-module in MD-SAL for " + svcOperation + " [" + vfid + "] ");
1383 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + vfid + "] " + responseBuilder.build());
1385 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1386 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1388 return Futures.immediateFuture(rpcResult);
1392 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
1393 final String svcOperation = "vnf-topology-operation";
1394 ServiceData serviceData;
1395 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1396 Properties parms = new Properties();
1398 log.info(svcOperation + CALLED_STR);
1399 // create a new response object
1400 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1402 if (input == null || input.getServiceInformation() == null
1403 || input.getServiceInformation().getServiceInstanceId() == null
1404 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1405 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty service-instance-id");
1406 responseBuilder.setResponseCode("403");
1407 responseBuilder.setResponseMessage(INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID);
1408 responseBuilder.setAckFinalIndicator("Y");
1409 RpcResult<VnfTopologyOperationOutput> rpcResult =
1410 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1412 return Futures.immediateFuture(rpcResult);
1415 if (input.getVnfRequestInformation() == null || input.getVnfRequestInformation().getVnfId() == null
1416 || input.getVnfRequestInformation().getVnfId().length() == 0) {
1417 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty vf-module-id");
1418 responseBuilder.setResponseCode("403");
1419 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1420 responseBuilder.setAckFinalIndicator("Y");
1421 RpcResult<VnfTopologyOperationOutput> rpcResult =
1422 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1424 return Futures.immediateFuture(rpcResult);
1427 // Grab the service instance ID from the input buffer
1428 String siid = input.getVnfRequestInformation().getVnfId();
1429 String preloadName = input.getVnfRequestInformation().getVnfName();
1430 String preloadType = input.getVnfRequestInformation().getVnfType();
1432 if (input.getSdncRequestHeader() != null) {
1433 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1434 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1437 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1438 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1440 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1441 getServiceData(siid, serviceDataBuilder);
1443 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1444 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1446 // Set the serviceStatus based on input
1447 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1448 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1451 // setup a service-data object builder
1452 // ACTION vnf-topology-operation
1454 // USES request-information;
1455 // USES vnf-request-information
1457 // USES vnf-information
1458 // USES service-information
1460 // container service-data
1461 // uses oper-status;
1463 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + siid + INPUT_STR + input);
1464 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1465 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1467 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + siid + OPERATIONAL_DATA_STR + operDataBuilder
1469 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1472 "Adding CONFIG data for " + svcOperation + " [" + preloadName + "," + preloadType + "] preload-data: "
1473 + preloadDataBuilder.build());
1474 VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1476 // Call SLI sync method
1477 // Get SvcLogicService reference
1478 Properties respProps = null;
1479 String errorCode = "200";
1480 String errorMessage = null;
1481 String ackFinal = "Y";
1484 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1485 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", serviceDataBuilder, parms);
1487 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1490 } catch (SvcLogicException e) {
1491 log.error("Caught exception executing service logic for " + siid, e);
1492 errorMessage = e.getMessage();
1494 } catch (Exception e) {
1496 errorMessage = e.getMessage();
1497 log.error("Caught exception looking for service logic", e);
1500 if (respProps != null) {
1501 errorCode = respProps.getProperty("error-code");
1502 errorMessage = respProps.getProperty("error-message");
1503 ackFinal = respProps.getProperty("ack-final", "Y");
1506 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1507 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1508 serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
1510 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1511 responseBuilder.setResponseCode(errorCode);
1512 responseBuilder.setResponseMessage(errorMessage);
1513 responseBuilder.setAckFinalIndicator(ackFinal);
1514 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1515 vnfListBuilder.setVnfId(siid);
1516 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1518 saveVnfList(vnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1519 } catch (Exception e) {
1520 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + siid + "] \n", e);
1522 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1523 RpcResult<VnfTopologyOperationOutput> rpcResult =
1524 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1526 return Futures.immediateFuture(rpcResult);
1529 // Got success from SLI
1531 serviceData = serviceDataBuilder.build();
1532 log.info(UPDATING_MD_SAL_STR + svcOperation + " [" + siid + "] ServiceData: " + serviceData);
1533 // svc-configuration-list
1534 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1535 vnfListBuilder.setServiceData(serviceData);
1536 vnfListBuilder.setVnfId(serviceData.getVnfId());
1537 siid = serviceData.getVnfId();
1538 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1539 saveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1540 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1541 // Only update operational tree on Delete or Activate
1542 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1543 log.info(UPDATING_OPERATIONAL_TREE_STR);
1544 saveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1545 } else if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input
1546 .getSdncRequestHeader().getSvcAction().equals(SvcAction.Rollback)) {
1547 log.info("Delete OPERATIONAL tree.");
1548 deleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
1549 deleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
1552 VnfInformationBuilder vnfInformationBuilder = new VnfInformationBuilder();
1553 vnfInformationBuilder.setVnfId(siid);
1554 responseBuilder.setVnfInformation(vnfInformationBuilder.build());
1555 responseBuilder.setServiceInformation(serviceData.getServiceInformation());
1556 } catch (Exception e) {
1557 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + siid + "] \n", e);
1558 responseBuilder.setResponseCode("500");
1559 responseBuilder.setResponseMessage(e.toString());
1560 responseBuilder.setAckFinalIndicator("Y");
1561 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1562 RpcResult<VnfTopologyOperationOutput> rpcResult =
1563 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1565 return Futures.immediateFuture(rpcResult);
1569 responseBuilder.setResponseCode(errorCode);
1570 responseBuilder.setAckFinalIndicator(ackFinal);
1571 if (errorMessage != null) {
1572 responseBuilder.setResponseMessage(errorMessage);
1574 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + siid + "] ");
1575 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1577 RpcResult<VnfTopologyOperationOutput> rpcResult =
1578 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1580 return Futures.immediateFuture(rpcResult);
1584 public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1585 NetworkTopologyOperationInput input) {
1587 final String svcOperation = "network-topology-operation";
1588 ServiceData serviceData;
1589 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1590 Properties parms = new Properties();
1592 log.info(svcOperation + CALLED_STR);
1593 // create a new response object
1594 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1596 if (input == null || input.getServiceInformation() == null
1597 || input.getServiceInformation().getServiceInstanceId() == null
1598 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1599 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty service-instance-id");
1600 responseBuilder.setResponseCode("403");
1601 responseBuilder.setResponseMessage(INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID);
1602 responseBuilder.setAckFinalIndicator("Y");
1603 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1604 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1607 return Futures.immediateFuture(rpcResult);
1610 if (input.getNetworkRequestInformation() == null
1611 || input.getNetworkRequestInformation().getNetworkName() == null) {
1612 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty service-instance-id");
1613 responseBuilder.setResponseCode("403");
1614 responseBuilder.setResponseMessage(INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID);
1615 responseBuilder.setAckFinalIndicator("Y");
1616 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1617 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1620 return Futures.immediateFuture(rpcResult);
1623 // Grab the service instance ID from the input buffer
1625 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Assign)) {
1626 siid = input.getNetworkRequestInformation().getNetworkName();
1628 siid = input.getNetworkRequestInformation().getNetworkId();
1630 String preloadName = input.getNetworkRequestInformation().getNetworkName();
1631 String preloadType = input.getNetworkRequestInformation().getNetworkType();
1633 if (input.getSdncRequestHeader() != null) {
1634 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1635 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1638 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1639 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1641 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + siid + INPUT_STR + input);
1642 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1643 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1645 // Call SLI sync method
1646 // Get SvcLogicService reference
1647 Properties respProps = null;
1648 String errorCode = "200";
1649 String errorMessage = null;
1650 String ackFinal = "Y";
1651 String networkId = "error";
1654 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1655 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", preloadDataBuilder, parms);
1657 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1660 } catch (SvcLogicException e) {
1661 log.error("Caught exception executing service logic for " + svcOperation, e);
1662 errorMessage = e.getMessage();
1664 } catch (Exception e) {
1666 errorMessage = e.getMessage();
1667 log.error("Caught exception looking for service logic", e);
1670 if (respProps != null) {
1671 errorCode = respProps.getProperty("error-code");
1672 errorMessage = respProps.getProperty("error-message");
1673 ackFinal = respProps.getProperty("ack-final", "Y");
1674 networkId = respProps.getProperty("networkId", "0");
1677 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1678 responseBuilder.setResponseCode(errorCode);
1679 responseBuilder.setResponseMessage(errorMessage);
1680 responseBuilder.setAckFinalIndicator(ackFinal);
1682 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1684 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1685 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1688 return Futures.immediateFuture(rpcResult);
1691 // Got success from SLI
1693 NetworkInformationBuilder networkInformationBuilder = new NetworkInformationBuilder();
1694 networkInformationBuilder.setNetworkId(networkId);
1695 responseBuilder.setNetworkInformation(networkInformationBuilder.build());
1696 responseBuilder.setServiceInformation(input.getServiceInformation());
1697 } catch (IllegalStateException e) {
1698 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + siid + "] \n", e);
1699 responseBuilder.setResponseCode("500");
1700 responseBuilder.setResponseMessage(e.toString());
1701 responseBuilder.setAckFinalIndicator("Y");
1702 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1703 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1704 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1707 return Futures.immediateFuture(rpcResult);
1711 responseBuilder.setResponseCode(errorCode);
1712 responseBuilder.setAckFinalIndicator(ackFinal);
1713 if (errorMessage != null) {
1714 responseBuilder.setResponseMessage(errorMessage);
1716 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + siid + "] ");
1717 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1719 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1720 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1722 return Futures.immediateFuture(rpcResult);
1726 public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1727 PreloadVnfTopologyOperationInput input) {
1729 final String svcOperation = "preload-vnf-topology-operation";
1730 PreloadData preloadData;
1731 Properties parms = new Properties();
1733 log.info(svcOperation + CALLED_STR);
1734 // create a new response object
1735 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1737 // Result from savePreloadData
1739 if (input == null || input.getVnfTopologyInformation() == null
1740 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null
1741 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName() == null
1742 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType() == null) {
1743 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty vnf-name or vnf-type");
1744 responseBuilder.setResponseCode("403");
1745 responseBuilder.setResponseMessage("invalid input, null or empty vnf-name or vnf-type");
1746 responseBuilder.setAckFinalIndicator("Y");
1747 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1748 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1750 return Futures.immediateFuture(rpcResult);
1753 // Grab the name and type from the input buffer
1754 String preloadName = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1755 String preloadType = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1757 // Make sure we have a preload_name and preload_type
1758 if (preloadName == null || preloadName.length() == 0) {
1759 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
1760 responseBuilder.setResponseCode("403");
1761 responseBuilder.setResponseMessage(INVALID_INPUT_INVALID_PRELOAD_TYPE);
1762 responseBuilder.setAckFinalIndicator("Y");
1763 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1764 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1766 return Futures.immediateFuture(rpcResult);
1769 if (preloadType == null || preloadType.length() == 0) {
1770 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
1771 responseBuilder.setResponseCode("403");
1772 responseBuilder.setResponseMessage(INVALID_INPUT_INVALID_PRELOAD_TYPE);
1773 responseBuilder.setAckFinalIndicator("Y");
1774 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1775 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1777 return Futures.immediateFuture(rpcResult);
1780 if (input.getSdncRequestHeader() != null) {
1781 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1782 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1785 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1786 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1787 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1788 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1791 // setup a preload-data object builder
1792 // ACTION vnf-topology-operation
1794 // USES request-information;
1795 // uses vnf-topology-information;
1798 // container preload-data
1800 ADDING_INPUT_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
1801 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1802 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1803 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
1804 + OPERATIONAL_DATA_STR + operDataBuilder.build());
1805 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1807 // Call SLI sync method
1808 // Get SvcLogicService reference
1809 Properties respProps = null;
1810 String errorCode = "200";
1811 String errorMessage = null;
1812 String ackFinal = "Y";
1815 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1816 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", preloadDataBuilder, parms);
1818 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1821 } catch (SvcLogicException e) {
1822 log.error("Caught exception executing service logic for " + svcOperation, e);
1823 errorMessage = e.getMessage();
1825 } catch (Exception e) {
1827 errorMessage = e.getMessage();
1828 log.error("Caught exception looking for service logic", e);
1831 if (respProps != null) {
1832 errorCode = respProps.getProperty("error-code");
1833 errorMessage = respProps.getProperty("error-message");
1834 ackFinal = respProps.getProperty("ack-final", "Y");
1837 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1839 responseBuilder.setResponseCode(errorCode);
1840 responseBuilder.setResponseMessage(errorMessage);
1841 responseBuilder.setAckFinalIndicator(ackFinal);
1843 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1844 preloadVnfListBuilder.setVnfName(preloadName);
1845 preloadVnfListBuilder.setVnfType(preloadType);
1846 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1848 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
1849 + errorCode + "', Reason: '" + errorMessage + "'");
1851 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1852 } catch (Exception e) {
1854 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
1857 log.debug(SENDING_SUCCESS_RPC);
1858 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1859 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1861 return Futures.immediateFuture(rpcResult);
1864 // Got success from SLI
1866 preloadData = preloadDataBuilder.build();
1868 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
1870 // svc-configuration-list
1871 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1872 preloadVnfListBuilder.setVnfName(preloadName);
1873 preloadVnfListBuilder.setVnfType(preloadType);
1874 preloadVnfListBuilder.setPreloadData(preloadData);
1876 // SDNGC-989 set merge flag to false
1877 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1878 log.info(UPDATING_OPERATIONAL_TREE_STR);
1879 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1880 } catch (Exception e) {
1881 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
1883 responseBuilder.setResponseCode("500");
1884 responseBuilder.setResponseMessage(e.toString());
1885 responseBuilder.setAckFinalIndicator("Y");
1886 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
1887 + responseBuilder.build());
1888 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1889 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(false).withResult(responseBuilder.build())
1891 return Futures.immediateFuture(rpcResult);
1895 responseBuilder.setResponseCode(errorCode);
1896 responseBuilder.setAckFinalIndicator(ackFinal);
1897 if (errorMessage != null) {
1898 responseBuilder.setResponseMessage(errorMessage);
1900 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
1902 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
1905 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1906 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1908 return Futures.immediateFuture(rpcResult);
1911 //1610 preload-vnf-instance-topology-operation
1913 public Future<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> preloadVnfInstanceTopologyOperation(
1914 PreloadVnfInstanceTopologyOperationInput input) {
1916 final String svcOperation = "preload-vnf-instance-topology-operation";
1917 VnfInstancePreloadData vnfInstancePreloadData;
1918 Properties parms = new Properties();
1920 log.info(svcOperation + CALLED_STR);
1921 // create a new response object
1922 PreloadVnfInstanceTopologyOperationOutputBuilder responseBuilder =
1923 new PreloadVnfInstanceTopologyOperationOutputBuilder();
1925 if (input == null || input.getVnfInstanceTopologyInformation() == null
1926 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName() == null
1927 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId() == null) {
1928 log.debug(EXITING_STR + svcOperation
1929 + " because of invalid input, null or empty vnf-instance-name or vnf-model-id");
1930 responseBuilder.setResponseCode("403");
1931 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name or vnf-model-id");
1932 responseBuilder.setAckFinalIndicator("Y");
1933 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1934 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1935 .withResult(responseBuilder.build()).build();
1936 return Futures.immediateFuture(rpcResult);
1939 // Grab the name and type from the input buffer
1940 String preloadName =
1941 input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName();
1942 String preloadType = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId();
1944 // Make sure we have a preloadName and preloadType
1945 if (preloadName == null || preloadName.length() == 0) {
1946 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
1947 responseBuilder.setResponseCode("403");
1948 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1949 responseBuilder.setAckFinalIndicator("Y");
1950 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1951 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1952 .withResult(responseBuilder.build()).build();
1953 return Futures.immediateFuture(rpcResult);
1956 if (preloadType == null || preloadType.length() == 0) {
1957 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
1958 responseBuilder.setResponseCode("403");
1959 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1960 responseBuilder.setAckFinalIndicator("Y");
1961 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1962 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1963 .withResult(responseBuilder.build()).build();
1964 return Futures.immediateFuture(rpcResult);
1967 if (input.getSdncRequestHeader() != null) {
1968 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1969 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1972 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
1973 getVnfInstancePreloadData(preloadName, preloadType, vnfInstancePreloadDataBuilder);
1974 VnfInstancePreloadDataBuilder operDataBuilder = new VnfInstancePreloadDataBuilder();
1975 getVnfInstancePreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1978 // setup a preload-data object builder
1979 // ACTION vnf-topology-operation
1981 // uses vnf-topology-information;
1983 // container preload-data
1985 ADDING_CONFIG_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
1986 PreloadVnfInstanceTopologyOperationInputBuilder inputBuilder =
1987 new PreloadVnfInstanceTopologyOperationInputBuilder(input);
1988 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1989 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
1990 + OPERATIONAL_DATA_STR + operDataBuilder.build());
1991 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1993 // Call SLI sync method
1994 // Get SvcLogicService reference
1995 Properties respProps = null;
1996 String errorCode = "200";
1997 String errorMessage = null;
1998 String ackFinal = "Y";
2001 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
2002 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", vnfInstancePreloadDataBuilder, parms);
2004 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
2007 } catch (SvcLogicException e) {
2008 log.error("Caught exception executing service logic for " + svcOperation, e);
2009 errorMessage = e.getMessage();
2011 } catch (Exception e) {
2013 errorMessage = e.getMessage();
2014 log.error("Caught exception looking for service logic", e);
2017 if (respProps != null) {
2018 errorCode = respProps.getProperty("error-code");
2019 errorMessage = respProps.getProperty("error-message");
2020 ackFinal = respProps.getProperty("ack-final", "Y");
2023 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2025 responseBuilder.setResponseCode(errorCode);
2026 responseBuilder.setResponseMessage(errorMessage);
2027 responseBuilder.setAckFinalIndicator(ackFinal);
2029 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2030 vnfInstancePreloadListBuilder.setVnfInstanceName(preloadName);
2031 vnfInstancePreloadListBuilder.setVnfModelId(preloadType);
2032 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadDataBuilder.build());
2034 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
2035 + errorCode + "', Reason: '" + errorMessage + "'");
2037 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), true,
2038 LogicalDatastoreType.CONFIGURATION);
2039 } catch (Exception e) {
2041 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2044 log.debug(SENDING_SUCCESS_RPC);
2045 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2046 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2047 .withResult(responseBuilder.build()).build();
2048 return Futures.immediateFuture(rpcResult);
2051 // Got success from SLI
2053 vnfInstancePreloadData = vnfInstancePreloadDataBuilder.build();
2055 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
2056 + vnfInstancePreloadData);
2057 // svc-configuration-list
2058 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2059 vnfInstancePreloadListBuilder.setVnfInstanceName(preloadName);
2060 vnfInstancePreloadListBuilder.setVnfModelId(preloadType);
2061 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadData);
2063 // SDNGC-989 set merge flag to false
2064 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false,
2065 LogicalDatastoreType.CONFIGURATION);
2066 log.info(UPDATING_OPERATIONAL_TREE_STR);
2067 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2068 } catch (Exception e) {
2069 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2071 responseBuilder.setResponseCode("500");
2072 responseBuilder.setResponseMessage(e.toString());
2073 responseBuilder.setAckFinalIndicator("Y");
2074 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
2075 + responseBuilder.build());
2076 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2077 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(false)
2078 .withResult(responseBuilder.build()).build();
2079 return Futures.immediateFuture(rpcResult);
2083 responseBuilder.setResponseCode(errorCode);
2084 responseBuilder.setAckFinalIndicator(ackFinal);
2085 if (errorMessage != null) {
2086 responseBuilder.setResponseMessage(errorMessage);
2088 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
2090 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
2093 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2094 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2096 return Futures.immediateFuture(rpcResult);
2100 //1610 preload-vf-module-topology-operation
2102 public Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2103 PreloadVfModuleTopologyOperationInput input) {
2105 final String svcOperation = "preload-vf-module-topology-operation";
2106 VfModulePreloadData vfModulePreloadData;
2107 Properties parms = new Properties();
2109 log.info(svcOperation + CALLED_STR);
2110 // create a new response object
2111 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder =
2112 new PreloadVfModuleTopologyOperationOutputBuilder();
2114 // Result from savePreloadData
2116 if (input == null || input.getVfModuleTopologyInformation() == null
2117 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName() == null
2118 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId() == null) {
2119 log.debug(EXITING_STR + svcOperation
2120 + " because of invalid input, null or empty vf-module-name or vf-module-model-id");
2121 responseBuilder.setResponseCode("403");
2122 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-name or vf-module-model-id");
2123 responseBuilder.setAckFinalIndicator("Y");
2124 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2125 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2126 .withResult(responseBuilder.build()).build();
2127 return Futures.immediateFuture(rpcResult);
2130 // Grab the name and type from the input buffer
2131 String preloadName = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName();
2132 String preloadType = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId();
2134 // Make sure we have a preloadName and preloadType
2135 if (preloadName == null || preloadName.length() == 0) {
2136 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
2137 responseBuilder.setResponseCode("403");
2138 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2139 responseBuilder.setAckFinalIndicator("Y");
2140 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2141 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2142 .withResult(responseBuilder.build()).build();
2143 return Futures.immediateFuture(rpcResult);
2145 if (preloadType == null || preloadType.length() == 0) {
2146 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
2147 responseBuilder.setResponseCode("403");
2148 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2149 responseBuilder.setAckFinalIndicator("Y");
2150 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2151 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2152 .withResult(responseBuilder.build()).build();
2153 return Futures.immediateFuture(rpcResult);
2156 if (input.getSdncRequestHeader() != null) {
2157 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2158 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2161 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
2162 getVfModulePreloadData(preloadName, preloadType, vfModulePreloadDataBuilder);
2163 VfModulePreloadDataBuilder operDataBuilder = new VfModulePreloadDataBuilder();
2164 getVfModulePreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2167 // setup a preload-data object builder
2168 // ACTION vnf-topology-operation
2170 // USES request-information;
2171 // uses vnf-topology-information;
2174 // container preload-data
2177 ADDING_INPUT_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
2178 PreloadVfModuleTopologyOperationInputBuilder inputBuilder =
2179 new PreloadVfModuleTopologyOperationInputBuilder(input);
2180 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2181 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
2182 + OPERATIONAL_DATA_STR + operDataBuilder.build());
2183 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
2185 // Call SLI sync method
2186 // Get SvcLogicService reference
2187 Properties respProps = null;
2188 String errorCode = "200";
2189 String errorMessage = null;
2190 String ackFinal = "Y";
2193 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
2194 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", vfModulePreloadDataBuilder, parms);
2196 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
2199 } catch (SvcLogicException e) {
2200 log.error("Caught exception executing service logic for " + svcOperation, e);
2201 errorMessage = e.getMessage();
2204 } catch (Exception e) {
2206 errorMessage = e.getMessage();
2207 log.error("Caught exception looking for service logic", e);
2210 if (respProps != null) {
2211 errorCode = respProps.getProperty("error-code");
2212 errorMessage = respProps.getProperty("error-message");
2213 ackFinal = respProps.getProperty("ack-final", "Y");
2216 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2218 responseBuilder.setResponseCode(errorCode);
2219 responseBuilder.setResponseMessage(errorMessage);
2220 responseBuilder.setAckFinalIndicator(ackFinal);
2222 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2223 vfModulePreloadListBuilder.setVfModuleName(preloadName);
2224 vfModulePreloadListBuilder.setVfModuleModelId(preloadType);
2225 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadDataBuilder.build());
2227 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
2228 + errorCode + "', Reason: '" + errorMessage + "'");
2230 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2231 } catch (Exception e) {
2233 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2236 log.debug(SENDING_SUCCESS_RPC);
2237 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2238 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2239 .withResult(responseBuilder.build()).build();
2240 return Futures.immediateFuture(rpcResult);
2243 // Got success from SLI
2245 vfModulePreloadData = vfModulePreloadDataBuilder.build();
2247 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
2248 + vfModulePreloadData);
2249 // svc-configuration-list
2250 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2251 vfModulePreloadListBuilder.setVfModuleName(preloadName);
2252 vfModulePreloadListBuilder.setVfModuleModelId(preloadType);
2253 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadData);
2255 // SDNGC-989 set merge flag to false
2256 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2257 log.info(UPDATING_OPERATIONAL_TREE_STR);
2258 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2259 } catch (Exception e) {
2260 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2262 responseBuilder.setResponseCode("500");
2263 responseBuilder.setResponseMessage(e.toString());
2264 responseBuilder.setAckFinalIndicator("Y");
2265 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
2266 + responseBuilder.build());
2267 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2268 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(false)
2269 .withResult(responseBuilder.build()).build();
2270 return Futures.immediateFuture(rpcResult);
2274 responseBuilder.setResponseCode(errorCode);
2275 responseBuilder.setAckFinalIndicator(ackFinal);
2276 if (errorMessage != null) {
2277 responseBuilder.setResponseMessage(errorMessage);
2279 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
2281 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
2284 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2285 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2287 return Futures.immediateFuture(rpcResult);
2292 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2293 PreloadNetworkTopologyOperationInput input) {
2295 final String svcOperation = "preload-network-topology-operation";
2296 PreloadData preloadData = null;
2297 Properties parms = new Properties();
2299 log.info(svcOperation + CALLED_STR);
2300 // create a new response object
2301 PreloadNetworkTopologyOperationOutputBuilder responseBuilder =
2302 new PreloadNetworkTopologyOperationOutputBuilder();
2304 // Result from savePreloadData
2306 if (input == null || input.getNetworkTopologyInformation() == null
2307 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null
2308 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName() == null
2309 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType() == null) {
2310 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or" +
2311 " empty network-name or network-type");
2312 responseBuilder.setResponseCode("403");
2313 responseBuilder.setResponseMessage("input, null or empty network-name or network-type");
2314 responseBuilder.setAckFinalIndicator("Y");
2315 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2316 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2318 return Futures.immediateFuture(rpcResult);
2321 // Grab the name and type from the input buffer
2322 String preloadName = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2323 String preloadType = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2325 // Make sure we have a preloadName and preloadType
2326 if (preloadName == null || preloadName.length() == 0) {
2327 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
2328 responseBuilder.setResponseCode("403");
2329 responseBuilder.setResponseMessage("input, invalid preload-name");
2330 responseBuilder.setAckFinalIndicator("Y");
2331 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2332 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2334 return Futures.immediateFuture(rpcResult);
2338 if (preloadType == null || preloadType.length() == 0) {
2339 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
2340 responseBuilder.setResponseCode("403");
2341 responseBuilder.setResponseMessage("input, invalid preload-type");
2342 responseBuilder.setAckFinalIndicator("Y");
2343 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2344 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2346 return Futures.immediateFuture(rpcResult);
2349 if (input.getSdncRequestHeader() != null) {
2350 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2351 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2354 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2355 getPreloadData(preloadName, preloadType, preloadDataBuilder);
2357 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2358 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2361 // setup a preload-data object builder
2362 // ACTION vnf-topology-operation
2364 // USES request-information;
2365 // uses vnf-topology-information;
2368 // container preload-data
2370 ADDING_INPUT_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
2371 PreloadNetworkTopologyOperationInputBuilder inputBuilder =
2372 new PreloadNetworkTopologyOperationInputBuilder(input);
2373 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2374 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
2375 + OPERATIONAL_DATA_STR + operDataBuilder.build());
2376 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
2378 // Call SLI sync method
2379 // Get SvcLogicService reference
2380 Properties respProps = null;
2381 String errorCode = "200";
2382 String errorMessage = null;
2383 String ackFinal = "Y";
2386 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
2387 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", preloadDataBuilder, parms);
2389 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
2392 } catch (SvcLogicException e) {
2393 log.error("Caught exception executing service logic for " + svcOperation, e);
2394 errorMessage = e.getMessage();
2396 } catch (Exception e) {
2398 errorMessage = e.getMessage();
2399 log.error("Caught exception looking for service logic", e);
2402 if (respProps != null) {
2403 errorCode = respProps.getProperty("error-code");
2404 errorMessage = respProps.getProperty("error-message");
2405 ackFinal = respProps.getProperty("ack-final", "Y");
2408 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2409 responseBuilder.setResponseCode(errorCode);
2410 responseBuilder.setResponseMessage(errorMessage);
2411 responseBuilder.setAckFinalIndicator(ackFinal);
2413 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2414 preloadVnfListBuilder.setVnfName(preloadName);
2415 preloadVnfListBuilder.setVnfType(preloadType);
2416 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2418 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
2419 + errorCode + "', Reason: '" + errorMessage + "'");
2421 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2422 } catch (Exception e) {
2424 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2428 log.debug(SENDING_SUCCESS_RPC);
2429 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2430 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2432 return Futures.immediateFuture(rpcResult);
2435 // Got success from SLI
2437 preloadData = preloadDataBuilder.build();
2439 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
2441 // svc-configuration-list
2442 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2443 preloadVnfListBuilder.setVnfName(preloadName);
2444 preloadVnfListBuilder.setVnfType(preloadType);
2445 preloadVnfListBuilder.setPreloadData(preloadData);
2447 // SDNGC-989 set merge flag to false
2448 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2449 log.info(UPDATING_OPERATIONAL_TREE_STR);
2450 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2451 } catch (Exception e) {
2452 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2454 responseBuilder.setResponseCode("500");
2455 responseBuilder.setResponseMessage(e.toString());
2456 responseBuilder.setAckFinalIndicator("Y");
2457 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
2458 + responseBuilder.build());
2459 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2460 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(false)
2461 .withResult(responseBuilder.build()).build();
2462 return Futures.immediateFuture(rpcResult);
2466 responseBuilder.setResponseCode(errorCode);
2467 responseBuilder.setAckFinalIndicator(ackFinal);
2468 if (errorMessage != null) {
2469 responseBuilder.setResponseMessage(errorMessage);
2471 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
2473 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
2476 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2477 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2479 return Futures.immediateFuture(rpcResult);