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;
172 private VNFSDNSvcLogicServiceClient svcLogicClient;
176 public vnfapiProvider(DataBroker dataBroker2, NotificationPublishService notificationPublishService,
177 RpcProviderRegistry rpcProviderRegistry, VNFSDNSvcLogicServiceClient client) {
178 this.log.info( "Creating provider for " + appName );
179 executor = Executors.newFixedThreadPool(1);
180 dataBroker = dataBroker2;
181 notificationService = notificationPublishService;
182 rpcRegistry = rpcProviderRegistry;
183 this.svcLogicClient = client;
188 public void initialize(){
189 log.info( "Initializing provider for " + appName );
190 // Create the top level containers
193 VnfSdnUtil.loadProperties();
194 } catch (Exception e) {
195 log.error("Caught Exception while trying to load properties file: ", e);
197 // rpcRegistration = rpcRegistry.addRpcImplementation(VNFAPIService.class, this);
199 log.info( "Initialization complete for " + appName );
202 private void createContainers() {
203 final WriteTransaction t = dataBroker.newReadWriteTransaction();
205 // Create the Vnfs container
206 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Vnfs.class),
207 new VnfsBuilder().build());
208 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Vnfs.class),
209 new VnfsBuilder().build());
211 // Create the PreloadVnfs container
212 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
213 new PreloadVnfsBuilder().build());
214 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
215 new PreloadVnfsBuilder().build());
217 // 1610 Create the PreloadVnfInstances container
218 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfInstances.class),
219 new PreloadVnfInstancesBuilder().build());
220 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfInstances.class),
221 new PreloadVnfInstancesBuilder().build());
223 // 1610 Create the VnfInstances container
224 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VnfInstances.class),
225 new VnfInstancesBuilder().build());
226 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VnfInstances.class),
227 new VnfInstancesBuilder().build());
229 // 1610 Create the PreloadVfModules container
230 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVfModules.class),
231 new PreloadVfModulesBuilder().build());
232 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVfModules.class),
233 new PreloadVfModulesBuilder().build());
235 // 1610 Create the VfModules container
236 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(VfModules.class),
237 new VfModulesBuilder().build());
238 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(VfModules.class),
239 new VfModulesBuilder().build());
242 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
244 log.info("Create Containers succeeded!: ");
246 } catch (InterruptedException | ExecutionException e) {
247 log.error("Create Containers Failed: " + e);
253 protected void initializeChild() {
254 //Override if you have custom initialization intelligence
258 public void close() throws Exception {
259 log.info( "Closing provider for " + appName );
261 rpcRegistration.close();
262 // dclServices.close();
263 log.info( "Successfully closed provider for " + appName );
266 // On data change not used
268 public void onDataChanged(
269 AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
270 boolean changed = false;
271 log.info(" IN ON DATA CHANGE: ");
272 WriteTransaction writeTransaction = dataBroker
273 .newWriteOnlyTransaction();
275 DataObject updatedSubTree = change.getUpdatedSubtree();
277 if (updatedSubTree != null) {
278 if (log.isDebugEnabled())
280 log.debug("updatedSubTree was non-null:" + updatedSubTree);
282 if ( updatedSubTree instanceof Vnfs ) {
283 ArrayList<VnfList> vnfList = (ArrayList<VnfList>) ((Vnfs) updatedSubTree).getVnfList();
284 if (vnfList != null) {
285 for (VnfList entry : vnfList) {
286 ServiceData serviceData = entry.getServiceData();
287 ServiceStatus serviceStatus = entry.getServiceStatus();
288 if (serviceData != null && serviceStatus != null) {
290 // ServiceData change detected, check the AckFinal indicator and request-status to see if we need to proceed.
292 if ((! "Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete.equals(serviceStatus.getRequestStatus()))) {
293 if (log.isDebugEnabled())
295 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
297 //handleServiceDataUpdated(serviceData, serviceStatus, writeTransaction);
304 if ( updatedSubTree instanceof PreloadVnfs ) {
305 ArrayList<VnfPreloadList> vnfList = (ArrayList<VnfPreloadList>) ((PreloadVnfs) updatedSubTree).getVnfPreloadList();
306 if (vnfList != null) {
307 for (VnfPreloadList entry : vnfList) {
308 PreloadData preloadData = entry.getPreloadData();
309 if (preloadData != null ) {
311 // PreloadData change detected
313 // handlePreloadDataUpdated(preloadData, writeTransaction);
320 if ( updatedSubTree instanceof PreloadVnfInstances ) {
321 ArrayList<VnfInstancePreloadList> vnfInstanceList = (ArrayList<VnfInstancePreloadList>) ((PreloadVnfInstances) updatedSubTree).getVnfInstancePreloadList();
322 if (vnfInstanceList != null) {
323 for (VnfInstancePreloadList entry : vnfInstanceList) {
324 VnfInstancePreloadData vnfInstancePreloadData = entry.getVnfInstancePreloadData();
325 if (vnfInstancePreloadData != null ) {
327 // PreloadData change detected
329 // handlePreloadDataUpdated(preloadData, writeTransaction);
336 if ( updatedSubTree instanceof VnfInstances ) {
337 ArrayList<VnfInstanceList> vnfInstanceList = (ArrayList<VnfInstanceList>) ((VnfInstances) updatedSubTree).getVnfInstanceList();
338 if (vnfInstanceList != null) {
339 for (VnfInstanceList entry : vnfInstanceList) {
340 VnfInstanceServiceData vnfInstanceServiceData = entry.getVnfInstanceServiceData();
341 ServiceStatus serviceStatus = entry.getServiceStatus();
342 if (vnfInstanceServiceData != null && serviceStatus != null) {
344 // VnfInstanceServiceData change detected, check the AckFinal indicator and request-status to see if we need to proceed.
346 if ((! "Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete.equals(serviceStatus.getRequestStatus()))) {
347 if (log.isDebugEnabled())
349 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
351 //handleServiceDataUpdated(serviceData, serviceStatus, writeTransaction);
359 if ( updatedSubTree instanceof PreloadVfModules ) {
360 ArrayList<VfModulePreloadList> vnfInstanceList = (ArrayList<VfModulePreloadList>) ((PreloadVfModules) updatedSubTree).getVfModulePreloadList();
361 if (vnfInstanceList != null) {
362 for (VfModulePreloadList entry : vnfInstanceList) {
363 VfModulePreloadData vnfInstancePreloadData = entry.getVfModulePreloadData();
364 if (vnfInstancePreloadData != null ) {
366 // PreloadData change detected
368 // handlePreloadDataUpdated(preloadData, writeTransaction);
375 if ( updatedSubTree instanceof VfModules ) {
376 ArrayList<VfModuleList> vfModuleList = (ArrayList<VfModuleList>) ((VfModules) updatedSubTree).getVfModuleList();
377 if (vfModuleList != null) {
378 for (VfModuleList entry : vfModuleList) {
379 VfModuleServiceData vfModuleServiceData = entry.getVfModuleServiceData();
380 ServiceStatus serviceStatus = entry.getServiceStatus();
381 if (vfModuleServiceData != null && serviceStatus != null) {
383 // VfModuleServiceData change detected, check the AckFinal indicator and request-status to see if we need to proceed.
385 if ((! "Y".equals(serviceStatus.getFinalIndicator())) && (RequestStatus.Synccomplete.equals(serviceStatus.getRequestStatus()))) {
386 if (log.isDebugEnabled())
388 log.debug("Final Indicator is not Y, calling handleServiceDataUpdated");
390 //handleServiceDataUpdated(serviceData, serviceStatus, writeTransaction);
398 // Do the write transaction only if something changed.
400 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = writeTransaction
402 Futures.addCallback(checkedFuture, new FutureCallback<Void>() {
405 public void onSuccess(Void arg0) {
406 log.debug("Successfully updated Service Status");
410 public void onFailure(Throwable ex) {
412 "Failed updating Service Status",
419 private static class Iso8601Util
421 private static TimeZone tz = TimeZone.getTimeZone("UTC");
422 private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
429 private static String now()
431 return df.format(new Date());
435 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage, String ackFinal)
437 serviceStatusBuilder.setResponseCode(errorCode);
438 serviceStatusBuilder.setResponseMessage(errorMessage);
439 serviceStatusBuilder.setFinalIndicator(ackFinal);
440 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
443 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation)
445 if (requestInformation != null && requestInformation.getRequestAction() != null) {
446 switch (requestInformation.getRequestAction())
448 case VNFActivateRequest:
449 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VNFActivateRequest);
451 case ChangeVNFActivateRequest:
452 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVNFActivateRequest);
454 case DisconnectVNFRequest:
455 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVNFRequest);
457 case PreloadVNFRequest:
458 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVNFRequest);
460 case DeletePreloadVNFRequest:
461 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DeletePreloadVNFRequest);
463 // 1610 vnf-instance Requests
464 case VnfInstanceActivateRequest:
465 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VnfInstanceActivateRequest);
467 case ChangeVnfInstanceActivateRequest:
468 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVnfInstanceActivateRequest);
470 case DisconnectVnfInstanceRequest:
471 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVnfInstanceRequest);
473 case PreloadVnfInstanceRequest:
474 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVnfInstanceRequest);
476 // 1610 vf-module Requests
477 case VfModuleActivateRequest:
478 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.VfModuleActivateRequest);
480 case ChangeVfModuleActivateRequest:
481 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.ChangeVfModuleActivateRequest);
483 case DisconnectVfModuleRequest:
484 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.DisconnectVfModuleRequest);
486 case PreloadVfModuleRequest:
487 serviceStatusBuilder.setVnfsdnAction(VnfsdnAction.PreloadVfModuleRequest);
490 log.error("Unknown RequestAction: " + requestInformation.getRequestAction() );
494 if (requestInformation != null && requestInformation.getRequestSubAction() != null) {
495 switch (requestInformation.getRequestSubAction())
498 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP);
501 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
504 log.error("Unknown RequestSubAction: " + requestInformation.getRequestSubAction() );
510 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader)
512 if (requestHeader != null && requestHeader.getSvcAction() != null) {
513 switch (requestHeader.getSvcAction())
516 serviceStatusBuilder.setRpcAction(RpcAction.Reserve);
519 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
522 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
525 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
528 serviceStatusBuilder.setRpcAction(RpcAction.Changeassign);
531 serviceStatusBuilder.setRpcAction(RpcAction.Changedelete);
534 serviceStatusBuilder.setRpcAction(RpcAction.Rollback);
537 log.error("Unknown SvcAction: " + requestHeader.getSvcAction() );
543 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder)
546 getServiceData(siid,serviceDataBuilder,LogicalDatastoreType.CONFIGURATION);
550 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type)
552 // See if any data exists yet for this siid, if so grab it.
553 InstanceIdentifier serviceInstanceIdentifier =
554 InstanceIdentifier.<Vnfs>builder(Vnfs.class)
555 .child(VnfList.class, new VnfListKey(siid)).build();
556 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
557 Optional<VnfList> data = null;
559 data = (Optional<VnfList>) readTx.read(type, serviceInstanceIdentifier).get();
560 } catch (InterruptedException | ExecutionException e) {
561 log.error("Caught Exception reading MD-SAL ("+type+") for ["+siid+"] " ,e);
564 if (data != null && data.isPresent()) {
565 ServiceData serviceData = (ServiceData) data.get().getServiceData();
566 if (serviceData != null) {
567 log.info("Read MD-SAL ("+type+") data for ["+siid+"] ServiceData: " + serviceData);
568 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
569 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
570 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
571 serviceDataBuilder.setVnfRequestInformation(serviceData.getVnfRequestInformation());
572 serviceDataBuilder.setVnfId(serviceData.getVnfId());
573 serviceDataBuilder.setVnfTopologyInformation(serviceData.getVnfTopologyInformation());
574 serviceDataBuilder.setOperStatus(serviceData.getOperStatus());
576 log.info("No service-data found in MD-SAL ("+type+") for ["+siid+"] ");
579 log.info("No data found in MD-SAL ("+type+") for ["+siid+"] ");
584 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder)
587 getVnfInstanceServiceData(siid,vnfInstanceServiceDataBuilder,LogicalDatastoreType.CONFIGURATION);
590 private void getVnfInstanceServiceData(String siid, VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder, LogicalDatastoreType type)
592 // See if any data exists yet for this siid, if so grab it.
593 InstanceIdentifier vnfInstanceIdentifier =
594 InstanceIdentifier.<VnfInstances>builder(VnfInstances.class)
595 .child(VnfInstanceList.class, new VnfInstanceListKey(siid)).build();
596 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
597 Optional<VnfInstanceList> data = null;
599 data = (Optional<VnfInstanceList>) readTx.read(type, vnfInstanceIdentifier).get();
600 } catch (InterruptedException | ExecutionException e) {
601 log.error("Caught Exception reading MD-SAL ("+type+") for ["+siid+"] " ,e);
604 if (data != null && data.isPresent()) {
605 VnfInstanceServiceData vnfInstanceServiceData = (VnfInstanceServiceData) data.get().getVnfInstanceServiceData();
606 if (vnfInstanceServiceData != null) {
607 log.info("Read MD-SAL ("+type+") data for ["+siid+"] VnfInstanceServiceData: " + vnfInstanceServiceData);
608 vnfInstanceServiceDataBuilder.setSdncRequestHeader(vnfInstanceServiceData.getSdncRequestHeader());
609 vnfInstanceServiceDataBuilder.setRequestInformation(vnfInstanceServiceData.getRequestInformation());
610 vnfInstanceServiceDataBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
611 vnfInstanceServiceDataBuilder.setVnfInstanceRequestInformation(vnfInstanceServiceData.getVnfInstanceRequestInformation());
612 vnfInstanceServiceDataBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
613 vnfInstanceServiceDataBuilder.setVnfInstanceTopologyInformation(vnfInstanceServiceData.getVnfInstanceTopologyInformation());
614 vnfInstanceServiceDataBuilder.setOperStatus(vnfInstanceServiceData.getOperStatus());
616 log.info("No vnf-instance-service-data found in MD-SAL ("+type+") for ["+siid+"] ");
619 log.info("No data found in MD-SAL ("+type+") for ["+siid+"] ");
624 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder)
627 getVfModuleServiceData(siid,vfModuleServiceDataBuilder,LogicalDatastoreType.CONFIGURATION);
630 private void getVfModuleServiceData(String siid, VfModuleServiceDataBuilder vfModuleServiceDataBuilder, LogicalDatastoreType type)
632 // See if any data exists yet for this siid, if so grab it.
633 InstanceIdentifier vfModuleIdentifier =
634 InstanceIdentifier.<VfModules>builder(VfModules.class)
635 .child(VfModuleList.class, new VfModuleListKey(siid)).build();
636 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
637 Optional<VfModuleList> data = null;
639 data = (Optional<VfModuleList>) readTx.read(type, vfModuleIdentifier).get();
640 } catch (InterruptedException | ExecutionException e) {
641 log.error("Caught Exception reading MD-SAL ("+type+") for ["+siid+"] " ,e);
644 if (data != null && data.isPresent()) {
645 VfModuleServiceData vfModuleServiceData = (VfModuleServiceData) data.get().getVfModuleServiceData();
646 if (vfModuleServiceData != null) {
647 log.info("Read MD-SAL ("+type+") data for ["+siid+"] VfModuleServiceData: " + vfModuleServiceData);
648 vfModuleServiceDataBuilder.setSdncRequestHeader(vfModuleServiceData.getSdncRequestHeader());
649 vfModuleServiceDataBuilder.setRequestInformation(vfModuleServiceData.getRequestInformation());
650 vfModuleServiceDataBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
651 vfModuleServiceDataBuilder.setVfModuleRequestInformation(vfModuleServiceData.getVfModuleRequestInformation());
652 vfModuleServiceDataBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
653 vfModuleServiceDataBuilder.setVfModuleTopologyInformation(vfModuleServiceData.getVfModuleTopologyInformation());
654 vfModuleServiceDataBuilder.setOperStatus(vfModuleServiceData.getOperStatus());
656 log.info("No vf-module-service-data found in MD-SAL ("+type+") for ["+siid+"] ");
659 log.info("No data found in MD-SAL ("+type+") for ["+siid+"] ");
664 private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder)
667 getPreloadData(vnf_name, vnf_type ,preloadDataBuilder,LogicalDatastoreType.CONFIGURATION);
670 private void getPreloadData(String preload_name, String preload_type, PreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type)
672 // See if any data exists yet for this name/type, if so grab it.
673 InstanceIdentifier preloadInstanceIdentifier =
674 InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
675 .child(VnfPreloadList.class, new VnfPreloadListKey(preload_name, preload_type)).build();
676 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
677 Optional<VnfPreloadList> data = null;
679 data = (Optional<VnfPreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
680 } catch (InterruptedException | ExecutionException e) {
681 log.error("Caught Exception reading MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] " ,e);
684 if (data != null && data.isPresent()) {
685 PreloadData preloadData = (PreloadData) data.get().getPreloadData();
686 if (preloadData != null) {
687 log.info("Read MD-SAL ("+type+") data for ["+preload_name+","+preload_type+"] PreloadData: " + preloadData);
688 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
689 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
690 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
692 log.info("No preload-data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
695 log.info("No data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
699 //1610 preload-vnf-instance
700 private void getVnfInstancePreloadData(String vnf_name, String vnf_type, VnfInstancePreloadDataBuilder preloadDataBuilder)
703 getVnfInstancePreloadData(vnf_name, vnf_type ,preloadDataBuilder,LogicalDatastoreType.CONFIGURATION);
706 //1610 preload-vnf-instance
707 private void getVnfInstancePreloadData(String preload_name, String preload_type, VnfInstancePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type)
709 // See if any data exists yet for this name/type, if so grab it.
710 InstanceIdentifier preloadInstanceIdentifier =
711 InstanceIdentifier.<PreloadVnfInstances>builder(PreloadVnfInstances.class)
712 .child(VnfInstancePreloadList.class, new VnfInstancePreloadListKey(preload_name, preload_type)).build();
713 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
714 Optional<VnfInstancePreloadList> data = null;
716 data = (Optional<VnfInstancePreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
717 } catch (InterruptedException | ExecutionException e) {
718 log.error("Caught Exception reading MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] " ,e);
721 if (data != null && data.isPresent()) {
722 VnfInstancePreloadData preloadData = (VnfInstancePreloadData) data.get().getVnfInstancePreloadData();
723 if (preloadData != null) {
724 log.info("Read MD-SAL ("+type+") data for ["+preload_name+","+preload_type+"] VnfInstancePreloadData: " + preloadData);
725 preloadDataBuilder.setVnfInstanceTopologyInformation(preloadData.getVnfInstanceTopologyInformation());
726 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
728 log.info("No vnf-instance-preload-data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
731 log.info("No data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
735 // 1610 preload-vf-module
736 private void getVfModulePreloadData(String vnf_name, String vnf_type, VfModulePreloadDataBuilder preloadDataBuilder)
739 getVfModulePreloadData(vnf_name, vnf_type ,preloadDataBuilder,LogicalDatastoreType.CONFIGURATION);
742 private void getVfModulePreloadData(String preload_name, String preload_type, VfModulePreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type)
744 // See if any data exists yet for this name/type, if so grab it.
745 InstanceIdentifier preloadInstanceIdentifier =
746 InstanceIdentifier.<PreloadVfModules>builder(PreloadVfModules.class)
747 .child(VfModulePreloadList.class, new VfModulePreloadListKey(preload_name, preload_type)).build();
748 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
749 Optional<VfModulePreloadList> data = null;
751 data = (Optional<VfModulePreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
752 } catch (InterruptedException | ExecutionException e) {
753 log.error("Caught Exception reading MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] " ,e);
756 if (data != null && data.isPresent()) {
757 VfModulePreloadData preloadData = (VfModulePreloadData) data.get().getVfModulePreloadData();
758 if (preloadData != null) {
759 log.info("Read MD-SAL ("+type+") data for ["+preload_name+","+preload_type+"] VfModulePreloadData: " + preloadData);
760 preloadDataBuilder.setVfModuleTopologyInformation(preloadData.getVfModuleTopologyInformation());
761 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
763 log.info("No preload-data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
766 log.info("No data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
770 private void SaveVnfList (final VnfList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException {
771 // Each entry will be identifiable by a unique key, we have to create that identifier
772 InstanceIdentifier.InstanceIdentifierBuilder<VnfList> vnfListIdBuilder =
773 InstanceIdentifier.<Vnfs>builder(Vnfs.class)
774 .child(VnfList.class, entry.getKey());
775 InstanceIdentifier<VnfList> path = vnfListIdBuilder.build();
780 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
782 tx.merge(storeType, path, entry);
784 tx.put(storeType, path, entry);
786 tx.submit().checkedGet();
787 log.debug("Update DataStore succeeded");
789 } catch (final TransactionCommitFailedException e) {
790 if(e instanceof OptimisticLockFailedException) {
792 log.debug("Got OptimisticLockFailedException on last try - failing ");
793 throw new IllegalStateException(e);
795 log.debug("Got OptimisticLockFailedException - trying again ");
797 log.debug("Update DataStore failed");
798 throw new IllegalStateException(e);
804 private void DeleteVnfList (final VnfList entry, LogicalDatastoreType storeType) throws IllegalStateException {
805 // Each entry will be identifiable by a unique key, we have to create that identifier
806 InstanceIdentifier.InstanceIdentifierBuilder<VnfList> vnfListIdBuilder =
807 InstanceIdentifier.<Vnfs>builder(Vnfs.class)
808 .child(VnfList.class, entry.getKey());
809 InstanceIdentifier<VnfList> path = vnfListIdBuilder.build();
814 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
815 tx.delete(storeType, path);
816 tx.submit().checkedGet();
817 log.debug("DataStore delete succeeded");
819 } catch (final TransactionCommitFailedException e) {
820 if (e instanceof OptimisticLockFailedException) {
822 log.debug("Got OptimisticLockFailedException on last try - failing ");
823 throw new IllegalStateException(e);
825 log.debug("Got OptimisticLockFailedException - trying again ");
827 log.debug("Delete DataStore failed");
828 throw new IllegalStateException(e);
835 private void SaveVnfInstanceList (final VnfInstanceList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException {
836 // Each entry will be identifiable by a unique key, we have to create that identifier
837 InstanceIdentifier.InstanceIdentifierBuilder<VnfInstanceList> vnfInstanceListIdBuilder =
838 InstanceIdentifier.<VnfInstances>builder(VnfInstances.class)
839 .child(VnfInstanceList.class, entry.getKey());
840 InstanceIdentifier<VnfInstanceList> path = vnfInstanceListIdBuilder.build();
845 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
847 tx.merge(storeType, path, entry);
849 tx.put(storeType, path, entry);
851 tx.submit().checkedGet();
852 log.debug("Update DataStore succeeded");
854 } catch (final TransactionCommitFailedException e) {
855 if(e instanceof OptimisticLockFailedException) {
857 log.debug("Got OptimisticLockFailedException on last try - failing ");
858 throw new IllegalStateException(e);
860 log.debug("Got OptimisticLockFailedException - trying again ");
862 log.debug("Update DataStore failed");
863 throw new IllegalStateException(e);
870 private void SaveVfModuleList (final VfModuleList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException {
871 // Each entry will be identifiable by a unique key, we have to create that identifier
872 InstanceIdentifier.InstanceIdentifierBuilder<VfModuleList> vfModuleListIdBuilder =
873 InstanceIdentifier.<VfModules>builder(VfModules.class)
874 .child(VfModuleList.class, entry.getKey());
875 InstanceIdentifier<VfModuleList> path = vfModuleListIdBuilder.build();
880 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
882 tx.merge(storeType, path, entry);
884 tx.put(storeType, path, entry);
886 tx.submit().checkedGet();
887 log.debug("Update DataStore succeeded");
889 } catch (final TransactionCommitFailedException e) {
890 if(e instanceof OptimisticLockFailedException) {
892 log.debug("Got OptimisticLockFailedException on last try - failing ");
893 throw new IllegalStateException(e);
895 log.debug("Got OptimisticLockFailedException - trying again ");
897 log.debug("Update DataStore failed");
898 throw new IllegalStateException(e);
904 private void SavePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException{
906 // Each entry will be identifiable by a unique key, we have to create that identifier
907 InstanceIdentifier.InstanceIdentifierBuilder<VnfPreloadList> vnfListIdBuilder =
908 InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
909 .child(VnfPreloadList.class, entry.getKey());
910 InstanceIdentifier<VnfPreloadList> path = vnfListIdBuilder.build();
914 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
916 tx.merge(storeType, path, entry);
918 tx.put(storeType, path, entry);
920 tx.submit().checkedGet();
921 log.debug("Update DataStore succeeded");
923 } catch (final TransactionCommitFailedException e) {
924 if(e instanceof OptimisticLockFailedException) {
926 log.debug("Got OptimisticLockFailedException on last try - failing ");
927 throw new IllegalStateException(e);
929 log.debug("Got OptimisticLockFailedException - trying again ");
931 log.debug("Update DataStore failed");
932 throw new IllegalStateException(e);
938 //1610 preload vnf-instance
939 private void SaveVnfInstancePreloadList(final VnfInstancePreloadList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException{
941 // Each entry will be identifiable by a unique key, we have to create that identifier
942 InstanceIdentifier.InstanceIdentifierBuilder<VnfInstancePreloadList> vnfInstanceListIdBuilder =
943 InstanceIdentifier.<PreloadVnfInstances>builder(PreloadVnfInstances.class)
944 .child(VnfInstancePreloadList.class, entry.getKey());
945 InstanceIdentifier<VnfInstancePreloadList> path = vnfInstanceListIdBuilder.build();
949 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
951 tx.merge(storeType, path, entry);
953 tx.put(storeType, path, entry);
955 tx.submit().checkedGet();
956 log.debug("Update DataStore succeeded");
958 } catch (final TransactionCommitFailedException e) {
959 if(e instanceof OptimisticLockFailedException) {
961 log.debug("Got OptimisticLockFailedException on last try - failing ");
962 throw new IllegalStateException(e);
964 log.debug("Got OptimisticLockFailedException - trying again ");
966 log.debug("Update DataStore failed");
967 throw new IllegalStateException(e);
973 //1610 preload vf-module
974 private void SaveVfModulePreloadList(final VfModulePreloadList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException{
976 // Each entry will be identifiable by a unique key, we have to create that identifier
977 InstanceIdentifier.InstanceIdentifierBuilder<VfModulePreloadList> vfModuleListIdBuilder =
978 InstanceIdentifier.<PreloadVfModules>builder(PreloadVfModules.class)
979 .child(VfModulePreloadList.class, entry.getKey());
980 InstanceIdentifier<VfModulePreloadList> path = vfModuleListIdBuilder.build();
984 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
986 tx.merge(storeType, path, entry);
988 tx.put(storeType, path, entry);
990 tx.submit().checkedGet();
991 log.debug("Update DataStore succeeded");
993 } catch (final TransactionCommitFailedException e) {
994 if(e instanceof OptimisticLockFailedException) {
996 log.debug("Got OptimisticLockFailedException on last try - failing ");
997 throw new IllegalStateException(e);
999 log.debug("Got OptimisticLockFailedException - trying again ");
1001 log.debug("Update DataStore failed");
1002 throw new IllegalStateException(e);
1008 //Save the requestId into MDC
1009 private void setRequestIdAsMDC(String requestId){
1010 MDC.put("RequestId", requestId);
1013 //1610 vnf-instance-topology-operation
1015 public Future<RpcResult<VnfInstanceTopologyOperationOutput>> vnfInstanceTopologyOperation(
1016 VnfInstanceTopologyOperationInput input) {
1018 final String SVC_OPERATION = "vnf-instance-topology-operation";
1019 VnfInstanceServiceData vnfInstanceServiceData = null;
1020 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1021 Properties parms = new Properties();
1023 log.info( SVC_OPERATION +" called." );
1024 // create a new response object
1025 VnfInstanceTopologyOperationOutputBuilder responseBuilder = new VnfInstanceTopologyOperationOutputBuilder();
1027 //if(input == null || input.getVnfInstanceRequestInformation().getVnfInstanceTopologyIdentifier().getVnfInstanceId() == null )
1029 input.getVnfInstanceRequestInformation() == null ||
1030 input.getVnfInstanceRequestInformation().getVnfInstanceId() == null )
1032 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-instance-id");
1033 responseBuilder.setResponseCode("403");
1034 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1035 responseBuilder.setAckFinalIndicator("Y");
1036 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1037 RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1039 return Futures.immediateFuture(rpcResult);
1042 // Grab the service instance ID from the input buffer
1043 String viid = input.getVnfInstanceRequestInformation().getVnfInstanceId();
1044 String preload_name = input.getVnfInstanceRequestInformation().getVnfInstanceName();
1045 String preload_type = input.getVnfInstanceRequestInformation().getVnfModelId();
1047 // Make sure we have a valid viid
1048 if(viid == null || viid.length() == 0 ) {
1049 log.debug("exiting "+SVC_OPERATION+" because of invalid vnf-instance-id");
1050 responseBuilder.setResponseCode("403");
1051 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1052 responseBuilder.setAckFinalIndicator("Y");
1053 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1054 RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1056 return Futures.immediateFuture(rpcResult);
1059 if (input.getSdncRequestHeader() != null) {
1060 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1061 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1064 // Get vnf-instance-preload-data
1065 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
1066 getVnfInstancePreloadData(preload_name, preload_type, vnfInstancePreloadDataBuilder);
1069 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1070 getVnfInstanceServiceData(viid,vnfInstanceServiceDataBuilder);
1072 // Get operational-data
1073 VnfInstanceServiceDataBuilder operDataBuilder = new VnfInstanceServiceDataBuilder();
1074 getVnfInstanceServiceData(viid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1076 // Set the serviceStatus based on input
1077 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1078 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1081 // setup a service-data object builder
1082 // ACTION vnf-topology-operation
1084 // USES sdnc-request-header;
1085 // USES request-information;
1086 // USES service-information;
1087 // USES vnf-request-information
1089 // USES vnf-topology-response-body;
1090 // USES vnf-information
1091 // USES service-information
1093 // container service-data
1094 // uses vnf-configuration-information;
1095 // uses oper-status;
1097 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+viid+"] input: " + input);
1098 VnfInstanceTopologyOperationInputBuilder inputBuilder = new VnfInstanceTopologyOperationInputBuilder(input);
1099 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1101 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+viid+"] operational-data: " + operDataBuilder.build());
1102 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1104 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " + vnfInstancePreloadDataBuilder.build());
1105 VnfSdnUtil.toProperties(parms, "vnf-instance-preload-data", vnfInstancePreloadDataBuilder);
1107 // Call SLI sync method
1108 // Get SvcLogicService reference
1110 Properties respProps = null;
1112 String errorCode = "200";
1113 String errorMessage = null;
1114 String ackFinal = "Y";
1119 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1124 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", vnfInstanceServiceDataBuilder, parms);
1128 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1129 errorMessage = e.getMessage();
1133 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1140 errorMessage = e.getMessage();
1141 log.error("Caught exception looking for service logic", e);
1145 if (respProps != null)
1147 errorCode = respProps.getProperty("error-code");
1148 errorMessage = respProps.getProperty("error-message");
1149 ackFinal = respProps.getProperty("ack-final", "Y");
1152 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
1153 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1154 serviceStatusBuilder.setRpcName(RpcName.VnfInstanceTopologyOperation);
1156 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1157 responseBuilder.setResponseCode(errorCode);
1158 responseBuilder.setResponseMessage(errorMessage);
1159 responseBuilder.setAckFinalIndicator(ackFinal);
1160 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1161 vnfInstanceListBuilder.setVnfInstanceId(viid);
1162 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1164 SaveVnfInstanceList (vnfInstanceListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
1165 } catch (Exception e) {
1166 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+viid+"] \n",e);
1168 log.error("Returned FAILED for "+SVC_OPERATION+" ["+viid+"] " + responseBuilder.build());
1169 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1170 RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1172 return Futures.immediateFuture(rpcResult);
1175 // Got success from SLI
1177 vnfInstanceServiceData = vnfInstanceServiceDataBuilder.build();
1178 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+viid+"] VnfInstanceServiceData: " + vnfInstanceServiceData);
1179 // svc-configuration-list
1180 VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1181 vnfInstanceListBuilder.setVnfInstanceServiceData(vnfInstanceServiceData);
1182 vnfInstanceListBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
1183 //siid = vnfInstanceServiceData.getVnfInstanceId();
1184 vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1185 SaveVnfInstanceList (vnfInstanceListBuilder.build(), false,LogicalDatastoreType.CONFIGURATION);
1186 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1188 // Only update operational tree on Delete or Activate
1189 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
1190 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1192 log.info("Updating OPERATIONAL tree.");
1193 SaveVnfInstanceList (vnfInstanceListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1196 VnfInstanceInformationBuilder vnfInstanceInformationBuilder = new VnfInstanceInformationBuilder();
1197 vnfInstanceInformationBuilder.setVnfInstanceId(viid);
1198 responseBuilder.setVnfInstanceInformation(vnfInstanceInformationBuilder.build());
1199 responseBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
1200 } catch (Exception e) {
1201 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+viid+"] \n",e);
1202 responseBuilder.setResponseCode("500");
1203 responseBuilder.setResponseMessage(e.toString());
1204 responseBuilder.setAckFinalIndicator("Y");
1205 log.error("Returned FAILED for "+SVC_OPERATION+" ["+viid+"] " + responseBuilder.build());
1206 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1207 RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1209 return Futures.immediateFuture(rpcResult);
1213 responseBuilder.setResponseCode(errorCode);
1214 responseBuilder.setAckFinalIndicator(ackFinal);
1215 if (errorMessage != null)
1217 responseBuilder.setResponseMessage(errorMessage);
1219 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+viid+"] ");
1220 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+viid+"] " + responseBuilder.build());
1222 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1223 RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1225 return Futures.immediateFuture(rpcResult);
1228 //1610 vf-module-topology-operation
1230 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1231 VfModuleTopologyOperationInput input) {
1233 final String SVC_OPERATION = "vf-module-topology-operation";
1234 VfModuleServiceData vfModuleServiceData = null;
1235 VnfInstanceServiceData vnfInstanceServiceData = null;
1236 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1237 Properties parms = new Properties();
1239 log.info( SVC_OPERATION +" called." );
1240 // create a new response object
1241 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1243 // Validate vf-module-id from vf-module-request-information
1245 input.getVfModuleRequestInformation() == null ||
1246 input.getVfModuleRequestInformation().getVfModuleId() == null)
1248 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vf-module-id");
1249 responseBuilder.setResponseCode("403");
1250 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1251 responseBuilder.setAckFinalIndicator("Y");
1252 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1253 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1255 return Futures.immediateFuture(rpcResult);
1258 // Grab the vf-module-request-information.vf-module-id from the input buffer
1259 String vfid = input.getVfModuleRequestInformation().getVfModuleId();
1260 String preload_name = input.getVfModuleRequestInformation().getVfModuleName();
1261 String preload_type = input.getVfModuleRequestInformation().getVfModuleModelId();
1263 // Make sure we have a valid siid
1264 if(vfid == null || vfid.length() == 0 ) {
1265 log.debug("exiting "+SVC_OPERATION+" because of invalid vf-module-id");
1266 responseBuilder.setResponseCode("403");
1267 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1268 responseBuilder.setAckFinalIndicator("Y");
1269 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1270 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1272 return Futures.immediateFuture(rpcResult);
1275 // 1610 add vf-module-id to vnf-instance-list.vf-module-relationship-list
1276 String viid = input.getVfModuleRequestInformation().getVnfInstanceId();
1278 if(viid == null || viid.length() == 0 ) {
1279 log.debug("exiting "+SVC_OPERATION+" because of invalid vnf-instance-id");
1280 responseBuilder.setResponseCode("403");
1281 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1282 responseBuilder.setAckFinalIndicator("Y");
1283 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1284 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1286 return Futures.immediateFuture(rpcResult);
1289 if (input.getSdncRequestHeader() != null) {
1290 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1291 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1294 // Get vf-module-preload-data
1295 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
1296 getVfModulePreloadData(preload_name, preload_type, vfModulePreloadDataBuilder);
1298 // Get vf-module-service-data
1299 VfModuleServiceDataBuilder vfModuleServiceDataBuilder = new VfModuleServiceDataBuilder();
1300 getVfModuleServiceData(vfid,vfModuleServiceDataBuilder);
1302 // Get vf-module operation-data
1303 VfModuleServiceDataBuilder operDataBuilder = new VfModuleServiceDataBuilder();
1304 getVfModuleServiceData(vfid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1306 // save service-data builder object for rollback
1307 VfModuleServiceDataBuilder rb_vfModuleServiceDataBuilder = vfModuleServiceDataBuilder;
1308 VfModuleServiceDataBuilder rb_operDataBuilder = operDataBuilder;
1310 // 1610 Need to pull vnf-instance-list.vf-module-relationship-list from MD-SAL
1311 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1312 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1314 // vnf-instance operational-data
1315 VnfInstanceServiceDataBuilder vnfInstanceOperDataBuilder = new VnfInstanceServiceDataBuilder();
1316 getVnfInstanceServiceData(viid, vnfInstanceOperDataBuilder, LogicalDatastoreType.OPERATIONAL );
1318 // save operational builder object for rollback
1319 VnfInstanceServiceDataBuilder rb_vnfInstanceServiceDataBuilder = vnfInstanceServiceDataBuilder;
1320 VnfInstanceServiceDataBuilder rb_vnfInstanceOperDataBuilder = vnfInstanceOperDataBuilder;
1322 // Set the serviceStatus based on input
1323 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1324 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1327 // setup a service-data object builder
1328 // ACTION vnf-topology-operation
1330 // USES sdnc-request-header;
1331 // USES request-information;
1332 // USES service-information;
1333 // USES vnf-request-information
1335 // USES vnf-topology-response-body;
1336 // USES vnf-information
1337 // USES service-information
1339 // container service-data
1340 // uses vnf-configuration-information;
1341 // uses oper-status;
1343 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+vfid+"] input: " + input);
1344 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1345 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1347 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+vfid+"] vf-module operational-data: " + operDataBuilder.build());
1348 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1350 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] vf-module-preload-data: " + vfModulePreloadDataBuilder.build());
1351 VnfSdnUtil.toProperties(parms, "vf-module-preload-data", vfModulePreloadDataBuilder);
1353 log.info("Adding vnf-instance CONFIG data for "+SVC_OPERATION+" ["+viid+"] vnf-instance-service-data: " + vnfInstanceServiceDataBuilder.build());
1354 VnfSdnUtil.toProperties(parms, "vnf-instance-service-data", vnfInstanceServiceDataBuilder);
1356 log.info("Adding vnf-instance OPERATIONAL data for "+SVC_OPERATION+" ["+viid+"] vnf-instance operational-data: " + vnfInstanceOperDataBuilder.build());
1357 VnfSdnUtil.toProperties(parms, "vnf-instance-operational-data", vnfInstanceOperDataBuilder);
1359 // Call SLI sync method
1360 // Get SvcLogicService reference
1362 Properties respProps = null;
1364 String errorCode = "200";
1365 String errorMessage = null;
1366 String ackFinal = "Y";
1371 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1376 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", vfModuleServiceDataBuilder, parms);
1380 log.error("Caught exception executing service logic on vf-module for "+ SVC_OPERATION, e);
1381 errorMessage = e.getMessage();
1386 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1393 errorMessage = e.getMessage();
1394 log.error("Caught exception looking for service logic", e);
1398 if (respProps != null) {
1399 errorCode = respProps.getProperty("error-code");
1400 errorMessage = respProps.getProperty("error-message");
1401 ackFinal = respProps.getProperty("ack-final", "Y");
1404 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
1405 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1406 serviceStatusBuilder.setRpcName(RpcName.VfModuleTopologyOperation);
1408 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1409 responseBuilder.setResponseCode(errorCode);
1410 responseBuilder.setResponseMessage(errorMessage);
1411 responseBuilder.setAckFinalIndicator(ackFinal);
1412 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1413 vfModuleListBuilder.setVfModuleId(vfid);
1414 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1416 SaveVfModuleList (vfModuleListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
1417 } catch (Exception e) {
1418 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+vfid+"] \n",e);
1420 log.error("Returned FAILED for "+SVC_OPERATION+" ["+vfid+"] " + responseBuilder.build());
1421 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1422 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1424 return Futures.immediateFuture(rpcResult);
1427 // Got success from SLI
1428 // save vf-module-service-data in MD-SAL
1430 vfModuleServiceData = vfModuleServiceDataBuilder.build();
1431 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+vfid+"] VfModuleServiceData: " + vfModuleServiceData);
1433 VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1434 vfModuleListBuilder.setVfModuleServiceData(vfModuleServiceData);
1435 vfModuleListBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
1436 //vfid = vfModuleServiceData.getVfModuleId();
1437 vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1438 SaveVfModuleList (vfModuleListBuilder.build(), false,LogicalDatastoreType.CONFIGURATION);
1439 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1441 // Only update operational tree on Delete or Activate
1442 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
1443 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1445 log.info("Updating OPERATIONAL tree.");
1446 SaveVfModuleList (vfModuleListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1449 VfModuleInformationBuilder vfModuleInformationBuilder = new VfModuleInformationBuilder();
1450 vfModuleInformationBuilder.setVfModuleId(vfid);
1451 responseBuilder.setVfModuleInformation(vfModuleInformationBuilder.build());
1452 responseBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
1453 } catch (Exception e) {
1454 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+vfid+"] \n",e);
1455 responseBuilder.setResponseCode("500");
1456 responseBuilder.setResponseMessage(e.toString());
1457 responseBuilder.setAckFinalIndicator("Y");
1458 log.error("Returned FAILED for "+SVC_OPERATION+" ["+vfid+"] " + responseBuilder.build());
1459 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1460 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1462 return Futures.immediateFuture(rpcResult);
1466 responseBuilder.setResponseCode(errorCode);
1467 responseBuilder.setAckFinalIndicator(ackFinal);
1468 if (errorMessage != null)
1470 responseBuilder.setResponseMessage(errorMessage);
1472 log.info("Updated vf-module in MD-SAL for "+SVC_OPERATION+" ["+vfid+"] ");
1473 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+vfid+"] " + responseBuilder.build());
1475 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1476 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1478 return Futures.immediateFuture(rpcResult);
1483 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(
1484 VnfTopologyOperationInput input) {
1486 final String SVC_OPERATION = "vnf-topology-operation";
1487 ServiceData serviceData = null;
1488 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1489 Properties parms = new Properties();
1491 log.info( SVC_OPERATION +" called." );
1492 // create a new response object
1493 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1496 input.getServiceInformation() == null ||
1497 input.getServiceInformation().getServiceInstanceId() == null ||
1498 input.getServiceInformation().getServiceInstanceId().length() == 0)
1500 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty service-instance-id");
1501 responseBuilder.setResponseCode("403");
1502 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1503 responseBuilder.setAckFinalIndicator("Y");
1504 RpcResult<VnfTopologyOperationOutput> rpcResult =
1505 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1507 return Futures.immediateFuture(rpcResult);
1510 if(input.getVnfRequestInformation() == null ||
1511 input.getVnfRequestInformation().getVnfId() == null ||
1512 input.getVnfRequestInformation().getVnfId().length() == 0)
1514 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vf-module-id");
1515 responseBuilder.setResponseCode("403");
1516 responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1517 responseBuilder.setAckFinalIndicator("Y");
1518 RpcResult<VnfTopologyOperationOutput> rpcResult =
1519 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1521 return Futures.immediateFuture(rpcResult);
1524 // Grab the service instance ID from the input buffer
1525 String siid = input.getVnfRequestInformation().getVnfId();
1526 String preload_name = input.getVnfRequestInformation().getVnfName();
1527 String preload_type = input.getVnfRequestInformation().getVnfType();
1530 // Make sure we have a valid siid
1531 if(siid == null || siid.length() == 0 ) {
1532 log.debug("exiting "+SVC_OPERATION+" because of invalid siid");
1533 responseBuilder.setResponseCode("403");
1534 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1535 responseBuilder.setAckFinalIndicator("Y");
1536 RpcResult<VnfTopologyOperationOutput> rpcResult =
1537 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1539 return Futures.immediateFuture(rpcResult);
1543 if (input.getSdncRequestHeader() != null) {
1544 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1545 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1548 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1549 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1551 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1552 getServiceData(siid,serviceDataBuilder);
1554 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1555 getServiceData(siid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1557 // Set the serviceStatus based on input
1558 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1559 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1562 // setup a service-data object builder
1563 // ACTION vnf-topology-operation
1565 // USES sdnc-request-header;
1566 // USES request-information;
1567 // USES service-information;
1568 // USES vnf-request-information
1570 // USES vnf-topology-response-body;
1571 // USES vnf-information
1572 // USES service-information
1574 // container service-data
1575 // uses vnf-configuration-information;
1576 // uses oper-status;
1578 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+siid+"] input: " + input);
1579 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1580 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1582 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+siid+"] operational-data: " + operDataBuilder.build());
1583 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1585 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " + preloadDataBuilder.build());
1586 VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1588 // Call SLI sync method
1589 // Get SvcLogicService reference
1591 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 Properties respProps = null;
1802 String errorCode = "200";
1803 String errorMessage = null;
1804 String ackFinal = "Y";
1805 String networkId = "error";
1810 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1815 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1819 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1820 errorMessage = e.getMessage();
1824 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1831 errorMessage = e.getMessage();
1832 log.error("Caught exception looking for service logic", e);
1836 if (respProps != null)
1838 errorCode = respProps.getProperty("error-code");
1839 errorMessage = respProps.getProperty("error-message");
1840 ackFinal = respProps.getProperty("ack-final", "Y");
1841 networkId = respProps.getProperty("networkId","0");
1844 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1845 responseBuilder.setResponseCode(errorCode);
1846 responseBuilder.setResponseMessage(errorMessage);
1847 responseBuilder.setAckFinalIndicator(ackFinal);
1849 log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1851 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1852 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1854 return Futures.immediateFuture(rpcResult);
1857 // Got success from SLI
1859 NetworkInformationBuilder networkInformationBuilder = new NetworkInformationBuilder();
1860 networkInformationBuilder.setNetworkId(networkId);
1861 responseBuilder.setNetworkInformation(networkInformationBuilder.build());
1862 responseBuilder.setServiceInformation(input.getServiceInformation());
1863 } catch (IllegalStateException e) {
1864 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
1865 responseBuilder.setResponseCode("500");
1866 responseBuilder.setResponseMessage(e.toString());
1867 responseBuilder.setAckFinalIndicator("Y");
1868 log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1869 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1870 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1872 return Futures.immediateFuture(rpcResult);
1876 responseBuilder.setResponseCode(errorCode);
1877 responseBuilder.setAckFinalIndicator(ackFinal);
1878 if (errorMessage != null)
1880 responseBuilder.setResponseMessage(errorMessage);
1882 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+siid+"] ");
1883 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1885 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1886 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1888 return Futures.immediateFuture(rpcResult);
1892 public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1893 PreloadVnfTopologyOperationInput input) {
1895 final String SVC_OPERATION = "preload-vnf-topology-operation";
1896 PreloadData preloadData = null;
1897 Properties parms = new Properties();
1899 log.info( SVC_OPERATION +" called." );
1900 // create a new response object
1901 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1903 // Result from savePreloadData
1904 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1906 if(input == null || input.getVnfTopologyInformation() == null || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName() == null || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType() == null) {
1907 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-name and vnf-type");
1908 responseBuilder.setResponseCode("403");
1909 responseBuilder.setResponseMessage("invalid input, null or empty vnf-name and vnf-type");
1910 responseBuilder.setAckFinalIndicator("Y");
1911 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1912 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1913 return Futures.immediateFuture(rpcResult);
1916 // Grab the name and type from the input buffer
1917 String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1918 String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1920 // Make sure we have a preload_name and preload_type
1921 if(preload_name == null || preload_name.length() == 0 ) {
1922 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-name");
1923 responseBuilder.setResponseCode("403");
1924 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1925 responseBuilder.setAckFinalIndicator("Y");
1926 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1927 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1928 return Futures.immediateFuture(rpcResult);
1930 if(preload_type == null || preload_type.length() == 0 ) {
1931 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-type");
1932 responseBuilder.setResponseCode("403");
1933 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1934 responseBuilder.setAckFinalIndicator("Y");
1935 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1936 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1937 return Futures.immediateFuture(rpcResult);
1940 if (input.getSdncRequestHeader() != null) {
1941 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1942 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1945 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1946 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1947 //preloadData = preloadDataBuilder.build();
1949 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1950 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1953 // setup a preload-data object builder
1954 // ACTION vnf-topology-operation
1956 // USES sdnc-request-header;
1957 // USES request-information;
1958 // uses vnf-topology-information;
1960 // USES vnf-topology-response-body;
1962 // container preload-data
1963 // uses vnf-configuration-information;
1966 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
1967 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1968 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1969 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
1970 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1972 // Call SLI sync method
1973 // Get SvcLogicService reference
1975 Properties respProps = null;
1977 String errorCode = "200";
1978 String errorMessage = null;
1979 String ackFinal = "Y";
1984 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1989 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1993 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1994 errorMessage = e.getMessage();
1998 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2005 errorMessage = e.getMessage();
2006 log.error("Caught exception looking for service logic", e);
2010 if (respProps != null)
2012 errorCode = respProps.getProperty("error-code");
2013 errorMessage = respProps.getProperty("error-message");
2014 ackFinal = respProps.getProperty("ack-final", "Y");
2015 // internalError = respProps.getProperty("internal-error", "false");
2018 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2020 responseBuilder.setResponseCode(errorCode);
2021 responseBuilder.setResponseMessage(errorMessage);
2022 responseBuilder.setAckFinalIndicator(ackFinal);
2024 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2025 preloadVnfListBuilder.setVnfName(preload_name);
2026 preloadVnfListBuilder.setVnfType(preload_type);
2027 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2028 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
2030 SavePreloadList (preloadVnfListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
2031 } catch (Exception e) {
2032 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2034 log.debug("Sending Success rpc result due to external error");
2035 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2036 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2037 return Futures.immediateFuture(rpcResult);
2040 // Got success from SLI
2042 preloadData = preloadDataBuilder.build();
2043 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + preloadData);
2044 // svc-configuration-list
2045 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2046 preloadVnfListBuilder.setVnfName(preload_name);
2047 preloadVnfListBuilder.setVnfType(preload_type);
2048 preloadVnfListBuilder.setPreloadData(preloadData);
2050 // SDNGC-989 set merge flag to false
2051 SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2052 log.info("Updating OPERATIONAL tree.");
2053 SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2054 } catch (Exception e) {
2055 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2056 responseBuilder.setResponseCode("500");
2057 responseBuilder.setResponseMessage(e.toString());
2058 responseBuilder.setAckFinalIndicator("Y");
2059 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2060 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2061 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2062 return Futures.immediateFuture(rpcResult);
2066 responseBuilder.setResponseCode(errorCode);
2067 responseBuilder.setAckFinalIndicator(ackFinal);
2068 if (errorMessage != null)
2070 responseBuilder.setResponseMessage(errorMessage);
2072 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
2073 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2075 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2076 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2077 return Futures.immediateFuture(rpcResult);
2080 //1610 preload-vnf-instance-topology-operation
2082 public Future<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> preloadVnfInstanceTopologyOperation(
2083 PreloadVnfInstanceTopologyOperationInput input) {
2085 final String SVC_OPERATION = "preload-vnf-instance-topology-operation";
2086 VnfInstancePreloadData vnfInstancePreloadData = null;
2087 Properties parms = new Properties();
2089 log.info( SVC_OPERATION +" called." );
2090 // create a new response object
2091 PreloadVnfInstanceTopologyOperationOutputBuilder responseBuilder = new PreloadVnfInstanceTopologyOperationOutputBuilder();
2093 // Result from savePreloadData
2094 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2097 input.getVnfInstanceTopologyInformation() == null ||
2098 input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName() == null ||
2099 input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId() == null)
2101 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-instance-name and vnf-model-id");
2102 responseBuilder.setResponseCode("403");
2103 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name and vnf-model-id");
2104 responseBuilder.setAckFinalIndicator("Y");
2105 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2106 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2107 return Futures.immediateFuture(rpcResult);
2110 // Grab the name and type from the input buffer
2111 String preload_name = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName();
2112 String preload_type = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId();
2114 // Make sure we have a preload_name and preload_type
2115 if(preload_name == null || preload_name.length() == 0 ) {
2116 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-name");
2117 responseBuilder.setResponseCode("403");
2118 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2119 responseBuilder.setAckFinalIndicator("Y");
2120 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2121 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2122 return Futures.immediateFuture(rpcResult);
2124 if(preload_type == null || preload_type.length() == 0 ) {
2125 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-type");
2126 responseBuilder.setResponseCode("403");
2127 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2128 responseBuilder.setAckFinalIndicator("Y");
2129 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2130 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2131 return Futures.immediateFuture(rpcResult);
2134 if (input.getSdncRequestHeader() != null) {
2135 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2136 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2139 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
2140 getVnfInstancePreloadData(preload_name, preload_type, vnfInstancePreloadDataBuilder);
2141 //preloadData = preloadDataBuilder.build();
2143 VnfInstancePreloadDataBuilder operDataBuilder = new VnfInstancePreloadDataBuilder();
2144 getVnfInstancePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
2147 // setup a preload-data object builder
2148 // ACTION vnf-topology-operation
2150 // USES sdnc-request-header;
2151 // USES request-information;
2152 // uses vnf-topology-information;
2154 // USES vnf-topology-response-body;
2156 // container preload-data
2157 // uses vnf-configuration-information;
2160 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
2161 PreloadVnfInstanceTopologyOperationInputBuilder inputBuilder = new PreloadVnfInstanceTopologyOperationInputBuilder(input);
2162 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2163 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
2164 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2166 // Call SLI sync method
2167 // Get SvcLogicService reference
2169 Properties respProps = null;
2171 String errorCode = "200";
2172 String errorMessage = null;
2173 String ackFinal = "Y";
2178 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
2183 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", vnfInstancePreloadDataBuilder, parms);
2187 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
2188 errorMessage = e.getMessage();
2192 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2199 errorMessage = e.getMessage();
2200 log.error("Caught exception looking for service logic", e);
2204 if (respProps != null)
2206 errorCode = respProps.getProperty("error-code");
2207 errorMessage = respProps.getProperty("error-message");
2208 ackFinal = respProps.getProperty("ack-final", "Y");
2209 // internalError = respProps.getProperty("internal-error", "false");
2212 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2214 responseBuilder.setResponseCode(errorCode);
2215 responseBuilder.setResponseMessage(errorMessage);
2216 responseBuilder.setAckFinalIndicator(ackFinal);
2218 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2219 vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2220 vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2221 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadDataBuilder.build());
2222 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
2224 SaveVnfInstancePreloadList (vnfInstancePreloadListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
2225 } catch (Exception e) {
2226 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2228 log.debug("Sending Success rpc result due to external error");
2229 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2230 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2231 return Futures.immediateFuture(rpcResult);
2234 // Got success from SLI
2236 vnfInstancePreloadData = vnfInstancePreloadDataBuilder.build();
2237 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + vnfInstancePreloadData);
2238 // svc-configuration-list
2239 VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2240 vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2241 vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2242 vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadData);
2244 // SDNGC-989 set merge flag to false
2245 SaveVnfInstancePreloadList (vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2246 log.info("Updating OPERATIONAL tree.");
2247 SaveVnfInstancePreloadList (vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2248 } catch (Exception e) {
2249 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2250 responseBuilder.setResponseCode("500");
2251 responseBuilder.setResponseMessage(e.toString());
2252 responseBuilder.setAckFinalIndicator("Y");
2253 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2254 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2255 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2256 return Futures.immediateFuture(rpcResult);
2260 responseBuilder.setResponseCode(errorCode);
2261 responseBuilder.setAckFinalIndicator(ackFinal);
2262 if (errorMessage != null)
2264 responseBuilder.setResponseMessage(errorMessage);
2266 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
2267 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2269 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2270 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2271 return Futures.immediateFuture(rpcResult);
2275 //1610 preload-vf-module-topology-operation
2277 public Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2278 PreloadVfModuleTopologyOperationInput input) {
2280 final String SVC_OPERATION = "preload-vf-module-topology-operation";
2281 VfModulePreloadData vfModulePreloadData = null;
2282 Properties parms = new Properties();
2284 log.info( SVC_OPERATION +" called." );
2285 // create a new response object
2286 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder = new PreloadVfModuleTopologyOperationOutputBuilder();
2288 // Result from savePreloadData
2289 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2292 input.getVfModuleTopologyInformation() == null ||
2293 input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName() == null ||
2294 input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId() == null)
2296 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-instance-name and vnf-model-id");
2297 responseBuilder.setResponseCode("403");
2298 responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name and vnf-model-id");
2299 responseBuilder.setAckFinalIndicator("Y");
2300 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2301 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2302 return Futures.immediateFuture(rpcResult);
2305 // Grab the name and type from the input buffer
2306 String preload_name = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName();
2307 String preload_type = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId();
2309 // Make sure we have a preload_name and preload_type
2310 if(preload_name == null || preload_name.length() == 0 ) {
2311 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-name");
2312 responseBuilder.setResponseCode("403");
2313 responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2314 responseBuilder.setAckFinalIndicator("Y");
2315 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2316 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2317 return Futures.immediateFuture(rpcResult);
2319 if(preload_type == null || preload_type.length() == 0 ) {
2320 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-type");
2321 responseBuilder.setResponseCode("403");
2322 responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2323 responseBuilder.setAckFinalIndicator("Y");
2324 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2325 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2326 return Futures.immediateFuture(rpcResult);
2329 if (input.getSdncRequestHeader() != null) {
2330 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2331 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2334 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
2335 getVfModulePreloadData(preload_name, preload_type, vfModulePreloadDataBuilder);
2336 //preloadData = preloadDataBuilder.build();
2338 VfModulePreloadDataBuilder operDataBuilder = new VfModulePreloadDataBuilder();
2339 getVfModulePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
2342 // setup a preload-data object builder
2343 // ACTION vnf-topology-operation
2345 // USES sdnc-request-header;
2346 // USES request-information;
2347 // uses vnf-topology-information;
2349 // USES vnf-topology-response-body;
2351 // container preload-data
2352 // uses vnf-configuration-information;
2355 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
2356 PreloadVfModuleTopologyOperationInputBuilder inputBuilder = new PreloadVfModuleTopologyOperationInputBuilder(input);
2357 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2358 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
2359 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2361 // Call SLI sync method
2362 // Get SvcLogicService reference
2365 Properties respProps = null;
2367 String errorCode = "200";
2368 String errorMessage = null;
2369 String ackFinal = "Y";
2374 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
2379 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", vfModulePreloadDataBuilder, parms);
2383 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
2384 errorMessage = e.getMessage();
2388 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2395 errorMessage = e.getMessage();
2396 log.error("Caught exception looking for service logic", e);
2400 if (respProps != null)
2402 errorCode = respProps.getProperty("error-code");
2403 errorMessage = respProps.getProperty("error-message");
2404 ackFinal = respProps.getProperty("ack-final", "Y");
2405 // internalError = respProps.getProperty("internal-error", "false");
2408 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2410 responseBuilder.setResponseCode(errorCode);
2411 responseBuilder.setResponseMessage(errorMessage);
2412 responseBuilder.setAckFinalIndicator(ackFinal);
2414 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2415 vfModulePreloadListBuilder.setVfModuleName(preload_name);
2416 vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2417 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadDataBuilder.build());
2418 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
2420 SaveVfModulePreloadList (vfModulePreloadListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
2421 } catch (Exception e) {
2422 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2424 log.debug("Sending Success rpc result due to external error");
2425 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2426 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2427 return Futures.immediateFuture(rpcResult);
2430 // Got success from SLI
2432 vfModulePreloadData = vfModulePreloadDataBuilder.build();
2433 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + vfModulePreloadData);
2434 // svc-configuration-list
2435 VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2436 vfModulePreloadListBuilder.setVfModuleName(preload_name);
2437 vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2438 vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadData);
2440 // SDNGC-989 set merge flag to false
2441 SaveVfModulePreloadList (vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2442 log.info("Updating OPERATIONAL tree.");
2443 SaveVfModulePreloadList (vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2444 } catch (Exception e) {
2445 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2446 responseBuilder.setResponseCode("500");
2447 responseBuilder.setResponseMessage(e.toString());
2448 responseBuilder.setAckFinalIndicator("Y");
2449 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2450 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2451 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2452 return Futures.immediateFuture(rpcResult);
2456 responseBuilder.setResponseCode(errorCode);
2457 responseBuilder.setAckFinalIndicator(ackFinal);
2458 if (errorMessage != null)
2460 responseBuilder.setResponseMessage(errorMessage);
2462 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
2463 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2465 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2466 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2467 return Futures.immediateFuture(rpcResult);
2472 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2473 PreloadNetworkTopologyOperationInput input) {
2475 final String SVC_OPERATION = "preload-network-topology-operation";
2476 PreloadData preloadData = null;
2477 Properties parms = new Properties();
2479 log.info( SVC_OPERATION +" called." );
2480 // create a new response object
2481 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2483 // Result from savePreloadData
2484 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2486 if(input == null || input.getNetworkTopologyInformation() == null || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName() == null || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType() == null) {
2487 log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-name and vnf-type");
2488 responseBuilder.setResponseCode("403");
2489 responseBuilder.setResponseMessage("input, null or empty vnf-name and vnf-type");
2490 responseBuilder.setAckFinalIndicator("Y");
2491 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2492 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2493 return Futures.immediateFuture(rpcResult);
2496 // Grab the name and type from the input buffer
2497 String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2498 String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2500 // Make sure we have a preload_name and preload_type
2501 if(preload_name == null || preload_name.length() == 0 ) {
2502 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-name");
2503 responseBuilder.setResponseCode("403");
2504 responseBuilder.setResponseMessage("input, invalid preload-name");
2505 responseBuilder.setAckFinalIndicator("Y");
2506 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2507 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2508 return Futures.immediateFuture(rpcResult);
2510 if(preload_type == null || preload_type.length() == 0 ) {
2511 log.debug("exiting "+SVC_OPERATION+" because of invalid preload-type");
2512 responseBuilder.setResponseCode("403");
2513 responseBuilder.setResponseMessage("input, invalid preload-type");
2514 responseBuilder.setAckFinalIndicator("Y");
2515 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2516 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2517 return Futures.immediateFuture(rpcResult);
2520 if (input.getSdncRequestHeader() != null) {
2521 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2522 setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2525 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2526 getPreloadData(preload_name, preload_type, preloadDataBuilder);
2528 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2529 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
2532 // setup a preload-data object builder
2533 // ACTION vnf-topology-operation
2535 // USES sdnc-request-header;
2536 // USES request-information;
2537 // uses vnf-topology-information;
2539 // USES vnf-topology-response-body;
2541 // container preload-data
2542 // uses vnf-configuration-information;
2545 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
2546 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(input);
2547 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2548 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
2549 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2551 // Call SLI sync method
2552 // Get SvcLogicService reference
2554 Properties respProps = null;
2556 String errorCode = "200";
2557 String errorMessage = null;
2558 String ackFinal = "Y";
2563 if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
2568 respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2572 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
2573 errorMessage = e.getMessage();
2577 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2584 errorMessage = e.getMessage();
2585 log.error("Caught exception looking for service logic", e);
2589 if (respProps != null)
2591 errorCode = respProps.getProperty("error-code");
2592 errorMessage = respProps.getProperty("error-message");
2593 ackFinal = respProps.getProperty("ack-final", "Y");
2594 // internalError = respProps.getProperty("internal-error", "false");
2597 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2599 responseBuilder.setResponseCode(errorCode);
2600 responseBuilder.setResponseMessage(errorMessage);
2601 responseBuilder.setAckFinalIndicator(ackFinal);
2603 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2604 preloadVnfListBuilder.setVnfName(preload_name);
2605 preloadVnfListBuilder.setVnfType(preload_type);
2606 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2607 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
2609 SavePreloadList (preloadVnfListBuilder.build(),true,LogicalDatastoreType.CONFIGURATION);
2610 } catch (Exception e) {
2611 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2614 log.debug("Sending Success rpc result due to external error");
2615 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2616 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2617 return Futures.immediateFuture(rpcResult);
2620 // Got success from SLI
2622 preloadData = preloadDataBuilder.build();
2623 log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + preloadData);
2624 // svc-configuration-list
2625 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2626 preloadVnfListBuilder.setVnfName(preload_name);
2627 preloadVnfListBuilder.setVnfType(preload_type);
2628 preloadVnfListBuilder.setPreloadData(preloadData);
2630 // SDNGC-989 set merge flag to false
2631 SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2632 log.info("Updating OPERATIONAL tree.");
2633 SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2634 } catch (Exception e) {
2635 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2636 responseBuilder.setResponseCode("500");
2637 responseBuilder.setResponseMessage(e.toString());
2638 responseBuilder.setAckFinalIndicator("Y");
2639 log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2640 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2641 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2642 return Futures.immediateFuture(rpcResult);
2646 responseBuilder.setResponseCode(errorCode);
2647 responseBuilder.setAckFinalIndicator(ackFinal);
2648 if (errorMessage != null)
2650 responseBuilder.setResponseMessage(errorMessage);
2652 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
2653 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2655 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2656 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2657 return Futures.immediateFuture(rpcResult);