generic-resource-api/provider/src/main/java/org/onap/sdnc/northbound/GenericResourceApiProvider.java

   1 package org.onap.sdnc.northbound;
   2
   3 import java.text.DateFormat;
   4 import java.text.SimpleDateFormat;
   5 import java.util.Date;
   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;
  12
  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;
  94
  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;
  99
 100
 101 /**
 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.
 105  *
 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):
 109  *
 110  * <pre>
 111
 112     @Override
 113     public java.lang.AutoCloseable createInstance() {
 114
 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() {
 122
 123             @Override
 124             public void close() throws Exception {
 125                 //TODO: CLOSE ANY REGISTRATION OBJECTS CREATED USING ABOVE BROKER/NOTIFICATION
 126                 //SERVIE/RPC REGISTRY
 127                 provider.close();
 128             }
 129         };
 130     }
 131
 132
 133     </pre>
 134  */
 135
 136 public class GenericResourceApiProvider implements AutoCloseable, GENERICRESOURCEAPIService{
 137
 138     private final Logger log = LoggerFactory.getLogger( GenericResourceApiProvider.class );
 139     private final String appName = "generic-resource-api";
 140
 141     private final ExecutorService executor;
 142
 143     protected DataBroker dataBroker;
 144     protected NotificationPublishService notificationService;
 145     protected RpcProviderRegistry rpcRegistry;
 146     protected BindingAwareBroker.RpcRegistration<GENERICRESOURCEAPIService> rpcRegistration;
 147
 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;
 156         initialize();
 157
 158     }
 159
 160     public void initialize(){
 161         log.info("Initializing provider for {}", appName);
 162         // Create the top level containers
 163         createContainers();
 164         try {
 165             GenericResourceApiUtil.loadProperties();
 166         } catch (Exception e) {
 167             log.error("Caught Exception while trying to load properties file");
 168         }
 169         rpcRegistration = rpcRegistry.addRpcImplementation(GENERICRESOURCEAPIService.class, this);
 170
 171         log.info("Initialization complete for {}", appName);
 172     }
 173
 174
 175     protected void initializeChild() {
 176         //Override if you have custom initialization intelligence
 177     }
 178
 179
 180     @Override
 181     public void close() throws Exception {
 182         log.info("Closing provider for {}", appName);
 183         executor.shutdown();
 184         rpcRegistration.close();
 185         log.info("Successfully closed provider for {}", appName);
 186     }
 187
 188     private static class Iso8601Util
 189     {
 190         private static TimeZone tz = TimeZone.getTimeZone("UTC");
 191         private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
 192
 193         static { df.setTimeZone(tz); }
 194
 195         private static String now() {
 196             return df.format(new Date());
 197         }
 198     }
 199
 200
 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"));
 205         }
 206     }
 207
 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"));
 212         }
 213     }
 214
 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"));
 219         }
 220     }
 221
 222     private void createContainers() {
 223
 224         final WriteTransaction t = dataBroker.newReadWriteTransaction();
 225
 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());
 231
 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());
 237
 238         try {
 239             CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
 240             checkedFuture.get();
 241             log.info("Create containers succeeded!");
 242
 243         } catch (InterruptedException | ExecutionException e) {
 244             log.error("Create containers failed: ", e);
 245         }
 246     }
 247
 248     private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage, String ackFinal)
 249     {
 250         serviceStatusBuilder.setResponseCode(errorCode);
 251         serviceStatusBuilder.setResponseMessage(errorMessage);
 252         serviceStatusBuilder.setFinalIndicator(ackFinal);
 253         serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
 254     }
 255
 256     private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder,  RequestInformation requestInformation)
 257     {
 258         if (requestInformation != null && requestInformation.getRequestAction() != null) {
 259             serviceStatusBuilder.setAction(requestInformation.getRequestAction().toString());
 260         }
 261
 262         /*
 263         if (requestInformation != null && requestInformation.getRequestSubAction() != null) {
 264             switch (requestInformation.getRequestSubAction())
 265             {
 266                 case SUPP:
 267                     serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP);
 268                     break;
 269                 case CANCEL:
 270                     serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
 271                     break;
 272                 default:
 273                     log.error("Unknown RequestSubAction: " + requestInformation.getRequestSubAction() );
 274                     break;
 275             };
 276         }
 277         */
 278     }
 279
 280     private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder,  SdncRequestHeader requestHeader)
 281     {
 282         if (requestHeader != null && requestHeader.getSvcAction() != null) {
 283             switch (requestHeader.getSvcAction())
 284             {
 285                 case Assign:
 286                     serviceStatusBuilder.setRpcAction(RpcAction.Assign);
 287                     break;
 288                 case Unassign:
 289                     serviceStatusBuilder.setRpcAction(RpcAction.Unassign);
 290                     break;
 291                 case Activate:
 292                     serviceStatusBuilder.setRpcAction(RpcAction.Activate);
 293                     break;
 294                 case Deactivate:
 295                     serviceStatusBuilder.setRpcAction(RpcAction.Deactivate);
 296                     break;
 297                 case Delete:
 298                     serviceStatusBuilder.setRpcAction(RpcAction.Delete);
 299                     break;
 300                 default:
 301                     log.error("Unknown SvcAction: {}", requestHeader.getSvcAction() );
 302                     break;
 303             }
 304         }
 305     }
 306
 307     private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder)
 308     {
 309         // default to config
 310         getServiceData(siid,serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
 311     }
 312
 313
 314     private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type)
 315     {
 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;
 322         try {
 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);
 326         }
 327
 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
 343             } else {
 344                 log.info("No service-data found in MD-SAL ({}) for [{}]", type, siid);
 345             }
 346         } else {
 347             log.info("No data found in MD-SAL ({}) for [{}]", type, siid);
 348         }
 349     }
 350
 351     private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder)
 352     {
 353         // default to config
 354         getPreloadData(vnf_name, vnf_type ,preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
 355     }
 356
 357     private void getPreloadData(String preload_name, String preload_type, PreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type)
 358     {
 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;
 364         try {
 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);
 368         }
 369
 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());
 378             } else {
 379                 log.info("No preload-data found in MD-SAL ({}) for [{},{}] ", type, preload_name, preload_type);
 380             }
 381         } else {
 382             log.info("No data found in MD-SAL ({}) for [{},{}] ", type, preload_name, preload_type);
 383         }
 384     }
 385
 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();
 392
 393         int tries = 2;
 394         while(true) {
 395             try {
 396                 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 397                 if (merge) {
 398                     tx.merge(storeType, path, entry);
 399                 } else {
 400                     tx.put(storeType, path, entry);
 401                 }
 402                 tx.submit().checkedGet();
 403                 log.debug("Update DataStore succeeded");
 404                 break;
 405             } catch (final TransactionCommitFailedException e) {
 406                 if(e instanceof OptimisticLockFailedException) {
 407                     if(--tries <= 0) {
 408                         log.debug("Got OptimisticLockFailedException on last try - failing ");
 409                         throw new IllegalStateException(e);
 410                     }
 411                     log.debug("Got OptimisticLockFailedException - trying again ");
 412                 } else {
 413                     log.debug("Update DataStore failed");
 414                     throw new IllegalStateException(e);
 415                 }
 416             }
 417         }
 418     }
 419
 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
 422         // that identifier
 423         InstanceIdentifier.InstanceIdentifierBuilder<Service> serviceListIdBuilder = InstanceIdentifier.<Services> builder(Services.class).child(Service.class, entry.getKey());
 424         InstanceIdentifier<Service> path = serviceListIdBuilder.build();
 425
 426         int tries = 2;
 427         while (true) {
 428             try {
 429                 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 430                 tx.delete(storeType, path);
 431                 tx.submit().checkedGet();
 432                 log.debug("DataStore delete succeeded");
 433                 break;
 434             } catch (final TransactionCommitFailedException e) {
 435                 if (e instanceof OptimisticLockFailedException) {
 436                     if (--tries <= 0) {
 437                         log.debug("Got OptimisticLockFailedException on last try - failing ");
 438                         throw new IllegalStateException(e);
 439                     }
 440                     log.debug("Got OptimisticLockFailedException - trying again ");
 441                 } else {
 442                     log.debug("Update DataStore failed");
 443                     throw new IllegalStateException(e);
 444                 }
 445             }
 446         }
 447     }
 448
 449     private void savePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException{
 450
 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();
 456         int tries = 2;
 457         while(true) {
 458             try {
 459                 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 460                 if (merge) {
 461                     tx.merge(storeType, path, entry);
 462                 } else {
 463                     tx.put(storeType, path, entry);
 464                 }
 465                 tx.submit().checkedGet();
 466                 log.debug("Update DataStore succeeded");
 467                 break;
 468             } catch (final TransactionCommitFailedException e) {
 469                 if(e instanceof OptimisticLockFailedException) {
 470                     if(--tries <= 0) {
 471                         log.debug("Got OptimisticLockFailedException on last try - failing ");
 472                         throw new IllegalStateException(e);
 473                     }
 474                     log.debug("Got OptimisticLockFailedException - trying again ");
 475                 } else {
 476                     log.debug("Update DataStore failed");
 477                     throw new IllegalStateException(e);
 478                 }
 479             }
 480         }
 481     }
 482
 483         @Override
 484         public Future<RpcResult<ServiceTopologyOperationOutput>> serviceTopologyOperation(
 485                         ServiceTopologyOperationInput input) {
 486
 487                 final String SVC_OPERATION = "service-topology-operation";
 488                 ServiceData serviceData;
 489                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
 490                 Properties parms = new Properties();
 491
 492                 log.info("{} called.",SVC_OPERATION);
 493                 // create a new response object
 494                 ServiceTopologyOperationOutputBuilder responseBuilder = new ServiceTopologyOperationOutputBuilder();
 495
 496                 if(input == null ||
 497             input.getServiceInformation() == null ||
 498                 input.getServiceInformation().getServiceInstanceId() == null ||
 499                     input.getServiceInformation().getServiceInstanceId().length() == 0)
 500         {
 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);
 508                 }
 509
 510                 // Grab the service instance ID from the input buffer
 511                 String siid = input.getServiceInformation().getServiceInstanceId();
 512
 513                 if (input.getSdncRequestHeader() != null) {
 514                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
 515                 }
 516
 517                 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
 518                 getServiceData(siid,serviceDataBuilder);
 519
 520                 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
 521                 getServiceData(siid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
 522
 523                 // Set the serviceStatus based on input
 524                 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
 525                 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
 526
 527                 /*
 528                 // setup a service-data object builder
 529                 // ACTION service-topology-operation
 530                 // INPUT:
 531                 //  USES uses service-operation-information
 532                 // OUTPUT:
 533                 //  uses topology-response-common;
 534         //  uses service-response-information;
 535         */
 536
 537                 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
 538                 ServiceTopologyOperationInputBuilder inputBuilder = new ServiceTopologyOperationInputBuilder(input);
 539                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
 540
 541                 log.info("Adding OPERATIONAL data for {} [{}] operational-data: {}", SVC_OPERATION, siid, operDataBuilder.build());
 542                 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
 543
 544                 // Call SLI sync method
 545                 // Get SvcLogicService reference
 546
 547                 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
 548                 Properties respProps = null;
 549
 550                 String errorCode = "200";
 551                 String errorMessage = null;
 552                 String ackFinal = "Y";
 553         String serviceObjectPath = null;
 554
 555                 try
 556                 {
 557                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
 558                         {
 559
 560                                 try
 561                                 {
 562                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
 563                                 }
 564                                 catch (Exception e)
 565                                 {
 566                                         log.error("Caught exception executing service logic for {} ", SVC_OPERATION, e);
 567                                         errorMessage = e.getMessage();
 568                                         errorCode = "500";
 569                                 }
 570                         } else {
 571                                 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
 572                                 errorCode = "503";
 573                         }
 574                 }
 575                 catch (Exception e)
 576                 {
 577                         errorCode = "500";
 578                         errorMessage = e.getMessage();
 579                         log.error("Caught exception looking for service logic", e);
 580                 }
 581
 582
 583                 if (respProps != null)
 584                 {
 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");
 589                 }
 590
 591                 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
 592                 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
 593                 //serviceStatusBuilder.setRpcName(RpcName.ServiceTopologyOperation);
 594                 serviceStatusBuilder.setRpcName(SVC_OPERATION);
 595
 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);
 600
 601                         ServiceBuilder serviceBuilder = new ServiceBuilder();
 602                         serviceBuilder.setServiceInstanceId(siid);
 603                         serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
 604                         try {
 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);
 608                         }
 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);
 613                 }
 614
 615                 // Got success from SLI
 616                 try {
 617                         serviceData = serviceDataBuilder.build();
 618                         log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
 619
 620                         // service object
 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);
 626
 627                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
 628                         {
 629                                 // Only update operational tree on delete
 630                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete))
 631                                 {
 632                                         log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
 633                         deleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
 634                         deleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
 635                                 }
 636                         }
 637
 638             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
 639             serviceResponseInformationBuilder.setInstanceId(siid);
 640             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
 641             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
 642
 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);
 652                 }
 653
 654                 // Update succeeded
 655                 responseBuilder.setResponseCode(errorCode);
 656                 responseBuilder.setAckFinalIndicator(ackFinal);
 657                 if (errorMessage != null)
 658                 {
 659                         responseBuilder.setResponseMessage(errorMessage);
 660                 }
 661                 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
 662                 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
 663
 664                 RpcResult<ServiceTopologyOperationOutput> rpcResult =
 665             RpcResultBuilder.<ServiceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
 666                 return Futures.immediateFuture(rpcResult);
 667         }
 668
 669         @Override
 670         public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(
 671                         VnfTopologyOperationInput input) {
 672
 673                 final String SVC_OPERATION = "vnf-topology-operation";
 674                 ServiceData serviceData;
 675                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
 676                 Properties parms = new Properties();
 677
 678                 log.info("{} called.", SVC_OPERATION);
 679                 // create a new response object
 680                 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
 681
 682                 if(input == null ||
 683             input.getServiceInformation() == null ||
 684                 input.getServiceInformation().getServiceInstanceId() == null ||
 685                     input.getServiceInformation().getServiceInstanceId().length() == 0)
 686         {
 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();
 693                         // return error
 694                         return Futures.immediateFuture(rpcResult);
 695                 }
 696
 697                 // Grab the service instance ID from the input buffer
 698                 String siid = input.getServiceInformation().getServiceInstanceId();
 699
 700                 if (input.getSdncRequestHeader() != null) {
 701                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
 702                 }
 703
 704                 if(input.getVnfInformation() == null ||
 705                 input.getVnfInformation().getVnfId() == null ||
 706                     input.getVnfInformation().getVnfId().length() == 0)
 707         {
 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);
 715                 }
 716
 717         /* Mobility wont use vipr intf in 1707
 718
 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();
 724         }
 725         if (input.getVnfInformation().getVnfType() != null &&
 726                 input.getVnfInformation().getVnfType().length() != 0) {
 727                     preload_type = input.getVnfInformation().getVnfType();
 728         }
 729
 730                 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
 731         if (preload_name != null && preload_type != null) {
 732                     getPreloadData(preload_name, preload_type, preloadDataBuilder);
 733         }
 734         else {
 735             log.info("vnf-name and vnf-type not present in the request");
 736         }
 737         */
 738
 739                 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
 740                 getServiceData(siid,serviceDataBuilder);
 741
 742                 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
 743                 getServiceData(siid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
 744
 745                 // Set the serviceStatus based on input
 746                 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
 747                 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
 748
 749                 //
 750                 // setup a service-data object builder
 751                 // ACTION vnf-topology-operation
 752                 // INPUT:
 753                 //  USES sdnc-request-header;
 754                 //  USES request-information;
 755                 //  USES service-information;
 756                 //  USES vnf-request-information
 757                 // OUTPUT:
 758                 //  USES vnf-topology-response-body;
 759                 //  USES vnf-information
 760                 //  USES service-information
 761                 //
 762                 // container service-data
 763         //   uses vnf-configuration-information;
 764         //   uses oper-status;
 765
 766                 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
 767                 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
 768                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
 769
 770                 log.info("Adding OPERATIONAL data for {} [{}] operational-data: {}", SVC_OPERATION, siid, operDataBuilder.build());
 771                 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
 772
 773         /*
 774                 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " + preloadDataBuilder.build());
 775                 GenericResourceApiUtil.toProperties(parms, "preload-data", preloadDataBuilder);
 776         */
 777
 778                 // Call SLI sync method
 779                 // Get SvcLogicService reference
 780
 781                 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
 782                 Properties respProps = null;
 783
 784                 String errorCode = "200";
 785                 String errorMessage = null;
 786                 String ackFinal = "Y";
 787         String serviceObjectPath = null;
 788
 789                 try
 790                 {
 791                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
 792                         {
 793
 794                                 try
 795                                 {
 796                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
 797                                 }
 798                                 catch (Exception e)
 799                                 {
 800                                         log.error("Caught exception executing service logic for {} ", SVC_OPERATION, e);
 801                                         errorMessage = e.getMessage();
 802                                         errorCode = "500";
 803                                 }
 804                         } else {
 805                                 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
 806                                 errorCode = "503";
 807                         }
 808                 }
 809                 catch (Exception e)
 810                 {
 811                         errorCode = "500";
 812                         errorMessage = e.getMessage();
 813                         log.error("Caught exception looking for service logic", e);
 814                 }
 815
 816                 if (respProps != null)
 817                 {
 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");
 822                 }
 823
 824                 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
 825                 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
 826                 //serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
 827                 serviceStatusBuilder.setRpcName(SVC_OPERATION);
 828
 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);
 833
 834                         ServiceBuilder serviceBuilder = new ServiceBuilder();
 835                         serviceBuilder.setServiceInstanceId(siid);
 836                         serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
 837                         try {
 838                                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
 839                                 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
 840                                 {
 841                                         // Only update operational tree on activate or delete
 842                                         if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
 843                                                         input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
 844                                         {
 845                                                 log.info("Updating OPERATIONAL tree.");
 846                                                 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
 847                                         }
 848                                 }
 849                         } catch (Exception e) {
 850                                 log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
 851                         }
 852                         log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
 853                         RpcResult<VnfTopologyOperationOutput> rpcResult =
 854                             RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
 855                         // return error
 856                         return Futures.immediateFuture(rpcResult);
 857                 }
 858
 859                 // Got success from SLI
 860                 try {
 861                         serviceData = serviceDataBuilder.build();
 862                         log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
 863
 864                         // service object
 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);
 870
 871                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
 872                         {
 873                                 // Only update operational tree on Assign
 874                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
 875                                 {
 876                                         log.info("Updating OPERATIONAL tree.");
 877                                         saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
 878                                 }
 879                         }
 880
 881             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
 882             serviceResponseInformationBuilder.setInstanceId(siid);
 883             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
 884             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
 885
 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);
 895                 }
 896
 897                 // Update succeeded
 898                 responseBuilder.setResponseCode(errorCode);
 899                 responseBuilder.setAckFinalIndicator(ackFinal);
 900                 if (errorMessage != null)
 901                 {
 902                         responseBuilder.setResponseMessage(errorMessage);
 903                 }
 904                 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
 905                 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
 906
 907                 RpcResult<VnfTopologyOperationOutput> rpcResult =
 908                     RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
 909                 // return success
 910                 return Futures.immediateFuture(rpcResult);
 911         }
 912
 913     @Override
 914     public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
 915             VfModuleTopologyOperationInput input) {
 916
 917         final String SVC_OPERATION = "vf-module-topology-operation";
 918         ServiceData serviceData;
 919         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
 920         Properties parms = new Properties();
 921
 922         log.info("{} called.", SVC_OPERATION);
 923         // create a new response object
 924         VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
 925
 926         if(input == null ||
 927             input.getServiceInformation() == null ||
 928                 input.getServiceInformation().getServiceInstanceId() == null ||
 929                     input.getServiceInformation().getServiceInstanceId().length() == 0)
 930         {
 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();
 937             // return error
 938             return Futures.immediateFuture(rpcResult);
 939         }
 940
 941         if(input.getVnfInformation() == null ||
 942                 input.getVnfInformation().getVnfId() == null ||
 943                     input.getVnfInformation().getVnfId().length() == 0)
 944         {
 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);
 952         }
 953
 954         if(input.getVfModuleInformation() == null ||
 955                 input.getVfModuleInformation().getVfModuleId() == null ||
 956                     input.getVfModuleInformation().getVfModuleId().length() == 0)
 957         {
 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);
 965         }
 966
 967         // Grab the service instance ID from the input buffer
 968         String siid = input.getServiceInformation().getServiceInstanceId();
 969
 970         if (input.getSdncRequestHeader() != null) {
 971             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
 972         }
 973
 974         /*
 975         String preload_name  = null;
 976         String preload_type = null;
 977
 978         preload_name  = input.getVfModuleRequestInput().getVfModuleName();
 979
 980         if(input.getVfModuleInformation().getVfModuleType() != null &&
 981                     input.getVfModuleInformation().getVfModuleType().length() != 0) {
 982             preload_type = input.getVfModuleInformation().getVfModuleType();
 983         }
 984
 985         PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
 986         if (preload_name != null && preload_type != null) {
 987             getPreloadData(preload_name, preload_type, preloadDataBuilder);
 988         }
 989         else {
 990             log.debug("vf-module-name and vf-module-type not present in the request.");
 991         }
 992         */
 993
 994         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
 995         getServiceData(siid,serviceDataBuilder);
 996
 997         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
 998         getServiceData(siid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
 999
1000         // Set the serviceStatus based on input
1001         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1002         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1003
1004         //
1005         // setup a service-data object builder
1006         // ACTION vnf-topology-operation
1007         // INPUT:
1008         //  USES sdnc-request-header;
1009         //  USES request-information;
1010         //  USES service-information;
1011         //  USES vnf-request-information
1012         // OUTPUT:
1013         //  USES vnf-topology-response-body;
1014         //  USES vnf-information
1015         //  USES service-information
1016         //
1017         // container service-data
1018         //   uses vnf-configuration-information;
1019         //   uses oper-status;
1020
1021         log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1022         VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1023         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1024
1025         log.info("Adding OPERATIONAL data for {} [{}] operational-data: {}", SVC_OPERATION, siid, operDataBuilder.build());
1026         GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
1027
1028         /*
1029         log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " +preloadDataBuilder.build());
1030         GenericResourceApiUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1031         */
1032
1033         // Call SLI sync method
1034         // Get SvcLogicService reference
1035
1036         GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1037         Properties respProps = null;
1038
1039         String errorCode = "200";
1040         String errorMessage = null;
1041         String ackFinal = "Y";
1042         String serviceObjectPath = null;
1043
1044         try
1045         {
1046             if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1047             {
1048
1049                 try
1050                 {
1051                     respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1052                 }
1053                 catch (Exception e)
1054                 {
1055                     log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1056                     errorMessage = e.getMessage();
1057                     errorCode = "500";
1058                 }
1059             } else {
1060                 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1061                 errorCode = "503";
1062             }
1063         }
1064         catch (Exception e)
1065         {
1066             errorCode = "500";
1067             errorMessage = e.getMessage();
1068             log.error("Caught exception looking for service logic", e);
1069         }
1070
1071         if (respProps != null)
1072         {
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");
1077         }
1078
1079         setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
1080         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1081         serviceStatusBuilder.setRpcName(SVC_OPERATION);
1082
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);
1087
1088             ServiceBuilder serviceBuilder = new ServiceBuilder();
1089             serviceBuilder.setServiceInstanceId(siid);
1090             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1091             try {
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);
1095             }
1096             log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1097             RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1098                     RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1099             // return error
1100             return Futures.immediateFuture(rpcResult);
1101         }
1102
1103         // Got success from SLI
1104         try {
1105             serviceData = serviceDataBuilder.build();
1106             log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1107
1108             // service object
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);
1115
1116                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1117                         {
1118                                 // Only update operational tree on activate or delete
1119                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1120                                                 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1121                                 {
1122                                         log.info("Updating OPERATIONAL tree.");
1123                                         saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1124                                 }
1125                         }
1126
1127             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1128             serviceResponseInformationBuilder.setInstanceId(siid);
1129             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1130             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1131
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);
1141         }
1142
1143         // Update succeeded
1144         responseBuilder.setResponseCode(errorCode);
1145         responseBuilder.setAckFinalIndicator(ackFinal);
1146         if (errorMessage != null)
1147         {
1148             responseBuilder.setResponseMessage(errorMessage);
1149         }
1150         log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1151         log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1152
1153         RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1154             RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1155         // return success
1156         return Futures.immediateFuture(rpcResult);
1157     }
1158
1159         @Override
1160         public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1161                         NetworkTopologyOperationInput input) {
1162
1163                 final String SVC_OPERATION = "network-topology-operation";
1164                 ServiceData serviceData;
1165                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1166                 Properties parms = new Properties();
1167
1168                 log.info("{} called.", SVC_OPERATION );
1169                 // create a new response object
1170                 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1171
1172                 if(input == null ||
1173             input.getServiceInformation() == null ||
1174                 input.getServiceInformation().getServiceInstanceId() == null ||
1175                     input.getServiceInformation().getServiceInstanceId().length() == 0)
1176         {
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);
1184                 }
1185
1186         String siid = input.getServiceInformation().getServiceInstanceId();
1187
1188         // Get the service-instance service data from MD-SAL
1189         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1190         getServiceData(siid,serviceDataBuilder);
1191
1192                 if (input.getSdncRequestHeader() != null) {
1193                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1194                 }
1195
1196         ServiceData sd = serviceDataBuilder.build();
1197         if (sd == null || sd.getServiceLevelOperStatus() == null)
1198         {
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);
1206                 }
1207
1208
1209        /*
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();
1217         }
1218         if (input.getNetworkInformation() != null &&
1219                 input.getNetworkInformation().getNetworkType() != null &&
1220                     input.getNetworkInformation().getNetworkType().length() != 0) {
1221             preload_type = input.getNetworkInformation().getNetworkType();
1222         }
1223
1224                 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1225         if (preload_name != null && preload_type != null) {
1226                     getPreloadData(preload_name, preload_type, preloadDataBuilder);
1227         }
1228         else {
1229                         log.debug("network-name and network-type not present in request");
1230         }
1231         */
1232
1233                 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1234                 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1235                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1236
1237                 // Call SLI sync method
1238                 // Get SvcLogicService reference
1239
1240                 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1241                 Properties respProps = null;
1242
1243                 String errorCode = "200";
1244                 String errorMessage = null;
1245                 String ackFinal = "Y";
1246                 String networkId = "error";
1247         String serviceObjectPath = null;
1248         String networkObjectPath = null;
1249
1250                 try
1251                 {
1252                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1253                         {
1254
1255                                 try
1256                                 {
1257                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1258                                 }
1259                                 catch (Exception e)
1260                                 {
1261                                         log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1262                                         errorMessage = e.getMessage();
1263                                         errorCode = "500";
1264                                 }
1265                         } else {
1266                                 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1267                                 errorCode = "503";
1268                         }
1269                 }
1270                 catch (Exception e)
1271                 {
1272                         errorCode = "500";
1273                         errorMessage = e.getMessage();
1274                         log.error("Caught exception looking for service logic", e);
1275                 }
1276
1277
1278                 if (respProps != null)
1279                 {
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");
1286                 }
1287
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);
1292
1293                         log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1294
1295                         RpcResult<NetworkTopologyOperationOutput> rpcResult =
1296                 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1297                         return Futures.immediateFuture(rpcResult);
1298                 }
1299
1300                 // Got success from SLI
1301                 try {
1302
1303                         serviceData = serviceDataBuilder.build();
1304                         log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1305
1306                         // service object
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);
1312
1313                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1314                         {
1315                                 // Only update operational tree on Activate
1316                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1317                 {
1318                                         log.info("Updating OPERATIONAL tree.");
1319                                         saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1320                                 }
1321                         }
1322
1323                         NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1324                         networkResponseInformationBuilder.setInstanceId(networkId);
1325                         networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1326                         responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1327
1328                         ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1329                         serviceResponseInformationBuilder.setInstanceId(siid);
1330                         serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1331                         responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1332
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);
1342                 }
1343
1344                 // Update succeeded
1345                 responseBuilder.setResponseCode(errorCode);
1346                 responseBuilder.setAckFinalIndicator(ackFinal);
1347                 if (errorMessage != null)
1348                 {
1349                         responseBuilder.setResponseMessage(errorMessage);
1350                 }
1351                 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1352                 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1353
1354                 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1355             RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1356                 return Futures.immediateFuture(rpcResult);
1357         }
1358
1359         @Override
1360         public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1361                         ContrailRouteTopologyOperationInput input) {
1362
1363                 final String SVC_OPERATION = "contrail-route-topology-operation";
1364                 ServiceData serviceData;
1365                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1366                 Properties parms = new Properties();
1367
1368                 log.info("{} called.", SVC_OPERATION);
1369                 // create a new response object
1370                 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1371
1372                 if(input == null ||
1373             input.getServiceInformation() == null ||
1374                 input.getServiceInformation().getServiceInstanceId() == null ||
1375                     input.getServiceInformation().getServiceInstanceId().length() == 0)
1376         {
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);
1384                 }
1385
1386         String siid = input.getServiceInformation().getServiceInstanceId();
1387
1388         // Get the service-instance service data from MD-SAL
1389         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1390         getServiceData(siid,serviceDataBuilder);
1391
1392                 if (input.getSdncRequestHeader() != null) {
1393                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1394                 }
1395
1396         ServiceData sd = serviceDataBuilder.build();
1397         if (sd == null || sd.getServiceLevelOperStatus() == null)
1398         {
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);
1406                 }
1407
1408                 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+siid+"] input: " + input);
1409                 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1410                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1411
1412                 // Call SLI sync method
1413                 // Get SvcLogicService reference
1414
1415                 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1416                 Properties respProps = null;
1417
1418                 String errorCode = "200";
1419                 String errorMessage = null;
1420                 String ackFinal = "Y";
1421                 String allottedResourceId = "error";
1422         String serviceObjectPath = null;
1423         String contrailRouteObjectPath = null;
1424
1425                 try
1426                 {
1427                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1428                         {
1429
1430                                 try
1431                                 {
1432                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1433                                 }
1434                                 catch (Exception e)
1435                                 {
1436                                         log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1437                                         errorMessage = e.getMessage();
1438                                         errorCode = "500";
1439                                 }
1440                         } else {
1441                                 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1442                                 errorCode = "503";
1443                         }
1444                 }
1445                 catch (Exception e)
1446                 {
1447                         errorCode = "500";
1448                         errorMessage = e.getMessage();
1449                         log.error("Caught exception looking for service logic", e);
1450                 }
1451
1452
1453                 if (respProps != null)
1454                 {
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");
1461                 }
1462
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);
1467
1468                         log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1469
1470                         RpcResult<ContrailRouteTopologyOperationOutput> rpcResult =
1471                 RpcResultBuilder.<ContrailRouteTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1472                         return Futures.immediateFuture(rpcResult);
1473                 }
1474
1475                 // Got success from SLI
1476                 try {
1477
1478                         serviceData = serviceDataBuilder.build();
1479                         log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1480
1481                         // service object
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);
1487
1488                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1489                         {
1490                                 // Only update operational tree on activate or delete
1491                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1492                                                 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1493                                 {
1494                                         log.info("Updating OPERATIONAL tree.");
1495                                         saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1496                                 }
1497                         }
1498
1499                         ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1500                         contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1501                         contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1502                         responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1503
1504                         ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1505                         serviceResponseInformationBuilder.setInstanceId(siid);
1506                         serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1507                         responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1508
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);
1518                 }
1519
1520                 // Update succeeded
1521                 responseBuilder.setResponseCode(errorCode);
1522                 responseBuilder.setAckFinalIndicator(ackFinal);
1523                 if (errorMessage != null)
1524                 {
1525                         responseBuilder.setResponseMessage(errorMessage);
1526                 }
1527                 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1528                 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1529
1530                 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult =
1531             RpcResultBuilder.<ContrailRouteTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1532                 return Futures.immediateFuture(rpcResult);
1533         }
1534
1535         @Override
1536         public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1537                         SecurityZoneTopologyOperationInput input) {
1538
1539                 final String SVC_OPERATION = "security-zone-topology-operation";
1540                 ServiceData serviceData;
1541                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1542                 Properties parms = new Properties();
1543
1544                 log.info("{} called.", SVC_OPERATION);
1545                 // create a new response object
1546                 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1547
1548                 if(input == null ||
1549             input.getServiceInformation() == null ||
1550                 input.getServiceInformation().getServiceInstanceId() == null ||
1551                     input.getServiceInformation().getServiceInstanceId().length() == 0)
1552         {
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);
1560                 }
1561
1562         String siid = input.getServiceInformation().getServiceInstanceId();
1563
1564         // Get the service-instance service data from MD-SAL
1565         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1566         getServiceData(siid,serviceDataBuilder);
1567
1568                 if (input.getSdncRequestHeader() != null) {
1569                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1570                 }
1571
1572         ServiceData sd = serviceDataBuilder.build();
1573         if (sd == null || sd.getServiceLevelOperStatus() == null)
1574         {
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);
1582                 }
1583
1584                 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1585                 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1586                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1587
1588                 // Call SLI sync method
1589                 // Get SvcLogicService reference
1590
1591                 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1592                 Properties respProps = null;
1593
1594                 String errorCode = "200";
1595                 String errorMessage = null;
1596                 String ackFinal = "Y";
1597                 String allottedResourceId = "error";
1598         String serviceObjectPath = null;
1599         String securityZoneObjectPath = null;
1600
1601                 try
1602                 {
1603                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1604                         {
1605
1606                                 try
1607                                 {
1608                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1609                                 }
1610                                 catch (Exception e)
1611                                 {
1612                                         log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1613                                         errorMessage = e.getMessage();
1614                                         errorCode = "500";
1615                                 }
1616                         } else {
1617                                 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1618                                 errorCode = "503";
1619                         }
1620                 }
1621                 catch (Exception e)
1622                 {
1623                         errorCode = "500";
1624                         errorMessage = e.getMessage();
1625                         log.error("Caught exception looking for service logic", e);
1626                 }
1627
1628
1629                 if (respProps != null)
1630                 {
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");
1637                 }
1638
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);
1643
1644                         log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1645
1646                         RpcResult<SecurityZoneTopologyOperationOutput> rpcResult =
1647                 RpcResultBuilder.<SecurityZoneTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1648                         return Futures.immediateFuture(rpcResult);
1649                 }
1650
1651                 // Got success from SLI
1652                 try {
1653
1654                         serviceData = serviceDataBuilder.build();
1655                         log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1656
1657                         // service object
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);
1663
1664                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1665                         {
1666                                 // Only update operational tree on activate or delete
1667                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1668                                                 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1669                                 {
1670                                         log.info("Updating OPERATIONAL tree.");
1671                                         saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1672                                 }
1673                         }
1674
1675                         SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1676                         securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1677                         securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1678                         responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1679
1680                         ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1681                         serviceResponseInformationBuilder.setInstanceId(siid);
1682                         serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1683                         responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1684
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);
1694                 }
1695
1696                 // Update succeeded
1697                 responseBuilder.setResponseCode(errorCode);
1698                 responseBuilder.setAckFinalIndicator(ackFinal);
1699                 if (errorMessage != null)
1700                 {
1701                         responseBuilder.setResponseMessage(errorMessage);
1702                 }
1703                 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1704                 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1705
1706                 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult =
1707             RpcResultBuilder.<SecurityZoneTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1708                 return Futures.immediateFuture(rpcResult);
1709         }
1710
1711         @Override
1712         public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1713                         TunnelxconnTopologyOperationInput input) {
1714
1715                 final String SVC_OPERATION = "tunnelxconn-topology-operation";
1716                 ServiceData serviceData;
1717                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1718                 Properties parms = new Properties();
1719
1720                 log.info("{} called.", SVC_OPERATION);
1721                 // create a new response object
1722                 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1723
1724                 if(input == null ||
1725             input.getServiceInformation() == null ||
1726                 input.getServiceInformation().getServiceInstanceId() == null ||
1727                     input.getServiceInformation().getServiceInstanceId().length() == 0)
1728         {
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);
1736                 }
1737
1738         String siid = input.getServiceInformation().getServiceInstanceId();
1739
1740         // Get the service-instance service data from MD-SAL
1741         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1742         getServiceData(siid,serviceDataBuilder);
1743
1744                 if (input.getSdncRequestHeader() != null) {
1745                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1746                 }
1747
1748         ServiceData sd = serviceDataBuilder.build();
1749         if (sd == null || sd.getServiceLevelOperStatus() == null)
1750         {
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);
1758                 }
1759
1760                 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1761                 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1762                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1763
1764                 // Call SLI sync method
1765                 // Get SvcLogicService reference
1766
1767                 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1768                 Properties respProps = null;
1769
1770                 String errorCode = "200";
1771                 String errorMessage = null;
1772                 String ackFinal = "Y";
1773                 String allottedResourceId = "error";
1774         String serviceObjectPath = null;
1775         String tunnelxconnObjectPath = null;
1776
1777                 try
1778                 {
1779                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1780                         {
1781
1782                                 try
1783                                 {
1784                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1785                                 }
1786                                 catch (Exception e)
1787                                 {
1788                                         log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1789                                         errorMessage = e.getMessage();
1790                                         errorCode = "500";
1791                                 }
1792                         } else {
1793                                 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1794                                 errorCode = "503";
1795                         }
1796                 }
1797                 catch (Exception e)
1798                 {
1799                         errorCode = "500";
1800                         errorMessage = e.getMessage();
1801                         log.error("Caught exception looking for service logic", e);
1802                 }
1803
1804
1805                 if (respProps != null)
1806                 {
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");
1813                 }
1814
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);
1819
1820                         log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1821
1822                         RpcResult<TunnelxconnTopologyOperationOutput> rpcResult =
1823                 RpcResultBuilder.<TunnelxconnTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1824                         return Futures.immediateFuture(rpcResult);
1825                 }
1826
1827                 // Got success from SLI
1828                 try {
1829
1830                         serviceData = serviceDataBuilder.build();
1831                         log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1832
1833                         // service object
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);
1839
1840                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1841                         {
1842                                 // Only update operational tree on activate or delete
1843                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1844                                                 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1845                                 {
1846                                         log.info("Updating OPERATIONAL tree.");
1847                                         saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1848                                 }
1849                         }
1850
1851                         TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1852                         tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1853                         tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1854                         responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1855
1856                         ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1857                         serviceResponseInformationBuilder.setInstanceId(siid);
1858                         serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1859                         responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1860
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);
1870                 }
1871
1872                 // Update succeeded
1873                 responseBuilder.setResponseCode(errorCode);
1874                 responseBuilder.setAckFinalIndicator(ackFinal);
1875                 if (errorMessage != null)
1876                 {
1877                         responseBuilder.setResponseMessage(errorMessage);
1878                 }
1879                 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1880                 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1881
1882                 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult =
1883             RpcResultBuilder.<TunnelxconnTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1884                 return Futures.immediateFuture(rpcResult);
1885         }
1886
1887         @Override
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();
1893
1894                 log.info("{} called.", SVC_OPERATION);
1895                 // create a new response object
1896                 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
1897
1898                 if(input == null ||
1899             input.getServiceInformation() == null ||
1900                 input.getServiceInformation().getServiceInstanceId() == null ||
1901                     input.getServiceInformation().getServiceInstanceId().length() == 0)
1902         {
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);
1910                 }
1911
1912         String siid = input.getServiceInformation().getServiceInstanceId();
1913
1914         // Get the service-instance service data from MD-SAL
1915         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1916         getServiceData(siid,serviceDataBuilder);
1917
1918                 if (input.getSdncRequestHeader() != null) {
1919                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1920                 }
1921
1922         ServiceData sd = serviceDataBuilder.build();
1923         if (sd == null || sd.getServiceLevelOperStatus() == null)
1924         {
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);
1932                 }
1933
1934                 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1935                 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
1936                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1937
1938                 // Call SLI sync method
1939                 // Get SvcLogicService reference
1940
1941                 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1942                 Properties respProps = null;
1943
1944                 String errorCode = "200";
1945                 String errorMessage = null;
1946                 String ackFinal = "Y";
1947                 String allottedResourceId = "error";
1948         String serviceObjectPath = null;
1949         String brgObjectPath = null;
1950
1951                 try
1952                 {
1953                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1954                         {
1955
1956                                 try
1957                                 {
1958                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1959                                 }
1960                                 catch (Exception e)
1961                                 {
1962                                         log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1963                                         errorMessage = e.getMessage();
1964                                         errorCode = "500";
1965                                 }
1966                         } else {
1967                                 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1968                                 errorCode = "503";
1969                         }
1970                 }
1971                 catch (Exception e)
1972                 {
1973                         errorCode = "500";
1974                         errorMessage = e.getMessage();
1975                         log.error("Caught exception looking for service logic", e);
1976                 }
1977
1978
1979                 if (respProps != null)
1980                 {
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");
1987                 }
1988
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);
1993
1994                         log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1995
1996                         RpcResult<BrgTopologyOperationOutput> rpcResult =
1997                 RpcResultBuilder.<BrgTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1998                         return Futures.immediateFuture(rpcResult);
1999                 }
2000
2001                 // Got success from SLI
2002                 try {
2003
2004                         serviceData = serviceDataBuilder.build();
2005                         log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
2006
2007                         // service object
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);
2013
2014                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
2015                         {
2016                                 // Only update operational tree on activate or delete
2017                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
2018                                                 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
2019                                 {
2020                                         log.info("Updating OPERATIONAL tree.");
2021                                         saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2022                                 }
2023                         }
2024
2025                         BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
2026                         brgResponseInformationBuilder.setInstanceId(allottedResourceId);
2027                         brgResponseInformationBuilder.setObjectPath(brgObjectPath);
2028                         responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
2029
2030                         ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2031                         serviceResponseInformationBuilder.setInstanceId(siid);
2032                         serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2033                         responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2034
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);
2044                 }
2045
2046                 // Update succeeded
2047                 responseBuilder.setResponseCode(errorCode);
2048                 responseBuilder.setAckFinalIndicator(ackFinal);
2049                 if (errorMessage != null)
2050                 {
2051                         responseBuilder.setResponseMessage(errorMessage);
2052                 }
2053                 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
2054                 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
2055
2056                 RpcResult<BrgTopologyOperationOutput> rpcResult =
2057             RpcResultBuilder.<BrgTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2058                 return Futures.immediateFuture(rpcResult);
2059         }
2060
2061     @Override
2062     public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
2063             PreloadVnfTopologyOperationInput input) {
2064
2065         final String SVC_OPERATION = "preload-vnf-topology-operation";
2066         PreloadData preloadData;
2067         Properties parms = new Properties();
2068
2069         log.info("{} called.", SVC_OPERATION);
2070         // create a new response object
2071         PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
2072
2073         // Result from savePreloadData
2074         final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2075
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);
2085         }
2086
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();
2090
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);
2100         }
2101
2102         if (input.getSdncRequestHeader() != null) {
2103             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2104         }
2105
2106         PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2107         getPreloadData(preload_name, preload_type, preloadDataBuilder);
2108
2109         PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2110         getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
2111
2112         // setup a preload-data object builder
2113         // ACTION preload-vnf-topology-operation
2114         // INPUT:
2115         //  USES sdnc-request-header;
2116         //  USES request-information;
2117         //  uses vnf-topology-information;
2118         // OUTPUT:
2119         //  USES vnf-topology-response-body;
2120         //
2121         // container preload-data
2122         //   uses vnf-topology-information;
2123         //   uses network-topology-information;
2124         //   uses oper-status;
2125
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);
2132
2133         // Call SLI sync method
2134         // Get SvcLogicService reference
2135
2136         GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
2137         Properties respProps = null;
2138
2139         String errorCode = "200";
2140         String errorMessage = null;
2141         String ackFinal = "Y";
2142
2143
2144         try
2145         {
2146             if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
2147             {
2148
2149                 try
2150                 {
2151                     respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2152                 }
2153                 catch (Exception e)
2154                 {
2155                     log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
2156                     errorMessage = e.getMessage();
2157                     errorCode = "500";
2158                 }
2159             } else {
2160                 errorMessage = "No service logic active for "+ appName + ": '" + SVC_OPERATION + "'";
2161                 errorCode = "503";
2162             }
2163         }
2164         catch (Exception e)
2165         {
2166             errorCode = "500";
2167             errorMessage = e.getMessage();
2168             log.error("Caught exception looking for service logic", e);
2169         }
2170
2171
2172         if (respProps != null)
2173         {
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");
2178         }
2179
2180         if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2181
2182             responseBuilder.setResponseCode(errorCode);
2183             responseBuilder.setResponseMessage(errorMessage);
2184             responseBuilder.setAckFinalIndicator(ackFinal);
2185
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);
2192             try {
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);
2197             }
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);
2202         }
2203
2204         // Got success from SLI
2205         try {
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);
2214
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);
2230         }
2231
2232         // Update succeeded
2233         responseBuilder.setResponseCode(errorCode);
2234         responseBuilder.setAckFinalIndicator(ackFinal);
2235         if (errorMessage != null)
2236         {
2237             responseBuilder.setResponseMessage(errorMessage);
2238         }
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());
2241
2242         RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2243                 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2244         return Futures.immediateFuture(rpcResult);
2245     }
2246
2247
2248     @Override
2249     public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2250             PreloadNetworkTopologyOperationInput input) {
2251
2252         final String SVC_OPERATION = "preload-network-topology-operation";
2253         PreloadData preloadData;
2254         Properties parms = new Properties();
2255
2256         log.info("{} called.", SVC_OPERATION);
2257         // create a new response object
2258         PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2259
2260         // Result from savePreloadData
2261         final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2262
2263         if(input == null || input.getNetworkTopologyInformation() == null ||
2264             input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null) {
2265
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);
2273         }
2274
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();
2278
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);
2288         }
2289
2290         if (input.getSdncRequestHeader() != null) {
2291             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2292         }
2293
2294         PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2295         getPreloadData(preload_name, preload_type, preloadDataBuilder);
2296
2297         PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2298         getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
2299
2300         //
2301         // setup a preload-data object builder
2302         // ACTION preload-network-topology-operation
2303         // INPUT:
2304         //  USES sdnc-request-header;
2305         //  USES request-information;
2306         //  uses network-topology-information;
2307         // OUTPUT:
2308         //  USES vnf-topology-response-body;
2309         //
2310         // container preload-data
2311         //   uses vnf-topology-information;
2312         //   uses network-topology-information;
2313         //   uses oper-status;
2314
2315
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);
2322
2323         // Call SLI sync method
2324         // Get SvcLogicService reference
2325
2326         GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
2327         Properties respProps = null;
2328
2329         String errorCode = "200";
2330         String errorMessage = null;
2331         String ackFinal = "Y";
2332
2333
2334         try
2335         {
2336             if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
2337             {
2338
2339                 try
2340                 {
2341                     respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2342                 }
2343                 catch (Exception e)
2344                 {
2345                     log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
2346                     errorMessage = e.getMessage();
2347                     errorCode = "500";
2348                 }
2349             } else {
2350                 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
2351                 errorCode = "503";
2352             }
2353         }
2354         catch (Exception e)
2355         {
2356             errorCode = "500";
2357             errorMessage = e.getMessage();
2358             log.error("Caught exception looking for service logic", e);
2359         }
2360
2361
2362         if (respProps != null)
2363         {
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");
2368         }
2369
2370         if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2371
2372             responseBuilder.setResponseCode(errorCode);
2373             responseBuilder.setResponseMessage(errorMessage);
2374             responseBuilder.setAckFinalIndicator(ackFinal);
2375
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);
2382             try {
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);
2387
2388             }
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);
2393         }
2394
2395         // Got success from SLI
2396         try {
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);
2405
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);
2420         }
2421
2422         // Update succeeded
2423         responseBuilder.setResponseCode(errorCode);
2424         responseBuilder.setAckFinalIndicator(ackFinal);
2425         if (errorMessage != null)
2426         {
2427             responseBuilder.setResponseMessage(errorMessage);
2428         }
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());
2432
2433         RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2434                 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2435         return Futures.immediateFuture(rpcResult);
2436     }
2437
2438
2439 }