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.Optional;
   7 import java.util.Properties;
   8 import java.util.TimeZone;
   9 import java.util.concurrent.ExecutionException;
  10 import java.util.concurrent.ExecutorService;
  11 import java.util.concurrent.Executors;
  12
  13 import com.google.common.util.concurrent.FluentFuture;
  14 import com.google.common.util.concurrent.Futures;
  15 import com.google.common.util.concurrent.ListenableFuture;
  16
  17 import org.eclipse.jdt.annotation.NonNull;
  18 import org.opendaylight.mdsal.binding.api.DataBroker;
  19 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
  20 import org.opendaylight.mdsal.binding.api.ReadTransaction;
  21 import org.opendaylight.mdsal.binding.api.RpcProviderService;
  22 import org.opendaylight.mdsal.binding.api.WriteTransaction;
  23 import org.opendaylight.mdsal.common.api.CommitInfo;
  24 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  25 import org.opendaylight.mdsal.common.api.OptimisticLockFailedException;
  26 import org.opendaylight.mdsal.common.api.TransactionCommitFailedException;
  27 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.*;
  28 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.brg.response.information.BrgResponseInformationBuilder;
  29 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.connection.attachment.response.information.ConnectionAttachmentResponseInformationBuilder;
  30 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.contrail.route.response.information.ContrailRouteResponseInformationBuilder;
  31 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.gc.response.information.GcResponseInformationBuilder;
  32 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.network.response.information.NetworkResponseInformationBuilder;
  33 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.pnf.response.information.PnfResponseInformationBuilder;
  34 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.port.mirror.response.information.PortMirrorResponseInformationBuilder;
  35 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadData;
  36 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadDataBuilder;
  37 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.PreloadList;
  38 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.PreloadListBuilder;
  39 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.PreloadListKey;
  40 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.request.information.RequestInformation;
  41 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader;
  42 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader.SvcAction;
  43 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.security.zone.response.information.SecurityZoneResponseInformationBuilder;
  44 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceData;
  45 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceDataBuilder;
  46 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.Service;
  47 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceBuilder;
  48 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceKey;
  49 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.response.information.ServiceResponseInformationBuilder;
  50 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RequestStatus;
  51 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RpcAction;
  52 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatusBuilder;
  53 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.tunnelxconn.response.information.TunnelxconnResponseInformationBuilder;
  54 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.vf.module.response.information.VfModuleResponseInformationBuilder;
  55 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.vnf.response.information.VnfResponseInformationBuilder;
  56 import org.opendaylight.yangtools.concepts.ObjectRegistration;
  57 import org.opendaylight.yangtools.yang.binding.DataObject;
  58 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  59 import org.opendaylight.yangtools.yang.common.RpcResult;
  60 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  61 import org.slf4j.Logger;
  62 import org.slf4j.LoggerFactory;
  63
  64 /**
  65  * Defines a base implementation for your provider. This class extends from a helper class which provides storage for
  66  * the most commonly used components of the MD-SAL. Additionally the base class provides some basic logging and
  67  * initialization / clean up methods.
  68  *
  69  * To use this, copy and paste (overwrite) the following method into the TestApplicationProviderModule class which is
  70  * auto generated under src/main/java in this project (created only once during first compilation):
  71  *
  72  * <pre>
  73  *
  74  * &#64;Override
  75  * public java.lang.AutoCloseable createInstance() {
  76  *
  77  *     // final GENERIC-RESOURCE-APIProvider provider = new
  78  *     // GENERIC-RESOURCE-APIProvider();
  79  *     final GenericResourceApiProvider provider = new GenericResourceApiProvider();
  80  *     provider.setDataBroker(getDataBrokerDependency());
  81  *     provider.setNotificationService(getNotificationServiceDependency());
  82  *     provider.setRpcService(getRpcServiceDependency());
  83  *     provider.initialize();
  84  *     return new AutoCloseable() {
  85  *
  86  *         &#64;Override
  87  *         public void close() throws Exception {
  88  *             // TODO: CLOSE ANY REGISTRATION OBJECTS CREATED USING ABOVE
  89  *             // BROKER/NOTIFICATION
  90  *             // SERVIE/RPC REGISTRY
  91  *             provider.close();
  92  *         }
  93  *     };
  94  * }
  95  *
  96  * </pre>
  97  */
  98
  99 public class GenericResourceApiProvider implements AutoCloseable, GENERICRESOURCEAPIService {
 100
 101     protected static final String APP_NAME = "generic-resource-api";
 102     private static final String CALLED_STR = "{} called.";
 103     private static final String NULL_OR_EMPTY_ERROR_MESSAGE = "exiting {} because of null or empty service-instance-id";
 104     protected static final String NULL_OR_EMPTY_ERROR_PARAM = "invalid input, null or empty service-instance-id";
 105     private static final String ADDING_INPUT_DATA_LOG = "Adding INPUT data for {} [{}] input: {}";
 106     private static final String ADDING_OPERATIONAL_DATA_LOG = "Adding OPERATIONAL data for {} [{}] operational-data: {}";
 107     private static final String OPERATIONAL_DATA_PARAM = "operational-data";
 108     protected static final String NO_SERVICE_LOGIC_ACTIVE = "No service logic active for ";
 109     private static final String SERVICE_LOGIC_SEARCH_ERROR_MESSAGE = "Caught exception looking for service logic";
 110     private static final String ERROR_CODE_PARAM = "error-code";
 111     private static final String ERROR_MESSAGE_PARAM = "error-message";
 112     private static final String ACK_FINAL_PARAM = "ack-final";
 113     private static final String SERVICE_OBJECT_PATH_PARAM = "service-object-path";
 114     private static final String NETWORK_OBJECT_PATH_PARAM = "network-object-path";
 115     private static final String VNF_OBJECT_PATH_PARAM = "vnf-object-path";
 116     private static final String PNF_OBJECT_PATH_PARAM = "pnf-object-path";
 117     private static final String VF_MODULE_OBJECT_PATH_PARAM = "vf-module-object-path";
 118     private static final String VF_MODULE_ID_PARAM = "vf-module-id";
 119     private static final String UPDATING_MDSAL_ERROR_MESSAGE = "Caught Exception updating MD-SAL for {} [{}] \n";
 120     private static final String UPDATING_MDSAL_ERROR_MESSAGE_2 = "Caught Exception updating MD-SAL for {} [{},{}] \n";
 121     private static final String RETURNED_FAILED_MESSAGE = "Returned FAILED for {} [{}] {}";
 122     private static final String UPDATING_MDSAL_INFO_MESSAGE = "Updating MD-SAL for {} [{}] ServiceData: {}";
 123     private static final String UPDATED_MDSAL_INFO_MESSAGE = "Updated MD-SAL for {} [{}]";
 124     private static final String RETURNED_SUCCESS_MESSAGE = "Returned SUCCESS for {} [{}] {}";
 125     private static final String NON_NULL_PARAM = "non-null";
 126     private static final String NULL_PARAM = "null";
 127     private static final String SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE = "Caught exception executing service logic for {} ";
 128     private static final String UPDATING_TREE_INFO_MESSAGE = "Updating OPERATIONAL tree.";
 129     private static final String EMPTY_SERVICE_INSTANCE_MESSAGE = "exiting {} because the service-instance does not have any service data in SDNC";
 130     protected static final String INVALID_INPUT_ERROR_MESSAGE = "invalid input: the service-instance does not have any service data in SDNC";
 131     private static final String ALLOTTED_RESOURCE_ID_PARAM = "allotted-resource-id";
 132     private static final String ERROR_NETWORK_ID = "error";
 133     private static final String BACKGROUND_THREAD_STARTED_MESSAGE = "Start background thread";
 134     private static final String BACKGROUND_THREAD_INFO = "Background thread: input conf_id is {}";
 135     private static final String SKIP_MDSAL_UPDATE_PROP = "skip-mdsal-update";
 136
 137     private final Logger log = LoggerFactory.getLogger(GenericResourceApiProvider.class);
 138     private final ExecutorService executor;
 139     private final GenericResourceApiSvcLogicServiceClient svcLogicClient;
 140
 141     protected DataBroker dataBroker;
 142     protected NotificationPublishService notificationService;
 143     protected RpcProviderService rpcService;
 144     protected ObjectRegistration<GENERICRESOURCEAPIService> rpcRegistration;
 145
 146     public GenericResourceApiProvider(DataBroker dataBroker, NotificationPublishService notificationPublishService,
 147         RpcProviderService rpcProviderService, GenericResourceApiSvcLogicServiceClient client) {
 148         log.info("Creating provider for {}", APP_NAME);
 149         executor = Executors.newFixedThreadPool(1);
 150         setDataBroker(dataBroker);
 151         setNotificationService(notificationPublishService);
 152         setRpcService(rpcProviderService);
 153         svcLogicClient = client;
 154         initialize();
 155
 156     }
 157
 158     public void initialize() {
 159         log.info("Initializing provider for {}", APP_NAME);
 160         // Create the top level containers
 161         createContainers();
 162         try {
 163             GenericResourceApiUtil.loadProperties();
 164         } catch (Exception e) {
 165             log.error("Caught Exception while trying to load properties file", e);
 166         }
 167
 168         if (rpcRegistration == null) {
 169             if (rpcService != null) {
 170                 rpcRegistration = rpcService.registerRpcImplementation(GENERICRESOURCEAPIService.class, this);
 171             }
 172         }
 173
 174         log.info("Initialization complete for {}", APP_NAME);
 175     }
 176
 177     protected void initializeChild() {
 178         // Override if you have custom initialization intelligence
 179     }
 180
 181     @Override
 182     public void close() throws Exception {
 183         log.info("Closing provider for {}", APP_NAME);
 184         executor.shutdown();
 185         rpcRegistration.close();
 186         log.info("Successfully closed provider for {}", APP_NAME);
 187     }
 188
 189     private static class Iso8601Util {
 190
 191         private static TimeZone timeZone = TimeZone.getTimeZone("UTC");
 192         private static DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
 193
 194         private Iso8601Util() {
 195         }
 196
 197         static {
 198             dateFormat.setTimeZone(timeZone);
 199         }
 200
 201         private static String now() {
 202             return dateFormat.format(new Date());
 203         }
 204     }
 205
 206     public void setDataBroker(DataBroker dataBroker) {
 207         this.dataBroker = dataBroker;
 208         if (log.isDebugEnabled()) {
 209             log.debug("DataBroker set to {}", dataBroker == null ? NULL_PARAM : NON_NULL_PARAM);
 210         }
 211     }
 212
 213     public void setNotificationService(NotificationPublishService notificationService) {
 214         this.notificationService = notificationService;
 215         if (log.isDebugEnabled()) {
 216             log.debug("Notification Service set to {}", notificationService == null ? NULL_PARAM : NON_NULL_PARAM);
 217         }
 218     }
 219
 220     public void setRpcService(RpcProviderService rpcService) {
 221         this.rpcService = rpcService;
 222         if (log.isDebugEnabled()) {
 223             log.debug("rpcService set to {}", rpcService == null ? NULL_PARAM : NON_NULL_PARAM);
 224         }
 225     }
 226
 227     private void createContainers() {
 228
 229         final WriteTransaction configT = dataBroker.newReadWriteTransaction();
 230         final WriteTransaction operT = dataBroker.newReadWriteTransaction();
 231
 232
 233
 234         // Create the service-instance container
 235         configT.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Services.class),
 236             new ServicesBuilder().build());
 237         operT.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Services.class),
 238             new ServicesBuilder().build());
 239
 240         // Create the PreloadInformation container
 241         configT.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadInformation.class),
 242             new PreloadInformationBuilder().build());
 243         operT.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadInformation.class),
 244             new PreloadInformationBuilder().build());
 245
 246         try {
 247             FluentFuture<? extends @NonNull CommitInfo> configCheckedFuture = configT.commit();
 248             configCheckedFuture.get();
 249             FluentFuture<? extends @NonNull CommitInfo> operCheckedFuture = operT.commit();
 250             operCheckedFuture.get();
 251
 252             log.info("Create containers succeeded!");
 253
 254         } catch (InterruptedException | ExecutionException e) {
 255             log.error("Create containers failed: ", e);
 256         }
 257     }
 258
 259     private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
 260         String ackFinal) {
 261         serviceStatusBuilder.setResponseCode(errorCode);
 262         serviceStatusBuilder.setResponseMessage(errorMessage);
 263         serviceStatusBuilder.setFinalIndicator(ackFinal);
 264         serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
 265     }
 266
 267     private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
 268         if (requestInformation != null && requestInformation.getRequestAction() != null) {
 269             serviceStatusBuilder.setAction(requestInformation.getRequestAction().toString());
 270         }
 271     }
 272
 273     private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
 274         if (requestHeader != null && requestHeader.getSvcAction() != null) {
 275             switch (requestHeader.getSvcAction()) {
 276                 case Assign:
 277                     serviceStatusBuilder.setRpcAction(RpcAction.Assign);
 278                     break;
 279                 case Unassign:
 280                     serviceStatusBuilder.setRpcAction(RpcAction.Unassign);
 281                     break;
 282                 case Activate:
 283                     serviceStatusBuilder.setRpcAction(RpcAction.Activate);
 284                     break;
 285                 case Deactivate:
 286                     serviceStatusBuilder.setRpcAction(RpcAction.Deactivate);
 287                     break;
 288                 case Delete:
 289                     serviceStatusBuilder.setRpcAction(RpcAction.Delete);
 290                     break;
 291                 case Create:
 292                     serviceStatusBuilder.setRpcAction(RpcAction.Create);
 293                     break;
 294                 default:
 295                     log.error("Unknown SvcAction: {}", requestHeader.getSvcAction());
 296                     break;
 297             }
 298         }
 299     }
 300
 301     private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
 302         // default to config
 303         getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
 304     }
 305
 306     private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
 307         // See if any data exists yet for this siid, if so grab it.
 308         InstanceIdentifier<Service> serviceInstanceIdentifier = InstanceIdentifier.<Services>builder(Services.class)
 309             .child(Service.class, new ServiceKey(siid)).build();
 310
 311         Optional<Service> data = null;
 312
 313         try (final ReadTransaction readTx = dataBroker.newReadOnlyTransaction()) {
 314             data = (Optional<Service>) readTx.read(type, serviceInstanceIdentifier).get();
 315         } catch (final InterruptedException | ExecutionException e) {
 316             log.error("Caught Exception reading MD-SAL ({}) data for [{}] ", type, siid, e);
 317         }
 318
 319         if (data != null && data.isPresent()) {
 320             ServiceData serviceData = data.get().getServiceData();
 321             if (serviceData != null) {
 322                 log.info("Read MD-SAL ({}) data for [{}] ServiceData: {}", type, siid, serviceData);
 323                 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
 324                 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
 325                 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
 326                 serviceDataBuilder.setServiceRequestInput(serviceData.getServiceRequestInput());
 327                 serviceDataBuilder.setServiceTopology(serviceData.getServiceTopology());
 328                 serviceDataBuilder.setServiceLevelOperStatus(serviceData.getServiceLevelOperStatus());
 329                 serviceDataBuilder.setNetworks(serviceData.getNetworks());
 330                 serviceDataBuilder.setVnfs(serviceData.getVnfs());
 331                 serviceDataBuilder.setProvidedAllottedResources(serviceData.getProvidedAllottedResources());
 332                 serviceDataBuilder.setConsumedAllottedResources(serviceData.getConsumedAllottedResources());
 333                 serviceDataBuilder.setNetworkInstanceGroups(serviceData.getNetworkInstanceGroups());
 334                 serviceDataBuilder.setVnfcInstanceGroups(serviceData.getVnfcInstanceGroups());
 335                 serviceDataBuilder.setForwardingPaths(serviceData.getForwardingPaths());
 336                 serviceDataBuilder.setProvidedConfigurations(serviceData.getProvidedConfigurations());
 337                 // service-instance-id needs to be set
 338             } else {
 339                 log.info("No service-data found in MD-SAL ({}) for [{}]", type, siid);
 340             }
 341         } else {
 342             log.info("No data found in MD-SAL ({}) for [{}]", type, siid);
 343         }
 344     }
 345
 346     private void saveService(final Service entry, boolean merge, LogicalDatastoreType storeType) {
 347         // Each entry will be identifiable by a unique key, we have to create that
 348         // identifier
 349         InstanceIdentifier<Service> path = InstanceIdentifier.builder(Services.class)
 350             .child(Service.class, entry.key()).build();
 351
 352         trySaveEntry(entry, merge, storeType, path);
 353     }
 354
 355     private <T extends DataObject> void trySaveEntry(T entry, boolean merge, LogicalDatastoreType storeType,
 356         InstanceIdentifier<T> path) {
 357         int tries = 2;
 358         while (true) {
 359             try {
 360                 save(entry, merge, storeType, path);
 361                 break;
 362             } catch (OptimisticLockFailedException e) {
 363                 if (--tries <= 0) {
 364                     log.debug("Got OptimisticLockFailedException on last try - failing ");
 365                     throw new IllegalStateException(e);
 366                 }
 367                 log.debug("Got OptimisticLockFailedException - trying again ");
 368             } catch (TransactionCommitFailedException|InterruptedException|ExecutionException ex) {
 369                 log.debug("Update DataStore failed");
 370                 throw new IllegalStateException(ex);
 371             }
 372         }
 373     }
 374
 375     private <T extends DataObject> void save(T entry, boolean merge, LogicalDatastoreType storeType,
 376         InstanceIdentifier<T> path) throws TransactionCommitFailedException, InterruptedException,
 377             ExecutionException {
 378         WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 379         if (merge) {
 380             tx.merge(storeType, path, entry);
 381         } else {
 382             tx.put(storeType, path, entry);
 383         }
 384         tx.commit().get();
 385         log.debug("Update DataStore succeeded");
 386     }
 387
 388     private void deleteService(final Service entry, LogicalDatastoreType storeType) {
 389         // Each entry will be identifiable by a unique key, we have to create
 390         // that identifier
 391         InstanceIdentifier<Service> path = InstanceIdentifier.builder(Services.class)
 392             .child(Service.class, entry.key()).build();
 393
 394         tryDeleteEntry(storeType, path);
 395     }
 396
 397     private void tryDeleteEntry(LogicalDatastoreType storeType, InstanceIdentifier<Service> path) {
 398         int tries = 2;
 399         while (true) {
 400             try {
 401                 delete(storeType, path);
 402                 break;
 403             } catch (OptimisticLockFailedException e) {
 404                 if (--tries <= 0) {
 405                     log.debug("Got OptimisticLockFailedException on last try - failing ");
 406                     throw new IllegalStateException(e);
 407                 }
 408                 log.debug("Got OptimisticLockFailedException - trying again ");
 409             } catch (TransactionCommitFailedException|InterruptedException|ExecutionException ex) {
 410                 log.debug("Update DataStore failed");
 411                 throw new IllegalStateException(ex);
 412             }
 413         }
 414     }
 415
 416     private void delete(LogicalDatastoreType storeType, InstanceIdentifier<Service> path)
 417         throws TransactionCommitFailedException, InterruptedException, ExecutionException {
 418         WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 419         tx.delete(storeType, path);
 420         tx.commit().get();
 421         log.debug("DataStore delete succeeded");
 422     }
 423
 424     private void getPreloadData(String vnf_name, String vnf_type, PreloadDataBuilder preloadDataBuilder) {
 425         // default to config
 426         getPreloadData(vnf_name, vnf_type, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
 427     }
 428
 429     private void getPreloadData(String preloadName, String preloadType, PreloadDataBuilder preloadDataBuilder,
 430         LogicalDatastoreType type) {
 431         // See if any data exists yet for this name/type, if so grab it.
 432         InstanceIdentifier preloadInstanceIdentifier = InstanceIdentifier
 433             .<PreloadInformation>builder(PreloadInformation.class)
 434             .child(PreloadList.class, new PreloadListKey(preloadName, preloadType)).build();
 435
 436         Optional<PreloadList> data = null;
 437         try (final ReadTransaction readTx = dataBroker.newReadOnlyTransaction()) {
 438             data = (Optional<PreloadList>) readTx.read(type, preloadInstanceIdentifier).get();
 439         } catch (final InterruptedException | ExecutionException e) {
 440             log.error("Caught Exception reading MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType, e);
 441         }
 442
 443         if (data != null && data.isPresent()) {
 444             PreloadData preloadData = data.get().getPreloadData();
 445             if (preloadData != null) {
 446                 log.info("Read MD-SAL ({}) data for [{},{}] PreloadData: {}", type, preloadName, preloadType,
 447                     preloadData);
 448                 preloadDataBuilder
 449                     .setPreloadVfModuleTopologyInformation(preloadData.getPreloadVfModuleTopologyInformation());
 450                 preloadDataBuilder
 451                     .setPreloadNetworkTopologyInformation(preloadData.getPreloadNetworkTopologyInformation());
 452                 preloadDataBuilder.setPreloadOperStatus(preloadData.getPreloadOperStatus());
 453             } else {
 454                 log.info("No preload-data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
 455             }
 456         } else {
 457             log.info("No data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
 458         }
 459     }
 460
 461     private void savePreloadList(final PreloadList entry, boolean merge, LogicalDatastoreType storeType)
 462         throws IllegalStateException {
 463
 464         // Each entry will be identifiable by a unique key, we have to create that
 465         // identifier
 466         InstanceIdentifier.InstanceIdentifierBuilder<PreloadList> preloadListBuilder = InstanceIdentifier
 467             .<PreloadInformation>builder(PreloadInformation.class).child(PreloadList.class, entry.key());
 468         InstanceIdentifier<PreloadList> path = preloadListBuilder.build();
 469         int tries = 2;
 470         while (true) {
 471             try {
 472                 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 473                 if (merge) {
 474                     tx.merge(storeType, path, entry);
 475                 } else {
 476                     tx.put(storeType, path, entry);
 477                 }
 478                 tx.commit().get();
 479                 log.debug("Update DataStore succeeded");
 480                 break;
 481             } catch (final InterruptedException | ExecutionException e) {
 482                 if (e instanceof OptimisticLockFailedException) {
 483                     if (--tries <= 0) {
 484                         log.debug("Got OptimisticLockFailedException on last try - failing ");
 485                         throw new IllegalStateException(e);
 486                     }
 487                     log.debug("Got OptimisticLockFailedException - trying again ");
 488                 } else {
 489                     log.debug("Update DataStore failed");
 490                     throw new IllegalStateException(e);
 491                 }
 492             }
 493         }
 494     }
 495
 496     private void deletePreloadList(final PreloadList entry, LogicalDatastoreType storeType) {
 497         // Each entry will be identifiable by a unique key, we have to create
 498         // that identifier
 499         InstanceIdentifier<PreloadList> path = InstanceIdentifier.builder(PreloadInformation.class)
 500             .child(PreloadList.class, entry.key()).build();
 501
 502         tryDeletePreloadListEntry(storeType, path);
 503     }
 504
 505     private void tryDeletePreloadListEntry(LogicalDatastoreType storeType, InstanceIdentifier<PreloadList> path) {
 506         int tries = 2;
 507         while (true) {
 508             try {
 509                 deletePreloadList(storeType, path);
 510                 break;
 511             } catch (OptimisticLockFailedException e) {
 512                 if (--tries <= 0) {
 513                     log.debug("Got OptimisticLockFailedException on last try - failing ");
 514                     throw new IllegalStateException(e);
 515                 }
 516                 log.debug("Got OptimisticLockFailedException - trying again ");
 517             } catch (TransactionCommitFailedException|InterruptedException|ExecutionException ex) {
 518                 log.debug("Update DataStore failed");
 519                 throw new IllegalStateException(ex);
 520             }
 521         }
 522     }
 523
 524     private void deletePreloadList(LogicalDatastoreType storeType, InstanceIdentifier<PreloadList> path)
 525         throws TransactionCommitFailedException, InterruptedException, ExecutionException {
 526         WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 527         tx.delete(storeType, path);
 528         tx.commit().get();
 529         log.debug("DataStore delete succeeded");
 530     }
 531
 532     @Override
 533     public ListenableFuture<RpcResult<ServiceTopologyOperationOutput>> serviceTopologyOperation(
 534         ServiceTopologyOperationInput input) {
 535
 536         final String svcOperation = "service-topology-operation";
 537         ServiceData serviceData;
 538         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
 539         Properties parms = new Properties();
 540
 541         log.info(CALLED_STR, svcOperation);
 542         // create a new response object
 543         ServiceTopologyOperationOutputBuilder responseBuilder = new ServiceTopologyOperationOutputBuilder();
 544
 545         if (hasInvalidServiceId(input)) {
 546             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
 547             responseBuilder.setResponseCode("404");
 548             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
 549             responseBuilder.setAckFinalIndicator("Y");
 550
 551             RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
 552                 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
 553
 554             return Futures.immediateFuture(rpcResult);
 555         }
 556
 557         // Grab the service instance ID from the input buffer
 558         String siid = input.getServiceInformation().getServiceInstanceId();
 559
 560         trySetSvcRequestId(input, responseBuilder);
 561
 562         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
 563         getServiceData(siid, serviceDataBuilder);
 564
 565         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
 566         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
 567
 568         // Set the serviceStatus based on input
 569         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
 570         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
 571
 572         /*
 573          * // setup a service-data object builder // ACTION service-topology-operation
 574          * // INPUT: // USES uses service-operation-information // OUTPUT: // uses
 575          * topology-response-common; // uses service-response-information;
 576          */
 577
 578         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
 579         ServiceTopologyOperationInputBuilder inputBuilder = new ServiceTopologyOperationInputBuilder(input);
 580         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
 581
 582         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
 583         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
 584
 585         // Call SLI sync method
 586         ResponseObject responseObject = new ResponseObject("200", "");
 587         String ackFinal = "Y";
 588         String serviceObjectPath = null;
 589         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
 590
 591         if (respProps != null) {
 592             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
 593             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
 594             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
 595             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
 596         }
 597
 598         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
 599         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
 600         serviceStatusBuilder.setRpcName(svcOperation);
 601
 602         if (failed(responseObject)) {
 603             responseBuilder.setResponseCode(responseObject.getStatusCode());
 604             responseBuilder.setResponseMessage(responseObject.getMessage());
 605             responseBuilder.setAckFinalIndicator(ackFinal);
 606
 607             ServiceBuilder serviceBuilder = new ServiceBuilder();
 608             serviceBuilder.setServiceInstanceId(siid);
 609             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
 610             try {
 611                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
 612             } catch (Exception e) {
 613                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
 614             }
 615             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
 616
 617             RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
 618                 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
 619
 620             return Futures.immediateFuture(rpcResult);
 621         }
 622
 623         // Got success from SLI
 624         try {
 625             serviceData = serviceDataBuilder.build();
 626             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
 627
 628             // service object
 629             ServiceBuilder serviceBuilder = new ServiceBuilder();
 630             serviceBuilder.setServiceData(serviceData);
 631             serviceBuilder.setServiceInstanceId(siid);
 632             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
 633             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
 634
 635             tryDeleteService(input, serviceBuilder);
 636
 637             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
 638             serviceResponseInformationBuilder.setInstanceId(siid);
 639             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
 640             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
 641
 642         } catch (Exception e) {
 643             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
 644             responseBuilder.setResponseCode("500");
 645             responseBuilder.setResponseMessage(e.getMessage());
 646             responseBuilder.setAckFinalIndicator("Y");
 647             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
 648
 649             RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
 650                 .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
 651
 652             return Futures.immediateFuture(rpcResult);
 653         }
 654
 655         // Update succeeded
 656         responseBuilder.setResponseCode(responseObject.getStatusCode());
 657         responseBuilder.setAckFinalIndicator(ackFinal);
 658         trySetResponseMessage(responseBuilder, responseObject);
 659         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
 660         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
 661
 662         RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
 663             .<ServiceTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
 664
 665         return Futures.immediateFuture(rpcResult);
 666     }
 667
 668     private void trySetResponseMessage(ServiceTopologyOperationOutputBuilder responseBuilder,
 669         ResponseObject responseObject) {
 670         if (responseObject.getMessage() != null) {
 671             responseBuilder.setResponseMessage(responseObject.getMessage());
 672         }
 673     }
 674
 675     private boolean hasInvalidServiceId(ServiceTopologyOperationInput input) {
 676         return input == null || input.getServiceInformation() == null
 677             || input.getServiceInformation().getServiceInstanceId() == null
 678             || input.getServiceInformation().getServiceInstanceId().length() == 0;
 679     }
 680
 681     private void trySetSvcRequestId(ServiceTopologyOperationInput input,
 682         ServiceTopologyOperationOutputBuilder responseBuilder) {
 683         if (input.getSdncRequestHeader() != null) {
 684             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
 685         }
 686     }
 687
 688     private void tryDeleteService(ServiceTopologyOperationInput input, ServiceBuilder serviceBuilder) {
 689         if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
 690             // Only update operational tree on delete
 691             log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
 692             deleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
 693             deleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
 694         }
 695     }
 696
 697     private Properties tryGetProperties(String svcOperation, Properties parms, ServiceDataBuilder serviceDataBuilder,
 698         ResponseObject responseObject) {
 699         try {
 700             if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
 701                 try {
 702                     return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
 703                 } catch (Exception e) {
 704                     log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
 705                     responseObject.setMessage(e.getMessage());
 706                     responseObject.setStatusCode("500");
 707                 }
 708             } else {
 709                 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
 710                 responseObject.setStatusCode("503");
 711             }
 712         } catch (Exception e) {
 713             responseObject.setMessage(e.getMessage());
 714             responseObject.setStatusCode("500");
 715             log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
 716         }
 717
 718         return null;
 719     }
 720
 721     private boolean failed(ResponseObject error) {
 722         return !error.getStatusCode().isEmpty()
 723             && !("0".equals(error.getStatusCode()) || "200".equals(error.getStatusCode()));
 724     }
 725
 726     private boolean isValidRequest(ServiceTopologyOperationInput input) {
 727         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
 728     }
 729
 730
 731     @Override
 732     public ListenableFuture<RpcResult<PnfTopologyOperationOutput>> pnfTopologyOperation(
 733         PnfTopologyOperationInput input) {
 734
 735         final String svcOperation = "pnf-topology-operation";
 736         ServiceData serviceData;
 737         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
 738         Properties properties = new Properties();
 739
 740         log.info(CALLED_STR, svcOperation);
 741         // create a new response object
 742         PnfTopologyOperationOutputBuilder responseBuilder = new PnfTopologyOperationOutputBuilder();
 743
 744         if (hasInvalidServiceId(input)) {
 745             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
 746             responseBuilder.setResponseCode("404");
 747             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
 748             responseBuilder.setAckFinalIndicator("Y");
 749             RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
 750                 .withResult(responseBuilder.build()).build();
 751             // return error
 752             return Futures.immediateFuture(rpcResult);
 753         }
 754
 755         // Grab the service instance ID from the input buffer
 756         String siid = input.getServiceInformation().getServiceInstanceId();
 757
 758         trySetSvcRequestId(input, responseBuilder);
 759
 760         /* Comment out mandatory check for pnf id for scenario wherein for assign/create request pnf-id is generated by
 761         SDNC itself.
 762         if (hasInvalidPnfId(input)) {
 763             log.debug("exiting {} because of null or empty pnf-id", svcOperation);
 764             responseBuilder.setResponseCode("404");
 765             responseBuilder.setResponseMessage("invalid input, null or empty pnf-id");
 766             responseBuilder.setAckFinalIndicator("Y");
 767
 768             RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
 769                     .withResult(responseBuilder.build()).build();
 770
 771             return Futures.immediateFuture(rpcResult);
 772         }
 773         */
 774
 775         String pnfId = input.getPnfDetails().getPnfId();
 776         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
 777         getServiceData(siid, serviceDataBuilder);
 778
 779         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
 780         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
 781
 782         // Set the serviceStatus based on input
 783         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
 784         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
 785
 786         //
 787         // setup a service-data object builder
 788         // ACTION pnf-topology-operation
 789         // INPUT:
 790         // USES sdnc-request-header;
 791         // USES request-information;
 792         // USES service-information;
 793         // USES pnf-details
 794         // OUTPUT:
 795         // USES pnf-topology-response-body;
 796         // USES pnf-details
 797         // USES service-information
 798         //
 799         // uses oper-status;
 800
 801         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
 802         PnfTopologyOperationInputBuilder inputBuilder = new PnfTopologyOperationInputBuilder(input);
 803         GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
 804
 805         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
 806         GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
 807
 808         // Call SLI sync method
 809
 810         ResponseObject responseObject = new ResponseObject("200", "");
 811         String ackFinal = "Y";
 812         String serviceObjectPath = null;
 813         String pnfObjectPath = null;
 814         Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
 815
 816         if (respProps != null) {
 817             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
 818             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
 819             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
 820             if (pnfId == null) {
 821                 pnfId = respProps.getProperty("pnfId");
 822             }
 823             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
 824             pnfObjectPath = respProps.getProperty(PNF_OBJECT_PATH_PARAM);
 825         }
 826
 827         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
 828         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
 829         serviceStatusBuilder.setRpcName(svcOperation);
 830
 831         if (failed(responseObject)) {
 832             responseBuilder.setResponseCode(responseObject.getStatusCode());
 833             responseBuilder.setResponseMessage(responseObject.getMessage());
 834             responseBuilder.setAckFinalIndicator(ackFinal);
 835
 836             ServiceBuilder serviceBuilder = new ServiceBuilder();
 837             serviceBuilder.setServiceInstanceId(siid);
 838             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
 839             try {
 840                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
 841                 trySaveService(input, serviceBuilder);
 842             } catch (Exception e) {
 843                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
 844             }
 845             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
 846
 847             RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
 848                 .withResult(responseBuilder.build()).build();
 849
 850             // return error
 851             return Futures.immediateFuture(rpcResult);
 852         }
 853
 854         // Got success from SLI
 855         try {
 856             serviceData = serviceDataBuilder.build();
 857             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
 858
 859             // service object
 860             ServiceBuilder serviceBuilder = new ServiceBuilder();
 861             serviceBuilder.setServiceData(serviceData);
 862             serviceBuilder.setServiceInstanceId(siid);
 863             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
 864             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
 865
 866             if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
 867                 // Only update operational tree on Assign
 868                 log.info(UPDATING_TREE_INFO_MESSAGE);
 869                 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
 870             }
 871
 872             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
 873             serviceResponseInformationBuilder.setInstanceId(siid);
 874             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
 875             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
 876
 877             PnfResponseInformationBuilder pnfResponseInformationBuilder = new PnfResponseInformationBuilder();
 878             pnfResponseInformationBuilder.setInstanceId(pnfId);
 879             pnfResponseInformationBuilder.setObjectPath(pnfObjectPath);
 880             responseBuilder.setPnfResponseInformation(pnfResponseInformationBuilder.build());
 881
 882         } catch (Exception e) {
 883             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
 884             responseBuilder.setResponseCode("500");
 885             responseBuilder.setResponseMessage(e.getMessage());
 886             responseBuilder.setAckFinalIndicator("Y");
 887             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
 888
 889             RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
 890                 .withResult(responseBuilder.build()).build();
 891
 892             return Futures.immediateFuture(rpcResult);
 893         }
 894
 895         // Update succeeded
 896         responseBuilder.setResponseCode(responseObject.getStatusCode());
 897         responseBuilder.setAckFinalIndicator(ackFinal);
 898         trySetResponseMessage(responseBuilder, responseObject);
 899         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
 900         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
 901
 902         RpcResult<PnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<PnfTopologyOperationOutput>status(true)
 903             .withResult(responseBuilder.build()).build();
 904
 905         // return success
 906         return Futures.immediateFuture(rpcResult);
 907     }
 908
 909     private void trySetResponseMessage(PnfTopologyOperationOutputBuilder responseBuilder,
 910         ResponseObject responseObject) {
 911         if (responseObject.getMessage() != null) {
 912             responseBuilder.setResponseMessage(responseObject.getMessage());
 913         }
 914     }
 915
 916     private void trySaveService(PnfTopologyOperationInput input, ServiceBuilder serviceBuilder) {
 917         if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)
 918             || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
 919
 920             // Only update operational tree on activate or delete
 921             log.info(UPDATING_TREE_INFO_MESSAGE);
 922             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
 923         }
 924     }
 925
 926     private boolean hasInvalidPnfId(PnfTopologyOperationInput input) {
 927         return input.getPnfDetails() == null || input.getPnfDetails().getPnfId() == null
 928             || input.getPnfDetails().getPnfId().length() == 0;
 929     }
 930
 931     private boolean hasInvalidServiceId(PnfTopologyOperationInput input) {
 932         return input == null || input.getServiceInformation() == null
 933             || input.getServiceInformation().getServiceInstanceId() == null
 934             || input.getServiceInformation().getServiceInstanceId().length() == 0;
 935     }
 936
 937     private void trySetSvcRequestId(PnfTopologyOperationInput input,
 938         PnfTopologyOperationOutputBuilder responseBuilder) {
 939         if (input.getSdncRequestHeader() != null) {
 940             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
 941         }
 942     }
 943
 944     private boolean isValidRequest(PnfTopologyOperationInput input) {
 945         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
 946     }
 947
 948
 949     @Override
 950     public ListenableFuture<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(
 951         VnfTopologyOperationInput input) {
 952
 953         final String svcOperation = "vnf-topology-operation";
 954         ServiceData serviceData;
 955         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
 956         Properties properties = new Properties();
 957
 958         log.info(CALLED_STR, svcOperation);
 959         // create a new response object
 960         VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
 961
 962         if (hasInvalidServiceId(input)) {
 963             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
 964             responseBuilder.setResponseCode("404");
 965             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
 966             responseBuilder.setAckFinalIndicator("Y");
 967             RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
 968                 .withResult(responseBuilder.build()).build();
 969             // return error
 970             return Futures.immediateFuture(rpcResult);
 971         }
 972
 973         // Grab the service instance ID from the input buffer
 974         String siid = input.getServiceInformation().getServiceInstanceId();
 975
 976         trySetSvcRequestId(input, responseBuilder);
 977
 978         /* Comment out mandatory check for vnf id for scenario wherein for assign/create request vnf-id is generated by
 979         SDNC itself.
 980         if (hasInvalidVnfId(input)) {
 981             log.debug("exiting {} because of null or empty vnf-id", svcOperation);
 982             responseBuilder.setResponseCode("404");
 983             responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
 984             responseBuilder.setAckFinalIndicator("Y");
 985
 986             RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
 987                     .withResult(responseBuilder.build()).build();
 988
 989             return Futures.immediateFuture(rpcResult);
 990         }
 991         */
 992
 993         String vnfId = input.getVnfInformation().getVnfId();
 994         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
 995         getServiceData(siid, serviceDataBuilder);
 996
 997         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
 998         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
 999
1000         // Set the serviceStatus based on input
1001         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1002         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1003
1004         //
1005         // setup a service-data object builder
1006         // ACTION vnf-topology-operation
1007         // INPUT:
1008         // USES sdnc-request-header;
1009         // USES request-information;
1010         // USES service-information;
1011         // USES vnf-request-information
1012         // OUTPUT:
1013         // USES vnf-topology-response-body;
1014         // USES vnf-information
1015         // USES service-information
1016         //
1017         // container service-data
1018         // uses vnf-configuration-information;
1019         // uses oper-status;
1020
1021         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1022         VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1023         GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
1024
1025         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1026         GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
1027
1028         // Call SLI sync method
1029
1030         ResponseObject responseObject = new ResponseObject("200", "");
1031         String ackFinal = "Y";
1032         String serviceObjectPath = null;
1033         String vnfObjectPath = null;
1034         String skipMdsalUpdate = null;
1035         Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
1036
1037         if (respProps != null) {
1038             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1039             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1040             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1041             if (vnfId == null) {
1042                 vnfId = respProps.getProperty("vnfId");
1043             }
1044             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1045             vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1046             skipMdsalUpdate = respProps.getProperty(SKIP_MDSAL_UPDATE_PROP);
1047             if (skipMdsalUpdate == null) {
1048                 skipMdsalUpdate = "N";
1049             }
1050         }
1051
1052         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1053         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1054         serviceStatusBuilder.setRpcName(svcOperation);
1055
1056         if (failed(responseObject)) {
1057             responseBuilder.setResponseCode(responseObject.getStatusCode());
1058             responseBuilder.setResponseMessage(responseObject.getMessage());
1059             responseBuilder.setAckFinalIndicator(ackFinal);
1060
1061             ServiceBuilder serviceBuilder = new ServiceBuilder();
1062             serviceBuilder.setServiceInstanceId(siid);
1063             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1064             try {
1065                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1066                 trySaveService(input, serviceBuilder);
1067             } catch (Exception e) {
1068                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1069             }
1070             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1071
1072             RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
1073                 .withResult(responseBuilder.build()).build();
1074
1075             // return error
1076             return Futures.immediateFuture(rpcResult);
1077         }
1078
1079         // Got success from SLI
1080         try {
1081             if (skipMdsalUpdate.equals("N")) {
1082                 serviceData = serviceDataBuilder.build();
1083                 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1084
1085                 // service object
1086                 ServiceBuilder serviceBuilder = new ServiceBuilder();
1087                 serviceBuilder.setServiceData(serviceData);
1088                 serviceBuilder.setServiceInstanceId(siid);
1089                 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1090                 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1091
1092                 if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1093                     // Only update operational tree on Assign
1094                     log.info(UPDATING_TREE_INFO_MESSAGE);
1095                     saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1096                 }
1097             } else {
1098                 // Even if we are skipping the MD-SAL update, update the service status object
1099                 ServiceBuilder serviceBuilder = new ServiceBuilder();
1100                 serviceBuilder.setServiceInstanceId(siid);
1101                 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1102                 Service service = serviceBuilder.build();
1103                 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, service);
1104                 saveService(service, true, LogicalDatastoreType.CONFIGURATION);
1105             }
1106
1107             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1108             serviceResponseInformationBuilder.setInstanceId(siid);
1109             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1110             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1111
1112             VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1113             vnfResponseInformationBuilder.setInstanceId(vnfId);
1114             vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1115             responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1116
1117         } catch (Exception e) {
1118             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1119             responseBuilder.setResponseCode("500");
1120             responseBuilder.setResponseMessage(e.getMessage());
1121             responseBuilder.setAckFinalIndicator("Y");
1122             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1123
1124             RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
1125                 .withResult(responseBuilder.build()).build();
1126
1127             return Futures.immediateFuture(rpcResult);
1128         }
1129
1130         // Update succeeded
1131         responseBuilder.setResponseCode(responseObject.getStatusCode());
1132         responseBuilder.setAckFinalIndicator(ackFinal);
1133         trySetResponseMessage(responseBuilder, responseObject);
1134         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1135         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1136
1137         RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
1138             .withResult(responseBuilder.build()).build();
1139
1140         if (ackFinal.equals("N")) {
1141             // Spawn background thread to invoke the Async DG
1142             Runnable backgroundThread = new Runnable() {
1143                 public void run() {
1144                     log.info(BACKGROUND_THREAD_STARTED_MESSAGE);
1145                     processAsyncVnfTopologyOperation(input);
1146                 }
1147             };
1148             new Thread(backgroundThread).start();
1149         }
1150
1151         // return success
1152         return Futures.immediateFuture(rpcResult);
1153     }
1154
1155     private void trySetResponseMessage(VnfTopologyOperationOutputBuilder responseBuilder,
1156         ResponseObject responseObject) {
1157         if (responseObject.getMessage() != null) {
1158             responseBuilder.setResponseMessage(responseObject.getMessage());
1159         }
1160     }
1161
1162     private void trySaveService(VnfTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1163         if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)
1164             || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1165
1166             // Only update operational tree on activate or delete
1167             log.info(UPDATING_TREE_INFO_MESSAGE);
1168             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1169         }
1170     }
1171
1172     private boolean hasInvalidVnfId(VnfTopologyOperationInput input) {
1173         return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
1174             || input.getVnfInformation().getVnfId().length() == 0;
1175     }
1176
1177     private boolean hasInvalidServiceId(VnfTopologyOperationInput input) {
1178         return input == null || input.getServiceInformation() == null
1179             || input.getServiceInformation().getServiceInstanceId() == null
1180             || input.getServiceInformation().getServiceInstanceId().length() == 0;
1181     }
1182
1183     private void trySetSvcRequestId(VnfTopologyOperationInput input,
1184         VnfTopologyOperationOutputBuilder responseBuilder) {
1185         if (input.getSdncRequestHeader() != null) {
1186             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1187         }
1188     }
1189
1190     private boolean isValidRequest(VnfTopologyOperationInput input) {
1191         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1192     }
1193
1194     public void processAsyncVnfTopologyOperation(VnfTopologyOperationInput input) {
1195         log.info(BACKGROUND_THREAD_INFO, input.getVnfInformation().getVnfId());
1196
1197         final String svcOperation = "vnf-topology-operation-async";
1198         ServiceData serviceData = null;
1199         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1200         Properties parms = new Properties();
1201
1202         log.info(CALLED_STR, svcOperation);
1203
1204         // create a new response object (for logging purposes only)
1205         VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1206
1207         // Grab the service instance ID from the input buffer
1208         String siid = input.getServiceInformation().getServiceInstanceId();
1209         String vnfId = input.getVnfInformation().getVnfId();
1210
1211         trySetSvcRequestId(input, responseBuilder);
1212
1213         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1214         getServiceData(siid, serviceDataBuilder);
1215
1216         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1217         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1218
1219         // Set the serviceStatus based on input
1220         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1221         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1222
1223         //
1224         // setup a service-data object builder
1225         // ACTION vnf-topology-operation
1226         // INPUT:
1227         // USES sdnc-request-header;
1228         // USES request-information;
1229         // USES service-information;
1230         // USES vnf-request-information
1231         // OUTPUT:
1232         // USES vnf-topology-response-body;
1233         // USES vnf-information
1234         // USES service-information
1235         //
1236         // container service-data
1237         // uses vnf-configuration-information;
1238         // uses oper-status;
1239
1240         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1241         VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1242         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1243
1244         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1245         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1246
1247         // Call SLI sync method
1248
1249         ResponseObject responseObject = new ResponseObject("200", "");
1250         String ackFinal = "Y";
1251         String serviceObjectPath = null;
1252         String vnfObjectPath = null;
1253         String skipMdsalUpdate = null;
1254         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1255
1256         if (respProps != null) {
1257             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1258             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1259             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1260             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1261             vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1262             skipMdsalUpdate = respProps.getProperty(SKIP_MDSAL_UPDATE_PROP);
1263             if (skipMdsalUpdate == null) {
1264                 skipMdsalUpdate = "N";
1265             }
1266         }
1267
1268         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1269         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1270         serviceStatusBuilder.setRpcName(svcOperation);
1271
1272         if (failed(responseObject)) {
1273             responseBuilder.setResponseCode(responseObject.getStatusCode());
1274             responseBuilder.setResponseMessage(responseObject.getMessage());
1275             responseBuilder.setAckFinalIndicator(ackFinal);
1276
1277             ServiceBuilder serviceBuilder = new ServiceBuilder();
1278             serviceBuilder.setServiceInstanceId(siid);
1279             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1280             try {
1281                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1282             } catch (Exception e) {
1283                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1284             }
1285             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1286             return;
1287         }
1288
1289         // Got success from SLI
1290         try {
1291             if (skipMdsalUpdate.equals("N")) {
1292                 serviceData = serviceDataBuilder.build();
1293                 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1294
1295                 // service object
1296                 ServiceBuilder serviceBuilder = new ServiceBuilder();
1297                 serviceBuilder.setServiceData(serviceData);
1298                 serviceBuilder.setServiceInstanceId(siid);
1299                 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1300                 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1301
1302                 trySaveService(input, serviceBuilder);
1303             } else {
1304                 // Even if we are skipping the MD-SAL update, update the service status object
1305                 ServiceBuilder serviceBuilder = new ServiceBuilder();
1306                 serviceBuilder.setServiceInstanceId(siid);
1307                 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1308                 Service service = serviceBuilder.build();
1309                 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, service);
1310                 saveService(service, true, LogicalDatastoreType.CONFIGURATION);
1311             }
1312
1313             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1314             serviceResponseInformationBuilder.setInstanceId(siid);
1315             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1316             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1317
1318             VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1319             vnfResponseInformationBuilder.setInstanceId(vnfId);
1320             vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1321             responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1322
1323         } catch (Exception e) {
1324             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1325             responseBuilder.setResponseCode("500");
1326             responseBuilder.setResponseMessage(e.getMessage());
1327             responseBuilder.setAckFinalIndicator("Y");
1328             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1329
1330             return;
1331         }
1332
1333         // Update succeeded
1334         responseBuilder.setResponseCode(responseObject.getStatusCode());
1335         responseBuilder.setAckFinalIndicator(ackFinal);
1336         trySetResponseMessage(responseBuilder, responseObject);
1337         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1338         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1339         return;
1340     }
1341
1342     @Override
1343     public ListenableFuture<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1344         VfModuleTopologyOperationInput input) {
1345
1346         final String svcOperation = "vf-module-topology-operation";
1347         ServiceData serviceData;
1348         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1349         Properties parms = new Properties();
1350
1351         log.info(CALLED_STR, svcOperation);
1352         // create a new response object
1353         VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1354
1355         if (hasInvalidServiceId(input)) {
1356             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1357             responseBuilder.setResponseCode("403");
1358             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1359             responseBuilder.setAckFinalIndicator("Y");
1360
1361             RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1362                 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1363
1364             // return error
1365             return Futures.immediateFuture(rpcResult);
1366         }
1367
1368         if (hasInvalidVnfId(input)) {
1369             log.debug("exiting {} because of null or empty vnf-id", svcOperation);
1370             responseBuilder.setResponseCode("403");
1371             responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
1372             responseBuilder.setAckFinalIndicator("Y");
1373             RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1374                 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1375             return Futures.immediateFuture(rpcResult);
1376         }
1377
1378         /*if (hasInvalidVfModuleId(input)) {
1379             log.debug("exiting {} because of null or empty vf-module-id", svcOperation);
1380             responseBuilder.setResponseCode("403");
1381             responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
1382             responseBuilder.setAckFinalIndicator("Y");
1383
1384             RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1385                     .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1386
1387             return Futures.immediateFuture(rpcResult);
1388         }*/
1389
1390         // Grab the service instance ID from the input buffer
1391         String siid = input.getServiceInformation().getServiceInstanceId();
1392         String vnfId = input.getVnfInformation().getVnfId();
1393         String vfModuleId = input.getVfModuleInformation().getVfModuleId();
1394
1395         trySetSvcRequestId(input, responseBuilder);
1396
1397         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1398         getServiceData(siid, serviceDataBuilder);
1399
1400         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1401         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1402
1403         // Set the serviceStatus based on input
1404         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1405         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1406
1407         //
1408         // setup a service-data object builder
1409         // ACTION vnf-topology-operation
1410         // INPUT:
1411         // USES sdnc-request-header;
1412         // USES request-information;
1413         // USES service-information;
1414         // USES vnf-request-information
1415         // OUTPUT:
1416         // USES vnf-topology-response-body;
1417         // USES vnf-information
1418         // USES service-information
1419         //
1420         // container service-data
1421         // uses vnf-configuration-information;
1422         // uses oper-status;
1423
1424         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1425         VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1426         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1427
1428         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1429         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1430
1431         // Call SLI sync method
1432
1433         ResponseObject responseObject = new ResponseObject("200", "");
1434         String ackFinal = "Y";
1435         String serviceObjectPath = null;
1436         String vnfObjectPath = null;
1437         String vfModuleObjectPath = null;
1438         String skipMdsalUpdate = null;
1439         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1440
1441         if (respProps != null) {
1442             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1443             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1444             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1445             if (vfModuleId == null) {
1446                 vfModuleId = respProps.getProperty(VF_MODULE_ID_PARAM);
1447                 if (vfModuleId == null) {
1448                     log.debug("exiting {} because vf-module-id not found in response", svcOperation);
1449                     responseBuilder.setResponseCode("403");
1450                     responseBuilder.setResponseMessage("failed to generate vf-module-id");
1451                     responseBuilder.setAckFinalIndicator("Y");
1452
1453                     RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1454                         .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1455
1456                     return Futures.immediateFuture(rpcResult);
1457                 }
1458             }
1459             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1460             vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1461             vfModuleObjectPath = respProps.getProperty(VF_MODULE_OBJECT_PATH_PARAM);
1462             skipMdsalUpdate = respProps.getProperty(SKIP_MDSAL_UPDATE_PROP);
1463             if (skipMdsalUpdate == null) {
1464                 skipMdsalUpdate = "N";
1465             }
1466         }
1467
1468         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1469         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1470         serviceStatusBuilder.setRpcName(svcOperation);
1471
1472         if (failed(responseObject)) {
1473             responseBuilder.setResponseCode(responseObject.getStatusCode());
1474             responseBuilder.setResponseMessage(responseObject.getMessage());
1475             responseBuilder.setAckFinalIndicator(ackFinal);
1476
1477             ServiceBuilder serviceBuilder = new ServiceBuilder();
1478             serviceBuilder.setServiceInstanceId(siid);
1479             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1480             try {
1481                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1482             } catch (Exception e) {
1483                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1484             }
1485             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1486
1487             RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1488                 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1489
1490             // return error
1491             return Futures.immediateFuture(rpcResult);
1492         }
1493
1494         // Got success from SLI
1495         try {
1496             if (skipMdsalUpdate.equals("N")) {
1497                 serviceData = serviceDataBuilder.build();
1498                 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1499
1500                 // service object
1501                 ServiceBuilder serviceBuilder = new ServiceBuilder();
1502                 serviceBuilder.setServiceData(serviceData);
1503                 serviceBuilder.setServiceInstanceId(siid);
1504                 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1505                 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1506
1507                 trySaveService(input, serviceBuilder);
1508             } else {
1509                 // Even if we are skipping the MD-SAL update, update the service status object
1510                 ServiceBuilder serviceBuilder = new ServiceBuilder();
1511                 serviceBuilder.setServiceInstanceId(siid);
1512                 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1513                 Service service = serviceBuilder.build();
1514                 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, service);
1515                 saveService(service, true, LogicalDatastoreType.CONFIGURATION);
1516             }
1517
1518             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1519             serviceResponseInformationBuilder.setInstanceId(siid);
1520             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1521             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1522
1523             VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1524             vnfResponseInformationBuilder.setInstanceId(vnfId);
1525             vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1526             responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1527
1528             VfModuleResponseInformationBuilder vfModuleResponseInformationBuilder = new VfModuleResponseInformationBuilder();
1529             vfModuleResponseInformationBuilder.setInstanceId(vfModuleId);
1530             vfModuleResponseInformationBuilder.setObjectPath(vfModuleObjectPath);
1531             responseBuilder.setVfModuleResponseInformation(vfModuleResponseInformationBuilder.build());
1532
1533         } catch (Exception e) {
1534             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1535             responseBuilder.setResponseCode("500");
1536             responseBuilder.setResponseMessage(e.getMessage());
1537             responseBuilder.setAckFinalIndicator("Y");
1538             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1539
1540             RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1541                 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1542
1543             return Futures.immediateFuture(rpcResult);
1544         }
1545
1546         // Update succeeded
1547         responseBuilder.setResponseCode(responseObject.getStatusCode());
1548         responseBuilder.setAckFinalIndicator(ackFinal);
1549         trySetResponseMessage(responseBuilder, responseObject);
1550         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1551         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1552
1553         RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1554             .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1555
1556         if (ackFinal.equals("N")) {
1557             // Spawn background thread to invoke the Async DG
1558             Runnable backgroundThread = new Runnable() {
1559                 public void run() {
1560                     log.info(BACKGROUND_THREAD_STARTED_MESSAGE);
1561                     processAsyncVfModuleTopologyOperation(input);
1562                 }
1563             };
1564             new Thread(backgroundThread).start();
1565         }
1566
1567         // return success
1568         return Futures.immediateFuture(rpcResult);
1569     }
1570
1571     private void trySetResponseMessage(VfModuleTopologyOperationOutputBuilder responseBuilder,
1572         ResponseObject responseObject) {
1573         if (responseObject.getMessage() != null) {
1574             responseBuilder.setResponseMessage(responseObject.getMessage());
1575         }
1576     }
1577
1578     private void trySaveService(VfModuleTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1579         if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1580             || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1581             // Only update operational tree on activate or delete
1582
1583             log.info(UPDATING_TREE_INFO_MESSAGE);
1584             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1585         }
1586     }
1587
1588     private void trySetSvcRequestId(VfModuleTopologyOperationInput input,
1589         VfModuleTopologyOperationOutputBuilder responseBuilder) {
1590         if (input.getSdncRequestHeader() != null) {
1591             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1592         }
1593     }
1594
1595     private boolean hasInvalidVfModuleId(VfModuleTopologyOperationInput input) {
1596         return input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
1597             || input.getVfModuleInformation().getVfModuleId().length() == 0;
1598     }
1599
1600     private boolean hasInvalidVnfId(VfModuleTopologyOperationInput input) {
1601         return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
1602             || input.getVnfInformation().getVnfId().length() == 0;
1603     }
1604
1605     private boolean hasInvalidServiceId(VfModuleTopologyOperationInput input) {
1606         return input == null || input.getServiceInformation() == null
1607             || input.getServiceInformation().getServiceInstanceId() == null
1608             || input.getServiceInformation().getServiceInstanceId().length() == 0;
1609     }
1610
1611     private boolean isValidRequest(VfModuleTopologyOperationInput input) {
1612         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1613     }
1614
1615     public void processAsyncVfModuleTopologyOperation(VfModuleTopologyOperationInput input) {
1616         log.info(BACKGROUND_THREAD_INFO, input.getVfModuleInformation().getVfModuleId());
1617
1618         final String svcOperation = "vf-module-topology-operation-async";
1619         ServiceData serviceData = null;
1620         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1621         Properties parms = new Properties();
1622
1623         log.info(CALLED_STR, svcOperation);
1624
1625         // create a new response object (for logging purposes only)
1626         VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1627
1628         // Grab the service instance ID from the input buffer
1629         String siid = input.getServiceInformation().getServiceInstanceId();
1630         String vnfId = input.getVnfInformation().getVnfId();
1631         String vfModuleId = input.getVfModuleInformation().getVfModuleId();
1632
1633         trySetSvcRequestId(input, responseBuilder);
1634
1635         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1636         getServiceData(siid, serviceDataBuilder);
1637
1638         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1639         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1640
1641         // Set the serviceStatus based on input
1642         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1643         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1644
1645         //
1646         // setup a service-data object builder
1647         // ACTION vnf-topology-operation
1648         // INPUT:
1649         // USES sdnc-request-header;
1650         // USES request-information;
1651         // USES service-information;
1652         // USES vnf-request-information
1653         // OUTPUT:
1654         // USES vnf-topology-response-body;
1655         // USES vnf-information
1656         // USES service-information
1657         //
1658         // container service-data
1659         // uses vnf-configuration-information;
1660         // uses oper-status;
1661
1662         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1663         VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1664         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1665
1666         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1667         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1668
1669         // Call SLI sync method
1670
1671         ResponseObject responseObject = new ResponseObject("200", "");
1672         String ackFinal = "Y";
1673         String serviceObjectPath = null;
1674         String vnfObjectPath = null;
1675         String vfModuleObjectPath = null;
1676         String skipMdsalUpdate = null;
1677         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1678
1679         if (respProps != null) {
1680             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1681             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1682             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1683             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1684             vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1685             vfModuleObjectPath = respProps.getProperty(VF_MODULE_OBJECT_PATH_PARAM);
1686             skipMdsalUpdate = respProps.getProperty(SKIP_MDSAL_UPDATE_PROP);
1687             if (skipMdsalUpdate == null) {
1688                 skipMdsalUpdate = "N";
1689             }
1690         }
1691
1692         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1693         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1694         serviceStatusBuilder.setRpcName(svcOperation);
1695
1696         if (failed(responseObject)) {
1697             responseBuilder.setResponseCode(responseObject.getStatusCode());
1698             responseBuilder.setResponseMessage(responseObject.getMessage());
1699             responseBuilder.setAckFinalIndicator(ackFinal);
1700
1701             ServiceBuilder serviceBuilder = new ServiceBuilder();
1702             serviceBuilder.setServiceInstanceId(siid);
1703             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1704             try {
1705                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1706             } catch (Exception e) {
1707                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1708             }
1709             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1710             return;
1711         }
1712
1713         // Got success from SLI
1714         try {
1715             if (skipMdsalUpdate.equals("N")) {
1716                 serviceData = serviceDataBuilder.build();
1717                 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1718
1719                 // service object
1720                 ServiceBuilder serviceBuilder = new ServiceBuilder();
1721                 serviceBuilder.setServiceData(serviceData);
1722                 serviceBuilder.setServiceInstanceId(siid);
1723                 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1724                 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1725
1726                 trySaveService(input, serviceBuilder);
1727             } else {
1728                 // Even if we are skipping the MD-SAL update, update the service status object
1729                 ServiceBuilder serviceBuilder = new ServiceBuilder();
1730                 serviceBuilder.setServiceInstanceId(siid);
1731                 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1732                 Service service = serviceBuilder.build();
1733                 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, service);
1734                 saveService(service, true, LogicalDatastoreType.CONFIGURATION);
1735             }
1736
1737             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1738             serviceResponseInformationBuilder.setInstanceId(siid);
1739             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1740             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1741
1742             VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1743             vnfResponseInformationBuilder.setInstanceId(vnfId);
1744             vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1745             responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1746
1747             VfModuleResponseInformationBuilder vfModuleResponseInformationBuilder = new VfModuleResponseInformationBuilder();
1748             vfModuleResponseInformationBuilder.setInstanceId(vfModuleId);
1749             vfModuleResponseInformationBuilder.setObjectPath(vfModuleObjectPath);
1750             responseBuilder.setVfModuleResponseInformation(vfModuleResponseInformationBuilder.build());
1751
1752         } catch (Exception e) {
1753             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1754             responseBuilder.setResponseCode("500");
1755             responseBuilder.setResponseMessage(e.getMessage());
1756             responseBuilder.setAckFinalIndicator("Y");
1757             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1758
1759             return;
1760         }
1761
1762         // Update succeeded
1763         responseBuilder.setResponseCode(responseObject.getStatusCode());
1764         responseBuilder.setAckFinalIndicator(ackFinal);
1765         trySetResponseMessage(responseBuilder, responseObject);
1766         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1767         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1768         return;
1769     }
1770
1771     @Override
1772     public ListenableFuture<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1773         NetworkTopologyOperationInput input) {
1774
1775         final String svcOperation = "network-topology-operation";
1776         ServiceData serviceData;
1777         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1778         Properties parms = new Properties();
1779
1780         log.info(CALLED_STR, svcOperation);
1781         // create a new response object
1782         NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1783
1784         if (hasInvalidServiceId(input)) {
1785             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1786             return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1787         }
1788
1789         String siid = input.getServiceInformation().getServiceInstanceId();
1790
1791         // Get the service-instance service data from MD-SAL
1792         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1793         getServiceData(siid, serviceDataBuilder);
1794
1795         this.trySetSvcRequestId(input, responseBuilder);
1796
1797         ServiceData sd = serviceDataBuilder.build();
1798         if (isInvalidServiceData(sd)) {
1799             log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1800             return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1801         }
1802
1803         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1804         NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1805         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1806
1807         // Call SLI sync method
1808
1809         ResponseObject responseObject = new ResponseObject("200", "");
1810         String ackFinal = "Y";
1811         String networkId = ERROR_NETWORK_ID;
1812         String serviceObjectPath = null;
1813         String networkObjectPath = null;
1814         String skipMdsalUpdate = null;
1815         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1816
1817         if (respProps != null) {
1818             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1819             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1820             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1821             networkId = respProps.getProperty("networkId");
1822             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1823             networkObjectPath = respProps.getProperty(NETWORK_OBJECT_PATH_PARAM);
1824             skipMdsalUpdate = respProps.getProperty(SKIP_MDSAL_UPDATE_PROP);
1825             if (skipMdsalUpdate == null) {
1826                 skipMdsalUpdate = "N";
1827             }
1828         }
1829
1830         if (failed(responseObject)) {
1831             responseBuilder.setResponseCode(responseObject.getStatusCode());
1832             responseBuilder.setResponseMessage(responseObject.getMessage());
1833             responseBuilder.setAckFinalIndicator(ackFinal);
1834
1835             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1836
1837             RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1838                 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1839
1840             return Futures.immediateFuture(rpcResult);
1841         }
1842
1843         // Got success from SLI
1844         try {
1845             if (skipMdsalUpdate.equals("N")) {
1846                 serviceData = serviceDataBuilder.build();
1847                 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1848
1849                 // service object
1850                 ServiceBuilder serviceBuilder = new ServiceBuilder();
1851                 serviceBuilder.setServiceData(serviceData);
1852                 serviceBuilder.setServiceInstanceId(siid);
1853                 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1854                 saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1855
1856                 trySaveService(input, serviceBuilder);
1857             } else {
1858                 // Even if we are skipping the MD-SAL update, update the service status object
1859                 ServiceBuilder serviceBuilder = new ServiceBuilder();
1860                 serviceBuilder.setServiceInstanceId(siid);
1861                 serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1862                 Service service = serviceBuilder.build();
1863                 log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, service);
1864                 saveService(service, true, LogicalDatastoreType.CONFIGURATION);
1865             }
1866
1867             NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1868             networkResponseInformationBuilder.setInstanceId(networkId);
1869             networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1870             responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1871
1872             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1873             serviceResponseInformationBuilder.setInstanceId(siid);
1874             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1875             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1876         } catch (IllegalStateException e) {
1877             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1878             responseBuilder.setResponseCode("500");
1879             responseBuilder.setResponseMessage(e.getMessage());
1880             responseBuilder.setAckFinalIndicator("Y");
1881             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1882
1883             RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1884                 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1885
1886             return Futures.immediateFuture(rpcResult);
1887         }
1888
1889         // Update succeeded
1890         responseBuilder.setResponseCode(responseObject.getStatusCode());
1891         responseBuilder.setAckFinalIndicator(ackFinal);
1892         trySetResponseMessage(responseBuilder, responseObject);
1893         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1894         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1895
1896         RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1897             .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1898
1899         return Futures.immediateFuture(rpcResult);
1900     }
1901
1902     private void trySetResponseMessage(NetworkTopologyOperationOutputBuilder responseBuilder,
1903         ResponseObject responseObject) {
1904         if (responseObject.getMessage() != null) {
1905             responseBuilder.setResponseMessage(responseObject.getMessage());
1906         }
1907     }
1908
1909     private void trySetSvcRequestId(NetworkTopologyOperationInput input,
1910         NetworkTopologyOperationOutputBuilder responseBuilder) {
1911         if (input.getSdncRequestHeader() != null) {
1912             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1913         }
1914     }
1915
1916     private void trySaveService(NetworkTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1917         if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)
1918             || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create))) {
1919             // Only update operational tree on Activate
1920             log.info(UPDATING_TREE_INFO_MESSAGE);
1921             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1922         }
1923     }
1924
1925     private boolean hasInvalidServiceId(NetworkTopologyOperationInput input) {
1926         return input == null || input.getServiceInformation() == null
1927             || input.getServiceInformation().getServiceInstanceId() == null
1928             || input.getServiceInformation().getServiceInstanceId().length() == 0;
1929     }
1930
1931     private ListenableFuture<RpcResult<NetworkTopologyOperationOutput>> buildRpcResultFuture(
1932         NetworkTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1933
1934         responseBuilder.setResponseCode("404");
1935         responseBuilder.setResponseMessage(responseMessage);
1936         responseBuilder.setAckFinalIndicator("Y");
1937
1938         RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1939             .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1940
1941         return Futures.immediateFuture(rpcResult);
1942     }
1943
1944     private boolean isValidRequest(NetworkTopologyOperationInput input) {
1945         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1946     }
1947
1948     @Override
1949     public ListenableFuture<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1950         ContrailRouteTopologyOperationInput input) {
1951
1952         final String svcOperation = "contrail-route-topology-operation";
1953         ServiceData serviceData;
1954         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1955         Properties properties = new Properties();
1956
1957         log.info(CALLED_STR, svcOperation);
1958         // create a new response object
1959         ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1960
1961         if (hasInvalidServiceId(input)) {
1962             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1963             return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1964         }
1965
1966         String siid = input.getServiceInformation().getServiceInstanceId();
1967
1968         // Get the service-instance service data from MD-SAL
1969         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1970         getServiceData(siid, serviceDataBuilder);
1971
1972         trySetSvcRequestId(input, responseBuilder);
1973
1974         ServiceData sd = serviceDataBuilder.build();
1975         if (isInvalidServiceData(sd)) {
1976             log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1977             return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1978         }
1979
1980         log.info("Adding INPUT data for " + svcOperation + " [" + siid + "] input: " + input);
1981         ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1982         GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
1983
1984         // Call SLI sync method
1985
1986         ResponseObject responseObject = new ResponseObject("200", "");
1987         String ackFinal = "Y";
1988         String allottedResourceId = ERROR_NETWORK_ID;
1989         String serviceObjectPath = null;
1990         String contrailRouteObjectPath = null;
1991         Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
1992
1993         if (respProps != null) {
1994             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1995             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1996             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1997             allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1998             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1999             contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
2000         }
2001
2002         if (failed(responseObject)) {
2003             responseBuilder.setResponseCode(responseObject.getStatusCode());
2004             responseBuilder.setResponseMessage(responseObject.getMessage());
2005             responseBuilder.setAckFinalIndicator(ackFinal);
2006             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2007
2008             RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
2009                 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2010
2011             return Futures.immediateFuture(rpcResult);
2012         }
2013
2014         // Got success from SLI
2015         try {
2016             serviceData = serviceDataBuilder.build();
2017             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
2018
2019             // service object
2020             ServiceBuilder serviceBuilder = new ServiceBuilder();
2021             serviceBuilder.setServiceData(serviceData);
2022             serviceBuilder.setServiceInstanceId(siid);
2023             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2024             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2025
2026             trySaveService(input, serviceBuilder);
2027
2028             ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
2029             contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
2030             contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
2031             responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
2032
2033             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2034             serviceResponseInformationBuilder.setInstanceId(siid);
2035             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2036             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2037
2038         } catch (IllegalStateException e) {
2039             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2040             responseBuilder.setResponseCode("500");
2041             responseBuilder.setResponseMessage(e.getMessage());
2042             responseBuilder.setAckFinalIndicator("Y");
2043             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2044
2045             RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
2046                 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2047
2048             return Futures.immediateFuture(rpcResult);
2049         }
2050
2051         // Update succeeded
2052         responseBuilder.setResponseCode(responseObject.getStatusCode());
2053         responseBuilder.setAckFinalIndicator(ackFinal);
2054         trySetResponseMessage(responseBuilder, responseObject);
2055         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2056         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2057
2058         RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
2059             .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2060
2061         return Futures.immediateFuture(rpcResult);
2062     }
2063
2064     private void trySetResponseMessage(ContrailRouteTopologyOperationOutputBuilder responseBuilder,
2065         ResponseObject responseObject) {
2066         if (responseObject.getMessage() != null) {
2067             responseBuilder.setResponseMessage(responseObject.getMessage());
2068         }
2069     }
2070
2071     private void trySaveService(ContrailRouteTopologyOperationInput input, ServiceBuilder serviceBuilder) {
2072         if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
2073             || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
2074             // Only update operational tree on activate or delete
2075             log.info(UPDATING_TREE_INFO_MESSAGE);
2076             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2077         }
2078     }
2079
2080     private void trySetSvcRequestId(ContrailRouteTopologyOperationInput input,
2081         ContrailRouteTopologyOperationOutputBuilder responseBuilder) {
2082         if (input.getSdncRequestHeader() != null) {
2083             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2084         }
2085     }
2086
2087     private boolean hasInvalidServiceId(ContrailRouteTopologyOperationInput input) {
2088         return input == null || input.getServiceInformation() == null
2089             || input.getServiceInformation().getServiceInstanceId() == null
2090             || input.getServiceInformation().getServiceInstanceId().length() == 0;
2091     }
2092
2093     private ListenableFuture<RpcResult<ContrailRouteTopologyOperationOutput>> buildRpcResultFuture(
2094         ContrailRouteTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
2095         responseBuilder.setResponseCode("404");
2096         responseBuilder.setResponseMessage(responseMessage);
2097         responseBuilder.setAckFinalIndicator("Y");
2098
2099         RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
2100             .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2101
2102         return Futures.immediateFuture(rpcResult);
2103     }
2104
2105     private boolean isValidRequest(ContrailRouteTopologyOperationInput input) {
2106         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
2107     }
2108
2109     @Override
2110     public ListenableFuture<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
2111         SecurityZoneTopologyOperationInput input) {
2112
2113         final String svcOperation = "security-zone-topology-operation";
2114         ServiceData serviceData;
2115         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2116         Properties parms = new Properties();
2117
2118         log.info(CALLED_STR, svcOperation);
2119         // create a new response object
2120         SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
2121
2122         if (this.hasInvalidServiceId(input)) {
2123             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2124             return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
2125         }
2126
2127         String siid = input.getServiceInformation().getServiceInstanceId();
2128
2129         // Get the service-instance service data from MD-SAL
2130         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2131         getServiceData(siid, serviceDataBuilder);
2132         trySetSvcRequestId(input, responseBuilder);
2133
2134         ServiceData sd = serviceDataBuilder.build();
2135         if (isInvalidServiceData(sd)) {
2136             log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
2137             return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
2138         }
2139
2140         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2141         SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
2142         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2143
2144         // Call SLI sync method
2145
2146         Properties respProps = null;
2147
2148         ResponseObject responseObject = new ResponseObject("200", "");
2149         String ackFinal = "Y";
2150         String allottedResourceId = ERROR_NETWORK_ID;
2151         String serviceObjectPath = null;
2152         String securityZoneObjectPath = null;
2153
2154         try {
2155             if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2156
2157                 try {
2158                     respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
2159                 } catch (Exception e) {
2160                     log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2161                     responseObject.setMessage(e.getMessage());
2162                     responseObject.setStatusCode("500");
2163                 }
2164             } else {
2165                 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2166                 responseObject.setStatusCode("503");
2167             }
2168         } catch (Exception e) {
2169             responseObject.setStatusCode("500");
2170             responseObject.setMessage(e.getMessage());
2171             log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2172         }
2173
2174         if (respProps != null) {
2175             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2176             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2177             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2178             allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2179             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2180             securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
2181         }
2182
2183         if (failed(responseObject)) {
2184             responseBuilder.setResponseCode(responseObject.getStatusCode());
2185             responseBuilder.setResponseMessage(responseObject.getMessage());
2186             responseBuilder.setAckFinalIndicator(ackFinal);
2187             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2188
2189             RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
2190                 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2191
2192             return Futures.immediateFuture(rpcResult);
2193         }
2194
2195         // Got success from SLI
2196         try {
2197
2198             serviceData = serviceDataBuilder.build();
2199             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
2200
2201             // service object
2202             ServiceBuilder serviceBuilder = new ServiceBuilder();
2203             serviceBuilder.setServiceData(serviceData);
2204             serviceBuilder.setServiceInstanceId(siid);
2205             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2206             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2207
2208             trySaveService(input, serviceBuilder);
2209
2210             SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
2211             securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
2212             securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
2213             responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
2214
2215             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2216             serviceResponseInformationBuilder.setInstanceId(siid);
2217             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2218             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2219
2220         } catch (IllegalStateException e) {
2221             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2222             responseBuilder.setResponseCode("500");
2223             responseBuilder.setResponseMessage(e.getMessage());
2224             responseBuilder.setAckFinalIndicator("Y");
2225             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2226
2227             RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
2228                 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2229
2230             return Futures.immediateFuture(rpcResult);
2231         }
2232
2233         // Update succeeded
2234         responseBuilder.setResponseCode(responseObject.getStatusCode());
2235         responseBuilder.setAckFinalIndicator(ackFinal);
2236         trySetResponseMessage(responseBuilder, responseObject);
2237         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2238         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2239
2240         RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
2241             .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2242
2243         return Futures.immediateFuture(rpcResult);
2244     }
2245
2246     private void trySetResponseMessage(SecurityZoneTopologyOperationOutputBuilder responseBuilder,
2247         ResponseObject responseObject) {
2248         if (responseObject.getMessage() != null) {
2249             responseBuilder.setResponseMessage(responseObject.getMessage());
2250         }
2251     }
2252
2253     private void trySaveService(SecurityZoneTopologyOperationInput input, ServiceBuilder serviceBuilder) {
2254         if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
2255             || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
2256             // Only update operational tree on activate or delete
2257             log.info(UPDATING_TREE_INFO_MESSAGE);
2258             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2259         }
2260     }
2261
2262     private void trySetSvcRequestId(SecurityZoneTopologyOperationInput input,
2263         SecurityZoneTopologyOperationOutputBuilder responseBuilder) {
2264         if (input.getSdncRequestHeader() != null) {
2265             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2266         }
2267     }
2268
2269     private boolean isInvalidServiceData(ServiceData sd) {
2270         return sd == null || sd.getServiceLevelOperStatus() == null;
2271     }
2272
2273     private boolean hasInvalidServiceId(SecurityZoneTopologyOperationInput input) {
2274         return input == null || input.getServiceInformation() == null
2275             || input.getServiceInformation().getServiceInstanceId() == null
2276             || input.getServiceInformation().getServiceInstanceId().length() == 0;
2277     }
2278
2279     private ListenableFuture<RpcResult<SecurityZoneTopologyOperationOutput>> buildRpcResultFuture(
2280         SecurityZoneTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
2281
2282         responseBuilder.setResponseCode("404");
2283         responseBuilder.setResponseMessage(responseMessage);
2284         responseBuilder.setAckFinalIndicator("Y");
2285
2286         RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
2287             .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2288
2289         return Futures.immediateFuture(rpcResult);
2290     }
2291
2292     private boolean isValidRequest(SecurityZoneTopologyOperationInput input) {
2293         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
2294     }
2295
2296
2297     private boolean hasInvalidServiceId(ConnectionAttachmentTopologyOperationInput input) {
2298         return input == null || input.getServiceInformation() == null
2299             || input.getServiceInformation().getServiceInstanceId() == null
2300             || input.getServiceInformation().getServiceInstanceId().length() == 0;
2301     }
2302
2303     private void trySetResponseMessage(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder,
2304         ResponseObject error) {
2305         if (!error.getMessage().isEmpty()) {
2306             responseBuilder.setResponseMessage(error.getMessage());
2307         }
2308     }
2309
2310     private void trySetSvcRequestId(ConnectionAttachmentTopologyOperationInput input,
2311         ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder) {
2312         if (input.getSdncRequestHeader() != null) {
2313             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2314         }
2315     }
2316
2317     private ListenableFuture<RpcResult<ConnectionAttachmentTopologyOperationOutput>>
2318     buildRpcResultFuture(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
2319
2320         responseBuilder.setResponseCode("404");
2321         responseBuilder.setResponseMessage(responseMessage);
2322         responseBuilder.setAckFinalIndicator("Y");
2323
2324         RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2325             .<ConnectionAttachmentTopologyOperationOutput>status(true)
2326             .withResult(responseBuilder.build())
2327             .build();
2328
2329         return Futures.immediateFuture(rpcResult);
2330     }
2331
2332     private void trySaveService(ConnectionAttachmentTopologyOperationInput input, ServiceBuilder serviceBuilder) {
2333         if (isValidRequest(input) &&
2334             (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
2335                 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
2336             // Only update operational tree on activate or delete
2337             log.info(UPDATING_TREE_INFO_MESSAGE);
2338             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2339         }
2340     }
2341
2342     private boolean isValidRequest(ConnectionAttachmentTopologyOperationInput input) {
2343         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
2344     }
2345
2346     @Override
2347     public ListenableFuture<RpcResult<ConnectionAttachmentTopologyOperationOutput>> connectionAttachmentTopologyOperation(
2348         ConnectionAttachmentTopologyOperationInput input) {
2349         final String svcOperation = "connection-attachment-topology-operation";
2350         Properties parms = new Properties();
2351         log.info(CALLED_STR, svcOperation);
2352
2353         // create a new response object
2354         ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder = new ConnectionAttachmentTopologyOperationOutputBuilder();
2355         if (hasInvalidServiceId(input)) {
2356             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2357             responseBuilder.setResponseCode("404");
2358             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2359             responseBuilder.setAckFinalIndicator("Y");
2360
2361             RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2362                 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2363                 .withResult(responseBuilder.build())
2364                 .build();
2365
2366             return Futures.immediateFuture(rpcResult);
2367         }
2368
2369         ServiceData serviceData;
2370         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2371
2372         String siid = input.getServiceInformation().getServiceInstanceId();
2373         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2374
2375         // Get the service-instance service data from MD-SAL
2376         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2377         getServiceData(siid, serviceDataBuilder);
2378
2379         trySetSvcRequestId(input, responseBuilder);
2380
2381         ServiceData sd = serviceDataBuilder.build();
2382         if (isInvalidServiceData(sd)) {
2383             log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
2384             return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
2385         }
2386
2387         ConnectionAttachmentTopologyOperationInputBuilder inputBuilder = new ConnectionAttachmentTopologyOperationInputBuilder(
2388             input);
2389         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2390
2391         // Call SLI sync method
2392         // Get SvcLogicService reference
2393         ResponseObject responseObject = new ResponseObject("200", "");
2394         String ackFinal = "Y";
2395         String allottedResourceId = ERROR_NETWORK_ID;
2396         String serviceObjectPath = null;
2397         String connectionAttachmentObjectPath = null;
2398
2399         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2400
2401         if (respProps != null) {
2402             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2403             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2404             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2405             allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2406             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2407             connectionAttachmentObjectPath = respProps.getProperty("connection-attachment-object-path");
2408         }
2409
2410         if (failed(responseObject)) {
2411             responseBuilder.setResponseCode(responseObject.getStatusCode());
2412             responseBuilder.setResponseMessage(responseObject.getMessage());
2413             responseBuilder.setAckFinalIndicator(ackFinal);
2414
2415             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2416
2417             RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2418                 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2419                 .withResult(responseBuilder.build())
2420                 .build();
2421
2422             return Futures.immediateFuture(rpcResult);
2423         }
2424
2425         // Got success from SLI
2426         try {
2427
2428             serviceData = serviceDataBuilder.build();
2429             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
2430
2431             // service object
2432             ServiceBuilder serviceBuilder = new ServiceBuilder();
2433             serviceBuilder.setServiceData(serviceData);
2434             serviceBuilder.setServiceInstanceId(siid);
2435             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2436             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2437
2438             trySaveService(input, serviceBuilder);
2439
2440             ConnectionAttachmentResponseInformationBuilder connectionAttachmentResponseInformationBuilder = new ConnectionAttachmentResponseInformationBuilder();
2441             connectionAttachmentResponseInformationBuilder.setInstanceId(allottedResourceId);
2442             connectionAttachmentResponseInformationBuilder.setObjectPath(connectionAttachmentObjectPath);
2443             responseBuilder
2444                 .setConnectionAttachmentResponseInformation(connectionAttachmentResponseInformationBuilder.build());
2445
2446             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2447             serviceResponseInformationBuilder.setInstanceId(siid);
2448             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2449             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2450
2451         } catch (IllegalStateException e) {
2452             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2453             responseBuilder.setResponseCode("500");
2454             responseBuilder.setResponseMessage(e.getMessage());
2455             responseBuilder.setAckFinalIndicator("Y");
2456             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2457
2458             RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2459                 .<ConnectionAttachmentTopologyOperationOutput>status(true)
2460                 .withResult(responseBuilder.build())
2461                 .build();
2462
2463             return Futures.immediateFuture(rpcResult);
2464         }
2465
2466         // Update succeeded
2467         responseBuilder.setResponseCode(responseObject.getStatusCode());
2468         responseBuilder.setAckFinalIndicator(ackFinal);
2469         trySetResponseMessage(responseBuilder, responseObject);
2470         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2471         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2472
2473         RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2474             .<ConnectionAttachmentTopologyOperationOutput>status(true)
2475             .withResult(responseBuilder.build())
2476             .build();
2477
2478         return Futures.immediateFuture(rpcResult);
2479     }
2480
2481     @Override
2482     public ListenableFuture<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
2483         TunnelxconnTopologyOperationInput input) {
2484
2485         final String svcOperation = "tunnelxconn-topology-operation";
2486         Properties parms = new Properties();
2487         log.info(CALLED_STR, svcOperation);
2488
2489         // create a new response object
2490         TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
2491         if (hasInvalidServiceId(input)) {
2492             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2493             responseBuilder.setResponseCode("404");
2494             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2495             responseBuilder.setAckFinalIndicator("Y");
2496
2497             RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2498                 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2499
2500             return Futures.immediateFuture(rpcResult);
2501         }
2502         String siid = input.getServiceInformation().getServiceInstanceId();
2503         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2504         TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
2505         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2506
2507         // Call SLI sync method
2508
2509         ResponseObject responseObject = new ResponseObject("200", "");
2510         String ackFinal = "Y";
2511         String allottedResourceId = ERROR_NETWORK_ID;
2512         String serviceObjectPath = null;
2513         String tunnelxconnObjectPath = null;
2514         Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2515
2516         if (respProps != null) {
2517             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2518             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2519             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2520             allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2521             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2522             tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
2523         }
2524
2525         if (failed(responseObject)) {
2526             responseBuilder.setResponseCode(responseObject.getStatusCode());
2527             responseBuilder.setResponseMessage(responseObject.getMessage());
2528             responseBuilder.setAckFinalIndicator(ackFinal);
2529
2530             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2531
2532             RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2533                 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2534
2535             return Futures.immediateFuture(rpcResult);
2536         }
2537
2538         // Got success from SLI
2539         try {
2540             TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
2541             tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
2542             tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
2543             responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
2544
2545             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2546             serviceResponseInformationBuilder.setInstanceId(siid);
2547             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2548             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2549
2550         } catch (IllegalStateException e) {
2551             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2552             responseBuilder.setResponseCode("500");
2553             responseBuilder.setResponseMessage(e.getMessage());
2554             responseBuilder.setAckFinalIndicator("Y");
2555             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2556
2557             RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2558                 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2559
2560             return Futures.immediateFuture(rpcResult);
2561         }
2562
2563         // Update succeeded
2564         responseBuilder.setResponseCode(responseObject.getStatusCode());
2565         responseBuilder.setAckFinalIndicator(ackFinal);
2566         trySetResponseMessage(responseBuilder, responseObject);
2567         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2568         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2569
2570         RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2571             .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2572
2573         return Futures.immediateFuture(rpcResult);
2574     }
2575
2576     private void trySetResponseMessage(TunnelxconnTopologyOperationOutputBuilder responseBuilder,
2577         ResponseObject responseObject) {
2578         if (responseObject.getMessage() != null) {
2579             responseBuilder.setResponseMessage(responseObject.getMessage());
2580         }
2581     }
2582
2583     private boolean hasInvalidServiceId(TunnelxconnTopologyOperationInput input) {
2584         return input == null || input.getServiceInformation() == null
2585             || input.getServiceInformation().getServiceInstanceId() == null
2586             || input.getServiceInformation().getServiceInstanceId().length() == 0;
2587     }
2588
2589     private Properties tryGetProperties(String svcOperation, Properties parms, ResponseObject responseObject) {
2590         try {
2591             if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2592
2593                 try {
2594                     return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
2595                 } catch (Exception e) {
2596                     log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2597                     responseObject.setMessage(e.getMessage());
2598                     responseObject.setStatusCode("500");
2599                 }
2600             } else {
2601                 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2602                 responseObject.setStatusCode("503");
2603             }
2604         } catch (Exception e) {
2605             responseObject.setMessage(e.getMessage());
2606             responseObject.setStatusCode("500");
2607             log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2608         }
2609         return null;
2610     }
2611
2612     @Override
2613     public ListenableFuture<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(
2614         BrgTopologyOperationInput input) {
2615         final String svcOperation = "brg-topology-operation";
2616         Properties parms = new Properties();
2617
2618         log.info(CALLED_STR, svcOperation);
2619         // create a new response object
2620         BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
2621
2622         if (this.hasInvalidServiceId(input)) {
2623
2624             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2625             responseBuilder.setResponseCode("404");
2626             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2627             responseBuilder.setAckFinalIndicator("Y");
2628
2629             RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2630                 .withResult(responseBuilder.build()).build();
2631
2632             return Futures.immediateFuture(rpcResult);
2633         }
2634
2635         String siid = input.getServiceInformation().getServiceInstanceId();
2636
2637         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2638         BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
2639         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2640
2641         // Call SLI sync method
2642
2643         ResponseObject responseObject = new ResponseObject("200", "");
2644         String ackFinal = "Y";
2645         String allottedResourceId = ERROR_NETWORK_ID;
2646         String serviceObjectPath = null;
2647         String brgObjectPath = null;
2648         Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2649
2650         if (respProps != null) {
2651             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2652             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2653             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2654             allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2655             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2656             brgObjectPath = respProps.getProperty("brg-object-path");
2657         }
2658
2659         if (failed(responseObject)) {
2660             responseBuilder.setResponseCode(responseObject.getStatusCode());
2661             responseBuilder.setResponseMessage(responseObject.getMessage());
2662             responseBuilder.setAckFinalIndicator(ackFinal);
2663
2664             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2665             RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2666                 .withResult(responseBuilder.build()).build();
2667
2668             return Futures.immediateFuture(rpcResult);
2669         }
2670
2671         // Got success from SLI
2672         try {
2673
2674             BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
2675             brgResponseInformationBuilder.setInstanceId(allottedResourceId);
2676             brgResponseInformationBuilder.setObjectPath(brgObjectPath);
2677             responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
2678
2679             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2680             serviceResponseInformationBuilder.setInstanceId(siid);
2681             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2682             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2683
2684         } catch (IllegalStateException e) {
2685             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2686             responseBuilder.setResponseCode("500");
2687             responseBuilder.setResponseMessage(e.getMessage());
2688             responseBuilder.setAckFinalIndicator("Y");
2689             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2690
2691             RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2692                 .withResult(responseBuilder.build()).build();
2693
2694             return Futures.immediateFuture(rpcResult);
2695         }
2696
2697         // Update succeeded
2698         responseBuilder.setResponseCode(responseObject.getStatusCode());
2699         responseBuilder.setAckFinalIndicator(ackFinal);
2700         trySetResponseMessage(responseBuilder, responseObject);
2701         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2702         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2703
2704         RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2705             .withResult(responseBuilder.build()).build();
2706
2707         return Futures.immediateFuture(rpcResult);
2708     }
2709
2710     private void trySetResponseMessage(BrgTopologyOperationOutputBuilder responseBuilder,
2711         ResponseObject responseObject) {
2712         if (responseObject.getMessage() != null) {
2713             responseBuilder.setResponseMessage(responseObject.getMessage());
2714         }
2715     }
2716
2717     private boolean hasInvalidServiceId(BrgTopologyOperationInput input) {
2718         return input == null || input.getServiceInformation() == null
2719             || input.getServiceInformation().getServiceInstanceId() == null
2720             || input.getServiceInformation().getServiceInstanceId().length() == 0;
2721     }
2722
2723     private String resolveAckFinal(ResponseObject responseObject, Properties respProps) {
2724         if (respProps != null) {
2725             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2726             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2727             return respProps.getProperty(ACK_FINAL_PARAM, "Y");
2728         }
2729         return "Y";
2730     }
2731
2732     @Override
2733     public ListenableFuture<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2734         PreloadNetworkTopologyOperationInput input) {
2735
2736         final String svcOperation = "preload-network-topology-operation";
2737         PreloadData preloadData;
2738         Properties properties = new Properties();
2739
2740         log.info(CALLED_STR, svcOperation);
2741         // create a new response object
2742         PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2743
2744         if (hasInvalidPreloadNetwork(input)) {
2745             log.debug("exiting {} because of null or empty preload-network-topology-information", svcOperation);
2746             responseBuilder.setResponseCode("403");
2747             responseBuilder.setResponseMessage("invalid input, null or empty preload-network-topology-information");
2748             responseBuilder.setAckFinalIndicator("Y");
2749
2750             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2751                 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2752
2753             return Futures.immediateFuture(rpcResult);
2754         }
2755
2756         // Grab the preload ID from the input buffer
2757         String preloadId = input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure()
2758             .getNetworkName();
2759         String preloadType = "network";
2760
2761         trySetSvcRequestId(input, responseBuilder);
2762
2763         PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2764         getPreloadData(preloadId, preloadType, preloadDataBuilder);
2765
2766         PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2767         getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2768
2769         //
2770         // setup a preload-data object builder
2771         // ACTION preload-network-topology-operation
2772         // INPUT:
2773         // uses sdnc-request-header;
2774         // uses request-information;
2775         // uses preload-network-topology-information;
2776         // OUTPUT:
2777         // uses preload-topology-response-body;
2778         //
2779         // container preload-data
2780         // uses preload-network-topology-information;
2781         // uses preload-oper-status;
2782
2783         log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
2784         PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2785             input);
2786         GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2787         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
2788         GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
2789
2790         // Call SLI sync method
2791         ResponseObject responseObject = new ResponseObject("200", "");
2792         String ackFinal = "Y";
2793         Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
2794
2795         if (respProps != null) {
2796             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2797             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2798             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2799         }
2800
2801         if (failed(responseObject)) {
2802             responseBuilder.setResponseCode(responseObject.getStatusCode());
2803             responseBuilder.setResponseMessage(responseObject.getMessage());
2804             responseBuilder.setAckFinalIndicator(ackFinal);
2805             log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2806             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2807                 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2808             return Futures.immediateFuture(rpcResult);
2809         }
2810
2811         // Got success from SLI
2812         try {
2813             preloadData = preloadDataBuilder.build();
2814             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
2815
2816             // preload-list object
2817             PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
2818             preloadListBuilder.setPreloadId(preloadId);
2819             preloadListBuilder.setPreloadType(preloadType);
2820             preloadListBuilder.setPreloadData(preloadData);
2821
2822             savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2823             log.info(UPDATING_TREE_INFO_MESSAGE);
2824             savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2825
2826             tryDeletePreload(input, preloadListBuilder);
2827         } catch (Exception e) {
2828             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
2829             responseBuilder.setResponseCode("500");
2830             responseBuilder.setResponseMessage(e.getMessage());
2831             responseBuilder.setAckFinalIndicator("Y");
2832             log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2833             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2834                 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2835             return Futures.immediateFuture(rpcResult);
2836         }
2837
2838         // Update succeeded
2839         responseBuilder.setResponseCode(responseObject.getStatusCode());
2840         responseBuilder.setAckFinalIndicator(ackFinal);
2841         trySetResponseMessage(responseBuilder, responseObject);
2842         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, preloadId);
2843         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2844
2845         RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2846             .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2847         return Futures.immediateFuture(rpcResult);
2848     }
2849
2850     private boolean hasInvalidPreloadNetwork(PreloadNetworkTopologyOperationInput input) {
2851         return input == null || input.getPreloadNetworkTopologyInformation() == null
2852             || input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure() == null;
2853     }
2854
2855     private boolean hasInvalidPreloadId(String preloadId) {
2856         return preloadId == null || preloadId.length() == 0;
2857     }
2858
2859     private void trySetSvcRequestId(PreloadNetworkTopologyOperationInput input,
2860         PreloadNetworkTopologyOperationOutputBuilder responseBuilder) {
2861         if (input.getSdncRequestHeader() != null) {
2862             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2863         }
2864     }
2865
2866     private Properties tryGetProperties(String svcOperation, Properties parms, PreloadDataBuilder preloadDataBuilder,
2867         ResponseObject responseObject) {
2868         try {
2869             if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2870                 try {
2871                     return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", preloadDataBuilder, parms);
2872                 } catch (Exception e) {
2873                     log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2874                     responseObject.setMessage(e.getMessage());
2875                     responseObject.setStatusCode("500");
2876                 }
2877             } else {
2878                 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2879                 responseObject.setStatusCode("503");
2880             }
2881         } catch (Exception e) {
2882             responseObject.setMessage(e.getMessage());
2883             responseObject.setStatusCode("500");
2884             log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2885         }
2886
2887         return null;
2888     }
2889
2890     private void trySetResponseMessage(PreloadNetworkTopologyOperationOutputBuilder responseBuilder,
2891         ResponseObject responseObject) {
2892         if (responseObject.getMessage() != null) {
2893             if (!responseObject.getMessage().isEmpty()) {
2894                 responseBuilder.setResponseMessage(responseObject.getMessage());
2895             }
2896         }
2897     }
2898
2899     private void tryDeletePreload(PreloadNetworkTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
2900         if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
2901             log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
2902             deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
2903             deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
2904         }
2905     }
2906
2907     @Override
2908     public ListenableFuture<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2909         PreloadVfModuleTopologyOperationInput input) {
2910
2911         final String svcOperation = "preload-vf-module-topology-operation";
2912         PreloadData preloadData;
2913         Properties properties = new Properties();
2914
2915         log.info(CALLED_STR, svcOperation);
2916         // create a new response object
2917         PreloadVfModuleTopologyOperationOutputBuilder responseBuilder = new PreloadVfModuleTopologyOperationOutputBuilder();
2918
2919         if (hasInvalidPreloadVfModule(input)) {
2920             log.debug(
2921                 "exiting {} because of null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name",
2922                 svcOperation);
2923             responseBuilder.setResponseCode("403");
2924             responseBuilder.setResponseMessage(
2925                 "invalid input, null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name");
2926             responseBuilder.setAckFinalIndicator("Y");
2927
2928             RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2929                 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2930
2931             return Futures.immediateFuture(rpcResult);
2932         }
2933
2934         // Grab the preload ID from the input buffer
2935         String preloadId = input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
2936             .getVfModuleTopologyIdentifier().getVfModuleName();
2937         String preloadType = "vf-module";
2938
2939         trySetSvcRequestId(input, responseBuilder);
2940
2941         PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2942         getPreloadData(preloadId, preloadType, preloadDataBuilder);
2943
2944         PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2945         getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2946
2947         //
2948         // setup a preload-data object builder
2949         // ACTION preload-vf-module-topology-operation
2950         // INPUT:
2951         // uses sdnc-request-header;
2952         // uses request-information;
2953         // uses preload-vnf-topology-information;
2954         // OUTPUT:
2955         // uses preload-topology-response-body;
2956         //
2957         // container preload-data
2958         // uses preload-vf-module-topology-information;
2959         // uses preload-oper-status;
2960
2961         log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
2962         PreloadVfModuleTopologyOperationInputBuilder inputBuilder = new PreloadVfModuleTopologyOperationInputBuilder(
2963             input);
2964         GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2965         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
2966         GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
2967
2968         // Call SLI sync method
2969         ResponseObject responseObject = new ResponseObject("200", "");
2970         String ackFinal = "Y";
2971         Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
2972
2973         if (respProps != null) {
2974             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2975             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2976             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2977         }
2978
2979         if (failed(responseObject)) {
2980             responseBuilder.setResponseCode(responseObject.getStatusCode());
2981             responseBuilder.setResponseMessage(responseObject.getMessage());
2982             responseBuilder.setAckFinalIndicator(ackFinal);
2983             log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2984             RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2985                 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2986             return Futures.immediateFuture(rpcResult);
2987         }
2988
2989         // Got success from SLI
2990         try {
2991             preloadData = preloadDataBuilder.build();
2992             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
2993
2994             // preload-list object
2995             PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
2996             preloadListBuilder.setPreloadId(preloadId);
2997             preloadListBuilder.setPreloadType(preloadType);
2998             preloadListBuilder.setPreloadData(preloadData);
2999
3000             savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3001             log.info(UPDATING_TREE_INFO_MESSAGE);
3002             savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3003
3004             tryDeletePreload(input, preloadListBuilder);
3005
3006         } catch (Exception e) {
3007             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
3008             responseBuilder.setResponseCode("500");
3009             responseBuilder.setResponseMessage(e.getMessage());
3010             responseBuilder.setAckFinalIndicator("Y");
3011             log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
3012             RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
3013                 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3014             return Futures.immediateFuture(rpcResult);
3015         }
3016
3017         // Update succeeded
3018         responseBuilder.setResponseCode(responseObject.getStatusCode());
3019         responseBuilder.setAckFinalIndicator(ackFinal);
3020         trySetResponseMessage(responseBuilder, responseObject);
3021         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, preloadId);
3022         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
3023
3024         RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
3025             .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3026         return Futures.immediateFuture(rpcResult);
3027     }
3028
3029     private boolean hasInvalidPreloadVfModule(PreloadVfModuleTopologyOperationInput input) {
3030         return input == null || input.getPreloadVfModuleTopologyInformation() == null
3031             || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology() == null
3032             || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
3033             .getVfModuleTopologyIdentifier() == null
3034             || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology().getVfModuleTopologyIdentifier()
3035             .getVfModuleName() == null;
3036     }
3037
3038     private void trySetSvcRequestId(PreloadVfModuleTopologyOperationInput input,
3039         PreloadVfModuleTopologyOperationOutputBuilder responseBuilder) {
3040         if (input.getSdncRequestHeader() != null) {
3041             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3042         }
3043     }
3044
3045     private void trySetResponseMessage(PreloadVfModuleTopologyOperationOutputBuilder responseBuilder,
3046         ResponseObject responseObject) {
3047         if (responseObject.getMessage() != null) {
3048             if (!responseObject.getMessage().isEmpty()) {
3049                 responseBuilder.setResponseMessage(responseObject.getMessage());
3050             }
3051         }
3052     }
3053
3054     private void tryDeletePreload(PreloadVfModuleTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
3055         if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
3056             log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
3057             deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
3058             deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
3059         }
3060     }
3061
3062     @Override
3063     public ListenableFuture<RpcResult<GenericConfigurationTopologyOperationOutput>> genericConfigurationTopologyOperation(
3064         GenericConfigurationTopologyOperationInput input) {
3065
3066         final String svcOperation = "generic-configuration-topology-operation";
3067         ServiceData serviceData;
3068         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3069         Properties parms = new Properties();
3070
3071         log.info(CALLED_STR, svcOperation);
3072         // create a new response object
3073         GenericConfigurationTopologyOperationOutputBuilder responseBuilder = new GenericConfigurationTopologyOperationOutputBuilder();
3074
3075         if (hasInvalidService(input)) {
3076             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3077             responseBuilder.setResponseCode("404");
3078             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
3079             responseBuilder.setAckFinalIndicator("Y");
3080
3081             RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
3082                 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
3083                 .build();
3084
3085             return Futures.immediateFuture(rpcResult);
3086         }
3087
3088         // Grab the service instance ID from the input buffer
3089         String siid = input.getServiceInformation().getServiceInstanceId();
3090
3091         trySetSvcRequestId(input, responseBuilder);
3092
3093         if (hasInvalidConfigurationIdOrType(input)) {
3094             log.debug("exiting {} because of null or empty configuration-id or configuration-type", svcOperation);
3095             responseBuilder.setResponseCode("404");
3096             responseBuilder.setResponseMessage("invalid input, null or empty configuration-id or configuration-type");
3097             responseBuilder.setAckFinalIndicator("Y");
3098             RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
3099                 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
3100                 .build();
3101             return Futures.immediateFuture(rpcResult);
3102         }
3103
3104         // Grab the configuration ID from the input buffer
3105         String configId = input.getConfigurationInformation().getConfigurationId();
3106
3107         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3108         getServiceData(siid, serviceDataBuilder);
3109
3110         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3111         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3112
3113         // Set the serviceStatus based on input
3114         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3115         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3116
3117         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3118         GenericConfigurationTopologyOperationInputBuilder inputBuilder = new GenericConfigurationTopologyOperationInputBuilder(
3119             input);
3120         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3121
3122         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3123         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3124
3125         // Call SLI sync method
3126
3127         ResponseObject responseObject = new ResponseObject("200", "");
3128         String ackFinal = "Y";
3129         String serviceObjectPath = "";
3130         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3131
3132         if (respProps != null) {
3133             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3134             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3135             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3136             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
3137         }
3138
3139         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3140         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3141         serviceStatusBuilder.setRpcName(svcOperation);
3142
3143         if (failed(responseObject)) {
3144             responseBuilder.setResponseCode(responseObject.getStatusCode());
3145             responseBuilder.setResponseMessage(responseObject.getMessage());
3146             responseBuilder.setAckFinalIndicator(ackFinal);
3147
3148             ServiceBuilder serviceBuilder = new ServiceBuilder();
3149             serviceBuilder.setServiceInstanceId(siid);
3150             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3151             try {
3152                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3153             } catch (Exception e) {
3154                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3155             }
3156             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3157
3158             RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
3159                 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
3160                 .build();
3161
3162             return Futures.immediateFuture(rpcResult);
3163         }
3164
3165         // Got success from SLI
3166         try {
3167             serviceData = serviceDataBuilder.build();
3168
3169             // service object
3170             ServiceBuilder serviceBuilder = new ServiceBuilder();
3171             serviceBuilder.setServiceData(serviceData);
3172             serviceBuilder.setServiceInstanceId(siid);
3173             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3174             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3175
3176             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3177             serviceResponseInformationBuilder.setInstanceId(siid);
3178             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3179             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
3180             GcResponseInformationBuilder gcResponseInformationBuilder = new GcResponseInformationBuilder();
3181             gcResponseInformationBuilder.setInstanceId(configId);
3182             responseBuilder.setGcResponseInformation(gcResponseInformationBuilder.build());
3183
3184         } catch (Exception e) {
3185             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3186             responseBuilder.setResponseCode("500");
3187             responseBuilder.setResponseMessage(e.getMessage());
3188             responseBuilder.setAckFinalIndicator("Y");
3189             RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
3190                 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
3191                 .build();
3192
3193             return Futures.immediateFuture(rpcResult);
3194         }
3195
3196         // Update succeeded
3197         responseBuilder.setResponseCode(responseObject.getStatusCode());
3198         responseBuilder.setAckFinalIndicator(ackFinal);
3199         trySetResponseMessage(responseBuilder, responseObject);
3200         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3201         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3202
3203         RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
3204             .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3205
3206         return Futures.immediateFuture(rpcResult);
3207     }
3208
3209     private boolean hasInvalidService(GenericConfigurationTopologyOperationInput input) {
3210         return input == null || input.getServiceInformation() == null
3211             || input.getServiceInformation().getServiceInstanceId() == null
3212             || input.getServiceInformation().getServiceInstanceId().length() == 0;
3213     }
3214
3215     private void trySetSvcRequestId(GenericConfigurationTopologyOperationInput input,
3216         GenericConfigurationTopologyOperationOutputBuilder responseBuilder) {
3217         if (input.getSdncRequestHeader() != null) {
3218             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3219         }
3220     }
3221
3222     private boolean hasInvalidConfigurationIdOrType(GenericConfigurationTopologyOperationInput input) {
3223         return input.getConfigurationInformation() == null
3224             || input.getConfigurationInformation().getConfigurationId() == null
3225             || input.getConfigurationInformation().getConfigurationType() == null;
3226     }
3227
3228     private void trySetResponseMessage(GenericConfigurationTopologyOperationOutputBuilder responseBuilder,
3229         ResponseObject responseObject) {
3230         if (responseObject.getMessage() != null) {
3231             if (!responseObject.getMessage().isEmpty()) {
3232                 responseBuilder.setResponseMessage(responseObject.getMessage());
3233             }
3234         }
3235     }
3236
3237     @Override
3238     public ListenableFuture<RpcResult<GenericConfigurationNotificationOutput>> genericConfigurationNotification(
3239         GenericConfigurationNotificationInput input) {
3240
3241         final String svcOperation = "generic-configuration-notification";
3242         ServiceData serviceData;
3243         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3244         Properties parms = new Properties();
3245
3246         log.info(CALLED_STR, svcOperation);
3247
3248         // Grab the service instance ID from the input buffer
3249         String siid = input.getServiceInformation().getServiceInstanceId();
3250
3251         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3252         getServiceData(siid, serviceDataBuilder);
3253
3254         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3255         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3256
3257         // Set the serviceStatus based on input
3258         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3259         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3260
3261         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3262         GenericConfigurationNotificationInputBuilder inputBuilder = new GenericConfigurationNotificationInputBuilder(
3263             input);
3264         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3265
3266         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3267         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3268
3269         // Call SLI sync method
3270
3271         ResponseObject responseObject = new ResponseObject("200", "");
3272         String ackFinal = "Y";
3273         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3274
3275         if (respProps != null) {
3276             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3277             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3278             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3279         }
3280
3281         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3282         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3283         serviceStatusBuilder.setRpcName(svcOperation);
3284
3285         if (failed(responseObject)) {
3286             ServiceBuilder serviceBuilder = new ServiceBuilder();
3287             serviceBuilder.setServiceInstanceId(siid);
3288             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3289             try {
3290                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3291             } catch (Exception e) {
3292                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3293             }
3294
3295             RpcResult<GenericConfigurationNotificationOutput> rpcResult = RpcResultBuilder.<GenericConfigurationNotificationOutput>status(
3296                 true).build();
3297
3298             return Futures.immediateFuture(rpcResult);
3299         }
3300
3301         // Got success from SLI
3302         try {
3303             serviceData = serviceDataBuilder.build();
3304
3305             // service object
3306             ServiceBuilder serviceBuilder = new ServiceBuilder();
3307             serviceBuilder.setServiceData(serviceData);
3308             serviceBuilder.setServiceInstanceId(siid);
3309             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3310             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3311
3312             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3313             serviceResponseInformationBuilder.setInstanceId(siid);
3314
3315         } catch (Exception e) {
3316             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3317             RpcResult<GenericConfigurationNotificationOutput> rpcResult = RpcResultBuilder.<GenericConfigurationNotificationOutput>status(
3318                 true).build();
3319
3320             return Futures.immediateFuture(rpcResult);
3321         }
3322
3323         // Update succeeded
3324         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3325
3326         RpcResult<GenericConfigurationNotificationOutput> rpcResult = RpcResultBuilder.<GenericConfigurationNotificationOutput>status(
3327             true).build();
3328
3329         return Futures.immediateFuture(rpcResult);
3330     }
3331
3332     @Override
3333     public ListenableFuture<RpcResult<GetpathsegmentTopologyOperationOutput>> getpathsegmentTopologyOperation(
3334         GetpathsegmentTopologyOperationInput input) {
3335
3336         final String svcOperation = "getpathsegment-topology-operation";
3337         ServiceData serviceData;
3338         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3339         Properties parms = new Properties();
3340
3341         log.info(CALLED_STR, svcOperation);
3342         // create a new response object
3343         GetpathsegmentTopologyOperationOutputBuilder responseBuilder = new GetpathsegmentTopologyOperationOutputBuilder();
3344
3345         if (hasInvalidService(input)) {
3346             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3347             responseBuilder.setResponseCode("404");
3348             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
3349             responseBuilder.setAckFinalIndicator("Y");
3350
3351             RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3352                 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3353
3354             return Futures.immediateFuture(rpcResult);
3355         }
3356
3357         // Grab the service instance ID from the input buffer
3358         String siid = input.getServiceInformation().getServiceInstanceId();
3359
3360         trySetSvcRequestId(input, responseBuilder);
3361
3362         if (hasInvalidOnapModelInformation(input)) {
3363             log.debug("exiting {} because no model-uuid provided", svcOperation);
3364             responseBuilder.setResponseCode("404");
3365             responseBuilder.setResponseMessage("invalid input, no model-uuid provided");
3366             responseBuilder.setAckFinalIndicator("Y");
3367             RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3368                 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3369             return Futures.immediateFuture(rpcResult);
3370         }
3371
3372         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3373         getServiceData(siid, serviceDataBuilder);
3374
3375         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3376         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3377
3378         // Set the serviceStatus based on input
3379         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3380         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3381
3382         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3383         GetpathsegmentTopologyOperationInputBuilder inputBuilder = new GetpathsegmentTopologyOperationInputBuilder(
3384             input);
3385         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3386
3387         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3388         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3389
3390         // Call SLI sync method
3391
3392         ResponseObject responseObject = new ResponseObject("200", "");
3393         String ackFinal = "Y";
3394         String serviceObjectPath = null;
3395         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3396
3397         if (respProps != null) {
3398             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3399             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3400             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3401             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
3402         }
3403
3404         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3405         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3406         serviceStatusBuilder.setRpcName(svcOperation);
3407
3408         if (failed(responseObject)) {
3409             responseBuilder.setResponseCode(responseObject.getStatusCode());
3410             responseBuilder.setResponseMessage(responseObject.getMessage());
3411             responseBuilder.setAckFinalIndicator(ackFinal);
3412
3413             ServiceBuilder serviceBuilder = new ServiceBuilder();
3414             serviceBuilder.setServiceInstanceId(siid);
3415             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3416             try {
3417                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3418             } catch (Exception e) {
3419                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3420             }
3421             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3422
3423             RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3424                 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3425
3426             return Futures.immediateFuture(rpcResult);
3427         }
3428
3429         // Got success from SLI
3430         try {
3431             serviceData = serviceDataBuilder.build();
3432             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3433
3434             // service object
3435             ServiceBuilder serviceBuilder = new ServiceBuilder();
3436             serviceBuilder.setServiceData(serviceData);
3437             serviceBuilder.setServiceInstanceId(siid);
3438             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3439             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3440
3441             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3442             serviceResponseInformationBuilder.setInstanceId(siid);
3443             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3444             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
3445
3446         } catch (Exception e) {
3447             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3448             responseBuilder.setResponseCode("500");
3449             responseBuilder.setResponseMessage(e.getMessage());
3450             responseBuilder.setAckFinalIndicator("Y");
3451             RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3452                 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3453
3454             return Futures.immediateFuture(rpcResult);
3455         }
3456
3457         // Update succeeded
3458         responseBuilder.setResponseCode(responseObject.getStatusCode());
3459         responseBuilder.setAckFinalIndicator(ackFinal);
3460         trySetResponseMessage(responseBuilder, responseObject);
3461         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3462         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3463
3464         RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
3465             .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3466
3467         return Futures.immediateFuture(rpcResult);
3468     }
3469
3470     private boolean hasInvalidService(GetpathsegmentTopologyOperationInput input) {
3471         return input == null || input.getServiceInformation() == null
3472             || input.getServiceInformation().getServiceInstanceId() == null
3473             || input.getServiceInformation().getServiceInstanceId().length() == 0;
3474     }
3475
3476     private void trySetSvcRequestId(GetpathsegmentTopologyOperationInput input,
3477         GetpathsegmentTopologyOperationOutputBuilder responseBuilder) {
3478         if (input.getSdncRequestHeader() != null) {
3479             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3480         }
3481     }
3482
3483     private boolean hasInvalidOnapModelInformation(GetpathsegmentTopologyOperationInput input) {
3484         return input.getServiceInformation() == null || input.getServiceInformation().getOnapModelInformation() == null
3485             || input.getServiceInformation().getOnapModelInformation().getModelUuid() == null;
3486     }
3487
3488     private void trySetResponseMessage(GetpathsegmentTopologyOperationOutputBuilder responseBuilder,
3489         ResponseObject responseObject) {
3490         if (responseObject.getMessage() != null) {
3491             if (!responseObject.getMessage().isEmpty()) {
3492                 responseBuilder.setResponseMessage(responseObject.getMessage());
3493             }
3494         }
3495     }
3496
3497     @Override
3498     public ListenableFuture<RpcResult<PolicyUpdateNotifyOperationOutput>> policyUpdateNotifyOperation(
3499         PolicyUpdateNotifyOperationInput input) {
3500
3501         final String svcOperation = "policy-update-notify-operation";
3502         Properties parms = new Properties();
3503
3504         log.info(CALLED_STR, svcOperation);
3505
3506         // create a new response object
3507         PolicyUpdateNotifyOperationOutputBuilder responseBuilder = new PolicyUpdateNotifyOperationOutputBuilder();
3508
3509         // Make sure we have a valid input
3510         if (hasInvalidInput(input)) {
3511             log.debug("exiting {} because policy name, update type, or version id was not provided", svcOperation);
3512             responseBuilder.setErrorCode("404");
3513             responseBuilder.setErrorMsg("Invalid input, missing input data");
3514             RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
3515                 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3516             return Futures.immediateFuture(rpcResult);
3517         }
3518
3519         log.info("Adding INPUT data for {} input: {}", svcOperation, input);
3520         PolicyUpdateNotifyOperationInputBuilder inputBuilder = new PolicyUpdateNotifyOperationInputBuilder(input);
3521         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3522
3523         // Call SLI sync method
3524         ResponseObject responseObject = new ResponseObject("200", "");
3525         String ackFinal = "Y";
3526         String serviceObjectPath = null;
3527         Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
3528
3529         if (respProps != null) {
3530             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3531             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3532             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3533             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
3534         }
3535
3536         if (failed(responseObject)) {
3537             responseBuilder.setErrorCode(responseObject.getStatusCode());
3538             responseBuilder.setErrorMsg(responseObject.getMessage());
3539             log.error(RETURNED_FAILED_MESSAGE, svcOperation, "policy update", responseBuilder.build());
3540
3541             RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
3542                 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3543
3544             return Futures.immediateFuture(rpcResult);
3545         }
3546
3547         // Got success from SLI
3548         responseBuilder.setErrorCode(responseObject.getStatusCode());
3549         if (responseObject.getMessage() != null) {
3550             responseBuilder.setErrorMsg(responseObject.getMessage());
3551         }
3552         log.info("Returned SUCCESS for " + svcOperation + responseBuilder.build());
3553         RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
3554             .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3555         // return success
3556         return Futures.immediateFuture(rpcResult);
3557     }
3558
3559     private boolean hasInvalidInput(PolicyUpdateNotifyOperationInput input) {
3560         return (input.getPolicyName() == null) || (input.getUpdateType() == null) || (input.getVersionId() == null);
3561     }
3562
3563     @Override
3564     public ListenableFuture<RpcResult<PortMirrorTopologyOperationOutput>> portMirrorTopologyOperation(
3565         final PortMirrorTopologyOperationInput input) {
3566
3567         final String svcOperation = "port-mirror-topology-operation";
3568         ServiceData serviceData = null;
3569         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3570         Properties properties = new Properties();
3571
3572         log.info(CALLED_STR, svcOperation);
3573
3574         // create a new response object
3575         PortMirrorTopologyOperationOutputBuilder responseBuilder = new PortMirrorTopologyOperationOutputBuilder();
3576
3577         if (hasInvalidService(input)) {
3578             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3579             responseBuilder.setResponseCode("404");
3580             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
3581             responseBuilder.setAckFinalIndicator("Y");
3582             RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3583                 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3584             // return error
3585             return Futures.immediateFuture(rpcResult);
3586         }
3587
3588         if (hasInvalidConfigurationId(input)) {
3589             log.debug("exiting {} because of null or empty configuration-id", svcOperation);
3590             responseBuilder.setResponseCode("404");
3591             responseBuilder.setResponseMessage("invalid input, null or empty configuration-id");
3592             responseBuilder.setAckFinalIndicator("Y");
3593             RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3594                 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3595             return Futures.immediateFuture(rpcResult);
3596         }
3597
3598         // Grab the service instance ID from the input buffer
3599         String siid = input.getServiceInformation().getServiceInstanceId();
3600
3601         trySetSvcRequestId(input, responseBuilder);
3602
3603         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3604         getServiceData(siid, serviceDataBuilder);
3605
3606         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3607         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3608
3609         // Set the serviceStatus based on input
3610         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3611         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3612
3613         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3614         PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3615         GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
3616
3617         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3618         GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
3619
3620         // Call SLI sync method
3621         ResponseObject responseObject = new ResponseObject("200", "");
3622         String ackFinal = "Y";
3623         String serviceObjectPath = null;
3624         String portMirrorObjectPath = null;
3625         Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
3626
3627         if (respProps != null) {
3628             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3629             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3630             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3631             serviceObjectPath = respProps.getProperty("service-object-path");
3632             portMirrorObjectPath = respProps.getProperty("port-mirror-object-path");
3633         }
3634
3635         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3636         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3637         serviceStatusBuilder.setRpcName(svcOperation);
3638
3639         if (failed(responseObject)) {
3640             responseBuilder.setResponseCode(responseObject.getStatusCode());
3641             responseBuilder.setResponseMessage(responseObject.getMessage());
3642             responseBuilder.setAckFinalIndicator(ackFinal);
3643
3644             ServiceBuilder serviceBuilder = new ServiceBuilder();
3645             serviceBuilder.setServiceInstanceId(siid);
3646             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3647             try {
3648                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3649             } catch (Exception e) {
3650                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3651             }
3652             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3653
3654             RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3655                 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3656
3657             // return error
3658             return Futures.immediateFuture(rpcResult);
3659         }
3660
3661         // Got success from SLI
3662         try {
3663             serviceData = serviceDataBuilder.build();
3664             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3665
3666             // service object
3667             ServiceBuilder serviceBuilder = new ServiceBuilder();
3668             serviceBuilder.setServiceData(serviceData);
3669             serviceBuilder.setServiceInstanceId(siid);
3670             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3671             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3672
3673             if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3674                 // Only update operational tree on activate or delete
3675                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3676                     || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3677                     log.info(UPDATING_TREE_INFO_MESSAGE);
3678                     saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3679                 }
3680             }
3681
3682             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3683             serviceResponseInformationBuilder.setInstanceId(siid);
3684             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3685             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
3686             PortMirrorResponseInformationBuilder portMirrorResponseInformationBuilder = new PortMirrorResponseInformationBuilder();
3687             portMirrorResponseInformationBuilder
3688                 .setInstanceId(input.getConfigurationInformation().getConfigurationId());
3689             portMirrorResponseInformationBuilder.setObjectPath(portMirrorObjectPath);
3690             responseBuilder.setPortMirrorResponseInformation(portMirrorResponseInformationBuilder.build());
3691
3692         } catch (Exception e) {
3693             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3694             responseBuilder.setResponseCode("500");
3695             responseBuilder.setResponseMessage(e.getMessage());
3696             responseBuilder.setAckFinalIndicator("Y");
3697             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3698             RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3699                 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3700             return Futures.immediateFuture(rpcResult);
3701         }
3702
3703         // Update succeeded
3704         responseBuilder.setResponseCode(responseObject.getStatusCode());
3705         responseBuilder.setAckFinalIndicator(ackFinal);
3706         trySetResponseMessage(responseBuilder, responseObject);
3707         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3708         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3709
3710         RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3711             .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3712
3713         if (ackFinal.equals("N")) {
3714             // Spawn background thread to invoke the Async DG
3715             Runnable backgroundThread = new Runnable() {
3716                 public void run() {
3717                     log.info(BACKGROUND_THREAD_STARTED_MESSAGE);
3718                     processAsyncPortMirrorTopologyOperation(input);
3719                 }
3720             };
3721             new Thread(backgroundThread).start();
3722         }
3723
3724         // return success
3725         return Futures.immediateFuture(rpcResult);
3726     }
3727
3728     private boolean hasInvalidService(PortMirrorTopologyOperationInput input) {
3729         return input == null || input.getServiceInformation() == null
3730             || input.getServiceInformation().getServiceInstanceId() == null
3731             || input.getServiceInformation().getServiceInstanceId().length() == 0;
3732     }
3733
3734     private boolean hasInvalidConfigurationId(PortMirrorTopologyOperationInput input) {
3735         return input.getConfigurationInformation() == null
3736             || input.getConfigurationInformation().getConfigurationId() == null
3737             || input.getConfigurationInformation().getConfigurationId().length() == 0;
3738     }
3739
3740     private void trySetSvcRequestId(PortMirrorTopologyOperationInput input,
3741         PortMirrorTopologyOperationOutputBuilder responseBuilder) {
3742         if (input.getSdncRequestHeader() != null) {
3743             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3744         }
3745     }
3746
3747     private void trySetResponseMessage(PortMirrorTopologyOperationOutputBuilder responseBuilder,
3748         ResponseObject responseObject) {
3749         if (responseObject.getMessage() != null) {
3750             if (!responseObject.getMessage().isEmpty()) {
3751                 responseBuilder.setResponseMessage(responseObject.getMessage());
3752             }
3753         }
3754     }
3755
3756     public void processAsyncPortMirrorTopologyOperation(PortMirrorTopologyOperationInput input) {
3757         log.info(BACKGROUND_THREAD_INFO, input.getConfigurationInformation().getConfigurationId());
3758
3759         final String svcOperation = "port-mirror-topology-operation-async";
3760         ServiceData serviceData = null;
3761         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3762         Properties parms = new Properties();
3763
3764         log.info(CALLED_STR, svcOperation);
3765
3766         // Grab the service instance ID from the input buffer
3767         String siid = input.getServiceInformation().getServiceInstanceId();
3768
3769         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3770         getServiceData(siid, serviceDataBuilder);
3771
3772         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3773         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3774
3775         // Set the serviceStatus based on input
3776         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3777         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3778
3779         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3780         PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3781         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3782
3783         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3784         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3785
3786         // Call SLI sync method
3787         ResponseObject responseObject = new ResponseObject("200", "");
3788         String ackFinal = "Y";
3789         String serviceObjectPath = null;
3790         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3791
3792         if (respProps != null) {
3793             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3794             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3795             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3796         }
3797
3798         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3799         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3800         serviceStatusBuilder.setRpcName(svcOperation);
3801
3802         if (failed(responseObject)) {
3803             ServiceBuilder serviceBuilder = new ServiceBuilder();
3804             serviceBuilder.setServiceInstanceId(siid);
3805             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3806             try {
3807                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3808             } catch (Exception e) {
3809                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3810             }
3811
3812             // return error
3813             return;
3814         }
3815
3816         // Got success from SLI
3817         try {
3818             serviceData = serviceDataBuilder.build();
3819             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3820
3821             // service object
3822             ServiceBuilder serviceBuilder = new ServiceBuilder();
3823             serviceBuilder.setServiceData(serviceData);
3824             serviceBuilder.setServiceInstanceId(siid);
3825             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3826             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3827
3828             if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3829                 // Only update operational tree on activate or delete
3830                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3831                     || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3832                     log.info(UPDATING_TREE_INFO_MESSAGE);
3833                     saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3834                 }
3835             }
3836
3837             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3838             serviceResponseInformationBuilder.setInstanceId(siid);
3839             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3840
3841         } catch (Exception e) {
3842             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3843             return;
3844         }
3845
3846         // Update succeeded
3847         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3848
3849         return;
3850     }
3851
3852     @Override
3853     public ListenableFuture<RpcResult<VnfGetResourceRequestOutput>> vnfGetResourceRequest(
3854         VnfGetResourceRequestInput input) {
3855
3856         final String svcOperation = "vnf-get-resource-request";
3857         ServiceData serviceData;
3858         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3859         Properties parms = new Properties();
3860
3861         log.info(CALLED_STR, svcOperation);
3862         // create a new response object
3863         VnfGetResourceRequestOutputBuilder responseBuilder = new VnfGetResourceRequestOutputBuilder();
3864
3865         if (hasInvalidService(input)) {
3866             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3867             RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3868                 .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3869             // return error
3870             return Futures.immediateFuture(rpcResult);
3871         }
3872
3873         // Grab the service instance ID from the input buffer
3874         String siid = input.getServiceInformation().getServiceInstanceId();
3875
3876         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3877         getServiceData(siid, serviceDataBuilder);
3878
3879         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3880         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3881
3882         // Set the serviceStatus based on input
3883         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3884         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3885
3886         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3887         VnfGetResourceRequestInputBuilder inputBuilder = new VnfGetResourceRequestInputBuilder(input);
3888         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3889
3890         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3891         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3892
3893         // Call SLI sync method
3894
3895         ResponseObject responseObject = new ResponseObject("200", "");
3896         String ackFinal = "Y";
3897         String serviceObjectPath = null;
3898         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3899
3900         if (respProps != null) {
3901             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3902             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3903             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3904             serviceObjectPath = respProps.getProperty("service-object-path");
3905         }
3906
3907         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3908         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3909         serviceStatusBuilder.setRpcName(svcOperation);
3910
3911         if (failed(responseObject)) {
3912             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3913             RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3914                 .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3915             // return error
3916             return Futures.immediateFuture(rpcResult);
3917         }
3918
3919         // Got success from SLI
3920         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3921
3922         if (respProps != null) {
3923             GenericResourceApiUtil.toBuilder(respProps, responseBuilder);
3924         }
3925
3926         RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder.<VnfGetResourceRequestOutput>status(true)
3927             .withResult(responseBuilder.build()).build();
3928
3929         // return success
3930         return Futures.immediateFuture(rpcResult);
3931     }
3932
3933     private boolean hasInvalidService(VnfGetResourceRequestInput input) {
3934         return input == null || input.getServiceInformation() == null
3935             || input.getServiceInformation().getServiceInstanceId() == null
3936             || input.getServiceInformation().getServiceInstanceId().length() == 0;
3937     }
3938
3939     @Override
3940     public ListenableFuture<RpcResult<CollectPerformanceDataOutput>> collectPerformanceData(CollectPerformanceDataInput input) {
3941         final String svcOperation = "performance-data-collector";
3942         Properties parms = new Properties();
3943
3944         log.info(CALLED_STR, svcOperation);
3945         // create a new response object
3946         CollectPerformanceDataOutputBuilder responseBuilder = new CollectPerformanceDataOutputBuilder();
3947
3948         if (hasInvalidService(input)) {
3949             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3950             RpcResult<CollectPerformanceDataOutput> rpcResult = RpcResultBuilder
3951                     .<CollectPerformanceDataOutput>status(true).withResult(responseBuilder.build()).build();
3952             // return error
3953             return Futures.immediateFuture(rpcResult);
3954         }
3955
3956         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3957         serviceDataBuilder.setControllerIpv4Address(input.getControllerIpv4Address());
3958
3959         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3960
3961         log.info(ADDING_INPUT_DATA_LOG, svcOperation, input.getControllerIpv4Address(), input);
3962         CollectPerformanceDataInputBuilder inputBuilder = new CollectPerformanceDataInputBuilder(input);
3963         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3964
3965         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, input.getControllerIpv4Address(), operDataBuilder.build());
3966         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3967
3968         // Call SLI sync method
3969         ResponseObject responseObject = new ResponseObject("200", "");
3970         String ackFinal = "Y";
3971         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3972
3973         if (respProps != null) {
3974             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3975             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3976             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3977         }
3978
3979         if (failed(responseObject)) {
3980             responseBuilder.setResponseCode(responseObject.getStatusCode());
3981             responseBuilder.setResponseMessage(responseObject.getMessage());
3982             responseBuilder.setAckFinalIndicator(ackFinal);
3983
3984             log.error(RETURNED_FAILED_MESSAGE, svcOperation, input.getControllerIpv4Address(), responseBuilder.build());
3985             RpcResult<CollectPerformanceDataOutput> rpcResult = RpcResultBuilder
3986                     .<CollectPerformanceDataOutput>status(true).withResult(responseBuilder.build()).build();
3987             // return error
3988             return Futures.immediateFuture(rpcResult);
3989         }
3990
3991         // Got success from SLI
3992         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, input.getControllerIpv4Address(), responseBuilder.build());
3993
3994         if (respProps != null) {
3995             GenericResourceApiUtil.toBuilder(respProps, responseBuilder);
3996         }
3997
3998         RpcResult<CollectPerformanceDataOutput> rpcResult = RpcResultBuilder.<CollectPerformanceDataOutput>status(true)
3999                 .withResult(responseBuilder.build()).build();
4000
4001         // return success
4002         return Futures.immediateFuture(rpcResult);
4003     }
4004
4005     private boolean hasInvalidService(CollectPerformanceDataInput input) {
4006         return input == null || input.getControllerIpv4Address() == null;
4007     }
4008 }