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.base.Optional;
25 import com.google.common.util.concurrent.CheckedFuture;
26 import com.google.common.util.concurrent.FutureCallback;
27 import com.google.common.util.concurrent.Futures;
28 import com.google.common.util.concurrent.SettableFuture;
29 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
30 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
31 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
32 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
33 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
34 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
35 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
36 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
37 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
38 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
39 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
40 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationInput;
41 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationInputBuilder;
42 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationOutput;
43 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationOutputBuilder;
44 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationInput;
45 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationInputBuilder;
46 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationOutput;
47 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationOutputBuilder;
48 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationInput;
49 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationInputBuilder;
50 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationOutput;
51 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationOutputBuilder;
52 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModules;
53 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModulesBuilder;
54 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationInput;
55 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationInputBuilder;
56 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationOutput;
57 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationOutputBuilder;
58 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstances;
59 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstancesBuilder;
60 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationInput;
61 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationInputBuilder;
62 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationOutput;
63 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationOutputBuilder;
64 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfs;
65 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfsBuilder;
66 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VNFAPIService;
67 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationInput;
68 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationInputBuilder;
69 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationOutput;
70 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationOutputBuilder;
71 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModules;
72 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModulesBuilder;
73 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationInput;
74 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationInputBuilder;
75 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationOutput;
76 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationOutputBuilder;
77 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstances;
78 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstancesBuilder;
79 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationInput;
80 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationInputBuilder;
81 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationOutput;
82 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationOutputBuilder;
83 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.Vnfs;
84 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfsBuilder;
85 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.network.information.NetworkInformationBuilder;
86 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.data.PreloadData;
87 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.data.PreloadDataBuilder;
88 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadList;
89 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadListBuilder;
90 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadListKey;
91 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadList;
92 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadListBuilder;
93 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadListKey;
94 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadList;
95 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadListBuilder;
96 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadListKey;
97 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.request.information.RequestInformation;
98 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.sdnc.request.header.SdncRequestHeader;
99 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.sdnc.request.header.SdncRequestHeader.SvcAction;
100 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.data.ServiceData;
101 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.data.ServiceDataBuilder;
102 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus;
103 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RequestStatus;
104 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RpcAction;
105 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RpcName;
106 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.VnfsdnAction;
107 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.VnfsdnSubaction;
108 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatusBuilder;
109 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.information.VfModuleInformationBuilder;
110 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleList;
111 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleListBuilder;
112 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleListKey;
113 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.preload.data.VfModulePreloadData;
114 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.preload.data.VfModulePreloadDataBuilder;
115 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.service.data.VfModuleServiceData;
116 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.service.data.VfModuleServiceDataBuilder;
117 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.information.VnfInformationBuilder;
118 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.information.VnfInstanceInformationBuilder;
119 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceList;
120 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceListBuilder;
121 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceListKey;
122 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.preload.data.VnfInstancePreloadData;
123 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.preload.data.VnfInstancePreloadDataBuilder;
124 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.service.data.VnfInstanceServiceData;
125 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.service.data.VnfInstanceServiceDataBuilder;
126 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfList;
127 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfListBuilder;
128 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfListKey;
129 import org.opendaylight.yangtools.concepts.ListenerRegistration;
130 import org.opendaylight.yangtools.yang.binding.DataObject;
131 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
132 import org.opendaylight.yangtools.yang.common.RpcResult;
133 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
134 import org.opendaylight.yangtools.yang.data.api.schema.tree.ModifiedNodeDoesNotExistException;
135 import org.slf4j.Logger;
136 import org.slf4j.LoggerFactory;
137 import org.slf4j.MDC;
139 import java.text.DateFormat;
140 import java.text.SimpleDateFormat;
141 import java.util.ArrayList;
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.concurrent.Future;
151 * Defines a base implementation for your provider. This class extends from a helper class
152 * which provides storage for the most commonly used components of the MD-SAL. Additionally the
153 * base class provides some basic logging and initialization / clean up methods.
155 public class VnfApiProvider implements AutoCloseable, VNFAPIService, DataChangeListener {
157 private final Logger log = LoggerFactory.getLogger(VnfApiProvider.class);
159 private static final String APP_NAME = "vnfapi";
161 private VNFSDNSvcLogicServiceClient svcLogicClient;
162 private final ExecutorService executor;
164 protected DataBroker dataBroker;
165 protected NotificationPublishService notificationService;
166 protected RpcProviderRegistry rpcRegistry;
167 protected BindingAwareBroker.RpcRegistration<VNFAPIService> rpcRegistration;
169 public VnfApiProvider(DataBroker dataBroker2, NotificationPublishService notificationPublishService,
170 RpcProviderRegistry rpcProviderRegistry, VNFSDNSvcLogicServiceClient client) {
171 log.info("Creating provider for " + APP_NAME);
172 executor = Executors.newFixedThreadPool(1);
173 dataBroker = dataBroker2;
174 notificationService = notificationPublishService;
175 rpcRegistry = rpcProviderRegistry;
176 svcLogicClient = client;
180 private void initialize() {
181 log.info("Initializing provider for " + APP_NAME);
182 // Create the top level containers
185 VnfSdnUtil.loadProperties();
186 } catch (Exception e) {
187 log.error("Caught Exception while trying to load properties file: ", e);
190 log.info("Initialization complete for " + APP_NAME);
193 private void createContainers() {
194 final WriteTransaction t = dataBroker.newReadWriteTransaction();
196 // Create the Vnfs container
197 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
198 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Vnfs.class), new VnfsBuilder().build());
200 // Create the PreloadVnfs container
201 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
202 new PreloadVnfsBuilder().build());
203 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
204 new PreloadVnfsBuilder().build());
206 // 1610 Create the PreloadVnfInstances container
207 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfInstances.class),
208 new PreloadVnfInstancesBuilder().build());
209 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfInstances.class),
210 new PreloadVnfInstancesBuilder().build());
212 // 1610 Create the VnfInstances container
213 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VnfInstances.class),
214 new VnfInstancesBuilder().build());
215 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VnfInstances.class),
216 new VnfInstancesBuilder().build());
218 // 1610 Create the PreloadVfModules container
219 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVfModules.class),
220 new PreloadVfModulesBuilder().build());
221 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVfModules.class),
222 new PreloadVfModulesBuilder().build());
224 // 1610 Create the VfModules container
225 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VfModules.class),
226 new VfModulesBuilder().build());
227 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VfModules.class),
228 new VfModulesBuilder().build());
231 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
233 log.info("Create Containers succeeded!: ");
235 } catch (InterruptedException | ExecutionException e) {
236 log.error("Create Containers Failed: " + e);
241 public void close() throws Exception {
242 log.info("Closing provider for " + APP_NAME);
244 rpcRegistration.close();
245 log.info("Successfully closed provider for " + APP_NAME);
248 // On data change not used
250 public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
252 log.info(" IN ON DATA CHANGE: ");
254 boolean changed = false;
255 WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
256 DataObject updatedSubTree = change.getUpdatedSubtree();
258 if (updatedSubTree != null) {
259 if (log.isDebugEnabled()) {
260 log.debug("updatedSubTree was non-null:" + updatedSubTree);
262 if (updatedSubTree instanceof Vnfs) {
263 changed = isChanged(changed, (Vnfs) updatedSubTree);
265 if (updatedSubTree instanceof PreloadVnfs) {
266 changed = isChanged(changed, (PreloadVnfs) updatedSubTree);
269 if (updatedSubTree instanceof PreloadVnfInstances) {
270 changed = isChanged(changed, (PreloadVnfInstances) updatedSubTree);
273 if (updatedSubTree instanceof VnfInstances) {
274 changed = isChanged(changed, (VnfInstances) updatedSubTree);
277 if (updatedSubTree instanceof PreloadVfModules) {
278 changed = isChanged(changed, (PreloadVfModules) updatedSubTree);
281 if (updatedSubTree instanceof VfModules) {
282 changed = isChanged(changed, (VfModules) updatedSubTree);
286 // Do the write transaction only if something changed.
288 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = writeTransaction.submit();
289 Futures.addCallback(checkedFuture, new FutureCallback<Void>() {
292 public void onSuccess(Void arg0) {
293 log.debug("Successfully updated Service Status");
297 public void onFailure(Throwable e) {
298 log.debug("Failed updating Service Status", e);
304 private boolean isChanged(boolean changed, VfModules updatedSubTree) {
305 ArrayList<VfModuleList> vfModuleList =
306 (ArrayList<VfModuleList>) updatedSubTree.getVfModuleList();
307 if (vfModuleList != null) {
308 for (VfModuleList entry : vfModuleList) {
309 VfModuleServiceData vfModuleServiceData = entry.getVfModuleServiceData();
310 ServiceStatus serviceStatus = entry.getServiceStatus();
311 if (vfModuleServiceData != null && serviceStatus != null) {
312 // VfModuleServiceData change detected, check the AckFinal indicator and request-status to
313 // see if we need to proceed.
314 return isChanged(changed, serviceStatus);
321 private boolean isChanged(boolean changed, PreloadVfModules updatedSubTree) {
322 ArrayList<VfModulePreloadList> vnfInstanceList =
323 (ArrayList<VfModulePreloadList>) updatedSubTree.getVfModulePreloadList();
324 if (vnfInstanceList != null) {
325 for (VfModulePreloadList entry : vnfInstanceList) {
326 VfModulePreloadData vnfInstancePreloadData = entry.getVfModulePreloadData();
327 if (vnfInstancePreloadData != null) {
335 private boolean isChanged(boolean changed, VnfInstances updatedSubTree) {
336 ArrayList<VnfInstanceList> vnfInstanceList =
337 (ArrayList<VnfInstanceList>) updatedSubTree.getVnfInstanceList();
338 if (vnfInstanceList != null) {
339 for (VnfInstanceList entry : vnfInstanceList) {
340 VnfInstanceServiceData vnfInstanceServiceData = entry.getVnfInstanceServiceData();
341 ServiceStatus serviceStatus = entry.getServiceStatus();
342 if (vnfInstanceServiceData != null && serviceStatus != null) {
343 // VnfInstanceServiceData change detected, check the AckFinal indicator and request-status
344 // to see if we need to proceed.
345 return isChanged(changed, serviceStatus);
352 private boolean isChanged(boolean changed, PreloadVnfInstances updatedSubTree) {
353 ArrayList<VnfInstancePreloadList> vnfInstanceList =
354 (ArrayList<VnfInstancePreloadList>) updatedSubTree
355 .getVnfInstancePreloadList();
356 if (vnfInstanceList != null) {
357 for (VnfInstancePreloadList entry : vnfInstanceList) {
358 VnfInstancePreloadData vnfInstancePreloadData = entry.getVnfInstancePreloadData();
359 if (vnfInstancePreloadData != null) {
367 private boolean isChanged(boolean changed, PreloadVnfs updatedSubTree) {
368 ArrayList<VnfPreloadList> vnfList =
369 (ArrayList<VnfPreloadList>) updatedSubTree.getVnfPreloadList();
370 if (vnfList != null) {
371 for (VnfPreloadList entry : vnfList) {
372 PreloadData preloadData = entry.getPreloadData();
373 if (preloadData != null) {
381 private boolean isChanged(boolean changed, Vnfs updatedSubTree) {
382 ArrayList<VnfList> vnfList = (ArrayList<VnfList>) updatedSubTree.getVnfList();
383 if (vnfList != null) {
384 for (VnfList entry : vnfList) {
385 ServiceData serviceData = entry.getServiceData();
386 ServiceStatus serviceStatus = entry.getServiceStatus();
387 if (serviceData != null && serviceStatus != null) {
389 // ServiceData change detected, check the AckFinal indicator and request-status to see if we need to proceed.
391 return isChanged(changed, serviceStatus);
398 private boolean isChanged(boolean changed, ServiceStatus serviceStatus) {
399 if ((!"Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete
400 .equals(serviceStatus.getRequestStatus()))) {
401 if (log.isDebugEnabled()) {
402 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
409 private static class Iso8601Util {
411 private static TimeZone tz = TimeZone.getTimeZone("UTC");
412 private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
414 private Iso8601Util() {}
420 private static String now() {
421 return df.format(new Date());
425 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
427 serviceStatusBuilder.setResponseCode(errorCode);
428 serviceStatusBuilder.setResponseMessage(errorMessage);
429 serviceStatusBuilder.setFinalIndicator(ackFinal);
430 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
433 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
434 if (requestInformation != null && requestInformation.getRequestAction() != null) {
435 switch (requestInformation.getRequestAction()) {
436 case VNFActivateRequest:
437 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VNFActivateRequest);
439 case ChangeVNFActivateRequest:
440 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVNFActivateRequest);
442 case DisconnectVNFRequest:
443 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVNFRequest);
445 case PreloadVNFRequest:
446 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVNFRequest);
448 case DeletePreloadVNFRequest:
449 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DeletePreloadVNFRequest);
451 // 1610 vnf-instance Requests
452 case VnfInstanceActivateRequest:
453 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VnfInstanceActivateRequest);
455 case ChangeVnfInstanceActivateRequest:
456 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVnfInstanceActivateRequest);
458 case DisconnectVnfInstanceRequest:
459 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVnfInstanceRequest);
461 case PreloadVnfInstanceRequest:
462 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVnfInstanceRequest);
464 // 1610 vf-module Requests
465 case VfModuleActivateRequest:
466 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VfModuleActivateRequest);
468 case ChangeVfModuleActivateRequest:
469 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVfModuleActivateRequest);
471 case DisconnectVfModuleRequest:
472 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVfModuleRequest);
474 case PreloadVfModuleRequest:
475 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVfModuleRequest);
478 log.error("Unknown RequestAction: " + requestInformation.getRequestAction());
482 if (requestInformation != null && requestInformation.getRequestSubAction() != null) {
483 switch (requestInformation.getRequestSubAction()) {
485 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP);
488 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
491 log.error("Unknown RequestSubAction: " + requestInformation.getRequestSubAction());
497 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
498 if (requestHeader != null && requestHeader.getSvcAction() != null) {
499 switch (requestHeader.getSvcAction()) {
501 serviceStatusBuilder.setRpcAction(RpcAction.Reserve);
504 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
507 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
510 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
513 serviceStatusBuilder.setRpcAction(RpcAction.Changeassign);
516 serviceStatusBuilder.setRpcAction(RpcAction.Changedelete);
519 serviceStatusBuilder.setRpcAction(RpcAction.Rollback);
522 log.error("Unknown SvcAction: " + requestHeader.getSvcAction());
528 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
530 getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
534 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
535 // See if any data exists yet for this siid, if so grab it.
536 InstanceIdentifier serviceInstanceIdentifier =
537 InstanceIdentifier.<Vnfs>builder(Vnfs.class).child(VnfList.class, new VnfListKey(siid)).build();
538 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
539 Optional<VnfList> data = null;
541 data = (Optional<VnfList>) readTx.read(type, serviceInstanceIdentifier).get();
542 } catch (InterruptedException | ExecutionException e) {
543 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + siid + "] ", e);
546 if (data != null && data.isPresent()) {
547 ServiceData serviceData = (ServiceData) data.get().getServiceData();
548 if (serviceData != null) {
549 log.info("Read MD-SAL (" + type + ") data for [" + siid + "] ServiceData: " + serviceData);
550 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
551 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
552 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
553 serviceDataBuilder.setVnfRequestInformation(serviceData.getVnfRequestInformation());
554 serviceDataBuilder.setVnfId(serviceData.getVnfId());
555 serviceDataBuilder.setVnfTopologyInformation(serviceData.getVnfTopologyInformation());
556 serviceDataBuilder.setOperStatus(serviceData.getOperStatus());
558 log.info("No service-data found in MD-SAL (" + type + ") for [" + siid + "] ");
561 log.info("No data found in MD-SAL (" + type + ") for [" + siid + "] ");
566 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder) {
568 getVnfInstanceServiceData(siid, vnfInstanceServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
572 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder,
573 LogicalDatastoreType type) {
574 // See if any data exists yet for this siid, if so grab it.
575 InstanceIdentifier vnfInstanceIdentifier = InstanceIdentifier.<VnfInstances>builder(VnfInstances.class)
576 .child(VnfInstanceList.class, new VnfInstanceListKey(siid)).build();
577 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
578 Optional<VnfInstanceList> data = null;
580 data = (Optional<VnfInstanceList>) readTx.read(type, vnfInstanceIdentifier).get();
581 } catch (InterruptedException | ExecutionException e) {
582 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + siid + "] ", e);
585 if (data != null && data.isPresent()) {
586 VnfInstanceServiceData vnfInstanceServiceData =
587 (VnfInstanceServiceData) data.get().getVnfInstanceServiceData();
588 if (vnfInstanceServiceData != null) {
589 log.info("Read MD-SAL (" + type + ") data for [" + siid + "] VnfInstanceServiceData: "
590 + vnfInstanceServiceData);
591 vnfInstanceServiceDataBuilder.setSdncRequestHeader(vnfInstanceServiceData.getSdncRequestHeader());
592 vnfInstanceServiceDataBuilder.setRequestInformation(vnfInstanceServiceData.getRequestInformation());
593 vnfInstanceServiceDataBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
594 vnfInstanceServiceDataBuilder
595 .setVnfInstanceRequestInformation(vnfInstanceServiceData.getVnfInstanceRequestInformation());
596 vnfInstanceServiceDataBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
597 vnfInstanceServiceDataBuilder
598 .setVnfInstanceTopologyInformation(vnfInstanceServiceData.getVnfInstanceTopologyInformation());
599 vnfInstanceServiceDataBuilder.setOperStatus(vnfInstanceServiceData.getOperStatus());
601 log.info("No vnf-instance-service-data found in MD-SAL (" + type + ") for [" + siid + "] ");
604 log.info("No data found in MD-SAL (" + type + ") for [" + siid + "] ");
609 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder) {
611 getVfModuleServiceData(siid, vfModuleServiceDataBuilder, LogicalDatastoreType.CONFIGURATION);
615 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder,
616 LogicalDatastoreType type) {
617 // See if any data exists yet for this siid, if so grab it.
618 InstanceIdentifier vfModuleIdentifier =
619 InstanceIdentifier.<VfModules>builder(VfModules.class).child(VfModuleList.class, new VfModuleListKey(siid))
621 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
622 Optional<VfModuleList> data = null;
624 data = (Optional<VfModuleList>) readTx.read(type, vfModuleIdentifier).get();
625 } catch (InterruptedException | ExecutionException e) {
626 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + siid + "] ", e);
629 if (data != null && data.isPresent()) {
630 VfModuleServiceData vfModuleServiceData = data.get().getVfModuleServiceData();
631 if (vfModuleServiceData != null) {
633 "Read MD-SAL (" + type + ") data for [" + siid + "] VfModuleServiceData: " + vfModuleServiceData);
634 vfModuleServiceDataBuilder.setSdncRequestHeader(vfModuleServiceData.getSdncRequestHeader());
635 vfModuleServiceDataBuilder.setRequestInformation(vfModuleServiceData.getRequestInformation());
636 vfModuleServiceDataBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
637 vfModuleServiceDataBuilder
638 .setVfModuleRequestInformation(vfModuleServiceData.getVfModuleRequestInformation());
639 vfModuleServiceDataBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
640 vfModuleServiceDataBuilder
641 .setVfModuleTopologyInformation(vfModuleServiceData.getVfModuleTopologyInformation());
642 vfModuleServiceDataBuilder.setOperStatus(vfModuleServiceData.getOperStatus());
644 log.info("No vf-module-service-data found in MD-SAL (" + type + ") for [" + siid + "] ");
647 log.info("No data found in MD-SAL (" + type + ") for [" + siid + "] ");
652 private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder) {
654 getPreloadData(vnf_name, vnf_type, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
657 private void getPreloadData(String preload_name, String preload_type, PreloadDataBuilder preloadDataBuilder,
658 LogicalDatastoreType type) {
659 // See if any data exists yet for this name/type, if so grab it.
660 InstanceIdentifier preloadInstanceIdentifier = InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
661 .child(VnfPreloadList.class, new VnfPreloadListKey(preload_name, preload_type)).build();
662 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
663 Optional<VnfPreloadList> data = null;
665 data = (Optional<VnfPreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
666 } catch (InterruptedException | ExecutionException e) {
667 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ",
671 if (data != null && data.isPresent()) {
672 PreloadData preloadData = (PreloadData) data.get().getPreloadData();
673 if (preloadData != null) {
674 log.info("Read MD-SAL (" + type + ") data for [" + preload_name + "," + preload_type + "] PreloadData: "
676 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
677 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
678 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
681 "No preload-data found in MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ");
684 log.info("No data found in MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ");
688 //1610 preload-vnf-instance
689 private void getVnfInstancePreloadData(String vnf_name, String vnf_type,
690 VnfInstancePreloadDataBuilder preloadDataBuilder) {
692 getVnfInstancePreloadData(vnf_name, vnf_type, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
695 //1610 preload-vnf-instance
696 private void getVnfInstancePreloadData(String preload_name, String preload_type,
697 VnfInstancePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
698 // See if any data exists yet for this name/type, if so grab it.
699 InstanceIdentifier preloadInstanceIdentifier =
700 InstanceIdentifier.<PreloadVnfInstances>builder(PreloadVnfInstances.class)
701 .child(VnfInstancePreloadList.class, new VnfInstancePreloadListKey(preload_name, preload_type)).build();
702 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
703 Optional<VnfInstancePreloadList> data = null;
705 data = (Optional<VnfInstancePreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
706 } catch (InterruptedException | ExecutionException e) {
707 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ",
711 if (data != null && data.isPresent()) {
712 VnfInstancePreloadData preloadData = (VnfInstancePreloadData) data.get().getVnfInstancePreloadData();
713 if (preloadData != null) {
714 log.info("Read MD-SAL (" + type + ") data for [" + preload_name + "," + preload_type
715 + "] VnfInstancePreloadData: " + preloadData);
716 preloadDataBuilder.setVnfInstanceTopologyInformation(preloadData.getVnfInstanceTopologyInformation());
717 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
719 log.info("No vnf-instance-preload-data found in MD-SAL (" + type + ") for [" + preload_name + ","
720 + preload_type + "] ");
723 log.info("No data found in MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ");
727 // 1610 preload-vf-module
728 private void getVfModulePreloadData(String vnf_name, String vnf_type,
729 VfModulePreloadDataBuilder preloadDataBuilder) {
731 getVfModulePreloadData(vnf_name, vnf_type, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
734 private void getVfModulePreloadData(String preload_name, String preload_type,
735 VfModulePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type) {
736 // See if any data exists yet for this name/type, if so grab it.
737 InstanceIdentifier preloadInstanceIdentifier =
738 InstanceIdentifier.<PreloadVfModules>builder(PreloadVfModules.class)
739 .child(VfModulePreloadList.class, new VfModulePreloadListKey(preload_name, preload_type)).build();
740 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
741 Optional<VfModulePreloadList> data = null;
743 data = (Optional<VfModulePreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
744 } catch (InterruptedException | ExecutionException e) {
745 log.error("Caught Exception reading MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ",
749 if (data != null && data.isPresent()) {
750 VfModulePreloadData preloadData = (VfModulePreloadData) data.get().getVfModulePreloadData();
751 if (preloadData != null) {
752 log.info("Read MD-SAL (" + type + ") data for [" + preload_name + "," + preload_type
753 + "] VfModulePreloadData: " + preloadData);
754 preloadDataBuilder.setVfModuleTopologyInformation(preloadData.getVfModuleTopologyInformation());
755 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
758 "No preload-data found in MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ");
761 log.info("No data found in MD-SAL (" + type + ") for [" + preload_name + "," + preload_type + "] ");
765 private void SaveVnfList(final VnfList entry, boolean merge, LogicalDatastoreType storeType)
766 throws IllegalStateException {
767 // Each entry will be identifiable by a unique key, we have to create that identifier
768 InstanceIdentifier.InstanceIdentifierBuilder<VnfList> vnfListIdBuilder =
769 InstanceIdentifier.<Vnfs>builder(Vnfs.class).child(VnfList.class, entry.getKey());
770 InstanceIdentifier<VnfList> path = vnfListIdBuilder.build();
775 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
777 tx.merge(storeType, path, entry);
779 tx.put(storeType, path, entry);
781 tx.submit().checkedGet();
782 log.debug("Update DataStore succeeded");
784 } catch (final TransactionCommitFailedException e) {
785 if (e instanceof OptimisticLockFailedException) {
787 log.debug("Got OptimisticLockFailedException on last try - failing ");
788 throw new IllegalStateException(e);
790 log.debug("Got OptimisticLockFailedException - trying again ");
792 log.debug("Update DataStore failed");
793 throw new IllegalStateException(e);
800 private void DeleteVnfList(final VnfList entry, LogicalDatastoreType storeType) throws IllegalStateException {
801 // Each entry will be identifiable by a unique key, we have to create that identifier
802 InstanceIdentifier.InstanceIdentifierBuilder<VnfList> vnfListIdBuilder =
803 InstanceIdentifier.<Vnfs>builder(Vnfs.class).child(VnfList.class, entry.getKey());
804 InstanceIdentifier<VnfList> path = vnfListIdBuilder.build();
806 int optimisticLockTries = 2;
807 boolean tryAgain =true;
811 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
812 tx.delete(storeType, path);
813 tx.submit().checkedGet();
814 log.debug("DataStore delete succeeded");
815 } catch (final TransactionCommitFailedException e) {
816 if (e instanceof OptimisticLockFailedException) {
817 if (--optimisticLockTries <= 0) {
818 log.debug("Got OptimisticLockFailedException on last try - failing ");
819 throw new IllegalStateException(e);
821 log.debug("Got OptimisticLockFailedException - trying again ");
826 if (e.getCause() instanceof ModifiedNodeDoesNotExistException) {
827 log.debug("Ignoring MpdifiedNodeDoesNotExistException");
831 log.debug("Delete DataStore failed");
832 throw new IllegalStateException(e);
838 private void SaveVnfInstanceList(final VnfInstanceList entry, boolean merge, LogicalDatastoreType storeType)
839 throws IllegalStateException {
840 // Each entry will be identifiable by a unique key, we have to create that identifier
841 InstanceIdentifier.InstanceIdentifierBuilder<VnfInstanceList> vnfInstanceListIdBuilder =
842 InstanceIdentifier.<VnfInstances>builder(VnfInstances.class).child(VnfInstanceList.class, entry.getKey());
843 InstanceIdentifier<VnfInstanceList> path = vnfInstanceListIdBuilder.build();
848 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
850 tx.merge(storeType, path, entry);
852 tx.put(storeType, path, entry);
854 tx.submit().checkedGet();
855 log.debug("Update DataStore succeeded");
857 } catch (final TransactionCommitFailedException e) {
858 if (e instanceof OptimisticLockFailedException) {
860 log.debug("Got OptimisticLockFailedException on last try - failing ");
861 throw new IllegalStateException(e);
863 log.debug("Got OptimisticLockFailedException - trying again ");
865 log.debug("Update DataStore failed");
866 throw new IllegalStateException(e);
873 private void SaveVfModuleList(final VfModuleList entry, boolean merge, LogicalDatastoreType storeType)
874 throws IllegalStateException {
875 // Each entry will be identifiable by a unique key, we have to create that identifier
876 InstanceIdentifier.InstanceIdentifierBuilder<VfModuleList> vfModuleListIdBuilder =
877 InstanceIdentifier.<VfModules>builder(VfModules.class).child(VfModuleList.class, entry.getKey());
878 InstanceIdentifier<VfModuleList> path = vfModuleListIdBuilder.build();
883 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
885 tx.merge(storeType, path, entry);
887 tx.put(storeType, path, entry);
889 tx.submit().checkedGet();
890 log.debug("Update DataStore succeeded");
892 } catch (final TransactionCommitFailedException e) {
893 if (e instanceof OptimisticLockFailedException) {
895 log.debug("Got OptimisticLockFailedException on last try - failing ");
896 throw new IllegalStateException(e);
898 log.debug("Got OptimisticLockFailedException - trying again ");
900 log.debug("Update DataStore failed");
901 throw new IllegalStateException(e);
907 private void SavePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType)
908 throws IllegalStateException {
910 // Each entry will be identifiable by a unique key, we have to create that identifier
911 InstanceIdentifier.InstanceIdentifierBuilder<VnfPreloadList> vnfListIdBuilder =
912 InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class).child(VnfPreloadList.class, entry.getKey());
913 InstanceIdentifier<VnfPreloadList> path = vnfListIdBuilder.build();
917 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
919 tx.merge(storeType, path, entry);
921 tx.put(storeType, path, entry);
923 tx.submit().checkedGet();
924 log.debug("Update DataStore succeeded");
926 } catch (final TransactionCommitFailedException e) {
927 if (e instanceof OptimisticLockFailedException) {
929 log.debug("Got OptimisticLockFailedException on last try - failing ");
930 throw new IllegalStateException(e);
932 log.debug("Got OptimisticLockFailedException - trying again ");
934 log.debug("Update DataStore failed");
935 throw new IllegalStateException(e);
941 //1610 preload vnf-instance
942 private void SaveVnfInstancePreloadList(final VnfInstancePreloadList entry, boolean merge,
943 LogicalDatastoreType storeType) throws IllegalStateException {
945 // Each entry will be identifiable by a unique key, we have to create that identifier
946 InstanceIdentifier.InstanceIdentifierBuilder<VnfInstancePreloadList> vnfInstanceListIdBuilder =
947 InstanceIdentifier.<PreloadVnfInstances>builder(PreloadVnfInstances.class)
948 .child(VnfInstancePreloadList.class, entry.getKey());
949 InstanceIdentifier<VnfInstancePreloadList> path = vnfInstanceListIdBuilder.build();
953 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
955 tx.merge(storeType, path, entry);
957 tx.put(storeType, path, entry);
959 tx.submit().checkedGet();
960 log.debug("Update DataStore succeeded");
962 } catch (final TransactionCommitFailedException e) {
963 if (e instanceof OptimisticLockFailedException) {
965 log.debug("Got OptimisticLockFailedException on last try - failing ");
966 throw new IllegalStateException(e);
968 log.debug("Got OptimisticLockFailedException - trying again ");
970 log.debug("Update DataStore failed");
971 throw new IllegalStateException(e);
977 //1610 preload vf-module
978 private void SaveVfModulePreloadList(final VfModulePreloadList entry, boolean merge, LogicalDatastoreType storeType)
979 throws IllegalStateException {
981 // Each entry will be identifiable by a unique key, we have to create that identifier
982 InstanceIdentifier.InstanceIdentifierBuilder<VfModulePreloadList> vfModuleListIdBuilder =
983 InstanceIdentifier.<PreloadVfModules>builder(PreloadVfModules.class)
984 .child(VfModulePreloadList.class, entry.getKey());
985 InstanceIdentifier<VfModulePreloadList> path = vfModuleListIdBuilder.build();
989 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
991 tx.merge(storeType, path, entry);
993 tx.put(storeType, path, entry);
995 tx.submit().checkedGet();
996 log.debug("Update DataStore succeeded");
998 } catch (final TransactionCommitFailedException e) {
999 if (e instanceof OptimisticLockFailedException) {
1001 log.debug("Got OptimisticLockFailedException on last try - failing ");
1002 throw new IllegalStateException(e);
1004 log.debug("Got OptimisticLockFailedException - trying again ");
1006 log.debug("Update DataStore failed");
1007 throw new IllegalStateException(e);
1013 //Save the requestId into MDC
1014 private void setRequestIdAsMDC(String requestId) {
1015 MDC.put("RequestId", requestId);
1018 //1610 vnf-instance-topology-operation
1019 @Override public Future<RpcResult<VnfInstanceTopologyOperationOutput>> vnfInstanceTopologyOperation(
1020 VnfInstanceTopologyOperationInput input) {
1022 final String SVC_OPERATION = "vnf-instance-topology-operation";
1023 VnfInstanceServiceData vnfInstanceServiceData = null;
1024 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1025 Properties parms = new Properties();
1027 log.info(SVC_OPERATION + " called.");
1028 // create a new response object
1029 VnfInstanceTopologyOperationOutputBuilder responseBuilder = new VnfInstanceTopologyOperationOutputBuilder();
1031 //if(input == null || input.getVnfInstanceRequestInformation().getVnfInstanceTopologyIdentifier().getVnfInstanceId() == null )
1032 if (input == null || input.getVnfInstanceRequestInformation() == null
1033 || input.getVnfInstanceRequestInformation().getVnfInstanceId() == null) {
1034 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vnf-instance-id");
1035 responseBuilder.setResponseCode("403");
1036 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1037 responseBuilder.setAckFinalIndicator("Y");
1038 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1039 RpcResultBuilder.<VnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1042 return Futures.immediateFuture(rpcResult);
1045 // Grab the service instance ID from the input buffer
1046 String viid = input.getVnfInstanceRequestInformation().getVnfInstanceId();
1047 String preload_name = input.getVnfInstanceRequestInformation().getVnfInstanceName();
1048 String preload_type = input.getVnfInstanceRequestInformation().getVnfModelId();
1050 // Make sure we have a valid viid
1051 if (viid == null || viid.length() == 0) {
1052 log.debug("exiting " + SVC_OPERATION + " because of invalid vnf-instance-id");
1053 responseBuilder.setResponseCode("403");
1054 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1055 responseBuilder.setAckFinalIndicator("Y");
1056 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1057 RpcResultBuilder.<VnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1060 return Futures.immediateFuture(rpcResult);
1063 if (input.getSdncRequestHeader() != null) {
1064 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1065 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1068 // Get vnf-instance-preload-data
1069 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
1070 getVnfInstancePreloadData(preload_name, preload_type, vnfInstancePreloadDataBuilder);
1073 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1074 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1076 // Get operational-data
1077 VnfInstanceServiceDataBuilder operDataBuilder = new VnfInstanceServiceDataBuilder();
1078 getVnfInstanceServiceData(viid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1080 // Set the serviceStatus based on input
1081 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1082 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1085 // setup a service-data object builder
1086 // ACTION vnf-topology-operation
1088 // USES sdnc-request-header;
1089 // USES request-information;
1090 // USES service-information;
1091 // USES vnf-request-information
1093 // USES vnf-topology-response-body;
1094 // USES vnf-information
1095 // USES service-information
1097 // container service-data
1098 // uses vnf-configuration-information;
1099 // uses oper-status;
1101 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + viid + "] input: " + input);
1102 VnfInstanceTopologyOperationInputBuilder inputBuilder = new VnfInstanceTopologyOperationInputBuilder(input);
1103 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1105 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + viid + "] operational-data: " + operDataBuilder
1107 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1110 "Adding CONFIG data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preload-data: "
1111 + vnfInstancePreloadDataBuilder.build());
1112 VnfSdnUtil.toProperties(parms, "vnf-instance-preload-data", vnfInstancePreloadDataBuilder);
1114 // Call SLI sync method
1115 // Get SvcLogicService reference
1116 Properties respProps = null;
1117 String errorCode = "200";
1118 String errorMessage = null;
1119 String ackFinal = "Y";
1122 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1125 respProps = svcLogicClient
1126 .execute("VNF-API", SVC_OPERATION, null, "sync", vnfInstanceServiceDataBuilder, parms);
1127 } catch (Exception e) {
1128 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1129 errorMessage = e.getMessage();
1133 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1136 } catch (Exception e) {
1138 errorMessage = e.getMessage();
1139 log.error("Caught exception looking for service logic", e);
1142 if (respProps != null) {
1143 errorCode = respProps.getProperty("error-code");
1144 errorMessage = respProps.getProperty("error-message");
1145 ackFinal = respProps.getProperty("ack-final", "Y");
1148 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1149 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1150 serviceStatusBuilder.setRpcName(RpcName.VnfInstanceTopologyOperation);
1152 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1153 responseBuilder.setResponseCode(errorCode);
1154 responseBuilder.setResponseMessage(errorMessage);
1155 responseBuilder.setAckFinalIndicator(ackFinal);
1156 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1157 vnfInstanceListBuilder.setVnfInstanceId(viid);
1158 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1160 SaveVnfInstanceList(vnfInstanceListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1161 } catch (Exception e) {
1162 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + viid + "] \n", e);
1164 log.error("Returned FAILED for " + SVC_OPERATION + " [" + viid + "] " + responseBuilder.build());
1165 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1166 RpcResultBuilder.<VnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1169 return Futures.immediateFuture(rpcResult);
1172 // Got success from SLI
1174 vnfInstanceServiceData = vnfInstanceServiceDataBuilder.build();
1175 log.info("Updating MD-SAL for " + SVC_OPERATION + " [" + viid + "] VnfInstanceServiceData: "
1176 + vnfInstanceServiceData);
1177 // svc-configuration-list
1178 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1179 vnfInstanceListBuilder.setVnfInstanceServiceData(vnfInstanceServiceData);
1180 vnfInstanceListBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
1181 //siid = vnfInstanceServiceData.getVnfInstanceId();
1182 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1183 SaveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1184 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1185 // Only update operational tree on Delete or Activate
1186 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1187 .getSvcAction().equals(SvcAction.Activate)) {
1188 log.info("Updating OPERATIONAL tree.");
1189 SaveVnfInstanceList(vnfInstanceListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1192 VnfInstanceInformationBuilder vnfInstanceInformationBuilder = new VnfInstanceInformationBuilder();
1193 vnfInstanceInformationBuilder.setVnfInstanceId(viid);
1194 responseBuilder.setVnfInstanceInformation(vnfInstanceInformationBuilder.build());
1195 responseBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
1196 } catch (Exception e) {
1197 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + viid + "] \n", e);
1198 responseBuilder.setResponseCode("500");
1199 responseBuilder.setResponseMessage(e.toString());
1200 responseBuilder.setAckFinalIndicator("Y");
1201 log.error("Returned FAILED for " + SVC_OPERATION + " [" + viid + "] " + responseBuilder.build());
1202 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1203 RpcResultBuilder.<VnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1206 return Futures.immediateFuture(rpcResult);
1210 responseBuilder.setResponseCode(errorCode);
1211 responseBuilder.setAckFinalIndicator(ackFinal);
1212 if (errorMessage != null) {
1213 responseBuilder.setResponseMessage(errorMessage);
1215 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + viid + "] ");
1216 log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + viid + "] " + responseBuilder.build());
1218 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1219 RpcResultBuilder.<VnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1222 return Futures.immediateFuture(rpcResult);
1225 //1610 vf-module-topology-operation
1226 @Override public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1227 VfModuleTopologyOperationInput input) {
1229 final String SVC_OPERATION = "vf-module-topology-operation";
1230 VfModuleServiceData vfModuleServiceData = null;
1231 VnfInstanceServiceData vnfInstanceServiceData = null;
1232 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1233 Properties parms = new Properties();
1235 log.info(SVC_OPERATION + " called.");
1236 // create a new response object
1237 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1239 // Validate vf-module-id from vf-module-request-information
1240 if (input == null || input.getVfModuleRequestInformation() == null
1241 || input.getVfModuleRequestInformation().getVfModuleId() == null) {
1242 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vf-module-id");
1243 responseBuilder.setResponseCode("403");
1244 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1245 responseBuilder.setAckFinalIndicator("Y");
1246 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1247 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1250 return Futures.immediateFuture(rpcResult);
1253 // Grab the vf-module-request-information.vf-module-id from the input buffer
1254 String vfid = input.getVfModuleRequestInformation().getVfModuleId();
1255 String preload_name = input.getVfModuleRequestInformation().getVfModuleName();
1256 String preload_type = input.getVfModuleRequestInformation().getVfModuleModelId();
1258 // Make sure we have a valid siid
1259 if (vfid == null || vfid.length() == 0) {
1260 log.debug("exiting " + SVC_OPERATION + " because of invalid vf-module-id");
1261 responseBuilder.setResponseCode("403");
1262 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1263 responseBuilder.setAckFinalIndicator("Y");
1264 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1265 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1268 return Futures.immediateFuture(rpcResult);
1271 // 1610 add vf-module-id to vnf-instance-list.vf-module-relationship-list
1272 String viid = input.getVfModuleRequestInformation().getVnfInstanceId();
1274 if (viid == null || viid.length() == 0) {
1275 log.debug("exiting " + SVC_OPERATION + " because of invalid vnf-instance-id");
1276 responseBuilder.setResponseCode("403");
1277 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1278 responseBuilder.setAckFinalIndicator("Y");
1279 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1280 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1283 return Futures.immediateFuture(rpcResult);
1286 if (input.getSdncRequestHeader() != null) {
1287 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1288 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1291 // Get vf-module-preload-data
1292 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
1293 getVfModulePreloadData(preload_name, preload_type, vfModulePreloadDataBuilder);
1295 // Get vf-module-service-data
1296 VfModuleServiceDataBuilder vfModuleServiceDataBuilder = new VfModuleServiceDataBuilder();
1297 getVfModuleServiceData(vfid, vfModuleServiceDataBuilder);
1299 // Get vf-module operation-data
1300 VfModuleServiceDataBuilder operDataBuilder = new VfModuleServiceDataBuilder();
1301 getVfModuleServiceData(vfid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1303 // save service-data builder object for rollback
1304 VfModuleServiceDataBuilder rb_vfModuleServiceDataBuilder = vfModuleServiceDataBuilder;
1305 VfModuleServiceDataBuilder rb_operDataBuilder = operDataBuilder;
1307 // 1610 Need to pull vnf-instance-list.vf-module-relationship-list from MD-SAL
1308 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1309 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1311 // vnf-instance operational-data
1312 VnfInstanceServiceDataBuilder vnfInstanceOperDataBuilder = new VnfInstanceServiceDataBuilder();
1313 getVnfInstanceServiceData(viid, vnfInstanceOperDataBuilder, LogicalDatastoreType.OPERATIONAL);
1315 // save operational builder object for rollback
1316 VnfInstanceServiceDataBuilder rb_vnfInstanceServiceDataBuilder = vnfInstanceServiceDataBuilder;
1317 VnfInstanceServiceDataBuilder rb_vnfInstanceOperDataBuilder = vnfInstanceOperDataBuilder;
1319 // Set the serviceStatus based on input
1320 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1321 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1324 // setup a service-data object builder
1325 // ACTION vnf-topology-operation
1327 // USES sdnc-request-header;
1328 // USES request-information;
1329 // USES service-information;
1330 // USES vnf-request-information
1332 // USES vnf-topology-response-body;
1333 // USES vnf-information
1334 // USES service-information
1336 // container service-data
1337 // uses vnf-configuration-information;
1338 // uses oper-status;
1340 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + vfid + "] input: " + input);
1341 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1342 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1344 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + vfid + "] vf-module operational-data: "
1345 + operDataBuilder.build());
1346 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1348 log.info("Adding CONFIG data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1349 + "] vf-module-preload-data: " + vfModulePreloadDataBuilder.build());
1350 VnfSdnUtil.toProperties(parms, "vf-module-preload-data", vfModulePreloadDataBuilder);
1352 log.info("Adding vnf-instance CONFIG data for " + SVC_OPERATION + " [" + viid + "] vnf-instance-service-data: "
1353 + vnfInstanceServiceDataBuilder.build());
1354 VnfSdnUtil.toProperties(parms, "vnf-instance-service-data", vnfInstanceServiceDataBuilder);
1356 log.info("Adding vnf-instance OPERATIONAL data for " + SVC_OPERATION + " [" + viid
1357 + "] vnf-instance operational-data: " + vnfInstanceOperDataBuilder.build());
1358 VnfSdnUtil.toProperties(parms, "vnf-instance-operational-data", vnfInstanceOperDataBuilder);
1360 // Call SLI sync method
1361 // Get SvcLogicService reference
1363 Properties respProps = null;
1364 String errorCode = "200";
1365 String errorMessage = null;
1366 String ackFinal = "Y";
1369 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1372 respProps = svcLogicClient
1373 .execute("VNF-API", SVC_OPERATION, null, "sync", vfModuleServiceDataBuilder, parms);
1374 } catch (Exception e) {
1375 log.error("Caught exception executing service logic on vf-module for " + SVC_OPERATION, e);
1376 errorMessage = e.getMessage();
1381 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1384 } catch (Exception e) {
1386 errorMessage = e.getMessage();
1387 log.error("Caught exception looking for service logic", e);
1391 if (respProps != null) {
1392 errorCode = respProps.getProperty("error-code");
1393 errorMessage = respProps.getProperty("error-message");
1394 ackFinal = respProps.getProperty("ack-final", "Y");
1397 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1398 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1399 serviceStatusBuilder.setRpcName(RpcName.VfModuleTopologyOperation);
1401 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1402 responseBuilder.setResponseCode(errorCode);
1403 responseBuilder.setResponseMessage(errorMessage);
1404 responseBuilder.setAckFinalIndicator(ackFinal);
1405 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1406 vfModuleListBuilder.setVfModuleId(vfid);
1407 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1409 SaveVfModuleList(vfModuleListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1410 } catch (Exception e) {
1411 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + vfid + "] \n", e);
1413 log.error("Returned FAILED for " + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1414 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1415 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1418 return Futures.immediateFuture(rpcResult);
1421 // Got success from SLI
1422 // save vf-module-service-data in MD-SAL
1424 vfModuleServiceData = vfModuleServiceDataBuilder.build();
1426 "Updating MD-SAL for " + SVC_OPERATION + " [" + vfid + "] VfModuleServiceData: " + vfModuleServiceData);
1428 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1429 vfModuleListBuilder.setVfModuleServiceData(vfModuleServiceData);
1430 vfModuleListBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
1431 //vfid = vfModuleServiceData.getVfModuleId();
1432 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1433 SaveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1434 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1435 // Only update operational tree on Delete or Activate
1436 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1437 .getSvcAction().equals(SvcAction.Activate)) {
1438 log.info("Updating OPERATIONAL tree.");
1439 SaveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1442 VfModuleInformationBuilder vfModuleInformationBuilder = new VfModuleInformationBuilder();
1443 vfModuleInformationBuilder.setVfModuleId(vfid);
1444 responseBuilder.setVfModuleInformation(vfModuleInformationBuilder.build());
1445 responseBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
1446 } catch (Exception e) {
1447 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + vfid + "] \n", e);
1448 responseBuilder.setResponseCode("500");
1449 responseBuilder.setResponseMessage(e.toString());
1450 responseBuilder.setAckFinalIndicator("Y");
1451 log.error("Returned FAILED for " + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1452 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1453 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1456 return Futures.immediateFuture(rpcResult);
1460 responseBuilder.setResponseCode(errorCode);
1461 responseBuilder.setAckFinalIndicator(ackFinal);
1462 if (errorMessage != null) {
1463 responseBuilder.setResponseMessage(errorMessage);
1465 log.info("Updated vf-module in MD-SAL for " + SVC_OPERATION + " [" + vfid + "] ");
1466 log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1468 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1469 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1471 return Futures.immediateFuture(rpcResult);
1476 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
1477 final String SVC_OPERATION = "vnf-topology-operation";
1478 ServiceData serviceData = null;
1479 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1480 Properties parms = new Properties();
1482 log.info(SVC_OPERATION + " called.");
1483 // create a new response object
1484 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1486 if (input == null || input.getServiceInformation() == null
1487 || input.getServiceInformation().getServiceInstanceId() == null
1488 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1489 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1490 responseBuilder.setResponseCode("403");
1491 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1492 responseBuilder.setAckFinalIndicator("Y");
1493 RpcResult<VnfTopologyOperationOutput> rpcResult =
1494 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1496 return Futures.immediateFuture(rpcResult);
1499 if (input.getVnfRequestInformation() == null || input.getVnfRequestInformation().getVnfId() == null
1500 || input.getVnfRequestInformation().getVnfId().length() == 0) {
1501 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vf-module-id");
1502 responseBuilder.setResponseCode("403");
1503 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1504 responseBuilder.setAckFinalIndicator("Y");
1505 RpcResult<VnfTopologyOperationOutput> rpcResult =
1506 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1508 return Futures.immediateFuture(rpcResult);
1511 // Grab the service instance ID from the input buffer
1512 String siid = input.getVnfRequestInformation().getVnfId();
1513 String preload_name = input.getVnfRequestInformation().getVnfName();
1514 String preload_type = input.getVnfRequestInformation().getVnfType();
1516 if (input.getSdncRequestHeader() != null) {
1517 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1518 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1521 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1522 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1524 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1525 getServiceData(siid, serviceDataBuilder);
1527 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1528 getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1530 // Set the serviceStatus based on input
1531 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1532 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1535 // setup a service-data object builder
1536 // ACTION vnf-topology-operation
1538 // USES sdnc-request-header;
1539 // USES request-information;
1540 // USES service-information;
1541 // USES vnf-request-information
1543 // USES vnf-topology-response-body;
1544 // USES vnf-information
1545 // USES service-information
1547 // container service-data
1548 // uses vnf-configuration-information;
1549 // uses oper-status;
1551 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + siid + "] input: " + input);
1552 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1553 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1555 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + siid + "] operational-data: " + operDataBuilder
1557 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1560 "Adding CONFIG data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preload-data: "
1561 + preloadDataBuilder.build());
1562 VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1564 // Call SLI sync method
1565 // Get SvcLogicService reference
1566 Properties respProps = null;
1567 String errorCode = "200";
1568 String errorMessage = null;
1569 String ackFinal = "Y";
1572 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1576 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1577 } catch (Exception e) {
1578 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1579 errorMessage = e.getMessage();
1583 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1586 } catch (Exception e) {
1588 errorMessage = e.getMessage();
1589 log.error("Caught exception looking for service logic", e);
1592 if (respProps != null) {
1593 errorCode = respProps.getProperty("error-code");
1594 errorMessage = respProps.getProperty("error-message");
1595 ackFinal = respProps.getProperty("ack-final", "Y");
1598 setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1599 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1600 serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
1602 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1603 responseBuilder.setResponseCode(errorCode);
1604 responseBuilder.setResponseMessage(errorMessage);
1605 responseBuilder.setAckFinalIndicator(ackFinal);
1606 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1607 vnfListBuilder.setVnfId(siid);
1608 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1610 SaveVnfList(vnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1611 } catch (Exception e) {
1612 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1614 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1615 RpcResult<VnfTopologyOperationOutput> rpcResult =
1616 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1618 return Futures.immediateFuture(rpcResult);
1621 // Got success from SLI
1623 serviceData = serviceDataBuilder.build();
1624 log.info("Updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] ServiceData: " + serviceData);
1625 // svc-configuration-list
1626 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1627 vnfListBuilder.setServiceData(serviceData);
1628 vnfListBuilder.setVnfId(serviceData.getVnfId());
1629 siid = serviceData.getVnfId();
1630 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1631 SaveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1632 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1633 // Only update operational tree on Delete or Activate
1634 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1635 log.info("Updating OPERATIONAL tree.");
1636 SaveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1637 } else if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input
1638 .getSdncRequestHeader().getSvcAction().equals(SvcAction.Rollback)) {
1639 log.info("Delete OPERATIONAL tree.");
1640 DeleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
1641 DeleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
1644 VnfInformationBuilder vnfInformationBuilder = new VnfInformationBuilder();
1645 vnfInformationBuilder.setVnfId(siid);
1646 responseBuilder.setVnfInformation(vnfInformationBuilder.build());
1647 responseBuilder.setServiceInformation(serviceData.getServiceInformation());
1648 } catch (Exception e) {
1649 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1650 responseBuilder.setResponseCode("500");
1651 responseBuilder.setResponseMessage(e.toString());
1652 responseBuilder.setAckFinalIndicator("Y");
1653 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1654 RpcResult<VnfTopologyOperationOutput> rpcResult =
1655 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1657 return Futures.immediateFuture(rpcResult);
1661 responseBuilder.setResponseCode(errorCode);
1662 responseBuilder.setAckFinalIndicator(ackFinal);
1663 if (errorMessage != null) {
1664 responseBuilder.setResponseMessage(errorMessage);
1666 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + siid + "] ");
1667 log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1669 RpcResult<VnfTopologyOperationOutput> rpcResult =
1670 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1672 return Futures.immediateFuture(rpcResult);
1675 @Override public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1676 NetworkTopologyOperationInput input) {
1678 final String SVC_OPERATION = "network-topology-operation";
1679 ServiceData serviceData = null;
1680 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1681 Properties parms = new Properties();
1683 log.info(SVC_OPERATION + " called.");
1684 // create a new response object
1685 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1687 if (input == null || input.getServiceInformation() == null
1688 || input.getServiceInformation().getServiceInstanceId() == null
1689 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1690 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1691 responseBuilder.setResponseCode("403");
1692 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1693 responseBuilder.setAckFinalIndicator("Y");
1694 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1695 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1698 return Futures.immediateFuture(rpcResult);
1701 if (input.getNetworkRequestInformation() == null
1702 || input.getNetworkRequestInformation().getNetworkName() == null) {
1703 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1704 responseBuilder.setResponseCode("403");
1705 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1706 responseBuilder.setAckFinalIndicator("Y");
1707 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1708 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1711 return Futures.immediateFuture(rpcResult);
1714 // Grab the service instance ID from the input buffer
1716 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Assign)) {
1717 siid = input.getNetworkRequestInformation().getNetworkName();
1719 siid = input.getNetworkRequestInformation().getNetworkId();
1721 String preload_name = input.getNetworkRequestInformation().getNetworkName();
1722 String preload_type = input.getNetworkRequestInformation().getNetworkType();
1724 if (input.getSdncRequestHeader() != null) {
1725 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1726 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1729 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1730 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1732 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + siid + "] input: " + input);
1733 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1734 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1736 // Call SLI sync method
1737 // Get SvcLogicService reference
1738 Properties respProps = null;
1739 String errorCode = "200";
1740 String errorMessage = null;
1741 String ackFinal = "Y";
1742 String networkId = "error";
1745 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1749 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1750 } catch (Exception e) {
1751 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1752 errorMessage = e.getMessage();
1756 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1759 } catch (Exception e) {
1761 errorMessage = e.getMessage();
1762 log.error("Caught exception looking for service logic", e);
1765 if (respProps != null) {
1766 errorCode = respProps.getProperty("error-code");
1767 errorMessage = respProps.getProperty("error-message");
1768 ackFinal = respProps.getProperty("ack-final", "Y");
1769 networkId = respProps.getProperty("networkId", "0");
1772 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1773 responseBuilder.setResponseCode(errorCode);
1774 responseBuilder.setResponseMessage(errorMessage);
1775 responseBuilder.setAckFinalIndicator(ackFinal);
1777 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1779 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1780 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1783 return Futures.immediateFuture(rpcResult);
1786 // Got success from SLI
1788 NetworkInformationBuilder networkInformationBuilder = new NetworkInformationBuilder();
1789 networkInformationBuilder.setNetworkId(networkId);
1790 responseBuilder.setNetworkInformation(networkInformationBuilder.build());
1791 responseBuilder.setServiceInformation(input.getServiceInformation());
1792 } catch (IllegalStateException e) {
1793 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1794 responseBuilder.setResponseCode("500");
1795 responseBuilder.setResponseMessage(e.toString());
1796 responseBuilder.setAckFinalIndicator("Y");
1797 log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1798 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1799 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1802 return Futures.immediateFuture(rpcResult);
1806 responseBuilder.setResponseCode(errorCode);
1807 responseBuilder.setAckFinalIndicator(ackFinal);
1808 if (errorMessage != null) {
1809 responseBuilder.setResponseMessage(errorMessage);
1811 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + siid + "] ");
1812 log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1814 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1815 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1817 return Futures.immediateFuture(rpcResult);
1820 @Override public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1821 PreloadVnfTopologyOperationInput input) {
1823 final String SVC_OPERATION = "preload-vnf-topology-operation";
1824 PreloadData preloadData = null;
1825 Properties parms = new Properties();
1827 log.info(SVC_OPERATION + " called.");
1828 // create a new response object
1829 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1831 // Result from savePreloadData
1832 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1834 if (input == null || input.getVnfTopologyInformation() == null
1835 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null
1836 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName() == null
1837 || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType() == null) {
1838 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vnf-name or vnf-type");
1839 responseBuilder.setResponseCode("403");
1840 responseBuilder.setResponseMessage("invalid input, null or empty vnf-name or vnf-type");
1841 responseBuilder.setAckFinalIndicator("Y");
1842 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1843 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1845 return Futures.immediateFuture(rpcResult);
1848 // Grab the name and type from the input buffer
1849 String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1850 String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1852 // Make sure we have a preload_name and preload_type
1853 if (preload_name == null || preload_name.length() == 0) {
1854 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
1855 responseBuilder.setResponseCode("403");
1856 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1857 responseBuilder.setAckFinalIndicator("Y");
1858 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1859 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1861 return Futures.immediateFuture(rpcResult);
1863 if (preload_type == null || preload_type.length() == 0) {
1864 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
1865 responseBuilder.setResponseCode("403");
1866 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1867 responseBuilder.setAckFinalIndicator("Y");
1868 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1869 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1871 return Futures.immediateFuture(rpcResult);
1874 if (input.getSdncRequestHeader() != null) {
1875 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1876 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1879 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1880 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1881 //preloadData = preloadDataBuilder.build();
1883 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1884 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1887 // setup a preload-data object builder
1888 // ACTION vnf-topology-operation
1890 // USES sdnc-request-header;
1891 // USES request-information;
1892 // uses vnf-topology-information;
1894 // USES vnf-topology-response-body;
1896 // container preload-data
1897 // uses vnf-configuration-information;
1899 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
1900 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1901 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1902 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1903 + "] operational-data: " + operDataBuilder.build());
1904 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1906 // Call SLI sync method
1907 // Get SvcLogicService reference
1908 Properties respProps = null;
1909 String errorCode = "200";
1910 String errorMessage = null;
1911 String ackFinal = "Y";
1914 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1918 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1919 } catch (Exception e) {
1920 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1921 errorMessage = e.getMessage();
1925 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1928 } catch (Exception e) {
1930 errorMessage = e.getMessage();
1931 log.error("Caught exception looking for service logic", e);
1934 if (respProps != null) {
1935 errorCode = respProps.getProperty("error-code");
1936 errorMessage = respProps.getProperty("error-message");
1937 ackFinal = respProps.getProperty("ack-final", "Y");
1938 // internalError = respProps.getProperty("internal-error", "false");
1941 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1943 responseBuilder.setResponseCode(errorCode);
1944 responseBuilder.setResponseMessage(errorMessage);
1945 responseBuilder.setAckFinalIndicator(ackFinal);
1947 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1948 preloadVnfListBuilder.setVnfName(preload_name);
1949 preloadVnfListBuilder.setVnfType(preload_type);
1950 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1952 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
1953 + errorCode + "', Reason: '" + errorMessage + "'");
1955 SavePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1956 } catch (Exception e) {
1958 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1961 log.debug("Sending Success rpc result due to external error");
1962 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1963 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1965 return Futures.immediateFuture(rpcResult);
1968 // Got success from SLI
1970 preloadData = preloadDataBuilder.build();
1972 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
1974 // svc-configuration-list
1975 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1976 preloadVnfListBuilder.setVnfName(preload_name);
1977 preloadVnfListBuilder.setVnfType(preload_type);
1978 preloadVnfListBuilder.setPreloadData(preloadData);
1980 // SDNGC-989 set merge flag to false
1981 SavePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1982 log.info("Updating OPERATIONAL tree.");
1983 SavePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1984 } catch (Exception e) {
1985 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1987 responseBuilder.setResponseCode("500");
1988 responseBuilder.setResponseMessage(e.toString());
1989 responseBuilder.setAckFinalIndicator("Y");
1990 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
1991 + responseBuilder.build());
1992 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1993 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(false).withResult(responseBuilder.build())
1995 return Futures.immediateFuture(rpcResult);
1999 responseBuilder.setResponseCode(errorCode);
2000 responseBuilder.setAckFinalIndicator(ackFinal);
2001 if (errorMessage != null) {
2002 responseBuilder.setResponseMessage(errorMessage);
2004 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2006 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2009 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2010 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2012 return Futures.immediateFuture(rpcResult);
2015 //1610 preload-vnf-instance-topology-operation
2016 @Override public Future<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> preloadVnfInstanceTopologyOperation(
2017 PreloadVnfInstanceTopologyOperationInput input) {
2019 final String SVC_OPERATION = "preload-vnf-instance-topology-operation";
2020 VnfInstancePreloadData vnfInstancePreloadData = null;
2021 Properties parms = new Properties();
2023 log.info(SVC_OPERATION + " called.");
2024 // create a new response object
2025 PreloadVnfInstanceTopologyOperationOutputBuilder responseBuilder =
2026 new PreloadVnfInstanceTopologyOperationOutputBuilder();
2028 // Result from savePreloadData
2029 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2031 if (input == null || input.getVnfInstanceTopologyInformation() == null
2032 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName() == null
2033 || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId() == null) {
2034 log.debug("exiting " + SVC_OPERATION
2035 + " because of invalid input, null or empty vnf-instance-name or vnf-model-id");
2036 responseBuilder.setResponseCode("403");
2037 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name or vnf-model-id");
2038 responseBuilder.setAckFinalIndicator("Y");
2039 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2040 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2041 .withResult(responseBuilder.build()).build();
2042 return Futures.immediateFuture(rpcResult);
2045 // Grab the name and type from the input buffer
2046 String preload_name =
2047 input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName();
2048 String preload_type = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId();
2050 // Make sure we have a preload_name and preload_type
2051 if (preload_name == null || preload_name.length() == 0) {
2052 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
2053 responseBuilder.setResponseCode("403");
2054 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2055 responseBuilder.setAckFinalIndicator("Y");
2056 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2057 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2058 .withResult(responseBuilder.build()).build();
2059 return Futures.immediateFuture(rpcResult);
2061 if (preload_type == null || preload_type.length() == 0) {
2062 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
2063 responseBuilder.setResponseCode("403");
2064 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2065 responseBuilder.setAckFinalIndicator("Y");
2066 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2067 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2068 .withResult(responseBuilder.build()).build();
2069 return Futures.immediateFuture(rpcResult);
2072 if (input.getSdncRequestHeader() != null) {
2073 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2074 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2077 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
2078 getVnfInstancePreloadData(preload_name, preload_type, vnfInstancePreloadDataBuilder);
2079 //preloadData = preloadDataBuilder.build();
2081 VnfInstancePreloadDataBuilder operDataBuilder = new VnfInstancePreloadDataBuilder();
2082 getVnfInstancePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2085 // setup a preload-data object builder
2086 // ACTION vnf-topology-operation
2088 // USES sdnc-request-header;
2089 // USES request-information;
2090 // uses vnf-topology-information;
2092 // USES vnf-topology-response-body;
2094 // container preload-data
2095 // uses vnf-configuration-information;
2097 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2098 PreloadVnfInstanceTopologyOperationInputBuilder inputBuilder =
2099 new PreloadVnfInstanceTopologyOperationInputBuilder(input);
2100 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2101 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2102 + "] operational-data: " + operDataBuilder.build());
2103 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2105 // Call SLI sync method
2106 // Get SvcLogicService reference
2107 Properties respProps = null;
2108 String errorCode = "200";
2109 String errorMessage = null;
2110 String ackFinal = "Y";
2113 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2116 respProps = svcLogicClient
2117 .execute("VNF-API", SVC_OPERATION, null, "sync", vnfInstancePreloadDataBuilder, parms);
2118 } catch (Exception e) {
2119 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2120 errorMessage = e.getMessage();
2124 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2127 } catch (Exception e) {
2129 errorMessage = e.getMessage();
2130 log.error("Caught exception looking for service logic", e);
2133 if (respProps != null) {
2134 errorCode = respProps.getProperty("error-code");
2135 errorMessage = respProps.getProperty("error-message");
2136 ackFinal = respProps.getProperty("ack-final", "Y");
2137 // internalError = respProps.getProperty("internal-error", "false");
2140 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2142 responseBuilder.setResponseCode(errorCode);
2143 responseBuilder.setResponseMessage(errorMessage);
2144 responseBuilder.setAckFinalIndicator(ackFinal);
2146 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2147 vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2148 vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2149 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadDataBuilder.build());
2151 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2152 + errorCode + "', Reason: '" + errorMessage + "'");
2154 SaveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), true,
2155 LogicalDatastoreType.CONFIGURATION);
2156 } catch (Exception e) {
2158 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2161 log.debug("Sending Success rpc result due to external error");
2162 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2163 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2164 .withResult(responseBuilder.build()).build();
2165 return Futures.immediateFuture(rpcResult);
2168 // Got success from SLI
2170 vnfInstancePreloadData = vnfInstancePreloadDataBuilder.build();
2172 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2173 + vnfInstancePreloadData);
2174 // svc-configuration-list
2175 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2176 vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2177 vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2178 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadData);
2180 // SDNGC-989 set merge flag to false
2181 SaveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false,
2182 LogicalDatastoreType.CONFIGURATION);
2183 log.info("Updating OPERATIONAL tree.");
2184 SaveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2185 } catch (Exception e) {
2186 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2188 responseBuilder.setResponseCode("500");
2189 responseBuilder.setResponseMessage(e.toString());
2190 responseBuilder.setAckFinalIndicator("Y");
2191 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2192 + responseBuilder.build());
2193 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2194 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(false)
2195 .withResult(responseBuilder.build()).build();
2196 return Futures.immediateFuture(rpcResult);
2200 responseBuilder.setResponseCode(errorCode);
2201 responseBuilder.setAckFinalIndicator(ackFinal);
2202 if (errorMessage != null) {
2203 responseBuilder.setResponseMessage(errorMessage);
2205 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2207 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2210 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2211 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2213 return Futures.immediateFuture(rpcResult);
2217 //1610 preload-vf-module-topology-operation
2218 @Override public Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2219 PreloadVfModuleTopologyOperationInput input) {
2221 final String SVC_OPERATION = "preload-vf-module-topology-operation";
2222 VfModulePreloadData vfModulePreloadData = null;
2223 Properties parms = new Properties();
2225 log.info(SVC_OPERATION + " called.");
2226 // create a new response object
2227 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder =
2228 new PreloadVfModuleTopologyOperationOutputBuilder();
2230 // Result from savePreloadData
2231 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2233 if (input == null || input.getVfModuleTopologyInformation() == null
2234 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName() == null
2235 || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId() == null) {
2236 log.debug("exiting " + SVC_OPERATION
2237 + " because of invalid input, null or empty vf-module-name or vf-module-model-id");
2238 responseBuilder.setResponseCode("403");
2239 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-name or vf-module-model-id");
2240 responseBuilder.setAckFinalIndicator("Y");
2241 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2242 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2243 .withResult(responseBuilder.build()).build();
2244 return Futures.immediateFuture(rpcResult);
2247 // Grab the name and type from the input buffer
2248 String preload_name = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName();
2249 String preload_type = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId();
2251 // Make sure we have a preload_name and preload_type
2252 if (preload_name == null || preload_name.length() == 0) {
2253 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
2254 responseBuilder.setResponseCode("403");
2255 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2256 responseBuilder.setAckFinalIndicator("Y");
2257 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2258 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2259 .withResult(responseBuilder.build()).build();
2260 return Futures.immediateFuture(rpcResult);
2262 if (preload_type == null || preload_type.length() == 0) {
2263 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
2264 responseBuilder.setResponseCode("403");
2265 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2266 responseBuilder.setAckFinalIndicator("Y");
2267 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2268 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2269 .withResult(responseBuilder.build()).build();
2270 return Futures.immediateFuture(rpcResult);
2273 if (input.getSdncRequestHeader() != null) {
2274 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2275 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2278 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
2279 getVfModulePreloadData(preload_name, preload_type, vfModulePreloadDataBuilder);
2280 //preloadData = preloadDataBuilder.build();
2282 VfModulePreloadDataBuilder operDataBuilder = new VfModulePreloadDataBuilder();
2283 getVfModulePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2286 // setup a preload-data object builder
2287 // ACTION vnf-topology-operation
2289 // USES sdnc-request-header;
2290 // USES request-information;
2291 // uses vnf-topology-information;
2293 // USES vnf-topology-response-body;
2295 // container preload-data
2296 // uses vnf-configuration-information;
2299 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2300 PreloadVfModuleTopologyOperationInputBuilder inputBuilder =
2301 new PreloadVfModuleTopologyOperationInputBuilder(input);
2302 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2303 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2304 + "] operational-data: " + operDataBuilder.build());
2305 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2307 // Call SLI sync method
2308 // Get SvcLogicService reference
2309 Properties respProps = null;
2310 String errorCode = "200";
2311 String errorMessage = null;
2312 String ackFinal = "Y";
2315 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2317 respProps = svcLogicClient
2318 .execute("VNF-API", SVC_OPERATION, null, "sync", vfModulePreloadDataBuilder, parms);
2319 } catch (Exception e) {
2320 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2321 errorMessage = e.getMessage();
2325 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2328 } catch (Exception e) {
2330 errorMessage = e.getMessage();
2331 log.error("Caught exception looking for service logic", e);
2334 if (respProps != null) {
2335 errorCode = respProps.getProperty("error-code");
2336 errorMessage = respProps.getProperty("error-message");
2337 ackFinal = respProps.getProperty("ack-final", "Y");
2338 // internalError = respProps.getProperty("internal-error", "false");
2341 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2343 responseBuilder.setResponseCode(errorCode);
2344 responseBuilder.setResponseMessage(errorMessage);
2345 responseBuilder.setAckFinalIndicator(ackFinal);
2347 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2348 vfModulePreloadListBuilder.setVfModuleName(preload_name);
2349 vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2350 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadDataBuilder.build());
2352 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2353 + errorCode + "', Reason: '" + errorMessage + "'");
2355 SaveVfModulePreloadList(vfModulePreloadListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2356 } catch (Exception e) {
2358 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2361 log.debug("Sending Success rpc result due to external error");
2362 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2363 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2364 .withResult(responseBuilder.build()).build();
2365 return Futures.immediateFuture(rpcResult);
2368 // Got success from SLI
2370 vfModulePreloadData = vfModulePreloadDataBuilder.build();
2372 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2373 + vfModulePreloadData);
2374 // svc-configuration-list
2375 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2376 vfModulePreloadListBuilder.setVfModuleName(preload_name);
2377 vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2378 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadData);
2380 // SDNGC-989 set merge flag to false
2381 SaveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2382 log.info("Updating OPERATIONAL tree.");
2383 SaveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2384 } catch (Exception e) {
2385 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2387 responseBuilder.setResponseCode("500");
2388 responseBuilder.setResponseMessage(e.toString());
2389 responseBuilder.setAckFinalIndicator("Y");
2390 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2391 + responseBuilder.build());
2392 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2393 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(false)
2394 .withResult(responseBuilder.build()).build();
2395 return Futures.immediateFuture(rpcResult);
2399 responseBuilder.setResponseCode(errorCode);
2400 responseBuilder.setAckFinalIndicator(ackFinal);
2401 if (errorMessage != null) {
2402 responseBuilder.setResponseMessage(errorMessage);
2404 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2406 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2409 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2410 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2412 return Futures.immediateFuture(rpcResult);
2416 @Override public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2417 PreloadNetworkTopologyOperationInput input) {
2419 final String SVC_OPERATION = "preload-network-topology-operation";
2420 PreloadData preloadData = null;
2421 Properties parms = new Properties();
2423 log.info(SVC_OPERATION + " called.");
2424 // create a new response object
2425 PreloadNetworkTopologyOperationOutputBuilder responseBuilder =
2426 new PreloadNetworkTopologyOperationOutputBuilder();
2428 // Result from savePreloadData
2429 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2431 if (input == null || input.getNetworkTopologyInformation() == null
2432 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null
2433 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName() == null
2434 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType() == null) {
2435 log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or" +
2436 " empty network-name or network-type");
2437 responseBuilder.setResponseCode("403");
2438 responseBuilder.setResponseMessage("input, null or empty network-name or network-type");
2439 responseBuilder.setAckFinalIndicator("Y");
2440 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2441 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2443 return Futures.immediateFuture(rpcResult);
2446 // Grab the name and type from the input buffer
2447 String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2448 String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2450 // Make sure we have a preload_name and preload_type
2451 if (preload_name == null || preload_name.length() == 0) {
2452 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
2453 responseBuilder.setResponseCode("403");
2454 responseBuilder.setResponseMessage("input, invalid preload-name");
2455 responseBuilder.setAckFinalIndicator("Y");
2456 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2457 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2459 return Futures.immediateFuture(rpcResult);
2462 if (preload_type == null || preload_type.length() == 0) {
2463 log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
2464 responseBuilder.setResponseCode("403");
2465 responseBuilder.setResponseMessage("input, invalid preload-type");
2466 responseBuilder.setAckFinalIndicator("Y");
2467 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2468 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2470 return Futures.immediateFuture(rpcResult);
2473 if (input.getSdncRequestHeader() != null) {
2474 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2475 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2478 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2479 getPreloadData(preload_name, preload_type, preloadDataBuilder);
2481 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2482 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2485 // setup a preload-data object builder
2486 // ACTION vnf-topology-operation
2488 // USES sdnc-request-header;
2489 // USES request-information;
2490 // uses vnf-topology-information;
2492 // USES vnf-topology-response-body;
2494 // container preload-data
2495 // uses vnf-configuration-information;
2497 "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2498 PreloadNetworkTopologyOperationInputBuilder inputBuilder =
2499 new PreloadNetworkTopologyOperationInputBuilder(input);
2500 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2501 log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2502 + "] operational-data: " + operDataBuilder.build());
2503 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2505 // Call SLI sync method
2506 // Get SvcLogicService reference
2507 Properties respProps = null;
2508 String errorCode = "200";
2509 String errorMessage = null;
2510 String ackFinal = "Y";
2513 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2516 svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2517 } catch (Exception e) {
2518 log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2519 errorMessage = e.getMessage();
2523 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2526 } catch (Exception e) {
2528 errorMessage = e.getMessage();
2529 log.error("Caught exception looking for service logic", e);
2533 if (respProps != null) {
2534 errorCode = respProps.getProperty("error-code");
2535 errorMessage = respProps.getProperty("error-message");
2536 ackFinal = respProps.getProperty("ack-final", "Y");
2537 // internalError = respProps.getProperty("internal-error", "false");
2540 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2541 responseBuilder.setResponseCode(errorCode);
2542 responseBuilder.setResponseMessage(errorMessage);
2543 responseBuilder.setAckFinalIndicator(ackFinal);
2545 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2546 preloadVnfListBuilder.setVnfName(preload_name);
2547 preloadVnfListBuilder.setVnfType(preload_type);
2548 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2550 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2551 + errorCode + "', Reason: '" + errorMessage + "'");
2553 SavePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2554 } catch (Exception e) {
2556 "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2560 log.debug("Sending Success rpc result due to external error");
2561 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2562 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2564 return Futures.immediateFuture(rpcResult);
2567 // Got success from SLI
2569 preloadData = preloadDataBuilder.build();
2571 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2573 // svc-configuration-list
2574 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2575 preloadVnfListBuilder.setVnfName(preload_name);
2576 preloadVnfListBuilder.setVnfType(preload_type);
2577 preloadVnfListBuilder.setPreloadData(preloadData);
2579 // SDNGC-989 set merge flag to false
2580 SavePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2581 log.info("Updating OPERATIONAL tree.");
2582 SavePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2583 } catch (Exception e) {
2584 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2586 responseBuilder.setResponseCode("500");
2587 responseBuilder.setResponseMessage(e.toString());
2588 responseBuilder.setAckFinalIndicator("Y");
2589 log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2590 + responseBuilder.build());
2591 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2592 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(false)
2593 .withResult(responseBuilder.build()).build();
2594 return Futures.immediateFuture(rpcResult);
2598 responseBuilder.setResponseCode(errorCode);
2599 responseBuilder.setAckFinalIndicator(ackFinal);
2600 if (errorMessage != null) {
2601 responseBuilder.setResponseMessage(errorMessage);
2603 log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2605 "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2608 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2609 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2611 return Futures.immediateFuture(rpcResult);