generic-resource-api/provider/src/main/java/org/onap/sdnc/northbound/GenericResourceApiProvider.java

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