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