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