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

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