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.ContrailRouteTopologyOperationInput;
  23 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInputBuilder;
  24 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutput;
  25 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutputBuilder;
  26 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GENERICRESOURCEAPIService;
  27 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInput;
  28 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInputBuilder;
  29 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutput;
  30 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutputBuilder;
  31 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInput;
  32 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInputBuilder;
  33 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutput;
  34 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutputBuilder;
  35 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationInput;
  36 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationInputBuilder;
  37 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationOutput;
  38 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationOutputBuilder;
  39 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfs;
  40 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfsBuilder;
  41 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInput;
  42 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInputBuilder;
  43 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutput;
  44 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutputBuilder;
  45 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInput;
  46 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInputBuilder;
  47 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutput;
  48 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutputBuilder;
  49 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.Services;
  50 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServicesBuilder;
  51 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInput;
  52 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInputBuilder;
  53 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutput;
  54 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutputBuilder;
  55 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInput;
  56 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInputBuilder;
  57 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutput;
  58 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutputBuilder;
  59 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.contrail.route.response.information.ContrailRouteResponseInformationBuilder;
  60 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.network.response.information.NetworkResponseInformationBuilder;
  61 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadData;
  62 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadDataBuilder;
  63 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadList;
  64 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadListBuilder;
  65 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadListKey;
  66 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.request.information.RequestInformation;
  67 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader;
  68 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader.SvcAction;
  69 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.security.zone.response.information.SecurityZoneResponseInformationBuilder;
  70 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceData;
  71 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceDataBuilder;
  72 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.Service;
  73 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceBuilder;
  74 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceKey;
  75 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.response.information.ServiceResponseInformationBuilder;
  76 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RequestStatus;
  77 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RpcAction;
  78 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatusBuilder;
  79 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  80 import org.opendaylight.yangtools.yang.common.RpcResult;
  81 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  82 import org.slf4j.Logger;
  83 import org.slf4j.LoggerFactory;
  84
  85 import com.google.common.base.Optional;
  86 import com.google.common.util.concurrent.CheckedFuture;
  87 import com.google.common.util.concurrent.Futures;
  88 import com.google.common.util.concurrent.SettableFuture;
  89
  90
  91 /**
  92  * Defines a base implementation for your provider. This class extends from a helper class
  93  * which provides storage for the most commonly used components of the MD-SAL. Additionally the
  94  * base class provides some basic logging and initialization / clean up methods.
  95  *
  96  * To use this, copy and paste (overwrite) the following method into the TestApplicationProviderModule
  97  * class which is auto generated under src/main/java in this project
  98  * (created only once during first compilation):
  99  *
 100  * <pre>
 101
 102     @Override
 103     public java.lang.AutoCloseable createInstance() {
 104
 105          //final GENERIC-RESOURCE-APIProvider provider = new GENERIC-RESOURCE-APIProvider();
 106          final GenericResourceApiProvider provider = new GenericResourceApiProvider();
 107          provider.setDataBroker( getDataBrokerDependency() );
 108          provider.setNotificationService( getNotificationServiceDependency() );
 109          provider.setRpcRegistry( getRpcRegistryDependency() );
 110          provider.initialize();
 111          return new AutoCloseable() {
 112
 113             @Override
 114             public void close() throws Exception {
 115                 //TODO: CLOSE ANY REGISTRATION OBJECTS CREATED USING ABOVE BROKER/NOTIFICATION
 116                 //SERVIE/RPC REGISTRY
 117                 provider.close();
 118             }
 119         };
 120     }
 121
 122
 123     </pre>
 124  */
 125
 126 public class GenericResourceApiProvider implements AutoCloseable, GENERICRESOURCEAPIService{
 127
 128     private final Logger log = LoggerFactory.getLogger( GenericResourceApiProvider.class );
 129     private final String appName = "generic-resource-api";
 130
 131     private final ExecutorService executor;
 132
 133     protected DataBroker dataBroker;
 134     protected NotificationPublishService notificationService;
 135     protected RpcProviderRegistry rpcRegistry;
 136     protected BindingAwareBroker.RpcRegistration<GENERICRESOURCEAPIService> rpcRegistration;
 137
 138     public GenericResourceApiProvider(DataBroker dataBroker2,
 139                                       NotificationPublishService notificationPublishService,
 140             RpcProviderRegistry rpcProviderRegistry) {
 141         this.log.info( "Creating provider for " + appName );
 142         executor = Executors.newFixedThreadPool(1);
 143         dataBroker = dataBroker2;
 144         notificationService = notificationPublishService;
 145         rpcRegistry = rpcProviderRegistry;
 146         initialize();
 147
 148     }
 149
 150     public void initialize(){
 151         log.info( "Initializing provider for " + appName );
 152         // Create the top level containers
 153         createContainers();
 154         try {
 155             GenericResourceApiUtil.loadProperties();
 156         } catch (Exception e) {
 157             log.error("Caught Exception while trying to load properties file");
 158         }
 159         rpcRegistration = rpcRegistry.addRpcImplementation(GENERICRESOURCEAPIService.class, this);
 160
 161         log.info( "Initialization complete for " + appName );
 162     }
 163
 164
 165     protected void initializeChild() {
 166         //Override if you have custom initialization intelligence
 167     }
 168
 169
 170     @Override
 171     public void close() throws Exception {
 172         log.info( "Closing provider for " + appName );
 173         executor.shutdown();
 174         rpcRegistration.close();
 175         log.info( "Successfully closed provider for " + appName );
 176     }
 177
 178     private static class Iso8601Util
 179     {
 180         private static TimeZone tz = TimeZone.getTimeZone("UTC");
 181         private static DateFormat df = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
 182
 183         static { df.setTimeZone(tz); }
 184
 185         private static String now() {
 186             return df.format(new Date());
 187         }
 188     }
 189
 190
 191     public void setDataBroker(DataBroker dataBroker) {
 192         this.dataBroker = dataBroker;
 193         if( log.isDebugEnabled() ){
 194             log.debug( "DataBroker set to " + (dataBroker==null?"null":"non-null") + "." );
 195         }
 196     }
 197
 198     public void setNotificationService(
 199             NotificationPublishService notificationService) {
 200         this.notificationService = notificationService;
 201         if( log.isDebugEnabled() ){
 202             log.debug( "Notification Service set to " + (notificationService==null?"null":"non-null") + "." );
 203         }
 204     }
 205
 206     public void setRpcRegistry(RpcProviderRegistry rpcRegistry) {
 207         this.rpcRegistry = rpcRegistry;
 208         if( log.isDebugEnabled() ){
 209             log.debug( "RpcRegistry set to " + (rpcRegistry==null?"null":"non-null") + "." );
 210         }
 211     }
 212
 213     private void createContainers() {
 214
 215         final WriteTransaction t = dataBroker.newReadWriteTransaction();
 216
 217         // Create the service-instance container
 218         t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Services.class),
 219                 new ServicesBuilder().build());
 220         t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Services.class),
 221                 new ServicesBuilder().build());
 222
 223         // Create the PreloadVnfs container
 224         t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
 225                 new PreloadVnfsBuilder().build());
 226         t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
 227                 new PreloadVnfsBuilder().build());
 228
 229         try {
 230             CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
 231             checkedFuture.get();
 232             log.info("Create Containers succeeded!: ");
 233
 234         } catch (InterruptedException | ExecutionException e) {
 235             log.error("Create Containers Failed: " + e);
 236             e.printStackTrace();
 237         }
 238     }
 239
 240     private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage, String ackFinal)
 241     {
 242         serviceStatusBuilder.setResponseCode(errorCode);
 243         serviceStatusBuilder.setResponseMessage(errorMessage);
 244         serviceStatusBuilder.setFinalIndicator(ackFinal);
 245         serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
 246     }
 247
 248     private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder,  RequestInformation requestInformation)
 249     {
 250         if (requestInformation != null && requestInformation.getRequestAction() != null) {
 251             serviceStatusBuilder.setAction(requestInformation.getRequestAction().toString());
 252         }
 253
 254         /*
 255         if (requestInformation != null && requestInformation.getRequestSubAction() != null) {
 256             switch (requestInformation.getRequestSubAction())
 257             {
 258                 case SUPP:
 259                     serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.SUPP);
 260                     break;
 261                 case CANCEL:
 262                     serviceStatusBuilder.setVnfsdnSubaction(VnfsdnSubaction.CANCEL);
 263                     break;
 264                 default:
 265                     log.error("Unknown RequestSubAction: " + requestInformation.getRequestSubAction() );
 266                     break;
 267             };
 268         }
 269         */
 270     }
 271
 272     private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder,  SdncRequestHeader requestHeader)
 273     {
 274         if (requestHeader != null && requestHeader.getSvcAction() != null) {
 275             switch (requestHeader.getSvcAction())
 276             {
 277                 case Assign:
 278                     serviceStatusBuilder.setRpcAction(RpcAction.Assign);
 279                     break;
 280                 case Unassign:
 281                     serviceStatusBuilder.setRpcAction(RpcAction.Unassign);
 282                     break;
 283                 case Activate:
 284                     serviceStatusBuilder.setRpcAction(RpcAction.Activate);
 285                     break;
 286                 case Deactivate:
 287                     serviceStatusBuilder.setRpcAction(RpcAction.Deactivate);
 288                     break;
 289                 case Delete:
 290                     serviceStatusBuilder.setRpcAction(RpcAction.Delete);
 291                     break;
 292                 default:
 293                     log.error("Unknown SvcAction: " + requestHeader.getSvcAction() );
 294                     break;
 295             };
 296         }
 297     }
 298
 299     private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder)
 300     {
 301         // default to config
 302         getServiceData(siid,serviceDataBuilder,LogicalDatastoreType.CONFIGURATION);
 303     }
 304
 305
 306     private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type)
 307     {
 308         // See if any data exists yet for this siid, if so grab it.
 309         InstanceIdentifier serviceInstanceIdentifier =
 310                 InstanceIdentifier.<Services>builder(Services.class)
 311                 .child(Service.class, new ServiceKey(siid)).build();
 312         ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
 313         Optional<Service> data = null;
 314         try {
 315             data = (Optional<Service>) readTx.read(type, serviceInstanceIdentifier).get();
 316         } catch (InterruptedException | ExecutionException e) {
 317             log.error("Caught Exception reading MD-SAL ("+type+") for ["+siid+"] " ,e);
 318         }
 319
 320         if (data != null && data.isPresent()) {
 321             ServiceData serviceData = data.get().getServiceData();
 322             if (serviceData != null) {
 323                 log.info("Read MD-SAL ("+type+") data for ["+siid+"] ServiceData: " + serviceData);
 324                 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
 325                 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
 326                 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
 327                 serviceDataBuilder.setServiceRequestInput(serviceData.getServiceRequestInput());
 328                 serviceDataBuilder.setServiceTopology(serviceData.getServiceTopology());
 329                 serviceDataBuilder.setServiceLevelOperStatus(serviceData.getServiceLevelOperStatus());
 330                 serviceDataBuilder.setNetworks(serviceData.getNetworks());
 331                 serviceDataBuilder.setVnfs(serviceData.getVnfs());
 332                 serviceDataBuilder.setProvidedAllottedResources(serviceData.getProvidedAllottedResources());
 333                 serviceDataBuilder.setConsumedAllottedResources(serviceData.getConsumedAllottedResources());
 334                 // service-instance-id needs to be set
 335             } else {
 336                 log.info("No service-data found in MD-SAL ("+type+") for ["+siid+"] ");
 337             }
 338         } else {
 339             log.info("No data found in MD-SAL ("+type+") for ["+siid+"] ");
 340         }
 341     }
 342
 343     private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder)
 344     {
 345         // default to config
 346         getPreloadData(vnf_name, vnf_type ,preloadDataBuilder,LogicalDatastoreType.CONFIGURATION);
 347     }
 348
 349     private void getPreloadData(String preload_name, String preload_type, PreloadDataBuilder preloadDataBuilder, LogicalDatastoreType type)
 350     {
 351         // See if any data exists yet for this name/type, if so grab it.
 352         InstanceIdentifier preloadInstanceIdentifier =
 353                 InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
 354                 .child(VnfPreloadList.class, new VnfPreloadListKey(preload_name, preload_type)).build();
 355         ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
 356         Optional<VnfPreloadList> data = null;
 357         try {
 358             data = (Optional<VnfPreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
 359         } catch (InterruptedException | ExecutionException e) {
 360             log.error("Caught Exception reading MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] " ,e);
 361         }
 362
 363         if (data != null && data.isPresent()) {
 364             PreloadData preloadData = data.get().getPreloadData();
 365             if (preloadData != null) {
 366                 log.info("Read MD-SAL ("+type+") data for ["+preload_name+","+preload_type+"] PreloadData: " + preloadData);
 367                 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
 368                 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
 369                 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
 370             } else {
 371                 log.info("No preload-data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
 372             }
 373         } else {
 374             log.info("No data found in MD-SAL ("+type+") for ["+preload_name+","+preload_type+"] ");
 375         }
 376     }
 377
 378     private void SaveService (final Service entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException {
 379         // Each entry will be identifiable by a unique key, we have to create that identifier
 380         InstanceIdentifier.InstanceIdentifierBuilder<Service> serviceBuilder =
 381                 InstanceIdentifier.<Services>builder(Services.class)
 382                 .child(Service.class, entry.getKey());
 383         InstanceIdentifier<Service> path = serviceBuilder.build();
 384
 385         int tries = 2;
 386         while(true) {
 387             try {
 388                 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 389                 if (merge) {
 390                     tx.merge(storeType, path, entry);
 391                 } else {
 392                     tx.put(storeType, path, entry);
 393                 }
 394                 tx.submit().checkedGet();
 395                 log.debug("Update DataStore succeeded");
 396                 break;
 397             } catch (final TransactionCommitFailedException e) {
 398                 if(e instanceof OptimisticLockFailedException) {
 399                     if(--tries <= 0) {
 400                         log.debug("Got OptimisticLockFailedException on last try - failing ");
 401                         throw new IllegalStateException(e);
 402                     }
 403                     log.debug("Got OptimisticLockFailedException - trying again ");
 404                 } else {
 405                     log.debug("Update DataStore failed");
 406                     throw new IllegalStateException(e);
 407                 }
 408             }
 409         }
 410     }
 411
 412     private void DeleteService(final Service entry, LogicalDatastoreType storeType) throws IllegalStateException {
 413         // Each entry will be identifiable by a unique key, we have to create
 414         // that identifier
 415         InstanceIdentifier.InstanceIdentifierBuilder<Service> serviceListIdBuilder = InstanceIdentifier.<Services> builder(Services.class).child(Service.class, entry.getKey());
 416         InstanceIdentifier<Service> path = serviceListIdBuilder.build();
 417
 418         int tries = 2;
 419         while (true) {
 420             try {
 421                 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 422                 tx.delete(storeType, path);
 423                 tx.submit().checkedGet();
 424                 log.debug("DataStore delete succeeded");
 425                 break;
 426             } catch (final TransactionCommitFailedException e) {
 427                 if (e instanceof OptimisticLockFailedException) {
 428                     if (--tries <= 0) {
 429                         log.debug("Got OptimisticLockFailedException on last try - failing ");
 430                         throw new IllegalStateException(e);
 431                     }
 432                     log.debug("Got OptimisticLockFailedException - trying again ");
 433                 } else {
 434                     log.debug("Update DataStore failed");
 435                     throw new IllegalStateException(e);
 436                 }
 437             }
 438         }
 439     }
 440
 441     private void SavePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException{
 442
 443         // Each entry will be identifiable by a unique key, we have to create that identifier
 444         InstanceIdentifier.InstanceIdentifierBuilder<VnfPreloadList> vnfPreloadListBuilder =
 445                 InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
 446                 .child(VnfPreloadList.class, entry.getKey());
 447         InstanceIdentifier<VnfPreloadList> path = vnfPreloadListBuilder.build();
 448         int tries = 2;
 449         while(true) {
 450             try {
 451                 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 452                 if (merge) {
 453                     tx.merge(storeType, path, entry);
 454                 } else {
 455                     tx.put(storeType, path, entry);
 456                 }
 457                 tx.submit().checkedGet();
 458                 log.debug("Update DataStore succeeded");
 459                 break;
 460             } catch (final TransactionCommitFailedException e) {
 461                 if(e instanceof OptimisticLockFailedException) {
 462                     if(--tries <= 0) {
 463                         log.debug("Got OptimisticLockFailedException on last try - failing ");
 464                         throw new IllegalStateException(e);
 465                     }
 466                     log.debug("Got OptimisticLockFailedException - trying again ");
 467                 } else {
 468                     log.debug("Update DataStore failed");
 469                     throw new IllegalStateException(e);
 470                 }
 471             }
 472         }
 473     }
 474
 475         @Override
 476         public Future<RpcResult<ServiceTopologyOperationOutput>> serviceTopologyOperation(
 477                         ServiceTopologyOperationInput input) {
 478
 479                 final String SVC_OPERATION = "service-topology-operation";
 480                 ServiceData serviceData;
 481                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
 482                 Properties parms = new Properties();
 483
 484                 log.info( SVC_OPERATION +" called." );
 485                 // create a new response object
 486                 ServiceTopologyOperationOutputBuilder responseBuilder = new ServiceTopologyOperationOutputBuilder();
 487
 488                 if(input == null ||
 489             input.getServiceInformation() == null ||
 490                 input.getServiceInformation().getServiceInstanceId() == null ||
 491                     input.getServiceInformation().getServiceInstanceId().length() == 0)
 492         {
 493                         log.debug("exiting " +SVC_OPERATION+ " because of null or empty service-instance-id");
 494                         responseBuilder.setResponseCode("404");
 495                         responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
 496                         responseBuilder.setAckFinalIndicator("Y");
 497                         RpcResult<ServiceTopologyOperationOutput> rpcResult =
 498                 RpcResultBuilder.<ServiceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
 499                         return Futures.immediateFuture(rpcResult);
 500                 }
 501
 502                 // Grab the service instance ID from the input buffer
 503                 String siid = input.getServiceInformation().getServiceInstanceId();
 504
 505                 if (input.getSdncRequestHeader() != null) {
 506                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
 507                 }
 508
 509                 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
 510                 getServiceData(siid,serviceDataBuilder);
 511
 512                 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
 513                 getServiceData(siid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
 514
 515                 // Set the serviceStatus based on input
 516                 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
 517                 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
 518
 519                 /*
 520                 // setup a service-data object builder
 521                 // ACTION service-topology-operation
 522                 // INPUT:
 523                 //  USES uses service-operation-information
 524                 // OUTPUT:
 525                 //  uses topology-response-common;
 526         //  uses service-response-information;
 527         */
 528
 529                 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+siid+"] input: " + input);
 530                 ServiceTopologyOperationInputBuilder inputBuilder = new ServiceTopologyOperationInputBuilder(input);
 531                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
 532
 533                 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+siid+"] operational-data: " + operDataBuilder.build());
 534                 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
 535
 536                 // Call SLI sync method
 537                 // Get SvcLogicService reference
 538
 539                 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
 540                 Properties respProps = null;
 541
 542                 String errorCode = "200";
 543                 String errorMessage = null;
 544                 String ackFinal = "Y";
 545         String serviceObjectPath = null;
 546
 547                 try
 548                 {
 549                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
 550                         {
 551
 552                                 try
 553                                 {
 554                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
 555                                 }
 556                                 catch (Exception e)
 557                                 {
 558                                         log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
 559                                         errorMessage = e.getMessage();
 560                                         errorCode = "500";
 561                                 }
 562                         } else {
 563                                 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
 564                                 errorCode = "503";
 565                         }
 566                 }
 567                 catch (Exception e)
 568                 {
 569                         errorCode = "500";
 570                         errorMessage = e.getMessage();
 571                         log.error("Caught exception looking for service logic", e);
 572                 }
 573
 574
 575                 if (respProps != null)
 576                 {
 577                         errorCode = respProps.getProperty("error-code");
 578                         errorMessage = respProps.getProperty("error-message");
 579                         ackFinal = respProps.getProperty("ack-final", "Y");
 580             serviceObjectPath = respProps.getProperty("service-object-path");
 581                 }
 582
 583                 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
 584                 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
 585                 //serviceStatusBuilder.setRpcName(RpcName.ServiceTopologyOperation);
 586                 serviceStatusBuilder.setRpcName(SVC_OPERATION);
 587
 588                 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
 589                         responseBuilder.setResponseCode(errorCode);
 590                         responseBuilder.setResponseMessage(errorMessage);
 591                         responseBuilder.setAckFinalIndicator(ackFinal);
 592
 593                         ServiceBuilder serviceBuilder = new ServiceBuilder();
 594                         serviceBuilder.setServiceInstanceId(siid);
 595                         serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
 596                         try {
 597                                 SaveService (serviceBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
 598                         } catch (Exception e) {
 599                                 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
 600                         }
 601                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
 602                         RpcResult<ServiceTopologyOperationOutput> rpcResult =
 603                 RpcResultBuilder.<ServiceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
 604                         return Futures.immediateFuture(rpcResult);
 605                 }
 606
 607                 // Got success from SLI
 608                 try {
 609                         serviceData = serviceDataBuilder.build();
 610                         log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] ServiceData: " + serviceData);
 611
 612                         // service object
 613                         ServiceBuilder serviceBuilder = new ServiceBuilder();
 614                         serviceBuilder.setServiceData(serviceData);
 615                         serviceBuilder.setServiceInstanceId(siid);
 616                         serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
 617                         SaveService (serviceBuilder.build(), false,LogicalDatastoreType.CONFIGURATION);
 618
 619                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
 620                         {
 621                                 // Only update operational tree on delete
 622                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete))
 623                                 {
 624                                         log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
 625                         DeleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
 626                         DeleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
 627                                 }
 628                         }
 629
 630             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
 631             serviceResponseInformationBuilder.setInstanceId(siid);
 632             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
 633             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
 634
 635                 } catch (Exception e) {
 636                         log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
 637                         responseBuilder.setResponseCode("500");
 638                         responseBuilder.setResponseMessage(e.toString());
 639                         responseBuilder.setAckFinalIndicator("Y");
 640                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
 641                         RpcResult<ServiceTopologyOperationOutput> rpcResult =
 642                 RpcResultBuilder.<ServiceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
 643                         return Futures.immediateFuture(rpcResult);
 644                 }
 645
 646                 // Update succeeded
 647                 responseBuilder.setResponseCode(errorCode);
 648                 responseBuilder.setAckFinalIndicator(ackFinal);
 649                 if (errorMessage != null)
 650                 {
 651                         responseBuilder.setResponseMessage(errorMessage);
 652                 }
 653                 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+siid+"] ");
 654                 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
 655
 656                 RpcResult<ServiceTopologyOperationOutput> rpcResult =
 657             RpcResultBuilder.<ServiceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
 658                 return Futures.immediateFuture(rpcResult);
 659         }
 660
 661         @Override
 662         public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(
 663                         VnfTopologyOperationInput input) {
 664
 665                 final String SVC_OPERATION = "vnf-topology-operation";
 666                 ServiceData serviceData;
 667                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
 668                 Properties parms = new Properties();
 669
 670                 log.info( SVC_OPERATION +" called." );
 671                 // create a new response object
 672                 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
 673
 674                 if(input == null ||
 675             input.getServiceInformation() == null ||
 676                 input.getServiceInformation().getServiceInstanceId() == null ||
 677                     input.getServiceInformation().getServiceInstanceId().length() == 0)
 678         {
 679                         log.debug("exiting " +SVC_OPERATION+ " because of null or empty service-instance-id");
 680                         responseBuilder.setResponseCode("404");
 681                         responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
 682                         responseBuilder.setAckFinalIndicator("Y");
 683                         RpcResult<VnfTopologyOperationOutput> rpcResult =
 684                                         RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
 685                         // return error
 686                         return Futures.immediateFuture(rpcResult);
 687                 }
 688
 689                 // Grab the service instance ID from the input buffer
 690                 String siid = input.getServiceInformation().getServiceInstanceId();
 691
 692                 if (input.getSdncRequestHeader() != null) {
 693                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
 694                 }
 695
 696                 if(input.getVnfInformation() == null ||
 697                 input.getVnfInformation().getVnfId() == null ||
 698                     input.getVnfInformation().getVnfId().length() == 0)
 699         {
 700                         log.debug("exiting " +SVC_OPERATION+ " because of null or empty vnf-id");
 701                         responseBuilder.setResponseCode("404");
 702                         responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
 703                         responseBuilder.setAckFinalIndicator("Y");
 704                         RpcResult<VnfTopologyOperationOutput> rpcResult =
 705                 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
 706                         return Futures.immediateFuture(rpcResult);
 707                 }
 708
 709         /* Mobility wont use vipr intf in 1707
 710
 711                 String preload_name  = null;
 712                 String preload_type = null;
 713         if (input.getVnfRequestInput() != null &&
 714                 input.getVnfRequestInput().getVnfName() != null && input.getVnfRequestInput().getVnfName().length() != 0) {
 715             preload_name  = input.getVnfRequestInput().getVnfName();
 716         }
 717         if (input.getVnfInformation().getVnfType() != null &&
 718                 input.getVnfInformation().getVnfType().length() != 0) {
 719                     preload_type = input.getVnfInformation().getVnfType();
 720         }
 721
 722                 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
 723         if (preload_name != null && preload_type != null) {
 724                     getPreloadData(preload_name, preload_type, preloadDataBuilder);
 725         }
 726         else {
 727             log.info("vnf-name and vnf-type not present in the request");
 728         }
 729         */
 730
 731                 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
 732                 getServiceData(siid,serviceDataBuilder);
 733
 734                 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
 735                 getServiceData(siid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
 736
 737                 // Set the serviceStatus based on input
 738                 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
 739                 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
 740
 741                 //
 742                 // setup a service-data object builder
 743                 // ACTION vnf-topology-operation
 744                 // INPUT:
 745                 //  USES sdnc-request-header;
 746                 //  USES request-information;
 747                 //  USES service-information;
 748                 //  USES vnf-request-information
 749                 // OUTPUT:
 750                 //  USES vnf-topology-response-body;
 751                 //  USES vnf-information
 752                 //  USES service-information
 753                 //
 754                 // container service-data
 755         //   uses vnf-configuration-information;
 756         //   uses oper-status;
 757
 758                 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+siid+"] input: " + input);
 759                 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
 760                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
 761
 762                 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+siid+"] operational-data: " + operDataBuilder.build());
 763                 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
 764
 765         /*
 766                 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " + preloadDataBuilder.build());
 767                 GenericResourceApiUtil.toProperties(parms, "preload-data", preloadDataBuilder);
 768         */
 769
 770                 // Call SLI sync method
 771                 // Get SvcLogicService reference
 772
 773                 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
 774                 Properties respProps = null;
 775
 776                 String errorCode = "200";
 777                 String errorMessage = null;
 778                 String ackFinal = "Y";
 779         String serviceObjectPath = null;
 780
 781                 try
 782                 {
 783                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
 784                         {
 785
 786                                 try
 787                                 {
 788                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
 789                                 }
 790                                 catch (Exception e)
 791                                 {
 792                                         log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
 793                                         errorMessage = e.getMessage();
 794                                         errorCode = "500";
 795                                 }
 796                         } else {
 797                                 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
 798                                 errorCode = "503";
 799                         }
 800                 }
 801                 catch (Exception e)
 802                 {
 803                         errorCode = "500";
 804                         errorMessage = e.getMessage();
 805                         log.error("Caught exception looking for service logic", e);
 806                 }
 807
 808                 if (respProps != null)
 809                 {
 810                         errorCode = respProps.getProperty("error-code");
 811                         errorMessage = respProps.getProperty("error-message");
 812                         ackFinal = respProps.getProperty("ack-final", "Y");
 813             serviceObjectPath = respProps.getProperty("vnf-object-path");
 814                 }
 815
 816                 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
 817                 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
 818                 //serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
 819                 serviceStatusBuilder.setRpcName(SVC_OPERATION);
 820
 821                 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
 822                         responseBuilder.setResponseCode(errorCode);
 823                         responseBuilder.setResponseMessage(errorMessage);
 824                         responseBuilder.setAckFinalIndicator(ackFinal);
 825
 826                         ServiceBuilder serviceBuilder = new ServiceBuilder();
 827                         serviceBuilder.setServiceInstanceId(siid);
 828                         serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
 829                         try {
 830                                 SaveService (serviceBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
 831                                 if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
 832                                 {
 833                                         // Only update operational tree on activate or delete
 834                                         if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
 835                                                         input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
 836                                         {
 837                                                 log.info("Updating OPERATIONAL tree.");
 838                                                 SaveService (serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
 839                                         }
 840                                 }
 841                         } catch (Exception e) {
 842                                 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
 843                         }
 844                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
 845                         RpcResult<VnfTopologyOperationOutput> rpcResult =
 846                             RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
 847                         // return error
 848                         return Futures.immediateFuture(rpcResult);
 849                 }
 850
 851                 // Got success from SLI
 852                 try {
 853                         serviceData = serviceDataBuilder.build();
 854                         log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] ServiceData: " + serviceData);
 855
 856                         // service object
 857                         ServiceBuilder serviceBuilder = new ServiceBuilder();
 858                         serviceBuilder.setServiceData(serviceData);
 859                         serviceBuilder.setServiceInstanceId(siid);
 860                         serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
 861                         SaveService (serviceBuilder.build(), false,LogicalDatastoreType.CONFIGURATION);
 862
 863                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
 864                         {
 865                                 // Only update operational tree on Assign
 866                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
 867                                 {
 868                                         log.info("Updating OPERATIONAL tree.");
 869                                         SaveService (serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
 870                                 }
 871                         }
 872
 873             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
 874             serviceResponseInformationBuilder.setInstanceId(siid);
 875             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
 876             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
 877
 878                 } catch (Exception e) {
 879                         log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
 880                         responseBuilder.setResponseCode("500");
 881                         responseBuilder.setResponseMessage(e.toString());
 882                         responseBuilder.setAckFinalIndicator("Y");
 883                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
 884                         RpcResult<VnfTopologyOperationOutput> rpcResult =
 885                             RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
 886                         return Futures.immediateFuture(rpcResult);
 887                 }
 888
 889                 // Update succeeded
 890                 responseBuilder.setResponseCode(errorCode);
 891                 responseBuilder.setAckFinalIndicator(ackFinal);
 892                 if (errorMessage != null)
 893                 {
 894                         responseBuilder.setResponseMessage(errorMessage);
 895                 }
 896                 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+siid+"] ");
 897                 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
 898
 899                 RpcResult<VnfTopologyOperationOutput> rpcResult =
 900                     RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
 901                 // return success
 902                 return Futures.immediateFuture(rpcResult);
 903         }
 904
 905     @Override
 906     public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
 907             VfModuleTopologyOperationInput input) {
 908
 909         final String SVC_OPERATION = "vf-module-topology-operation";
 910         ServiceData serviceData;
 911         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
 912         Properties parms = new Properties();
 913
 914         log.info( SVC_OPERATION +" called." );
 915         // create a new response object
 916         VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
 917
 918         if(input == null ||
 919             input.getServiceInformation() == null ||
 920                 input.getServiceInformation().getServiceInstanceId() == null ||
 921                     input.getServiceInformation().getServiceInstanceId().length() == 0)
 922         {
 923             log.debug("exiting " +SVC_OPERATION+ " because of null or empty service-instance-id");
 924             responseBuilder.setResponseCode("403");
 925             responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
 926             responseBuilder.setAckFinalIndicator("Y");
 927             RpcResult<VfModuleTopologyOperationOutput> rpcResult =
 928                     RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
 929             // return error
 930             return Futures.immediateFuture(rpcResult);
 931         }
 932
 933         if(input.getVnfInformation() == null ||
 934                 input.getVnfInformation().getVnfId() == null ||
 935                     input.getVnfInformation().getVnfId().length() == 0)
 936         {
 937             log.debug("exiting " +SVC_OPERATION+ " because of null or empty vnf-id");
 938             responseBuilder.setResponseCode("403");
 939             responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
 940             responseBuilder.setAckFinalIndicator("Y");
 941             RpcResult<VfModuleTopologyOperationOutput> rpcResult =
 942                 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
 943             return Futures.immediateFuture(rpcResult);
 944         }
 945
 946         if(input.getVfModuleInformation() == null ||
 947                 input.getVfModuleInformation().getVfModuleId() == null ||
 948                     input.getVfModuleInformation().getVfModuleId().length() == 0)
 949         {
 950             log.debug("exiting " +SVC_OPERATION+ " because of null or empty vf-module-id");
 951             responseBuilder.setResponseCode("403");
 952             responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
 953             responseBuilder.setAckFinalIndicator("Y");
 954             RpcResult<VfModuleTopologyOperationOutput> rpcResult =
 955                 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
 956             return Futures.immediateFuture(rpcResult);
 957         }
 958
 959         // Grab the service instance ID from the input buffer
 960         String siid = input.getServiceInformation().getServiceInstanceId();
 961
 962         if (input.getSdncRequestHeader() != null) {
 963             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
 964         }
 965
 966         /*
 967         String preload_name  = null;
 968         String preload_type = null;
 969
 970         preload_name  = input.getVfModuleRequestInput().getVfModuleName();
 971
 972         if(input.getVfModuleInformation().getVfModuleType() != null &&
 973                     input.getVfModuleInformation().getVfModuleType().length() != 0) {
 974             preload_type = input.getVfModuleInformation().getVfModuleType();
 975         }
 976
 977         PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
 978         if (preload_name != null && preload_type != null) {
 979             getPreloadData(preload_name, preload_type, preloadDataBuilder);
 980         }
 981         else {
 982             log.debug("vf-module-name and vf-module-type not present in the request.");
 983         }
 984         */
 985
 986         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
 987         getServiceData(siid,serviceDataBuilder);
 988
 989         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
 990         getServiceData(siid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
 991
 992         // Set the serviceStatus based on input
 993         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
 994         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
 995
 996         //
 997         // setup a service-data object builder
 998         // ACTION vnf-topology-operation
 999         // INPUT:
1000         //  USES sdnc-request-header;
1001         //  USES request-information;
1002         //  USES service-information;
1003         //  USES vnf-request-information
1004         // OUTPUT:
1005         //  USES vnf-topology-response-body;
1006         //  USES vnf-information
1007         //  USES service-information
1008         //
1009         // container service-data
1010         //   uses vnf-configuration-information;
1011         //   uses oper-status;
1012
1013         log.info("Adding INPUT data for "+SVC_OPERATION+" ["+siid+"] input: " + input);
1014         VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1015         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1016
1017         log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+siid+"] operational-data: " + operDataBuilder.build());
1018         GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
1019
1020         /*
1021         log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " +preloadDataBuilder.build());
1022         GenericResourceApiUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1023         */
1024
1025         // Call SLI sync method
1026         // Get SvcLogicService reference
1027
1028         GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1029         Properties respProps = null;
1030
1031         String errorCode = "200";
1032         String errorMessage = null;
1033         String ackFinal = "Y";
1034         String serviceObjectPath = null;
1035
1036         try
1037         {
1038             if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1039             {
1040
1041                 try
1042                 {
1043                     respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1044                 }
1045                 catch (Exception e)
1046                 {
1047                     log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1048                     errorMessage = e.getMessage();
1049                     errorCode = "500";
1050                 }
1051             } else {
1052                 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1053                 errorCode = "503";
1054             }
1055         }
1056         catch (Exception e)
1057         {
1058             errorCode = "500";
1059             errorMessage = e.getMessage();
1060             log.error("Caught exception looking for service logic", e);
1061         }
1062
1063         if (respProps != null)
1064         {
1065             errorCode = respProps.getProperty("error-code");
1066             errorMessage = respProps.getProperty("error-message");
1067             ackFinal = respProps.getProperty("ack-final", "Y");
1068             serviceObjectPath = respProps.getProperty("vf-module-object-path");
1069         }
1070
1071         setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
1072         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1073         serviceStatusBuilder.setRpcName(SVC_OPERATION);
1074
1075         if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1076             responseBuilder.setResponseCode(errorCode);
1077             responseBuilder.setResponseMessage(errorMessage);
1078             responseBuilder.setAckFinalIndicator(ackFinal);
1079
1080             ServiceBuilder serviceBuilder = new ServiceBuilder();
1081             serviceBuilder.setServiceInstanceId(siid);
1082             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1083             try {
1084                 SaveService (serviceBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
1085             } catch (Exception e) {
1086                 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
1087             }
1088             log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1089             RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1090                     RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1091             // return error
1092             return Futures.immediateFuture(rpcResult);
1093         }
1094
1095         // Got success from SLI
1096         try {
1097             serviceData = serviceDataBuilder.build();
1098             log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] ServiceData: " + serviceData);
1099
1100             // service object
1101             ServiceBuilder serviceBuilder = new ServiceBuilder();
1102             serviceBuilder.setServiceData(serviceData);
1103             //serviceBuilder.setServiceInstanceId(serviceData.getServiceTopology().getServiceTopologyIdentifier().getServiceInstanceId());
1104             serviceBuilder.setServiceInstanceId(siid);
1105             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1106             SaveService (serviceBuilder.build(), false,LogicalDatastoreType.CONFIGURATION);
1107
1108                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1109                         {
1110                                 // Only update operational tree on activate or delete
1111                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1112                                                 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1113                                 {
1114                                         log.info("Updating OPERATIONAL tree.");
1115                                         SaveService (serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1116                                 }
1117                         }
1118
1119             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1120             serviceResponseInformationBuilder.setInstanceId(siid);
1121             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1122             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1123
1124         } catch (Exception e) {
1125             log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
1126             responseBuilder.setResponseCode("500");
1127             responseBuilder.setResponseMessage(e.toString());
1128             responseBuilder.setAckFinalIndicator("Y");
1129             log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1130             RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1131                 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1132             return Futures.immediateFuture(rpcResult);
1133         }
1134
1135         // Update succeeded
1136         responseBuilder.setResponseCode(errorCode);
1137         responseBuilder.setAckFinalIndicator(ackFinal);
1138         if (errorMessage != null)
1139         {
1140             responseBuilder.setResponseMessage(errorMessage);
1141         }
1142         log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+siid+"] ");
1143         log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1144
1145         RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1146             RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1147         // return success
1148         return Futures.immediateFuture(rpcResult);
1149     }
1150
1151         @Override
1152         public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1153                         NetworkTopologyOperationInput input) {
1154
1155                 final String SVC_OPERATION = "network-topology-operation";
1156                 ServiceData serviceData;
1157                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1158                 Properties parms = new Properties();
1159
1160                 log.info( SVC_OPERATION +" called." );
1161                 // create a new response object
1162                 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1163
1164                 if(input == null ||
1165             input.getServiceInformation() == null ||
1166                 input.getServiceInformation().getServiceInstanceId() == null ||
1167                     input.getServiceInformation().getServiceInstanceId().length() == 0)
1168         {
1169                         log.debug("exiting " +SVC_OPERATION+ " because of null or empty service-instance-id");
1170                         responseBuilder.setResponseCode("404");
1171                         responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1172                         responseBuilder.setAckFinalIndicator("Y");
1173                         RpcResult<NetworkTopologyOperationOutput> rpcResult =
1174                 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1175                         return Futures.immediateFuture(rpcResult);
1176                 }
1177
1178         String siid = input.getServiceInformation().getServiceInstanceId();
1179
1180         // Get the service-instance service data from MD-SAL
1181         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1182         getServiceData(siid,serviceDataBuilder);
1183
1184                 if (input.getSdncRequestHeader() != null) {
1185                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1186                 }
1187
1188         ServiceData sd = serviceDataBuilder.build();
1189         if (sd == null || sd.getServiceLevelOperStatus() == null)
1190         {
1191                         log.debug("exiting " +SVC_OPERATION+ " because the service-instance does not have any service data in SDNC");
1192                         responseBuilder.setResponseCode("404");
1193                         responseBuilder.setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1194                         responseBuilder.setAckFinalIndicator("Y");
1195                         RpcResult<NetworkTopologyOperationOutput> rpcResult =
1196                 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1197                         return Futures.immediateFuture(rpcResult);
1198                 }
1199
1200
1201        /*
1202                 //String preload_name  = null;
1203                 //String preload_type = null;
1204         // If both network-name and network-type are present in request, get the preload network from MD-SAL
1205         if (input.getNetworkRequestInput() != null &&
1206                 input.getNetworkRequestInput().getNetworkName() != null &&
1207                     input.getNetworkRequestInput().getNetworkName().length() != 0) {
1208             preload_name = input.getNetworkRequestInput().getNetworkName();
1209         }
1210         if (input.getNetworkInformation() != null &&
1211                 input.getNetworkInformation().getNetworkType() != null &&
1212                     input.getNetworkInformation().getNetworkType().length() != 0) {
1213             preload_type = input.getNetworkInformation().getNetworkType();
1214         }
1215
1216                 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1217         if (preload_name != null && preload_type != null) {
1218                     getPreloadData(preload_name, preload_type, preloadDataBuilder);
1219         }
1220         else {
1221                         log.debug("network-name and network-type not present in request");
1222         }
1223         */
1224
1225                 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+siid+"] input: " + input);
1226                 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1227                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1228
1229                 // Call SLI sync method
1230                 // Get SvcLogicService reference
1231
1232                 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1233                 Properties respProps = null;
1234
1235                 String errorCode = "200";
1236                 String errorMessage = null;
1237                 String ackFinal = "Y";
1238                 String networkId = "error";
1239         String serviceObjectPath = null;
1240         String networkObjectPath = null;
1241
1242                 try
1243                 {
1244                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1245                         {
1246
1247                                 try
1248                                 {
1249                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1250                                 }
1251                                 catch (Exception e)
1252                                 {
1253                                         log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1254                                         errorMessage = e.getMessage();
1255                                         errorCode = "500";
1256                                 }
1257                         } else {
1258                                 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1259                                 errorCode = "503";
1260                         }
1261                 }
1262                 catch (Exception e)
1263                 {
1264                         errorCode = "500";
1265                         errorMessage = e.getMessage();
1266                         log.error("Caught exception looking for service logic", e);
1267                 }
1268
1269
1270                 if (respProps != null)
1271                 {
1272                         errorCode = respProps.getProperty("error-code");
1273                         errorMessage = respProps.getProperty("error-message");
1274                         ackFinal = respProps.getProperty("ack-final", "Y");
1275                         networkId = respProps.getProperty("networkId");
1276                         serviceObjectPath = respProps.getProperty("service-object-path");
1277                         networkObjectPath = respProps.getProperty("network-object-path");
1278                 }
1279
1280                 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1281                         responseBuilder.setResponseCode(errorCode);
1282                         responseBuilder.setResponseMessage(errorMessage);
1283                         responseBuilder.setAckFinalIndicator(ackFinal);
1284
1285                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1286
1287                         RpcResult<NetworkTopologyOperationOutput> rpcResult =
1288                 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1289                         return Futures.immediateFuture(rpcResult);
1290                 }
1291
1292                 // Got success from SLI
1293                 try {
1294
1295                         serviceData = serviceDataBuilder.build();
1296                         log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] ServiceData: " + serviceData);
1297
1298                         // service object
1299                         ServiceBuilder serviceBuilder = new ServiceBuilder();
1300                         serviceBuilder.setServiceData(serviceData);
1301                         serviceBuilder.setServiceInstanceId(siid);
1302                         serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1303                         SaveService (serviceBuilder.build(), false,LogicalDatastoreType.CONFIGURATION);
1304
1305                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1306                         {
1307                                 // Only update operational tree on Activate
1308                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1309                 {
1310                                         log.info("Updating OPERATIONAL tree.");
1311                                         SaveService (serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1312                                 }
1313                         }
1314
1315                         NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1316                         networkResponseInformationBuilder.setInstanceId(networkId);
1317                         networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1318                         responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1319
1320                         ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1321                         serviceResponseInformationBuilder.setInstanceId(siid);
1322                         serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1323                         responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1324
1325                 } catch (IllegalStateException e) {
1326                         log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
1327                         responseBuilder.setResponseCode("500");
1328                         responseBuilder.setResponseMessage(e.toString());
1329                         responseBuilder.setAckFinalIndicator("Y");
1330                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1331                         RpcResult<NetworkTopologyOperationOutput> rpcResult =
1332                 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1333                         return Futures.immediateFuture(rpcResult);
1334                 }
1335
1336                 // Update succeeded
1337                 responseBuilder.setResponseCode(errorCode);
1338                 responseBuilder.setAckFinalIndicator(ackFinal);
1339                 if (errorMessage != null)
1340                 {
1341                         responseBuilder.setResponseMessage(errorMessage);
1342                 }
1343                 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+siid+"] ");
1344                 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1345
1346                 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1347             RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1348                 return Futures.immediateFuture(rpcResult);
1349         }
1350
1351         @Override
1352         public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1353                         ContrailRouteTopologyOperationInput input) {
1354
1355                 final String SVC_OPERATION = "contrail-route-topology-operation";
1356                 ServiceData serviceData;
1357                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1358                 Properties parms = new Properties();
1359
1360                 log.info( SVC_OPERATION +" called." );
1361                 // create a new response object
1362                 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1363
1364                 if(input == null ||
1365             input.getServiceInformation() == null ||
1366                 input.getServiceInformation().getServiceInstanceId() == null ||
1367                     input.getServiceInformation().getServiceInstanceId().length() == 0)
1368         {
1369                         log.debug("exiting " +SVC_OPERATION+ " because of null or empty service-instance-id");
1370                         responseBuilder.setResponseCode("404");
1371                         responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1372                         responseBuilder.setAckFinalIndicator("Y");
1373                         RpcResult<ContrailRouteTopologyOperationOutput> rpcResult =
1374                 RpcResultBuilder.<ContrailRouteTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1375                         return Futures.immediateFuture(rpcResult);
1376                 }
1377
1378         String siid = input.getServiceInformation().getServiceInstanceId();
1379
1380         // Get the service-instance service data from MD-SAL
1381         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1382         getServiceData(siid,serviceDataBuilder);
1383
1384                 if (input.getSdncRequestHeader() != null) {
1385                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1386                 }
1387
1388         ServiceData sd = serviceDataBuilder.build();
1389         if (sd == null || sd.getServiceLevelOperStatus() == null)
1390         {
1391                         log.debug("exiting " +SVC_OPERATION+ " because the service-instance does not have any service data in SDNC");
1392                         responseBuilder.setResponseCode("404");
1393                         responseBuilder.setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1394                         responseBuilder.setAckFinalIndicator("Y");
1395                         RpcResult<ContrailRouteTopologyOperationOutput> rpcResult =
1396                 RpcResultBuilder.<ContrailRouteTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1397                         return Futures.immediateFuture(rpcResult);
1398                 }
1399
1400                 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+siid+"] input: " + input);
1401                 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1402                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1403
1404                 // Call SLI sync method
1405                 // Get SvcLogicService reference
1406
1407                 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1408                 Properties respProps = null;
1409
1410                 String errorCode = "200";
1411                 String errorMessage = null;
1412                 String ackFinal = "Y";
1413                 String allottedResourceId = "error";
1414         String serviceObjectPath = null;
1415         String contrailRouteObjectPath = null;
1416
1417                 try
1418                 {
1419                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1420                         {
1421
1422                                 try
1423                                 {
1424                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1425                                 }
1426                                 catch (Exception e)
1427                                 {
1428                                         log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1429                                         errorMessage = e.getMessage();
1430                                         errorCode = "500";
1431                                 }
1432                         } else {
1433                                 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1434                                 errorCode = "503";
1435                         }
1436                 }
1437                 catch (Exception e)
1438                 {
1439                         errorCode = "500";
1440                         errorMessage = e.getMessage();
1441                         log.error("Caught exception looking for service logic", e);
1442                 }
1443
1444
1445                 if (respProps != null)
1446                 {
1447                         errorCode = respProps.getProperty("error-code");
1448                         errorMessage = respProps.getProperty("error-message");
1449                         ackFinal = respProps.getProperty("ack-final", "Y");
1450                         allottedResourceId = respProps.getProperty("allotted-resource-id");
1451                         serviceObjectPath = respProps.getProperty("service-object-path");
1452                         contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1453                 }
1454
1455                 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1456                         responseBuilder.setResponseCode(errorCode);
1457                         responseBuilder.setResponseMessage(errorMessage);
1458                         responseBuilder.setAckFinalIndicator(ackFinal);
1459
1460                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1461
1462                         RpcResult<ContrailRouteTopologyOperationOutput> rpcResult =
1463                 RpcResultBuilder.<ContrailRouteTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1464                         return Futures.immediateFuture(rpcResult);
1465                 }
1466
1467                 // Got success from SLI
1468                 try {
1469
1470                         serviceData = serviceDataBuilder.build();
1471                         log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] ServiceData: " + serviceData);
1472
1473                         // service object
1474                         ServiceBuilder serviceBuilder = new ServiceBuilder();
1475                         serviceBuilder.setServiceData(serviceData);
1476                         serviceBuilder.setServiceInstanceId(siid);
1477                         serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1478                         SaveService (serviceBuilder.build(), false,LogicalDatastoreType.CONFIGURATION);
1479
1480                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1481                         {
1482                                 // Only update operational tree on activate or delete
1483                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1484                                                 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1485                                 {
1486                                         log.info("Updating OPERATIONAL tree.");
1487                                         SaveService (serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1488                                 }
1489                         }
1490
1491                         ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1492                         contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1493                         contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1494                         responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1495
1496                         ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1497                         serviceResponseInformationBuilder.setInstanceId(siid);
1498                         serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1499                         responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1500
1501                 } catch (IllegalStateException e) {
1502                         log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
1503                         responseBuilder.setResponseCode("500");
1504                         responseBuilder.setResponseMessage(e.toString());
1505                         responseBuilder.setAckFinalIndicator("Y");
1506                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1507                         RpcResult<ContrailRouteTopologyOperationOutput> rpcResult =
1508                 RpcResultBuilder.<ContrailRouteTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1509                         return Futures.immediateFuture(rpcResult);
1510                 }
1511
1512                 // Update succeeded
1513                 responseBuilder.setResponseCode(errorCode);
1514                 responseBuilder.setAckFinalIndicator(ackFinal);
1515                 if (errorMessage != null)
1516                 {
1517                         responseBuilder.setResponseMessage(errorMessage);
1518                 }
1519                 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+siid+"] ");
1520                 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1521
1522                 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult =
1523             RpcResultBuilder.<ContrailRouteTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1524                 return Futures.immediateFuture(rpcResult);
1525         }
1526
1527         @Override
1528         public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1529                         SecurityZoneTopologyOperationInput input) {
1530
1531                 final String SVC_OPERATION = "security-zone-topology-operation";
1532                 ServiceData serviceData;
1533                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1534                 Properties parms = new Properties();
1535
1536                 log.info( SVC_OPERATION +" called." );
1537                 // create a new response object
1538                 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1539
1540                 if(input == null ||
1541             input.getServiceInformation() == null ||
1542                 input.getServiceInformation().getServiceInstanceId() == null ||
1543                     input.getServiceInformation().getServiceInstanceId().length() == 0)
1544         {
1545                         log.debug("exiting " +SVC_OPERATION+ " because of null or empty service-instance-id");
1546                         responseBuilder.setResponseCode("404");
1547                         responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1548                         responseBuilder.setAckFinalIndicator("Y");
1549                         RpcResult<SecurityZoneTopologyOperationOutput> rpcResult =
1550                 RpcResultBuilder.<SecurityZoneTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1551                         return Futures.immediateFuture(rpcResult);
1552                 }
1553
1554         String siid = input.getServiceInformation().getServiceInstanceId();
1555
1556         // Get the service-instance service data from MD-SAL
1557         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1558         getServiceData(siid,serviceDataBuilder);
1559
1560                 if (input.getSdncRequestHeader() != null) {
1561                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1562                 }
1563
1564         ServiceData sd = serviceDataBuilder.build();
1565         if (sd == null || sd.getServiceLevelOperStatus() == null)
1566         {
1567                         log.debug("exiting " +SVC_OPERATION+ " because the service-instance does not have any service data in SDNC");
1568                         responseBuilder.setResponseCode("404");
1569                         responseBuilder.setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1570                         responseBuilder.setAckFinalIndicator("Y");
1571                         RpcResult<SecurityZoneTopologyOperationOutput> rpcResult =
1572                 RpcResultBuilder.<SecurityZoneTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1573                         return Futures.immediateFuture(rpcResult);
1574                 }
1575
1576                 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+siid+"] input: " + input);
1577                 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1578                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1579
1580                 // Call SLI sync method
1581                 // Get SvcLogicService reference
1582
1583                 GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1584                 Properties respProps = null;
1585
1586                 String errorCode = "200";
1587                 String errorMessage = null;
1588                 String ackFinal = "Y";
1589                 String allottedResourceId = "error";
1590         String serviceObjectPath = null;
1591         String securityZoneObjectPath = null;
1592
1593                 try
1594                 {
1595                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1596                         {
1597
1598                                 try
1599                                 {
1600                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1601                                 }
1602                                 catch (Exception e)
1603                                 {
1604                                         log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1605                                         errorMessage = e.getMessage();
1606                                         errorCode = "500";
1607                                 }
1608                         } else {
1609                                 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1610                                 errorCode = "503";
1611                         }
1612                 }
1613                 catch (Exception e)
1614                 {
1615                         errorCode = "500";
1616                         errorMessage = e.getMessage();
1617                         log.error("Caught exception looking for service logic", e);
1618                 }
1619
1620
1621                 if (respProps != null)
1622                 {
1623                         errorCode = respProps.getProperty("error-code");
1624                         errorMessage = respProps.getProperty("error-message");
1625                         ackFinal = respProps.getProperty("ack-final", "Y");
1626                         allottedResourceId = respProps.getProperty("allotted-resource-id");
1627                         serviceObjectPath = respProps.getProperty("service-object-path");
1628                         securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1629                 }
1630
1631                 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1632                         responseBuilder.setResponseCode(errorCode);
1633                         responseBuilder.setResponseMessage(errorMessage);
1634                         responseBuilder.setAckFinalIndicator(ackFinal);
1635
1636                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1637
1638                         RpcResult<SecurityZoneTopologyOperationOutput> rpcResult =
1639                 RpcResultBuilder.<SecurityZoneTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1640                         return Futures.immediateFuture(rpcResult);
1641                 }
1642
1643                 // Got success from SLI
1644                 try {
1645
1646                         serviceData = serviceDataBuilder.build();
1647                         log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] ServiceData: " + serviceData);
1648
1649                         // service object
1650                         ServiceBuilder serviceBuilder = new ServiceBuilder();
1651                         serviceBuilder.setServiceData(serviceData);
1652                         serviceBuilder.setServiceInstanceId(siid);
1653                         serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1654                         SaveService (serviceBuilder.build(), false,LogicalDatastoreType.CONFIGURATION);
1655
1656                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1657                         {
1658                                 // Only update operational tree on activate or delete
1659                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1660                                                 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1661                                 {
1662                                         log.info("Updating OPERATIONAL tree.");
1663                                         SaveService (serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1664                                 }
1665                         }
1666
1667                         SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1668                         securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1669                         securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1670                         responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1671
1672                         ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1673                         serviceResponseInformationBuilder.setInstanceId(siid);
1674                         serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1675                         responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1676
1677                 } catch (IllegalStateException e) {
1678                         log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
1679                         responseBuilder.setResponseCode("500");
1680                         responseBuilder.setResponseMessage(e.toString());
1681                         responseBuilder.setAckFinalIndicator("Y");
1682                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1683                         RpcResult<SecurityZoneTopologyOperationOutput> rpcResult =
1684                 RpcResultBuilder.<SecurityZoneTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1685                         return Futures.immediateFuture(rpcResult);
1686                 }
1687
1688                 // Update succeeded
1689                 responseBuilder.setResponseCode(errorCode);
1690                 responseBuilder.setAckFinalIndicator(ackFinal);
1691                 if (errorMessage != null)
1692                 {
1693                         responseBuilder.setResponseMessage(errorMessage);
1694                 }
1695                 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+siid+"] ");
1696                 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1697
1698                 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult =
1699             RpcResultBuilder.<SecurityZoneTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1700                 return Futures.immediateFuture(rpcResult);
1701         }
1702
1703     @Override
1704     public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1705             PreloadVnfTopologyOperationInput input) {
1706
1707         final String SVC_OPERATION = "preload-vnf-topology-operation";
1708         PreloadData preloadData = null;
1709         Properties parms = new Properties();
1710
1711         log.info( SVC_OPERATION +" called." );
1712         // create a new response object
1713         PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1714
1715         // Result from savePreloadData
1716         final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1717
1718         if(input == null || input.getVnfTopologyInformation() == null ||
1719             input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null) {
1720                 log.debug("exiting " +SVC_OPERATION+ " because of null input");
1721                 responseBuilder.setResponseCode("403");
1722                 responseBuilder.setResponseMessage("invalid input: input is null");
1723                 responseBuilder.setAckFinalIndicator("Y");
1724                 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1725                     RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1726                 return Futures.immediateFuture(rpcResult);
1727         }
1728
1729         // Grab the name and type from the input buffer
1730         String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1731         String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1732
1733         // Make sure we have a preload_name and preload_type
1734         if(preload_name == null || preload_name.length() == 0 || preload_type == null || preload_type.length() == 0 ) {
1735             log.debug("exiting "+ SVC_OPERATION + " vnf-name or vnf-type is null or empty");
1736             responseBuilder.setResponseCode("403");
1737             responseBuilder.setResponseMessage("invalid input: vnf-name or vnf-type is null or empty");
1738             responseBuilder.setAckFinalIndicator("Y");
1739             RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1740                 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1741             return Futures.immediateFuture(rpcResult);
1742         }
1743
1744         if (input.getSdncRequestHeader() != null) {
1745             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1746         }
1747
1748         PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1749         getPreloadData(preload_name, preload_type, preloadDataBuilder);
1750
1751         PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1752         getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1753
1754         // setup a preload-data object builder
1755         // ACTION preload-vnf-topology-operation
1756         // INPUT:
1757         //  USES sdnc-request-header;
1758         //  USES request-information;
1759         //  uses vnf-topology-information;
1760         // OUTPUT:
1761         //  USES vnf-topology-response-body;
1762         //
1763         // container preload-data
1764         //   uses vnf-topology-information;
1765         //   uses network-topology-information;
1766         //   uses oper-status;
1767
1768         log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
1769         PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1770         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1771         log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
1772         GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
1773
1774         // Call SLI sync method
1775         // Get SvcLogicService reference
1776
1777         GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1778         Properties respProps = null;
1779
1780         String errorCode = "200";
1781         String errorMessage = null;
1782         String ackFinal = "Y";
1783
1784
1785         try
1786         {
1787             if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1788             {
1789
1790                 try
1791                 {
1792                     respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1793                 }
1794                 catch (Exception e)
1795                 {
1796                     log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1797                     errorMessage = e.getMessage();
1798                     errorCode = "500";
1799                 }
1800             } else {
1801                 errorMessage = "No service logic active for "+ appName + ": '" + SVC_OPERATION + "'";
1802                 errorCode = "503";
1803             }
1804         }
1805         catch (Exception e)
1806         {
1807             errorCode = "500";
1808             errorMessage = e.getMessage();
1809             log.error("Caught exception looking for service logic", e);
1810         }
1811
1812
1813         if (respProps != null)
1814         {
1815             errorCode = respProps.getProperty("error-code");
1816             errorMessage = respProps.getProperty("error-message");
1817             ackFinal = respProps.getProperty("ack-final", "Y");
1818             // internalError = respProps.getProperty("internal-error", "false");
1819         }
1820
1821         if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1822
1823             responseBuilder.setResponseCode(errorCode);
1824             responseBuilder.setResponseMessage(errorMessage);
1825             responseBuilder.setAckFinalIndicator(ackFinal);
1826
1827             VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1828             preloadVnfListBuilder.setVnfName(preload_name);
1829             preloadVnfListBuilder.setVnfType(preload_type);
1830             preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1831             log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
1832             try {
1833                 SavePreloadList (preloadVnfListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
1834             } catch (Exception e) {
1835                 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
1836             }
1837             log.debug("Sending Success rpc result due to external error");
1838             RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1839                 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1840             return Futures.immediateFuture(rpcResult);
1841         }
1842
1843         // Got success from SLI
1844         try {
1845             preloadData = preloadDataBuilder.build();
1846             log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + preloadData);
1847             // svc-configuration-list
1848             VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1849             preloadVnfListBuilder.setVnfName(preload_name);
1850             preloadVnfListBuilder.setVnfType(preload_type);
1851             preloadVnfListBuilder.setPreloadData(preloadData);
1852
1853             // merge flag sets to false to allow it to be overwritten (not appended)
1854             SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1855             log.info("Updating OPERATIONAL tree.");
1856             SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1857         } catch (Exception e) {
1858             log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
1859             responseBuilder.setResponseCode("500");
1860             responseBuilder.setResponseMessage(e.toString());
1861             responseBuilder.setAckFinalIndicator("Y");
1862             log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
1863             RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1864                 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
1865             return Futures.immediateFuture(rpcResult);
1866         }
1867
1868         // Update succeeded
1869         responseBuilder.setResponseCode(errorCode);
1870         responseBuilder.setAckFinalIndicator(ackFinal);
1871         if (errorMessage != null)
1872         {
1873             responseBuilder.setResponseMessage(errorMessage);
1874         }
1875         log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
1876         log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
1877
1878         RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1879                 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1880         return Futures.immediateFuture(rpcResult);
1881     }
1882
1883
1884     @Override
1885     public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
1886             PreloadNetworkTopologyOperationInput input) {
1887
1888         final String SVC_OPERATION = "preload-network-topology-operation";
1889         PreloadData preloadData = null;
1890         Properties parms = new Properties();
1891
1892         log.info( SVC_OPERATION +" called." );
1893         // create a new response object
1894         PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
1895
1896         // Result from savePreloadData
1897         final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1898
1899         if(input == null || input.getNetworkTopologyInformation() == null ||
1900             input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null) {
1901
1902             log.debug("exiting " +SVC_OPERATION+ " because of null input");
1903             responseBuilder.setResponseCode("403");
1904             responseBuilder.setResponseMessage("input is null");
1905             responseBuilder.setAckFinalIndicator("Y");
1906             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
1907                 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1908             return Futures.immediateFuture(rpcResult);
1909         }
1910
1911         // Grab the name and type from the input buffer
1912         String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
1913         String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
1914
1915         // Make sure we have a preload_name and preload_type
1916         if(preload_name == null || preload_name.length() == 0 || preload_type == null || preload_type.length() == 0 ) {
1917             log.debug("exiting "+SVC_OPERATION+" because of invalid preload-name");
1918             responseBuilder.setResponseCode("403");
1919             responseBuilder.setResponseMessage("input, invalid preload-name");
1920             responseBuilder.setAckFinalIndicator("Y");
1921             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
1922                 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1923             return Futures.immediateFuture(rpcResult);
1924         }
1925
1926         if (input.getSdncRequestHeader() != null) {
1927             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1928         }
1929
1930         PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1931         getPreloadData(preload_name, preload_type, preloadDataBuilder);
1932
1933         PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1934         getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1935
1936         //
1937         // setup a preload-data object builder
1938         // ACTION preload-network-topology-operation
1939         // INPUT:
1940         //  USES sdnc-request-header;
1941         //  USES request-information;
1942         //  uses network-topology-information;
1943         // OUTPUT:
1944         //  USES vnf-topology-response-body;
1945         //
1946         // container preload-data
1947         //   uses vnf-topology-information;
1948         //   uses network-topology-information;
1949         //   uses oper-status;
1950
1951
1952         log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
1953         PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(input);
1954         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1955         log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
1956         GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
1957
1958         // Call SLI sync method
1959         // Get SvcLogicService reference
1960
1961         GenericResourceApiSvcLogicServiceClient svcLogicClient = new GenericResourceApiSvcLogicServiceClient();
1962         Properties respProps = null;
1963
1964         String errorCode = "200";
1965         String errorMessage = null;
1966         String ackFinal = "Y";
1967
1968
1969         try
1970         {
1971             if (svcLogicClient.hasGraph(appName, SVC_OPERATION , null, "sync"))
1972             {
1973
1974                 try
1975                 {
1976                     respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1977                 }
1978                 catch (Exception e)
1979                 {
1980                     log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1981                     errorMessage = e.getMessage();
1982                     errorCode = "500";
1983                 }
1984             } else {
1985                 errorMessage = "No service logic active for "+ appName +": '" + SVC_OPERATION + "'";
1986                 errorCode = "503";
1987             }
1988         }
1989         catch (Exception e)
1990         {
1991             errorCode = "500";
1992             errorMessage = e.getMessage();
1993             log.error("Caught exception looking for service logic", e);
1994         }
1995
1996
1997         if (respProps != null)
1998         {
1999             errorCode = respProps.getProperty("error-code");
2000             errorMessage = respProps.getProperty("error-message");
2001             ackFinal = respProps.getProperty("ack-final", "Y");
2002             // internalError = respProps.getProperty("internal-error", "false");
2003         }
2004
2005         if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2006
2007             responseBuilder.setResponseCode(errorCode);
2008             responseBuilder.setResponseMessage(errorMessage);
2009             responseBuilder.setAckFinalIndicator(ackFinal);
2010
2011             VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2012             preloadVnfListBuilder.setVnfName(preload_name);
2013             preloadVnfListBuilder.setVnfType(preload_type);
2014             preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2015             log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
2016             try {
2017                 SavePreloadList (preloadVnfListBuilder.build(),true,LogicalDatastoreType.CONFIGURATION);
2018             } catch (Exception e) {
2019                 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2020
2021             }
2022             log.debug("Sending Success rpc result due to external error");
2023             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2024                 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2025             return Futures.immediateFuture(rpcResult);
2026         }
2027
2028         // Got success from SLI
2029         try {
2030             preloadData = preloadDataBuilder.build();
2031             log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + preloadData);
2032             // svc-configuration-list
2033             VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2034             preloadVnfListBuilder.setVnfName(preload_name);
2035             preloadVnfListBuilder.setVnfType(preload_type);
2036             preloadVnfListBuilder.setPreloadData(preloadData);
2037
2038             // merge flag sets to false to allow it to be overwritten (not appended)
2039             SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2040             log.info("Updating OPERATIONAL tree.");
2041             SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2042         } catch (Exception e) {
2043             log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2044             responseBuilder.setResponseCode("500");
2045             responseBuilder.setResponseMessage(e.toString());
2046             responseBuilder.setAckFinalIndicator("Y");
2047             log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2048             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2049                 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2050             return Futures.immediateFuture(rpcResult);
2051         }
2052
2053         // Update succeeded
2054         responseBuilder.setResponseCode(errorCode);
2055         responseBuilder.setAckFinalIndicator(ackFinal);
2056         if (errorMessage != null)
2057         {
2058             responseBuilder.setResponseMessage(errorMessage);
2059         }
2060         log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
2061         log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2062
2063         RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2064                 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2065         return Futures.immediateFuture(rpcResult);
2066     }
2067 }