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.ContrailRouteTopologyOperationInput;
23 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInputBuilder;
24 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutput;
25 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutputBuilder;
26 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GENERICRESOURCEAPIService;
27 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInput;
28 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInputBuilder;
29 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutput;
30 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutputBuilder;
31 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInput;
32 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInputBuilder;
33 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutput;
34 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutputBuilder;
35 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationInput;
36 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationInputBuilder;
37 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationOutput;
38 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationOutputBuilder;
39 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfs;
40 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfsBuilder;
41 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInput;
42 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInputBuilder;
43 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutput;
44 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutputBuilder;
45 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInput;
46 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInputBuilder;
47 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutput;
48 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutputBuilder;
49 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.Services;
50 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServicesBuilder;
51 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInput;
52 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInputBuilder;
53 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutput;
54 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutputBuilder;
55 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInput;
56 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInputBuilder;
57 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutput;
58 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutputBuilder;
59 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.contrail.route.response.information.ContrailRouteResponseInformationBuilder;
60 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.network.response.information.NetworkResponseInformationBuilder;
61 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadData;
62 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadDataBuilder;
63 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadList;
64 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadListBuilder;
65 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadListKey;
66 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.request.information.RequestInformation;
67 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader;
68 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader.SvcAction;
69 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.security.zone.response.information.SecurityZoneResponseInformationBuilder;
70 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceData;
71 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceDataBuilder;
72 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.Service;
73 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceBuilder;
74 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceKey;
75 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.response.information.ServiceResponseInformationBuilder;
76 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RequestStatus;
77 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RpcAction;
78 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatusBuilder;
79 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
80 import org.opendaylight.yangtools.yang.common.RpcResult;
81 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
82 import org.slf4j.Logger;
83 import org.slf4j.LoggerFactory;
85 import com.google.common.base.Optional;
86 import com.google.common.util.concurrent.CheckedFuture;
87 import com.google.common.util.concurrent.Futures;
88 import com.google.common.util.concurrent.SettableFuture;
92 * Defines a base implementation for your provider. This class extends from a helper class
93 * which provides storage for the most commonly used components of the MD-SAL. Additionally the
94 * base class provides some basic logging and initialization / clean up methods.
96 * To use this, copy and paste (overwrite) the following method into the TestApplicationProviderModule
97 * class which is auto generated under src/main/java in this project
98 * (created only once during first compilation):
103 public java.lang.AutoCloseable createInstance() {
105 //final GENERIC-RESOURCE-APIProvider provider = new GENERIC-RESOURCE-APIProvider();
106 final GenericResourceApiProvider provider = new GenericResourceApiProvider();
107 provider.setDataBroker( getDataBrokerDependency() );
108 provider.setNotificationService( getNotificationServiceDependency() );
109 provider.setRpcRegistry( getRpcRegistryDependency() );
110 provider.initialize();
111 return new AutoCloseable() {
114 public void close() throws Exception {
115 //TODO: CLOSE ANY REGISTRATION OBJECTS CREATED USING ABOVE BROKER/NOTIFICATION
116 //SERVIE/RPC REGISTRY
126 public class GenericResourceApiProvider implements AutoCloseable, GENERICRESOURCEAPIService{
128 private final Logger log = LoggerFactory.getLogger( GenericResourceApiProvider.class );
129 private final String appName = "generic-resource-api";
131 private final ExecutorService executor;
133 protected DataBroker dataBroker;
134 protected NotificationPublishService notificationService;
135 protected RpcProviderRegistry rpcRegistry;
136 protected BindingAwareBroker.RpcRegistration<GENERICRESOURCEAPIService> rpcRegistration;
138 public GenericResourceApiProvider(DataBroker dataBroker2,
139 NotificationPublishService notificationPublishService,
140 RpcProviderRegistry rpcProviderRegistry) {
141 log.info( "Creating provider for {}", appName);
142 executor = Executors.newFixedThreadPool(1);
143 dataBroker = dataBroker2;
144 notificationService = notificationPublishService;
145 rpcRegistry = rpcProviderRegistry;
150 public void initialize(){
151 log.info("Initializing provider for {}", appName);
152 // Create the top level containers
155 GenericResourceApiUtil.loadProperties();
156 } catch (Exception e) {
157 log.error("Caught Exception while trying to load properties file");
159 rpcRegistration = rpcRegistry.addRpcImplementation(GENERICRESOURCEAPIService.class, this);
161 log.info("Initialization complete for {}", appName);
165 protected void initializeChild() {
166 //Override if you have custom initialization intelligence
171 public void close() throws Exception {
172 log.info("Closing provider for {}", appName);
174 rpcRegistration.close();
175 log.info("Successfully closed provider for {}", appName);
178 private static class Iso8601Util
180 private static TimeZone tz = TimeZone.getTimeZone("UTC");
181 private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
183 static { df.setTimeZone(tz); }
185 private static String now() {
186 return df.format(new Date());
191 public void setDataBroker(DataBroker dataBroker) {
192 this.dataBroker = dataBroker;
193 if( log.isDebugEnabled() ){
194 log.debug("DataBroker set to {}", (dataBroker==null?"null":"non-null"));
198 public void setNotificationService(NotificationPublishService notificationService) {
199 this.notificationService = notificationService;
200 if( log.isDebugEnabled() ){
201 log.debug("Notification Service set to {}", (notificationService==null?"null":"non-null"));
205 public void setRpcRegistry(RpcProviderRegistry rpcRegistry) {
206 this.rpcRegistry = rpcRegistry;
207 if( log.isDebugEnabled() ){
208 log.debug("RpcRegistry set to {}", (rpcRegistry==null?"null":"non-null"));
212 private void createContainers() {
214 final WriteTransaction t = dataBroker.newReadWriteTransaction();
216 // Create the service-instance container
217 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Services.class),
218 new ServicesBuilder().build());
219 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Services.class),
220 new ServicesBuilder().build());
222 // Create the PreloadVnfs container
223 t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
224 new PreloadVnfsBuilder().build());
225 t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
226 new PreloadVnfsBuilder().build());
229 CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
231 log.info("Create containers succeeded!");
233 } catch (InterruptedException | ExecutionException e) {
234 log.error("Create containers failed: ", e);
238 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage, String ackFinal)
240 serviceStatusBuilder.setResponseCode(errorCode);
241 serviceStatusBuilder.setResponseMessage(errorMessage);
242 serviceStatusBuilder.setFinalIndicator(ackFinal);
243 serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
246 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation)
248 if (requestInformation != null && requestInformation.getRequestAction() != null) {
249 serviceStatusBuilder.setAction(requestInformation.getRequestAction().toString());
253 if (requestInformation != null && requestInformation.getRequestSubAction() != null) {
254 switch (requestInformation.getRequestSubAction())
257 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP);
260 serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
263 log.error("Unknown RequestSubAction: " + requestInformation.getRequestSubAction() );
270 private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader)
272 if (requestHeader != null && requestHeader.getSvcAction() != null) {
273 switch (requestHeader.getSvcAction())
276 serviceStatusBuilder.setRpcAction(RpcAction.Assign);
279 serviceStatusBuilder.setRpcAction(RpcAction.Unassign);
282 serviceStatusBuilder.setRpcAction(RpcAction.Activate);
285 serviceStatusBuilder.setRpcAction(RpcAction.Deactivate);
288 serviceStatusBuilder.setRpcAction(RpcAction.Delete);
291 log.error("Unknown SvcAction: {}", requestHeader.getSvcAction() );
297 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder)
300 getServiceData(siid,serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
304 private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type)
306 // See if any data exists yet for this siid, if so grab it.
307 InstanceIdentifier serviceInstanceIdentifier =
308 InstanceIdentifier.<Services>builder(Services.class)
309 .child(Service.class, new ServiceKey(siid)).build();
310 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
311 Optional<Service> data = null;
313 data = (Optional<Service>) readTx.read(type, serviceInstanceIdentifier).get();
314 } catch (InterruptedException | ExecutionException e) {
315 log.error("Caught Exception reading MD-SAL ({}) data for [{}] ", type, siid, e);
318 if (data != null && data.isPresent()) {
319 ServiceData serviceData = data.get().getServiceData();
320 if (serviceData != null) {
321 log.info("Read MD-SAL ({}) data for [{}] ServiceData: {}", type, siid, serviceData);
322 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
323 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
324 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
325 serviceDataBuilder.setServiceRequestInput(serviceData.getServiceRequestInput());
326 serviceDataBuilder.setServiceTopology(serviceData.getServiceTopology());
327 serviceDataBuilder.setServiceLevelOperStatus(serviceData.getServiceLevelOperStatus());
328 serviceDataBuilder.setNetworks(serviceData.getNetworks());
329 serviceDataBuilder.setVnfs(serviceData.getVnfs());
330 serviceDataBuilder.setProvidedAllottedResources(serviceData.getProvidedAllottedResources());
331 serviceDataBuilder.setConsumedAllottedResources(serviceData.getConsumedAllottedResources());
332 // service-instance-id needs to be set
334 log.info("No service-data found in MD-SAL ({}) for [{}]", type, siid);
337 log.info("No data found in MD-SAL ({}) for [{}]", type, siid);
341 private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder)
344 getPreloadData(vnf_name, vnf_type ,preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
347 private void getPreloadData(String preload_name, String preload_type, PreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type)
349 // See if any data exists yet for this name/type, if so grab it.
350 InstanceIdentifier preloadInstanceIdentifier = InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
351 .child(VnfPreloadList.class, new VnfPreloadListKey(preload_name, preload_type)).build();
352 ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
353 Optional<VnfPreloadList> data = null;
355 data = (Optional<VnfPreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
356 } catch (InterruptedException | ExecutionException e) {
357 log.error("Caught Exception reading MD-SAL ({}) for [{},{}] ", type, preload_name, preload_type, e);
360 if (data != null && data.isPresent()) {
361 PreloadData preloadData = data.get().getPreloadData();
362 if (preloadData != null) {
363 log.info("Read MD-SAL ({}) data for [{},{}] PreloadData: {}",
364 type, preload_name, preload_type, preloadData);
365 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
366 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
367 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
369 log.info("No preload-data found in MD-SAL ({}) for [{},{}] ", type, preload_name, preload_type);
372 log.info("No data found in MD-SAL ({}) for [{},{}] ", type, preload_name, preload_type);
376 private void saveService(final Service entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException {
377 // Each entry will be identifiable by a unique key, we have to create that identifier
378 InstanceIdentifier.InstanceIdentifierBuilder<Service> serviceBuilder =
379 InstanceIdentifier.<Services>builder(Services.class)
380 .child(Service.class, entry.getKey());
381 InstanceIdentifier<Service> path = serviceBuilder.build();
386 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
388 tx.merge(storeType, path, entry);
390 tx.put(storeType, path, entry);
392 tx.submit().checkedGet();
393 log.debug("Update DataStore succeeded");
395 } catch (final TransactionCommitFailedException e) {
396 if(e instanceof OptimisticLockFailedException) {
398 log.debug("Got OptimisticLockFailedException on last try - failing ");
399 throw new IllegalStateException(e);
401 log.debug("Got OptimisticLockFailedException - trying again ");
403 log.debug("Update DataStore failed");
404 throw new IllegalStateException(e);
410 private void deleteService(final Service entry, LogicalDatastoreType storeType) throws IllegalStateException {
411 // Each entry will be identifiable by a unique key, we have to create
413 InstanceIdentifier.InstanceIdentifierBuilder<Service> serviceListIdBuilder = InstanceIdentifier.<Services> builder(Services.class).child(Service.class, entry.getKey());
414 InstanceIdentifier<Service> path = serviceListIdBuilder.build();
419 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
420 tx.delete(storeType, path);
421 tx.submit().checkedGet();
422 log.debug("DataStore delete succeeded");
424 } catch (final TransactionCommitFailedException e) {
425 if (e instanceof OptimisticLockFailedException) {
427 log.debug("Got OptimisticLockFailedException on last try - failing ");
428 throw new IllegalStateException(e);
430 log.debug("Got OptimisticLockFailedException - trying again ");
432 log.debug("Update DataStore failed");
433 throw new IllegalStateException(e);
439 private void savePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException{
441 // Each entry will be identifiable by a unique key, we have to create that identifier
442 InstanceIdentifier.InstanceIdentifierBuilder<VnfPreloadList> vnfPreloadListBuilder =
443 InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
444 .child(VnfPreloadList.class, entry.getKey());
445 InstanceIdentifier<VnfPreloadList> path = vnfPreloadListBuilder.build();
449 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
451 tx.merge(storeType, path, entry);
453 tx.put(storeType, path, entry);
455 tx.submit().checkedGet();
456 log.debug("Update DataStore succeeded");
458 } catch (final TransactionCommitFailedException e) {
459 if(e instanceof OptimisticLockFailedException) {
461 log.debug("Got OptimisticLockFailedException on last try - failing ");
462 throw new IllegalStateException(e);
464 log.debug("Got OptimisticLockFailedException - trying again ");
466 log.debug("Update DataStore failed");
467 throw new IllegalStateException(e);
474 public Future<RpcResult<ServiceTopologyOperationOutput>> serviceTopologyOperation(
475 ServiceTopologyOperationInput input) {
477 final String SVC_OPERATION = "service-topology-operation";
478 ServiceData serviceData;
479 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
480 Properties parms = new Properties();
482 log.info("{} called.",SVC_OPERATION);
483 // create a new response object
484 ServiceTopologyOperationOutputBuilder responseBuilder = new ServiceTopologyOperationOutputBuilder();
487 input.getServiceInformation() == null ||
488 input.getServiceInformation().getServiceInstanceId() == null ||
489 input.getServiceInformation().getServiceInstanceId().length() == 0)
491 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
492 responseBuilder.setResponseCode("404");
493 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
494 responseBuilder.setAckFinalIndicator("Y");
495 RpcResult<ServiceTopologyOperationOutput> rpcResult =
496 RpcResultBuilder.<ServiceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
497 return Futures.immediateFuture(rpcResult);
500 // Grab the service instance ID from the input buffer
501 String siid = input.getServiceInformation().getServiceInstanceId();
503 if (input.getSdncRequestHeader() != null) {
504 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
507 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
508 getServiceData(siid,serviceDataBuilder);
510 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
511 getServiceData(siid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
513 // Set the serviceStatus based on input
514 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
515 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
518 // setup a service-data object builder
519 // ACTION service-topology-operation
521 // USES uses service-operation-information
523 // uses topology-response-common;
524 // uses service-response-information;
527 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
528 ServiceTopologyOperationInputBuilder inputBuilder = new ServiceTopologyOperationInputBuilder(input);
529 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
531 log.info("Adding OPERATIONAL data for {} [{}] operational-data: {}", SVC_OPERATION, siid, operDataBuilder.build());
532 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
534 // Call SLI sync method
535 // Get SvcLogicService reference
537 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
538 Properties respProps = null;
540 String errorCode = "200";
541 String errorMessage = null;
542 String ackFinal = "Y";
543 String serviceObjectPath = null;
547 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
552 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
556 log.error("Caught exception executing service logic for {} ", SVC_OPERATION, e);
557 errorMessage = e.getMessage();
561 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
568 errorMessage = e.getMessage();
569 log.error("Caught exception looking for service logic", e);
573 if (respProps != null)
575 errorCode = respProps.getProperty("error-code");
576 errorMessage = respProps.getProperty("error-message");
577 ackFinal = respProps.getProperty("ack-final", "Y");
578 serviceObjectPath = respProps.getProperty("service-object-path");
581 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
582 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
583 //serviceStatusBuilder.setRpcName(RpcName.ServiceTopologyOperation);
584 serviceStatusBuilder.setRpcName(SVC_OPERATION);
586 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
587 responseBuilder.setResponseCode(errorCode);
588 responseBuilder.setResponseMessage(errorMessage);
589 responseBuilder.setAckFinalIndicator(ackFinal);
591 ServiceBuilder serviceBuilder = new ServiceBuilder();
592 serviceBuilder.setServiceInstanceId(siid);
593 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
595 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
596 } catch (Exception e) {
597 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
599 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
600 RpcResult<ServiceTopologyOperationOutput> rpcResult =
601 RpcResultBuilder.<ServiceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
602 return Futures.immediateFuture(rpcResult);
605 // Got success from SLI
607 serviceData = serviceDataBuilder.build();
608 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
611 ServiceBuilder serviceBuilder = new ServiceBuilder();
612 serviceBuilder.setServiceData(serviceData);
613 serviceBuilder.setServiceInstanceId(siid);
614 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
615 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
617 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
619 // Only update operational tree on delete
620 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete))
622 log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
623 deleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
624 deleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
628 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
629 serviceResponseInformationBuilder.setInstanceId(siid);
630 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
631 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
633 } catch (Exception e) {
634 log.error("Caught Exception updating MD-SAL for {} [{}] \n",SVC_OPERATION, siid, e);
635 responseBuilder.setResponseCode("500");
636 responseBuilder.setResponseMessage(e.toString());
637 responseBuilder.setAckFinalIndicator("Y");
638 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
639 RpcResult<ServiceTopologyOperationOutput> rpcResult =
640 RpcResultBuilder.<ServiceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
641 return Futures.immediateFuture(rpcResult);
645 responseBuilder.setResponseCode(errorCode);
646 responseBuilder.setAckFinalIndicator(ackFinal);
647 if (errorMessage != null)
649 responseBuilder.setResponseMessage(errorMessage);
651 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
652 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
654 RpcResult<ServiceTopologyOperationOutput> rpcResult =
655 RpcResultBuilder.<ServiceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
656 return Futures.immediateFuture(rpcResult);
660 public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(
661 VnfTopologyOperationInput input) {
663 final String SVC_OPERATION = "vnf-topology-operation";
664 ServiceData serviceData;
665 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
666 Properties parms = new Properties();
668 log.info("{} called.", SVC_OPERATION);
669 // create a new response object
670 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
673 input.getServiceInformation() == null ||
674 input.getServiceInformation().getServiceInstanceId() == null ||
675 input.getServiceInformation().getServiceInstanceId().length() == 0)
677 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
678 responseBuilder.setResponseCode("404");
679 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
680 responseBuilder.setAckFinalIndicator("Y");
681 RpcResult<VnfTopologyOperationOutput> rpcResult =
682 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
684 return Futures.immediateFuture(rpcResult);
687 // Grab the service instance ID from the input buffer
688 String siid = input.getServiceInformation().getServiceInstanceId();
690 if (input.getSdncRequestHeader() != null) {
691 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
694 if(input.getVnfInformation() == null ||
695 input.getVnfInformation().getVnfId() == null ||
696 input.getVnfInformation().getVnfId().length() == 0)
698 log.debug("exiting {} because of null or empty vnf-id", SVC_OPERATION);
699 responseBuilder.setResponseCode("404");
700 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
701 responseBuilder.setAckFinalIndicator("Y");
702 RpcResult<VnfTopologyOperationOutput> rpcResult =
703 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
704 return Futures.immediateFuture(rpcResult);
707 /* Mobility wont use vipr intf in 1707
709 String preload_name = null;
710 String preload_type = null;
711 if (input.getVnfRequestInput() != null &&
712 input.getVnfRequestInput().getVnfName() != null && input.getVnfRequestInput().getVnfName().length() != 0) {
713 preload_name = input.getVnfRequestInput().getVnfName();
715 if (input.getVnfInformation().getVnfType() != null &&
716 input.getVnfInformation().getVnfType().length() != 0) {
717 preload_type = input.getVnfInformation().getVnfType();
720 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
721 if (preload_name != null && preload_type != null) {
722 getPreloadData(preload_name, preload_type, preloadDataBuilder);
725 log.info("vnf-name and vnf-type not present in the request");
729 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
730 getServiceData(siid,serviceDataBuilder);
732 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
733 getServiceData(siid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
735 // Set the serviceStatus based on input
736 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
737 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
740 // setup a service-data object builder
741 // ACTION vnf-topology-operation
743 // USES sdnc-request-header;
744 // USES request-information;
745 // USES service-information;
746 // USES vnf-request-information
748 // USES vnf-topology-response-body;
749 // USES vnf-information
750 // USES service-information
752 // container service-data
753 // uses vnf-configuration-information;
756 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
757 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
758 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
760 log.info("Adding OPERATIONAL data for {} [{}] operational-data: {}", SVC_OPERATION, siid, operDataBuilder.build());
761 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
764 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " + preloadDataBuilder.build());
765 GenericResourceApiUtil.toProperties(parms, "preload-data", preloadDataBuilder);
768 // Call SLI sync method
769 // Get SvcLogicService reference
771 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
772 Properties respProps = null;
774 String errorCode = "200";
775 String errorMessage = null;
776 String ackFinal = "Y";
777 String serviceObjectPath = null;
781 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
786 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
790 log.error("Caught exception executing service logic for {} ", SVC_OPERATION, e);
791 errorMessage = e.getMessage();
795 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
802 errorMessage = e.getMessage();
803 log.error("Caught exception looking for service logic", e);
806 if (respProps != null)
808 errorCode = respProps.getProperty("error-code");
809 errorMessage = respProps.getProperty("error-message");
810 ackFinal = respProps.getProperty("ack-final", "Y");
811 serviceObjectPath = respProps.getProperty("vnf-object-path");
814 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
815 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
816 //serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
817 serviceStatusBuilder.setRpcName(SVC_OPERATION);
819 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
820 responseBuilder.setResponseCode(errorCode);
821 responseBuilder.setResponseMessage(errorMessage);
822 responseBuilder.setAckFinalIndicator(ackFinal);
824 ServiceBuilder serviceBuilder = new ServiceBuilder();
825 serviceBuilder.setServiceInstanceId(siid);
826 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
828 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
829 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
831 // Only update operational tree on activate or delete
832 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
833 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
835 log.info("Updating OPERATIONAL tree.");
836 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
839 } catch (Exception e) {
840 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
842 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
843 RpcResult<VnfTopologyOperationOutput> rpcResult =
844 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
846 return Futures.immediateFuture(rpcResult);
849 // Got success from SLI
851 serviceData = serviceDataBuilder.build();
852 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
855 ServiceBuilder serviceBuilder = new ServiceBuilder();
856 serviceBuilder.setServiceData(serviceData);
857 serviceBuilder.setServiceInstanceId(siid);
858 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
859 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
861 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
863 // Only update operational tree on Assign
864 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
866 log.info("Updating OPERATIONAL tree.");
867 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
871 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
872 serviceResponseInformationBuilder.setInstanceId(siid);
873 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
874 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
876 } catch (Exception e) {
877 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
878 responseBuilder.setResponseCode("500");
879 responseBuilder.setResponseMessage(e.toString());
880 responseBuilder.setAckFinalIndicator("Y");
881 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
882 RpcResult<VnfTopologyOperationOutput> rpcResult =
883 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
884 return Futures.immediateFuture(rpcResult);
888 responseBuilder.setResponseCode(errorCode);
889 responseBuilder.setAckFinalIndicator(ackFinal);
890 if (errorMessage != null)
892 responseBuilder.setResponseMessage(errorMessage);
894 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
895 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
897 RpcResult<VnfTopologyOperationOutput> rpcResult =
898 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
900 return Futures.immediateFuture(rpcResult);
904 public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
905 VfModuleTopologyOperationInput input) {
907 final String SVC_OPERATION = "vf-module-topology-operation";
908 ServiceData serviceData;
909 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
910 Properties parms = new Properties();
912 log.info("{} called.", SVC_OPERATION);
913 // create a new response object
914 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
917 input.getServiceInformation() == null ||
918 input.getServiceInformation().getServiceInstanceId() == null ||
919 input.getServiceInformation().getServiceInstanceId().length() == 0)
921 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
922 responseBuilder.setResponseCode("403");
923 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
924 responseBuilder.setAckFinalIndicator("Y");
925 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
926 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
928 return Futures.immediateFuture(rpcResult);
931 if(input.getVnfInformation() == null ||
932 input.getVnfInformation().getVnfId() == null ||
933 input.getVnfInformation().getVnfId().length() == 0)
935 log.debug("exiting {} because of null or empty vnf-id", SVC_OPERATION);
936 responseBuilder.setResponseCode("403");
937 responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
938 responseBuilder.setAckFinalIndicator("Y");
939 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
940 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
941 return Futures.immediateFuture(rpcResult);
944 if(input.getVfModuleInformation() == null ||
945 input.getVfModuleInformation().getVfModuleId() == null ||
946 input.getVfModuleInformation().getVfModuleId().length() == 0)
948 log.debug("exiting {} because of null or empty vf-module-id", SVC_OPERATION);
949 responseBuilder.setResponseCode("403");
950 responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
951 responseBuilder.setAckFinalIndicator("Y");
952 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
953 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
954 return Futures.immediateFuture(rpcResult);
957 // Grab the service instance ID from the input buffer
958 String siid = input.getServiceInformation().getServiceInstanceId();
960 if (input.getSdncRequestHeader() != null) {
961 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
965 String preload_name = null;
966 String preload_type = null;
968 preload_name = input.getVfModuleRequestInput().getVfModuleName();
970 if(input.getVfModuleInformation().getVfModuleType() != null &&
971 input.getVfModuleInformation().getVfModuleType().length() != 0) {
972 preload_type = input.getVfModuleInformation().getVfModuleType();
975 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
976 if (preload_name != null && preload_type != null) {
977 getPreloadData(preload_name, preload_type, preloadDataBuilder);
980 log.debug("vf-module-name and vf-module-type not present in the request.");
984 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
985 getServiceData(siid,serviceDataBuilder);
987 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
988 getServiceData(siid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
990 // Set the serviceStatus based on input
991 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
992 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
995 // setup a service-data object builder
996 // ACTION vnf-topology-operation
998 // USES sdnc-request-header;
999 // USES request-information;
1000 // USES service-information;
1001 // USES vnf-request-information
1003 // USES vnf-topology-response-body;
1004 // USES vnf-information
1005 // USES service-information
1007 // container service-data
1008 // uses vnf-configuration-information;
1009 // uses oper-status;
1011 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1012 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1013 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1015 log.info("Adding OPERATIONAL data for {} [{}] operational-data: {}", SVC_OPERATION, siid, operDataBuilder.build());
1016 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
1019 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " +preloadDataBuilder.build());
1020 GenericResourceApiUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1023 // Call SLI sync method
1024 // Get SvcLogicService reference
1026 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1027 Properties respProps = null;
1029 String errorCode = "200";
1030 String errorMessage = null;
1031 String ackFinal = "Y";
1032 String serviceObjectPath = null;
1036 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1041 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1045 log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1046 errorMessage = e.getMessage();
1050 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1057 errorMessage = e.getMessage();
1058 log.error("Caught exception looking for service logic", e);
1061 if (respProps != null)
1063 errorCode = respProps.getProperty("error-code");
1064 errorMessage = respProps.getProperty("error-message");
1065 ackFinal = respProps.getProperty("ack-final", "Y");
1066 serviceObjectPath = respProps.getProperty("vf-module-object-path");
1069 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
1070 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1071 serviceStatusBuilder.setRpcName(SVC_OPERATION);
1073 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1074 responseBuilder.setResponseCode(errorCode);
1075 responseBuilder.setResponseMessage(errorMessage);
1076 responseBuilder.setAckFinalIndicator(ackFinal);
1078 ServiceBuilder serviceBuilder = new ServiceBuilder();
1079 serviceBuilder.setServiceInstanceId(siid);
1080 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1082 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1083 } catch (Exception e) {
1084 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1086 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1087 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1088 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1090 return Futures.immediateFuture(rpcResult);
1093 // Got success from SLI
1095 serviceData = serviceDataBuilder.build();
1096 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1099 ServiceBuilder serviceBuilder = new ServiceBuilder();
1100 serviceBuilder.setServiceData(serviceData);
1101 //serviceBuilder.setServiceInstanceId(serviceData.getServiceTopology().getServiceTopologyIdentifier().getServiceInstanceId());
1102 serviceBuilder.setServiceInstanceId(siid);
1103 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1104 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1106 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1108 // Only update operational tree on activate or delete
1109 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1110 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1112 log.info("Updating OPERATIONAL tree.");
1113 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1117 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1118 serviceResponseInformationBuilder.setInstanceId(siid);
1119 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1120 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1122 } catch (Exception e) {
1123 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1124 responseBuilder.setResponseCode("500");
1125 responseBuilder.setResponseMessage(e.toString());
1126 responseBuilder.setAckFinalIndicator("Y");
1127 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1128 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1129 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1130 return Futures.immediateFuture(rpcResult);
1134 responseBuilder.setResponseCode(errorCode);
1135 responseBuilder.setAckFinalIndicator(ackFinal);
1136 if (errorMessage != null)
1138 responseBuilder.setResponseMessage(errorMessage);
1140 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1141 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1143 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1144 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1146 return Futures.immediateFuture(rpcResult);
1150 public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1151 NetworkTopologyOperationInput input) {
1153 final String SVC_OPERATION = "network-topology-operation";
1154 ServiceData serviceData;
1155 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1156 Properties parms = new Properties();
1158 log.info("{} called.", SVC_OPERATION );
1159 // create a new response object
1160 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1163 input.getServiceInformation() == null ||
1164 input.getServiceInformation().getServiceInstanceId() == null ||
1165 input.getServiceInformation().getServiceInstanceId().length() == 0)
1167 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1168 responseBuilder.setResponseCode("404");
1169 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1170 responseBuilder.setAckFinalIndicator("Y");
1171 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1172 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1173 return Futures.immediateFuture(rpcResult);
1176 String siid = input.getServiceInformation().getServiceInstanceId();
1178 // Get the service-instance service data from MD-SAL
1179 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1180 getServiceData(siid,serviceDataBuilder);
1182 if (input.getSdncRequestHeader() != null) {
1183 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1186 ServiceData sd = serviceDataBuilder.build();
1187 if (sd == null || sd.getServiceLevelOperStatus() == null)
1189 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1190 responseBuilder.setResponseCode("404");
1191 responseBuilder.setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1192 responseBuilder.setAckFinalIndicator("Y");
1193 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1194 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1195 return Futures.immediateFuture(rpcResult);
1200 //String preload_name = null;
1201 //String preload_type = null;
1202 // If both network-name and network-type are present in request, get the preload network from MD-SAL
1203 if (input.getNetworkRequestInput() != null &&
1204 input.getNetworkRequestInput().getNetworkName() != null &&
1205 input.getNetworkRequestInput().getNetworkName().length() != 0) {
1206 preload_name = input.getNetworkRequestInput().getNetworkName();
1208 if (input.getNetworkInformation() != null &&
1209 input.getNetworkInformation().getNetworkType() != null &&
1210 input.getNetworkInformation().getNetworkType().length() != 0) {
1211 preload_type = input.getNetworkInformation().getNetworkType();
1214 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1215 if (preload_name != null && preload_type != null) {
1216 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1219 log.debug("network-name and network-type not present in request");
1223 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1224 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1225 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1227 // Call SLI sync method
1228 // Get SvcLogicService reference
1230 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1231 Properties respProps = null;
1233 String errorCode = "200";
1234 String errorMessage = null;
1235 String ackFinal = "Y";
1236 String networkId = "error";
1237 String serviceObjectPath = null;
1238 String networkObjectPath = null;
1242 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1247 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1251 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1252 errorMessage = e.getMessage();
1256 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1263 errorMessage = e.getMessage();
1264 log.error("Caught exception looking for service logic", e);
1268 if (respProps != null)
1270 errorCode = respProps.getProperty("error-code");
1271 errorMessage = respProps.getProperty("error-message");
1272 ackFinal = respProps.getProperty("ack-final", "Y");
1273 networkId = respProps.getProperty("networkId");
1274 serviceObjectPath = respProps.getProperty("service-object-path");
1275 networkObjectPath = respProps.getProperty("network-object-path");
1278 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1279 responseBuilder.setResponseCode(errorCode);
1280 responseBuilder.setResponseMessage(errorMessage);
1281 responseBuilder.setAckFinalIndicator(ackFinal);
1283 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1285 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1286 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1287 return Futures.immediateFuture(rpcResult);
1290 // Got success from SLI
1293 serviceData = serviceDataBuilder.build();
1294 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1297 ServiceBuilder serviceBuilder = new ServiceBuilder();
1298 serviceBuilder.setServiceData(serviceData);
1299 serviceBuilder.setServiceInstanceId(siid);
1300 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1301 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1303 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1305 // Only update operational tree on Activate
1306 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1308 log.info("Updating OPERATIONAL tree.");
1309 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1313 NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1314 networkResponseInformationBuilder.setInstanceId(networkId);
1315 networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1316 responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1318 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1319 serviceResponseInformationBuilder.setInstanceId(siid);
1320 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1321 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1323 } catch (IllegalStateException e) {
1324 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1325 responseBuilder.setResponseCode("500");
1326 responseBuilder.setResponseMessage(e.toString());
1327 responseBuilder.setAckFinalIndicator("Y");
1328 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1329 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1330 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1331 return Futures.immediateFuture(rpcResult);
1335 responseBuilder.setResponseCode(errorCode);
1336 responseBuilder.setAckFinalIndicator(ackFinal);
1337 if (errorMessage != null)
1339 responseBuilder.setResponseMessage(errorMessage);
1341 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1342 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1344 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1345 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1346 return Futures.immediateFuture(rpcResult);
1350 public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1351 ContrailRouteTopologyOperationInput input) {
1353 final String SVC_OPERATION = "contrail-route-topology-operation";
1354 ServiceData serviceData;
1355 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1356 Properties parms = new Properties();
1358 log.info("{} called.", SVC_OPERATION);
1359 // create a new response object
1360 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1363 input.getServiceInformation() == null ||
1364 input.getServiceInformation().getServiceInstanceId() == null ||
1365 input.getServiceInformation().getServiceInstanceId().length() == 0)
1367 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1368 responseBuilder.setResponseCode("404");
1369 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1370 responseBuilder.setAckFinalIndicator("Y");
1371 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult =
1372 RpcResultBuilder.<ContrailRouteTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1373 return Futures.immediateFuture(rpcResult);
1376 String siid = input.getServiceInformation().getServiceInstanceId();
1378 // Get the service-instance service data from MD-SAL
1379 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1380 getServiceData(siid,serviceDataBuilder);
1382 if (input.getSdncRequestHeader() != null) {
1383 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1386 ServiceData sd = serviceDataBuilder.build();
1387 if (sd == null || sd.getServiceLevelOperStatus() == null)
1389 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1390 responseBuilder.setResponseCode("404");
1391 responseBuilder.setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1392 responseBuilder.setAckFinalIndicator("Y");
1393 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult =
1394 RpcResultBuilder.<ContrailRouteTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1395 return Futures.immediateFuture(rpcResult);
1398 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+siid+"] input: " + input);
1399 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1400 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1402 // Call SLI sync method
1403 // Get SvcLogicService reference
1405 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1406 Properties respProps = null;
1408 String errorCode = "200";
1409 String errorMessage = null;
1410 String ackFinal = "Y";
1411 String allottedResourceId = "error";
1412 String serviceObjectPath = null;
1413 String contrailRouteObjectPath = null;
1417 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1422 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1426 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1427 errorMessage = e.getMessage();
1431 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1438 errorMessage = e.getMessage();
1439 log.error("Caught exception looking for service logic", e);
1443 if (respProps != null)
1445 errorCode = respProps.getProperty("error-code");
1446 errorMessage = respProps.getProperty("error-message");
1447 ackFinal = respProps.getProperty("ack-final", "Y");
1448 allottedResourceId = respProps.getProperty("allotted-resource-id");
1449 serviceObjectPath = respProps.getProperty("service-object-path");
1450 contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1453 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1454 responseBuilder.setResponseCode(errorCode);
1455 responseBuilder.setResponseMessage(errorMessage);
1456 responseBuilder.setAckFinalIndicator(ackFinal);
1458 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1460 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult =
1461 RpcResultBuilder.<ContrailRouteTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1462 return Futures.immediateFuture(rpcResult);
1465 // Got success from SLI
1468 serviceData = serviceDataBuilder.build();
1469 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1472 ServiceBuilder serviceBuilder = new ServiceBuilder();
1473 serviceBuilder.setServiceData(serviceData);
1474 serviceBuilder.setServiceInstanceId(siid);
1475 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1476 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1478 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1480 // Only update operational tree on activate or delete
1481 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1482 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1484 log.info("Updating OPERATIONAL tree.");
1485 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1489 ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1490 contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1491 contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1492 responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1494 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1495 serviceResponseInformationBuilder.setInstanceId(siid);
1496 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1497 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1499 } catch (IllegalStateException e) {
1500 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1501 responseBuilder.setResponseCode("500");
1502 responseBuilder.setResponseMessage(e.toString());
1503 responseBuilder.setAckFinalIndicator("Y");
1504 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1505 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult =
1506 RpcResultBuilder.<ContrailRouteTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1507 return Futures.immediateFuture(rpcResult);
1511 responseBuilder.setResponseCode(errorCode);
1512 responseBuilder.setAckFinalIndicator(ackFinal);
1513 if (errorMessage != null)
1515 responseBuilder.setResponseMessage(errorMessage);
1517 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1518 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1520 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult =
1521 RpcResultBuilder.<ContrailRouteTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1522 return Futures.immediateFuture(rpcResult);
1526 public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1527 SecurityZoneTopologyOperationInput input) {
1529 final String SVC_OPERATION = "security-zone-topology-operation";
1530 ServiceData serviceData;
1531 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1532 Properties parms = new Properties();
1534 log.info("{} called.", SVC_OPERATION);
1535 // create a new response object
1536 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1539 input.getServiceInformation() == null ||
1540 input.getServiceInformation().getServiceInstanceId() == null ||
1541 input.getServiceInformation().getServiceInstanceId().length() == 0)
1543 log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1544 responseBuilder.setResponseCode("404");
1545 responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1546 responseBuilder.setAckFinalIndicator("Y");
1547 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult =
1548 RpcResultBuilder.<SecurityZoneTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1549 return Futures.immediateFuture(rpcResult);
1552 String siid = input.getServiceInformation().getServiceInstanceId();
1554 // Get the service-instance service data from MD-SAL
1555 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1556 getServiceData(siid,serviceDataBuilder);
1558 if (input.getSdncRequestHeader() != null) {
1559 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1562 ServiceData sd = serviceDataBuilder.build();
1563 if (sd == null || sd.getServiceLevelOperStatus() == null)
1565 log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1566 responseBuilder.setResponseCode("404");
1567 responseBuilder.setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1568 responseBuilder.setAckFinalIndicator("Y");
1569 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult =
1570 RpcResultBuilder.<SecurityZoneTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1571 return Futures.immediateFuture(rpcResult);
1574 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1575 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1576 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1578 // Call SLI sync method
1579 // Get SvcLogicService reference
1581 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1582 Properties respProps = null;
1584 String errorCode = "200";
1585 String errorMessage = null;
1586 String ackFinal = "Y";
1587 String allottedResourceId = "error";
1588 String serviceObjectPath = null;
1589 String securityZoneObjectPath = null;
1593 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1598 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1602 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1603 errorMessage = e.getMessage();
1607 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1614 errorMessage = e.getMessage();
1615 log.error("Caught exception looking for service logic", e);
1619 if (respProps != null)
1621 errorCode = respProps.getProperty("error-code");
1622 errorMessage = respProps.getProperty("error-message");
1623 ackFinal = respProps.getProperty("ack-final", "Y");
1624 allottedResourceId = respProps.getProperty("allotted-resource-id");
1625 serviceObjectPath = respProps.getProperty("service-object-path");
1626 securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1629 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1630 responseBuilder.setResponseCode(errorCode);
1631 responseBuilder.setResponseMessage(errorMessage);
1632 responseBuilder.setAckFinalIndicator(ackFinal);
1634 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1636 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult =
1637 RpcResultBuilder.<SecurityZoneTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1638 return Futures.immediateFuture(rpcResult);
1641 // Got success from SLI
1644 serviceData = serviceDataBuilder.build();
1645 log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1648 ServiceBuilder serviceBuilder = new ServiceBuilder();
1649 serviceBuilder.setServiceData(serviceData);
1650 serviceBuilder.setServiceInstanceId(siid);
1651 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1652 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1654 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1656 // Only update operational tree on activate or delete
1657 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1658 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1660 log.info("Updating OPERATIONAL tree.");
1661 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1665 SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1666 securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1667 securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1668 responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1670 ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1671 serviceResponseInformationBuilder.setInstanceId(siid);
1672 serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1673 responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1675 } catch (IllegalStateException e) {
1676 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1677 responseBuilder.setResponseCode("500");
1678 responseBuilder.setResponseMessage(e.toString());
1679 responseBuilder.setAckFinalIndicator("Y");
1680 log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1681 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult =
1682 RpcResultBuilder.<SecurityZoneTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1683 return Futures.immediateFuture(rpcResult);
1687 responseBuilder.setResponseCode(errorCode);
1688 responseBuilder.setAckFinalIndicator(ackFinal);
1689 if (errorMessage != null)
1691 responseBuilder.setResponseMessage(errorMessage);
1693 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1694 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1696 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult =
1697 RpcResultBuilder.<SecurityZoneTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1698 return Futures.immediateFuture(rpcResult);
1702 public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1703 PreloadVnfTopologyOperationInput input) {
1705 final String SVC_OPERATION = "preload-vnf-topology-operation";
1706 PreloadData preloadData;
1707 Properties parms = new Properties();
1709 log.info("{} called.", SVC_OPERATION);
1710 // create a new response object
1711 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1713 // Result from savePreloadData
1714 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1716 if(input == null || input.getVnfTopologyInformation() == null ||
1717 input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null) {
1718 log.debug("exiting {} because of null input", SVC_OPERATION);
1719 responseBuilder.setResponseCode("403");
1720 responseBuilder.setResponseMessage("invalid input: input is null");
1721 responseBuilder.setAckFinalIndicator("Y");
1722 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1723 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1724 return Futures.immediateFuture(rpcResult);
1727 // Grab the name and type from the input buffer
1728 String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1729 String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1731 // Make sure we have a preload_name and preload_type
1732 if(preload_name == null || preload_name.length() == 0 || preload_type == null || preload_type.length() == 0 ) {
1733 log.debug("exiting {} vnf-name or vnf-type is null or empty", SVC_OPERATION);
1734 responseBuilder.setResponseCode("403");
1735 responseBuilder.setResponseMessage("invalid input: vnf-name or vnf-type is null or empty");
1736 responseBuilder.setAckFinalIndicator("Y");
1737 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1738 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1739 return Futures.immediateFuture(rpcResult);
1742 if (input.getSdncRequestHeader() != null) {
1743 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1746 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1747 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1749 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1750 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1752 // setup a preload-data object builder
1753 // ACTION preload-vnf-topology-operation
1755 // USES sdnc-request-header;
1756 // USES request-information;
1757 // uses vnf-topology-information;
1759 // USES vnf-topology-response-body;
1761 // container preload-data
1762 // uses vnf-topology-information;
1763 // uses network-topology-information;
1764 // uses oper-status;
1766 log.info("Adding INPUT data for {} [{},{}] input: {}", SVC_OPERATION, preload_name, preload_type, input);
1767 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1768 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1769 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}",
1770 SVC_OPERATION, preload_name, preload_type, operDataBuilder.build());
1771 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
1773 // Call SLI sync method
1774 // Get SvcLogicService reference
1776 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1777 Properties respProps = null;
1779 String errorCode = "200";
1780 String errorMessage = null;
1781 String ackFinal = "Y";
1786 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1791 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1795 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1796 errorMessage = e.getMessage();
1800 errorMessage = "No service logic active for "+ appName + ": '" + SVC_OPERATION + "'";
1807 errorMessage = e.getMessage();
1808 log.error("Caught exception looking for service logic", e);
1812 if (respProps != null)
1814 errorCode = respProps.getProperty("error-code");
1815 errorMessage = respProps.getProperty("error-message");
1816 ackFinal = respProps.getProperty("ack-final", "Y");
1817 // internalError = respProps.getProperty("internal-error", "false");
1820 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1822 responseBuilder.setResponseCode(errorCode);
1823 responseBuilder.setResponseMessage(errorMessage);
1824 responseBuilder.setAckFinalIndicator(ackFinal);
1826 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1827 preloadVnfListBuilder.setVnfName(preload_name);
1828 preloadVnfListBuilder.setVnfType(preload_type);
1829 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1830 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'",
1831 SVC_OPERATION, preload_name, preload_type, errorCode, errorMessage);
1833 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1834 } catch (Exception e) {
1835 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n",
1836 SVC_OPERATION, preload_name, preload_type, e);
1838 log.debug("Sending Success rpc result due to external error");
1839 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1840 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1841 return Futures.immediateFuture(rpcResult);
1844 // Got success from SLI
1846 preloadData = preloadDataBuilder.build();
1847 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}",
1848 SVC_OPERATION, preload_name, preload_type, preloadData);
1849 // svc-configuration-list
1850 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1851 preloadVnfListBuilder.setVnfName(preload_name);
1852 preloadVnfListBuilder.setVnfType(preload_type);
1853 preloadVnfListBuilder.setPreloadData(preloadData);
1855 // merge flag sets to false to allow it to be overwritten (not appended)
1856 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1857 log.info("Updating OPERATIONAL tree.");
1858 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1859 } catch (Exception e) {
1860 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n",
1861 SVC_OPERATION, preload_name, preload_type, e);
1862 responseBuilder.setResponseCode("500");
1863 responseBuilder.setResponseMessage(e.toString());
1864 responseBuilder.setAckFinalIndicator("Y");
1865 log.error("Returned FAILED for {} [{},{}] {}",
1866 SVC_OPERATION, preload_name, preload_type, responseBuilder.build());
1867 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1868 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(false).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, preload_name, preload_type);
1880 log.info("Returned SUCCESS for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type, responseBuilder.build());
1882 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1883 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1884 return Futures.immediateFuture(rpcResult);
1889 public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
1890 PreloadNetworkTopologyOperationInput input) {
1892 final String SVC_OPERATION = "preload-network-topology-operation";
1893 PreloadData preloadData;
1894 Properties parms = new Properties();
1896 log.info("{} called.", SVC_OPERATION);
1897 // create a new response object
1898 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
1900 // Result from savePreloadData
1901 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1903 if(input == null || input.getNetworkTopologyInformation() == null ||
1904 input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null) {
1906 log.debug("exiting {} because of null input", SVC_OPERATION);
1907 responseBuilder.setResponseCode("403");
1908 responseBuilder.setResponseMessage("input is null");
1909 responseBuilder.setAckFinalIndicator("Y");
1910 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
1911 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1912 return Futures.immediateFuture(rpcResult);
1915 // Grab the name and type from the input buffer
1916 String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
1917 String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
1919 // Make sure we have a preload_name and preload_type
1920 if(preload_name == null || preload_name.length() == 0 || preload_type == null || preload_type.length() == 0 ) {
1921 log.debug("exiting {} because of invalid preload-name", SVC_OPERATION);
1922 responseBuilder.setResponseCode("403");
1923 responseBuilder.setResponseMessage("input, invalid preload-name");
1924 responseBuilder.setAckFinalIndicator("Y");
1925 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
1926 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1927 return Futures.immediateFuture(rpcResult);
1930 if (input.getSdncRequestHeader() != null) {
1931 responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1934 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1935 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1937 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1938 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1941 // setup a preload-data object builder
1942 // ACTION preload-network-topology-operation
1944 // USES sdnc-request-header;
1945 // USES request-information;
1946 // uses network-topology-information;
1948 // USES vnf-topology-response-body;
1950 // container preload-data
1951 // uses vnf-topology-information;
1952 // uses network-topology-information;
1953 // uses oper-status;
1956 log.info("Adding INPUT data for {} [{},{}] input: {}", SVC_OPERATION, preload_name, preload_type, input);
1957 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(input);
1958 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1959 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}",
1960 SVC_OPERATION, preload_name, preload_type, operDataBuilder.build());
1961 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
1963 // Call SLI sync method
1964 // Get SvcLogicService reference
1966 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1967 Properties respProps = null;
1969 String errorCode = "200";
1970 String errorMessage = null;
1971 String ackFinal = "Y";
1976 if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1981 respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1985 log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1986 errorMessage = e.getMessage();
1990 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1997 errorMessage = e.getMessage();
1998 log.error("Caught exception looking for service logic", e);
2002 if (respProps != null)
2004 errorCode = respProps.getProperty("error-code");
2005 errorMessage = respProps.getProperty("error-message");
2006 ackFinal = respProps.getProperty("ack-final", "Y");
2007 // internalError = respProps.getProperty("internal-error", "false");
2010 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2012 responseBuilder.setResponseCode(errorCode);
2013 responseBuilder.setResponseMessage(errorMessage);
2014 responseBuilder.setAckFinalIndicator(ackFinal);
2016 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2017 preloadVnfListBuilder.setVnfName(preload_name);
2018 preloadVnfListBuilder.setVnfType(preload_type);
2019 preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2020 log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'",
2021 SVC_OPERATION, preload_name, preload_type, errorCode, errorMessage);
2023 savePreloadList(preloadVnfListBuilder.build(),true, LogicalDatastoreType.CONFIGURATION);
2024 } catch (Exception e) {
2025 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n",
2026 SVC_OPERATION, preload_name, preload_type, e);
2029 log.debug("Sending Success rpc result due to external error");
2030 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2031 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2032 return Futures.immediateFuture(rpcResult);
2035 // Got success from SLI
2037 preloadData = preloadDataBuilder.build();
2038 log.info("Updating MD-SAL for {} [{},{}] preloadData: {}",
2039 SVC_OPERATION, preload_name, preload_type, preloadData);
2040 // svc-configuration-list
2041 VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2042 preloadVnfListBuilder.setVnfName(preload_name);
2043 preloadVnfListBuilder.setVnfType(preload_type);
2044 preloadVnfListBuilder.setPreloadData(preloadData);
2046 // merge flag sets to false to allow it to be overwritten (not appended)
2047 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2048 log.info("Updating OPERATIONAL tree.");
2049 savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2050 } catch (Exception e) {
2051 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2052 responseBuilder.setResponseCode("500");
2053 responseBuilder.setResponseMessage(e.toString());
2054 responseBuilder.setAckFinalIndicator("Y");
2055 log.error("Returned FAILED for {} [{},{}] {}",
2056 SVC_OPERATION, preload_name, preload_type, responseBuilder.build());
2057 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2058 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2059 return Futures.immediateFuture(rpcResult);
2063 responseBuilder.setResponseCode(errorCode);
2064 responseBuilder.setAckFinalIndicator(ackFinal);
2065 if (errorMessage != null)
2067 responseBuilder.setResponseMessage(errorMessage);
2069 log.info("Updated MD-SAL for {} [{},{}]", SVC_OPERATION, preload_name, preload_type);
2070 log.info("Returned SUCCESS for {} [{},{}] {}",
2071 SVC_OPERATION, preload_name, preload_type, responseBuilder.build());
2073 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2074 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2075 return Futures.immediateFuture(rpcResult);