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