2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights
7 * ================================================================================
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 * ============LICENSE_END=========================================================
22 package org.onap.sdnc.vnfapi;
24 import com.google.common.util.concurrent.CheckedFuture;
25 import com.google.common.util.concurrent.FutureCallback;
26 import com.google.common.util.concurrent.Futures;
27 import com.google.common.util.concurrent.ListenableFuture;
28 import com.google.common.base.Optional;
29 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
30 import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
31 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
32 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
33 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
34 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
35 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
36 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
37 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
38 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
39 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
40 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationInput;
41 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationInputBuilder;
42 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationOutput;
43 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationOutputBuilder;
44 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationInput;
45 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationInputBuilder;
46 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationOutput;
47 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationOutputBuilder;
48 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationInput;
49 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationInputBuilder;
50 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationOutput;
51 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationOutputBuilder;
52 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModules;
53 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModulesBuilder;
54 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationInput;
55 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationInputBuilder;
56 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationOutput;
57 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationOutputBuilder;
58 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstances;
59 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstancesBuilder;
60 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationInput;
61 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationInputBuilder;
62 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationOutput;
63 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationOutputBuilder;
64 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfs;
65 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfsBuilder;
66 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VNFAPIService;
67 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationInput;
68 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationInputBuilder;
69 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationOutput;
70 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationOutputBuilder;
71 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModules;
72 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModulesBuilder;
73 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationInput;
74 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationInputBuilder;
75 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationOutput;
76 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationOutputBuilder;
77 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstances;
78 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstancesBuilder;
79 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationInput;
80 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationInputBuilder;
81 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationOutput;
82 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationOutputBuilder;
83 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.Vnfs;
84 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfsBuilder;
85 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.network.information.NetworkInformationBuilder;
86 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.data.PreloadData;
87 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.data.PreloadDataBuilder;
88 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadList;
89 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadListBuilder;
90 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadListKey;
91 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadList;
92 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadListBuilder;
93 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadListKey;
94 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadList;
95 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadListBuilder;
96 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadListKey;
97 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.request.information.RequestInformation;
98 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.sdnc.request.header.SdncRequestHeader;
99 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.sdnc.request.header.SdncRequestHeader.SvcAction;
100 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.data.ServiceData;
101 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.data.ServiceDataBuilder;
102 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus;
103 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RequestStatus;
104 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RpcAction;
105 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RpcName;
106 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.VnfsdnAction;
107 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.VnfsdnSubaction;
108 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatusBuilder;
109 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.information.VfModuleInformationBuilder;
110 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleList;
111 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleListBuilder;
112 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleListKey;
113 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.preload.data.VfModulePreloadData;
114 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.preload.data.VfModulePreloadDataBuilder;
115 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.service.data.VfModuleServiceData;
116 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.service.data.VfModuleServiceDataBuilder;
117 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.information.VnfInformationBuilder;
118 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.information.VnfInstanceInformationBuilder;
119 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceList;
120 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceListBuilder;
121 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceListKey;
122 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.preload.data.VnfInstancePreloadData;
123 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.preload.data.VnfInstancePreloadDataBuilder;
124 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.service.data.VnfInstanceServiceData;
125 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.service.data.VnfInstanceServiceDataBuilder;
126 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfList;
127 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfListBuilder;
128 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfListKey;
129 import org.opendaylight.yangtools.yang.binding.DataObject;
130 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
131 import org.opendaylight.yangtools.yang.common.RpcResult;
132 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
133 import org.opendaylight.yangtools.yang.data.api.schema.tree.ModifiedNodeDoesNotExistException;
134 import org.onap.ccsdk.sli.core.sli.SvcLogicException;
135 import org.slf4j.Logger;
136 import org.slf4j.LoggerFactory;
137 import org.slf4j.MDC;
140 import java.text.DateFormat;
141 import java.text.SimpleDateFormat;
142 import java.util.Date;
143 import java.util.Properties;
144 import java.util.TimeZone;
145 import java.util.concurrent.ExecutionException;
146 import java.util.concurrent.ExecutorService;
147 import java.util.concurrent.Executors;
148 import java.util.ArrayList;
149 import java.util.Collection;
150 import java.util.concurrent.Future;
153 * Defines a base implementation for your provider. This class extends from a helper class which provides storage for
154 * the most commonly used components of the MD-SAL. Additionally the base class provides some basic logging and
155 * initialization / clean up methods.
158 public class VnfApiProvider implements AutoCloseable, VNFAPIService, DataTreeChangeListener {
159 protected DataBroker dataBroker;
160 protected NotificationPublishService notificationService;
161 protected RpcProviderRegistry rpcRegistry;
162 protected BindingAwareBroker.RpcRegistration<VNFAPIService> rpcRegistration;
163 private final Logger log = LoggerFactory.getLogger(VnfApiProvider.class);
164 private final ExecutorService executor;
166 private static final String PRELOAD_DATA = "] PreloadData: ";
167 private static final String SENDING_SUCCESS_RPC = "Sending Success rpc result due to external error";
168 public static final String REASON = "', Reason: '";
169 public static final String ERROR_CODE = "] error code: '";
170 public static final String INVALID_INPUT_INVALID_PRELOAD_TYPE = "invalid input, invalid preload-type";
171 public static final String BECAUSE_OF_INVALID_PRELOAD_TYPE = " because of invalid preload-type";
172 public static final String INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID = "invalid input, null or empty service-instance-id";
173 public static final String BECAUSE_OF_INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID = " because of invalid input, null or empty service-instance-id";
174 private static final String APP_NAME = "vnfapi";
175 private static final String VNF_API = "VNF-API";
176 private static final String OPERATIONAL_DATA = "operational-data";
177 private static final String READ_MD_SAL_STR = "Read MD-SAL (";
178 private static final String DATA_FOR_STR = ") data for [";
179 private static final String SERVICE_DATA_STR = "] ServiceData: ";
180 private static final String NO_DATA_FOUND_STR = "No data found in MD-SAL (";
181 private static final String EXCEPTION_READING_MD_SAL_STR = "Caught Exception reading MD-SAL (";
182 private static final String FOR_STR = ") for [";
183 private static final String INVALID_INPUT_VF_MODULE_STR = "invalid input, null or empty vf-module-id";
184 private static final String UPDATED_MD_SAL_STR = "Updated MD-SAL for ";
185 private static final String RETURNED_SUCCESS_STR = "Returned SUCCESS for ";
186 private static final String UPDATING_OPERATIONAL_TREE_STR = "Updating OPERATIONAL tree.";
187 private static final String UPDATING_MD_SAL_STR = "Updating MD-SAL for ";
188 private static final String CAUGHT_EXCEPTION_STR = "Caught Exception updating MD-SAL for ";
189 private static final String RETURNED_FAILED_STR = "Returned FAILED for ";
190 private static final String ADDING_INPUT_DATA_STR = "Adding INPUT data for ";
191 private static final String ADDING_OPERATIONAL_DATA_STR = "Adding OPERATIONAL data for ";
192 private static final String OPERATIONAL_DATA_STR = "] operational-data: ";
193 private static final String ADDING_CONFIG_DATA_STR = "Adding CONFIG data for ";
194 private static final String INPUT_STR = "] input: ";
195 private static final String CALLED_STR = " called.";
196 private static final String EXITING_STR = "exiting ";
197 private static final String INVALID_INPUT_VNF_INSTANCE_STR = "invalid input, null or empty vnf-instance-id";
199 private VNFSDNSvcLogicServiceClient svcLogicClient;
201 public VnfApiProvider(DataBroker dataBroker2, NotificationPublishService notificationPublishService,
202 RpcProviderRegistry rpcProviderRegistry, VNFSDNSvcLogicServiceClient client) {
203 log.info("Creating provider for " + APP_NAME);
204 executor = Executors.newFixedThreadPool(1);
205 dataBroker = dataBroker2;
206 notificationService = notificationPublishService;
207 rpcRegistry = rpcProviderRegistry;
208 svcLogicClient = client;
212 private void initialize() {
213 log.info("Initializing provider for " + APP_NAME);
214 // Create the top level containers
217 VnfSdnUtil.loadProperties();
218 } catch (Exception e) {
219 log.error("Caught Exception while trying to load properties file: ", e);
222 log.info("Initialization complete for " + APP_NAME);
225 private void createContainers() {
226 final WriteTransaction t = dataBroker.newReadWriteTransaction();
228 // Create the Vnfs container
229 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
230 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
232 // Create the PreloadVnfs container
233 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
234 new PreloadVnfsBuilder().build());
235 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
236 new PreloadVnfsBuilder().build());
238 // 1610 Create the PreloadVnfInstances container
239 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfInstances.class),
240 new PreloadVnfInstancesBuilder().build());
241 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfInstances.class),
242 new PreloadVnfInstancesBuilder().build());
244 // 1610 Create the VnfInstances container
245 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VnfInstances.class),
246 new VnfInstancesBuilder().build());
247 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VnfInstances.class),
248 new VnfInstancesBuilder().build());
250 // 1610 Create the PreloadVfModules container
251 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVfModules.class),
252 new PreloadVfModulesBuilder().build());
253 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVfModules.class),
254 new PreloadVfModulesBuilder().build());
256 // 1610 Create the VfModules container
257 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VfModules.class),
258 new VfModulesBuilder().build());
259 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VfModules.class),
260 new VfModulesBuilder().build());
263 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
265 log.info("Create Containers succeeded!: ");
267 } catch (InterruptedException | ExecutionException e) {
268 log.error("Create Containers Failed: " + e);
273 public void close() throws Exception {
274 log.info("Closing provider for " + APP_NAME);
276 rpcRegistration.close();
277 log.info("Successfully closed provider for " + APP_NAME);
280 // On data change not used
282 public void onDataTreeChanged(Collection changes) {
284 log.info(" IN ON DATA CHANGE: ");
286 for (Object changeObj : changes) {
288 if (changeObj instanceof DataTreeModification) {
290 DataTreeModification change = (DataTreeModification) changeObj;
293 boolean changed = false;
294 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
295 DataObject updatedSubTree = change.getRootNode().getDataAfter();
297 if (updatedSubTree != null) {
298 if (log.isDebugEnabled()) {
299 log.debug("updatedSubTree was non-null:" + updatedSubTree);
301 if (updatedSubTree instanceof Vnfs) {
302 changed = isChanged(changed, (Vnfs) updatedSubTree);
304 if (updatedSubTree instanceof PreloadVnfs) {
305 changed = isChanged(changed, (PreloadVnfs) updatedSubTree);
308 if (updatedSubTree instanceof PreloadVnfInstances) {
309 changed = isChanged(changed, (PreloadVnfInstances) updatedSubTree);
312 if (updatedSubTree instanceof VnfInstances) {
313 changed = isChanged(changed, (VnfInstances) updatedSubTree);
316 if (updatedSubTree instanceof PreloadVfModules) {
317 changed = isChanged(changed, (PreloadVfModules) updatedSubTree);
320 if (updatedSubTree instanceof VfModules) {
321 changed = isChanged(changed, (VfModules) updatedSubTree);
325 // Do the write transaction only if something changed.
327 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = writeTransaction.submit();
328 Futures.addCallback(checkedFuture, new FutureCallback<Void>() {
331 public void onSuccess(Void arg0) {
332 log.debug("Successfully updated Service Status");
336 public void onFailure(Throwable e) {
337 log.debug("Failed updating Service Status", e);
345 private boolean isChanged(boolean changed, VfModules updatedSubTree) {
346 ArrayList<VfModuleList> vfModuleList =
347 (ArrayList<VfModuleList>) updatedSubTree.getVfModuleList();
348 if (vfModuleList != null) {
349 for (VfModuleList entry : vfModuleList) {
350 VfModuleServiceData vfModuleServiceData = entry.getVfModuleServiceData();
351 ServiceStatus serviceStatus = entry.getServiceStatus();
352 if (vfModuleServiceData != null && serviceStatus != null) {
353 // VfModuleServiceData change detected, check the AckFinal indicator and request-status to
354 // see if we need to proceed.
355 return isChanged(changed, serviceStatus);
362 private boolean isChanged(boolean changed, PreloadVfModules updatedSubTree) {
363 ArrayList<VfModulePreloadList> vnfInstanceList =
364 (ArrayList<VfModulePreloadList>) updatedSubTree.getVfModulePreloadList();
365 if (vnfInstanceList != null) {
366 for (VfModulePreloadList entry : vnfInstanceList) {
367 VfModulePreloadData vnfInstancePreloadData = entry.getVfModulePreloadData();
368 if (vnfInstancePreloadData != null) {
376 private boolean isChanged(boolean changed, VnfInstances updatedSubTree) {
377 ArrayList<VnfInstanceList> vnfInstanceList =
378 (ArrayList<VnfInstanceList>) updatedSubTree.getVnfInstanceList();
379 if (vnfInstanceList != null) {
380 for (VnfInstanceList entry : vnfInstanceList) {
381 VnfInstanceServiceData vnfInstanceServiceData = entry.getVnfInstanceServiceData();
382 ServiceStatus serviceStatus = entry.getServiceStatus();
383 if (vnfInstanceServiceData != null && serviceStatus != null) {
384 // VnfInstanceServiceData change detected, check the AckFinal indicator and request-status
385 // to see if we need to proceed.
386 return isChanged(changed, serviceStatus);
393 private boolean isChanged(boolean changed, PreloadVnfInstances updatedSubTree) {
394 ArrayList<VnfInstancePreloadList> vnfInstanceList =
395 (ArrayList<VnfInstancePreloadList>) updatedSubTree
396 .getVnfInstancePreloadList();
397 if (vnfInstanceList != null) {
398 for (VnfInstancePreloadList entry : vnfInstanceList) {
399 VnfInstancePreloadData vnfInstancePreloadData = entry.getVnfInstancePreloadData();
400 if (vnfInstancePreloadData != null) {
408 private boolean isChanged(boolean changed, PreloadVnfs updatedSubTree) {
409 ArrayList<VnfPreloadList> vnfList =
410 (ArrayList<VnfPreloadList>) updatedSubTree.getVnfPreloadList();
411 if (vnfList != null) {
412 for (VnfPreloadList entry : vnfList) {
413 PreloadData preloadData = entry.getPreloadData();
414 if (preloadData != null) {
422 private boolean isChanged(boolean changed, Vnfs updatedSubTree) {
423 ArrayList<VnfList> vnfList = (ArrayList<VnfList>) updatedSubTree.getVnfList();
424 if (vnfList != null) {
425 for (VnfList entry : vnfList) {
426 ServiceData serviceData = entry.getServiceData();
427 ServiceStatus serviceStatus = entry.getServiceStatus();
428 if (serviceData != null && serviceStatus != null) {
430 // ServiceData change detected, check the AckFinal indicator and request-status to see if we need to proceed.
432 return isChanged(changed, serviceStatus);
439 private boolean isChanged(boolean changed, ServiceStatus serviceStatus) {
440 if ((!"Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete
441 .equals(serviceStatus.getRequestStatus()))) {
442 if (log.isDebugEnabled()) {
443 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
450 private static class Iso8601Util {
453 private static TimeZone tz = TimeZone.getTimeZone("UTC");
454 private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
456 private Iso8601Util() {
463 private static String now() {
464 return df.format(new Date());
468 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
470 serviceStatusBuilder.setResponseCode(errorCode);
471 serviceStatusBuilder.setResponseMessage(errorMessage);
472 serviceStatusBuilder.setFinalIndicator(ackFinal);
473 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
476 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
477 if (requestInformation != null && requestInformation.getRequestAction() != null) {
478 switch (requestInformation.getRequestAction()) {
479 case VNFActivateRequest:
480 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VNFActivateRequest);
482 case ChangeVNFActivateRequest:
483 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVNFActivateRequest);
485 case DisconnectVNFRequest:
486 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVNFRequest);
488 case PreloadVNFRequest:
489 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVNFRequest);
491 case DeletePreloadVNFRequest:
492 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DeletePreloadVNFRequest);
494 // 1610 vnf-instance Requests
495 case VnfInstanceActivateRequest:
496 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VnfInstanceActivateRequest);
498 case ChangeVnfInstanceActivateRequest:
499 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVnfInstanceActivateRequest);
501 case DisconnectVnfInstanceRequest:
502 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVnfInstanceRequest);
504 case PreloadVnfInstanceRequest:
505 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVnfInstanceRequest);
507 // 1610 vf-module Requests
508 case VfModuleActivateRequest:
509 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VfModuleActivateRequest);
511 case ChangeVfModuleActivateRequest:
512 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVfModuleActivateRequest);
514 case DisconnectVfModuleRequest:
515 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVfModuleRequest);
517 case PreloadVfModuleRequest:
518 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVfModuleRequest);
521 log.error("Unknown RequestAction: " + requestInformation.getRequestAction());
525 if (requestInformation != null && requestInformation.getRequestSubAction() != null) {
526 switch (requestInformation.getRequestSubAction()) {
528 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP);
531 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
534 log.error("Unknown RequestSubAction: " + requestInformation.getRequestSubAction());
540 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
541 if (requestHeader != null && requestHeader.getSvcAction() != null) {
542 switch (requestHeader.getSvcAction()) {
544 serviceStatusBuilder.setRpcAction(RpcAction.Reserve);
547 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
550 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
553 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
556 serviceStatusBuilder.setRpcAction(RpcAction.Changeassign);
559 serviceStatusBuilder.setRpcAction(RpcAction.Changedelete);
562 serviceStatusBuilder.setRpcAction(RpcAction.Rollback);
565 log.error("Unknown SvcAction: " + requestHeader.getSvcAction());
571 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
573 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
577 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
578 // See if any data exists yet for this siid, if so grab it.
579 InstanceIdentifier<VnfList> serviceInstanceIdentifier = InstanceIdentifier
581 .child(VnfList.class, new VnfListKey(siid))
584 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
585 Optional<VnfList> data = Optional.absent();
587 data = readTx.read(type, serviceInstanceIdentifier).get();
588 } catch (InterruptedException | ExecutionException e) {
589 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
592 if (data.isPresent()) {
593 ServiceData serviceData = (ServiceData) data.get().getServiceData();
594 if (serviceData != null) {
595 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + siid + SERVICE_DATA_STR + serviceData);
596 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
597 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
598 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
599 serviceDataBuilder.setVnfRequestInformation(serviceData.getVnfRequestInformation());
600 serviceDataBuilder.setVnfId(serviceData.getVnfId());
601 serviceDataBuilder.setVnfTopologyInformation(serviceData.getVnfTopologyInformation());
602 serviceDataBuilder.setOperStatus(serviceData.getOperStatus());
604 log.info("No service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
607 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
612 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder) {
614 getVnfInstanceServiceData(siid, vnfInstanceServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
618 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder,
619 LogicalDatastoreType type) {
620 // See if any data exists yet for this siid, if so grab it.
621 InstanceIdentifier<VnfInstanceList> vnfInstanceIdentifier = InstanceIdentifier
622 .builder(VnfInstances.class)
623 .child(VnfInstanceList.class, new VnfInstanceListKey(siid))
626 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
627 Optional<VnfInstanceList> data = Optional.absent();
629 data = readTx.read(type, vnfInstanceIdentifier).get();
630 } catch (InterruptedException | ExecutionException e) {
631 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
634 if (data.isPresent()) {
635 VnfInstanceServiceData vnfInstanceServiceData = data.get().getVnfInstanceServiceData();
636 if (vnfInstanceServiceData != null) {
637 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + siid + "] VnfInstanceServiceData: "
638 + vnfInstanceServiceData);
639 vnfInstanceServiceDataBuilder.setSdncRequestHeader(vnfInstanceServiceData.getSdncRequestHeader());
640 vnfInstanceServiceDataBuilder.setRequestInformation(vnfInstanceServiceData.getRequestInformation());
641 vnfInstanceServiceDataBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
642 vnfInstanceServiceDataBuilder
643 .setVnfInstanceRequestInformation(vnfInstanceServiceData.getVnfInstanceRequestInformation());
644 vnfInstanceServiceDataBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
645 vnfInstanceServiceDataBuilder
646 .setVnfInstanceTopologyInformation(vnfInstanceServiceData.getVnfInstanceTopologyInformation());
647 vnfInstanceServiceDataBuilder.setOperStatus(vnfInstanceServiceData.getOperStatus());
649 log.info("No vnf-instance-service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
652 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
657 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder) {
659 getVfModuleServiceData(siid, vfModuleServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
663 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder,
664 LogicalDatastoreType type) {
665 // See if any data exists yet for this siid, if so grab it.
666 InstanceIdentifier<VfModuleList> vfModuleIdentifier = InstanceIdentifier
667 .builder(VfModules.class)
668 .child(VfModuleList.class, new VfModuleListKey(siid))
671 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
672 Optional<VfModuleList> data = Optional.absent();
674 data = readTx.read(type, vfModuleIdentifier).get();
675 } catch (InterruptedException | ExecutionException e) {
676 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + siid + "] ", e);
679 if (data.isPresent()) {
680 VfModuleServiceData vfModuleServiceData = data.get().getVfModuleServiceData();
681 if (vfModuleServiceData != null) {
683 READ_MD_SAL_STR + type + DATA_FOR_STR + siid + "] VfModuleServiceData: " + vfModuleServiceData);
684 vfModuleServiceDataBuilder.setSdncRequestHeader(vfModuleServiceData.getSdncRequestHeader());
685 vfModuleServiceDataBuilder.setRequestInformation(vfModuleServiceData.getRequestInformation());
686 vfModuleServiceDataBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
687 vfModuleServiceDataBuilder
688 .setVfModuleRequestInformation(vfModuleServiceData.getVfModuleRequestInformation());
689 vfModuleServiceDataBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
690 vfModuleServiceDataBuilder
691 .setVfModuleTopologyInformation(vfModuleServiceData.getVfModuleTopologyInformation());
692 vfModuleServiceDataBuilder.setOperStatus(vfModuleServiceData.getOperStatus());
694 log.info("No vf-module-service-data found in MD-SAL (" + type + FOR_STR + siid + "] ");
697 log.info(NO_DATA_FOUND_STR + type + FOR_STR + siid + "] ");
702 private void getPreloadData(String vnfName, String vnfType, PreloadDataBuilder preloadDataBuilder) {
704 getPreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
707 private void getPreloadData(String preloadName, String preloadType, PreloadDataBuilder preloadDataBuilder,
708 LogicalDatastoreType type) {
709 // See if any data exists yet for this name/type, if so grab it.
710 InstanceIdentifier<VnfPreloadList> preloadInstanceIdentifier = InstanceIdentifier
711 .builder(PreloadVnfs.class)
712 .child(VnfPreloadList.class, new VnfPreloadListKey(preloadName, preloadType))
715 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
716 Optional<VnfPreloadList> data = Optional.absent();
718 data = readTx.read(type, preloadInstanceIdentifier).get();
719 } catch (InterruptedException | ExecutionException e) {
720 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ",
724 if (data.isPresent()) {
725 PreloadData preloadData = (PreloadData) data.get().getPreloadData();
726 if (preloadData != null) {
727 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType + PRELOAD_DATA
729 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
730 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
731 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
734 "No preload-data found in MD-SAL (" + type + FOR_STR + preloadName + "," + preloadType + "] ");
737 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
741 //1610 preload-vnf-instance
742 private void getVnfInstancePreloadData(String vnfName, String vnfType,
743 VnfInstancePreloadDataBuilder preloadDataBuilder) {
745 getVnfInstancePreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
748 //1610 preload-vnf-instance
749 private void getVnfInstancePreloadData(String preloadName, String preloadType,
750 VnfInstancePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
751 // See if any data exists yet for this name/type, if so grab it.
752 InstanceIdentifier<VnfInstancePreloadList> preloadInstanceIdentifier = InstanceIdentifier
753 .builder(PreloadVnfInstances.class)
754 .child(VnfInstancePreloadList.class, new VnfInstancePreloadListKey(preloadName, preloadType))
757 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
758 Optional<VnfInstancePreloadList> data = Optional.absent();
760 data = readTx.read(type, preloadInstanceIdentifier).get();
761 } catch (InterruptedException | ExecutionException e) {
762 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ",
766 if (data.isPresent()) {
767 VnfInstancePreloadData preloadData = (VnfInstancePreloadData) data.get().getVnfInstancePreloadData();
768 if (preloadData != null) {
769 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType
770 + "] VnfInstancePreloadData: " + preloadData);
771 preloadDataBuilder.setVnfInstanceTopologyInformation(preloadData.getVnfInstanceTopologyInformation());
772 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
774 log.info("No vnf-instance-preload-data found in MD-SAL (" + type + FOR_STR + preloadName + ","
775 + preloadType + "] ");
778 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
782 // 1610 preload-vf-module
783 private void getVfModulePreloadData(String vnfName, String vnfType,
784 VfModulePreloadDataBuilder preloadDataBuilder) {
786 getVfModulePreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
789 private void getVfModulePreloadData(String preloadName, String preloadType,
790 VfModulePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
791 // See if any data exists yet for this name/type, if so grab it.
792 InstanceIdentifier<VfModulePreloadList> preloadInstanceIdentifier = InstanceIdentifier
793 .builder(PreloadVfModules.class)
794 .child(VfModulePreloadList.class, new VfModulePreloadListKey(preloadName, preloadType))
797 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
798 Optional<VfModulePreloadList> data = Optional.absent();
801 data = readTx.read(type, preloadInstanceIdentifier).get();
802 } catch (InterruptedException | ExecutionException e) {
803 log.error(EXCEPTION_READING_MD_SAL_STR + type + FOR_STR + preloadName + "," + preloadType + "] ",
807 if (data.isPresent()) {
808 VfModulePreloadData preloadData = (VfModulePreloadData) data.get().getVfModulePreloadData();
809 if (preloadData != null) {
810 log.info(READ_MD_SAL_STR + type + DATA_FOR_STR + preloadName + "," + preloadType
811 + "] VfModulePreloadData: " + preloadData);
812 preloadDataBuilder.setVfModuleTopologyInformation(preloadData.getVfModuleTopologyInformation());
813 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
816 "No preload-data found in MD-SAL (" + type + FOR_STR + preloadName + "," + preloadType + "] ");
819 log.info(NO_DATA_FOUND_STR + type + FOR_STR + preloadName + "," + preloadType + "] ");
823 private void deleteVnfList(final VnfList entry, LogicalDatastoreType storeType) {
824 // Each entry will be identifiable by a unique key, we have to create that identifier
825 InstanceIdentifier<VnfList> path = InstanceIdentifier
827 .child(VnfList.class, entry.key())
830 int optimisticLockTries = 2;
831 boolean tryAgain = true;
835 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
836 tx.delete(storeType, path);
837 tx.submit().checkedGet();
838 log.debug("DataStore delete succeeded");
839 } catch (OptimisticLockFailedException e) {
840 if (--optimisticLockTries <= 0) {
841 log.debug("Got OptimisticLockFailedException on last try - failing ");
842 throw new IllegalStateException(e);
844 log.debug("Got OptimisticLockFailedException - trying again ");
847 } catch (final TransactionCommitFailedException e) {
848 Throwable eCause = e.getCause();
851 if (eCause instanceof org.opendaylight.mdsal.common.api.TransactionCommitFailedException) {
852 log.debug("Nested TransactionCommitFailed exception - getting next cause");
853 eCause = eCause.getCause();
855 log.debug("Got TransactionCommitFailedException, caused by {}", eCause.getClass().getName());
858 if (eCause instanceof ModifiedNodeDoesNotExistException) {
859 log.debug("Ignoring ModifiedNodeDoesNotExistException");
863 log.debug("Delete DataStore failed due to exception", eCause);
864 throw new IllegalStateException(e);
869 private void saveVnfList(final VnfList entry, boolean merge, LogicalDatastoreType storeType) {
870 // Each entry will be identifiable by a unique key, we have to create that identifier
871 InstanceIdentifier<VnfList> path = InstanceIdentifier
873 .child(VnfList.class, entry.key())
876 tryUpdateDataStore(entry, merge, storeType, path);
880 private void saveVnfInstanceList(final VnfInstanceList entry, boolean merge, LogicalDatastoreType storeType) {
881 // Each entry will be identifiable by a unique key, we have to create that identifier
882 InstanceIdentifier<VnfInstanceList> path = InstanceIdentifier
883 .builder(VnfInstances.class)
884 .child(VnfInstanceList.class, entry.key())
887 tryUpdateDataStore(entry, merge, storeType, path);
891 private void saveVfModuleList(final VfModuleList entry, boolean merge, LogicalDatastoreType storeType) {
892 // Each entry will be identifiable by a unique key, we have to create that identifier
893 InstanceIdentifier<VfModuleList> path = InstanceIdentifier
894 .builder(VfModules.class)
895 .child(VfModuleList.class, entry.key())
898 tryUpdateDataStore(entry, merge, storeType, path);
901 private void savePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) {
903 // Each entry will be identifiable by a unique key, we have to create that identifier
904 InstanceIdentifier<VnfPreloadList> path = InstanceIdentifier
905 .builder(PreloadVnfs.class)
906 .child(VnfPreloadList.class, entry.key())
909 tryUpdateDataStore(entry, merge, storeType, path);
912 //1610 preload vnf-instance
913 private void saveVnfInstancePreloadList(final VnfInstancePreloadList entry, boolean merge,
914 LogicalDatastoreType storeType) {
916 // Each entry will be identifiable by a unique key, we have to create that identifier
917 InstanceIdentifier<VnfInstancePreloadList> path = InstanceIdentifier
918 .builder(PreloadVnfInstances.class)
919 .child(VnfInstancePreloadList.class, entry.key())
922 tryUpdateDataStore(entry, merge, storeType, path);
925 //1610 preload vf-module
926 private void saveVfModulePreloadList(final VfModulePreloadList entry, boolean merge,
927 LogicalDatastoreType storeType) {
929 // Each entry will be identifiable by a unique key, we have to create that identifier
930 InstanceIdentifier<VfModulePreloadList> path = InstanceIdentifier
931 .builder(PreloadVfModules.class)
932 .child(VfModulePreloadList.class, entry.key())
935 tryUpdateDataStore(entry, merge, storeType, path);
938 private <T extends DataObject> void tryUpdateDataStore(T entry, boolean merge, LogicalDatastoreType storeType,
939 InstanceIdentifier<T> path) {
944 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
946 tx.merge(storeType, path, entry);
948 tx.put(storeType, path, entry);
950 tx.submit().checkedGet();
951 log.debug("Update DataStore succeeded");
953 } catch (OptimisticLockFailedException e) {
955 log.debug("Got OptimisticLockFailedException on last try - failing ");
956 throw new IllegalStateException(e);
958 log.debug("Got OptimisticLockFailedException - trying again ");
959 } catch (final TransactionCommitFailedException e) {
960 log.debug("Update DataStore failed");
961 throw new IllegalStateException(e);
966 //Save the requestId into MDC
967 private void setRequestIdAsMDC(String requestId) {
968 MDC.put("RequestId", requestId);
971 //1610 vnf-instance-topology-operation
973 private Boolean validateVnfInstanceTopologyOperationInput(VnfInstanceTopologyOperationInput input) {
975 && input.getVnfInstanceRequestInformation() != null
976 && input.getVnfInstanceRequestInformation().getVnfInstanceId() != null
977 && input.getVnfInstanceRequestInformation().getVnfInstanceId().length() != 0;
980 private ListenableFuture<RpcResult<VnfInstanceTopologyOperationOutput>> buildVnfInstanceTopologyOperationOutputWithtError(
981 String responseCode, String responseMessage, String ackFinalIndicator) {
982 VnfInstanceTopologyOperationOutputBuilder responseBuilder = new VnfInstanceTopologyOperationOutputBuilder();
983 responseBuilder.setResponseCode(responseCode);
984 responseBuilder.setResponseMessage(responseMessage);
985 responseBuilder.setAckFinalIndicator(ackFinalIndicator);
986 return Futures.immediateFuture(RpcResultBuilder
987 .<VnfInstanceTopologyOperationOutput>status(true)
988 .withResult(responseBuilder.build())
993 public ListenableFuture<RpcResult<VnfInstanceTopologyOperationOutput>> vnfInstanceTopologyOperation(
994 VnfInstanceTopologyOperationInput input) {
996 final String svcOperation = "vnf-instance-topology-operation";
997 VnfInstanceServiceData vnfInstanceServiceData;
998 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
999 Properties parms = new Properties();
1001 log.info(svcOperation + CALLED_STR);
1002 // create a new response object
1003 VnfInstanceTopologyOperationOutputBuilder responseBuilder = new VnfInstanceTopologyOperationOutputBuilder();
1005 if (!validateVnfInstanceTopologyOperationInput(input)) {
1006 log.debug(EXITING_STR + svcOperation + " because of " + INVALID_INPUT_VNF_INSTANCE_STR);
1007 return buildVnfInstanceTopologyOperationOutputWithtError("403",
1008 INVALID_INPUT_VNF_INSTANCE_STR,
1012 // Grab the service instance ID from the input buffer
1013 String viid = input.getVnfInstanceRequestInformation().getVnfInstanceId();
1014 String preloadName = input.getVnfInstanceRequestInformation().getVnfInstanceName();
1015 String preloadType = input.getVnfInstanceRequestInformation().getVnfModelId();
1017 if (input.getSdncRequestHeader() != null) {
1018 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1019 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1022 // Get vnf-instance-preload-data
1023 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
1024 getVnfInstancePreloadData(preloadName, preloadType, vnfInstancePreloadDataBuilder);
1027 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1028 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1030 // Get operational-data
1031 VnfInstanceServiceDataBuilder operDataBuilder = new VnfInstanceServiceDataBuilder();
1032 getVnfInstanceServiceData(viid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1034 // Set the serviceStatus based on input
1035 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1036 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1039 // setup a service-data object builder
1040 // ACTION vnf-topology-operationa
1042 // USES sdnc-request-header;
1043 // USES request-information;
1044 // USES service-information;
1045 // USES vnf-request-information
1047 // USES vnf-topology-response-body;
1048 // USES vnf-information
1049 // USES service-information
1051 // container service-data
1052 // uses vnf-configuration-information;
1053 // uses oper-status;
1055 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + viid + INPUT_STR + input);
1056 VnfInstanceTopologyOperationInputBuilder inputBuilder = new VnfInstanceTopologyOperationInputBuilder(input);
1057 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1059 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + viid + OPERATIONAL_DATA_STR + operDataBuilder
1061 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1064 ADDING_CONFIG_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preload-data: "
1065 + vnfInstancePreloadDataBuilder.build());
1066 VnfSdnUtil.toProperties(parms, "vnf-instance-preload-data", vnfInstancePreloadDataBuilder);
1068 // Call SLI sync method
1069 // Get SvcLogicService reference
1070 Properties respProps = null;
1071 String errorCode = "200";
1072 String errorMessage = null;
1073 String ackFinal = "Y";
1076 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1077 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", vnfInstanceServiceDataBuilder, parms);
1079 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1082 } catch (SvcLogicException e) {
1083 log.error("Caught exception executing service logic for " + svcOperation, e);
1084 errorMessage = e.getMessage();
1086 } catch (Exception e) {
1088 errorMessage = e.getMessage();
1089 log.error("Caught exception looking for service logic", e);
1092 if (respProps != null) {
1093 errorCode = respProps.getProperty("error-code");
1094 errorMessage = respProps.getProperty("error-message");
1095 ackFinal = respProps.getProperty("ack-final", "Y");
1098 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1099 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1100 serviceStatusBuilder.setRpcName(RpcName.VnfInstanceTopologyOperation);
1102 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1103 responseBuilder.setResponseCode(errorCode);
1104 responseBuilder.setResponseMessage(errorMessage);
1105 responseBuilder.setAckFinalIndicator(ackFinal);
1106 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1107 vnfInstanceListBuilder.setVnfInstanceId(viid);
1108 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1110 saveVnfInstanceList(vnfInstanceListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1111 } catch (Exception e) {
1112 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + viid + "] \n", e);
1114 log.error(RETURNED_FAILED_STR + svcOperation + " [" + viid + "] " + responseBuilder.build());
1115 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
1116 .<VnfInstanceTopologyOperationOutput>status(true)
1117 .withResult(responseBuilder.build())
1120 return Futures.immediateFuture(rpcResult);
1123 // Got success from SLI
1125 vnfInstanceServiceData = vnfInstanceServiceDataBuilder.build();
1126 log.info(UPDATING_MD_SAL_STR + svcOperation + " [" + viid + "] VnfInstanceServiceData: "
1127 + vnfInstanceServiceData);
1128 // svc-configuration-list
1129 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1130 vnfInstanceListBuilder.setVnfInstanceServiceData(vnfInstanceServiceData);
1131 vnfInstanceListBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
1132 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1133 saveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1134 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1135 // Only update operational tree on Delete or Activate
1136 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1137 .getSvcAction().equals(SvcAction.Activate)) {
1138 log.info(UPDATING_OPERATIONAL_TREE_STR);
1139 saveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1142 VnfInstanceInformationBuilder vnfInstanceInformationBuilder = new VnfInstanceInformationBuilder();
1143 vnfInstanceInformationBuilder.setVnfInstanceId(viid);
1144 responseBuilder.setVnfInstanceInformation(vnfInstanceInformationBuilder.build());
1145 responseBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
1146 } catch (Exception e) {
1147 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + viid + "] \n", e);
1148 responseBuilder.setResponseCode("500");
1149 responseBuilder.setResponseMessage(e.toString());
1150 responseBuilder.setAckFinalIndicator("Y");
1151 log.error(RETURNED_FAILED_STR + svcOperation + " [" + viid + "] " + responseBuilder.build());
1152 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
1153 .<VnfInstanceTopologyOperationOutput>status(true)
1154 .withResult(responseBuilder.build())
1157 return Futures.immediateFuture(rpcResult);
1161 responseBuilder.setResponseCode(errorCode);
1162 responseBuilder.setAckFinalIndicator(ackFinal);
1163 if (errorMessage != null) {
1164 responseBuilder.setResponseMessage(errorMessage);
1166 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + viid + "] ");
1167 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + viid + "] " + responseBuilder.build());
1169 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult = RpcResultBuilder
1170 .<VnfInstanceTopologyOperationOutput>status(true)
1171 .withResult(responseBuilder.build())
1174 return Futures.immediateFuture(rpcResult);
1177 //1610 vf-module-topology-operation
1179 public ListenableFuture<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1180 VfModuleTopologyOperationInput input) {
1182 final String svcOperation = "vf-module-topology-operation";
1183 VfModuleServiceData vfModuleServiceData;
1184 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1185 Properties parms = new Properties();
1187 log.info(svcOperation + CALLED_STR);
1188 // create a new response object
1189 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1191 // Validate vf-module-id from vf-module-request-information
1192 if (input == null || input.getVfModuleRequestInformation() == null
1193 || input.getVfModuleRequestInformation().getVfModuleId() == null) {
1194 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty 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 // Grab the vf-module-request-information.vf-module-id from the input buffer
1207 String vfid = input.getVfModuleRequestInformation().getVfModuleId();
1208 String preloadName = input.getVfModuleRequestInformation().getVfModuleName();
1209 String preloadType = input.getVfModuleRequestInformation().getVfModuleModelId();
1211 // Make sure we have a valid siid
1212 if (vfid == null || vfid.length() == 0) {
1213 log.debug(EXITING_STR + svcOperation + " because of invalid vf-module-id");
1214 responseBuilder.setResponseCode("403");
1215 responseBuilder.setResponseMessage(INVALID_INPUT_VF_MODULE_STR);
1216 responseBuilder.setAckFinalIndicator("Y");
1217 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1218 .<VfModuleTopologyOperationOutput>status(true)
1219 .withResult(responseBuilder.build())
1222 return Futures.immediateFuture(rpcResult);
1225 // 1610 add vf-module-id to vnf-instance-list.vf-module-relationship-list
1226 String viid = input.getVfModuleRequestInformation().getVnfInstanceId();
1228 if (viid == null || viid.length() == 0) {
1229 log.debug(EXITING_STR + svcOperation + " because of invalid vnf-instance-id");
1230 responseBuilder.setResponseCode("403");
1231 responseBuilder.setResponseMessage(INVALID_INPUT_VNF_INSTANCE_STR);
1232 responseBuilder.setAckFinalIndicator("Y");
1233 RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1234 .<VfModuleTopologyOperationOutput>status(true)
1235 .withResult(responseBuilder.build())
1238 return Futures.immediateFuture(rpcResult);
1241 if (input.getSdncRequestHeader() != null) {
1242 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1243 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1246 // Get vf-module-preload-data
1247 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
1248 getVfModulePreloadData(preloadName, preloadType, vfModulePreloadDataBuilder);
1250 // Get vf-module-service-data
1251 VfModuleServiceDataBuilder vfModuleServiceDataBuilder = new VfModuleServiceDataBuilder();
1252 getVfModuleServiceData(vfid, vfModuleServiceDataBuilder);
1254 // Get vf-module operation-data
1255 VfModuleServiceDataBuilder operDataBuilder = new VfModuleServiceDataBuilder();
1256 getVfModuleServiceData(vfid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1258 // 1610 Need to pull vnf-instance-list.vf-module-relationship-list from MD-SAL
1259 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1260 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1262 // vnf-instance operational-data
1263 VnfInstanceServiceDataBuilder vnfInstanceOperDataBuilder = new VnfInstanceServiceDataBuilder();
1264 getVnfInstanceServiceData(viid, vnfInstanceOperDataBuilder, LogicalDatastoreType.OPERATIONAL);
1266 // Set the serviceStatus based on input
1267 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1268 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1271 // setup a service-data object builder
1272 // ACTION vnf-topology-operation
1274 // USES request-information;
1275 // USES service-information;
1276 // USES vnf-request-information
1278 // USES vnf-information
1279 // USES service-information
1281 // container service-data
1283 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + vfid + INPUT_STR + input);
1284 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1285 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1287 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + vfid + "] vf-module operational-data: "
1288 + operDataBuilder.build());
1289 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1291 log.info(ADDING_CONFIG_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
1292 + "] vf-module-preload-data: " + vfModulePreloadDataBuilder.build());
1293 VnfSdnUtil.toProperties(parms, "vf-module-preload-data", vfModulePreloadDataBuilder);
1295 log.info("Adding vnf-instance CONFIG data for " + svcOperation + " [" + viid + "] vnf-instance-service-data: "
1296 + vnfInstanceServiceDataBuilder.build());
1297 VnfSdnUtil.toProperties(parms, "vnf-instance-service-data", vnfInstanceServiceDataBuilder);
1299 log.info("Adding vnf-instance OPERATIONAL data for " + svcOperation + " [" + viid
1300 + "] vnf-instance operational-data: " + vnfInstanceOperDataBuilder.build());
1301 VnfSdnUtil.toProperties(parms, "vnf-instance-operational-data", vnfInstanceOperDataBuilder);
1303 // Call SLI sync method
1304 // Get SvcLogicService reference
1306 Properties respProps = null;
1307 String errorCode = "200";
1308 String errorMessage = null;
1309 String ackFinal = "Y";
1312 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1313 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", vfModuleServiceDataBuilder, parms);
1315 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1318 } catch (SvcLogicException e) {
1319 log.error("Caught exception executing service logic for " + svcOperation, e);
1320 errorMessage = e.getMessage();
1322 } catch (Exception e) {
1324 errorMessage = e.getMessage();
1325 log.error("Caught exception looking for service logic", e);
1328 if (respProps != null) {
1329 errorCode = respProps.getProperty("error-code");
1330 errorMessage = respProps.getProperty("error-message");
1331 ackFinal = respProps.getProperty("ack-final", "Y");
1334 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1335 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1336 serviceStatusBuilder.setRpcName(RpcName.VfModuleTopologyOperation);
1338 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1339 responseBuilder.setResponseCode(errorCode);
1340 responseBuilder.setResponseMessage(errorMessage);
1341 responseBuilder.setAckFinalIndicator(ackFinal);
1342 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1343 vfModuleListBuilder.setVfModuleId(vfid);
1344 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1346 saveVfModuleList(vfModuleListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1347 } catch (Exception e) {
1348 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + vfid + "] \n", e);
1350 log.error(RETURNED_FAILED_STR + svcOperation + " [" + vfid + "] " + responseBuilder.build());
1351 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1352 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1355 return Futures.immediateFuture(rpcResult);
1358 // Got success from SLI
1359 // save vf-module-service-data in MD-SAL
1361 vfModuleServiceData = vfModuleServiceDataBuilder.build();
1363 UPDATING_MD_SAL_STR + svcOperation + " [" + vfid + "] VfModuleServiceData: " + vfModuleServiceData);
1365 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1366 vfModuleListBuilder.setVfModuleServiceData(vfModuleServiceData);
1367 vfModuleListBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
1368 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1369 saveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1370 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1371 // Only update operational tree on Delete or Activate
1372 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1373 .getSvcAction().equals(SvcAction.Activate)) {
1374 log.info(UPDATING_OPERATIONAL_TREE_STR);
1375 saveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1378 VfModuleInformationBuilder vfModuleInformationBuilder = new VfModuleInformationBuilder();
1379 vfModuleInformationBuilder.setVfModuleId(vfid);
1380 responseBuilder.setVfModuleInformation(vfModuleInformationBuilder.build());
1381 responseBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
1382 } catch (Exception e) {
1383 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + vfid + "] \n", e);
1384 responseBuilder.setResponseCode("500");
1385 responseBuilder.setResponseMessage(e.toString());
1386 responseBuilder.setAckFinalIndicator("Y");
1387 log.error(RETURNED_FAILED_STR + svcOperation + " [" + vfid + "] " + responseBuilder.build());
1388 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1389 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1392 return Futures.immediateFuture(rpcResult);
1396 responseBuilder.setResponseCode(errorCode);
1397 responseBuilder.setAckFinalIndicator(ackFinal);
1398 if (errorMessage != null) {
1399 responseBuilder.setResponseMessage(errorMessage);
1401 log.info("Updated vf-module in MD-SAL for " + svcOperation + " [" + vfid + "] ");
1402 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + vfid + "] " + responseBuilder.build());
1404 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1405 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1407 return Futures.immediateFuture(rpcResult);
1411 public ListenableFuture<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
1412 final String svcOperation = "vnf-topology-operation";
1413 ServiceData serviceData;
1414 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1415 Properties parms = new Properties();
1417 log.info(svcOperation + CALLED_STR);
1418 // create a new response object
1419 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1421 if (input == null || input.getServiceInformation() == null
1422 || input.getServiceInformation().getServiceInstanceId() == null
1423 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1424 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty service-instance-id");
1425 responseBuilder.setResponseCode("403");
1426 responseBuilder.setResponseMessage(INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID);
1427 responseBuilder.setAckFinalIndicator("Y");
1428 RpcResult<VnfTopologyOperationOutput> rpcResult =
1429 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1431 return Futures.immediateFuture(rpcResult);
1434 if (input.getVnfRequestInformation() == null || input.getVnfRequestInformation().getVnfId() == null
1435 || input.getVnfRequestInformation().getVnfId().length() == 0) {
1436 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty vf-module-id");
1437 responseBuilder.setResponseCode("403");
1438 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1439 responseBuilder.setAckFinalIndicator("Y");
1440 RpcResult<VnfTopologyOperationOutput> rpcResult =
1441 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1443 return Futures.immediateFuture(rpcResult);
1446 // Grab the service instance ID from the input buffer
1447 String siid = input.getVnfRequestInformation().getVnfId();
1448 String preloadName = input.getVnfRequestInformation().getVnfName();
1449 String preloadType = input.getVnfRequestInformation().getVnfType();
1451 if (input.getSdncRequestHeader() != null) {
1452 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1453 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1456 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1457 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1459 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1460 getServiceData(siid, serviceDataBuilder);
1462 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1463 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1465 // Set the serviceStatus based on input
1466 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1467 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1470 // setup a service-data object builder
1471 // ACTION vnf-topology-operation
1473 // USES request-information;
1474 // USES vnf-request-information
1476 // USES vnf-information
1477 // USES service-information
1479 // container service-data
1480 // uses oper-status;
1482 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + siid + INPUT_STR + input);
1483 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1484 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1486 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + siid + OPERATIONAL_DATA_STR + operDataBuilder
1488 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1491 "Adding CONFIG data for " + svcOperation + " [" + preloadName + "," + preloadType + "] preload-data: "
1492 + preloadDataBuilder.build());
1493 VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1495 // Call SLI sync method
1496 // Get SvcLogicService reference
1497 Properties respProps = null;
1498 String errorCode = "200";
1499 String errorMessage = null;
1500 String ackFinal = "Y";
1503 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1504 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", serviceDataBuilder, parms);
1506 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1509 } catch (SvcLogicException e) {
1510 log.error("Caught exception executing service logic for " + siid, e);
1511 errorMessage = e.getMessage();
1513 } catch (Exception e) {
1515 errorMessage = e.getMessage();
1516 log.error("Caught exception looking for service logic", e);
1519 if (respProps != null) {
1520 errorCode = respProps.getProperty("error-code");
1521 errorMessage = respProps.getProperty("error-message");
1522 ackFinal = respProps.getProperty("ack-final", "Y");
1525 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1526 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1527 serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
1529 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1530 responseBuilder.setResponseCode(errorCode);
1531 responseBuilder.setResponseMessage(errorMessage);
1532 responseBuilder.setAckFinalIndicator(ackFinal);
1533 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1534 vnfListBuilder.setVnfId(siid);
1535 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1537 saveVnfList(vnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1538 } catch (Exception e) {
1539 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + siid + "] \n", e);
1541 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1542 RpcResult<VnfTopologyOperationOutput> rpcResult =
1543 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1545 return Futures.immediateFuture(rpcResult);
1548 // Got success from SLI
1550 serviceData = serviceDataBuilder.build();
1551 log.info(UPDATING_MD_SAL_STR + svcOperation + " [" + siid + "] ServiceData: " + serviceData);
1552 // svc-configuration-list
1553 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1554 vnfListBuilder.setServiceData(serviceData);
1555 vnfListBuilder.setVnfId(serviceData.getVnfId());
1556 siid = serviceData.getVnfId();
1557 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1558 saveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1559 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1560 // Only update operational tree on Delete or Activate
1561 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1562 log.info(UPDATING_OPERATIONAL_TREE_STR);
1563 saveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1564 } else if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input
1565 .getSdncRequestHeader().getSvcAction().equals(SvcAction.Rollback)) {
1566 log.info("Delete OPERATIONAL tree.");
1567 deleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
1568 deleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
1571 VnfInformationBuilder vnfInformationBuilder = new VnfInformationBuilder();
1572 vnfInformationBuilder.setVnfId(siid);
1573 responseBuilder.setVnfInformation(vnfInformationBuilder.build());
1574 responseBuilder.setServiceInformation(serviceData.getServiceInformation());
1575 } catch (Exception e) {
1576 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + siid + "] \n", e);
1577 responseBuilder.setResponseCode("500");
1578 responseBuilder.setResponseMessage(e.toString());
1579 responseBuilder.setAckFinalIndicator("Y");
1580 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1581 RpcResult<VnfTopologyOperationOutput> rpcResult =
1582 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1584 return Futures.immediateFuture(rpcResult);
1588 responseBuilder.setResponseCode(errorCode);
1589 responseBuilder.setAckFinalIndicator(ackFinal);
1590 if (errorMessage != null) {
1591 responseBuilder.setResponseMessage(errorMessage);
1593 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + siid + "] ");
1594 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1596 RpcResult<VnfTopologyOperationOutput> rpcResult =
1597 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1599 return Futures.immediateFuture(rpcResult);
1603 public ListenableFuture<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1604 NetworkTopologyOperationInput input) {
1606 final String svcOperation = "network-topology-operation";
1607 ServiceData serviceData;
1608 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1609 Properties parms = new Properties();
1611 log.info(svcOperation + CALLED_STR);
1612 // create a new response object
1613 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1615 if (input == null || input.getServiceInformation() == null
1616 || input.getServiceInformation().getServiceInstanceId() == null
1617 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1618 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty service-instance-id");
1619 responseBuilder.setResponseCode("403");
1620 responseBuilder.setResponseMessage(INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID);
1621 responseBuilder.setAckFinalIndicator("Y");
1622 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1623 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1626 return Futures.immediateFuture(rpcResult);
1629 if (input.getNetworkRequestInformation() == null
1630 || input.getNetworkRequestInformation().getNetworkName() == null) {
1631 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty service-instance-id");
1632 responseBuilder.setResponseCode("403");
1633 responseBuilder.setResponseMessage(INVALID_INPUT_NULL_OR_EMPTY_SERVICE_INSTANCE_ID);
1634 responseBuilder.setAckFinalIndicator("Y");
1635 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1636 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1639 return Futures.immediateFuture(rpcResult);
1642 // Grab the service instance ID from the input buffer
1644 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Assign)) {
1645 siid = input.getNetworkRequestInformation().getNetworkName();
1647 siid = input.getNetworkRequestInformation().getNetworkId();
1649 String preloadName = input.getNetworkRequestInformation().getNetworkName();
1650 String preloadType = input.getNetworkRequestInformation().getNetworkType();
1652 if (input.getSdncRequestHeader() != null) {
1653 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1654 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1657 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1658 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1660 log.info(ADDING_INPUT_DATA_STR + svcOperation + " [" + siid + INPUT_STR + input);
1661 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1662 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1664 // Call SLI sync method
1665 // Get SvcLogicService reference
1666 Properties respProps = null;
1667 String errorCode = "200";
1668 String errorMessage = null;
1669 String ackFinal = "Y";
1670 String networkId = "error";
1673 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1674 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", preloadDataBuilder, parms);
1676 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1679 } catch (SvcLogicException e) {
1680 log.error("Caught exception executing service logic for " + svcOperation, e);
1681 errorMessage = e.getMessage();
1683 } catch (Exception e) {
1685 errorMessage = e.getMessage();
1686 log.error("Caught exception looking for service logic", e);
1689 if (respProps != null) {
1690 errorCode = respProps.getProperty("error-code");
1691 errorMessage = respProps.getProperty("error-message");
1692 ackFinal = respProps.getProperty("ack-final", "Y");
1693 networkId = respProps.getProperty("networkId", "0");
1696 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1697 responseBuilder.setResponseCode(errorCode);
1698 responseBuilder.setResponseMessage(errorMessage);
1699 responseBuilder.setAckFinalIndicator(ackFinal);
1701 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);
1710 // Got success from SLI
1712 NetworkInformationBuilder networkInformationBuilder = new NetworkInformationBuilder();
1713 networkInformationBuilder.setNetworkId(networkId);
1714 responseBuilder.setNetworkInformation(networkInformationBuilder.build());
1715 responseBuilder.setServiceInformation(input.getServiceInformation());
1716 } catch (IllegalStateException e) {
1717 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + siid + "] \n", e);
1718 responseBuilder.setResponseCode("500");
1719 responseBuilder.setResponseMessage(e.toString());
1720 responseBuilder.setAckFinalIndicator("Y");
1721 log.error(RETURNED_FAILED_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1722 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1723 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1726 return Futures.immediateFuture(rpcResult);
1730 responseBuilder.setResponseCode(errorCode);
1731 responseBuilder.setAckFinalIndicator(ackFinal);
1732 if (errorMessage != null) {
1733 responseBuilder.setResponseMessage(errorMessage);
1735 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + siid + "] ");
1736 log.info(RETURNED_SUCCESS_STR + svcOperation + " [" + siid + "] " + responseBuilder.build());
1738 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1739 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1741 return Futures.immediateFuture(rpcResult);
1745 public ListenableFuture<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1746 PreloadVnfTopologyOperationInput input) {
1748 final String svcOperation = "preload-vnf-topology-operation";
1749 PreloadData preloadData;
1750 Properties parms = new Properties();
1752 log.info(svcOperation + CALLED_STR);
1753 // create a new response object
1754 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1756 // Result from savePreloadData
1758 if (input == null || input.getVnfTopologyInformation() == null
1759 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null
1760 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName() == null
1761 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType() == null) {
1762 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or empty vnf-name or vnf-type");
1763 responseBuilder.setResponseCode("403");
1764 responseBuilder.setResponseMessage("invalid input, null or empty vnf-name or vnf-type");
1765 responseBuilder.setAckFinalIndicator("Y");
1766 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1767 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1769 return Futures.immediateFuture(rpcResult);
1772 // Grab the name and type from the input buffer
1773 String preloadName = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1774 String preloadType = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1776 // Make sure we have a preload_name and preload_type
1777 if (preloadName == null || preloadName.length() == 0) {
1778 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
1779 responseBuilder.setResponseCode("403");
1780 responseBuilder.setResponseMessage(INVALID_INPUT_INVALID_PRELOAD_TYPE);
1781 responseBuilder.setAckFinalIndicator("Y");
1782 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1783 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1785 return Futures.immediateFuture(rpcResult);
1788 if (preloadType == null || preloadType.length() == 0) {
1789 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
1790 responseBuilder.setResponseCode("403");
1791 responseBuilder.setResponseMessage(INVALID_INPUT_INVALID_PRELOAD_TYPE);
1792 responseBuilder.setAckFinalIndicator("Y");
1793 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1794 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1796 return Futures.immediateFuture(rpcResult);
1799 if (input.getSdncRequestHeader() != null) {
1800 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1801 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1804 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1805 getPreloadData(preloadName, preloadType, preloadDataBuilder);
1806 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1807 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1810 // setup a preload-data object builder
1811 // ACTION vnf-topology-operation
1813 // USES request-information;
1814 // uses vnf-topology-information;
1817 // container preload-data
1819 ADDING_INPUT_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
1820 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1821 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1822 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
1823 + OPERATIONAL_DATA_STR + operDataBuilder.build());
1824 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1826 // Call SLI sync method
1827 // Get SvcLogicService reference
1828 Properties respProps = null;
1829 String errorCode = "200";
1830 String errorMessage = null;
1831 String ackFinal = "Y";
1834 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
1835 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", preloadDataBuilder, parms);
1837 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
1840 } catch (SvcLogicException e) {
1841 log.error("Caught exception executing service logic for " + svcOperation, e);
1842 errorMessage = e.getMessage();
1844 } catch (Exception e) {
1846 errorMessage = e.getMessage();
1847 log.error("Caught exception looking for service logic", e);
1850 if (respProps != null) {
1851 errorCode = respProps.getProperty("error-code");
1852 errorMessage = respProps.getProperty("error-message");
1853 ackFinal = respProps.getProperty("ack-final", "Y");
1856 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1858 responseBuilder.setResponseCode(errorCode);
1859 responseBuilder.setResponseMessage(errorMessage);
1860 responseBuilder.setAckFinalIndicator(ackFinal);
1862 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1863 preloadVnfListBuilder.setVnfName(preloadName);
1864 preloadVnfListBuilder.setVnfType(preloadType);
1865 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1867 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
1868 + errorCode + "', Reason: '" + errorMessage + "'");
1870 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1871 } catch (Exception e) {
1873 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
1876 log.debug(SENDING_SUCCESS_RPC);
1877 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1878 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1880 return Futures.immediateFuture(rpcResult);
1883 // Got success from SLI
1885 preloadData = preloadDataBuilder.build();
1887 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
1889 // svc-configuration-list
1890 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1891 preloadVnfListBuilder.setVnfName(preloadName);
1892 preloadVnfListBuilder.setVnfType(preloadType);
1893 preloadVnfListBuilder.setPreloadData(preloadData);
1895 // SDNGC-989 set merge flag to false
1896 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1897 log.info(UPDATING_OPERATIONAL_TREE_STR);
1898 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1899 } catch (Exception e) {
1900 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
1902 responseBuilder.setResponseCode("500");
1903 responseBuilder.setResponseMessage(e.toString());
1904 responseBuilder.setAckFinalIndicator("Y");
1905 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
1906 + responseBuilder.build());
1907 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1908 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(false).withResult(responseBuilder.build())
1910 return Futures.immediateFuture(rpcResult);
1914 responseBuilder.setResponseCode(errorCode);
1915 responseBuilder.setAckFinalIndicator(ackFinal);
1916 if (errorMessage != null) {
1917 responseBuilder.setResponseMessage(errorMessage);
1919 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
1921 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
1924 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1925 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1927 return Futures.immediateFuture(rpcResult);
1930 //1610 preload-vnf-instance-topology-operation
1932 public ListenableFuture<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> preloadVnfInstanceTopologyOperation(
1933 PreloadVnfInstanceTopologyOperationInput input) {
1935 final String svcOperation = "preload-vnf-instance-topology-operation";
1936 VnfInstancePreloadData vnfInstancePreloadData;
1937 Properties parms = new Properties();
1939 log.info(svcOperation + CALLED_STR);
1940 // create a new response object
1941 PreloadVnfInstanceTopologyOperationOutputBuilder responseBuilder =
1942 new PreloadVnfInstanceTopologyOperationOutputBuilder();
1944 if (input == null || input.getVnfInstanceTopologyInformation() == null
1945 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName() == null
1946 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId() == null) {
1947 log.debug(EXITING_STR + svcOperation
1948 + " because of invalid input, null or empty vnf-instance-name or vnf-model-id");
1949 responseBuilder.setResponseCode("403");
1950 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name or vnf-model-id");
1951 responseBuilder.setAckFinalIndicator("Y");
1952 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1953 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1954 .withResult(responseBuilder.build()).build();
1955 return Futures.immediateFuture(rpcResult);
1958 // Grab the name and type from the input buffer
1959 String preloadName =
1960 input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName();
1961 String preloadType = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId();
1963 // Make sure we have a preloadName and preloadType
1964 if (preloadName == null || preloadName.length() == 0) {
1965 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
1966 responseBuilder.setResponseCode("403");
1967 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1968 responseBuilder.setAckFinalIndicator("Y");
1969 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1970 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1971 .withResult(responseBuilder.build()).build();
1972 return Futures.immediateFuture(rpcResult);
1975 if (preloadType == null || preloadType.length() == 0) {
1976 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
1977 responseBuilder.setResponseCode("403");
1978 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1979 responseBuilder.setAckFinalIndicator("Y");
1980 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1981 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1982 .withResult(responseBuilder.build()).build();
1983 return Futures.immediateFuture(rpcResult);
1986 if (input.getSdncRequestHeader() != null) {
1987 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1988 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1991 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
1992 getVnfInstancePreloadData(preloadName, preloadType, vnfInstancePreloadDataBuilder);
1993 VnfInstancePreloadDataBuilder operDataBuilder = new VnfInstancePreloadDataBuilder();
1994 getVnfInstancePreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1997 // setup a preload-data object builder
1998 // ACTION vnf-topology-operation
2000 // uses vnf-topology-information;
2002 // container preload-data
2004 ADDING_CONFIG_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
2005 PreloadVnfInstanceTopologyOperationInputBuilder inputBuilder =
2006 new PreloadVnfInstanceTopologyOperationInputBuilder(input);
2007 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2008 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
2009 + OPERATIONAL_DATA_STR + operDataBuilder.build());
2010 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
2012 // Call SLI sync method
2013 // Get SvcLogicService reference
2014 Properties respProps = null;
2015 String errorCode = "200";
2016 String errorMessage = null;
2017 String ackFinal = "Y";
2020 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
2021 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", vnfInstancePreloadDataBuilder, parms);
2023 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
2026 } catch (SvcLogicException e) {
2027 log.error("Caught exception executing service logic for " + svcOperation, e);
2028 errorMessage = e.getMessage();
2030 } catch (Exception e) {
2032 errorMessage = e.getMessage();
2033 log.error("Caught exception looking for service logic", e);
2036 if (respProps != null) {
2037 errorCode = respProps.getProperty("error-code");
2038 errorMessage = respProps.getProperty("error-message");
2039 ackFinal = respProps.getProperty("ack-final", "Y");
2042 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2044 responseBuilder.setResponseCode(errorCode);
2045 responseBuilder.setResponseMessage(errorMessage);
2046 responseBuilder.setAckFinalIndicator(ackFinal);
2048 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2049 vnfInstancePreloadListBuilder.setVnfInstanceName(preloadName);
2050 vnfInstancePreloadListBuilder.setVnfModelId(preloadType);
2051 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadDataBuilder.build());
2053 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
2054 + errorCode + "', Reason: '" + errorMessage + "'");
2056 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), true,
2057 LogicalDatastoreType.CONFIGURATION);
2058 } catch (Exception e) {
2060 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2063 log.debug(SENDING_SUCCESS_RPC);
2064 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2065 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2066 .withResult(responseBuilder.build()).build();
2067 return Futures.immediateFuture(rpcResult);
2070 // Got success from SLI
2072 vnfInstancePreloadData = vnfInstancePreloadDataBuilder.build();
2074 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
2075 + vnfInstancePreloadData);
2076 // svc-configuration-list
2077 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2078 vnfInstancePreloadListBuilder.setVnfInstanceName(preloadName);
2079 vnfInstancePreloadListBuilder.setVnfModelId(preloadType);
2080 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadData);
2082 // SDNGC-989 set merge flag to false
2083 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false,
2084 LogicalDatastoreType.CONFIGURATION);
2085 log.info(UPDATING_OPERATIONAL_TREE_STR);
2086 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2087 } catch (Exception e) {
2088 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2090 responseBuilder.setResponseCode("500");
2091 responseBuilder.setResponseMessage(e.toString());
2092 responseBuilder.setAckFinalIndicator("Y");
2093 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
2094 + responseBuilder.build());
2095 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2096 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(false)
2097 .withResult(responseBuilder.build()).build();
2098 return Futures.immediateFuture(rpcResult);
2102 responseBuilder.setResponseCode(errorCode);
2103 responseBuilder.setAckFinalIndicator(ackFinal);
2104 if (errorMessage != null) {
2105 responseBuilder.setResponseMessage(errorMessage);
2107 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
2109 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
2112 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2113 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2115 return Futures.immediateFuture(rpcResult);
2119 //1610 preload-vf-module-topology-operation
2121 public ListenableFuture<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2122 PreloadVfModuleTopologyOperationInput input) {
2124 final String svcOperation = "preload-vf-module-topology-operation";
2125 VfModulePreloadData vfModulePreloadData;
2126 Properties parms = new Properties();
2128 log.info(svcOperation + CALLED_STR);
2129 // create a new response object
2130 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder =
2131 new PreloadVfModuleTopologyOperationOutputBuilder();
2133 // Result from savePreloadData
2135 if (input == null || input.getVfModuleTopologyInformation() == null
2136 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName() == null
2137 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId() == null) {
2138 log.debug(EXITING_STR + svcOperation
2139 + " because of invalid input, null or empty vf-module-name or vf-module-model-id");
2140 responseBuilder.setResponseCode("403");
2141 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-name or vf-module-model-id");
2142 responseBuilder.setAckFinalIndicator("Y");
2143 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2144 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2145 .withResult(responseBuilder.build()).build();
2146 return Futures.immediateFuture(rpcResult);
2149 // Grab the name and type from the input buffer
2150 String preloadName = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName();
2151 String preloadType = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId();
2153 // Make sure we have a preloadName and preloadType
2154 if (preloadName == null || preloadName.length() == 0) {
2155 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
2156 responseBuilder.setResponseCode("403");
2157 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2158 responseBuilder.setAckFinalIndicator("Y");
2159 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2160 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2161 .withResult(responseBuilder.build()).build();
2162 return Futures.immediateFuture(rpcResult);
2164 if (preloadType == null || preloadType.length() == 0) {
2165 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
2166 responseBuilder.setResponseCode("403");
2167 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2168 responseBuilder.setAckFinalIndicator("Y");
2169 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2170 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2171 .withResult(responseBuilder.build()).build();
2172 return Futures.immediateFuture(rpcResult);
2175 if (input.getSdncRequestHeader() != null) {
2176 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2177 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2180 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
2181 getVfModulePreloadData(preloadName, preloadType, vfModulePreloadDataBuilder);
2182 VfModulePreloadDataBuilder operDataBuilder = new VfModulePreloadDataBuilder();
2183 getVfModulePreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2186 // setup a preload-data object builder
2187 // ACTION vnf-topology-operation
2189 // USES request-information;
2190 // uses vnf-topology-information;
2193 // container preload-data
2196 ADDING_INPUT_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
2197 PreloadVfModuleTopologyOperationInputBuilder inputBuilder =
2198 new PreloadVfModuleTopologyOperationInputBuilder(input);
2199 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2200 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
2201 + OPERATIONAL_DATA_STR + operDataBuilder.build());
2202 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
2204 // Call SLI sync method
2205 // Get SvcLogicService reference
2206 Properties respProps = null;
2207 String errorCode = "200";
2208 String errorMessage = null;
2209 String ackFinal = "Y";
2212 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
2213 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", vfModulePreloadDataBuilder, parms);
2215 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
2218 } catch (SvcLogicException e) {
2219 log.error("Caught exception executing service logic for " + svcOperation, e);
2220 errorMessage = e.getMessage();
2223 } catch (Exception e) {
2225 errorMessage = e.getMessage();
2226 log.error("Caught exception looking for service logic", e);
2229 if (respProps != null) {
2230 errorCode = respProps.getProperty("error-code");
2231 errorMessage = respProps.getProperty("error-message");
2232 ackFinal = respProps.getProperty("ack-final", "Y");
2235 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2237 responseBuilder.setResponseCode(errorCode);
2238 responseBuilder.setResponseMessage(errorMessage);
2239 responseBuilder.setAckFinalIndicator(ackFinal);
2241 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2242 vfModulePreloadListBuilder.setVfModuleName(preloadName);
2243 vfModulePreloadListBuilder.setVfModuleModelId(preloadType);
2244 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadDataBuilder.build());
2246 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
2247 + errorCode + "', Reason: '" + errorMessage + "'");
2249 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2250 } catch (Exception e) {
2252 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2255 log.debug(SENDING_SUCCESS_RPC);
2256 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2257 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2258 .withResult(responseBuilder.build()).build();
2259 return Futures.immediateFuture(rpcResult);
2262 // Got success from SLI
2264 vfModulePreloadData = vfModulePreloadDataBuilder.build();
2266 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
2267 + vfModulePreloadData);
2268 // svc-configuration-list
2269 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2270 vfModulePreloadListBuilder.setVfModuleName(preloadName);
2271 vfModulePreloadListBuilder.setVfModuleModelId(preloadType);
2272 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadData);
2274 // SDNGC-989 set merge flag to false
2275 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2276 log.info(UPDATING_OPERATIONAL_TREE_STR);
2277 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2278 } catch (Exception e) {
2279 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2281 responseBuilder.setResponseCode("500");
2282 responseBuilder.setResponseMessage(e.toString());
2283 responseBuilder.setAckFinalIndicator("Y");
2284 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
2285 + responseBuilder.build());
2286 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2287 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(false)
2288 .withResult(responseBuilder.build()).build();
2289 return Futures.immediateFuture(rpcResult);
2293 responseBuilder.setResponseCode(errorCode);
2294 responseBuilder.setAckFinalIndicator(ackFinal);
2295 if (errorMessage != null) {
2296 responseBuilder.setResponseMessage(errorMessage);
2298 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
2300 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
2303 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2304 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2306 return Futures.immediateFuture(rpcResult);
2311 public ListenableFuture<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2312 PreloadNetworkTopologyOperationInput input) {
2314 final String svcOperation = "preload-network-topology-operation";
2315 PreloadData preloadData = null;
2316 Properties parms = new Properties();
2318 log.info(svcOperation + CALLED_STR);
2319 // create a new response object
2320 PreloadNetworkTopologyOperationOutputBuilder responseBuilder =
2321 new PreloadNetworkTopologyOperationOutputBuilder();
2323 // Result from savePreloadData
2325 if (input == null || input.getNetworkTopologyInformation() == null
2326 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null
2327 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName() == null
2328 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType() == null) {
2329 log.debug(EXITING_STR + svcOperation + " because of invalid input, null or" +
2330 " empty network-name or network-type");
2331 responseBuilder.setResponseCode("403");
2332 responseBuilder.setResponseMessage("input, null or empty network-name or network-type");
2333 responseBuilder.setAckFinalIndicator("Y");
2334 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2335 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2337 return Futures.immediateFuture(rpcResult);
2340 // Grab the name and type from the input buffer
2341 String preloadName = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2342 String preloadType = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2344 // Make sure we have a preloadName and preloadType
2345 if (preloadName == null || preloadName.length() == 0) {
2346 log.debug(EXITING_STR + svcOperation + " because of invalid preload-name");
2347 responseBuilder.setResponseCode("403");
2348 responseBuilder.setResponseMessage("input, invalid preload-name");
2349 responseBuilder.setAckFinalIndicator("Y");
2350 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2351 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2353 return Futures.immediateFuture(rpcResult);
2357 if (preloadType == null || preloadType.length() == 0) {
2358 log.debug(EXITING_STR + svcOperation + " because of invalid preload-type");
2359 responseBuilder.setResponseCode("403");
2360 responseBuilder.setResponseMessage("input, invalid preload-type");
2361 responseBuilder.setAckFinalIndicator("Y");
2362 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2363 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2365 return Futures.immediateFuture(rpcResult);
2368 if (input.getSdncRequestHeader() != null) {
2369 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2370 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2373 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2374 getPreloadData(preloadName, preloadType, preloadDataBuilder);
2376 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2377 getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2380 // setup a preload-data object builder
2381 // ACTION vnf-topology-operation
2383 // USES request-information;
2384 // uses vnf-topology-information;
2387 // container preload-data
2389 ADDING_INPUT_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType + INPUT_STR + input);
2390 PreloadNetworkTopologyOperationInputBuilder inputBuilder =
2391 new PreloadNetworkTopologyOperationInputBuilder(input);
2392 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2393 log.info(ADDING_OPERATIONAL_DATA_STR + svcOperation + " [" + preloadName + "," + preloadType
2394 + OPERATIONAL_DATA_STR + operDataBuilder.build());
2395 VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
2397 // Call SLI sync method
2398 // Get SvcLogicService reference
2399 Properties respProps = null;
2400 String errorCode = "200";
2401 String errorMessage = null;
2402 String ackFinal = "Y";
2405 if (svcLogicClient.hasGraph(VNF_API, svcOperation, null, "sync")) {
2406 respProps = svcLogicClient.execute(VNF_API, svcOperation, null, "sync", preloadDataBuilder, parms);
2408 errorMessage = "No service logic active for VNF-API: '" + svcOperation + "'";
2411 } catch (SvcLogicException e) {
2412 log.error("Caught exception executing service logic for " + svcOperation, e);
2413 errorMessage = e.getMessage();
2415 } catch (Exception e) {
2417 errorMessage = e.getMessage();
2418 log.error("Caught exception looking for service logic", e);
2421 if (respProps != null) {
2422 errorCode = respProps.getProperty("error-code");
2423 errorMessage = respProps.getProperty("error-message");
2424 ackFinal = respProps.getProperty("ack-final", "Y");
2427 if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2428 responseBuilder.setResponseCode(errorCode);
2429 responseBuilder.setResponseMessage(errorMessage);
2430 responseBuilder.setAckFinalIndicator(ackFinal);
2432 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2433 preloadVnfListBuilder.setVnfName(preloadName);
2434 preloadVnfListBuilder.setVnfType(preloadType);
2435 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2437 RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] error code: '"
2438 + errorCode + "', Reason: '" + errorMessage + "'");
2440 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2441 } catch (Exception e) {
2443 CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2447 log.debug(SENDING_SUCCESS_RPC);
2448 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2449 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2451 return Futures.immediateFuture(rpcResult);
2454 // Got success from SLI
2456 preloadData = preloadDataBuilder.build();
2458 UPDATING_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] preloadData: "
2460 // svc-configuration-list
2461 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2462 preloadVnfListBuilder.setVnfName(preloadName);
2463 preloadVnfListBuilder.setVnfType(preloadType);
2464 preloadVnfListBuilder.setPreloadData(preloadData);
2466 // SDNGC-989 set merge flag to false
2467 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2468 log.info(UPDATING_OPERATIONAL_TREE_STR);
2469 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2470 } catch (Exception e) {
2471 log.error(CAUGHT_EXCEPTION_STR + svcOperation + " [" + preloadName + "," + preloadType
2473 responseBuilder.setResponseCode("500");
2474 responseBuilder.setResponseMessage(e.toString());
2475 responseBuilder.setAckFinalIndicator("Y");
2476 log.error(RETURNED_FAILED_STR + svcOperation + " [" + preloadName + "," + preloadType + "] "
2477 + responseBuilder.build());
2478 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2479 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(false)
2480 .withResult(responseBuilder.build()).build();
2481 return Futures.immediateFuture(rpcResult);
2485 responseBuilder.setResponseCode(errorCode);
2486 responseBuilder.setAckFinalIndicator(ackFinal);
2487 if (errorMessage != null) {
2488 responseBuilder.setResponseMessage(errorMessage);
2490 log.info(UPDATED_MD_SAL_STR + svcOperation + " [" + preloadName + "," + preloadType + "] ");
2492 RETURNED_SUCCESS_STR + svcOperation + " [" + preloadName + "," + preloadType + "] " + responseBuilder
2495 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2496 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2498 return Futures.immediateFuture(rpcResult);