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