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

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