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