1 package org.onap.sdnc.northbound;
3 import java.text.DateFormat;
4 import java.text.SimpleDateFormat;
6 import java.util.Properties;
7 import java.util.TimeZone;
8 import java.util.concurrent.ExecutionException;
9 import java.util.concurrent.ExecutorService;
10 import java.util.concurrent.Executors;
11 import java.util.concurrent.Future;
13 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
14 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
15 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
16 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
17 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
18 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
19 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
20 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
21 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
22 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationInput;
23 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationInputBuilder;
24 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationOutput;
25 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationOutputBuilder;
26 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInput;
27 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInputBuilder;
28 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutput;
29 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutputBuilder;
30 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GENERICRESOURCEAPIService;
31 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInput;
32 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInputBuilder;
33 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutput;
34 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutputBuilder;
35 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInput;
36 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInputBuilder;
37 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutput;
38 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutputBuilder;
39 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationInput;
40 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationInputBuilder;
41 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationOutput;
42 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationOutputBuilder;
43 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfs;
44 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfsBuilder;
45 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInput;
46 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInputBuilder;
47 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutput;
48 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutputBuilder;
49 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInput;
50 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInputBuilder;
51 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutput;
52 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutputBuilder;
53 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.Services;
54 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServicesBuilder;
55 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInput;
56 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInputBuilder;
57 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutput;
58 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutputBuilder;
59 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInput;
60 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInputBuilder;
61 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutput;
62 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutputBuilder;
63 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInput;
64 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInputBuilder;
65 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutput;
66 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutputBuilder;
67 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.brg.response.information.BrgResponseInformationBuilder;
68 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.contrail.route.response.information.ContrailRouteResponseInformationBuilder;
69 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.network.response.information.NetworkResponseInformationBuilder;
70 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadData;
71 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadDataBuilder;
72 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadList;
73 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadListBuilder;
74 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadListKey;
75 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.request.information.RequestInformation;
76 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader;
77 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader.SvcAction;
78 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.security.zone.response.information.SecurityZoneResponseInformationBuilder;
79 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceData;
80 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceDataBuilder;
81 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.Service;
82 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceBuilder;
83 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceKey;
84 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.response.information.ServiceResponseInformationBuilder;
85 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RequestStatus;
86 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RpcAction;
87 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatusBuilder;
88 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.tunnelxconn.response.information.TunnelxconnResponseInformationBuilder;
89 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
90 import org.opendaylight.yangtools.yang.common.RpcResult;
91 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
92 import org.slf4j.Logger;
93 import org.slf4j.LoggerFactory;
95 import com.google.common.base.Optional;
96 import com.google.common.util.concurrent.CheckedFuture;
97 import com.google.common.util.concurrent.Futures;
98 import com.google.common.util.concurrent.SettableFuture;
102 * Defines a base implementation for your provider. This class extends from a helper class
103 * which provides storage for the most commonly used components of the MD-SAL. Additionally the
104 * base class provides some basic logging and initialization / clean up methods.
106 * To use this, copy and paste (overwrite) the following method into the TestApplicationProviderModule
107 * class which is auto generated under src/main/java in this project
108 * (created only once during first compilation):
113 public java.lang.AutoCloseable createInstance() {
115 //final GENERIC-RESOURCE-APIProvider provider = new GENERIC-RESOURCE-APIProvider();
116 final GenericResourceApiProvider provider = new GenericResourceApiProvider();
117 provider.setDataBroker( getDataBrokerDependency() );
118 provider.setNotificationService( getNotificationServiceDependency() );
119 provider.setRpcRegistry( getRpcRegistryDependency() );
120 provider.initialize();
121 return new AutoCloseable() {
124 public void close() throws Exception {
125 //TODO: CLOSE ANY REGISTRATION OBJECTS CREATED USING ABOVE BROKER/NOTIFICATION
126 //SERVIE/RPC REGISTRY
136 public class GenericResourceApiProvider implements AutoCloseable, GENERICRESOURCEAPIService{
138 private final Logger log = LoggerFactory.getLogger( GenericResourceApiProvider.class );
139 private final String appName = "generic-resource-api";
141 private final ExecutorService executor;
143 protected DataBroker dataBroker;
144 protected NotificationPublishService notificationService;
145 protected RpcProviderRegistry rpcRegistry;
146 protected BindingAwareBroker.RpcRegistration<GENERICRESOURCEAPIService> rpcRegistration;
148 public GenericResourceApiProvider(DataBroker dataBroker2,
149 NotificationPublishService notificationPublishService,
150 RpcProviderRegistry rpcProviderRegistry) {
151 log.info( "Creating provider for {}", appName);
152 executor = Executors.newFixedThreadPool(1);
153 dataBroker = dataBroker2;
154 notificationService = notificationPublishService;
155 rpcRegistry = rpcProviderRegistry;
160 public void initialize(){
161 log.info("Initializing provider for {}", appName);
162 // Create the top level containers
165 GenericResourceApiUtil.loadProperties();
166 } catch (Exception e) {
167 log.error("Caught Exception while trying to load properties file");
169 rpcRegistration = rpcRegistry.addRpcImplementation(GENERICRESOURCEAPIService.class, this);
171 log.info("Initialization complete for {}", appName);
175 protected void initializeChild() {
176 //Override if you have custom initialization intelligence
181 public void close() throws Exception {
182 log.info("Closing provider for {}", appName);
184 rpcRegistration.close();
185 log.info("Successfully closed provider for {}", appName);
188 private static class Iso8601Util
190 private static TimeZone tz = TimeZone.getTimeZone("UTC");
191 private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
193 static { df.setTimeZone(tz); }
195 private static String now() {
196 return df.format(new Date());
201 public void setDataBroker(DataBroker dataBroker) {
202 this.dataBroker = dataBroker;
203 if( log.isDebugEnabled() ){
204 log.debug("DataBroker set to {}", (dataBroker==null?"null":"non-null"));
208 public void setNotificationService(NotificationPublishService notificationService) {
209 this.notificationService = notificationService;
210 if( log.isDebugEnabled() ){
211 log.debug("Notification Service set to {}", (notificationService==null?"null":"non-null"));
215 public void setRpcRegistry(RpcProviderRegistry rpcRegistry) {
216 this.rpcRegistry = rpcRegistry;
217 if( log.isDebugEnabled() ){
218 log.debug("RpcRegistry set to {}", (rpcRegistry==null?"null":"non-null"));
222 private void createContainers() {
224 final WriteTransaction t = dataBroker.newReadWriteTransaction();
226 // Create the service-instance container
227 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Services.class),
228 new ServicesBuilder().build());
229 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Services.class),
230 new ServicesBuilder().build());
232 // Create the PreloadVnfs container
233 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
234 new PreloadVnfsBuilder().build());
235 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
236 new PreloadVnfsBuilder().build());
239 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
241 log.info("Create containers succeeded!");
243 } catch (InterruptedException | ExecutionException e) {
244 log.error("Create containers failed: ", e);
248 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage, String ackFinal)
250 serviceStatusBuilder.setResponseCode(errorCode);
251 serviceStatusBuilder.setResponseMessage(errorMessage);
252 serviceStatusBuilder.setFinalIndicator(ackFinal);
253 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
256 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation)
258 if (requestInformation != null && requestInformation.getRequestAction() != null) {
259 serviceStatusBuilder.setAction(requestInformation.getRequestAction().toString());
263 if (requestInformation != null && requestInformation.getRequestSubAction() != null) {
264 switch (requestInformation.getRequestSubAction())
267 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP);
270 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
273 log.error("Unknown RequestSubAction: " + requestInformation.getRequestSubAction() );
280 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader)
282 if (requestHeader != null && requestHeader.getSvcAction() != null) {
283 switch (requestHeader.getSvcAction())
286 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
289 serviceStatusBuilder.setRpcAction(RpcAction.Unassign);
292 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
295 serviceStatusBuilder.setRpcAction(RpcAction.Deactivate);
298 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
301 log.error("Unknown SvcAction: {}", requestHeader.getSvcAction() );
307 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder)
310 getServiceData(siid,serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
314 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type)
316 // See if any data exists yet for this siid, if so grab it.
317 InstanceIdentifier serviceInstanceIdentifier =
318 InstanceIdentifier.<Services>builder(Services.class)
319 .child(Service.class, new ServiceKey(siid)).build();
320 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
321 Optional<Service> data = null;
323 data = (Optional<Service>) readTx.read(type, serviceInstanceIdentifier).get();
324 } catch (InterruptedException | ExecutionException e) {
325 log.error("Caught Exception reading MD-SAL ({}) data for [{}] ", type, siid, e);
328 if (data != null && data.isPresent()) {
329 ServiceData serviceData = data.get().getServiceData();
330 if (serviceData != null) {
331 log.info("Read MD-SAL ({}) data for [{}] ServiceData: {}", type, siid, serviceData);
332 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
333 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
334 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
335 serviceDataBuilder.setServiceRequestInput(serviceData.getServiceRequestInput());
336 serviceDataBuilder.setServiceTopology(serviceData.getServiceTopology());
337 serviceDataBuilder.setServiceLevelOperStatus(serviceData.getServiceLevelOperStatus());
338 serviceDataBuilder.setNetworks(serviceData.getNetworks());
339 serviceDataBuilder.setVnfs(serviceData.getVnfs());
340 serviceDataBuilder.setProvidedAllottedResources(serviceData.getProvidedAllottedResources());
341 serviceDataBuilder.setConsumedAllottedResources(serviceData.getConsumedAllottedResources());
342 // service-instance-id needs to be set
344 log.info("No service-data found in MD-SAL ({}) for [{}]", type, siid);
347 log.info("No data found in MD-SAL ({}) for [{}]", type, siid);
351 private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder)
354 getPreloadData(vnf_name, vnf_type ,preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
357 private void getPreloadData(String preload_name, String preload_type, PreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type)
359 // See if any data exists yet for this name/type, if so grab it.
360 InstanceIdentifier preloadInstanceIdentifier = InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
361 .child(VnfPreloadList.class, new VnfPreloadListKey(preload_name, preload_type)).build();
362 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
363 Optional<VnfPreloadList> data = null;
365 data = (Optional<VnfPreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
366 } catch (InterruptedException | ExecutionException e) {
367 log.error("Caught Exception reading MD-SAL ({}) for [{},{}] ", type, preload_name, preload_type, e);
370 if (data != null && data.isPresent()) {
371 PreloadData preloadData = data.get().getPreloadData();
372 if (preloadData != null) {
373 log.info("Read MD-SAL ({}) data for [{},{}] PreloadData: {}",
374 type, preload_name, preload_type, preloadData);
375 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
376 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
377 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
379 log.info("No preload-data found in MD-SAL ({}) for [{},{}] ", type, preload_name, preload_type);
382 log.info("No data found in MD-SAL ({}) for [{},{}] ", type, preload_name, preload_type);
386 private void saveService(final Service entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException {
387 // Each entry will be identifiable by a unique key, we have to create that identifier
388 InstanceIdentifier.InstanceIdentifierBuilder<Service> serviceBuilder =
389 InstanceIdentifier.<Services>builder(Services.class)
390 .child(Service.class, entry.getKey());
391 InstanceIdentifier<Service> path = serviceBuilder.build();
396 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
398 tx.merge(storeType, path, entry);
400 tx.put(storeType, path, entry);
402 tx.submit().checkedGet();
403 log.debug("Update DataStore succeeded");
405 } catch (final TransactionCommitFailedException e) {
406 if(e instanceof OptimisticLockFailedException) {
408 log.debug("Got OptimisticLockFailedException on last try - failing ");
409 throw new IllegalStateException(e);
411 log.debug("Got OptimisticLockFailedException - trying again ");
413 log.debug("Update DataStore failed");
414 throw new IllegalStateException(e);
420 private void deleteService(final Service entry, LogicalDatastoreType storeType) throws IllegalStateException {
421 // Each entry will be identifiable by a unique key, we have to create
423 InstanceIdentifier.InstanceIdentifierBuilder<Service> serviceListIdBuilder = InstanceIdentifier.<Services> builder(Services.class).child(Service.class, entry.getKey());
424 InstanceIdentifier<Service> path = serviceListIdBuilder.build();
429 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
430 tx.delete(storeType, path);
431 tx.submit().checkedGet();
432 log.debug("DataStore delete succeeded");
434 } catch (final TransactionCommitFailedException e) {
435 if (e instanceof OptimisticLockFailedException) {
437 log.debug("Got OptimisticLockFailedException on last try - failing ");
438 throw new IllegalStateException(e);
440 log.debug("Got OptimisticLockFailedException - trying again ");
442 log.debug("Update DataStore failed");
443 throw new IllegalStateException(e);
449 private void savePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException{
451 // Each entry will be identifiable by a unique key, we have to create that identifier
452 InstanceIdentifier.InstanceIdentifierBuilder<VnfPreloadList> vnfPreloadListBuilder =
453 InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
454 .child(VnfPreloadList.class, entry.getKey());
455 InstanceIdentifier<VnfPreloadList> path = vnfPreloadListBuilder.build();
459 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
461 tx.merge(storeType, path, entry);
463 tx.put(storeType, path, entry);
465 tx.submit().checkedGet();
466 log.debug("Update DataStore succeeded");
468 } catch (final TransactionCommitFailedException e) {
469 if(e instanceof OptimisticLockFailedException) {
471 log.debug("Got OptimisticLockFailedException on last try - failing ");
472 throw new IllegalStateException(e);
474 log.debug("Got OptimisticLockFailedException - trying again ");
476 log.debug("Update DataStore failed");
477 throw new IllegalStateException(e);
484 public Future<RpcResult<ServiceTopologyOperationOutput>> serviceTopologyOperation(
485 ServiceTopologyOperationInput input) {
487 final String SVC_OPERATION = "service-topology-operation";
488 ServiceData serviceData;
489 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
490 Properties parms = new Properties();
492 log.info("{} called.",SVC_OPERATION);
493 // create a new response object
494 ServiceTopologyOperationOutputBuilder responseBuilder = new ServiceTopologyOperationOutputBuilder();
497 input.getServiceInformation() == null ||
498 input.getServiceInformation().getServiceInstanceId() == null ||
499 input.getServiceInformation().getServiceInstanceId().length() == 0)
501 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
502 responseBuilder.setResponseCode("404");
503 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
504 responseBuilder.setAckFinalIndicator("Y");
505 RpcResult<ServiceTopologyOperationOutput> rpcResult =
506 RpcResultBuilder.<ServiceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
507 return Futures.immediateFuture(rpcResult);
510 // Grab the service instance ID from the input buffer
511 String siid = input.getServiceInformation().getServiceInstanceId();
513 if (input.getSdncRequestHeader() != null) {
514 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
517 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
518 getServiceData(siid,serviceDataBuilder);
520 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
521 getServiceData(siid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
523 // Set the serviceStatus based on input
524 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
525 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
528 // setup a service-data object builder
529 // ACTION service-topology-operation
531 // USES uses service-operation-information
533 // uses topology-response-common;
534 // uses service-response-information;
537 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
538 ServiceTopologyOperationInputBuilder inputBuilder = new ServiceTopologyOperationInputBuilder(input);
539 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
541 log.info("Adding OPERATIONAL data for {} [{}] operational-data: {}", SVC_OPERATION, siid, operDataBuilder.build());
542 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
544 // Call SLI sync method
545 // Get SvcLogicService reference
547 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
548 Properties respProps = null;
550 String errorCode = "200";
551 String errorMessage = null;
552 String ackFinal = "Y";
553 String serviceObjectPath = null;
557 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
562 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
566 log.error("Caught exception executing service logic for {} ", SVC_OPERATION, e);
567 errorMessage = e.getMessage();
571 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
578 errorMessage = e.getMessage();
579 log.error("Caught exception looking for service logic", e);
583 if (respProps != null)
585 errorCode = respProps.getProperty("error-code");
586 errorMessage = respProps.getProperty("error-message");
587 ackFinal = respProps.getProperty("ack-final", "Y");
588 serviceObjectPath = respProps.getProperty("service-object-path");
591 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
592 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
593 //serviceStatusBuilder.setRpcName(RpcName.ServiceTopologyOperation);
594 serviceStatusBuilder.setRpcName(SVC_OPERATION);
596 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
597 responseBuilder.setResponseCode(errorCode);
598 responseBuilder.setResponseMessage(errorMessage);
599 responseBuilder.setAckFinalIndicator(ackFinal);
601 ServiceBuilder serviceBuilder = new ServiceBuilder();
602 serviceBuilder.setServiceInstanceId(siid);
603 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
605 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
606 } catch (Exception e) {
607 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
609 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
610 RpcResult<ServiceTopologyOperationOutput> rpcResult =
611 RpcResultBuilder.<ServiceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
612 return Futures.immediateFuture(rpcResult);
615 // Got success from SLI
617 serviceData = serviceDataBuilder.build();
618 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
621 ServiceBuilder serviceBuilder = new ServiceBuilder();
622 serviceBuilder.setServiceData(serviceData);
623 serviceBuilder.setServiceInstanceId(siid);
624 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
625 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
627 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
629 // Only update operational tree on delete
630 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete))
632 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
633 deleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
634 deleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
638 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
639 serviceResponseInformationBuilder.setInstanceId(siid);
640 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
641 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
643 } catch (Exception e) {
644 log.error("Caught Exception updating MD-SAL for {} [{}] \n",SVC_OPERATION, siid, e);
645 responseBuilder.setResponseCode("500");
646 responseBuilder.setResponseMessage(e.toString());
647 responseBuilder.setAckFinalIndicator("Y");
648 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
649 RpcResult<ServiceTopologyOperationOutput> rpcResult =
650 RpcResultBuilder.<ServiceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
651 return Futures.immediateFuture(rpcResult);
655 responseBuilder.setResponseCode(errorCode);
656 responseBuilder.setAckFinalIndicator(ackFinal);
657 if (errorMessage != null)
659 responseBuilder.setResponseMessage(errorMessage);
661 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
662 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
664 RpcResult<ServiceTopologyOperationOutput> rpcResult =
665 RpcResultBuilder.<ServiceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
666 return Futures.immediateFuture(rpcResult);
670 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(
671 VnfTopologyOperationInput input) {
673 final String SVC_OPERATION = "vnf-topology-operation";
674 ServiceData serviceData;
675 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
676 Properties parms = new Properties();
678 log.info("{} called.", SVC_OPERATION);
679 // create a new response object
680 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
683 input.getServiceInformation() == null ||
684 input.getServiceInformation().getServiceInstanceId() == null ||
685 input.getServiceInformation().getServiceInstanceId().length() == 0)
687 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
688 responseBuilder.setResponseCode("404");
689 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
690 responseBuilder.setAckFinalIndicator("Y");
691 RpcResult<VnfTopologyOperationOutput> rpcResult =
692 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
694 return Futures.immediateFuture(rpcResult);
697 // Grab the service instance ID from the input buffer
698 String siid = input.getServiceInformation().getServiceInstanceId();
700 if (input.getSdncRequestHeader() != null) {
701 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
704 if(input.getVnfInformation() == null ||
705 input.getVnfInformation().getVnfId() == null ||
706 input.getVnfInformation().getVnfId().length() == 0)
708 log.debug("exiting {} because of null or empty vnf-id", SVC_OPERATION);
709 responseBuilder.setResponseCode("404");
710 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
711 responseBuilder.setAckFinalIndicator("Y");
712 RpcResult<VnfTopologyOperationOutput> rpcResult =
713 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
714 return Futures.immediateFuture(rpcResult);
717 /* Mobility wont use vipr intf in 1707
719 String preload_name = null;
720 String preload_type = null;
721 if (input.getVnfRequestInput() != null &&
722 input.getVnfRequestInput().getVnfName() != null && input.getVnfRequestInput().getVnfName().length() != 0) {
723 preload_name = input.getVnfRequestInput().getVnfName();
725 if (input.getVnfInformation().getVnfType() != null &&
726 input.getVnfInformation().getVnfType().length() != 0) {
727 preload_type = input.getVnfInformation().getVnfType();
730 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
731 if (preload_name != null && preload_type != null) {
732 getPreloadData(preload_name, preload_type, preloadDataBuilder);
735 log.info("vnf-name and vnf-type not present in the request");
739 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
740 getServiceData(siid,serviceDataBuilder);
742 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
743 getServiceData(siid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
745 // Set the serviceStatus based on input
746 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
747 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
750 // setup a service-data object builder
751 // ACTION vnf-topology-operation
753 // USES sdnc-request-header;
754 // USES request-information;
755 // USES service-information;
756 // USES vnf-request-information
758 // USES vnf-topology-response-body;
759 // USES vnf-information
760 // USES service-information
762 // container service-data
763 // uses vnf-configuration-information;
766 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
767 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
768 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
770 log.info("Adding OPERATIONAL data for {} [{}] operational-data: {}", SVC_OPERATION, siid, operDataBuilder.build());
771 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
774 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " + preloadDataBuilder.build());
775 GenericResourceApiUtil.toProperties(parms, "preload-data", preloadDataBuilder);
778 // Call SLI sync method
779 // Get SvcLogicService reference
781 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
782 Properties respProps = null;
784 String errorCode = "200";
785 String errorMessage = null;
786 String ackFinal = "Y";
787 String serviceObjectPath = null;
791 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
796 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
800 log.error("Caught exception executing service logic for {} ", SVC_OPERATION, e);
801 errorMessage = e.getMessage();
805 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
812 errorMessage = e.getMessage();
813 log.error("Caught exception looking for service logic", e);
816 if (respProps != null)
818 errorCode = respProps.getProperty("error-code");
819 errorMessage = respProps.getProperty("error-message");
820 ackFinal = respProps.getProperty("ack-final", "Y");
821 serviceObjectPath = respProps.getProperty("vnf-object-path");
824 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
825 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
826 //serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
827 serviceStatusBuilder.setRpcName(SVC_OPERATION);
829 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
830 responseBuilder.setResponseCode(errorCode);
831 responseBuilder.setResponseMessage(errorMessage);
832 responseBuilder.setAckFinalIndicator(ackFinal);
834 ServiceBuilder serviceBuilder = new ServiceBuilder();
835 serviceBuilder.setServiceInstanceId(siid);
836 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
838 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
839 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
841 // Only update operational tree on activate or delete
842 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
843 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
845 log.info("Updating OPERATIONAL tree.");
846 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
849 } catch (Exception e) {
850 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
852 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
853 RpcResult<VnfTopologyOperationOutput> rpcResult =
854 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
856 return Futures.immediateFuture(rpcResult);
859 // Got success from SLI
861 serviceData = serviceDataBuilder.build();
862 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
865 ServiceBuilder serviceBuilder = new ServiceBuilder();
866 serviceBuilder.setServiceData(serviceData);
867 serviceBuilder.setServiceInstanceId(siid);
868 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
869 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
871 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
873 // Only update operational tree on Assign
874 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
876 log.info("Updating OPERATIONAL tree.");
877 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
881 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
882 serviceResponseInformationBuilder.setInstanceId(siid);
883 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
884 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
886 } catch (Exception e) {
887 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
888 responseBuilder.setResponseCode("500");
889 responseBuilder.setResponseMessage(e.toString());
890 responseBuilder.setAckFinalIndicator("Y");
891 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
892 RpcResult<VnfTopologyOperationOutput> rpcResult =
893 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
894 return Futures.immediateFuture(rpcResult);
898 responseBuilder.setResponseCode(errorCode);
899 responseBuilder.setAckFinalIndicator(ackFinal);
900 if (errorMessage != null)
902 responseBuilder.setResponseMessage(errorMessage);
904 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
905 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
907 RpcResult<VnfTopologyOperationOutput> rpcResult =
908 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
910 return Futures.immediateFuture(rpcResult);
914 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
915 VfModuleTopologyOperationInput input) {
917 final String SVC_OPERATION = "vf-module-topology-operation";
918 ServiceData serviceData;
919 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
920 Properties parms = new Properties();
922 log.info("{} called.", SVC_OPERATION);
923 // create a new response object
924 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
927 input.getServiceInformation() == null ||
928 input.getServiceInformation().getServiceInstanceId() == null ||
929 input.getServiceInformation().getServiceInstanceId().length() == 0)
931 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
932 responseBuilder.setResponseCode("403");
933 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
934 responseBuilder.setAckFinalIndicator("Y");
935 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
936 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
938 return Futures.immediateFuture(rpcResult);
941 if(input.getVnfInformation() == null ||
942 input.getVnfInformation().getVnfId() == null ||
943 input.getVnfInformation().getVnfId().length() == 0)
945 log.debug("exiting {} because of null or empty vnf-id", SVC_OPERATION);
946 responseBuilder.setResponseCode("403");
947 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
948 responseBuilder.setAckFinalIndicator("Y");
949 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
950 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
951 return Futures.immediateFuture(rpcResult);
954 if(input.getVfModuleInformation() == null ||
955 input.getVfModuleInformation().getVfModuleId() == null ||
956 input.getVfModuleInformation().getVfModuleId().length() == 0)
958 log.debug("exiting {} because of null or empty vf-module-id", SVC_OPERATION);
959 responseBuilder.setResponseCode("403");
960 responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
961 responseBuilder.setAckFinalIndicator("Y");
962 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
963 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
964 return Futures.immediateFuture(rpcResult);
967 // Grab the service instance ID from the input buffer
968 String siid = input.getServiceInformation().getServiceInstanceId();
970 if (input.getSdncRequestHeader() != null) {
971 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
975 String preload_name = null;
976 String preload_type = null;
978 preload_name = input.getVfModuleRequestInput().getVfModuleName();
980 if(input.getVfModuleInformation().getVfModuleType() != null &&
981 input.getVfModuleInformation().getVfModuleType().length() != 0) {
982 preload_type = input.getVfModuleInformation().getVfModuleType();
985 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
986 if (preload_name != null && preload_type != null) {
987 getPreloadData(preload_name, preload_type, preloadDataBuilder);
990 log.debug("vf-module-name and vf-module-type not present in the request.");
994 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
995 getServiceData(siid,serviceDataBuilder);
997 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
998 getServiceData(siid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1000 // Set the serviceStatus based on input
1001 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1002 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1005 // setup a service-data object builder
1006 // ACTION vnf-topology-operation
1008 // USES sdnc-request-header;
1009 // USES request-information;
1010 // USES service-information;
1011 // USES vnf-request-information
1013 // USES vnf-topology-response-body;
1014 // USES vnf-information
1015 // USES service-information
1017 // container service-data
1018 // uses vnf-configuration-information;
1019 // uses oper-status;
1021 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1022 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1023 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1025 log.info("Adding OPERATIONAL data for {} [{}] operational-data: {}", SVC_OPERATION, siid, operDataBuilder.build());
1026 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
1029 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " +preloadDataBuilder.build());
1030 GenericResourceApiUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1033 // Call SLI sync method
1034 // Get SvcLogicService reference
1036 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1037 Properties respProps = null;
1039 String errorCode = "200";
1040 String errorMessage = null;
1041 String ackFinal = "Y";
1042 String serviceObjectPath = null;
1046 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1051 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1055 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1056 errorMessage = e.getMessage();
1060 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1067 errorMessage = e.getMessage();
1068 log.error("Caught exception looking for service logic", e);
1071 if (respProps != null)
1073 errorCode = respProps.getProperty("error-code");
1074 errorMessage = respProps.getProperty("error-message");
1075 ackFinal = respProps.getProperty("ack-final", "Y");
1076 serviceObjectPath = respProps.getProperty("vf-module-object-path");
1079 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
1080 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1081 serviceStatusBuilder.setRpcName(SVC_OPERATION);
1083 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1084 responseBuilder.setResponseCode(errorCode);
1085 responseBuilder.setResponseMessage(errorMessage);
1086 responseBuilder.setAckFinalIndicator(ackFinal);
1088 ServiceBuilder serviceBuilder = new ServiceBuilder();
1089 serviceBuilder.setServiceInstanceId(siid);
1090 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1092 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1093 } catch (Exception e) {
1094 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1096 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1097 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1098 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1100 return Futures.immediateFuture(rpcResult);
1103 // Got success from SLI
1105 serviceData = serviceDataBuilder.build();
1106 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1109 ServiceBuilder serviceBuilder = new ServiceBuilder();
1110 serviceBuilder.setServiceData(serviceData);
1111 //serviceBuilder.setServiceInstanceId(serviceData.getServiceTopology().getServiceTopologyIdentifier().getServiceInstanceId());
1112 serviceBuilder.setServiceInstanceId(siid);
1113 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1114 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1116 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1118 // Only update operational tree on activate or delete
1119 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1120 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1122 log.info("Updating OPERATIONAL tree.");
1123 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1127 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1128 serviceResponseInformationBuilder.setInstanceId(siid);
1129 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1130 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1132 } catch (Exception e) {
1133 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1134 responseBuilder.setResponseCode("500");
1135 responseBuilder.setResponseMessage(e.toString());
1136 responseBuilder.setAckFinalIndicator("Y");
1137 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1138 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1139 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1140 return Futures.immediateFuture(rpcResult);
1144 responseBuilder.setResponseCode(errorCode);
1145 responseBuilder.setAckFinalIndicator(ackFinal);
1146 if (errorMessage != null)
1148 responseBuilder.setResponseMessage(errorMessage);
1150 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1151 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1153 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1154 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1156 return Futures.immediateFuture(rpcResult);
1160 public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1161 NetworkTopologyOperationInput input) {
1163 final String SVC_OPERATION = "network-topology-operation";
1164 ServiceData serviceData;
1165 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1166 Properties parms = new Properties();
1168 log.info("{} called.", SVC_OPERATION );
1169 // create a new response object
1170 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1173 input.getServiceInformation() == null ||
1174 input.getServiceInformation().getServiceInstanceId() == null ||
1175 input.getServiceInformation().getServiceInstanceId().length() == 0)
1177 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1178 responseBuilder.setResponseCode("404");
1179 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1180 responseBuilder.setAckFinalIndicator("Y");
1181 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1182 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1183 return Futures.immediateFuture(rpcResult);
1186 String siid = input.getServiceInformation().getServiceInstanceId();
1188 // Get the service-instance service data from MD-SAL
1189 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1190 getServiceData(siid,serviceDataBuilder);
1192 if (input.getSdncRequestHeader() != null) {
1193 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1196 ServiceData sd = serviceDataBuilder.build();
1197 if (sd == null || sd.getServiceLevelOperStatus() == null)
1199 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1200 responseBuilder.setResponseCode("404");
1201 responseBuilder.setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1202 responseBuilder.setAckFinalIndicator("Y");
1203 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1204 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1205 return Futures.immediateFuture(rpcResult);
1210 //String preload_name = null;
1211 //String preload_type = null;
1212 // If both network-name and network-type are present in request, get the preload network from MD-SAL
1213 if (input.getNetworkRequestInput() != null &&
1214 input.getNetworkRequestInput().getNetworkName() != null &&
1215 input.getNetworkRequestInput().getNetworkName().length() != 0) {
1216 preload_name = input.getNetworkRequestInput().getNetworkName();
1218 if (input.getNetworkInformation() != null &&
1219 input.getNetworkInformation().getNetworkType() != null &&
1220 input.getNetworkInformation().getNetworkType().length() != 0) {
1221 preload_type = input.getNetworkInformation().getNetworkType();
1224 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1225 if (preload_name != null && preload_type != null) {
1226 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1229 log.debug("network-name and network-type not present in request");
1233 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1234 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1235 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1237 // Call SLI sync method
1238 // Get SvcLogicService reference
1240 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1241 Properties respProps = null;
1243 String errorCode = "200";
1244 String errorMessage = null;
1245 String ackFinal = "Y";
1246 String networkId = "error";
1247 String serviceObjectPath = null;
1248 String networkObjectPath = null;
1252 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1257 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1261 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1262 errorMessage = e.getMessage();
1266 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1273 errorMessage = e.getMessage();
1274 log.error("Caught exception looking for service logic", e);
1278 if (respProps != null)
1280 errorCode = respProps.getProperty("error-code");
1281 errorMessage = respProps.getProperty("error-message");
1282 ackFinal = respProps.getProperty("ack-final", "Y");
1283 networkId = respProps.getProperty("networkId");
1284 serviceObjectPath = respProps.getProperty("service-object-path");
1285 networkObjectPath = respProps.getProperty("network-object-path");
1288 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1289 responseBuilder.setResponseCode(errorCode);
1290 responseBuilder.setResponseMessage(errorMessage);
1291 responseBuilder.setAckFinalIndicator(ackFinal);
1293 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1295 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1296 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1297 return Futures.immediateFuture(rpcResult);
1300 // Got success from SLI
1303 serviceData = serviceDataBuilder.build();
1304 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1307 ServiceBuilder serviceBuilder = new ServiceBuilder();
1308 serviceBuilder.setServiceData(serviceData);
1309 serviceBuilder.setServiceInstanceId(siid);
1310 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1311 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1313 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1315 // Only update operational tree on Activate
1316 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1318 log.info("Updating OPERATIONAL tree.");
1319 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1323 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1324 networkResponseInformationBuilder.setInstanceId(networkId);
1325 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1326 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1328 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1329 serviceResponseInformationBuilder.setInstanceId(siid);
1330 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1331 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1333 } catch (IllegalStateException e) {
1334 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1335 responseBuilder.setResponseCode("500");
1336 responseBuilder.setResponseMessage(e.toString());
1337 responseBuilder.setAckFinalIndicator("Y");
1338 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1339 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1340 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1341 return Futures.immediateFuture(rpcResult);
1345 responseBuilder.setResponseCode(errorCode);
1346 responseBuilder.setAckFinalIndicator(ackFinal);
1347 if (errorMessage != null)
1349 responseBuilder.setResponseMessage(errorMessage);
1351 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1352 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1354 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1355 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1356 return Futures.immediateFuture(rpcResult);
1360 public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1361 ContrailRouteTopologyOperationInput input) {
1363 final String SVC_OPERATION = "contrail-route-topology-operation";
1364 ServiceData serviceData;
1365 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1366 Properties parms = new Properties();
1368 log.info("{} called.", SVC_OPERATION);
1369 // create a new response object
1370 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1373 input.getServiceInformation() == null ||
1374 input.getServiceInformation().getServiceInstanceId() == null ||
1375 input.getServiceInformation().getServiceInstanceId().length() == 0)
1377 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1378 responseBuilder.setResponseCode("404");
1379 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1380 responseBuilder.setAckFinalIndicator("Y");
1381 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult =
1382 RpcResultBuilder.<ContrailRouteTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1383 return Futures.immediateFuture(rpcResult);
1386 String siid = input.getServiceInformation().getServiceInstanceId();
1388 // Get the service-instance service data from MD-SAL
1389 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1390 getServiceData(siid,serviceDataBuilder);
1392 if (input.getSdncRequestHeader() != null) {
1393 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1396 ServiceData sd = serviceDataBuilder.build();
1397 if (sd == null || sd.getServiceLevelOperStatus() == null)
1399 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1400 responseBuilder.setResponseCode("404");
1401 responseBuilder.setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1402 responseBuilder.setAckFinalIndicator("Y");
1403 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult =
1404 RpcResultBuilder.<ContrailRouteTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1405 return Futures.immediateFuture(rpcResult);
1408 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+siid+"] input: " + input);
1409 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1410 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1412 // Call SLI sync method
1413 // Get SvcLogicService reference
1415 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1416 Properties respProps = null;
1418 String errorCode = "200";
1419 String errorMessage = null;
1420 String ackFinal = "Y";
1421 String allottedResourceId = "error";
1422 String serviceObjectPath = null;
1423 String contrailRouteObjectPath = null;
1427 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1432 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1436 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1437 errorMessage = e.getMessage();
1441 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1448 errorMessage = e.getMessage();
1449 log.error("Caught exception looking for service logic", e);
1453 if (respProps != null)
1455 errorCode = respProps.getProperty("error-code");
1456 errorMessage = respProps.getProperty("error-message");
1457 ackFinal = respProps.getProperty("ack-final", "Y");
1458 allottedResourceId = respProps.getProperty("allotted-resource-id");
1459 serviceObjectPath = respProps.getProperty("service-object-path");
1460 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1463 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1464 responseBuilder.setResponseCode(errorCode);
1465 responseBuilder.setResponseMessage(errorMessage);
1466 responseBuilder.setAckFinalIndicator(ackFinal);
1468 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1470 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult =
1471 RpcResultBuilder.<ContrailRouteTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1472 return Futures.immediateFuture(rpcResult);
1475 // Got success from SLI
1478 serviceData = serviceDataBuilder.build();
1479 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1482 ServiceBuilder serviceBuilder = new ServiceBuilder();
1483 serviceBuilder.setServiceData(serviceData);
1484 serviceBuilder.setServiceInstanceId(siid);
1485 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1486 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1488 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1490 // Only update operational tree on activate or delete
1491 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1492 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1494 log.info("Updating OPERATIONAL tree.");
1495 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1499 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1500 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1501 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1502 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1504 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1505 serviceResponseInformationBuilder.setInstanceId(siid);
1506 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1507 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1509 } catch (IllegalStateException e) {
1510 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1511 responseBuilder.setResponseCode("500");
1512 responseBuilder.setResponseMessage(e.toString());
1513 responseBuilder.setAckFinalIndicator("Y");
1514 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1515 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult =
1516 RpcResultBuilder.<ContrailRouteTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1517 return Futures.immediateFuture(rpcResult);
1521 responseBuilder.setResponseCode(errorCode);
1522 responseBuilder.setAckFinalIndicator(ackFinal);
1523 if (errorMessage != null)
1525 responseBuilder.setResponseMessage(errorMessage);
1527 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1528 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1530 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult =
1531 RpcResultBuilder.<ContrailRouteTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1532 return Futures.immediateFuture(rpcResult);
1536 public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1537 SecurityZoneTopologyOperationInput input) {
1539 final String SVC_OPERATION = "security-zone-topology-operation";
1540 ServiceData serviceData;
1541 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1542 Properties parms = new Properties();
1544 log.info("{} called.", SVC_OPERATION);
1545 // create a new response object
1546 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1549 input.getServiceInformation() == null ||
1550 input.getServiceInformation().getServiceInstanceId() == null ||
1551 input.getServiceInformation().getServiceInstanceId().length() == 0)
1553 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1554 responseBuilder.setResponseCode("404");
1555 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1556 responseBuilder.setAckFinalIndicator("Y");
1557 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult =
1558 RpcResultBuilder.<SecurityZoneTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1559 return Futures.immediateFuture(rpcResult);
1562 String siid = input.getServiceInformation().getServiceInstanceId();
1564 // Get the service-instance service data from MD-SAL
1565 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1566 getServiceData(siid,serviceDataBuilder);
1568 if (input.getSdncRequestHeader() != null) {
1569 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1572 ServiceData sd = serviceDataBuilder.build();
1573 if (sd == null || sd.getServiceLevelOperStatus() == null)
1575 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1576 responseBuilder.setResponseCode("404");
1577 responseBuilder.setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1578 responseBuilder.setAckFinalIndicator("Y");
1579 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult =
1580 RpcResultBuilder.<SecurityZoneTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1581 return Futures.immediateFuture(rpcResult);
1584 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1585 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1586 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1588 // Call SLI sync method
1589 // Get SvcLogicService reference
1591 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1592 Properties respProps = null;
1594 String errorCode = "200";
1595 String errorMessage = null;
1596 String ackFinal = "Y";
1597 String allottedResourceId = "error";
1598 String serviceObjectPath = null;
1599 String securityZoneObjectPath = null;
1603 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1608 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1612 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1613 errorMessage = e.getMessage();
1617 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1624 errorMessage = e.getMessage();
1625 log.error("Caught exception looking for service logic", e);
1629 if (respProps != null)
1631 errorCode = respProps.getProperty("error-code");
1632 errorMessage = respProps.getProperty("error-message");
1633 ackFinal = respProps.getProperty("ack-final", "Y");
1634 allottedResourceId = respProps.getProperty("allotted-resource-id");
1635 serviceObjectPath = respProps.getProperty("service-object-path");
1636 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1639 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1640 responseBuilder.setResponseCode(errorCode);
1641 responseBuilder.setResponseMessage(errorMessage);
1642 responseBuilder.setAckFinalIndicator(ackFinal);
1644 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1646 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult =
1647 RpcResultBuilder.<SecurityZoneTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1648 return Futures.immediateFuture(rpcResult);
1651 // Got success from SLI
1654 serviceData = serviceDataBuilder.build();
1655 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1658 ServiceBuilder serviceBuilder = new ServiceBuilder();
1659 serviceBuilder.setServiceData(serviceData);
1660 serviceBuilder.setServiceInstanceId(siid);
1661 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1662 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1664 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1666 // Only update operational tree on activate or delete
1667 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1668 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1670 log.info("Updating OPERATIONAL tree.");
1671 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1675 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1676 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1677 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1678 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1680 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1681 serviceResponseInformationBuilder.setInstanceId(siid);
1682 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1683 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1685 } catch (IllegalStateException e) {
1686 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, 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<SecurityZoneTopologyOperationOutput> rpcResult =
1692 RpcResultBuilder.<SecurityZoneTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1693 return Futures.immediateFuture(rpcResult);
1697 responseBuilder.setResponseCode(errorCode);
1698 responseBuilder.setAckFinalIndicator(ackFinal);
1699 if (errorMessage != null)
1701 responseBuilder.setResponseMessage(errorMessage);
1703 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1704 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1706 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult =
1707 RpcResultBuilder.<SecurityZoneTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1708 return Futures.immediateFuture(rpcResult);
1712 public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1713 TunnelxconnTopologyOperationInput input) {
1715 final String SVC_OPERATION = "tunnelxconn-topology-operation";
1716 ServiceData serviceData;
1717 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1718 Properties parms = new Properties();
1720 log.info("{} called.", SVC_OPERATION);
1721 // create a new response object
1722 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1725 input.getServiceInformation() == null ||
1726 input.getServiceInformation().getServiceInstanceId() == null ||
1727 input.getServiceInformation().getServiceInstanceId().length() == 0)
1729 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1730 responseBuilder.setResponseCode("404");
1731 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1732 responseBuilder.setAckFinalIndicator("Y");
1733 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult =
1734 RpcResultBuilder.<TunnelxconnTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1735 return Futures.immediateFuture(rpcResult);
1738 String siid = input.getServiceInformation().getServiceInstanceId();
1740 // Get the service-instance service data from MD-SAL
1741 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1742 getServiceData(siid,serviceDataBuilder);
1744 if (input.getSdncRequestHeader() != null) {
1745 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1748 ServiceData sd = serviceDataBuilder.build();
1749 if (sd == null || sd.getServiceLevelOperStatus() == null)
1751 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1752 responseBuilder.setResponseCode("404");
1753 responseBuilder.setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1754 responseBuilder.setAckFinalIndicator("Y");
1755 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult =
1756 RpcResultBuilder.<TunnelxconnTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1757 return Futures.immediateFuture(rpcResult);
1760 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1761 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1762 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1764 // Call SLI sync method
1765 // Get SvcLogicService reference
1767 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1768 Properties respProps = null;
1770 String errorCode = "200";
1771 String errorMessage = null;
1772 String ackFinal = "Y";
1773 String allottedResourceId = "error";
1774 String serviceObjectPath = null;
1775 String tunnelxconnObjectPath = null;
1779 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1784 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1788 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1789 errorMessage = e.getMessage();
1793 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1800 errorMessage = e.getMessage();
1801 log.error("Caught exception looking for service logic", e);
1805 if (respProps != null)
1807 errorCode = respProps.getProperty("error-code");
1808 errorMessage = respProps.getProperty("error-message");
1809 ackFinal = respProps.getProperty("ack-final", "Y");
1810 allottedResourceId = respProps.getProperty("allotted-resource-id");
1811 serviceObjectPath = respProps.getProperty("service-object-path");
1812 tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1815 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1816 responseBuilder.setResponseCode(errorCode);
1817 responseBuilder.setResponseMessage(errorMessage);
1818 responseBuilder.setAckFinalIndicator(ackFinal);
1820 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1822 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult =
1823 RpcResultBuilder.<TunnelxconnTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1824 return Futures.immediateFuture(rpcResult);
1827 // Got success from SLI
1830 serviceData = serviceDataBuilder.build();
1831 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1834 ServiceBuilder serviceBuilder = new ServiceBuilder();
1835 serviceBuilder.setServiceData(serviceData);
1836 serviceBuilder.setServiceInstanceId(siid);
1837 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1838 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1840 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1842 // Only update operational tree on activate or delete
1843 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1844 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1846 log.info("Updating OPERATIONAL tree.");
1847 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1851 TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1852 tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1853 tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1854 responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1856 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1857 serviceResponseInformationBuilder.setInstanceId(siid);
1858 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1859 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1861 } catch (IllegalStateException e) {
1862 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1863 responseBuilder.setResponseCode("500");
1864 responseBuilder.setResponseMessage(e.toString());
1865 responseBuilder.setAckFinalIndicator("Y");
1866 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1867 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult =
1868 RpcResultBuilder.<TunnelxconnTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1869 return Futures.immediateFuture(rpcResult);
1873 responseBuilder.setResponseCode(errorCode);
1874 responseBuilder.setAckFinalIndicator(ackFinal);
1875 if (errorMessage != null)
1877 responseBuilder.setResponseMessage(errorMessage);
1879 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1880 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1882 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult =
1883 RpcResultBuilder.<TunnelxconnTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1884 return Futures.immediateFuture(rpcResult);
1888 public Future<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
1889 final String SVC_OPERATION = "brg-topology-operation";
1890 ServiceData serviceData;
1891 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1892 Properties parms = new Properties();
1894 log.info("{} called.", SVC_OPERATION);
1895 // create a new response object
1896 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
1899 input.getServiceInformation() == null ||
1900 input.getServiceInformation().getServiceInstanceId() == null ||
1901 input.getServiceInformation().getServiceInstanceId().length() == 0)
1903 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1904 responseBuilder.setResponseCode("404");
1905 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1906 responseBuilder.setAckFinalIndicator("Y");
1907 RpcResult<BrgTopologyOperationOutput> rpcResult =
1908 RpcResultBuilder.<BrgTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1909 return Futures.immediateFuture(rpcResult);
1912 String siid = input.getServiceInformation().getServiceInstanceId();
1914 // Get the service-instance service data from MD-SAL
1915 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1916 getServiceData(siid,serviceDataBuilder);
1918 if (input.getSdncRequestHeader() != null) {
1919 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1922 ServiceData sd = serviceDataBuilder.build();
1923 if (sd == null || sd.getServiceLevelOperStatus() == null)
1925 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1926 responseBuilder.setResponseCode("404");
1927 responseBuilder.setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1928 responseBuilder.setAckFinalIndicator("Y");
1929 RpcResult<BrgTopologyOperationOutput> rpcResult =
1930 RpcResultBuilder.<BrgTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1931 return Futures.immediateFuture(rpcResult);
1934 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1935 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
1936 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1938 // Call SLI sync method
1939 // Get SvcLogicService reference
1941 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1942 Properties respProps = null;
1944 String errorCode = "200";
1945 String errorMessage = null;
1946 String ackFinal = "Y";
1947 String allottedResourceId = "error";
1948 String serviceObjectPath = null;
1949 String brgObjectPath = null;
1953 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1958 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1962 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1963 errorMessage = e.getMessage();
1967 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1974 errorMessage = e.getMessage();
1975 log.error("Caught exception looking for service logic", e);
1979 if (respProps != null)
1981 errorCode = respProps.getProperty("error-code");
1982 errorMessage = respProps.getProperty("error-message");
1983 ackFinal = respProps.getProperty("ack-final", "Y");
1984 allottedResourceId = respProps.getProperty("allotted-resource-id");
1985 serviceObjectPath = respProps.getProperty("service-object-path");
1986 brgObjectPath = respProps.getProperty("brg-object-path");
1989 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1990 responseBuilder.setResponseCode(errorCode);
1991 responseBuilder.setResponseMessage(errorMessage);
1992 responseBuilder.setAckFinalIndicator(ackFinal);
1994 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1996 RpcResult<BrgTopologyOperationOutput> rpcResult =
1997 RpcResultBuilder.<BrgTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1998 return Futures.immediateFuture(rpcResult);
2001 // Got success from SLI
2004 serviceData = serviceDataBuilder.build();
2005 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
2008 ServiceBuilder serviceBuilder = new ServiceBuilder();
2009 serviceBuilder.setServiceData(serviceData);
2010 serviceBuilder.setServiceInstanceId(siid);
2011 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2012 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2014 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
2016 // Only update operational tree on activate or delete
2017 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
2018 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
2020 log.info("Updating OPERATIONAL tree.");
2021 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2025 BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
2026 brgResponseInformationBuilder.setInstanceId(allottedResourceId);
2027 brgResponseInformationBuilder.setObjectPath(brgObjectPath);
2028 responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
2030 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2031 serviceResponseInformationBuilder.setInstanceId(siid);
2032 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2033 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2035 } catch (IllegalStateException e) {
2036 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
2037 responseBuilder.setResponseCode("500");
2038 responseBuilder.setResponseMessage(e.toString());
2039 responseBuilder.setAckFinalIndicator("Y");
2040 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
2041 RpcResult<BrgTopologyOperationOutput> rpcResult =
2042 RpcResultBuilder.<BrgTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2043 return Futures.immediateFuture(rpcResult);
2047 responseBuilder.setResponseCode(errorCode);
2048 responseBuilder.setAckFinalIndicator(ackFinal);
2049 if (errorMessage != null)
2051 responseBuilder.setResponseMessage(errorMessage);
2053 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
2054 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
2056 RpcResult<BrgTopologyOperationOutput> rpcResult =
2057 RpcResultBuilder.<BrgTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2058 return Futures.immediateFuture(rpcResult);
2062 public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
2063 PreloadVnfTopologyOperationInput input) {
2065 final String SVC_OPERATION = "preload-vnf-topology-operation";
2066 PreloadData preloadData;
2067 Properties parms = new Properties();
2069 log.info("{} called.", SVC_OPERATION);
2070 // create a new response object
2071 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
2073 // Result from savePreloadData
2074 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2076 if(input == null || input.getVnfTopologyInformation() == null ||
2077 input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null) {
2078 log.debug("exiting {} because of null input", SVC_OPERATION);
2079 responseBuilder.setResponseCode("403");
2080 responseBuilder.setResponseMessage("invalid input: input is null");
2081 responseBuilder.setAckFinalIndicator("Y");
2082 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2083 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2084 return Futures.immediateFuture(rpcResult);
2087 // Grab the name and type from the input buffer
2088 String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
2089 String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
2091 // Make sure we have a preload_name and preload_type
2092 if(preload_name == null || preload_name.length() == 0 || preload_type == null || preload_type.length() == 0 ) {
2093 log.debug("exiting {} vnf-name or vnf-type is null or empty", SVC_OPERATION);
2094 responseBuilder.setResponseCode("403");
2095 responseBuilder.setResponseMessage("invalid input: vnf-name or vnf-type is null or empty");
2096 responseBuilder.setAckFinalIndicator("Y");
2097 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2098 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2099 return Futures.immediateFuture(rpcResult);
2102 if (input.getSdncRequestHeader() != null) {
2103 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2106 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2107 getPreloadData(preload_name, preload_type, preloadDataBuilder);
2109 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2110 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
2112 // setup a preload-data object builder
2113 // ACTION preload-vnf-topology-operation
2115 // USES sdnc-request-header;
2116 // USES request-information;
2117 // uses vnf-topology-information;
2119 // USES vnf-topology-response-body;
2121 // container preload-data
2122 // uses vnf-topology-information;
2123 // uses network-topology-information;
2124 // uses oper-status;
2126 log.info("Adding INPUT data for {} [{},{}] input: {}", SVC_OPERATION, preload_name, preload_type, input);
2127 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
2128 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2129 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}",
2130 SVC_OPERATION, preload_name, preload_type, operDataBuilder.build());
2131 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
2133 // Call SLI sync method
2134 // Get SvcLogicService reference
2136 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
2137 Properties respProps = null;
2139 String errorCode = "200";
2140 String errorMessage = null;
2141 String ackFinal = "Y";
2146 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
2151 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2155 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
2156 errorMessage = e.getMessage();
2160 errorMessage = "No service logic active for "+ appName + ": '" + SVC_OPERATION + "'";
2167 errorMessage = e.getMessage();
2168 log.error("Caught exception looking for service logic", e);
2172 if (respProps != null)
2174 errorCode = respProps.getProperty("error-code");
2175 errorMessage = respProps.getProperty("error-message");
2176 ackFinal = respProps.getProperty("ack-final", "Y");
2177 // internalError = respProps.getProperty("internal-error", "false");
2180 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2182 responseBuilder.setResponseCode(errorCode);
2183 responseBuilder.setResponseMessage(errorMessage);
2184 responseBuilder.setAckFinalIndicator(ackFinal);
2186 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2187 preloadVnfListBuilder.setVnfName(preload_name);
2188 preloadVnfListBuilder.setVnfType(preload_type);
2189 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2190 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'",
2191 SVC_OPERATION, preload_name, preload_type, errorCode, errorMessage);
2193 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2194 } catch (Exception e) {
2195 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n",
2196 SVC_OPERATION, preload_name, preload_type, e);
2198 log.debug("Sending Success rpc result due to external error");
2199 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2200 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2201 return Futures.immediateFuture(rpcResult);
2204 // Got success from SLI
2206 preloadData = preloadDataBuilder.build();
2207 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}",
2208 SVC_OPERATION, preload_name, preload_type, preloadData);
2209 // svc-configuration-list
2210 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2211 preloadVnfListBuilder.setVnfName(preload_name);
2212 preloadVnfListBuilder.setVnfType(preload_type);
2213 preloadVnfListBuilder.setPreloadData(preloadData);
2215 // merge flag sets to false to allow it to be overwritten (not appended)
2216 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2217 log.info("Updating OPERATIONAL tree.");
2218 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2219 } catch (Exception e) {
2220 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n",
2221 SVC_OPERATION, preload_name, preload_type, e);
2222 responseBuilder.setResponseCode("500");
2223 responseBuilder.setResponseMessage(e.toString());
2224 responseBuilder.setAckFinalIndicator("Y");
2225 log.error("Returned FAILED for {} [{},{}] {}",
2226 SVC_OPERATION, preload_name, preload_type, responseBuilder.build());
2227 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2228 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2229 return Futures.immediateFuture(rpcResult);
2233 responseBuilder.setResponseCode(errorCode);
2234 responseBuilder.setAckFinalIndicator(ackFinal);
2235 if (errorMessage != null)
2237 responseBuilder.setResponseMessage(errorMessage);
2239 log.info("Updated MD-SAL for {} [{},{}]", SVC_OPERATION, preload_name, preload_type);
2240 log.info("Returned SUCCESS for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type, responseBuilder.build());
2242 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2243 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2244 return Futures.immediateFuture(rpcResult);
2249 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2250 PreloadNetworkTopologyOperationInput input) {
2252 final String SVC_OPERATION = "preload-network-topology-operation";
2253 PreloadData preloadData;
2254 Properties parms = new Properties();
2256 log.info("{} called.", SVC_OPERATION);
2257 // create a new response object
2258 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2260 // Result from savePreloadData
2261 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2263 if(input == null || input.getNetworkTopologyInformation() == null ||
2264 input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null) {
2266 log.debug("exiting {} because of null input", SVC_OPERATION);
2267 responseBuilder.setResponseCode("403");
2268 responseBuilder.setResponseMessage("input is null");
2269 responseBuilder.setAckFinalIndicator("Y");
2270 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2271 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2272 return Futures.immediateFuture(rpcResult);
2275 // Grab the name and type from the input buffer
2276 String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2277 String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2279 // Make sure we have a preload_name and preload_type
2280 if(preload_name == null || preload_name.length() == 0 || preload_type == null || preload_type.length() == 0 ) {
2281 log.debug("exiting {} because of invalid preload-name", SVC_OPERATION);
2282 responseBuilder.setResponseCode("403");
2283 responseBuilder.setResponseMessage("input, invalid preload-name");
2284 responseBuilder.setAckFinalIndicator("Y");
2285 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2286 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2287 return Futures.immediateFuture(rpcResult);
2290 if (input.getSdncRequestHeader() != null) {
2291 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2294 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2295 getPreloadData(preload_name, preload_type, preloadDataBuilder);
2297 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2298 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
2301 // setup a preload-data object builder
2302 // ACTION preload-network-topology-operation
2304 // USES sdnc-request-header;
2305 // USES request-information;
2306 // uses network-topology-information;
2308 // USES vnf-topology-response-body;
2310 // container preload-data
2311 // uses vnf-topology-information;
2312 // uses network-topology-information;
2313 // uses oper-status;
2316 log.info("Adding INPUT data for {} [{},{}] input: {}", SVC_OPERATION, preload_name, preload_type, input);
2317 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(input);
2318 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2319 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}",
2320 SVC_OPERATION, preload_name, preload_type, operDataBuilder.build());
2321 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
2323 // Call SLI sync method
2324 // Get SvcLogicService reference
2326 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
2327 Properties respProps = null;
2329 String errorCode = "200";
2330 String errorMessage = null;
2331 String ackFinal = "Y";
2336 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
2341 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2345 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
2346 errorMessage = e.getMessage();
2350 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
2357 errorMessage = e.getMessage();
2358 log.error("Caught exception looking for service logic", e);
2362 if (respProps != null)
2364 errorCode = respProps.getProperty("error-code");
2365 errorMessage = respProps.getProperty("error-message");
2366 ackFinal = respProps.getProperty("ack-final", "Y");
2367 // internalError = respProps.getProperty("internal-error", "false");
2370 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2372 responseBuilder.setResponseCode(errorCode);
2373 responseBuilder.setResponseMessage(errorMessage);
2374 responseBuilder.setAckFinalIndicator(ackFinal);
2376 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2377 preloadVnfListBuilder.setVnfName(preload_name);
2378 preloadVnfListBuilder.setVnfType(preload_type);
2379 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2380 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'",
2381 SVC_OPERATION, preload_name, preload_type, errorCode, errorMessage);
2383 savePreloadList(preloadVnfListBuilder.build(),true, LogicalDatastoreType.CONFIGURATION);
2384 } catch (Exception e) {
2385 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n",
2386 SVC_OPERATION, preload_name, preload_type, e);
2389 log.debug("Sending Success rpc result due to external error");
2390 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2391 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2392 return Futures.immediateFuture(rpcResult);
2395 // Got success from SLI
2397 preloadData = preloadDataBuilder.build();
2398 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}",
2399 SVC_OPERATION, preload_name, preload_type, preloadData);
2400 // svc-configuration-list
2401 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2402 preloadVnfListBuilder.setVnfName(preload_name);
2403 preloadVnfListBuilder.setVnfType(preload_type);
2404 preloadVnfListBuilder.setPreloadData(preloadData);
2406 // merge flag sets to false to allow it to be overwritten (not appended)
2407 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2408 log.info("Updating OPERATIONAL tree.");
2409 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2410 } catch (Exception e) {
2411 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2412 responseBuilder.setResponseCode("500");
2413 responseBuilder.setResponseMessage(e.toString());
2414 responseBuilder.setAckFinalIndicator("Y");
2415 log.error("Returned FAILED for {} [{},{}] {}",
2416 SVC_OPERATION, preload_name, preload_type, responseBuilder.build());
2417 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2418 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2419 return Futures.immediateFuture(rpcResult);
2423 responseBuilder.setResponseCode(errorCode);
2424 responseBuilder.setAckFinalIndicator(ackFinal);
2425 if (errorMessage != null)
2427 responseBuilder.setResponseMessage(errorMessage);
2429 log.info("Updated MD-SAL for {} [{},{}]", SVC_OPERATION, preload_name, preload_type);
2430 log.info("Returned SUCCESS for {} [{},{}] {}",
2431 SVC_OPERATION, preload_name, preload_type, responseBuilder.build());
2433 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2434 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2435 return Futures.immediateFuture(rpcResult);