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                                         || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create)) {
1231                                         log.info("Updating OPERATIONAL tree.");
1232                                         saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1233                                 }
1234                         }
1235
1236                         NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1237                         networkResponseInformationBuilder.setInstanceId(networkId);
1238                         networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1239                         responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1240
1241                         ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1242                         serviceResponseInformationBuilder.setInstanceId(siid);
1243                         serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1244                         responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1245
1246                 } catch (IllegalStateException e) {
1247                         log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1248                         responseBuilder.setResponseCode("500");
1249                         responseBuilder.setResponseMessage(e.toString());
1250                         responseBuilder.setAckFinalIndicator("Y");
1251                         log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1252                         RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1253                                         .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1254                         return Futures.immediateFuture(rpcResult);
1255                 }
1256
1257                 // Update succeeded
1258                 responseBuilder.setResponseCode(errorCode);
1259                 responseBuilder.setAckFinalIndicator(ackFinal);
1260                 if (errorMessage != null) {
1261                         responseBuilder.setResponseMessage(errorMessage);
1262                 }
1263                 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1264                 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1265
1266                 RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1267                                 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1268                 return Futures.immediateFuture(rpcResult);
1269         }
1270
1271         @Override
1272         public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1273                         ContrailRouteTopologyOperationInput input) {
1274
1275                 final String SVC_OPERATION = "contrail-route-topology-operation";
1276                 ServiceData serviceData;
1277                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1278                 Properties parms = new Properties();
1279
1280                 log.info("{} called.", SVC_OPERATION);
1281                 // create a new response object
1282                 ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1283
1284                 if (input == null || input.getServiceInformation() == null
1285                                 || input.getServiceInformation().getServiceInstanceId() == null
1286                                 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1287                         log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1288                         responseBuilder.setResponseCode("404");
1289                         responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1290                         responseBuilder.setAckFinalIndicator("Y");
1291                         RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1292                                         .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1293                         return Futures.immediateFuture(rpcResult);
1294                 }
1295
1296                 String siid = input.getServiceInformation().getServiceInstanceId();
1297
1298                 // Get the service-instance service data from MD-SAL
1299                 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1300                 getServiceData(siid, serviceDataBuilder);
1301
1302                 if (input.getSdncRequestHeader() != null) {
1303                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1304                 }
1305
1306                 ServiceData sd = serviceDataBuilder.build();
1307                 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1308                         log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1309                         responseBuilder.setResponseCode("404");
1310                         responseBuilder
1311                                         .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1312                         responseBuilder.setAckFinalIndicator("Y");
1313                         RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1314                                         .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1315                         return Futures.immediateFuture(rpcResult);
1316                 }
1317
1318                 log.info("Adding INPUT data for " + SVC_OPERATION + " [" + siid + "] input: " + input);
1319                 ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1320                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1321
1322                 // Call SLI sync method
1323                 // Get SvcLogicService reference
1324
1325                 Properties respProps = null;
1326
1327                 String errorCode = "200";
1328                 String errorMessage = null;
1329                 String ackFinal = "Y";
1330                 String allottedResourceId = "error";
1331                 String serviceObjectPath = null;
1332                 String contrailRouteObjectPath = null;
1333
1334                 try {
1335                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1336
1337                                 try {
1338                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1339                                 } catch (Exception e) {
1340                                         log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1341                                         errorMessage = e.getMessage();
1342                                         errorCode = "500";
1343                                 }
1344                         } else {
1345                                 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1346                                 errorCode = "503";
1347                         }
1348                 } catch (Exception e) {
1349                         errorCode = "500";
1350                         errorMessage = e.getMessage();
1351                         log.error("Caught exception looking for service logic", e);
1352                 }
1353
1354                 if (respProps != null) {
1355                         errorCode = respProps.getProperty("error-code");
1356                         errorMessage = respProps.getProperty("error-message");
1357                         ackFinal = respProps.getProperty("ack-final", "Y");
1358                         allottedResourceId = respProps.getProperty("allotted-resource-id");
1359                         serviceObjectPath = respProps.getProperty("service-object-path");
1360                         contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1361                 }
1362
1363                 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1364                         responseBuilder.setResponseCode(errorCode);
1365                         responseBuilder.setResponseMessage(errorMessage);
1366                         responseBuilder.setAckFinalIndicator(ackFinal);
1367
1368                         log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1369
1370                         RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1371                                         .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1372                         return Futures.immediateFuture(rpcResult);
1373                 }
1374
1375                 // Got success from SLI
1376                 try {
1377
1378                         serviceData = serviceDataBuilder.build();
1379                         log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1380
1381                         // service object
1382                         ServiceBuilder serviceBuilder = new ServiceBuilder();
1383                         serviceBuilder.setServiceData(serviceData);
1384                         serviceBuilder.setServiceInstanceId(siid);
1385                         serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1386                         saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1387
1388                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1389                                 // Only update operational tree on activate or delete
1390                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1391                                                 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1392                                         log.info("Updating OPERATIONAL tree.");
1393                                         saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1394                                 }
1395                         }
1396
1397                         ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1398                         contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1399                         contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1400                         responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1401
1402                         ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1403                         serviceResponseInformationBuilder.setInstanceId(siid);
1404                         serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1405                         responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1406
1407                 } catch (IllegalStateException e) {
1408                         log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1409                         responseBuilder.setResponseCode("500");
1410                         responseBuilder.setResponseMessage(e.toString());
1411                         responseBuilder.setAckFinalIndicator("Y");
1412                         log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1413                         RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1414                                         .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1415                         return Futures.immediateFuture(rpcResult);
1416                 }
1417
1418                 // Update succeeded
1419                 responseBuilder.setResponseCode(errorCode);
1420                 responseBuilder.setAckFinalIndicator(ackFinal);
1421                 if (errorMessage != null) {
1422                         responseBuilder.setResponseMessage(errorMessage);
1423                 }
1424                 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1425                 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1426
1427                 RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1428                                 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1429                 return Futures.immediateFuture(rpcResult);
1430         }
1431
1432         @Override
1433         public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1434                         SecurityZoneTopologyOperationInput input) {
1435
1436                 final String SVC_OPERATION = "security-zone-topology-operation";
1437                 ServiceData serviceData;
1438                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1439                 Properties parms = new Properties();
1440
1441                 log.info("{} called.", SVC_OPERATION);
1442                 // create a new response object
1443                 SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1444
1445                 if (input == null || input.getServiceInformation() == null
1446                                 || input.getServiceInformation().getServiceInstanceId() == null
1447                                 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1448                         log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1449                         responseBuilder.setResponseCode("404");
1450                         responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1451                         responseBuilder.setAckFinalIndicator("Y");
1452                         RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1453                                         .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1454                         return Futures.immediateFuture(rpcResult);
1455                 }
1456
1457                 String siid = input.getServiceInformation().getServiceInstanceId();
1458
1459                 // Get the service-instance service data from MD-SAL
1460                 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1461                 getServiceData(siid, serviceDataBuilder);
1462
1463                 if (input.getSdncRequestHeader() != null) {
1464                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1465                 }
1466
1467                 ServiceData sd = serviceDataBuilder.build();
1468                 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1469                         log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1470                         responseBuilder.setResponseCode("404");
1471                         responseBuilder
1472                                         .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1473                         responseBuilder.setAckFinalIndicator("Y");
1474                         RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1475                                         .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1476                         return Futures.immediateFuture(rpcResult);
1477                 }
1478
1479                 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1480                 SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1481                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1482
1483                 // Call SLI sync method
1484                 // Get SvcLogicService reference
1485
1486                 Properties respProps = null;
1487
1488                 String errorCode = "200";
1489                 String errorMessage = null;
1490                 String ackFinal = "Y";
1491                 String allottedResourceId = "error";
1492                 String serviceObjectPath = null;
1493                 String securityZoneObjectPath = null;
1494
1495                 try {
1496                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1497
1498                                 try {
1499                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1500                                 } catch (Exception e) {
1501                                         log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1502                                         errorMessage = e.getMessage();
1503                                         errorCode = "500";
1504                                 }
1505                         } else {
1506                                 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1507                                 errorCode = "503";
1508                         }
1509                 } catch (Exception e) {
1510                         errorCode = "500";
1511                         errorMessage = e.getMessage();
1512                         log.error("Caught exception looking for service logic", e);
1513                 }
1514
1515                 if (respProps != null) {
1516                         errorCode = respProps.getProperty("error-code");
1517                         errorMessage = respProps.getProperty("error-message");
1518                         ackFinal = respProps.getProperty("ack-final", "Y");
1519                         allottedResourceId = respProps.getProperty("allotted-resource-id");
1520                         serviceObjectPath = respProps.getProperty("service-object-path");
1521                         securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1522                 }
1523
1524                 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1525                         responseBuilder.setResponseCode(errorCode);
1526                         responseBuilder.setResponseMessage(errorMessage);
1527                         responseBuilder.setAckFinalIndicator(ackFinal);
1528
1529                         log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1530
1531                         RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1532                                         .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1533                         return Futures.immediateFuture(rpcResult);
1534                 }
1535
1536                 // Got success from SLI
1537                 try {
1538
1539                         serviceData = serviceDataBuilder.build();
1540                         log.info("Updating MD-SAL for {} [{}] ServiceData: {}", SVC_OPERATION, siid, serviceData);
1541
1542                         // service object
1543                         ServiceBuilder serviceBuilder = new ServiceBuilder();
1544                         serviceBuilder.setServiceData(serviceData);
1545                         serviceBuilder.setServiceInstanceId(siid);
1546                         serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1547                         saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1548
1549                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1550                                 // Only update operational tree on activate or delete
1551                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1552                                                 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1553                                         log.info("Updating OPERATIONAL tree.");
1554                                         saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1555                                 }
1556                         }
1557
1558                         SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1559                         securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1560                         securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1561                         responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1562
1563                         ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1564                         serviceResponseInformationBuilder.setInstanceId(siid);
1565                         serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1566                         responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1567
1568                 } catch (IllegalStateException e) {
1569                         log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1570                         responseBuilder.setResponseCode("500");
1571                         responseBuilder.setResponseMessage(e.toString());
1572                         responseBuilder.setAckFinalIndicator("Y");
1573                         log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1574                         RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1575                                         .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1576                         return Futures.immediateFuture(rpcResult);
1577                 }
1578
1579                 // Update succeeded
1580                 responseBuilder.setResponseCode(errorCode);
1581                 responseBuilder.setAckFinalIndicator(ackFinal);
1582                 if (errorMessage != null) {
1583                         responseBuilder.setResponseMessage(errorMessage);
1584                 }
1585                 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1586                 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1587
1588                 RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1589                                 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1590                 return Futures.immediateFuture(rpcResult);
1591         }
1592
1593         @Override
1594         public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1595                         TunnelxconnTopologyOperationInput input) {
1596
1597                 final String SVC_OPERATION = "tunnelxconn-topology-operation";
1598                 ServiceData serviceData;
1599                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1600                 Properties parms = new Properties();
1601
1602                 log.info("{} called.", SVC_OPERATION);
1603                 // create a new response object
1604                 TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1605
1606                 if (input == null || input.getServiceInformation() == null
1607                                 || input.getServiceInformation().getServiceInstanceId() == null
1608                                 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1609                         log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1610                         responseBuilder.setResponseCode("404");
1611                         responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1612                         responseBuilder.setAckFinalIndicator("Y");
1613                         RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1614                                         .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1615                         return Futures.immediateFuture(rpcResult);
1616                 }
1617
1618                 String siid = input.getServiceInformation().getServiceInstanceId();
1619 /*
1620                 // Get the service-instance service data from MD-SAL
1621                 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1622                 getServiceData(siid, serviceDataBuilder);
1623
1624                 if (input.getSdncRequestHeader() != null) {
1625                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1626                 }
1627
1628                 ServiceData sd = serviceDataBuilder.build();
1629                 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1630                         log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1631                         responseBuilder.setResponseCode("404");
1632                         responseBuilder
1633                                         .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1634                         responseBuilder.setAckFinalIndicator("Y");
1635                         RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1636                                         .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1637                         return Futures.immediateFuture(rpcResult);
1638                 }*/
1639
1640                 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1641                 TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1642                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1643
1644                 // Call SLI sync method
1645                 // Get SvcLogicService reference
1646
1647                 Properties respProps = null;
1648
1649                 String errorCode = "200";
1650                 String errorMessage = null;
1651                 String ackFinal = "Y";
1652                 String allottedResourceId = "error";
1653                 String serviceObjectPath = null;
1654                 String tunnelxconnObjectPath = null;
1655
1656                 try {
1657                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1658
1659                                 try {
1660                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync",  parms);
1661                                 } catch (Exception e) {
1662                                         log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1663                                         errorMessage = e.getMessage();
1664                                         errorCode = "500";
1665                                 }
1666                         } else {
1667                                 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1668                                 errorCode = "503";
1669                         }
1670                 } catch (Exception e) {
1671                         errorCode = "500";
1672                         errorMessage = e.getMessage();
1673                         log.error("Caught exception looking for service logic", e);
1674                 }
1675
1676                 if (respProps != null) {
1677                         errorCode = respProps.getProperty("error-code");
1678                         errorMessage = respProps.getProperty("error-message");
1679                         ackFinal = respProps.getProperty("ack-final", "Y");
1680                         allottedResourceId = respProps.getProperty("allotted-resource-id");
1681                         serviceObjectPath = respProps.getProperty("service-object-path");
1682                         tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1683                 }
1684
1685                 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1686                         responseBuilder.setResponseCode(errorCode);
1687                         responseBuilder.setResponseMessage(errorMessage);
1688                         responseBuilder.setAckFinalIndicator(ackFinal);
1689
1690                         log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1691
1692                         RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1693                                         .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1694                         return Futures.immediateFuture(rpcResult);
1695                 }
1696
1697                 // Got success from SLI
1698                 try {
1699
1700
1701
1702                         TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1703                         tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1704                         tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1705                         responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1706
1707                         ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1708                         serviceResponseInformationBuilder.setInstanceId(siid);
1709                         serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1710                         responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1711
1712                 } catch (IllegalStateException e) {
1713                         log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1714                         responseBuilder.setResponseCode("500");
1715                         responseBuilder.setResponseMessage(e.toString());
1716                         responseBuilder.setAckFinalIndicator("Y");
1717                         log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1718                         RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1719                                         .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1720                         return Futures.immediateFuture(rpcResult);
1721                 }
1722
1723                 // Update succeeded
1724                 responseBuilder.setResponseCode(errorCode);
1725                 responseBuilder.setAckFinalIndicator(ackFinal);
1726                 if (errorMessage != null) {
1727                         responseBuilder.setResponseMessage(errorMessage);
1728                 }
1729                 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1730                 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1731
1732                 RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1733                                 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1734                 return Futures.immediateFuture(rpcResult);
1735         }
1736
1737         @Override
1738         public Future<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
1739                 final String SVC_OPERATION = "brg-topology-operation";
1740                 ServiceData serviceData;
1741                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1742                 Properties parms = new Properties();
1743
1744                 log.info("{} called.", SVC_OPERATION);
1745                 // create a new response object
1746                 BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
1747
1748                 if (input == null || input.getServiceInformation() == null
1749                                 || input.getServiceInformation().getServiceInstanceId() == null
1750                                 || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1751                         log.debug("exiting {} because of null or empty service-instance-id", SVC_OPERATION);
1752                         responseBuilder.setResponseCode("404");
1753                         responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1754                         responseBuilder.setAckFinalIndicator("Y");
1755                         RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1756                                         .withResult(responseBuilder.build()).build();
1757                         return Futures.immediateFuture(rpcResult);
1758                 }
1759
1760                 String siid = input.getServiceInformation().getServiceInstanceId();
1761
1762 /*              // Get the service-instance service data from MD-SAL
1763                 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1764                 getServiceData(siid, serviceDataBuilder);
1765
1766                 if (input.getSdncRequestHeader() != null) {
1767                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1768                 }
1769
1770                 ServiceData sd = serviceDataBuilder.build();
1771                 if (sd == null || sd.getServiceLevelOperStatus() == null) {
1772                         log.debug("exiting {} because the service-instance does not have any service data in SDNC", SVC_OPERATION);
1773                         responseBuilder.setResponseCode("404");
1774                         responseBuilder
1775                                         .setResponseMessage("invalid input: the service-instance does not have any service data in SDNC");
1776                         responseBuilder.setAckFinalIndicator("Y");
1777                         RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1778                                         .withResult(responseBuilder.build()).build();
1779                         return Futures.immediateFuture(rpcResult);
1780                 }*/
1781
1782                 log.info("Adding INPUT data for {} [{}] input: {}", SVC_OPERATION, siid, input);
1783                 BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
1784                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1785
1786                 // Call SLI sync method
1787                 // Get SvcLogicService reference
1788
1789                 Properties respProps = null;
1790
1791                 String errorCode = "200";
1792                 String errorMessage = null;
1793                 String ackFinal = "Y";
1794                 String allottedResourceId = "error";
1795                 String serviceObjectPath = null;
1796                 String brgObjectPath = null;
1797
1798                 try {
1799                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1800
1801                                 try {
1802                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", parms);
1803                                 } catch (Exception e) {
1804                                         log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1805                                         errorMessage = e.getMessage();
1806                                         errorCode = "500";
1807                                 }
1808                         } else {
1809                                 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1810                                 errorCode = "503";
1811                         }
1812                 } catch (Exception e) {
1813                         errorCode = "500";
1814                         errorMessage = e.getMessage();
1815                         log.error("Caught exception looking for service logic", e);
1816                 }
1817
1818                 if (respProps != null) {
1819                         errorCode = respProps.getProperty("error-code");
1820                         errorMessage = respProps.getProperty("error-message");
1821                         ackFinal = respProps.getProperty("ack-final", "Y");
1822                         allottedResourceId = respProps.getProperty("allotted-resource-id");
1823                         serviceObjectPath = respProps.getProperty("service-object-path");
1824                         brgObjectPath = respProps.getProperty("brg-object-path");
1825                 }
1826
1827                 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1828                         responseBuilder.setResponseCode(errorCode);
1829                         responseBuilder.setResponseMessage(errorMessage);
1830                         responseBuilder.setAckFinalIndicator(ackFinal);
1831
1832                         log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1833
1834                         RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1835                                         .withResult(responseBuilder.build()).build();
1836                         return Futures.immediateFuture(rpcResult);
1837                 }
1838
1839                 // Got success from SLI
1840                 try {
1841
1842
1843                         BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
1844                         brgResponseInformationBuilder.setInstanceId(allottedResourceId);
1845                         brgResponseInformationBuilder.setObjectPath(brgObjectPath);
1846                         responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
1847
1848                         ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1849                         serviceResponseInformationBuilder.setInstanceId(siid);
1850                         serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1851                         responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1852
1853                 } catch (IllegalStateException e) {
1854                         log.error("Caught Exception updating MD-SAL for {} [{}] \n", SVC_OPERATION, siid, e);
1855                         responseBuilder.setResponseCode("500");
1856                         responseBuilder.setResponseMessage(e.toString());
1857                         responseBuilder.setAckFinalIndicator("Y");
1858                         log.error("Returned FAILED for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1859                         RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1860                                         .withResult(responseBuilder.build()).build();
1861                         return Futures.immediateFuture(rpcResult);
1862                 }
1863
1864                 // Update succeeded
1865                 responseBuilder.setResponseCode(errorCode);
1866                 responseBuilder.setAckFinalIndicator(ackFinal);
1867                 if (errorMessage != null) {
1868                         responseBuilder.setResponseMessage(errorMessage);
1869                 }
1870                 log.info("Updated MD-SAL for {} [{}]", SVC_OPERATION, siid);
1871                 log.info("Returned SUCCESS for {} [{}] {}", SVC_OPERATION, siid, responseBuilder.build());
1872
1873                 RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
1874                                 .withResult(responseBuilder.build()).build();
1875                 return Futures.immediateFuture(rpcResult);
1876         }
1877
1878         @Override
1879         public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1880                         PreloadVnfTopologyOperationInput input) {
1881
1882                 final String SVC_OPERATION = "preload-vnf-topology-operation";
1883                 PreloadData preloadData;
1884                 Properties parms = new Properties();
1885
1886                 log.info("{} called.", SVC_OPERATION);
1887                 // create a new response object
1888                 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1889
1890                 // Result from savePreloadData
1891                 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1892
1893                 if (input == null || input.getVnfTopologyInformation() == null
1894                                 || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null) {
1895                         log.debug("exiting {} because of null input", SVC_OPERATION);
1896                         responseBuilder.setResponseCode("403");
1897                         responseBuilder.setResponseMessage("invalid input: input is null");
1898                         responseBuilder.setAckFinalIndicator("Y");
1899                         RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1900                                         .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1901                         return Futures.immediateFuture(rpcResult);
1902                 }
1903
1904                 // Grab the name and type from the input buffer
1905                 String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1906                 String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1907
1908                 // Make sure we have a preload_name and preload_type
1909                 if (preload_name == null || preload_name.length() == 0 || preload_type == null || preload_type.length() == 0) {
1910                         log.debug("exiting {} vnf-name or vnf-type is null or empty", SVC_OPERATION);
1911                         responseBuilder.setResponseCode("403");
1912                         responseBuilder.setResponseMessage("invalid input: vnf-name or vnf-type is null or empty");
1913                         responseBuilder.setAckFinalIndicator("Y");
1914                         RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
1915                                         .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1916                         return Futures.immediateFuture(rpcResult);
1917                 }
1918
1919                 if (input.getSdncRequestHeader() != null) {
1920                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1921                 }
1922
1923                 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1924                 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1925
1926                 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1927                 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1928
1929                 // setup a preload-data object builder
1930                 // ACTION preload-vnf-topology-operation
1931                 // INPUT:
1932                 // USES sdnc-request-header;
1933                 // USES request-information;
1934                 // uses vnf-topology-information;
1935                 // OUTPUT:
1936                 // USES vnf-topology-response-body;
1937                 //
1938                 // container preload-data
1939                 // uses vnf-topology-information;
1940                 // uses network-topology-information;
1941                 // uses oper-status;
1942
1943                 log.info("Adding INPUT data for {} [{},{}] input: {}", SVC_OPERATION, preload_name, preload_type, input);
1944                 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1945                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1946                 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", SVC_OPERATION, preload_name,
1947                                 preload_type, operDataBuilder.build());
1948                 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
1949
1950                 // Call SLI sync method
1951                 // Get SvcLogicService reference
1952
1953                 Properties respProps = null;
1954
1955                 String errorCode = "200";
1956                 String errorMessage = null;
1957                 String ackFinal = "Y";
1958
1959                 try {
1960                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
1961
1962                                 try {
1963                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1964                                 } catch (Exception e) {
1965                                         log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
1966                                         errorMessage = e.getMessage();
1967                                         errorCode = "500";
1968                                 }
1969                         } else {
1970                                 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
1971                                 errorCode = "503";
1972                         }
1973                 } catch (Exception e) {
1974                         errorCode = "500";
1975                         errorMessage = e.getMessage();
1976                         log.error("Caught exception looking for service logic", e);
1977                 }
1978
1979                 if (respProps != null) {
1980                         errorCode = respProps.getProperty("error-code");
1981                         errorMessage = respProps.getProperty("error-message");
1982                         ackFinal = respProps.getProperty("ack-final", "Y");
1983                         // internalError = respProps.getProperty("internal-error", "false");
1984                 }
1985
1986                 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
1987
1988                         responseBuilder.setResponseCode(errorCode);
1989                         responseBuilder.setResponseMessage(errorMessage);
1990                         responseBuilder.setAckFinalIndicator(ackFinal);
1991
1992                         VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1993                         preloadVnfListBuilder.setVnfName(preload_name);
1994                         preloadVnfListBuilder.setVnfType(preload_type);
1995                         preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1996                         log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", SVC_OPERATION, preload_name,
1997                                         preload_type, errorCode, errorMessage);
1998                         try {
1999                                 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2000                         } catch (Exception e) {
2001                                 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n", SVC_OPERATION, preload_name,
2002                                                 preload_type, e);
2003                         }
2004                         log.debug("Sending Success rpc result due to external error");
2005                         RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2006                                         .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2007                         return Futures.immediateFuture(rpcResult);
2008                 }
2009
2010                 // Got success from SLI
2011                 try {
2012                         preloadData = preloadDataBuilder.build();
2013                         log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", SVC_OPERATION, preload_name, preload_type,
2014                                         preloadData);
2015                         // svc-configuration-list
2016                         VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2017                         preloadVnfListBuilder.setVnfName(preload_name);
2018                         preloadVnfListBuilder.setVnfType(preload_type);
2019                         preloadVnfListBuilder.setPreloadData(preloadData);
2020
2021                         // merge flag sets to false to allow it to be overwritten (not appended)
2022                         savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2023                         log.info("Updating OPERATIONAL tree.");
2024                         savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2025                 } catch (Exception e) {
2026                         log.error("Caught Exception updating MD-SAL for {} [{},{}] \n", SVC_OPERATION, preload_name, preload_type,
2027                                         e);
2028                         responseBuilder.setResponseCode("500");
2029                         responseBuilder.setResponseMessage(e.toString());
2030                         responseBuilder.setAckFinalIndicator("Y");
2031                         log.error("Returned FAILED for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2032                                         responseBuilder.build());
2033                         RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2034                                         .<PreloadVnfTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
2035                         return Futures.immediateFuture(rpcResult);
2036                 }
2037
2038                 // Update succeeded
2039                 responseBuilder.setResponseCode(errorCode);
2040                 responseBuilder.setAckFinalIndicator(ackFinal);
2041                 if (errorMessage != null) {
2042                         responseBuilder.setResponseMessage(errorMessage);
2043                 }
2044                 log.info("Updated MD-SAL for {} [{},{}]", SVC_OPERATION, preload_name, preload_type);
2045                 log.info("Returned SUCCESS for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2046                                 responseBuilder.build());
2047
2048                 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2049                                 .<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2050                 return Futures.immediateFuture(rpcResult);
2051         }
2052
2053         @Override
2054         public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2055                         PreloadNetworkTopologyOperationInput input) {
2056
2057                 final String SVC_OPERATION = "preload-network-topology-operation";
2058                 PreloadData preloadData;
2059                 Properties parms = new Properties();
2060
2061                 log.info("{} called.", SVC_OPERATION);
2062                 // create a new response object
2063                 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2064
2065                 // Result from savePreloadData
2066                 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2067
2068                 if (input == null || input.getNetworkTopologyInformation() == null
2069                                 || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null) {
2070
2071                         log.debug("exiting {} because of null input", SVC_OPERATION);
2072                         responseBuilder.setResponseCode("403");
2073                         responseBuilder.setResponseMessage("input is null");
2074                         responseBuilder.setAckFinalIndicator("Y");
2075                         RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2076                                         .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2077                         return Futures.immediateFuture(rpcResult);
2078                 }
2079
2080                 // Grab the name and type from the input buffer
2081                 String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2082                 String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2083
2084                 // Make sure we have a preload_name and preload_type
2085                 if (preload_name == null || preload_name.length() == 0 || preload_type == null || preload_type.length() == 0) {
2086                         log.debug("exiting {} because of invalid preload-name", SVC_OPERATION);
2087                         responseBuilder.setResponseCode("403");
2088                         responseBuilder.setResponseMessage("input, invalid preload-name");
2089                         responseBuilder.setAckFinalIndicator("Y");
2090                         RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2091                                         .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2092                         return Futures.immediateFuture(rpcResult);
2093                 }
2094
2095                 if (input.getSdncRequestHeader() != null) {
2096                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2097                 }
2098
2099                 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2100                 getPreloadData(preload_name, preload_type, preloadDataBuilder);
2101
2102                 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2103                 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2104
2105                 //
2106                 // setup a preload-data object builder
2107                 // ACTION preload-network-topology-operation
2108                 // INPUT:
2109                 // USES sdnc-request-header;
2110                 // USES request-information;
2111                 // uses network-topology-information;
2112                 // OUTPUT:
2113                 // USES vnf-topology-response-body;
2114                 //
2115                 // container preload-data
2116                 // uses vnf-topology-information;
2117                 // uses network-topology-information;
2118                 // uses oper-status;
2119
2120                 log.info("Adding INPUT data for {} [{},{}] input: {}", SVC_OPERATION, preload_name, preload_type, input);
2121                 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2122                                 input);
2123                 GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2124                 log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", SVC_OPERATION, preload_name,
2125                                 preload_type, operDataBuilder.build());
2126                 GenericResourceApiUtil.toProperties(parms, "operational-data", operDataBuilder);
2127
2128                 // Call SLI sync method
2129                 // Get SvcLogicService reference
2130
2131                 Properties respProps = null;
2132
2133                 String errorCode = "200";
2134                 String errorMessage = null;
2135                 String ackFinal = "Y";
2136
2137                 try {
2138                         if (svcLogicClient.hasGraph(appName, SVC_OPERATION, null, "sync")) {
2139
2140                                 try {
2141                                         respProps = svcLogicClient.execute(appName, SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2142                                 } catch (Exception e) {
2143                                         log.error("Caught exception executing service logic for {}", SVC_OPERATION, e);
2144                                         errorMessage = e.getMessage();
2145                                         errorCode = "500";
2146                                 }
2147                         } else {
2148                                 errorMessage = "No service logic active for " + appName + ": '" + SVC_OPERATION + "'";
2149                                 errorCode = "503";
2150                         }
2151                 } catch (Exception e) {
2152                         errorCode = "500";
2153                         errorMessage = e.getMessage();
2154                         log.error("Caught exception looking for service logic", e);
2155                 }
2156
2157                 if (respProps != null) {
2158                         errorCode = respProps.getProperty("error-code");
2159                         errorMessage = respProps.getProperty("error-message");
2160                         ackFinal = respProps.getProperty("ack-final", "Y");
2161                         // internalError = respProps.getProperty("internal-error", "false");
2162                 }
2163
2164                 if (errorCode != null && errorCode.length() != 0 && !(errorCode.equals("0") || errorCode.equals("200"))) {
2165
2166                         responseBuilder.setResponseCode(errorCode);
2167                         responseBuilder.setResponseMessage(errorMessage);
2168                         responseBuilder.setAckFinalIndicator(ackFinal);
2169
2170                         VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2171                         preloadVnfListBuilder.setVnfName(preload_name);
2172                         preloadVnfListBuilder.setVnfType(preload_type);
2173                         preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2174                         log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", SVC_OPERATION, preload_name,
2175                                         preload_type, errorCode, errorMessage);
2176                         try {
2177                                 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2178                         } catch (Exception e) {
2179                                 log.error("Caught Exception updating MD-SAL for {} [{},{}] \n", SVC_OPERATION, preload_name,
2180                                                 preload_type, e);
2181
2182                         }
2183                         log.debug("Sending Success rpc result due to external error");
2184                         RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2185                                         .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2186                         return Futures.immediateFuture(rpcResult);
2187                 }
2188
2189                 // Got success from SLI
2190                 try {
2191                         preloadData = preloadDataBuilder.build();
2192                         log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", SVC_OPERATION, preload_name, preload_type,
2193                                         preloadData);
2194                         // svc-configuration-list
2195                         VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2196                         preloadVnfListBuilder.setVnfName(preload_name);
2197                         preloadVnfListBuilder.setVnfType(preload_type);
2198                         preloadVnfListBuilder.setPreloadData(preloadData);
2199
2200                         // merge flag sets to false to allow it to be overwritten (not appended)
2201                         savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2202                         log.info("Updating OPERATIONAL tree.");
2203                         savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2204                 } catch (Exception e) {
2205                         log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2206                                         + "] \n", e);
2207                         responseBuilder.setResponseCode("500");
2208                         responseBuilder.setResponseMessage(e.toString());
2209                         responseBuilder.setAckFinalIndicator("Y");
2210                         log.error("Returned FAILED for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2211                                         responseBuilder.build());
2212                         RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2213                                         .<PreloadNetworkTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
2214                         return Futures.immediateFuture(rpcResult);
2215                 }
2216
2217                 // Update succeeded
2218                 responseBuilder.setResponseCode(errorCode);
2219                 responseBuilder.setAckFinalIndicator(ackFinal);
2220                 if (errorMessage != null) {
2221                         responseBuilder.setResponseMessage(errorMessage);
2222                 }
2223                 log.info("Updated MD-SAL for {} [{},{}]", SVC_OPERATION, preload_name, preload_type);
2224                 log.info("Returned SUCCESS for {} [{},{}] {}", SVC_OPERATION, preload_name, preload_type,
2225                                 responseBuilder.build());
2226
2227                 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2228                                 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2229                 return Futures.immediateFuture(rpcResult);
2230         }
2231
2232 }