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 java.text.DateFormat;
25 import java.text.SimpleDateFormat;
26 import java.util.ArrayList;
27 import java.util.Date;
28 import java.util.Properties;
29 import java.util.TimeZone;
30 import java.util.concurrent.ExecutionException;
31 import java.util.concurrent.ExecutorService;
32 import java.util.concurrent.Executors;
33 import java.util.concurrent.Future;
35 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
36 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
37 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
38 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
39 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
40 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
41 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
42 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
43 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
44 import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
45 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
46 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationInput;
47 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationInputBuilder;
48 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationOutput;
49 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.NetworkTopologyOperationOutputBuilder;
50 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationInput;
51 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationInputBuilder;
52 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationOutput;
53 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadNetworkTopologyOperationOutputBuilder;
54 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationInput;
55 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationInputBuilder;
56 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationOutput;
57 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModuleTopologyOperationOutputBuilder;
58 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModules;
59 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVfModulesBuilder;
60 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationInput;
61 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationInputBuilder;
62 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationOutput;
63 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstanceTopologyOperationOutputBuilder;
64 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstances;
65 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfInstancesBuilder;
66 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationInput;
67 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationInputBuilder;
68 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationOutput;
69 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfTopologyOperationOutputBuilder;
70 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfs;
71 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.PreloadVnfsBuilder;
72 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VNFAPIService;
73 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationInput;
74 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationInputBuilder;
75 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationOutput;
76 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModuleTopologyOperationOutputBuilder;
77 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModules;
78 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VfModulesBuilder;
79 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationInput;
80 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationInputBuilder;
81 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationOutput;
82 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstanceTopologyOperationOutputBuilder;
83 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstances;
84 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfInstancesBuilder;
85 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationInput;
86 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationInputBuilder;
87 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationOutput;
88 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfTopologyOperationOutputBuilder;
89 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.Vnfs;
90 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.VnfsBuilder;
91 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.network.information.NetworkInformationBuilder;
92 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.data.PreloadData;
93 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.data.PreloadDataBuilder;
94 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadList;
95 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadListBuilder;
96 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.model.information.VnfPreloadListKey;
97 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadList;
98 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadListBuilder;
99 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vf.module.model.information.VfModulePreloadListKey;
100 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadList;
101 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadListBuilder;
102 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.preload.vnf.instance.model.information.VnfInstancePreloadListKey;
103 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.request.information.RequestInformation;
104 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.sdnc.request.header.SdncRequestHeader;
105 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.sdnc.request.header.SdncRequestHeader.SvcAction;
106 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.data.ServiceData;
107 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.data.ServiceDataBuilder;
108 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus;
109 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RequestStatus;
110 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RpcAction;
111 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.RpcName;
112 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.VnfsdnAction;
113 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatus.VnfsdnSubaction;
114 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.service.status.ServiceStatusBuilder;
115 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.information.VfModuleInformationBuilder;
116 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleList;
117 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleListBuilder;
118 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.model.infrastructure.VfModuleListKey;
119 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.preload.data.VfModulePreloadData;
120 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.preload.data.VfModulePreloadDataBuilder;
121 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.service.data.VfModuleServiceData;
122 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vf.module.service.data.VfModuleServiceDataBuilder;
123 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.information.VnfInformationBuilder;
124 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.information.VnfInstanceInformationBuilder;
125 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceList;
126 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceListBuilder;
127 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.model.infrastructure.VnfInstanceListKey;
128 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.preload.data.VnfInstancePreloadData;
129 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.preload.data.VnfInstancePreloadDataBuilder;
130 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.service.data.VnfInstanceServiceData;
131 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.instance.service.data.VnfInstanceServiceDataBuilder;
132 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfList;
133 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfListBuilder;
134 import org.opendaylight.yang.gen.v1.org.onap.sdnctl.vnf.rev150720.vnf.model.infrastructure.VnfListKey;
135 import org.opendaylight.yangtools.concepts.ListenerRegistration;
136 import org.opendaylight.yangtools.yang.binding.DataObject;
137 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
138 import org.opendaylight.yangtools.yang.common.RpcResult;
139 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
140 import org.slf4j.Logger;
141 import org.slf4j.LoggerFactory;
142 import org.slf4j.MDC;
144 import com.google.common.base.Optional;
145 import com.google.common.util.concurrent.CheckedFuture;
146 import com.google.common.util.concurrent.FutureCallback;
147 import com.google.common.util.concurrent.Futures;
148 import com.google.common.util.concurrent.SettableFuture;
152 * Defines a base implementation for your provider. This class extends from a helper class
153 * which provides storage for the most commonly used components of the MD-SAL. Additionally the
154 * base class provides some basic logging and initialization / clean up methods.
158 public class vnfapiProvider implements AutoCloseable, VNFAPIService, DataChangeListener{
160 private final Logger log = LoggerFactory.getLogger( vnfapiProvider.class );
161 private final String appName = "vnfapi";
162 private final ExecutorService executor;
165 private ListenerRegistration<DataChangeListener> dclServices;
167 protected DataBroker dataBroker;
168 protected NotificationProviderService notificationService;
169 protected RpcProviderRegistry rpcRegistry;
170 protected BindingAwareBroker.RpcRegistration<VNFAPIService> rpcRegistration;
174 public vnfapiProvider(DataBroker dataBroker2,
175 NotificationProviderService notificationProviderService,
176 RpcProviderRegistry rpcProviderRegistry) {
177 this.log.info( "Creating provider for " + appName );
178 executor = Executors.newFixedThreadPool(1);
179 dataBroker = dataBroker2;
180 notificationService = notificationProviderService;
181 rpcRegistry = rpcProviderRegistry;
186 public void initialize(){
187 log.info( "Initializing provider for " + appName );
188 // Create the top level containers
191 VnfSdnUtil.loadProperties();
192 } catch (Exception e) {
193 log.error("Caught Exception while trying to load properties file: ", e);
195 rpcRegistration = rpcRegistry.addRpcImplementation(VNFAPIService.class, this);
197 log.info( "Initialization complete for " + appName );
200 private void createContainers() {
201 final WriteTransaction t = dataBroker.newReadWriteTransaction();
203 // Create the Vnfs container
204 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Vnfs.class),
205 new VnfsBuilder().build());
206 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Vnfs.class),
207 new VnfsBuilder().build());
209 // Create the PreloadVnfs container
210 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
211 new PreloadVnfsBuilder().build());
212 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
213 new PreloadVnfsBuilder().build());
215 // 1610 Create the PreloadVnfInstances container
216 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfInstances.class),
217 new PreloadVnfInstancesBuilder().build());
218 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfInstances.class),
219 new PreloadVnfInstancesBuilder().build());
221 // 1610 Create the VnfInstances container
222 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VnfInstances.class),
223 new VnfInstancesBuilder().build());
224 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VnfInstances.class),
225 new VnfInstancesBuilder().build());
227 // 1610 Create the PreloadVfModules container
228 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVfModules.class),
229 new PreloadVfModulesBuilder().build());
230 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVfModules.class),
231 new PreloadVfModulesBuilder().build());
233 // 1610 Create the VfModules container
234 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VfModules.class),
235 new VfModulesBuilder().build());
236 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VfModules.class),
237 new VfModulesBuilder().build());
240 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
242 log.info("Create Containers succeeded!: ");
244 } catch (InterruptedException | ExecutionException e) {
245 log.error("Create Containers Failed: " + e);
251 protected void initializeChild() {
252 //Override if you have custom initialization intelligence
256 public void close() throws Exception {
257 log.info( "Closing provider for " + appName );
259 rpcRegistration.close();
260 // dclServices.close();
261 log.info( "Successfully closed provider for " + appName );
264 // On data change not used
266 public void onDataChanged(
267 AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
268 boolean changed = false;
269 log.info(" IN ON DATA CHANGE: ");
270 WriteTransaction writeTransaction = dataBroker
271 .newWriteOnlyTransaction();
273 DataObject updatedSubTree = change.getUpdatedSubtree();
275 if (updatedSubTree != null) {
276 if (log.isDebugEnabled())
278 log.debug("updatedSubTree was non-null:" + updatedSubTree);
280 if ( updatedSubTree instanceof Vnfs ) {
281 ArrayList<VnfList> vnfList = (ArrayList<VnfList>) ((Vnfs) updatedSubTree).getVnfList();
282 if (vnfList != null) {
283 for (VnfList entry : vnfList) {
284 ServiceData serviceData = entry.getServiceData();
285 ServiceStatus serviceStatus = entry.getServiceStatus();
286 if (serviceData != null && serviceStatus != null) {
288 // ServiceData change detected, check the AckFinal indicator and request-status to see if we need to proceed.
290 if ((! "Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete.equals(serviceStatus.getRequestStatus()))) {
291 if (log.isDebugEnabled())
293 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
295 //handleServiceDataUpdated(serviceData, serviceStatus, writeTransaction);
302 if ( updatedSubTree instanceof PreloadVnfs ) {
303 ArrayList<VnfPreloadList> vnfList = (ArrayList<VnfPreloadList>) ((PreloadVnfs) updatedSubTree).getVnfPreloadList();
304 if (vnfList != null) {
305 for (VnfPreloadList entry : vnfList) {
306 PreloadData preloadData = entry.getPreloadData();
307 if (preloadData != null ) {
309 // PreloadData change detected
311 // handlePreloadDataUpdated(preloadData, writeTransaction);
318 if ( updatedSubTree instanceof PreloadVnfInstances ) {
319 ArrayList<VnfInstancePreloadList> vnfInstanceList = (ArrayList<VnfInstancePreloadList>) ((PreloadVnfInstances) updatedSubTree).getVnfInstancePreloadList();
320 if (vnfInstanceList != null) {
321 for (VnfInstancePreloadList entry : vnfInstanceList) {
322 VnfInstancePreloadData vnfInstancePreloadData = entry.getVnfInstancePreloadData();
323 if (vnfInstancePreloadData != null ) {
325 // PreloadData change detected
327 // handlePreloadDataUpdated(preloadData, writeTransaction);
334 if ( updatedSubTree instanceof VnfInstances ) {
335 ArrayList<VnfInstanceList> vnfInstanceList = (ArrayList<VnfInstanceList>) ((VnfInstances) updatedSubTree).getVnfInstanceList();
336 if (vnfInstanceList != null) {
337 for (VnfInstanceList entry : vnfInstanceList) {
338 VnfInstanceServiceData vnfInstanceServiceData = entry.getVnfInstanceServiceData();
339 ServiceStatus serviceStatus = entry.getServiceStatus();
340 if (vnfInstanceServiceData != null && serviceStatus != null) {
342 // VnfInstanceServiceData change detected, check the AckFinal indicator and request-status to see if we need to proceed.
344 if ((! "Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete.equals(serviceStatus.getRequestStatus()))) {
345 if (log.isDebugEnabled())
347 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
349 //handleServiceDataUpdated(serviceData, serviceStatus, writeTransaction);
357 if ( updatedSubTree instanceof PreloadVfModules ) {
358 ArrayList<VfModulePreloadList> vnfInstanceList = (ArrayList<VfModulePreloadList>) ((PreloadVfModules) updatedSubTree).getVfModulePreloadList();
359 if (vnfInstanceList != null) {
360 for (VfModulePreloadList entry : vnfInstanceList) {
361 VfModulePreloadData vnfInstancePreloadData = entry.getVfModulePreloadData();
362 if (vnfInstancePreloadData != null ) {
364 // PreloadData change detected
366 // handlePreloadDataUpdated(preloadData, writeTransaction);
373 if ( updatedSubTree instanceof VfModules ) {
374 ArrayList<VfModuleList> vfModuleList = (ArrayList<VfModuleList>) ((VfModules) updatedSubTree).getVfModuleList();
375 if (vfModuleList != null) {
376 for (VfModuleList entry : vfModuleList) {
377 VfModuleServiceData vfModuleServiceData = entry.getVfModuleServiceData();
378 ServiceStatus serviceStatus = entry.getServiceStatus();
379 if (vfModuleServiceData != null && serviceStatus != null) {
381 // VfModuleServiceData change detected, check the AckFinal indicator and request-status to see if we need to proceed.
383 if ((! "Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete.equals(serviceStatus.getRequestStatus()))) {
384 if (log.isDebugEnabled())
386 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
388 //handleServiceDataUpdated(serviceData, serviceStatus, writeTransaction);
396 // Do the write transaction only if something changed.
398 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = writeTransaction
400 Futures.addCallback(checkedFuture, new FutureCallback<Void>() {
403 public void onSuccess(Void arg0) {
404 log.debug("Successfully updated Service Status");
408 public void onFailure(Throwable ex) {
410 "Failed updating Service Status",
417 private static class Iso8601Util
419 private static TimeZone tz = TimeZone.getTimeZone("UTC");
420 private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
427 private static String now()
429 return df.format(new Date());
433 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage, String ackFinal)
435 serviceStatusBuilder.setResponseCode(errorCode);
436 serviceStatusBuilder.setResponseMessage(errorMessage);
437 serviceStatusBuilder.setFinalIndicator(ackFinal);
438 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
441 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation)
443 if (requestInformation != null && requestInformation.getRequestAction() != null) {
444 switch (requestInformation.getRequestAction())
446 case VNFActivateRequest:
447 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VNFActivateRequest);
449 case ChangeVNFActivateRequest:
450 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVNFActivateRequest);
452 case DisconnectVNFRequest:
453 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVNFRequest);
455 case PreloadVNFRequest:
456 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVNFRequest);
458 case DeletePreloadVNFRequest:
459 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DeletePreloadVNFRequest);
461 // 1610 vnf-instance Requests
462 case VnfInstanceActivateRequest:
463 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VnfInstanceActivateRequest);
465 case ChangeVnfInstanceActivateRequest:
466 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVnfInstanceActivateRequest);
468 case DisconnectVnfInstanceRequest:
469 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVnfInstanceRequest);
471 case PreloadVnfInstanceRequest:
472 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVnfInstanceRequest);
474 // 1610 vf-module Requests
475 case VfModuleActivateRequest:
476 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VfModuleActivateRequest);
478 case ChangeVfModuleActivateRequest:
479 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVfModuleActivateRequest);
481 case DisconnectVfModuleRequest:
482 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVfModuleRequest);
484 case PreloadVfModuleRequest:
485 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVfModuleRequest);
488 log.error("Unknown RequestAction: " + requestInformation.getRequestAction() );
492 if (requestInformation != null && requestInformation.getRequestSubAction() != null) {
493 switch (requestInformation.getRequestSubAction())
496 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP);
499 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
502 log.error("Unknown RequestSubAction: " + requestInformation.getRequestSubAction() );
508 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader)
510 if (requestHeader != null && requestHeader.getSvcAction() != null) {
511 switch (requestHeader.getSvcAction())
514 serviceStatusBuilder.setRpcAction(RpcAction.Reserve);
517 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
520 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
523 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
526 serviceStatusBuilder.setRpcAction(RpcAction.Changeassign);
529 serviceStatusBuilder.setRpcAction(RpcAction.Changedelete);
532 serviceStatusBuilder.setRpcAction(RpcAction.Rollback);
535 log.error("Unknown SvcAction: " + requestHeader.getSvcAction() );
541 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder)
544 getServiceData(siid,serviceDataBuilder,LogicalDatastoreType.CONFIGURATION);
548 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type)
550 // See if any data exists yet for this siid, if so grab it.
551 InstanceIdentifier serviceInstanceIdentifier =
552 InstanceIdentifier.<Vnfs>builder(Vnfs.class)
553 .child(VnfList.class, new VnfListKey(siid)).toInstance();
554 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
555 Optional<VnfList> data = null;
557 data = (Optional<VnfList>) readTx.read(type, serviceInstanceIdentifier).get();
558 } catch (InterruptedException | ExecutionException e) {
559 log.error("Caught Exception reading MD-SAL ("+type+") for ["+siid+"] " ,e);
562 if (data != null && data.isPresent()) {
563 ServiceData serviceData = (ServiceData) data.get().getServiceData();
564 if (serviceData != null) {
565 log.info("Read MD-SAL ("+type+") data for ["+siid+"] ServiceData: " + serviceData);
566 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
567 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
568 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
569 serviceDataBuilder.setVnfRequestInformation(serviceData.getVnfRequestInformation());
570 serviceDataBuilder.setVnfId(serviceData.getVnfId());
571 serviceDataBuilder.setVnfTopologyInformation(serviceData.getVnfTopologyInformation());
572 serviceDataBuilder.setOperStatus(serviceData.getOperStatus());
574 log.info("No service-data found in MD-SAL ("+type+") for ["+siid+"] ");
577 log.info("No data found in MD-SAL ("+type+") for ["+siid+"] ");
582 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder)
585 getVnfInstanceServiceData(siid,vnfInstanceServiceDataBuilder,LogicalDatastoreType.CONFIGURATION);
588 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder, LogicalDatastoreType type)
590 // See if any data exists yet for this siid, if so grab it.
591 InstanceIdentifier vnfInstanceIdentifier =
592 InstanceIdentifier.<VnfInstances>builder(VnfInstances.class)
593 .child(VnfInstanceList.class, new VnfInstanceListKey(siid)).toInstance();
594 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
595 Optional<VnfInstanceList> data = null;
597 data = (Optional<VnfInstanceList>) readTx.read(type, vnfInstanceIdentifier).get();
598 } catch (InterruptedException | ExecutionException e) {
599 log.error("Caught Exception reading MD-SAL ("+type+") for ["+siid+"] " ,e);
602 if (data != null && data.isPresent()) {
603 VnfInstanceServiceData vnfInstanceServiceData = (VnfInstanceServiceData) data.get().getVnfInstanceServiceData();
604 if (vnfInstanceServiceData != null) {
605 log.info("Read MD-SAL ("+type+") data for ["+siid+"] VnfInstanceServiceData: " + vnfInstanceServiceData);
606 vnfInstanceServiceDataBuilder.setSdncRequestHeader(vnfInstanceServiceData.getSdncRequestHeader());
607 vnfInstanceServiceDataBuilder.setRequestInformation(vnfInstanceServiceData.getRequestInformation());
608 vnfInstanceServiceDataBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
609 vnfInstanceServiceDataBuilder.setVnfInstanceRequestInformation(vnfInstanceServiceData.getVnfInstanceRequestInformation());
610 vnfInstanceServiceDataBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
611 vnfInstanceServiceDataBuilder.setVnfInstanceTopologyInformation(vnfInstanceServiceData.getVnfInstanceTopologyInformation());
612 vnfInstanceServiceDataBuilder.setOperStatus(vnfInstanceServiceData.getOperStatus());
614 log.info("No vnf-instance-service-data found in MD-SAL ("+type+") for ["+siid+"] ");
617 log.info("No data found in MD-SAL ("+type+") for ["+siid+"] ");
622 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder)
625 getVfModuleServiceData(siid,vfModuleServiceDataBuilder,LogicalDatastoreType.CONFIGURATION);
628 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder, LogicalDatastoreType type)
630 // See if any data exists yet for this siid, if so grab it.
631 InstanceIdentifier vfModuleIdentifier =
632 InstanceIdentifier.<VfModules>builder(VfModules.class)
633 .child(VfModuleList.class, new VfModuleListKey(siid)).toInstance();
634 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
635 Optional<VfModuleList> data = null;
637 data = (Optional<VfModuleList>) readTx.read(type, vfModuleIdentifier).get();
638 } catch (InterruptedException | ExecutionException e) {
639 log.error("Caught Exception reading MD-SAL ("+type+") for ["+siid+"] " ,e);
642 if (data != null && data.isPresent()) {
643 VfModuleServiceData vfModuleServiceData = (VfModuleServiceData) data.get().getVfModuleServiceData();
644 if (vfModuleServiceData != null) {
645 log.info("Read MD-SAL ("+type+") data for ["+siid+"] VfModuleServiceData: " + vfModuleServiceData);
646 vfModuleServiceDataBuilder.setSdncRequestHeader(vfModuleServiceData.getSdncRequestHeader());
647 vfModuleServiceDataBuilder.setRequestInformation(vfModuleServiceData.getRequestInformation());
648 vfModuleServiceDataBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
649 vfModuleServiceDataBuilder.setVfModuleRequestInformation(vfModuleServiceData.getVfModuleRequestInformation());
650 vfModuleServiceDataBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
651 vfModuleServiceDataBuilder.setVfModuleTopologyInformation(vfModuleServiceData.getVfModuleTopologyInformation());
652 vfModuleServiceDataBuilder.setOperStatus(vfModuleServiceData.getOperStatus());
654 log.info("No vf-module-service-data found in MD-SAL ("+type+") for ["+siid+"] ");
657 log.info("No data found in MD-SAL ("+type+") for ["+siid+"] ");
662 private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder)
665 getPreloadData(vnf_name, vnf_type ,preloadDataBuilder,LogicalDatastoreType.CONFIGURATION);
668 private void getPreloadData(String preload_name, String preload_type, PreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type)
670 // See if any data exists yet for this name/type, if so grab it.
671 InstanceIdentifier preloadInstanceIdentifier =
672 InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
673 .child(VnfPreloadList.class, new VnfPreloadListKey(preload_name, preload_type)).toInstance();
674 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
675 Optional<VnfPreloadList> data = null;
677 data = (Optional<VnfPreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
678 } catch (InterruptedException | ExecutionException e) {
679 log.error("Caught Exception reading MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] " ,e);
682 if (data != null && data.isPresent()) {
683 PreloadData preloadData = (PreloadData) data.get().getPreloadData();
684 if (preloadData != null) {
685 log.info("Read MD-SAL ("+type+") data for ["+preload_name+","+preload_type+"] PreloadData: " + preloadData);
686 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
687 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
688 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
690 log.info("No preload-data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
693 log.info("No data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
697 //1610 preload-vnf-instance
698 private void getVnfInstancePreloadData(String vnf_name, String vnf_type, VnfInstancePreloadDataBuilder preloadDataBuilder)
701 getVnfInstancePreloadData(vnf_name, vnf_type ,preloadDataBuilder,LogicalDatastoreType.CONFIGURATION);
704 //1610 preload-vnf-instance
705 private void getVnfInstancePreloadData(String preload_name, String preload_type, VnfInstancePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type)
707 // See if any data exists yet for this name/type, if so grab it.
708 InstanceIdentifier preloadInstanceIdentifier =
709 InstanceIdentifier.<PreloadVnfInstances>builder(PreloadVnfInstances.class)
710 .child(VnfInstancePreloadList.class, new VnfInstancePreloadListKey(preload_name, preload_type)).toInstance();
711 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
712 Optional<VnfInstancePreloadList> data = null;
714 data = (Optional<VnfInstancePreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
715 } catch (InterruptedException | ExecutionException e) {
716 log.error("Caught Exception reading MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] " ,e);
719 if (data != null && data.isPresent()) {
720 VnfInstancePreloadData preloadData = (VnfInstancePreloadData) data.get().getVnfInstancePreloadData();
721 if (preloadData != null) {
722 log.info("Read MD-SAL ("+type+") data for ["+preload_name+","+preload_type+"] VnfInstancePreloadData: " + preloadData);
723 preloadDataBuilder.setVnfInstanceTopologyInformation(preloadData.getVnfInstanceTopologyInformation());
724 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
726 log.info("No vnf-instance-preload-data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
729 log.info("No data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
733 // 1610 preload-vf-module
734 private void getVfModulePreloadData(String vnf_name, String vnf_type, VfModulePreloadDataBuilder preloadDataBuilder)
737 getVfModulePreloadData(vnf_name, vnf_type ,preloadDataBuilder,LogicalDatastoreType.CONFIGURATION);
740 private void getVfModulePreloadData(String preload_name, String preload_type, VfModulePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type)
742 // See if any data exists yet for this name/type, if so grab it.
743 InstanceIdentifier preloadInstanceIdentifier =
744 InstanceIdentifier.<PreloadVfModules>builder(PreloadVfModules.class)
745 .child(VfModulePreloadList.class, new VfModulePreloadListKey(preload_name, preload_type)).toInstance();
746 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
747 Optional<VfModulePreloadList> data = null;
749 data = (Optional<VfModulePreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
750 } catch (InterruptedException | ExecutionException e) {
751 log.error("Caught Exception reading MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] " ,e);
754 if (data != null && data.isPresent()) {
755 VfModulePreloadData preloadData = (VfModulePreloadData) data.get().getVfModulePreloadData();
756 if (preloadData != null) {
757 log.info("Read MD-SAL ("+type+") data for ["+preload_name+","+preload_type+"] VfModulePreloadData: " + preloadData);
758 preloadDataBuilder.setVfModuleTopologyInformation(preloadData.getVfModuleTopologyInformation());
759 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
761 log.info("No preload-data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
764 log.info("No data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
768 private void SaveVnfList (final VnfList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException {
769 // Each entry will be identifiable by a unique key, we have to create that identifier
770 InstanceIdentifier.InstanceIdentifierBuilder<VnfList> vnfListIdBuilder =
771 InstanceIdentifier.<Vnfs>builder(Vnfs.class)
772 .child(VnfList.class, entry.getKey());
773 InstanceIdentifier<VnfList> path = vnfListIdBuilder.toInstance();
778 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
780 tx.merge(storeType, path, entry);
782 tx.put(storeType, path, entry);
784 tx.submit().checkedGet();
785 log.debug("Update DataStore succeeded");
787 } catch (final TransactionCommitFailedException e) {
788 if(e instanceof OptimisticLockFailedException) {
790 log.debug("Got OptimisticLockFailedException on last try - failing ");
791 throw new IllegalStateException(e);
793 log.debug("Got OptimisticLockFailedException - trying again ");
795 log.debug("Update DataStore failed");
796 throw new IllegalStateException(e);
802 private void DeleteVnfList (final VnfList entry, LogicalDatastoreType storeType) throws IllegalStateException {
803 // Each entry will be identifiable by a unique key, we have to create that identifier
804 InstanceIdentifier.InstanceIdentifierBuilder<VnfList> vnfListIdBuilder =
805 InstanceIdentifier.<Vnfs>builder(Vnfs.class)
806 .child(VnfList.class, entry.getKey());
807 InstanceIdentifier<VnfList> path = vnfListIdBuilder.toInstance();
812 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
813 tx.delete(storeType, path);
814 tx.submit().checkedGet();
815 log.debug("DataStore delete succeeded");
817 } catch (final TransactionCommitFailedException e) {
818 if (e instanceof OptimisticLockFailedException) {
820 log.debug("Got OptimisticLockFailedException on last try - failing ");
821 throw new IllegalStateException(e);
823 log.debug("Got OptimisticLockFailedException - trying again ");
825 log.debug("Delete DataStore failed");
826 throw new IllegalStateException(e);
833 private void SaveVnfInstanceList (final VnfInstanceList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException {
834 // Each entry will be identifiable by a unique key, we have to create that identifier
835 InstanceIdentifier.InstanceIdentifierBuilder<VnfInstanceList> vnfInstanceListIdBuilder =
836 InstanceIdentifier.<VnfInstances>builder(VnfInstances.class)
837 .child(VnfInstanceList.class, entry.getKey());
838 InstanceIdentifier<VnfInstanceList> path = vnfInstanceListIdBuilder.toInstance();
843 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
845 tx.merge(storeType, path, entry);
847 tx.put(storeType, path, entry);
849 tx.submit().checkedGet();
850 log.debug("Update DataStore succeeded");
852 } catch (final TransactionCommitFailedException e) {
853 if(e instanceof OptimisticLockFailedException) {
855 log.debug("Got OptimisticLockFailedException on last try - failing ");
856 throw new IllegalStateException(e);
858 log.debug("Got OptimisticLockFailedException - trying again ");
860 log.debug("Update DataStore failed");
861 throw new IllegalStateException(e);
868 private void SaveVfModuleList (final VfModuleList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException {
869 // Each entry will be identifiable by a unique key, we have to create that identifier
870 InstanceIdentifier.InstanceIdentifierBuilder<VfModuleList> vfModuleListIdBuilder =
871 InstanceIdentifier.<VfModules>builder(VfModules.class)
872 .child(VfModuleList.class, entry.getKey());
873 InstanceIdentifier<VfModuleList> path = vfModuleListIdBuilder.toInstance();
878 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
880 tx.merge(storeType, path, entry);
882 tx.put(storeType, path, entry);
884 tx.submit().checkedGet();
885 log.debug("Update DataStore succeeded");
887 } catch (final TransactionCommitFailedException e) {
888 if(e instanceof OptimisticLockFailedException) {
890 log.debug("Got OptimisticLockFailedException on last try - failing ");
891 throw new IllegalStateException(e);
893 log.debug("Got OptimisticLockFailedException - trying again ");
895 log.debug("Update DataStore failed");
896 throw new IllegalStateException(e);
902 private void SavePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException{
904 // Each entry will be identifiable by a unique key, we have to create that identifier
905 InstanceIdentifier.InstanceIdentifierBuilder<VnfPreloadList> vnfListIdBuilder =
906 InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
907 .child(VnfPreloadList.class, entry.getKey());
908 InstanceIdentifier<VnfPreloadList> path = vnfListIdBuilder.toInstance();
912 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
914 tx.merge(storeType, path, entry);
916 tx.put(storeType, path, entry);
918 tx.submit().checkedGet();
919 log.debug("Update DataStore succeeded");
921 } catch (final TransactionCommitFailedException e) {
922 if(e instanceof OptimisticLockFailedException) {
924 log.debug("Got OptimisticLockFailedException on last try - failing ");
925 throw new IllegalStateException(e);
927 log.debug("Got OptimisticLockFailedException - trying again ");
929 log.debug("Update DataStore failed");
930 throw new IllegalStateException(e);
936 //1610 preload vnf-instance
937 private void SaveVnfInstancePreloadList(final VnfInstancePreloadList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException{
939 // Each entry will be identifiable by a unique key, we have to create that identifier
940 InstanceIdentifier.InstanceIdentifierBuilder<VnfInstancePreloadList> vnfInstanceListIdBuilder =
941 InstanceIdentifier.<PreloadVnfInstances>builder(PreloadVnfInstances.class)
942 .child(VnfInstancePreloadList.class, entry.getKey());
943 InstanceIdentifier<VnfInstancePreloadList> path = vnfInstanceListIdBuilder.toInstance();
947 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
949 tx.merge(storeType, path, entry);
951 tx.put(storeType, path, entry);
953 tx.submit().checkedGet();
954 log.debug("Update DataStore succeeded");
956 } catch (final TransactionCommitFailedException e) {
957 if(e instanceof OptimisticLockFailedException) {
959 log.debug("Got OptimisticLockFailedException on last try - failing ");
960 throw new IllegalStateException(e);
962 log.debug("Got OptimisticLockFailedException - trying again ");
964 log.debug("Update DataStore failed");
965 throw new IllegalStateException(e);
971 //1610 preload vf-module
972 private void SaveVfModulePreloadList(final VfModulePreloadList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException{
974 // Each entry will be identifiable by a unique key, we have to create that identifier
975 InstanceIdentifier.InstanceIdentifierBuilder<VfModulePreloadList> vfModuleListIdBuilder =
976 InstanceIdentifier.<PreloadVfModules>builder(PreloadVfModules.class)
977 .child(VfModulePreloadList.class, entry.getKey());
978 InstanceIdentifier<VfModulePreloadList> path = vfModuleListIdBuilder.toInstance();
982 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
984 tx.merge(storeType, path, entry);
986 tx.put(storeType, path, entry);
988 tx.submit().checkedGet();
989 log.debug("Update DataStore succeeded");
991 } catch (final TransactionCommitFailedException e) {
992 if(e instanceof OptimisticLockFailedException) {
994 log.debug("Got OptimisticLockFailedException on last try - failing ");
995 throw new IllegalStateException(e);
997 log.debug("Got OptimisticLockFailedException - trying again ");
999 log.debug("Update DataStore failed");
1000 throw new IllegalStateException(e);
1006 //Save the requestId into MDC
1007 private void setRequestIdAsMDC(String requestId){
1008 MDC.put("RequestId", requestId);
1011 //1610 vnf-instance-topology-operation
1013 public Future<RpcResult<VnfInstanceTopologyOperationOutput>> vnfInstanceTopologyOperation(
1014 VnfInstanceTopologyOperationInput input) {
1016 final String SVC_OPERATION = "vnf-instance-topology-operation";
1017 VnfInstanceServiceData vnfInstanceServiceData = null;
1018 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1019 Properties parms = new Properties();
1021 log.info( SVC_OPERATION +" called." );
1022 // create a new response object
1023 VnfInstanceTopologyOperationOutputBuilder responseBuilder = new VnfInstanceTopologyOperationOutputBuilder();
1025 //if(input == null || input.getVnfInstanceRequestInformation().getVnfInstanceTopologyIdentifier().getVnfInstanceId() == null )
1027 input.getVnfInstanceRequestInformation() == null ||
1028 input.getVnfInstanceRequestInformation().getVnfInstanceId() == null )
1030 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-instance-id");
1031 responseBuilder.setResponseCode("403");
1032 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1033 responseBuilder.setAckFinalIndicator("Y");
1034 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1035 RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1037 return Futures.immediateFuture(rpcResult);
1040 // Grab the service instance ID from the input buffer
1041 String viid = input.getVnfInstanceRequestInformation().getVnfInstanceId();
1042 String preload_name = input.getVnfInstanceRequestInformation().getVnfInstanceName();
1043 String preload_type = input.getVnfInstanceRequestInformation().getVnfModelId();
1045 // Make sure we have a valid viid
1046 if(viid == null || viid.length() == 0 ) {
1047 log.debug("exiting "+SVC_OPERATION+" because of invalid vnf-instance-id");
1048 responseBuilder.setResponseCode("403");
1049 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1050 responseBuilder.setAckFinalIndicator("Y");
1051 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1052 RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1054 return Futures.immediateFuture(rpcResult);
1057 if (input.getSdncRequestHeader() != null) {
1058 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1059 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1062 // Get vnf-instance-preload-data
1063 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
1064 getVnfInstancePreloadData(preload_name, preload_type, vnfInstancePreloadDataBuilder);
1067 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1068 getVnfInstanceServiceData(viid,vnfInstanceServiceDataBuilder);
1070 // Get operational-data
1071 VnfInstanceServiceDataBuilder operDataBuilder = new VnfInstanceServiceDataBuilder();
1072 getVnfInstanceServiceData(viid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1074 // Set the serviceStatus based on input
1075 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1076 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1079 // setup a service-data object builder
1080 // ACTION vnf-topology-operation
1082 // USES sdnc-request-header;
1083 // USES request-information;
1084 // USES service-information;
1085 // USES vnf-request-information
1087 // USES vnf-topology-response-body;
1088 // USES vnf-information
1089 // USES service-information
1091 // container service-data
1092 // uses vnf-configuration-information;
1093 // uses oper-status;
1095 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+viid+"] input: " + input);
1096 VnfInstanceTopologyOperationInputBuilder inputBuilder = new VnfInstanceTopologyOperationInputBuilder(input);
1097 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1099 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+viid+"] operational-data: " + operDataBuilder.build());
1100 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1102 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " + vnfInstancePreloadDataBuilder.build());
1103 VnfSdnUtil.toProperties(parms, "vnf-instance-preload-data", vnfInstancePreloadDataBuilder);
1105 // Call SLI sync method
1106 // Get SvcLogicService reference
1108 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
1109 Properties respProps = null;
1111 String errorCode = "200";
1112 String errorMessage = null;
1113 String ackFinal = "Y";
1118 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1123 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", vnfInstanceServiceDataBuilder, parms);
1127 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1128 errorMessage = e.getMessage();
1132 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1139 errorMessage = e.getMessage();
1140 log.error("Caught exception looking for service logic", e);
1144 if (respProps != null)
1146 errorCode = respProps.getProperty("error-code");
1147 errorMessage = respProps.getProperty("error-message");
1148 ackFinal = respProps.getProperty("ack-final", "Y");
1151 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
1152 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1153 serviceStatusBuilder.setRpcName(RpcName.VnfInstanceTopologyOperation);
1155 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1156 responseBuilder.setResponseCode(errorCode);
1157 responseBuilder.setResponseMessage(errorMessage);
1158 responseBuilder.setAckFinalIndicator(ackFinal);
1159 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1160 vnfInstanceListBuilder.setVnfInstanceId(viid);
1161 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1163 SaveVnfInstanceList (vnfInstanceListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
1164 } catch (Exception e) {
1165 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+viid+"] \n",e);
1167 log.error("Returned FAILED for "+SVC_OPERATION+" ["+viid+"] " + responseBuilder.build());
1168 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1169 RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1171 return Futures.immediateFuture(rpcResult);
1174 // Got success from SLI
1176 vnfInstanceServiceData = vnfInstanceServiceDataBuilder.build();
1177 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+viid+"] VnfInstanceServiceData: " + vnfInstanceServiceData);
1178 // svc-configuration-list
1179 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1180 vnfInstanceListBuilder.setVnfInstanceServiceData(vnfInstanceServiceData);
1181 vnfInstanceListBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
1182 //siid = vnfInstanceServiceData.getVnfInstanceId();
1183 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1184 SaveVnfInstanceList (vnfInstanceListBuilder.build(), false,LogicalDatastoreType.CONFIGURATION);
1185 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1187 // Only update operational tree on Delete or Activate
1188 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
1189 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1191 log.info("Updating OPERATIONAL tree.");
1192 SaveVnfInstanceList (vnfInstanceListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1195 VnfInstanceInformationBuilder vnfInstanceInformationBuilder = new VnfInstanceInformationBuilder();
1196 vnfInstanceInformationBuilder.setVnfInstanceId(viid);
1197 responseBuilder.setVnfInstanceInformation(vnfInstanceInformationBuilder.build());
1198 responseBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
1199 } catch (Exception e) {
1200 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+viid+"] \n",e);
1201 responseBuilder.setResponseCode("500");
1202 responseBuilder.setResponseMessage(e.toString());
1203 responseBuilder.setAckFinalIndicator("Y");
1204 log.error("Returned FAILED for "+SVC_OPERATION+" ["+viid+"] " + responseBuilder.build());
1205 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1206 RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1208 return Futures.immediateFuture(rpcResult);
1212 responseBuilder.setResponseCode(errorCode);
1213 responseBuilder.setAckFinalIndicator(ackFinal);
1214 if (errorMessage != null)
1216 responseBuilder.setResponseMessage(errorMessage);
1218 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+viid+"] ");
1219 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+viid+"] " + responseBuilder.build());
1221 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1222 RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1224 return Futures.immediateFuture(rpcResult);
1227 //1610 vf-module-topology-operation
1229 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1230 VfModuleTopologyOperationInput input) {
1232 final String SVC_OPERATION = "vf-module-topology-operation";
1233 VfModuleServiceData vfModuleServiceData = null;
1234 VnfInstanceServiceData vnfInstanceServiceData = null;
1235 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1236 Properties parms = new Properties();
1238 log.info( SVC_OPERATION +" called." );
1239 // create a new response object
1240 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1242 // Validate vf-module-id from vf-module-request-information
1244 input.getVfModuleRequestInformation() == null ||
1245 input.getVfModuleRequestInformation().getVfModuleId() == null)
1247 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vf-module-id");
1248 responseBuilder.setResponseCode("403");
1249 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1250 responseBuilder.setAckFinalIndicator("Y");
1251 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1252 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1254 return Futures.immediateFuture(rpcResult);
1257 // Grab the vf-module-request-information.vf-module-id from the input buffer
1258 String vfid = input.getVfModuleRequestInformation().getVfModuleId();
1259 String preload_name = input.getVfModuleRequestInformation().getVfModuleName();
1260 String preload_type = input.getVfModuleRequestInformation().getVfModuleModelId();
1262 // Make sure we have a valid siid
1263 if(vfid == null || vfid.length() == 0 ) {
1264 log.debug("exiting "+SVC_OPERATION+" because of invalid vf-module-id");
1265 responseBuilder.setResponseCode("403");
1266 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1267 responseBuilder.setAckFinalIndicator("Y");
1268 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1269 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1271 return Futures.immediateFuture(rpcResult);
1274 // 1610 add vf-module-id to vnf-instance-list.vf-module-relationship-list
1275 String viid = input.getVfModuleRequestInformation().getVnfInstanceId();
1277 if(viid == null || viid.length() == 0 ) {
1278 log.debug("exiting "+SVC_OPERATION+" because of invalid vnf-instance-id");
1279 responseBuilder.setResponseCode("403");
1280 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1281 responseBuilder.setAckFinalIndicator("Y");
1282 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1283 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1285 return Futures.immediateFuture(rpcResult);
1288 if (input.getSdncRequestHeader() != null) {
1289 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1290 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1293 // Get vf-module-preload-data
1294 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
1295 getVfModulePreloadData(preload_name, preload_type, vfModulePreloadDataBuilder);
1297 // Get vf-module-service-data
1298 VfModuleServiceDataBuilder vfModuleServiceDataBuilder = new VfModuleServiceDataBuilder();
1299 getVfModuleServiceData(vfid,vfModuleServiceDataBuilder);
1301 // Get vf-module operation-data
1302 VfModuleServiceDataBuilder operDataBuilder = new VfModuleServiceDataBuilder();
1303 getVfModuleServiceData(vfid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1305 // save service-data builder object for rollback
1306 VfModuleServiceDataBuilder rb_vfModuleServiceDataBuilder = vfModuleServiceDataBuilder;
1307 VfModuleServiceDataBuilder rb_operDataBuilder = operDataBuilder;
1309 // 1610 Need to pull vnf-instance-list.vf-module-relationship-list from MD-SAL
1310 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1311 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1313 // vnf-instance operational-data
1314 VnfInstanceServiceDataBuilder vnfInstanceOperDataBuilder = new VnfInstanceServiceDataBuilder();
1315 getVnfInstanceServiceData(viid, vnfInstanceOperDataBuilder, LogicalDatastoreType.OPERATIONAL );
1317 // save operational builder object for rollback
1318 VnfInstanceServiceDataBuilder rb_vnfInstanceServiceDataBuilder = vnfInstanceServiceDataBuilder;
1319 VnfInstanceServiceDataBuilder rb_vnfInstanceOperDataBuilder = vnfInstanceOperDataBuilder;
1321 // Set the serviceStatus based on input
1322 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1323 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1326 // setup a service-data object builder
1327 // ACTION vnf-topology-operation
1329 // USES sdnc-request-header;
1330 // USES request-information;
1331 // USES service-information;
1332 // USES vnf-request-information
1334 // USES vnf-topology-response-body;
1335 // USES vnf-information
1336 // USES service-information
1338 // container service-data
1339 // uses vnf-configuration-information;
1340 // uses oper-status;
1342 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+vfid+"] input: " + input);
1343 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1344 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1346 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+vfid+"] vf-module operational-data: " + operDataBuilder.build());
1347 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1349 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] 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: " + vnfInstanceServiceDataBuilder.build());
1353 VnfSdnUtil.toProperties(parms, "vnf-instance-service-data", vnfInstanceServiceDataBuilder);
1355 log.info("Adding vnf-instance OPERATIONAL data for "+SVC_OPERATION+" ["+viid+"] vnf-instance operational-data: " + vnfInstanceOperDataBuilder.build());
1356 VnfSdnUtil.toProperties(parms, "vnf-instance-operational-data", vnfInstanceOperDataBuilder);
1358 // Call SLI sync method
1359 // Get SvcLogicService reference
1361 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
1362 Properties respProps = null;
1364 String errorCode = "200";
1365 String errorMessage = null;
1366 String ackFinal = "Y";
1371 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1376 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", vfModuleServiceDataBuilder, parms);
1380 log.error("Caught exception executing service logic on vf-module for "+ SVC_OPERATION, e);
1381 errorMessage = e.getMessage();
1386 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1393 errorMessage = e.getMessage();
1394 log.error("Caught exception looking for service logic", e);
1398 if (respProps != null) {
1399 errorCode = respProps.getProperty("error-code");
1400 errorMessage = respProps.getProperty("error-message");
1401 ackFinal = respProps.getProperty("ack-final", "Y");
1404 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
1405 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1406 serviceStatusBuilder.setRpcName(RpcName.VfModuleTopologyOperation);
1408 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1409 responseBuilder.setResponseCode(errorCode);
1410 responseBuilder.setResponseMessage(errorMessage);
1411 responseBuilder.setAckFinalIndicator(ackFinal);
1412 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1413 vfModuleListBuilder.setVfModuleId(vfid);
1414 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1416 SaveVfModuleList (vfModuleListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
1417 } catch (Exception e) {
1418 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+vfid+"] \n",e);
1420 log.error("Returned FAILED for "+SVC_OPERATION+" ["+vfid+"] " + responseBuilder.build());
1421 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1422 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1424 return Futures.immediateFuture(rpcResult);
1427 // Got success from SLI
1428 // save vf-module-service-data in MD-SAL
1430 vfModuleServiceData = vfModuleServiceDataBuilder.build();
1431 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+vfid+"] VfModuleServiceData: " + vfModuleServiceData);
1433 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1434 vfModuleListBuilder.setVfModuleServiceData(vfModuleServiceData);
1435 vfModuleListBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
1436 //vfid = vfModuleServiceData.getVfModuleId();
1437 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1438 SaveVfModuleList (vfModuleListBuilder.build(), false,LogicalDatastoreType.CONFIGURATION);
1439 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1441 // Only update operational tree on Delete or Activate
1442 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
1443 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1445 log.info("Updating OPERATIONAL tree.");
1446 SaveVfModuleList (vfModuleListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1449 VfModuleInformationBuilder vfModuleInformationBuilder = new VfModuleInformationBuilder();
1450 vfModuleInformationBuilder.setVfModuleId(vfid);
1451 responseBuilder.setVfModuleInformation(vfModuleInformationBuilder.build());
1452 responseBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
1453 } catch (Exception e) {
1454 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+vfid+"] \n",e);
1455 responseBuilder.setResponseCode("500");
1456 responseBuilder.setResponseMessage(e.toString());
1457 responseBuilder.setAckFinalIndicator("Y");
1458 log.error("Returned FAILED for "+SVC_OPERATION+" ["+vfid+"] " + responseBuilder.build());
1459 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1460 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1462 return Futures.immediateFuture(rpcResult);
1466 responseBuilder.setResponseCode(errorCode);
1467 responseBuilder.setAckFinalIndicator(ackFinal);
1468 if (errorMessage != null)
1470 responseBuilder.setResponseMessage(errorMessage);
1472 log.info("Updated vf-module in MD-SAL for "+SVC_OPERATION+" ["+vfid+"] ");
1473 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+vfid+"] " + responseBuilder.build());
1475 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1476 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1478 return Futures.immediateFuture(rpcResult);
1483 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(
1484 VnfTopologyOperationInput input) {
1486 final String SVC_OPERATION = "vnf-topology-operation";
1487 ServiceData serviceData = null;
1488 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1489 Properties parms = new Properties();
1491 log.info( SVC_OPERATION +" called." );
1492 // create a new response object
1493 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1496 input.getServiceInformation() == null ||
1497 input.getServiceInformation().getServiceInstanceId() == null ||
1498 input.getServiceInformation().getServiceInstanceId().length() == 0)
1500 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty service-instance-id");
1501 responseBuilder.setResponseCode("403");
1502 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1503 responseBuilder.setAckFinalIndicator("Y");
1504 RpcResult<VnfTopologyOperationOutput> rpcResult =
1505 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1507 return Futures.immediateFuture(rpcResult);
1510 if(input.getVnfRequestInformation() == null ||
1511 input.getVnfRequestInformation().getVnfId() == null ||
1512 input.getVnfRequestInformation().getVnfId().length() == 0)
1514 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vf-module-id");
1515 responseBuilder.setResponseCode("403");
1516 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1517 responseBuilder.setAckFinalIndicator("Y");
1518 RpcResult<VnfTopologyOperationOutput> rpcResult =
1519 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1521 return Futures.immediateFuture(rpcResult);
1524 // Grab the service instance ID from the input buffer
1525 String siid = input.getVnfRequestInformation().getVnfId();
1526 String preload_name = input.getVnfRequestInformation().getVnfName();
1527 String preload_type = input.getVnfRequestInformation().getVnfType();
1530 // Make sure we have a valid siid
1531 if(siid == null || siid.length() == 0 ) {
1532 log.debug("exiting "+SVC_OPERATION+" because of invalid siid");
1533 responseBuilder.setResponseCode("403");
1534 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1535 responseBuilder.setAckFinalIndicator("Y");
1536 RpcResult<VnfTopologyOperationOutput> rpcResult =
1537 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1539 return Futures.immediateFuture(rpcResult);
1543 if (input.getSdncRequestHeader() != null) {
1544 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1545 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1548 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1549 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1551 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1552 getServiceData(siid,serviceDataBuilder);
1554 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1555 getServiceData(siid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1557 // Set the serviceStatus based on input
1558 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1559 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1562 // setup a service-data object builder
1563 // ACTION vnf-topology-operation
1565 // USES sdnc-request-header;
1566 // USES request-information;
1567 // USES service-information;
1568 // USES vnf-request-information
1570 // USES vnf-topology-response-body;
1571 // USES vnf-information
1572 // USES service-information
1574 // container service-data
1575 // uses vnf-configuration-information;
1576 // uses oper-status;
1578 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+siid+"] input: " + input);
1579 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1580 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1582 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+siid+"] operational-data: " + operDataBuilder.build());
1583 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1585 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " + preloadDataBuilder.build());
1586 VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1588 // Call SLI sync method
1589 // Get SvcLogicService reference
1591 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
1592 Properties respProps = null;
1594 String errorCode = "200";
1595 String errorMessage = null;
1596 String ackFinal = "Y";
1601 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1606 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1610 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1611 errorMessage = e.getMessage();
1615 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1622 errorMessage = e.getMessage();
1623 log.error("Caught exception looking for service logic", e);
1627 if (respProps != null)
1629 errorCode = respProps.getProperty("error-code");
1630 errorMessage = respProps.getProperty("error-message");
1631 ackFinal = respProps.getProperty("ack-final", "Y");
1634 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
1635 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1636 serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
1638 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1639 responseBuilder.setResponseCode(errorCode);
1640 responseBuilder.setResponseMessage(errorMessage);
1641 responseBuilder.setAckFinalIndicator(ackFinal);
1642 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1643 vnfListBuilder.setVnfId(siid);
1644 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1646 SaveVnfList (vnfListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
1647 } catch (Exception e) {
1648 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
1650 log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1651 RpcResult<VnfTopologyOperationOutput> rpcResult =
1652 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1654 return Futures.immediateFuture(rpcResult);
1657 // Got success from SLI
1659 serviceData = serviceDataBuilder.build();
1660 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] ServiceData: " + serviceData);
1661 // svc-configuration-list
1662 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1663 vnfListBuilder.setServiceData(serviceData);
1664 vnfListBuilder.setVnfId(serviceData.getVnfId());
1665 siid = serviceData.getVnfId();
1666 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1667 SaveVnfList (vnfListBuilder.build(), false,LogicalDatastoreType.CONFIGURATION);
1668 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1670 // Only update operational tree on Delete or Activate
1671 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1672 log.info("Updating OPERATIONAL tree.");
1673 SaveVnfList (vnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1675 else if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
1676 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Rollback)) {
1677 log.info("Delete OPERATIONAL tree.");
1678 DeleteVnfList (vnfListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
1679 DeleteVnfList (vnfListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
1682 VnfInformationBuilder vnfInformationBuilder = new VnfInformationBuilder();
1683 vnfInformationBuilder.setVnfId(siid);
1684 responseBuilder.setVnfInformation(vnfInformationBuilder.build());
1685 responseBuilder.setServiceInformation(serviceData.getServiceInformation());
1686 } catch (Exception e) {
1687 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
1688 responseBuilder.setResponseCode("500");
1689 responseBuilder.setResponseMessage(e.toString());
1690 responseBuilder.setAckFinalIndicator("Y");
1691 log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1692 RpcResult<VnfTopologyOperationOutput> rpcResult =
1693 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1695 return Futures.immediateFuture(rpcResult);
1699 responseBuilder.setResponseCode(errorCode);
1700 responseBuilder.setAckFinalIndicator(ackFinal);
1701 if (errorMessage != null)
1703 responseBuilder.setResponseMessage(errorMessage);
1705 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+siid+"] ");
1706 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1708 RpcResult<VnfTopologyOperationOutput> rpcResult =
1709 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1711 return Futures.immediateFuture(rpcResult);
1716 public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1717 NetworkTopologyOperationInput input) {
1719 final String SVC_OPERATION = "network-topology-operation";
1720 ServiceData serviceData = null;
1721 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1722 Properties parms = new Properties();
1724 log.info( SVC_OPERATION +" called." );
1725 // create a new response object
1726 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1729 input.getServiceInformation() == null ||
1730 input.getServiceInformation().getServiceInstanceId() == null ||
1731 input.getServiceInformation().getServiceInstanceId().length() == 0)
1733 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty service-instance-id");
1734 responseBuilder.setResponseCode("403");
1735 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1736 responseBuilder.setAckFinalIndicator("Y");
1737 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1738 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1740 return Futures.immediateFuture(rpcResult);
1743 if(input.getNetworkRequestInformation() == null || input.getNetworkRequestInformation().getNetworkName() == null) {
1744 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty service-instance-id");
1745 responseBuilder.setResponseCode("403");
1746 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1747 responseBuilder.setAckFinalIndicator("Y");
1748 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1749 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1751 return Futures.immediateFuture(rpcResult);
1754 // Grab the service instance ID from the input buffer
1756 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Assign)) {
1757 siid = input.getNetworkRequestInformation().getNetworkName();
1760 siid = input.getNetworkRequestInformation().getNetworkId();
1762 String preload_name = input.getNetworkRequestInformation().getNetworkName();
1763 String preload_type = input.getNetworkRequestInformation().getNetworkType();
1766 if(siid == null || siid.length() == 0 ) {
1767 log.debug("exiting "+SVC_OPERATION+" because of invalid siid");
1768 responseBuilder.setResponseCode("403");
1769 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1770 responseBuilder.setAckFinalIndicator("Y");
1771 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1772 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1774 return Futures.immediateFuture(rpcResult);
1778 if (input.getSdncRequestHeader() != null) {
1779 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1780 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1783 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1784 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1786 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+siid+"] input: " + input);
1787 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1788 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1791 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+siid+"] operational-data: " + operDataBuilder.build());
1792 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1794 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " + preloadDataBuilder.build());
1795 VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1798 // Call SLI sync method
1799 // Get SvcLogicService reference
1801 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
1802 Properties respProps = null;
1804 String errorCode = "200";
1805 String errorMessage = null;
1806 String ackFinal = "Y";
1807 String networkId = "error";
1812 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1817 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1821 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1822 errorMessage = e.getMessage();
1826 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1833 errorMessage = e.getMessage();
1834 log.error("Caught exception looking for service logic", e);
1838 if (respProps != null)
1840 errorCode = respProps.getProperty("error-code");
1841 errorMessage = respProps.getProperty("error-message");
1842 ackFinal = respProps.getProperty("ack-final", "Y");
1843 networkId = respProps.getProperty("networkId","0");
1846 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1847 responseBuilder.setResponseCode(errorCode);
1848 responseBuilder.setResponseMessage(errorMessage);
1849 responseBuilder.setAckFinalIndicator(ackFinal);
1851 log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1853 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1854 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1856 return Futures.immediateFuture(rpcResult);
1859 // Got success from SLI
1861 NetworkInformationBuilder networkInformationBuilder = new NetworkInformationBuilder();
1862 networkInformationBuilder.setNetworkId(networkId);
1863 responseBuilder.setNetworkInformation(networkInformationBuilder.build());
1864 responseBuilder.setServiceInformation(input.getServiceInformation());
1865 } catch (IllegalStateException e) {
1866 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
1867 responseBuilder.setResponseCode("500");
1868 responseBuilder.setResponseMessage(e.toString());
1869 responseBuilder.setAckFinalIndicator("Y");
1870 log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1871 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1872 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1874 return Futures.immediateFuture(rpcResult);
1878 responseBuilder.setResponseCode(errorCode);
1879 responseBuilder.setAckFinalIndicator(ackFinal);
1880 if (errorMessage != null)
1882 responseBuilder.setResponseMessage(errorMessage);
1884 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+siid+"] ");
1885 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1887 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1888 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1890 return Futures.immediateFuture(rpcResult);
1894 public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1895 PreloadVnfTopologyOperationInput input) {
1897 final String SVC_OPERATION = "preload-vnf-topology-operation";
1898 PreloadData preloadData = null;
1899 Properties parms = new Properties();
1901 log.info( SVC_OPERATION +" called." );
1902 // create a new response object
1903 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1905 // Result from savePreloadData
1906 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1908 if(input == null || input.getVnfTopologyInformation() == null || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName() == null || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType() == null) {
1909 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-name and vnf-type");
1910 responseBuilder.setResponseCode("403");
1911 responseBuilder.setResponseMessage("invalid input, null or empty vnf-name and vnf-type");
1912 responseBuilder.setAckFinalIndicator("Y");
1913 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1914 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1915 return Futures.immediateFuture(rpcResult);
1918 // Grab the name and type from the input buffer
1919 String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1920 String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1922 // Make sure we have a preload_name and preload_type
1923 if(preload_name == null || preload_name.length() == 0 ) {
1924 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-name");
1925 responseBuilder.setResponseCode("403");
1926 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1927 responseBuilder.setAckFinalIndicator("Y");
1928 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1929 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1930 return Futures.immediateFuture(rpcResult);
1932 if(preload_type == null || preload_type.length() == 0 ) {
1933 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-type");
1934 responseBuilder.setResponseCode("403");
1935 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1936 responseBuilder.setAckFinalIndicator("Y");
1937 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1938 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1939 return Futures.immediateFuture(rpcResult);
1942 if (input.getSdncRequestHeader() != null) {
1943 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1944 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1947 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1948 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1949 //preloadData = preloadDataBuilder.build();
1951 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1952 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1955 // setup a preload-data object builder
1956 // ACTION vnf-topology-operation
1958 // USES sdnc-request-header;
1959 // USES request-information;
1960 // uses vnf-topology-information;
1962 // USES vnf-topology-response-body;
1964 // container preload-data
1965 // uses vnf-configuration-information;
1968 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
1969 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1970 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1971 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
1972 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1974 // Call SLI sync method
1975 // Get SvcLogicService reference
1977 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
1978 Properties respProps = null;
1980 String errorCode = "200";
1981 String errorMessage = null;
1982 String ackFinal = "Y";
1987 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1992 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1996 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1997 errorMessage = e.getMessage();
2001 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2008 errorMessage = e.getMessage();
2009 log.error("Caught exception looking for service logic", e);
2013 if (respProps != null)
2015 errorCode = respProps.getProperty("error-code");
2016 errorMessage = respProps.getProperty("error-message");
2017 ackFinal = respProps.getProperty("ack-final", "Y");
2018 // internalError = respProps.getProperty("internal-error", "false");
2021 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2023 responseBuilder.setResponseCode(errorCode);
2024 responseBuilder.setResponseMessage(errorMessage);
2025 responseBuilder.setAckFinalIndicator(ackFinal);
2027 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2028 preloadVnfListBuilder.setVnfName(preload_name);
2029 preloadVnfListBuilder.setVnfType(preload_type);
2030 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2031 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
2033 SavePreloadList (preloadVnfListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
2034 } catch (Exception e) {
2035 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2037 log.debug("Sending Success rpc result due to external error");
2038 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2039 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2040 return Futures.immediateFuture(rpcResult);
2043 // Got success from SLI
2045 preloadData = preloadDataBuilder.build();
2046 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + preloadData);
2047 // svc-configuration-list
2048 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2049 preloadVnfListBuilder.setVnfName(preload_name);
2050 preloadVnfListBuilder.setVnfType(preload_type);
2051 preloadVnfListBuilder.setPreloadData(preloadData);
2053 // SDNGC-989 set merge flag to false
2054 SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2055 log.info("Updating OPERATIONAL tree.");
2056 SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2057 } catch (Exception e) {
2058 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2059 responseBuilder.setResponseCode("500");
2060 responseBuilder.setResponseMessage(e.toString());
2061 responseBuilder.setAckFinalIndicator("Y");
2062 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2063 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2064 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2065 return Futures.immediateFuture(rpcResult);
2069 responseBuilder.setResponseCode(errorCode);
2070 responseBuilder.setAckFinalIndicator(ackFinal);
2071 if (errorMessage != null)
2073 responseBuilder.setResponseMessage(errorMessage);
2075 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
2076 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2078 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2079 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2080 return Futures.immediateFuture(rpcResult);
2083 //1610 preload-vnf-instance-topology-operation
2085 public Future<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> preloadVnfInstanceTopologyOperation(
2086 PreloadVnfInstanceTopologyOperationInput input) {
2088 final String SVC_OPERATION = "preload-vnf-instance-topology-operation";
2089 VnfInstancePreloadData vnfInstancePreloadData = null;
2090 Properties parms = new Properties();
2092 log.info( SVC_OPERATION +" called." );
2093 // create a new response object
2094 PreloadVnfInstanceTopologyOperationOutputBuilder responseBuilder = new PreloadVnfInstanceTopologyOperationOutputBuilder();
2096 // Result from savePreloadData
2097 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2100 input.getVnfInstanceTopologyInformation() == null ||
2101 input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName() == null ||
2102 input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId() == null)
2104 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-instance-name and vnf-model-id");
2105 responseBuilder.setResponseCode("403");
2106 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name and vnf-model-id");
2107 responseBuilder.setAckFinalIndicator("Y");
2108 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2109 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2110 return Futures.immediateFuture(rpcResult);
2113 // Grab the name and type from the input buffer
2114 String preload_name = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName();
2115 String preload_type = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId();
2117 // Make sure we have a preload_name and preload_type
2118 if(preload_name == null || preload_name.length() == 0 ) {
2119 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-name");
2120 responseBuilder.setResponseCode("403");
2121 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2122 responseBuilder.setAckFinalIndicator("Y");
2123 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2124 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2125 return Futures.immediateFuture(rpcResult);
2127 if(preload_type == null || preload_type.length() == 0 ) {
2128 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-type");
2129 responseBuilder.setResponseCode("403");
2130 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2131 responseBuilder.setAckFinalIndicator("Y");
2132 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2133 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2134 return Futures.immediateFuture(rpcResult);
2137 if (input.getSdncRequestHeader() != null) {
2138 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2139 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2142 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
2143 getVnfInstancePreloadData(preload_name, preload_type, vnfInstancePreloadDataBuilder);
2144 //preloadData = preloadDataBuilder.build();
2146 VnfInstancePreloadDataBuilder operDataBuilder = new VnfInstancePreloadDataBuilder();
2147 getVnfInstancePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
2150 // setup a preload-data object builder
2151 // ACTION vnf-topology-operation
2153 // USES sdnc-request-header;
2154 // USES request-information;
2155 // uses vnf-topology-information;
2157 // USES vnf-topology-response-body;
2159 // container preload-data
2160 // uses vnf-configuration-information;
2163 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
2164 PreloadVnfInstanceTopologyOperationInputBuilder inputBuilder = new PreloadVnfInstanceTopologyOperationInputBuilder(input);
2165 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2166 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
2167 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2169 // Call SLI sync method
2170 // Get SvcLogicService reference
2172 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
2173 Properties respProps = null;
2175 String errorCode = "200";
2176 String errorMessage = null;
2177 String ackFinal = "Y";
2182 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
2187 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", vnfInstancePreloadDataBuilder, parms);
2191 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
2192 errorMessage = e.getMessage();
2196 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2203 errorMessage = e.getMessage();
2204 log.error("Caught exception looking for service logic", e);
2208 if (respProps != null)
2210 errorCode = respProps.getProperty("error-code");
2211 errorMessage = respProps.getProperty("error-message");
2212 ackFinal = respProps.getProperty("ack-final", "Y");
2213 // internalError = respProps.getProperty("internal-error", "false");
2216 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2218 responseBuilder.setResponseCode(errorCode);
2219 responseBuilder.setResponseMessage(errorMessage);
2220 responseBuilder.setAckFinalIndicator(ackFinal);
2222 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2223 vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2224 vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2225 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadDataBuilder.build());
2226 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
2228 SaveVnfInstancePreloadList (vnfInstancePreloadListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
2229 } catch (Exception e) {
2230 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2232 log.debug("Sending Success rpc result due to external error");
2233 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2234 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2235 return Futures.immediateFuture(rpcResult);
2238 // Got success from SLI
2240 vnfInstancePreloadData = vnfInstancePreloadDataBuilder.build();
2241 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + vnfInstancePreloadData);
2242 // svc-configuration-list
2243 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2244 vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2245 vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2246 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadData);
2248 // SDNGC-989 set merge flag to false
2249 SaveVnfInstancePreloadList (vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2250 log.info("Updating OPERATIONAL tree.");
2251 SaveVnfInstancePreloadList (vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2252 } catch (Exception e) {
2253 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2254 responseBuilder.setResponseCode("500");
2255 responseBuilder.setResponseMessage(e.toString());
2256 responseBuilder.setAckFinalIndicator("Y");
2257 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2258 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2259 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2260 return Futures.immediateFuture(rpcResult);
2264 responseBuilder.setResponseCode(errorCode);
2265 responseBuilder.setAckFinalIndicator(ackFinal);
2266 if (errorMessage != null)
2268 responseBuilder.setResponseMessage(errorMessage);
2270 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
2271 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2273 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2274 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2275 return Futures.immediateFuture(rpcResult);
2279 //1610 preload-vf-module-topology-operation
2281 public Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2282 PreloadVfModuleTopologyOperationInput input) {
2284 final String SVC_OPERATION = "preload-vf-module-topology-operation";
2285 VfModulePreloadData vfModulePreloadData = null;
2286 Properties parms = new Properties();
2288 log.info( SVC_OPERATION +" called." );
2289 // create a new response object
2290 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder = new PreloadVfModuleTopologyOperationOutputBuilder();
2292 // Result from savePreloadData
2293 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2296 input.getVfModuleTopologyInformation() == null ||
2297 input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName() == null ||
2298 input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId() == null)
2300 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-instance-name and vnf-model-id");
2301 responseBuilder.setResponseCode("403");
2302 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name and vnf-model-id");
2303 responseBuilder.setAckFinalIndicator("Y");
2304 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2305 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2306 return Futures.immediateFuture(rpcResult);
2309 // Grab the name and type from the input buffer
2310 String preload_name = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName();
2311 String preload_type = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId();
2313 // Make sure we have a preload_name and preload_type
2314 if(preload_name == null || preload_name.length() == 0 ) {
2315 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-name");
2316 responseBuilder.setResponseCode("403");
2317 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2318 responseBuilder.setAckFinalIndicator("Y");
2319 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2320 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2321 return Futures.immediateFuture(rpcResult);
2323 if(preload_type == null || preload_type.length() == 0 ) {
2324 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-type");
2325 responseBuilder.setResponseCode("403");
2326 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2327 responseBuilder.setAckFinalIndicator("Y");
2328 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2329 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2330 return Futures.immediateFuture(rpcResult);
2333 if (input.getSdncRequestHeader() != null) {
2334 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2335 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2338 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
2339 getVfModulePreloadData(preload_name, preload_type, vfModulePreloadDataBuilder);
2340 //preloadData = preloadDataBuilder.build();
2342 VfModulePreloadDataBuilder operDataBuilder = new VfModulePreloadDataBuilder();
2343 getVfModulePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
2346 // setup a preload-data object builder
2347 // ACTION vnf-topology-operation
2349 // USES sdnc-request-header;
2350 // USES request-information;
2351 // uses vnf-topology-information;
2353 // USES vnf-topology-response-body;
2355 // container preload-data
2356 // uses vnf-configuration-information;
2359 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
2360 PreloadVfModuleTopologyOperationInputBuilder inputBuilder = new PreloadVfModuleTopologyOperationInputBuilder(input);
2361 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2362 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
2363 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2365 // Call SLI sync method
2366 // Get SvcLogicService reference
2368 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
2369 Properties respProps = null;
2371 String errorCode = "200";
2372 String errorMessage = null;
2373 String ackFinal = "Y";
2378 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
2383 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", vfModulePreloadDataBuilder, parms);
2387 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
2388 errorMessage = e.getMessage();
2392 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2399 errorMessage = e.getMessage();
2400 log.error("Caught exception looking for service logic", e);
2404 if (respProps != null)
2406 errorCode = respProps.getProperty("error-code");
2407 errorMessage = respProps.getProperty("error-message");
2408 ackFinal = respProps.getProperty("ack-final", "Y");
2409 // internalError = respProps.getProperty("internal-error", "false");
2412 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2414 responseBuilder.setResponseCode(errorCode);
2415 responseBuilder.setResponseMessage(errorMessage);
2416 responseBuilder.setAckFinalIndicator(ackFinal);
2418 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2419 vfModulePreloadListBuilder.setVfModuleName(preload_name);
2420 vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2421 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadDataBuilder.build());
2422 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
2424 SaveVfModulePreloadList (vfModulePreloadListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
2425 } catch (Exception e) {
2426 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2428 log.debug("Sending Success rpc result due to external error");
2429 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2430 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2431 return Futures.immediateFuture(rpcResult);
2434 // Got success from SLI
2436 vfModulePreloadData = vfModulePreloadDataBuilder.build();
2437 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + vfModulePreloadData);
2438 // svc-configuration-list
2439 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2440 vfModulePreloadListBuilder.setVfModuleName(preload_name);
2441 vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2442 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadData);
2444 // SDNGC-989 set merge flag to false
2445 SaveVfModulePreloadList (vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2446 log.info("Updating OPERATIONAL tree.");
2447 SaveVfModulePreloadList (vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2448 } catch (Exception e) {
2449 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2450 responseBuilder.setResponseCode("500");
2451 responseBuilder.setResponseMessage(e.toString());
2452 responseBuilder.setAckFinalIndicator("Y");
2453 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2454 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2455 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2456 return Futures.immediateFuture(rpcResult);
2460 responseBuilder.setResponseCode(errorCode);
2461 responseBuilder.setAckFinalIndicator(ackFinal);
2462 if (errorMessage != null)
2464 responseBuilder.setResponseMessage(errorMessage);
2466 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
2467 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2469 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2470 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2471 return Futures.immediateFuture(rpcResult);
2476 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2477 PreloadNetworkTopologyOperationInput input) {
2479 final String SVC_OPERATION = "preload-network-topology-operation";
2480 PreloadData preloadData = null;
2481 Properties parms = new Properties();
2483 log.info( SVC_OPERATION +" called." );
2484 // create a new response object
2485 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2487 // Result from savePreloadData
2488 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2490 if(input == null || input.getNetworkTopologyInformation() == null || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName() == null || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType() == null) {
2491 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-name and vnf-type");
2492 responseBuilder.setResponseCode("403");
2493 responseBuilder.setResponseMessage("input, null or empty vnf-name and vnf-type");
2494 responseBuilder.setAckFinalIndicator("Y");
2495 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2496 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2497 return Futures.immediateFuture(rpcResult);
2500 // Grab the name and type from the input buffer
2501 String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2502 String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2504 // Make sure we have a preload_name and preload_type
2505 if(preload_name == null || preload_name.length() == 0 ) {
2506 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-name");
2507 responseBuilder.setResponseCode("403");
2508 responseBuilder.setResponseMessage("input, invalid preload-name");
2509 responseBuilder.setAckFinalIndicator("Y");
2510 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2511 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2512 return Futures.immediateFuture(rpcResult);
2514 if(preload_type == null || preload_type.length() == 0 ) {
2515 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-type");
2516 responseBuilder.setResponseCode("403");
2517 responseBuilder.setResponseMessage("input, invalid preload-type");
2518 responseBuilder.setAckFinalIndicator("Y");
2519 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2520 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2521 return Futures.immediateFuture(rpcResult);
2524 if (input.getSdncRequestHeader() != null) {
2525 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2526 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2529 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2530 getPreloadData(preload_name, preload_type, preloadDataBuilder);
2532 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2533 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
2536 // setup a preload-data object builder
2537 // ACTION vnf-topology-operation
2539 // USES sdnc-request-header;
2540 // USES request-information;
2541 // uses vnf-topology-information;
2543 // USES vnf-topology-response-body;
2545 // container preload-data
2546 // uses vnf-configuration-information;
2549 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
2550 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(input);
2551 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2552 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
2553 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2555 // Call SLI sync method
2556 // Get SvcLogicService reference
2558 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
2559 Properties respProps = null;
2561 String errorCode = "200";
2562 String errorMessage = null;
2563 String ackFinal = "Y";
2568 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
2573 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2577 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
2578 errorMessage = e.getMessage();
2582 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2589 errorMessage = e.getMessage();
2590 log.error("Caught exception looking for service logic", e);
2594 if (respProps != null)
2596 errorCode = respProps.getProperty("error-code");
2597 errorMessage = respProps.getProperty("error-message");
2598 ackFinal = respProps.getProperty("ack-final", "Y");
2599 // internalError = respProps.getProperty("internal-error", "false");
2602 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2604 responseBuilder.setResponseCode(errorCode);
2605 responseBuilder.setResponseMessage(errorMessage);
2606 responseBuilder.setAckFinalIndicator(ackFinal);
2608 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2609 preloadVnfListBuilder.setVnfName(preload_name);
2610 preloadVnfListBuilder.setVnfType(preload_type);
2611 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2612 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
2614 SavePreloadList (preloadVnfListBuilder.build(),true,LogicalDatastoreType.CONFIGURATION);
2615 } catch (Exception e) {
2616 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2619 log.debug("Sending Success rpc result due to external error");
2620 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2621 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2622 return Futures.immediateFuture(rpcResult);
2625 // Got success from SLI
2627 preloadData = preloadDataBuilder.build();
2628 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + preloadData);
2629 // svc-configuration-list
2630 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2631 preloadVnfListBuilder.setVnfName(preload_name);
2632 preloadVnfListBuilder.setVnfType(preload_type);
2633 preloadVnfListBuilder.setPreloadData(preloadData);
2635 // SDNGC-989 set merge flag to false
2636 SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2637 log.info("Updating OPERATIONAL tree.");
2638 SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2639 } catch (Exception e) {
2640 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2641 responseBuilder.setResponseCode("500");
2642 responseBuilder.setResponseMessage(e.toString());
2643 responseBuilder.setAckFinalIndicator("Y");
2644 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2645 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2646 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2647 return Futures.immediateFuture(rpcResult);
2651 responseBuilder.setResponseCode(errorCode);
2652 responseBuilder.setAckFinalIndicator(ackFinal);
2653 if (errorMessage != null)
2655 responseBuilder.setResponseMessage(errorMessage);
2657 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
2658 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2660 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2661 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2662 return Futures.immediateFuture(rpcResult);