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.md.sal.binding.api.NotificationPublishService;
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 NotificationPublishService notificationService;
169 protected RpcProviderRegistry rpcRegistry;
170 protected BindingAwareBroker.RpcRegistration<VNFAPIService> rpcRegistration;
174 public vnfapiProvider(DataBroker dataBroker2, NotificationPublishService notificationPublishService,
175 RpcProviderRegistry rpcProviderRegistry) {
176 this.log.info( "Creating provider for " + appName );
177 executor = Executors.newFixedThreadPool(1);
178 dataBroker = dataBroker2;
179 notificationService = notificationPublishService;
180 rpcRegistry = rpcProviderRegistry;
185 public void initialize(){
186 log.info( "Initializing provider for " + appName );
187 // Create the top level containers
190 VnfSdnUtil.loadProperties();
191 } catch (Exception e) {
192 log.error("Caught Exception while trying to load properties file: ", e);
194 rpcRegistration = rpcRegistry.addRpcImplementation(VNFAPIService.class, this);
196 log.info( "Initialization complete for " + appName );
199 private void createContainers() {
200 final WriteTransaction t = dataBroker.newReadWriteTransaction();
202 // Create the Vnfs container
203 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Vnfs.class),
204 new VnfsBuilder().build());
205 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Vnfs.class),
206 new VnfsBuilder().build());
208 // Create the PreloadVnfs container
209 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
210 new PreloadVnfsBuilder().build());
211 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
212 new PreloadVnfsBuilder().build());
214 // 1610 Create the PreloadVnfInstances container
215 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfInstances.class),
216 new PreloadVnfInstancesBuilder().build());
217 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfInstances.class),
218 new PreloadVnfInstancesBuilder().build());
220 // 1610 Create the VnfInstances container
221 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VnfInstances.class),
222 new VnfInstancesBuilder().build());
223 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VnfInstances.class),
224 new VnfInstancesBuilder().build());
226 // 1610 Create the PreloadVfModules container
227 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVfModules.class),
228 new PreloadVfModulesBuilder().build());
229 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVfModules.class),
230 new PreloadVfModulesBuilder().build());
232 // 1610 Create the VfModules container
233 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VfModules.class),
234 new VfModulesBuilder().build());
235 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VfModules.class),
236 new VfModulesBuilder().build());
239 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
241 log.info("Create Containers succeeded!: ");
243 } catch (InterruptedException | ExecutionException e) {
244 log.error("Create Containers Failed: " + e);
250 protected void initializeChild() {
251 //Override if you have custom initialization intelligence
255 public void close() throws Exception {
256 log.info( "Closing provider for " + appName );
258 rpcRegistration.close();
259 // dclServices.close();
260 log.info( "Successfully closed provider for " + appName );
263 // On data change not used
265 public void onDataChanged(
266 AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
267 boolean changed = false;
268 log.info(" IN ON DATA CHANGE: ");
269 WriteTransaction writeTransaction = dataBroker
270 .newWriteOnlyTransaction();
272 DataObject updatedSubTree = change.getUpdatedSubtree();
274 if (updatedSubTree != null) {
275 if (log.isDebugEnabled())
277 log.debug("updatedSubTree was non-null:" + updatedSubTree);
279 if ( updatedSubTree instanceof Vnfs ) {
280 ArrayList<VnfList> vnfList = (ArrayList<VnfList>) ((Vnfs) updatedSubTree).getVnfList();
281 if (vnfList != null) {
282 for (VnfList entry : vnfList) {
283 ServiceData serviceData = entry.getServiceData();
284 ServiceStatus serviceStatus = entry.getServiceStatus();
285 if (serviceData != null && serviceStatus != null) {
287 // ServiceData change detected, check the AckFinal indicator and request-status to see if we need to proceed.
289 if ((! "Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete.equals(serviceStatus.getRequestStatus()))) {
290 if (log.isDebugEnabled())
292 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
294 //handleServiceDataUpdated(serviceData, serviceStatus, writeTransaction);
301 if ( updatedSubTree instanceof PreloadVnfs ) {
302 ArrayList<VnfPreloadList> vnfList = (ArrayList<VnfPreloadList>) ((PreloadVnfs) updatedSubTree).getVnfPreloadList();
303 if (vnfList != null) {
304 for (VnfPreloadList entry : vnfList) {
305 PreloadData preloadData = entry.getPreloadData();
306 if (preloadData != null ) {
308 // PreloadData change detected
310 // handlePreloadDataUpdated(preloadData, writeTransaction);
317 if ( updatedSubTree instanceof PreloadVnfInstances ) {
318 ArrayList<VnfInstancePreloadList> vnfInstanceList = (ArrayList<VnfInstancePreloadList>) ((PreloadVnfInstances) updatedSubTree).getVnfInstancePreloadList();
319 if (vnfInstanceList != null) {
320 for (VnfInstancePreloadList entry : vnfInstanceList) {
321 VnfInstancePreloadData vnfInstancePreloadData = entry.getVnfInstancePreloadData();
322 if (vnfInstancePreloadData != null ) {
324 // PreloadData change detected
326 // handlePreloadDataUpdated(preloadData, writeTransaction);
333 if ( updatedSubTree instanceof VnfInstances ) {
334 ArrayList<VnfInstanceList> vnfInstanceList = (ArrayList<VnfInstanceList>) ((VnfInstances) updatedSubTree).getVnfInstanceList();
335 if (vnfInstanceList != null) {
336 for (VnfInstanceList entry : vnfInstanceList) {
337 VnfInstanceServiceData vnfInstanceServiceData = entry.getVnfInstanceServiceData();
338 ServiceStatus serviceStatus = entry.getServiceStatus();
339 if (vnfInstanceServiceData != null && serviceStatus != null) {
341 // VnfInstanceServiceData change detected, check the AckFinal indicator and request-status to see if we need to proceed.
343 if ((! "Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete.equals(serviceStatus.getRequestStatus()))) {
344 if (log.isDebugEnabled())
346 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
348 //handleServiceDataUpdated(serviceData, serviceStatus, writeTransaction);
356 if ( updatedSubTree instanceof PreloadVfModules ) {
357 ArrayList<VfModulePreloadList> vnfInstanceList = (ArrayList<VfModulePreloadList>) ((PreloadVfModules) updatedSubTree).getVfModulePreloadList();
358 if (vnfInstanceList != null) {
359 for (VfModulePreloadList entry : vnfInstanceList) {
360 VfModulePreloadData vnfInstancePreloadData = entry.getVfModulePreloadData();
361 if (vnfInstancePreloadData != null ) {
363 // PreloadData change detected
365 // handlePreloadDataUpdated(preloadData, writeTransaction);
372 if ( updatedSubTree instanceof VfModules ) {
373 ArrayList<VfModuleList> vfModuleList = (ArrayList<VfModuleList>) ((VfModules) updatedSubTree).getVfModuleList();
374 if (vfModuleList != null) {
375 for (VfModuleList entry : vfModuleList) {
376 VfModuleServiceData vfModuleServiceData = entry.getVfModuleServiceData();
377 ServiceStatus serviceStatus = entry.getServiceStatus();
378 if (vfModuleServiceData != null && serviceStatus != null) {
380 // VfModuleServiceData change detected, check the AckFinal indicator and request-status to see if we need to proceed.
382 if ((! "Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete.equals(serviceStatus.getRequestStatus()))) {
383 if (log.isDebugEnabled())
385 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
387 //handleServiceDataUpdated(serviceData, serviceStatus, writeTransaction);
395 // Do the write transaction only if something changed.
397 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = writeTransaction
399 Futures.addCallback(checkedFuture, new FutureCallback<Void>() {
402 public void onSuccess(Void arg0) {
403 log.debug("Successfully updated Service Status");
407 public void onFailure(Throwable ex) {
409 "Failed updating Service Status",
416 private static class Iso8601Util
418 private static TimeZone tz = TimeZone.getTimeZone("UTC");
419 private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
426 private static String now()
428 return df.format(new Date());
432 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage, String ackFinal)
434 serviceStatusBuilder.setResponseCode(errorCode);
435 serviceStatusBuilder.setResponseMessage(errorMessage);
436 serviceStatusBuilder.setFinalIndicator(ackFinal);
437 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
440 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation)
442 if (requestInformation != null && requestInformation.getRequestAction() != null) {
443 switch (requestInformation.getRequestAction())
445 case VNFActivateRequest:
446 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VNFActivateRequest);
448 case ChangeVNFActivateRequest:
449 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVNFActivateRequest);
451 case DisconnectVNFRequest:
452 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVNFRequest);
454 case PreloadVNFRequest:
455 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVNFRequest);
457 case DeletePreloadVNFRequest:
458 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DeletePreloadVNFRequest);
460 // 1610 vnf-instance Requests
461 case VnfInstanceActivateRequest:
462 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VnfInstanceActivateRequest);
464 case ChangeVnfInstanceActivateRequest:
465 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVnfInstanceActivateRequest);
467 case DisconnectVnfInstanceRequest:
468 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVnfInstanceRequest);
470 case PreloadVnfInstanceRequest:
471 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVnfInstanceRequest);
473 // 1610 vf-module Requests
474 case VfModuleActivateRequest:
475 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VfModuleActivateRequest);
477 case ChangeVfModuleActivateRequest:
478 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVfModuleActivateRequest);
480 case DisconnectVfModuleRequest:
481 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVfModuleRequest);
483 case PreloadVfModuleRequest:
484 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVfModuleRequest);
487 log.error("Unknown RequestAction: " + requestInformation.getRequestAction() );
491 if (requestInformation != null && requestInformation.getRequestSubAction() != null) {
492 switch (requestInformation.getRequestSubAction())
495 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP);
498 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
501 log.error("Unknown RequestSubAction: " + requestInformation.getRequestSubAction() );
507 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader)
509 if (requestHeader != null && requestHeader.getSvcAction() != null) {
510 switch (requestHeader.getSvcAction())
513 serviceStatusBuilder.setRpcAction(RpcAction.Reserve);
516 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
519 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
522 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
525 serviceStatusBuilder.setRpcAction(RpcAction.Changeassign);
528 serviceStatusBuilder.setRpcAction(RpcAction.Changedelete);
531 serviceStatusBuilder.setRpcAction(RpcAction.Rollback);
534 log.error("Unknown SvcAction: " + requestHeader.getSvcAction() );
540 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder)
543 getServiceData(siid,serviceDataBuilder,LogicalDatastoreType.CONFIGURATION);
547 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type)
549 // See if any data exists yet for this siid, if so grab it.
550 InstanceIdentifier serviceInstanceIdentifier =
551 InstanceIdentifier.<Vnfs>builder(Vnfs.class)
552 .child(VnfList.class, new VnfListKey(siid)).build();
553 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
554 Optional<VnfList> data = null;
556 data = (Optional<VnfList>) readTx.read(type, serviceInstanceIdentifier).get();
557 } catch (InterruptedException | ExecutionException e) {
558 log.error("Caught Exception reading MD-SAL ("+type+") for ["+siid+"] " ,e);
561 if (data != null && data.isPresent()) {
562 ServiceData serviceData = (ServiceData) data.get().getServiceData();
563 if (serviceData != null) {
564 log.info("Read MD-SAL ("+type+") data for ["+siid+"] ServiceData: " + serviceData);
565 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
566 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
567 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
568 serviceDataBuilder.setVnfRequestInformation(serviceData.getVnfRequestInformation());
569 serviceDataBuilder.setVnfId(serviceData.getVnfId());
570 serviceDataBuilder.setVnfTopologyInformation(serviceData.getVnfTopologyInformation());
571 serviceDataBuilder.setOperStatus(serviceData.getOperStatus());
573 log.info("No service-data found in MD-SAL ("+type+") for ["+siid+"] ");
576 log.info("No data found in MD-SAL ("+type+") for ["+siid+"] ");
581 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder)
584 getVnfInstanceServiceData(siid,vnfInstanceServiceDataBuilder,LogicalDatastoreType.CONFIGURATION);
587 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder, LogicalDatastoreType type)
589 // See if any data exists yet for this siid, if so grab it.
590 InstanceIdentifier vnfInstanceIdentifier =
591 InstanceIdentifier.<VnfInstances>builder(VnfInstances.class)
592 .child(VnfInstanceList.class, new VnfInstanceListKey(siid)).build();
593 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
594 Optional<VnfInstanceList> data = null;
596 data = (Optional<VnfInstanceList>) readTx.read(type, vnfInstanceIdentifier).get();
597 } catch (InterruptedException | ExecutionException e) {
598 log.error("Caught Exception reading MD-SAL ("+type+") for ["+siid+"] " ,e);
601 if (data != null && data.isPresent()) {
602 VnfInstanceServiceData vnfInstanceServiceData = (VnfInstanceServiceData) data.get().getVnfInstanceServiceData();
603 if (vnfInstanceServiceData != null) {
604 log.info("Read MD-SAL ("+type+") data for ["+siid+"] VnfInstanceServiceData: " + vnfInstanceServiceData);
605 vnfInstanceServiceDataBuilder.setSdncRequestHeader(vnfInstanceServiceData.getSdncRequestHeader());
606 vnfInstanceServiceDataBuilder.setRequestInformation(vnfInstanceServiceData.getRequestInformation());
607 vnfInstanceServiceDataBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
608 vnfInstanceServiceDataBuilder.setVnfInstanceRequestInformation(vnfInstanceServiceData.getVnfInstanceRequestInformation());
609 vnfInstanceServiceDataBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
610 vnfInstanceServiceDataBuilder.setVnfInstanceTopologyInformation(vnfInstanceServiceData.getVnfInstanceTopologyInformation());
611 vnfInstanceServiceDataBuilder.setOperStatus(vnfInstanceServiceData.getOperStatus());
613 log.info("No vnf-instance-service-data found in MD-SAL ("+type+") for ["+siid+"] ");
616 log.info("No data found in MD-SAL ("+type+") for ["+siid+"] ");
621 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder)
624 getVfModuleServiceData(siid,vfModuleServiceDataBuilder,LogicalDatastoreType.CONFIGURATION);
627 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder, LogicalDatastoreType type)
629 // See if any data exists yet for this siid, if so grab it.
630 InstanceIdentifier vfModuleIdentifier =
631 InstanceIdentifier.<VfModules>builder(VfModules.class)
632 .child(VfModuleList.class, new VfModuleListKey(siid)).build();
633 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
634 Optional<VfModuleList> data = null;
636 data = (Optional<VfModuleList>) readTx.read(type, vfModuleIdentifier).get();
637 } catch (InterruptedException | ExecutionException e) {
638 log.error("Caught Exception reading MD-SAL ("+type+") for ["+siid+"] " ,e);
641 if (data != null && data.isPresent()) {
642 VfModuleServiceData vfModuleServiceData = (VfModuleServiceData) data.get().getVfModuleServiceData();
643 if (vfModuleServiceData != null) {
644 log.info("Read MD-SAL ("+type+") data for ["+siid+"] VfModuleServiceData: " + vfModuleServiceData);
645 vfModuleServiceDataBuilder.setSdncRequestHeader(vfModuleServiceData.getSdncRequestHeader());
646 vfModuleServiceDataBuilder.setRequestInformation(vfModuleServiceData.getRequestInformation());
647 vfModuleServiceDataBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
648 vfModuleServiceDataBuilder.setVfModuleRequestInformation(vfModuleServiceData.getVfModuleRequestInformation());
649 vfModuleServiceDataBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
650 vfModuleServiceDataBuilder.setVfModuleTopologyInformation(vfModuleServiceData.getVfModuleTopologyInformation());
651 vfModuleServiceDataBuilder.setOperStatus(vfModuleServiceData.getOperStatus());
653 log.info("No vf-module-service-data found in MD-SAL ("+type+") for ["+siid+"] ");
656 log.info("No data found in MD-SAL ("+type+") for ["+siid+"] ");
661 private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder)
664 getPreloadData(vnf_name, vnf_type ,preloadDataBuilder,LogicalDatastoreType.CONFIGURATION);
667 private void getPreloadData(String preload_name, String preload_type, PreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type)
669 // See if any data exists yet for this name/type, if so grab it.
670 InstanceIdentifier preloadInstanceIdentifier =
671 InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
672 .child(VnfPreloadList.class, new VnfPreloadListKey(preload_name, preload_type)).build();
673 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
674 Optional<VnfPreloadList> data = null;
676 data = (Optional<VnfPreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
677 } catch (InterruptedException | ExecutionException e) {
678 log.error("Caught Exception reading MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] " ,e);
681 if (data != null && data.isPresent()) {
682 PreloadData preloadData = (PreloadData) data.get().getPreloadData();
683 if (preloadData != null) {
684 log.info("Read MD-SAL ("+type+") data for ["+preload_name+","+preload_type+"] PreloadData: " + preloadData);
685 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
686 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
687 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
689 log.info("No preload-data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
692 log.info("No data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
696 //1610 preload-vnf-instance
697 private void getVnfInstancePreloadData(String vnf_name, String vnf_type, VnfInstancePreloadDataBuilder preloadDataBuilder)
700 getVnfInstancePreloadData(vnf_name, vnf_type ,preloadDataBuilder,LogicalDatastoreType.CONFIGURATION);
703 //1610 preload-vnf-instance
704 private void getVnfInstancePreloadData(String preload_name, String preload_type, VnfInstancePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type)
706 // See if any data exists yet for this name/type, if so grab it.
707 InstanceIdentifier preloadInstanceIdentifier =
708 InstanceIdentifier.<PreloadVnfInstances>builder(PreloadVnfInstances.class)
709 .child(VnfInstancePreloadList.class, new VnfInstancePreloadListKey(preload_name, preload_type)).build();
710 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
711 Optional<VnfInstancePreloadList> data = null;
713 data = (Optional<VnfInstancePreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
714 } catch (InterruptedException | ExecutionException e) {
715 log.error("Caught Exception reading MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] " ,e);
718 if (data != null && data.isPresent()) {
719 VnfInstancePreloadData preloadData = (VnfInstancePreloadData) data.get().getVnfInstancePreloadData();
720 if (preloadData != null) {
721 log.info("Read MD-SAL ("+type+") data for ["+preload_name+","+preload_type+"] VnfInstancePreloadData: " + preloadData);
722 preloadDataBuilder.setVnfInstanceTopologyInformation(preloadData.getVnfInstanceTopologyInformation());
723 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
725 log.info("No vnf-instance-preload-data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
728 log.info("No data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
732 // 1610 preload-vf-module
733 private void getVfModulePreloadData(String vnf_name, String vnf_type, VfModulePreloadDataBuilder preloadDataBuilder)
736 getVfModulePreloadData(vnf_name, vnf_type ,preloadDataBuilder,LogicalDatastoreType.CONFIGURATION);
739 private void getVfModulePreloadData(String preload_name, String preload_type, VfModulePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type)
741 // See if any data exists yet for this name/type, if so grab it.
742 InstanceIdentifier preloadInstanceIdentifier =
743 InstanceIdentifier.<PreloadVfModules>builder(PreloadVfModules.class)
744 .child(VfModulePreloadList.class, new VfModulePreloadListKey(preload_name, preload_type)).build();
745 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
746 Optional<VfModulePreloadList> data = null;
748 data = (Optional<VfModulePreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
749 } catch (InterruptedException | ExecutionException e) {
750 log.error("Caught Exception reading MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] " ,e);
753 if (data != null && data.isPresent()) {
754 VfModulePreloadData preloadData = (VfModulePreloadData) data.get().getVfModulePreloadData();
755 if (preloadData != null) {
756 log.info("Read MD-SAL ("+type+") data for ["+preload_name+","+preload_type+"] VfModulePreloadData: " + preloadData);
757 preloadDataBuilder.setVfModuleTopologyInformation(preloadData.getVfModuleTopologyInformation());
758 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
760 log.info("No preload-data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
763 log.info("No data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
767 private void SaveVnfList (final VnfList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException {
768 // Each entry will be identifiable by a unique key, we have to create that identifier
769 InstanceIdentifier.InstanceIdentifierBuilder<VnfList> vnfListIdBuilder =
770 InstanceIdentifier.<Vnfs>builder(Vnfs.class)
771 .child(VnfList.class, entry.getKey());
772 InstanceIdentifier<VnfList> path = vnfListIdBuilder.build();
777 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
779 tx.merge(storeType, path, entry);
781 tx.put(storeType, path, entry);
783 tx.submit().checkedGet();
784 log.debug("Update DataStore succeeded");
786 } catch (final TransactionCommitFailedException e) {
787 if(e instanceof OptimisticLockFailedException) {
789 log.debug("Got OptimisticLockFailedException on last try - failing ");
790 throw new IllegalStateException(e);
792 log.debug("Got OptimisticLockFailedException - trying again ");
794 log.debug("Update DataStore failed");
795 throw new IllegalStateException(e);
801 private void DeleteVnfList (final VnfList entry, LogicalDatastoreType storeType) throws IllegalStateException {
802 // Each entry will be identifiable by a unique key, we have to create that identifier
803 InstanceIdentifier.InstanceIdentifierBuilder<VnfList> vnfListIdBuilder =
804 InstanceIdentifier.<Vnfs>builder(Vnfs.class)
805 .child(VnfList.class, entry.getKey());
806 InstanceIdentifier<VnfList> path = vnfListIdBuilder.build();
811 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
812 tx.delete(storeType, path);
813 tx.submit().checkedGet();
814 log.debug("DataStore delete succeeded");
816 } catch (final TransactionCommitFailedException e) {
817 if (e instanceof OptimisticLockFailedException) {
819 log.debug("Got OptimisticLockFailedException on last try - failing ");
820 throw new IllegalStateException(e);
822 log.debug("Got OptimisticLockFailedException - trying again ");
824 log.debug("Delete DataStore failed");
825 throw new IllegalStateException(e);
832 private void SaveVnfInstanceList (final VnfInstanceList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException {
833 // Each entry will be identifiable by a unique key, we have to create that identifier
834 InstanceIdentifier.InstanceIdentifierBuilder<VnfInstanceList> vnfInstanceListIdBuilder =
835 InstanceIdentifier.<VnfInstances>builder(VnfInstances.class)
836 .child(VnfInstanceList.class, entry.getKey());
837 InstanceIdentifier<VnfInstanceList> path = vnfInstanceListIdBuilder.build();
842 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
844 tx.merge(storeType, path, entry);
846 tx.put(storeType, path, entry);
848 tx.submit().checkedGet();
849 log.debug("Update DataStore succeeded");
851 } catch (final TransactionCommitFailedException e) {
852 if(e instanceof OptimisticLockFailedException) {
854 log.debug("Got OptimisticLockFailedException on last try - failing ");
855 throw new IllegalStateException(e);
857 log.debug("Got OptimisticLockFailedException - trying again ");
859 log.debug("Update DataStore failed");
860 throw new IllegalStateException(e);
867 private void SaveVfModuleList (final VfModuleList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException {
868 // Each entry will be identifiable by a unique key, we have to create that identifier
869 InstanceIdentifier.InstanceIdentifierBuilder<VfModuleList> vfModuleListIdBuilder =
870 InstanceIdentifier.<VfModules>builder(VfModules.class)
871 .child(VfModuleList.class, entry.getKey());
872 InstanceIdentifier<VfModuleList> path = vfModuleListIdBuilder.build();
877 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
879 tx.merge(storeType, path, entry);
881 tx.put(storeType, path, entry);
883 tx.submit().checkedGet();
884 log.debug("Update DataStore succeeded");
886 } catch (final TransactionCommitFailedException e) {
887 if(e instanceof OptimisticLockFailedException) {
889 log.debug("Got OptimisticLockFailedException on last try - failing ");
890 throw new IllegalStateException(e);
892 log.debug("Got OptimisticLockFailedException - trying again ");
894 log.debug("Update DataStore failed");
895 throw new IllegalStateException(e);
901 private void SavePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException{
903 // Each entry will be identifiable by a unique key, we have to create that identifier
904 InstanceIdentifier.InstanceIdentifierBuilder<VnfPreloadList> vnfListIdBuilder =
905 InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
906 .child(VnfPreloadList.class, entry.getKey());
907 InstanceIdentifier<VnfPreloadList> path = vnfListIdBuilder.build();
911 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
913 tx.merge(storeType, path, entry);
915 tx.put(storeType, path, entry);
917 tx.submit().checkedGet();
918 log.debug("Update DataStore succeeded");
920 } catch (final TransactionCommitFailedException e) {
921 if(e instanceof OptimisticLockFailedException) {
923 log.debug("Got OptimisticLockFailedException on last try - failing ");
924 throw new IllegalStateException(e);
926 log.debug("Got OptimisticLockFailedException - trying again ");
928 log.debug("Update DataStore failed");
929 throw new IllegalStateException(e);
935 //1610 preload vnf-instance
936 private void SaveVnfInstancePreloadList(final VnfInstancePreloadList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException{
938 // Each entry will be identifiable by a unique key, we have to create that identifier
939 InstanceIdentifier.InstanceIdentifierBuilder<VnfInstancePreloadList> vnfInstanceListIdBuilder =
940 InstanceIdentifier.<PreloadVnfInstances>builder(PreloadVnfInstances.class)
941 .child(VnfInstancePreloadList.class, entry.getKey());
942 InstanceIdentifier<VnfInstancePreloadList> path = vnfInstanceListIdBuilder.build();
946 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
948 tx.merge(storeType, path, entry);
950 tx.put(storeType, path, entry);
952 tx.submit().checkedGet();
953 log.debug("Update DataStore succeeded");
955 } catch (final TransactionCommitFailedException e) {
956 if(e instanceof OptimisticLockFailedException) {
958 log.debug("Got OptimisticLockFailedException on last try - failing ");
959 throw new IllegalStateException(e);
961 log.debug("Got OptimisticLockFailedException - trying again ");
963 log.debug("Update DataStore failed");
964 throw new IllegalStateException(e);
970 //1610 preload vf-module
971 private void SaveVfModulePreloadList(final VfModulePreloadList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException{
973 // Each entry will be identifiable by a unique key, we have to create that identifier
974 InstanceIdentifier.InstanceIdentifierBuilder<VfModulePreloadList> vfModuleListIdBuilder =
975 InstanceIdentifier.<PreloadVfModules>builder(PreloadVfModules.class)
976 .child(VfModulePreloadList.class, entry.getKey());
977 InstanceIdentifier<VfModulePreloadList> path = vfModuleListIdBuilder.build();
981 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
983 tx.merge(storeType, path, entry);
985 tx.put(storeType, path, entry);
987 tx.submit().checkedGet();
988 log.debug("Update DataStore succeeded");
990 } catch (final TransactionCommitFailedException e) {
991 if(e instanceof OptimisticLockFailedException) {
993 log.debug("Got OptimisticLockFailedException on last try - failing ");
994 throw new IllegalStateException(e);
996 log.debug("Got OptimisticLockFailedException - trying again ");
998 log.debug("Update DataStore failed");
999 throw new IllegalStateException(e);
1005 //Save the requestId into MDC
1006 private void setRequestIdAsMDC(String requestId){
1007 MDC.put("RequestId", requestId);
1010 //1610 vnf-instance-topology-operation
1012 public Future<RpcResult<VnfInstanceTopologyOperationOutput>> vnfInstanceTopologyOperation(
1013 VnfInstanceTopologyOperationInput input) {
1015 final String SVC_OPERATION = "vnf-instance-topology-operation";
1016 VnfInstanceServiceData vnfInstanceServiceData = null;
1017 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1018 Properties parms = new Properties();
1020 log.info( SVC_OPERATION +" called." );
1021 // create a new response object
1022 VnfInstanceTopologyOperationOutputBuilder responseBuilder = new VnfInstanceTopologyOperationOutputBuilder();
1024 //if(input == null || input.getVnfInstanceRequestInformation().getVnfInstanceTopologyIdentifier().getVnfInstanceId() == null )
1026 input.getVnfInstanceRequestInformation() == null ||
1027 input.getVnfInstanceRequestInformation().getVnfInstanceId() == null )
1029 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-instance-id");
1030 responseBuilder.setResponseCode("403");
1031 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1032 responseBuilder.setAckFinalIndicator("Y");
1033 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1034 RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1036 return Futures.immediateFuture(rpcResult);
1039 // Grab the service instance ID from the input buffer
1040 String viid = input.getVnfInstanceRequestInformation().getVnfInstanceId();
1041 String preload_name = input.getVnfInstanceRequestInformation().getVnfInstanceName();
1042 String preload_type = input.getVnfInstanceRequestInformation().getVnfModelId();
1044 // Make sure we have a valid viid
1045 if(viid == null || viid.length() == 0 ) {
1046 log.debug("exiting "+SVC_OPERATION+" because of invalid vnf-instance-id");
1047 responseBuilder.setResponseCode("403");
1048 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1049 responseBuilder.setAckFinalIndicator("Y");
1050 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1051 RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1053 return Futures.immediateFuture(rpcResult);
1056 if (input.getSdncRequestHeader() != null) {
1057 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1058 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1061 // Get vnf-instance-preload-data
1062 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
1063 getVnfInstancePreloadData(preload_name, preload_type, vnfInstancePreloadDataBuilder);
1066 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1067 getVnfInstanceServiceData(viid,vnfInstanceServiceDataBuilder);
1069 // Get operational-data
1070 VnfInstanceServiceDataBuilder operDataBuilder = new VnfInstanceServiceDataBuilder();
1071 getVnfInstanceServiceData(viid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1073 // Set the serviceStatus based on input
1074 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1075 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1078 // setup a service-data object builder
1079 // ACTION vnf-topology-operation
1081 // USES sdnc-request-header;
1082 // USES request-information;
1083 // USES service-information;
1084 // USES vnf-request-information
1086 // USES vnf-topology-response-body;
1087 // USES vnf-information
1088 // USES service-information
1090 // container service-data
1091 // uses vnf-configuration-information;
1092 // uses oper-status;
1094 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+viid+"] input: " + input);
1095 VnfInstanceTopologyOperationInputBuilder inputBuilder = new VnfInstanceTopologyOperationInputBuilder(input);
1096 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1098 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+viid+"] operational-data: " + operDataBuilder.build());
1099 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1101 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " + vnfInstancePreloadDataBuilder.build());
1102 VnfSdnUtil.toProperties(parms, "vnf-instance-preload-data", vnfInstancePreloadDataBuilder);
1104 // Call SLI sync method
1105 // Get SvcLogicService reference
1107 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
1108 Properties respProps = null;
1110 String errorCode = "200";
1111 String errorMessage = null;
1112 String ackFinal = "Y";
1117 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1122 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", vnfInstanceServiceDataBuilder, parms);
1126 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1127 errorMessage = e.getMessage();
1131 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1138 errorMessage = e.getMessage();
1139 log.error("Caught exception looking for service logic", e);
1143 if (respProps != null)
1145 errorCode = respProps.getProperty("error-code");
1146 errorMessage = respProps.getProperty("error-message");
1147 ackFinal = respProps.getProperty("ack-final", "Y");
1150 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
1151 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1152 serviceStatusBuilder.setRpcName(RpcName.VnfInstanceTopologyOperation);
1154 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1155 responseBuilder.setResponseCode(errorCode);
1156 responseBuilder.setResponseMessage(errorMessage);
1157 responseBuilder.setAckFinalIndicator(ackFinal);
1158 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1159 vnfInstanceListBuilder.setVnfInstanceId(viid);
1160 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1162 SaveVnfInstanceList (vnfInstanceListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
1163 } catch (Exception e) {
1164 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+viid+"] \n",e);
1166 log.error("Returned FAILED for "+SVC_OPERATION+" ["+viid+"] " + responseBuilder.build());
1167 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1168 RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1170 return Futures.immediateFuture(rpcResult);
1173 // Got success from SLI
1175 vnfInstanceServiceData = vnfInstanceServiceDataBuilder.build();
1176 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+viid+"] VnfInstanceServiceData: " + vnfInstanceServiceData);
1177 // svc-configuration-list
1178 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1179 vnfInstanceListBuilder.setVnfInstanceServiceData(vnfInstanceServiceData);
1180 vnfInstanceListBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
1181 //siid = vnfInstanceServiceData.getVnfInstanceId();
1182 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1183 SaveVnfInstanceList (vnfInstanceListBuilder.build(), false,LogicalDatastoreType.CONFIGURATION);
1184 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1186 // Only update operational tree on Delete or Activate
1187 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
1188 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1190 log.info("Updating OPERATIONAL tree.");
1191 SaveVnfInstanceList (vnfInstanceListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1194 VnfInstanceInformationBuilder vnfInstanceInformationBuilder = new VnfInstanceInformationBuilder();
1195 vnfInstanceInformationBuilder.setVnfInstanceId(viid);
1196 responseBuilder.setVnfInstanceInformation(vnfInstanceInformationBuilder.build());
1197 responseBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
1198 } catch (Exception e) {
1199 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+viid+"] \n",e);
1200 responseBuilder.setResponseCode("500");
1201 responseBuilder.setResponseMessage(e.toString());
1202 responseBuilder.setAckFinalIndicator("Y");
1203 log.error("Returned FAILED for "+SVC_OPERATION+" ["+viid+"] " + responseBuilder.build());
1204 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1205 RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1207 return Futures.immediateFuture(rpcResult);
1211 responseBuilder.setResponseCode(errorCode);
1212 responseBuilder.setAckFinalIndicator(ackFinal);
1213 if (errorMessage != null)
1215 responseBuilder.setResponseMessage(errorMessage);
1217 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+viid+"] ");
1218 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+viid+"] " + responseBuilder.build());
1220 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1221 RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1223 return Futures.immediateFuture(rpcResult);
1226 //1610 vf-module-topology-operation
1228 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1229 VfModuleTopologyOperationInput input) {
1231 final String SVC_OPERATION = "vf-module-topology-operation";
1232 VfModuleServiceData vfModuleServiceData = null;
1233 VnfInstanceServiceData vnfInstanceServiceData = null;
1234 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1235 Properties parms = new Properties();
1237 log.info( SVC_OPERATION +" called." );
1238 // create a new response object
1239 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1241 // Validate vf-module-id from vf-module-request-information
1243 input.getVfModuleRequestInformation() == null ||
1244 input.getVfModuleRequestInformation().getVfModuleId() == null)
1246 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vf-module-id");
1247 responseBuilder.setResponseCode("403");
1248 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1249 responseBuilder.setAckFinalIndicator("Y");
1250 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1251 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1253 return Futures.immediateFuture(rpcResult);
1256 // Grab the vf-module-request-information.vf-module-id from the input buffer
1257 String vfid = input.getVfModuleRequestInformation().getVfModuleId();
1258 String preload_name = input.getVfModuleRequestInformation().getVfModuleName();
1259 String preload_type = input.getVfModuleRequestInformation().getVfModuleModelId();
1261 // Make sure we have a valid siid
1262 if(vfid == null || vfid.length() == 0 ) {
1263 log.debug("exiting "+SVC_OPERATION+" because of invalid vf-module-id");
1264 responseBuilder.setResponseCode("403");
1265 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1266 responseBuilder.setAckFinalIndicator("Y");
1267 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1268 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1270 return Futures.immediateFuture(rpcResult);
1273 // 1610 add vf-module-id to vnf-instance-list.vf-module-relationship-list
1274 String viid = input.getVfModuleRequestInformation().getVnfInstanceId();
1276 if(viid == null || viid.length() == 0 ) {
1277 log.debug("exiting "+SVC_OPERATION+" because of invalid vnf-instance-id");
1278 responseBuilder.setResponseCode("403");
1279 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1280 responseBuilder.setAckFinalIndicator("Y");
1281 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1282 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1284 return Futures.immediateFuture(rpcResult);
1287 if (input.getSdncRequestHeader() != null) {
1288 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1289 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1292 // Get vf-module-preload-data
1293 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
1294 getVfModulePreloadData(preload_name, preload_type, vfModulePreloadDataBuilder);
1296 // Get vf-module-service-data
1297 VfModuleServiceDataBuilder vfModuleServiceDataBuilder = new VfModuleServiceDataBuilder();
1298 getVfModuleServiceData(vfid,vfModuleServiceDataBuilder);
1300 // Get vf-module operation-data
1301 VfModuleServiceDataBuilder operDataBuilder = new VfModuleServiceDataBuilder();
1302 getVfModuleServiceData(vfid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1304 // save service-data builder object for rollback
1305 VfModuleServiceDataBuilder rb_vfModuleServiceDataBuilder = vfModuleServiceDataBuilder;
1306 VfModuleServiceDataBuilder rb_operDataBuilder = operDataBuilder;
1308 // 1610 Need to pull vnf-instance-list.vf-module-relationship-list from MD-SAL
1309 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1310 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1312 // vnf-instance operational-data
1313 VnfInstanceServiceDataBuilder vnfInstanceOperDataBuilder = new VnfInstanceServiceDataBuilder();
1314 getVnfInstanceServiceData(viid, vnfInstanceOperDataBuilder, LogicalDatastoreType.OPERATIONAL );
1316 // save operational builder object for rollback
1317 VnfInstanceServiceDataBuilder rb_vnfInstanceServiceDataBuilder = vnfInstanceServiceDataBuilder;
1318 VnfInstanceServiceDataBuilder rb_vnfInstanceOperDataBuilder = vnfInstanceOperDataBuilder;
1320 // Set the serviceStatus based on input
1321 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1322 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1325 // setup a service-data object builder
1326 // ACTION vnf-topology-operation
1328 // USES sdnc-request-header;
1329 // USES request-information;
1330 // USES service-information;
1331 // USES vnf-request-information
1333 // USES vnf-topology-response-body;
1334 // USES vnf-information
1335 // USES service-information
1337 // container service-data
1338 // uses vnf-configuration-information;
1339 // uses oper-status;
1341 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+vfid+"] input: " + input);
1342 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1343 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1345 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+vfid+"] vf-module operational-data: " + operDataBuilder.build());
1346 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1348 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] vf-module-preload-data: " + vfModulePreloadDataBuilder.build());
1349 VnfSdnUtil.toProperties(parms, "vf-module-preload-data", vfModulePreloadDataBuilder);
1351 log.info("Adding vnf-instance CONFIG data for "+SVC_OPERATION+" ["+viid+"] vnf-instance-service-data: " + vnfInstanceServiceDataBuilder.build());
1352 VnfSdnUtil.toProperties(parms, "vnf-instance-service-data", vnfInstanceServiceDataBuilder);
1354 log.info("Adding vnf-instance OPERATIONAL data for "+SVC_OPERATION+" ["+viid+"] vnf-instance operational-data: " + vnfInstanceOperDataBuilder.build());
1355 VnfSdnUtil.toProperties(parms, "vnf-instance-operational-data", vnfInstanceOperDataBuilder);
1357 // Call SLI sync method
1358 // Get SvcLogicService reference
1360 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
1361 Properties respProps = null;
1363 String errorCode = "200";
1364 String errorMessage = null;
1365 String ackFinal = "Y";
1370 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1375 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", vfModuleServiceDataBuilder, parms);
1379 log.error("Caught exception executing service logic on vf-module for "+ SVC_OPERATION, e);
1380 errorMessage = e.getMessage();
1385 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1392 errorMessage = e.getMessage();
1393 log.error("Caught exception looking for service logic", e);
1397 if (respProps != null) {
1398 errorCode = respProps.getProperty("error-code");
1399 errorMessage = respProps.getProperty("error-message");
1400 ackFinal = respProps.getProperty("ack-final", "Y");
1403 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
1404 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1405 serviceStatusBuilder.setRpcName(RpcName.VfModuleTopologyOperation);
1407 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1408 responseBuilder.setResponseCode(errorCode);
1409 responseBuilder.setResponseMessage(errorMessage);
1410 responseBuilder.setAckFinalIndicator(ackFinal);
1411 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1412 vfModuleListBuilder.setVfModuleId(vfid);
1413 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1415 SaveVfModuleList (vfModuleListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
1416 } catch (Exception e) {
1417 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+vfid+"] \n",e);
1419 log.error("Returned FAILED for "+SVC_OPERATION+" ["+vfid+"] " + responseBuilder.build());
1420 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1421 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1423 return Futures.immediateFuture(rpcResult);
1426 // Got success from SLI
1427 // save vf-module-service-data in MD-SAL
1429 vfModuleServiceData = vfModuleServiceDataBuilder.build();
1430 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+vfid+"] VfModuleServiceData: " + vfModuleServiceData);
1432 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1433 vfModuleListBuilder.setVfModuleServiceData(vfModuleServiceData);
1434 vfModuleListBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
1435 //vfid = vfModuleServiceData.getVfModuleId();
1436 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1437 SaveVfModuleList (vfModuleListBuilder.build(), false,LogicalDatastoreType.CONFIGURATION);
1438 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1440 // Only update operational tree on Delete or Activate
1441 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
1442 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1444 log.info("Updating OPERATIONAL tree.");
1445 SaveVfModuleList (vfModuleListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1448 VfModuleInformationBuilder vfModuleInformationBuilder = new VfModuleInformationBuilder();
1449 vfModuleInformationBuilder.setVfModuleId(vfid);
1450 responseBuilder.setVfModuleInformation(vfModuleInformationBuilder.build());
1451 responseBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
1452 } catch (Exception e) {
1453 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+vfid+"] \n",e);
1454 responseBuilder.setResponseCode("500");
1455 responseBuilder.setResponseMessage(e.toString());
1456 responseBuilder.setAckFinalIndicator("Y");
1457 log.error("Returned FAILED for "+SVC_OPERATION+" ["+vfid+"] " + responseBuilder.build());
1458 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1459 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1461 return Futures.immediateFuture(rpcResult);
1465 responseBuilder.setResponseCode(errorCode);
1466 responseBuilder.setAckFinalIndicator(ackFinal);
1467 if (errorMessage != null)
1469 responseBuilder.setResponseMessage(errorMessage);
1471 log.info("Updated vf-module in MD-SAL for "+SVC_OPERATION+" ["+vfid+"] ");
1472 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+vfid+"] " + responseBuilder.build());
1474 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1475 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1477 return Futures.immediateFuture(rpcResult);
1482 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(
1483 VnfTopologyOperationInput input) {
1485 final String SVC_OPERATION = "vnf-topology-operation";
1486 ServiceData serviceData = null;
1487 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1488 Properties parms = new Properties();
1490 log.info( SVC_OPERATION +" called." );
1491 // create a new response object
1492 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1495 input.getServiceInformation() == null ||
1496 input.getServiceInformation().getServiceInstanceId() == null ||
1497 input.getServiceInformation().getServiceInstanceId().length() == 0)
1499 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty service-instance-id");
1500 responseBuilder.setResponseCode("403");
1501 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1502 responseBuilder.setAckFinalIndicator("Y");
1503 RpcResult<VnfTopologyOperationOutput> rpcResult =
1504 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1506 return Futures.immediateFuture(rpcResult);
1509 if(input.getVnfRequestInformation() == null ||
1510 input.getVnfRequestInformation().getVnfId() == null ||
1511 input.getVnfRequestInformation().getVnfId().length() == 0)
1513 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vf-module-id");
1514 responseBuilder.setResponseCode("403");
1515 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1516 responseBuilder.setAckFinalIndicator("Y");
1517 RpcResult<VnfTopologyOperationOutput> rpcResult =
1518 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1520 return Futures.immediateFuture(rpcResult);
1523 // Grab the service instance ID from the input buffer
1524 String siid = input.getVnfRequestInformation().getVnfId();
1525 String preload_name = input.getVnfRequestInformation().getVnfName();
1526 String preload_type = input.getVnfRequestInformation().getVnfType();
1529 // Make sure we have a valid siid
1530 if(siid == null || siid.length() == 0 ) {
1531 log.debug("exiting "+SVC_OPERATION+" because of invalid siid");
1532 responseBuilder.setResponseCode("403");
1533 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1534 responseBuilder.setAckFinalIndicator("Y");
1535 RpcResult<VnfTopologyOperationOutput> rpcResult =
1536 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1538 return Futures.immediateFuture(rpcResult);
1542 if (input.getSdncRequestHeader() != null) {
1543 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1544 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1547 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1548 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1550 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1551 getServiceData(siid,serviceDataBuilder);
1553 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1554 getServiceData(siid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1556 // Set the serviceStatus based on input
1557 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1558 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1561 // setup a service-data object builder
1562 // ACTION vnf-topology-operation
1564 // USES sdnc-request-header;
1565 // USES request-information;
1566 // USES service-information;
1567 // USES vnf-request-information
1569 // USES vnf-topology-response-body;
1570 // USES vnf-information
1571 // USES service-information
1573 // container service-data
1574 // uses vnf-configuration-information;
1575 // uses oper-status;
1577 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+siid+"] input: " + input);
1578 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1579 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1581 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+siid+"] operational-data: " + operDataBuilder.build());
1582 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1584 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " + preloadDataBuilder.build());
1585 VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1587 // Call SLI sync method
1588 // Get SvcLogicService reference
1590 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
1591 Properties respProps = null;
1593 String errorCode = "200";
1594 String errorMessage = null;
1595 String ackFinal = "Y";
1600 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1605 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1609 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1610 errorMessage = e.getMessage();
1614 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1621 errorMessage = e.getMessage();
1622 log.error("Caught exception looking for service logic", e);
1626 if (respProps != null)
1628 errorCode = respProps.getProperty("error-code");
1629 errorMessage = respProps.getProperty("error-message");
1630 ackFinal = respProps.getProperty("ack-final", "Y");
1633 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
1634 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1635 serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
1637 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1638 responseBuilder.setResponseCode(errorCode);
1639 responseBuilder.setResponseMessage(errorMessage);
1640 responseBuilder.setAckFinalIndicator(ackFinal);
1641 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1642 vnfListBuilder.setVnfId(siid);
1643 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1645 SaveVnfList (vnfListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
1646 } catch (Exception e) {
1647 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
1649 log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1650 RpcResult<VnfTopologyOperationOutput> rpcResult =
1651 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1653 return Futures.immediateFuture(rpcResult);
1656 // Got success from SLI
1658 serviceData = serviceDataBuilder.build();
1659 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] ServiceData: " + serviceData);
1660 // svc-configuration-list
1661 VnfListBuilder vnfListBuilder = new VnfListBuilder();
1662 vnfListBuilder.setServiceData(serviceData);
1663 vnfListBuilder.setVnfId(serviceData.getVnfId());
1664 siid = serviceData.getVnfId();
1665 vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1666 SaveVnfList (vnfListBuilder.build(), false,LogicalDatastoreType.CONFIGURATION);
1667 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1669 // Only update operational tree on Delete or Activate
1670 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1671 log.info("Updating OPERATIONAL tree.");
1672 SaveVnfList (vnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1674 else if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
1675 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Rollback)) {
1676 log.info("Delete OPERATIONAL tree.");
1677 DeleteVnfList (vnfListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
1678 DeleteVnfList (vnfListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
1681 VnfInformationBuilder vnfInformationBuilder = new VnfInformationBuilder();
1682 vnfInformationBuilder.setVnfId(siid);
1683 responseBuilder.setVnfInformation(vnfInformationBuilder.build());
1684 responseBuilder.setServiceInformation(serviceData.getServiceInformation());
1685 } catch (Exception e) {
1686 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
1687 responseBuilder.setResponseCode("500");
1688 responseBuilder.setResponseMessage(e.toString());
1689 responseBuilder.setAckFinalIndicator("Y");
1690 log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1691 RpcResult<VnfTopologyOperationOutput> rpcResult =
1692 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1694 return Futures.immediateFuture(rpcResult);
1698 responseBuilder.setResponseCode(errorCode);
1699 responseBuilder.setAckFinalIndicator(ackFinal);
1700 if (errorMessage != null)
1702 responseBuilder.setResponseMessage(errorMessage);
1704 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+siid+"] ");
1705 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1707 RpcResult<VnfTopologyOperationOutput> rpcResult =
1708 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1710 return Futures.immediateFuture(rpcResult);
1715 public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1716 NetworkTopologyOperationInput input) {
1718 final String SVC_OPERATION = "network-topology-operation";
1719 ServiceData serviceData = null;
1720 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1721 Properties parms = new Properties();
1723 log.info( SVC_OPERATION +" called." );
1724 // create a new response object
1725 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1728 input.getServiceInformation() == null ||
1729 input.getServiceInformation().getServiceInstanceId() == null ||
1730 input.getServiceInformation().getServiceInstanceId().length() == 0)
1732 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty service-instance-id");
1733 responseBuilder.setResponseCode("403");
1734 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1735 responseBuilder.setAckFinalIndicator("Y");
1736 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1737 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1739 return Futures.immediateFuture(rpcResult);
1742 if(input.getNetworkRequestInformation() == null || input.getNetworkRequestInformation().getNetworkName() == null) {
1743 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty service-instance-id");
1744 responseBuilder.setResponseCode("403");
1745 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1746 responseBuilder.setAckFinalIndicator("Y");
1747 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1748 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1750 return Futures.immediateFuture(rpcResult);
1753 // Grab the service instance ID from the input buffer
1755 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Assign)) {
1756 siid = input.getNetworkRequestInformation().getNetworkName();
1759 siid = input.getNetworkRequestInformation().getNetworkId();
1761 String preload_name = input.getNetworkRequestInformation().getNetworkName();
1762 String preload_type = input.getNetworkRequestInformation().getNetworkType();
1765 if(siid == null || siid.length() == 0 ) {
1766 log.debug("exiting "+SVC_OPERATION+" because of invalid siid");
1767 responseBuilder.setResponseCode("403");
1768 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1769 responseBuilder.setAckFinalIndicator("Y");
1770 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1771 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1773 return Futures.immediateFuture(rpcResult);
1777 if (input.getSdncRequestHeader() != null) {
1778 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1779 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1782 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1783 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1785 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+siid+"] input: " + input);
1786 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1787 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1790 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+siid+"] operational-data: " + operDataBuilder.build());
1791 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1793 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " + preloadDataBuilder.build());
1794 VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1797 // Call SLI sync method
1798 // Get SvcLogicService reference
1800 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
1801 Properties respProps = null;
1803 String errorCode = "200";
1804 String errorMessage = null;
1805 String ackFinal = "Y";
1806 String networkId = "error";
1811 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1816 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1820 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1821 errorMessage = e.getMessage();
1825 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1832 errorMessage = e.getMessage();
1833 log.error("Caught exception looking for service logic", e);
1837 if (respProps != null)
1839 errorCode = respProps.getProperty("error-code");
1840 errorMessage = respProps.getProperty("error-message");
1841 ackFinal = respProps.getProperty("ack-final", "Y");
1842 networkId = respProps.getProperty("networkId","0");
1845 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1846 responseBuilder.setResponseCode(errorCode);
1847 responseBuilder.setResponseMessage(errorMessage);
1848 responseBuilder.setAckFinalIndicator(ackFinal);
1850 log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1852 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1853 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1855 return Futures.immediateFuture(rpcResult);
1858 // Got success from SLI
1860 NetworkInformationBuilder networkInformationBuilder = new NetworkInformationBuilder();
1861 networkInformationBuilder.setNetworkId(networkId);
1862 responseBuilder.setNetworkInformation(networkInformationBuilder.build());
1863 responseBuilder.setServiceInformation(input.getServiceInformation());
1864 } catch (IllegalStateException e) {
1865 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
1866 responseBuilder.setResponseCode("500");
1867 responseBuilder.setResponseMessage(e.toString());
1868 responseBuilder.setAckFinalIndicator("Y");
1869 log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1870 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1871 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1873 return Futures.immediateFuture(rpcResult);
1877 responseBuilder.setResponseCode(errorCode);
1878 responseBuilder.setAckFinalIndicator(ackFinal);
1879 if (errorMessage != null)
1881 responseBuilder.setResponseMessage(errorMessage);
1883 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+siid+"] ");
1884 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1886 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1887 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1889 return Futures.immediateFuture(rpcResult);
1893 public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1894 PreloadVnfTopologyOperationInput input) {
1896 final String SVC_OPERATION = "preload-vnf-topology-operation";
1897 PreloadData preloadData = null;
1898 Properties parms = new Properties();
1900 log.info( SVC_OPERATION +" called." );
1901 // create a new response object
1902 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1904 // Result from savePreloadData
1905 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1907 if(input == null || input.getVnfTopologyInformation() == null || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName() == null || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType() == null) {
1908 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-name and vnf-type");
1909 responseBuilder.setResponseCode("403");
1910 responseBuilder.setResponseMessage("invalid input, null or empty vnf-name and vnf-type");
1911 responseBuilder.setAckFinalIndicator("Y");
1912 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1913 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1914 return Futures.immediateFuture(rpcResult);
1917 // Grab the name and type from the input buffer
1918 String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1919 String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1921 // Make sure we have a preload_name and preload_type
1922 if(preload_name == null || preload_name.length() == 0 ) {
1923 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-name");
1924 responseBuilder.setResponseCode("403");
1925 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1926 responseBuilder.setAckFinalIndicator("Y");
1927 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1928 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1929 return Futures.immediateFuture(rpcResult);
1931 if(preload_type == null || preload_type.length() == 0 ) {
1932 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-type");
1933 responseBuilder.setResponseCode("403");
1934 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1935 responseBuilder.setAckFinalIndicator("Y");
1936 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1937 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1938 return Futures.immediateFuture(rpcResult);
1941 if (input.getSdncRequestHeader() != null) {
1942 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1943 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1946 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1947 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1948 //preloadData = preloadDataBuilder.build();
1950 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1951 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1954 // setup a preload-data object builder
1955 // ACTION vnf-topology-operation
1957 // USES sdnc-request-header;
1958 // USES request-information;
1959 // uses vnf-topology-information;
1961 // USES vnf-topology-response-body;
1963 // container preload-data
1964 // uses vnf-configuration-information;
1967 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
1968 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1969 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1970 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
1971 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1973 // Call SLI sync method
1974 // Get SvcLogicService reference
1976 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
1977 Properties respProps = null;
1979 String errorCode = "200";
1980 String errorMessage = null;
1981 String ackFinal = "Y";
1986 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1991 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1995 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1996 errorMessage = e.getMessage();
2000 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2007 errorMessage = e.getMessage();
2008 log.error("Caught exception looking for service logic", e);
2012 if (respProps != null)
2014 errorCode = respProps.getProperty("error-code");
2015 errorMessage = respProps.getProperty("error-message");
2016 ackFinal = respProps.getProperty("ack-final", "Y");
2017 // internalError = respProps.getProperty("internal-error", "false");
2020 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2022 responseBuilder.setResponseCode(errorCode);
2023 responseBuilder.setResponseMessage(errorMessage);
2024 responseBuilder.setAckFinalIndicator(ackFinal);
2026 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2027 preloadVnfListBuilder.setVnfName(preload_name);
2028 preloadVnfListBuilder.setVnfType(preload_type);
2029 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2030 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
2032 SavePreloadList (preloadVnfListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
2033 } catch (Exception e) {
2034 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2036 log.debug("Sending Success rpc result due to external error");
2037 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2038 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2039 return Futures.immediateFuture(rpcResult);
2042 // Got success from SLI
2044 preloadData = preloadDataBuilder.build();
2045 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + preloadData);
2046 // svc-configuration-list
2047 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2048 preloadVnfListBuilder.setVnfName(preload_name);
2049 preloadVnfListBuilder.setVnfType(preload_type);
2050 preloadVnfListBuilder.setPreloadData(preloadData);
2052 // SDNGC-989 set merge flag to false
2053 SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2054 log.info("Updating OPERATIONAL tree.");
2055 SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2056 } catch (Exception e) {
2057 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2058 responseBuilder.setResponseCode("500");
2059 responseBuilder.setResponseMessage(e.toString());
2060 responseBuilder.setAckFinalIndicator("Y");
2061 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2062 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2063 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2064 return Futures.immediateFuture(rpcResult);
2068 responseBuilder.setResponseCode(errorCode);
2069 responseBuilder.setAckFinalIndicator(ackFinal);
2070 if (errorMessage != null)
2072 responseBuilder.setResponseMessage(errorMessage);
2074 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
2075 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2077 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2078 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2079 return Futures.immediateFuture(rpcResult);
2082 //1610 preload-vnf-instance-topology-operation
2084 public Future<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> preloadVnfInstanceTopologyOperation(
2085 PreloadVnfInstanceTopologyOperationInput input) {
2087 final String SVC_OPERATION = "preload-vnf-instance-topology-operation";
2088 VnfInstancePreloadData vnfInstancePreloadData = null;
2089 Properties parms = new Properties();
2091 log.info( SVC_OPERATION +" called." );
2092 // create a new response object
2093 PreloadVnfInstanceTopologyOperationOutputBuilder responseBuilder = new PreloadVnfInstanceTopologyOperationOutputBuilder();
2095 // Result from savePreloadData
2096 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2099 input.getVnfInstanceTopologyInformation() == null ||
2100 input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName() == null ||
2101 input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId() == null)
2103 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-instance-name and vnf-model-id");
2104 responseBuilder.setResponseCode("403");
2105 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name and vnf-model-id");
2106 responseBuilder.setAckFinalIndicator("Y");
2107 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2108 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2109 return Futures.immediateFuture(rpcResult);
2112 // Grab the name and type from the input buffer
2113 String preload_name = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName();
2114 String preload_type = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId();
2116 // Make sure we have a preload_name and preload_type
2117 if(preload_name == null || preload_name.length() == 0 ) {
2118 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-name");
2119 responseBuilder.setResponseCode("403");
2120 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2121 responseBuilder.setAckFinalIndicator("Y");
2122 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2123 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2124 return Futures.immediateFuture(rpcResult);
2126 if(preload_type == null || preload_type.length() == 0 ) {
2127 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-type");
2128 responseBuilder.setResponseCode("403");
2129 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2130 responseBuilder.setAckFinalIndicator("Y");
2131 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2132 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2133 return Futures.immediateFuture(rpcResult);
2136 if (input.getSdncRequestHeader() != null) {
2137 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2138 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2141 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
2142 getVnfInstancePreloadData(preload_name, preload_type, vnfInstancePreloadDataBuilder);
2143 //preloadData = preloadDataBuilder.build();
2145 VnfInstancePreloadDataBuilder operDataBuilder = new VnfInstancePreloadDataBuilder();
2146 getVnfInstancePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
2149 // setup a preload-data object builder
2150 // ACTION vnf-topology-operation
2152 // USES sdnc-request-header;
2153 // USES request-information;
2154 // uses vnf-topology-information;
2156 // USES vnf-topology-response-body;
2158 // container preload-data
2159 // uses vnf-configuration-information;
2162 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
2163 PreloadVnfInstanceTopologyOperationInputBuilder inputBuilder = new PreloadVnfInstanceTopologyOperationInputBuilder(input);
2164 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2165 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
2166 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2168 // Call SLI sync method
2169 // Get SvcLogicService reference
2171 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
2172 Properties respProps = null;
2174 String errorCode = "200";
2175 String errorMessage = null;
2176 String ackFinal = "Y";
2181 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
2186 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", vnfInstancePreloadDataBuilder, parms);
2190 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
2191 errorMessage = e.getMessage();
2195 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2202 errorMessage = e.getMessage();
2203 log.error("Caught exception looking for service logic", e);
2207 if (respProps != null)
2209 errorCode = respProps.getProperty("error-code");
2210 errorMessage = respProps.getProperty("error-message");
2211 ackFinal = respProps.getProperty("ack-final", "Y");
2212 // internalError = respProps.getProperty("internal-error", "false");
2215 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2217 responseBuilder.setResponseCode(errorCode);
2218 responseBuilder.setResponseMessage(errorMessage);
2219 responseBuilder.setAckFinalIndicator(ackFinal);
2221 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2222 vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2223 vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2224 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadDataBuilder.build());
2225 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
2227 SaveVnfInstancePreloadList (vnfInstancePreloadListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
2228 } catch (Exception e) {
2229 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2231 log.debug("Sending Success rpc result due to external error");
2232 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2233 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2234 return Futures.immediateFuture(rpcResult);
2237 // Got success from SLI
2239 vnfInstancePreloadData = vnfInstancePreloadDataBuilder.build();
2240 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + vnfInstancePreloadData);
2241 // svc-configuration-list
2242 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2243 vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2244 vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2245 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadData);
2247 // SDNGC-989 set merge flag to false
2248 SaveVnfInstancePreloadList (vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2249 log.info("Updating OPERATIONAL tree.");
2250 SaveVnfInstancePreloadList (vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2251 } catch (Exception e) {
2252 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2253 responseBuilder.setResponseCode("500");
2254 responseBuilder.setResponseMessage(e.toString());
2255 responseBuilder.setAckFinalIndicator("Y");
2256 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2257 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2258 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2259 return Futures.immediateFuture(rpcResult);
2263 responseBuilder.setResponseCode(errorCode);
2264 responseBuilder.setAckFinalIndicator(ackFinal);
2265 if (errorMessage != null)
2267 responseBuilder.setResponseMessage(errorMessage);
2269 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
2270 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2272 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2273 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2274 return Futures.immediateFuture(rpcResult);
2278 //1610 preload-vf-module-topology-operation
2280 public Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2281 PreloadVfModuleTopologyOperationInput input) {
2283 final String SVC_OPERATION = "preload-vf-module-topology-operation";
2284 VfModulePreloadData vfModulePreloadData = null;
2285 Properties parms = new Properties();
2287 log.info( SVC_OPERATION +" called." );
2288 // create a new response object
2289 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder = new PreloadVfModuleTopologyOperationOutputBuilder();
2291 // Result from savePreloadData
2292 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2295 input.getVfModuleTopologyInformation() == null ||
2296 input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName() == null ||
2297 input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId() == null)
2299 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-instance-name and vnf-model-id");
2300 responseBuilder.setResponseCode("403");
2301 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name and vnf-model-id");
2302 responseBuilder.setAckFinalIndicator("Y");
2303 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2304 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2305 return Futures.immediateFuture(rpcResult);
2308 // Grab the name and type from the input buffer
2309 String preload_name = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName();
2310 String preload_type = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId();
2312 // Make sure we have a preload_name and preload_type
2313 if(preload_name == null || preload_name.length() == 0 ) {
2314 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-name");
2315 responseBuilder.setResponseCode("403");
2316 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2317 responseBuilder.setAckFinalIndicator("Y");
2318 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2319 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2320 return Futures.immediateFuture(rpcResult);
2322 if(preload_type == null || preload_type.length() == 0 ) {
2323 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-type");
2324 responseBuilder.setResponseCode("403");
2325 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2326 responseBuilder.setAckFinalIndicator("Y");
2327 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2328 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2329 return Futures.immediateFuture(rpcResult);
2332 if (input.getSdncRequestHeader() != null) {
2333 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2334 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2337 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
2338 getVfModulePreloadData(preload_name, preload_type, vfModulePreloadDataBuilder);
2339 //preloadData = preloadDataBuilder.build();
2341 VfModulePreloadDataBuilder operDataBuilder = new VfModulePreloadDataBuilder();
2342 getVfModulePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
2345 // setup a preload-data object builder
2346 // ACTION vnf-topology-operation
2348 // USES sdnc-request-header;
2349 // USES request-information;
2350 // uses vnf-topology-information;
2352 // USES vnf-topology-response-body;
2354 // container preload-data
2355 // uses vnf-configuration-information;
2358 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
2359 PreloadVfModuleTopologyOperationInputBuilder inputBuilder = new PreloadVfModuleTopologyOperationInputBuilder(input);
2360 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2361 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
2362 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2364 // Call SLI sync method
2365 // Get SvcLogicService reference
2367 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
2368 Properties respProps = null;
2370 String errorCode = "200";
2371 String errorMessage = null;
2372 String ackFinal = "Y";
2377 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
2382 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", vfModulePreloadDataBuilder, parms);
2386 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
2387 errorMessage = e.getMessage();
2391 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2398 errorMessage = e.getMessage();
2399 log.error("Caught exception looking for service logic", e);
2403 if (respProps != null)
2405 errorCode = respProps.getProperty("error-code");
2406 errorMessage = respProps.getProperty("error-message");
2407 ackFinal = respProps.getProperty("ack-final", "Y");
2408 // internalError = respProps.getProperty("internal-error", "false");
2411 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2413 responseBuilder.setResponseCode(errorCode);
2414 responseBuilder.setResponseMessage(errorMessage);
2415 responseBuilder.setAckFinalIndicator(ackFinal);
2417 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2418 vfModulePreloadListBuilder.setVfModuleName(preload_name);
2419 vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2420 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadDataBuilder.build());
2421 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
2423 SaveVfModulePreloadList (vfModulePreloadListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
2424 } catch (Exception e) {
2425 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2427 log.debug("Sending Success rpc result due to external error");
2428 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2429 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2430 return Futures.immediateFuture(rpcResult);
2433 // Got success from SLI
2435 vfModulePreloadData = vfModulePreloadDataBuilder.build();
2436 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + vfModulePreloadData);
2437 // svc-configuration-list
2438 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2439 vfModulePreloadListBuilder.setVfModuleName(preload_name);
2440 vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2441 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadData);
2443 // SDNGC-989 set merge flag to false
2444 SaveVfModulePreloadList (vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2445 log.info("Updating OPERATIONAL tree.");
2446 SaveVfModulePreloadList (vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2447 } catch (Exception e) {
2448 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2449 responseBuilder.setResponseCode("500");
2450 responseBuilder.setResponseMessage(e.toString());
2451 responseBuilder.setAckFinalIndicator("Y");
2452 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2453 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2454 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2455 return Futures.immediateFuture(rpcResult);
2459 responseBuilder.setResponseCode(errorCode);
2460 responseBuilder.setAckFinalIndicator(ackFinal);
2461 if (errorMessage != null)
2463 responseBuilder.setResponseMessage(errorMessage);
2465 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
2466 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2468 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2469 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2470 return Futures.immediateFuture(rpcResult);
2475 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2476 PreloadNetworkTopologyOperationInput input) {
2478 final String SVC_OPERATION = "preload-network-topology-operation";
2479 PreloadData preloadData = null;
2480 Properties parms = new Properties();
2482 log.info( SVC_OPERATION +" called." );
2483 // create a new response object
2484 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2486 // Result from savePreloadData
2487 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2489 if(input == null || input.getNetworkTopologyInformation() == null || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName() == null || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType() == null) {
2490 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-name and vnf-type");
2491 responseBuilder.setResponseCode("403");
2492 responseBuilder.setResponseMessage("input, null or empty vnf-name and vnf-type");
2493 responseBuilder.setAckFinalIndicator("Y");
2494 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2495 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2496 return Futures.immediateFuture(rpcResult);
2499 // Grab the name and type from the input buffer
2500 String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2501 String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2503 // Make sure we have a preload_name and preload_type
2504 if(preload_name == null || preload_name.length() == 0 ) {
2505 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-name");
2506 responseBuilder.setResponseCode("403");
2507 responseBuilder.setResponseMessage("input, invalid preload-name");
2508 responseBuilder.setAckFinalIndicator("Y");
2509 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2510 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2511 return Futures.immediateFuture(rpcResult);
2513 if(preload_type == null || preload_type.length() == 0 ) {
2514 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-type");
2515 responseBuilder.setResponseCode("403");
2516 responseBuilder.setResponseMessage("input, invalid preload-type");
2517 responseBuilder.setAckFinalIndicator("Y");
2518 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2519 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2520 return Futures.immediateFuture(rpcResult);
2523 if (input.getSdncRequestHeader() != null) {
2524 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2525 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2528 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2529 getPreloadData(preload_name, preload_type, preloadDataBuilder);
2531 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2532 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
2535 // setup a preload-data object builder
2536 // ACTION vnf-topology-operation
2538 // USES sdnc-request-header;
2539 // USES request-information;
2540 // uses vnf-topology-information;
2542 // USES vnf-topology-response-body;
2544 // container preload-data
2545 // uses vnf-configuration-information;
2548 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
2549 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(input);
2550 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2551 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
2552 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2554 // Call SLI sync method
2555 // Get SvcLogicService reference
2557 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
2558 Properties respProps = null;
2560 String errorCode = "200";
2561 String errorMessage = null;
2562 String ackFinal = "Y";
2567 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
2572 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2576 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
2577 errorMessage = e.getMessage();
2581 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2588 errorMessage = e.getMessage();
2589 log.error("Caught exception looking for service logic", e);
2593 if (respProps != null)
2595 errorCode = respProps.getProperty("error-code");
2596 errorMessage = respProps.getProperty("error-message");
2597 ackFinal = respProps.getProperty("ack-final", "Y");
2598 // internalError = respProps.getProperty("internal-error", "false");
2601 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2603 responseBuilder.setResponseCode(errorCode);
2604 responseBuilder.setResponseMessage(errorMessage);
2605 responseBuilder.setAckFinalIndicator(ackFinal);
2607 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2608 preloadVnfListBuilder.setVnfName(preload_name);
2609 preloadVnfListBuilder.setVnfType(preload_type);
2610 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2611 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
2613 SavePreloadList (preloadVnfListBuilder.build(),true,LogicalDatastoreType.CONFIGURATION);
2614 } catch (Exception e) {
2615 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2618 log.debug("Sending Success rpc result due to external error");
2619 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2620 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2621 return Futures.immediateFuture(rpcResult);
2624 // Got success from SLI
2626 preloadData = preloadDataBuilder.build();
2627 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + preloadData);
2628 // svc-configuration-list
2629 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2630 preloadVnfListBuilder.setVnfName(preload_name);
2631 preloadVnfListBuilder.setVnfType(preload_type);
2632 preloadVnfListBuilder.setPreloadData(preloadData);
2634 // SDNGC-989 set merge flag to false
2635 SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2636 log.info("Updating OPERATIONAL tree.");
2637 SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2638 } catch (Exception e) {
2639 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2640 responseBuilder.setResponseCode("500");
2641 responseBuilder.setResponseMessage(e.toString());
2642 responseBuilder.setAckFinalIndicator("Y");
2643 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2644 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2645 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2646 return Futures.immediateFuture(rpcResult);
2650 responseBuilder.setResponseCode(errorCode);
2651 responseBuilder.setAckFinalIndicator(ackFinal);
2652 if (errorMessage != null)
2654 responseBuilder.setResponseMessage(errorMessage);
2656 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
2657 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2659 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2660 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2661 return Futures.immediateFuture(rpcResult);