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         /* Comment out mandatory check for vnf id for scenario wherein for assign/create request vnf-id is generated by
 811         SDNC itself.
 812         if (hasInvalidVnfId(input)) {
 813             log.debug("exiting {} because of null or empty vnf-id", svcOperation);
 814             responseBuilder.setResponseCode("404");
 815             responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
 816             responseBuilder.setAckFinalIndicator("Y");
 817
 818             RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
 819                     .withResult(responseBuilder.build()).build();
 820
 821             return Futures.immediateFuture(rpcResult);
 822         }
 823         */
 824
 825         String vnfId = input.getVnfInformation().getVnfId();
 826         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
 827         getServiceData(siid, serviceDataBuilder);
 828
 829         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
 830         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
 831
 832         // Set the serviceStatus based on input
 833         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
 834         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
 835
 836         //
 837         // setup a service-data object builder
 838         // ACTION vnf-topology-operation
 839         // INPUT:
 840         // USES sdnc-request-header;
 841         // USES request-information;
 842         // USES service-information;
 843         // USES vnf-request-information
 844         // OUTPUT:
 845         // USES vnf-topology-response-body;
 846         // USES vnf-information
 847         // USES service-information
 848         //
 849         // container service-data
 850         // uses vnf-configuration-information;
 851         // uses oper-status;
 852
 853         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
 854         VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
 855         GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
 856
 857         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
 858         GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
 859
 860         // Call SLI sync method
 861
 862         ResponseObject responseObject = new ResponseObject("200", "");
 863         String ackFinal = "Y";
 864         String serviceObjectPath = null;
 865         String vnfObjectPath = null;
 866         Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
 867
 868         if (respProps != null) {
 869             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
 870             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
 871             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
 872             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
 873             vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
 874         }
 875
 876         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
 877         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
 878         serviceStatusBuilder.setRpcName(svcOperation);
 879
 880         if (failed(responseObject)) {
 881             responseBuilder.setResponseCode(responseObject.getStatusCode());
 882             responseBuilder.setResponseMessage(responseObject.getMessage());
 883             responseBuilder.setAckFinalIndicator(ackFinal);
 884
 885             ServiceBuilder serviceBuilder = new ServiceBuilder();
 886             serviceBuilder.setServiceInstanceId(siid);
 887             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
 888             try {
 889                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
 890                 trySaveService(input, serviceBuilder);
 891             } catch (Exception e) {
 892                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
 893             }
 894             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
 895
 896             RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
 897                     .withResult(responseBuilder.build()).build();
 898
 899             // return error
 900             return Futures.immediateFuture(rpcResult);
 901         }
 902
 903         // Got success from SLI
 904         try {
 905             serviceData = serviceDataBuilder.build();
 906             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
 907
 908             // service object
 909             ServiceBuilder serviceBuilder = new ServiceBuilder();
 910             serviceBuilder.setServiceData(serviceData);
 911             serviceBuilder.setServiceInstanceId(siid);
 912             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
 913             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
 914
 915             if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
 916                 // Only update operational tree on Assign
 917                 log.info(UPDATING_TREE_INFO_MESSAGE);
 918                 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
 919             }
 920
 921             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
 922             serviceResponseInformationBuilder.setInstanceId(siid);
 923             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
 924             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
 925
 926             VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
 927             vnfResponseInformationBuilder.setInstanceId(vnfId);
 928             vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
 929             responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
 930
 931         } catch (Exception e) {
 932             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
 933             responseBuilder.setResponseCode("500");
 934             responseBuilder.setResponseMessage(e.getMessage());
 935             responseBuilder.setAckFinalIndicator("Y");
 936             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
 937
 938             RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
 939                     .withResult(responseBuilder.build()).build();
 940
 941             return Futures.immediateFuture(rpcResult);
 942         }
 943
 944         // Update succeeded
 945         responseBuilder.setResponseCode(responseObject.getStatusCode());
 946         responseBuilder.setAckFinalIndicator(ackFinal);
 947         trySetResponseMessage(responseBuilder, responseObject);
 948         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
 949         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
 950
 951         RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
 952                 .withResult(responseBuilder.build()).build();
 953
 954         // return success
 955         return Futures.immediateFuture(rpcResult);
 956     }
 957
 958     private void trySetResponseMessage(VnfTopologyOperationOutputBuilder responseBuilder,
 959             ResponseObject responseObject) {
 960         if (responseObject.getMessage() != null) {
 961             responseBuilder.setResponseMessage(responseObject.getMessage());
 962         }
 963     }
 964
 965     private void trySaveService(VnfTopologyOperationInput input, ServiceBuilder serviceBuilder) {
 966         if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)
 967                 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
 968
 969             // Only update operational tree on activate or delete
 970             log.info(UPDATING_TREE_INFO_MESSAGE);
 971             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
 972         }
 973     }
 974
 975     private boolean hasInvalidVnfId(VnfTopologyOperationInput input) {
 976         return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
 977                 || input.getVnfInformation().getVnfId().length() == 0;
 978     }
 979
 980     private boolean hasInvalidServiceId(VnfTopologyOperationInput input) {
 981         return input == null || input.getServiceInformation() == null
 982                 || input.getServiceInformation().getServiceInstanceId() == null
 983                 || input.getServiceInformation().getServiceInstanceId().length() == 0;
 984     }
 985
 986     private void trySetSvcRequestId(VnfTopologyOperationInput input,
 987             VnfTopologyOperationOutputBuilder responseBuilder) {
 988         if (input.getSdncRequestHeader() != null) {
 989             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
 990         }
 991     }
 992
 993     private boolean isValidRequest(VnfTopologyOperationInput input) {
 994         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
 995     }
 996
 997     @Override
 998     public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
 999             VfModuleTopologyOperationInput input) {
1000
1001         final String svcOperation = "vf-module-topology-operation";
1002         ServiceData serviceData;
1003         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1004         Properties parms = new Properties();
1005
1006         log.info(CALLED_STR, svcOperation);
1007         // create a new response object
1008         VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1009
1010         if (hasInvalidServiceId(input)) {
1011             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1012             responseBuilder.setResponseCode("403");
1013             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1014             responseBuilder.setAckFinalIndicator("Y");
1015
1016             RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1017                     .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1018
1019             // return error
1020             return Futures.immediateFuture(rpcResult);
1021         }
1022
1023         if (hasInvalidVnfId(input)) {
1024             log.debug("exiting {} because of null or empty vnf-id", svcOperation);
1025             responseBuilder.setResponseCode("403");
1026             responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
1027             responseBuilder.setAckFinalIndicator("Y");
1028             RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1029                     .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1030             return Futures.immediateFuture(rpcResult);
1031         }
1032
1033         if (hasInvalidVfModuleId(input)) {
1034             log.debug("exiting {} because of null or empty vf-module-id", svcOperation);
1035             responseBuilder.setResponseCode("403");
1036             responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
1037             responseBuilder.setAckFinalIndicator("Y");
1038
1039             RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1040                     .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1041
1042             return Futures.immediateFuture(rpcResult);
1043         }
1044
1045         // Grab the service instance ID from the input buffer
1046         String siid = input.getServiceInformation().getServiceInstanceId();
1047         String vnfId = input.getVnfInformation().getVnfId();
1048         String vfModuleId = input.getVfModuleInformation().getVfModuleId();
1049
1050         trySetSvcRequestId(input, responseBuilder);
1051
1052         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1053         getServiceData(siid, serviceDataBuilder);
1054
1055         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1056         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1057
1058         // Set the serviceStatus based on input
1059         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1060         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1061
1062         //
1063         // setup a service-data object builder
1064         // ACTION vnf-topology-operation
1065         // INPUT:
1066         // USES sdnc-request-header;
1067         // USES request-information;
1068         // USES service-information;
1069         // USES vnf-request-information
1070         // OUTPUT:
1071         // USES vnf-topology-response-body;
1072         // USES vnf-information
1073         // USES service-information
1074         //
1075         // container service-data
1076         // uses vnf-configuration-information;
1077         // uses oper-status;
1078
1079         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1080         VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1081         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1082
1083         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
1084         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1085
1086         // Call SLI sync method
1087
1088         ResponseObject responseObject = new ResponseObject("200", "");
1089         String ackFinal = "Y";
1090         String serviceObjectPath = null;
1091         String vnfObjectPath = null;
1092         String vfModuleObjectPath = null;
1093         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1094
1095         if (respProps != null) {
1096             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1097             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1098             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1099             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1100             vnfObjectPath = respProps.getProperty(VNF_OBJECT_PATH_PARAM);
1101             vfModuleObjectPath = respProps.getProperty(VF_MODULE_OBJECT_PATH_PARAM);
1102         }
1103
1104         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1105         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1106         serviceStatusBuilder.setRpcName(svcOperation);
1107
1108         if (failed(responseObject)) {
1109             responseBuilder.setResponseCode(responseObject.getStatusCode());
1110             responseBuilder.setResponseMessage(responseObject.getMessage());
1111             responseBuilder.setAckFinalIndicator(ackFinal);
1112
1113             ServiceBuilder serviceBuilder = new ServiceBuilder();
1114             serviceBuilder.setServiceInstanceId(siid);
1115             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1116             try {
1117                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1118             } catch (Exception e) {
1119                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1120             }
1121             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1122
1123             RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1124                     .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1125
1126             // return error
1127             return Futures.immediateFuture(rpcResult);
1128         }
1129
1130         // Got success from SLI
1131         try {
1132             serviceData = serviceDataBuilder.build();
1133             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1134
1135             // service object
1136             ServiceBuilder serviceBuilder = new ServiceBuilder();
1137             serviceBuilder.setServiceData(serviceData);
1138             serviceBuilder.setServiceInstanceId(siid);
1139             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1140             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1141
1142             trySaveService(input, serviceBuilder);
1143
1144             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1145             serviceResponseInformationBuilder.setInstanceId(siid);
1146             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1147             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1148
1149             VnfResponseInformationBuilder vnfResponseInformationBuilder = new VnfResponseInformationBuilder();
1150             vnfResponseInformationBuilder.setInstanceId(vnfId);
1151             vnfResponseInformationBuilder.setObjectPath(vnfObjectPath);
1152             responseBuilder.setVnfResponseInformation(vnfResponseInformationBuilder.build());
1153
1154             VfModuleResponseInformationBuilder vfModuleResponseInformationBuilder = new VfModuleResponseInformationBuilder();
1155             vfModuleResponseInformationBuilder.setInstanceId(vfModuleId);
1156             vfModuleResponseInformationBuilder.setObjectPath(vfModuleObjectPath);
1157             responseBuilder.setVfModuleResponseInformation(vfModuleResponseInformationBuilder.build());
1158
1159         } catch (Exception e) {
1160             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1161             responseBuilder.setResponseCode("500");
1162             responseBuilder.setResponseMessage(e.getMessage());
1163             responseBuilder.setAckFinalIndicator("Y");
1164             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1165
1166             RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1167                     .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1168
1169             return Futures.immediateFuture(rpcResult);
1170         }
1171
1172         // Update succeeded
1173         responseBuilder.setResponseCode(responseObject.getStatusCode());
1174         responseBuilder.setAckFinalIndicator(ackFinal);
1175         trySetResponseMessage(responseBuilder, responseObject);
1176         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1177         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1178
1179         RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1180                 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1181
1182         // return success
1183         return Futures.immediateFuture(rpcResult);
1184     }
1185
1186     private void trySetResponseMessage(VfModuleTopologyOperationOutputBuilder responseBuilder,
1187             ResponseObject responseObject) {
1188         if (responseObject.getMessage() != null) {
1189             responseBuilder.setResponseMessage(responseObject.getMessage());
1190         }
1191     }
1192
1193     private void trySaveService(VfModuleTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1194         if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1195                 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1196             // Only update operational tree on activate or delete
1197
1198             log.info(UPDATING_TREE_INFO_MESSAGE);
1199             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1200         }
1201     }
1202
1203     private void trySetSvcRequestId(VfModuleTopologyOperationInput input,
1204             VfModuleTopologyOperationOutputBuilder responseBuilder) {
1205         if (input.getSdncRequestHeader() != null) {
1206             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1207         }
1208     }
1209
1210     private boolean hasInvalidVfModuleId(VfModuleTopologyOperationInput input) {
1211         return input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
1212                 || input.getVfModuleInformation().getVfModuleId().length() == 0;
1213     }
1214
1215     private boolean hasInvalidVnfId(VfModuleTopologyOperationInput input) {
1216         return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
1217                 || input.getVnfInformation().getVnfId().length() == 0;
1218     }
1219
1220     private boolean hasInvalidServiceId(VfModuleTopologyOperationInput input) {
1221         return input == null || input.getServiceInformation() == null
1222                 || input.getServiceInformation().getServiceInstanceId() == null
1223                 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1224     }
1225
1226     private boolean isValidRequest(VfModuleTopologyOperationInput input) {
1227         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1228     }
1229
1230     @Override
1231     public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1232             NetworkTopologyOperationInput input) {
1233
1234         final String svcOperation = "network-topology-operation";
1235         ServiceData serviceData;
1236         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1237         Properties parms = new Properties();
1238
1239         log.info(CALLED_STR, svcOperation);
1240         // create a new response object
1241         NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1242
1243         if (hasInvalidServiceId(input)) {
1244             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1245             return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1246         }
1247
1248         String siid = input.getServiceInformation().getServiceInstanceId();
1249
1250         // Get the service-instance service data from MD-SAL
1251         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1252         getServiceData(siid, serviceDataBuilder);
1253
1254         this.trySetSvcRequestId(input, responseBuilder);
1255
1256         ServiceData sd = serviceDataBuilder.build();
1257         if (isInvalidServiceData(sd)) {
1258             log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1259             return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1260         }
1261
1262         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1263         NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1264         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1265
1266         // Call SLI sync method
1267
1268         ResponseObject responseObject = new ResponseObject("200", "");
1269         String ackFinal = "Y";
1270         String networkId = ERROR_NETWORK_ID;
1271         String serviceObjectPath = null;
1272         String networkObjectPath = null;
1273         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1274
1275         if (respProps != null) {
1276             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1277             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1278             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1279             networkId = respProps.getProperty("networkId");
1280             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1281             networkObjectPath = respProps.getProperty(NETWORK_OBJECT_PATH_PARAM);
1282         }
1283
1284         if (failed(responseObject)) {
1285             responseBuilder.setResponseCode(responseObject.getStatusCode());
1286             responseBuilder.setResponseMessage(responseObject.getMessage());
1287             responseBuilder.setAckFinalIndicator(ackFinal);
1288
1289             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1290
1291             RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1292                     .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1293
1294             return Futures.immediateFuture(rpcResult);
1295         }
1296
1297         // Got success from SLI
1298         try {
1299
1300             serviceData = serviceDataBuilder.build();
1301             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1302
1303             // service object
1304             ServiceBuilder serviceBuilder = new ServiceBuilder();
1305             serviceBuilder.setServiceData(serviceData);
1306             serviceBuilder.setServiceInstanceId(siid);
1307             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1308             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1309
1310             trySaveService(input, serviceBuilder);
1311
1312             NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1313             networkResponseInformationBuilder.setInstanceId(networkId);
1314             networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1315             responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1316
1317             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1318             serviceResponseInformationBuilder.setInstanceId(siid);
1319             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1320             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1321
1322         } catch (IllegalStateException e) {
1323             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1324             responseBuilder.setResponseCode("500");
1325             responseBuilder.setResponseMessage(e.getMessage());
1326             responseBuilder.setAckFinalIndicator("Y");
1327             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1328
1329             RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1330                     .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1331
1332             return Futures.immediateFuture(rpcResult);
1333         }
1334
1335         // Update succeeded
1336         responseBuilder.setResponseCode(responseObject.getStatusCode());
1337         responseBuilder.setAckFinalIndicator(ackFinal);
1338         trySetResponseMessage(responseBuilder, responseObject);
1339         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1340         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1341
1342         RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1343                 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1344
1345         return Futures.immediateFuture(rpcResult);
1346     }
1347
1348     private void trySetResponseMessage(NetworkTopologyOperationOutputBuilder responseBuilder,
1349             ResponseObject responseObject) {
1350         if (responseObject.getMessage() != null) {
1351             responseBuilder.setResponseMessage(responseObject.getMessage());
1352         }
1353     }
1354
1355     private void trySetSvcRequestId(NetworkTopologyOperationInput input,
1356             NetworkTopologyOperationOutputBuilder responseBuilder) {
1357         if (input.getSdncRequestHeader() != null) {
1358             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1359         }
1360     }
1361
1362     private void trySaveService(NetworkTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1363         if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)
1364                 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create))) {
1365             // Only update operational tree on Activate
1366             log.info(UPDATING_TREE_INFO_MESSAGE);
1367             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1368         }
1369     }
1370
1371     private boolean hasInvalidServiceId(NetworkTopologyOperationInput input) {
1372         return input == null || input.getServiceInformation() == null
1373                 || input.getServiceInformation().getServiceInstanceId() == null
1374                 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1375     }
1376
1377     private Future<RpcResult<NetworkTopologyOperationOutput>> buildRpcResultFuture(
1378             NetworkTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1379
1380         responseBuilder.setResponseCode("404");
1381         responseBuilder.setResponseMessage(responseMessage);
1382         responseBuilder.setAckFinalIndicator("Y");
1383
1384         RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1385                 .<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1386
1387         return Futures.immediateFuture(rpcResult);
1388     }
1389
1390     private boolean isValidRequest(NetworkTopologyOperationInput input) {
1391         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1392     }
1393
1394     @Override
1395     public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1396             ContrailRouteTopologyOperationInput input) {
1397
1398         final String svcOperation = "contrail-route-topology-operation";
1399         ServiceData serviceData;
1400         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1401         Properties properties = new Properties();
1402
1403         log.info(CALLED_STR, svcOperation);
1404         // create a new response object
1405         ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1406
1407         if (hasInvalidServiceId(input)) {
1408             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1409             return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1410         }
1411
1412         String siid = input.getServiceInformation().getServiceInstanceId();
1413
1414         // Get the service-instance service data from MD-SAL
1415         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1416         getServiceData(siid, serviceDataBuilder);
1417
1418         trySetSvcRequestId(input, responseBuilder);
1419
1420         ServiceData sd = serviceDataBuilder.build();
1421         if (isInvalidServiceData(sd)) {
1422             log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1423             return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1424         }
1425
1426         log.info("Adding INPUT data for " + svcOperation + " [" + siid + "] input: " + input);
1427         ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1428         GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
1429
1430         // Call SLI sync method
1431
1432         ResponseObject responseObject = new ResponseObject("200", "");
1433         String ackFinal = "Y";
1434         String allottedResourceId = ERROR_NETWORK_ID;
1435         String serviceObjectPath = null;
1436         String contrailRouteObjectPath = null;
1437         Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
1438
1439         if (respProps != null) {
1440             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1441             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1442             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1443             allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1444             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1445             contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1446         }
1447
1448         if (failed(responseObject)) {
1449             responseBuilder.setResponseCode(responseObject.getStatusCode());
1450             responseBuilder.setResponseMessage(responseObject.getMessage());
1451             responseBuilder.setAckFinalIndicator(ackFinal);
1452             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1453
1454             RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1455                     .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1456
1457             return Futures.immediateFuture(rpcResult);
1458         }
1459
1460         // Got success from SLI
1461         try {
1462             serviceData = serviceDataBuilder.build();
1463             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1464
1465             // service object
1466             ServiceBuilder serviceBuilder = new ServiceBuilder();
1467             serviceBuilder.setServiceData(serviceData);
1468             serviceBuilder.setServiceInstanceId(siid);
1469             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1470             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1471
1472             trySaveService(input, serviceBuilder);
1473
1474             ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1475             contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1476             contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1477             responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1478
1479             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1480             serviceResponseInformationBuilder.setInstanceId(siid);
1481             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1482             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1483
1484         } catch (IllegalStateException e) {
1485             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1486             responseBuilder.setResponseCode("500");
1487             responseBuilder.setResponseMessage(e.getMessage());
1488             responseBuilder.setAckFinalIndicator("Y");
1489             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1490
1491             RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1492                     .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1493
1494             return Futures.immediateFuture(rpcResult);
1495         }
1496
1497         // Update succeeded
1498         responseBuilder.setResponseCode(responseObject.getStatusCode());
1499         responseBuilder.setAckFinalIndicator(ackFinal);
1500         trySetResponseMessage(responseBuilder, responseObject);
1501         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1502         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1503
1504         RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1505                 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1506
1507         return Futures.immediateFuture(rpcResult);
1508     }
1509
1510     private void trySetResponseMessage(ContrailRouteTopologyOperationOutputBuilder responseBuilder,
1511             ResponseObject responseObject) {
1512         if (responseObject.getMessage() != null) {
1513             responseBuilder.setResponseMessage(responseObject.getMessage());
1514         }
1515     }
1516
1517     private void trySaveService(ContrailRouteTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1518         if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1519                 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1520             // Only update operational tree on activate or delete
1521             log.info(UPDATING_TREE_INFO_MESSAGE);
1522             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1523         }
1524     }
1525
1526     private void trySetSvcRequestId(ContrailRouteTopologyOperationInput input,
1527             ContrailRouteTopologyOperationOutputBuilder responseBuilder) {
1528         if (input.getSdncRequestHeader() != null) {
1529             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1530         }
1531     }
1532
1533     private boolean hasInvalidServiceId(ContrailRouteTopologyOperationInput input) {
1534         return input == null || input.getServiceInformation() == null
1535                 || input.getServiceInformation().getServiceInstanceId() == null
1536                 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1537     }
1538
1539     private Future<RpcResult<ContrailRouteTopologyOperationOutput>> buildRpcResultFuture(
1540             ContrailRouteTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1541         responseBuilder.setResponseCode("404");
1542         responseBuilder.setResponseMessage(responseMessage);
1543         responseBuilder.setAckFinalIndicator("Y");
1544
1545         RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1546                 .<ContrailRouteTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1547
1548         return Futures.immediateFuture(rpcResult);
1549     }
1550
1551     private boolean isValidRequest(ContrailRouteTopologyOperationInput input) {
1552         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1553     }
1554
1555     @Override
1556     public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1557             SecurityZoneTopologyOperationInput input) {
1558
1559         final String svcOperation = "security-zone-topology-operation";
1560         ServiceData serviceData;
1561         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1562         Properties parms = new Properties();
1563
1564         log.info(CALLED_STR, svcOperation);
1565         // create a new response object
1566         SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1567
1568         if (this.hasInvalidServiceId(input)) {
1569             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1570             return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1571         }
1572
1573         String siid = input.getServiceInformation().getServiceInstanceId();
1574
1575         // Get the service-instance service data from MD-SAL
1576         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1577         getServiceData(siid, serviceDataBuilder);
1578         trySetSvcRequestId(input, responseBuilder);
1579
1580         ServiceData sd = serviceDataBuilder.build();
1581         if (isInvalidServiceData(sd)) {
1582             log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1583             return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1584         }
1585
1586         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1587         SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1588         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1589
1590         // Call SLI sync method
1591
1592         Properties respProps = null;
1593
1594         ResponseObject responseObject = new ResponseObject("200", "");
1595         String ackFinal = "Y";
1596         String allottedResourceId = ERROR_NETWORK_ID;
1597         String serviceObjectPath = null;
1598         String securityZoneObjectPath = null;
1599
1600         try {
1601             if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1602
1603                 try {
1604                     respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
1605                 } catch (Exception e) {
1606                     log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1607                     responseObject.setMessage(e.getMessage());
1608                     responseObject.setStatusCode("500");
1609                 }
1610             } else {
1611                 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1612                 responseObject.setStatusCode("503");
1613             }
1614         } catch (Exception e) {
1615             responseObject.setStatusCode("500");
1616             responseObject.setMessage(e.getMessage());
1617             log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1618         }
1619
1620         if (respProps != null) {
1621             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1622             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1623             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1624             allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1625             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1626             securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1627         }
1628
1629         if (failed(responseObject)) {
1630             responseBuilder.setResponseCode(responseObject.getStatusCode());
1631             responseBuilder.setResponseMessage(responseObject.getMessage());
1632             responseBuilder.setAckFinalIndicator(ackFinal);
1633             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1634
1635             RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1636                     .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1637
1638             return Futures.immediateFuture(rpcResult);
1639         }
1640
1641         // Got success from SLI
1642         try {
1643
1644             serviceData = serviceDataBuilder.build();
1645             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1646
1647             // service object
1648             ServiceBuilder serviceBuilder = new ServiceBuilder();
1649             serviceBuilder.setServiceData(serviceData);
1650             serviceBuilder.setServiceInstanceId(siid);
1651             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1652             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1653
1654             trySaveService(input, serviceBuilder);
1655
1656             SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1657             securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1658             securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1659             responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1660
1661             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1662             serviceResponseInformationBuilder.setInstanceId(siid);
1663             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1664             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1665
1666         } catch (IllegalStateException e) {
1667             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1668             responseBuilder.setResponseCode("500");
1669             responseBuilder.setResponseMessage(e.getMessage());
1670             responseBuilder.setAckFinalIndicator("Y");
1671             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1672
1673             RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1674                     .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1675
1676             return Futures.immediateFuture(rpcResult);
1677         }
1678
1679         // Update succeeded
1680         responseBuilder.setResponseCode(responseObject.getStatusCode());
1681         responseBuilder.setAckFinalIndicator(ackFinal);
1682         trySetResponseMessage(responseBuilder, responseObject);
1683         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1684         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1685
1686         RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1687                 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1688
1689         return Futures.immediateFuture(rpcResult);
1690     }
1691
1692     private void trySetResponseMessage(SecurityZoneTopologyOperationOutputBuilder responseBuilder,
1693             ResponseObject responseObject) {
1694         if (responseObject.getMessage() != null) {
1695             responseBuilder.setResponseMessage(responseObject.getMessage());
1696         }
1697     }
1698
1699     private void trySaveService(SecurityZoneTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1700         if (isValidRequest(input) && (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
1701                 || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1702             // Only update operational tree on activate or delete
1703             log.info(UPDATING_TREE_INFO_MESSAGE);
1704             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1705         }
1706     }
1707
1708     private void trySetSvcRequestId(SecurityZoneTopologyOperationInput input,
1709             SecurityZoneTopologyOperationOutputBuilder responseBuilder) {
1710         if (input.getSdncRequestHeader() != null) {
1711             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1712         }
1713     }
1714
1715     private boolean isInvalidServiceData(ServiceData sd) {
1716         return sd == null || sd.getServiceLevelOperStatus() == null;
1717     }
1718
1719     private boolean hasInvalidServiceId(SecurityZoneTopologyOperationInput input) {
1720         return input == null || input.getServiceInformation() == null
1721                 || input.getServiceInformation().getServiceInstanceId() == null
1722                 || input.getServiceInformation().getServiceInstanceId().length() == 0;
1723     }
1724
1725     private Future<RpcResult<SecurityZoneTopologyOperationOutput>> buildRpcResultFuture(
1726             SecurityZoneTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1727
1728         responseBuilder.setResponseCode("404");
1729         responseBuilder.setResponseMessage(responseMessage);
1730         responseBuilder.setAckFinalIndicator("Y");
1731
1732         RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1733                 .<SecurityZoneTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1734
1735         return Futures.immediateFuture(rpcResult);
1736     }
1737
1738     private boolean isValidRequest(SecurityZoneTopologyOperationInput input) {
1739         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1740     }
1741
1742
1743     private boolean hasInvalidServiceId(ConnectionAttachmentTopologyOperationInput input) {
1744         return input == null || input.getServiceInformation() == null
1745             || input.getServiceInformation().getServiceInstanceId() == null
1746             || input.getServiceInformation().getServiceInstanceId().length() == 0;
1747     }
1748
1749     private void trySetResponseMessage(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder,
1750         ResponseObject error) {
1751         if (!error.getMessage().isEmpty()) {
1752             responseBuilder.setResponseMessage(error.getMessage());
1753         }
1754     }
1755
1756     private void trySetSvcRequestId(ConnectionAttachmentTopologyOperationInput input,
1757         ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder) {
1758         if (input.getSdncRequestHeader() != null) {
1759             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1760         }
1761     }
1762
1763     private Future<RpcResult<ConnectionAttachmentTopologyOperationOutput>>
1764     buildRpcResultFuture(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1765
1766         responseBuilder.setResponseCode("404");
1767         responseBuilder.setResponseMessage(responseMessage);
1768         responseBuilder.setAckFinalIndicator("Y");
1769
1770         RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1771             .<ConnectionAttachmentTopologyOperationOutput>status(true)
1772             .withResult(responseBuilder.build())
1773             .build();
1774
1775         return Futures.immediateFuture(rpcResult);
1776     }
1777
1778     private void trySaveService(ConnectionAttachmentTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1779         if (isValidRequest(input) &&
1780             (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1781                 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1782             // Only update operational tree on activate or delete
1783             log.info(UPDATING_TREE_INFO_MESSAGE);
1784             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1785         }
1786     }
1787
1788     private boolean isValidRequest(ConnectionAttachmentTopologyOperationInput input) {
1789         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1790     }
1791
1792     @Override
1793     public Future<RpcResult<ConnectionAttachmentTopologyOperationOutput>> connectionAttachmentTopologyOperation(ConnectionAttachmentTopologyOperationInput input) {
1794         final String svcOperation = "connection-attachment-topology-operation";
1795         Properties parms = new Properties();
1796         log.info(CALLED_STR, svcOperation);
1797
1798         // create a new response object
1799         ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder = new ConnectionAttachmentTopologyOperationOutputBuilder();
1800         if (hasInvalidServiceId(input)) {
1801             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1802             responseBuilder.setResponseCode("404");
1803             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1804             responseBuilder.setAckFinalIndicator("Y");
1805
1806             RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1807                 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1808                 .withResult(responseBuilder.build())
1809                 .build();
1810
1811             return Futures.immediateFuture(rpcResult);
1812         }
1813
1814         ServiceData serviceData;
1815         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1816
1817         String siid = input.getServiceInformation().getServiceInstanceId();
1818         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1819
1820         // Get the service-instance service data from MD-SAL
1821         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1822         getServiceData(siid, serviceDataBuilder);
1823
1824         trySetSvcRequestId(input, responseBuilder);
1825
1826         ServiceData sd = serviceDataBuilder.build();
1827         if (isInvalidServiceData(sd)) {
1828             log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1829             return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1830         }
1831
1832         ConnectionAttachmentTopologyOperationInputBuilder inputBuilder = new ConnectionAttachmentTopologyOperationInputBuilder(input);
1833         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1834
1835         // Call SLI sync method
1836         // Get SvcLogicService reference
1837         ResponseObject responseObject = new ResponseObject("200", "");
1838         String ackFinal = "Y";
1839         String allottedResourceId = ERROR_NETWORK_ID;
1840         String serviceObjectPath = null;
1841         String connectionAttachmentObjectPath = null;
1842
1843         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1844
1845         if (respProps != null) {
1846             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1847             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1848             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1849             allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1850             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1851             connectionAttachmentObjectPath = respProps.getProperty("connection-attachment-object-path");
1852         }
1853
1854         if (failed(responseObject)) {
1855             responseBuilder.setResponseCode(responseObject.getStatusCode());
1856             responseBuilder.setResponseMessage(responseObject.getMessage());
1857             responseBuilder.setAckFinalIndicator(ackFinal);
1858
1859             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1860
1861             RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1862                 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1863                 .withResult(responseBuilder.build())
1864                 .build();
1865
1866             return Futures.immediateFuture(rpcResult);
1867         }
1868
1869         // Got success from SLI
1870         try {
1871
1872             serviceData = serviceDataBuilder.build();
1873             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1874
1875             // service object
1876             ServiceBuilder serviceBuilder = new ServiceBuilder();
1877             serviceBuilder.setServiceData(serviceData);
1878             serviceBuilder.setServiceInstanceId(siid);
1879             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1880             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1881
1882             trySaveService(input, serviceBuilder);
1883
1884             ConnectionAttachmentResponseInformationBuilder connectionAttachmentResponseInformationBuilder = new ConnectionAttachmentResponseInformationBuilder();
1885             connectionAttachmentResponseInformationBuilder.setInstanceId(allottedResourceId);
1886             connectionAttachmentResponseInformationBuilder.setObjectPath(connectionAttachmentObjectPath);
1887             responseBuilder.setConnectionAttachmentResponseInformation(connectionAttachmentResponseInformationBuilder.build());
1888
1889             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1890             serviceResponseInformationBuilder.setInstanceId(siid);
1891             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1892             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1893
1894         } catch (IllegalStateException e) {
1895             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1896             responseBuilder.setResponseCode("500");
1897             responseBuilder.setResponseMessage(e.getMessage());
1898             responseBuilder.setAckFinalIndicator("Y");
1899             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1900
1901             RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1902                 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1903                 .withResult(responseBuilder.build())
1904                 .build();
1905
1906             return Futures.immediateFuture(rpcResult);
1907         }
1908
1909         // Update succeeded
1910         responseBuilder.setResponseCode(responseObject.getStatusCode());
1911         responseBuilder.setAckFinalIndicator(ackFinal);
1912         trySetResponseMessage(responseBuilder, responseObject);
1913         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1914         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1915
1916         RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1917             .<ConnectionAttachmentTopologyOperationOutput>status(true)
1918             .withResult(responseBuilder.build())
1919             .build();
1920
1921         return Futures.immediateFuture(rpcResult);
1922     }
1923
1924     @Override
1925     public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1926             TunnelxconnTopologyOperationInput input) {
1927
1928         final String svcOperation = "tunnelxconn-topology-operation";
1929         Properties parms = new Properties();
1930         log.info(CALLED_STR, svcOperation);
1931
1932         // create a new response object
1933         TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1934         if (hasInvalidServiceId(input)) {
1935             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1936             responseBuilder.setResponseCode("404");
1937             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1938             responseBuilder.setAckFinalIndicator("Y");
1939
1940             RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1941                     .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1942
1943             return Futures.immediateFuture(rpcResult);
1944         }
1945         String siid = input.getServiceInformation().getServiceInstanceId();
1946         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1947         TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1948         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1949
1950         // Call SLI sync method
1951
1952         ResponseObject responseObject = new ResponseObject("200", "");
1953         String ackFinal = "Y";
1954         String allottedResourceId = ERROR_NETWORK_ID;
1955         String serviceObjectPath = null;
1956         String tunnelxconnObjectPath = null;
1957         Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
1958
1959         if (respProps != null) {
1960             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1961             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1962             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1963             allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1964             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1965             tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1966         }
1967
1968         if (failed(responseObject)) {
1969             responseBuilder.setResponseCode(responseObject.getStatusCode());
1970             responseBuilder.setResponseMessage(responseObject.getMessage());
1971             responseBuilder.setAckFinalIndicator(ackFinal);
1972
1973             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1974
1975             RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1976                     .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1977
1978             return Futures.immediateFuture(rpcResult);
1979         }
1980
1981         // Got success from SLI
1982         try {
1983             TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1984             tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1985             tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1986             responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1987
1988             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1989             serviceResponseInformationBuilder.setInstanceId(siid);
1990             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1991             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1992
1993         } catch (IllegalStateException e) {
1994             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1995             responseBuilder.setResponseCode("500");
1996             responseBuilder.setResponseMessage(e.getMessage());
1997             responseBuilder.setAckFinalIndicator("Y");
1998             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1999
2000             RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2001                     .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2002
2003             return Futures.immediateFuture(rpcResult);
2004         }
2005
2006         // Update succeeded
2007         responseBuilder.setResponseCode(responseObject.getStatusCode());
2008         responseBuilder.setAckFinalIndicator(ackFinal);
2009         trySetResponseMessage(responseBuilder, responseObject);
2010         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2011         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2012
2013         RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
2014                 .<TunnelxconnTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2015
2016         return Futures.immediateFuture(rpcResult);
2017     }
2018
2019     private void trySetResponseMessage(TunnelxconnTopologyOperationOutputBuilder responseBuilder,
2020             ResponseObject responseObject) {
2021         if (responseObject.getMessage() != null) {
2022             responseBuilder.setResponseMessage(responseObject.getMessage());
2023         }
2024     }
2025
2026     private boolean hasInvalidServiceId(TunnelxconnTopologyOperationInput input) {
2027         return input == null || input.getServiceInformation() == null
2028                 || input.getServiceInformation().getServiceInstanceId() == null
2029                 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2030     }
2031
2032     private Properties tryGetProperties(String svcOperation, Properties parms, ResponseObject responseObject) {
2033         try {
2034             if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2035
2036                 try {
2037                     return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
2038                 } catch (Exception e) {
2039                     log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2040                     responseObject.setMessage(e.getMessage());
2041                     responseObject.setStatusCode("500");
2042                 }
2043             } else {
2044                 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2045                 responseObject.setStatusCode("503");
2046             }
2047         } catch (Exception e) {
2048             responseObject.setMessage(e.getMessage());
2049             responseObject.setStatusCode("500");
2050             log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2051         }
2052         return null;
2053     }
2054
2055     @Override
2056     public Future<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
2057         final String svcOperation = "brg-topology-operation";
2058         Properties parms = new Properties();
2059
2060         log.info(CALLED_STR, svcOperation);
2061         // create a new response object
2062         BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
2063
2064         if (this.hasInvalidServiceId(input)) {
2065
2066             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2067             responseBuilder.setResponseCode("404");
2068             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2069             responseBuilder.setAckFinalIndicator("Y");
2070
2071             RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2072                     .withResult(responseBuilder.build()).build();
2073
2074             return Futures.immediateFuture(rpcResult);
2075         }
2076
2077         String siid = input.getServiceInformation().getServiceInstanceId();
2078
2079         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2080         BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
2081         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2082
2083         // Call SLI sync method
2084
2085         ResponseObject responseObject = new ResponseObject("200", "");
2086         String ackFinal = "Y";
2087         String allottedResourceId = ERROR_NETWORK_ID;
2088         String serviceObjectPath = null;
2089         String brgObjectPath = null;
2090         Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2091
2092         if (respProps != null) {
2093             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2094             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2095             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2096             allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2097             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2098             brgObjectPath = respProps.getProperty("brg-object-path");
2099         }
2100
2101         if (failed(responseObject)) {
2102             responseBuilder.setResponseCode(responseObject.getStatusCode());
2103             responseBuilder.setResponseMessage(responseObject.getMessage());
2104             responseBuilder.setAckFinalIndicator(ackFinal);
2105
2106             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2107             RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2108                     .withResult(responseBuilder.build()).build();
2109
2110             return Futures.immediateFuture(rpcResult);
2111         }
2112
2113         // Got success from SLI
2114         try {
2115
2116             BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
2117             brgResponseInformationBuilder.setInstanceId(allottedResourceId);
2118             brgResponseInformationBuilder.setObjectPath(brgObjectPath);
2119             responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
2120
2121             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2122             serviceResponseInformationBuilder.setInstanceId(siid);
2123             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2124             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2125
2126         } catch (IllegalStateException e) {
2127             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2128             responseBuilder.setResponseCode("500");
2129             responseBuilder.setResponseMessage(e.getMessage());
2130             responseBuilder.setAckFinalIndicator("Y");
2131             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2132
2133             RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2134                     .withResult(responseBuilder.build()).build();
2135
2136             return Futures.immediateFuture(rpcResult);
2137         }
2138
2139         // Update succeeded
2140         responseBuilder.setResponseCode(responseObject.getStatusCode());
2141         responseBuilder.setAckFinalIndicator(ackFinal);
2142         trySetResponseMessage(responseBuilder, responseObject);
2143         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2144         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2145
2146         RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder.<BrgTopologyOperationOutput>status(true)
2147                 .withResult(responseBuilder.build()).build();
2148
2149         return Futures.immediateFuture(rpcResult);
2150     }
2151
2152     private void trySetResponseMessage(BrgTopologyOperationOutputBuilder responseBuilder,
2153             ResponseObject responseObject) {
2154         if (responseObject.getMessage() != null) {
2155             responseBuilder.setResponseMessage(responseObject.getMessage());
2156         }
2157     }
2158
2159     private boolean hasInvalidServiceId(BrgTopologyOperationInput input) {
2160         return input == null || input.getServiceInformation() == null
2161                 || input.getServiceInformation().getServiceInstanceId() == null
2162                 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2163     }
2164
2165     private String resolveAckFinal(ResponseObject responseObject, Properties respProps) {
2166         if (respProps != null) {
2167             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2168             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2169             return respProps.getProperty(ACK_FINAL_PARAM, "Y");
2170         }
2171         return "Y";
2172     }
2173
2174     @Override
2175     public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2176             PreloadNetworkTopologyOperationInput input) {
2177
2178         final String svcOperation = "preload-network-topology-operation";
2179         PreloadData preloadData;
2180         Properties properties = new Properties();
2181
2182         log.info(CALLED_STR, svcOperation);
2183         // create a new response object
2184         PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2185
2186         if (hasInvalidPreloadNetwork(input)) {
2187             log.debug("exiting {} because of null or empty preload-network-topology-information", svcOperation);
2188             responseBuilder.setResponseCode("403");
2189             responseBuilder.setResponseMessage("invalid input, null or empty preload-network-topology-information");
2190             responseBuilder.setAckFinalIndicator("Y");
2191
2192             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2193                     .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2194
2195             return Futures.immediateFuture(rpcResult);
2196         }
2197
2198         // Grab the preload ID from the input buffer
2199         String preloadId = input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure()
2200                 .getNetworkName();
2201         String preloadType = "network";
2202
2203         trySetSvcRequestId(input, responseBuilder);
2204
2205         PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2206         getPreloadData(preloadId, preloadType, preloadDataBuilder);
2207
2208         PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2209         getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2210
2211         //
2212         // setup a preload-data object builder
2213         // ACTION preload-network-topology-operation
2214         // INPUT:
2215         // uses sdnc-request-header;
2216         // uses request-information;
2217         // uses preload-network-topology-information;
2218         // OUTPUT:
2219         // uses preload-topology-response-body;
2220         //
2221         // container preload-data
2222         // uses preload-network-topology-information;
2223         // uses preload-oper-status;
2224
2225         log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
2226         PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2227                 input);
2228         GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2229         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
2230         GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
2231
2232         // Call SLI sync method
2233         ResponseObject responseObject = new ResponseObject("200", "");
2234         String ackFinal = "Y";
2235         Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
2236
2237         if (respProps != null) {
2238             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2239             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2240             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2241         }
2242
2243         if (failed(responseObject)) {
2244             responseBuilder.setResponseCode(responseObject.getStatusCode());
2245             responseBuilder.setResponseMessage(responseObject.getMessage());
2246             responseBuilder.setAckFinalIndicator(ackFinal);
2247             log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2248             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2249                     .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2250             return Futures.immediateFuture(rpcResult);
2251         }
2252
2253         // Got success from SLI
2254         try {
2255             preloadData = preloadDataBuilder.build();
2256             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
2257
2258             // preload-list object
2259             PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
2260             preloadListBuilder.setPreloadId(preloadId);
2261             preloadListBuilder.setPreloadType(preloadType);
2262             preloadListBuilder.setPreloadData(preloadData);
2263
2264             savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2265             log.info(UPDATING_TREE_INFO_MESSAGE);
2266             savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2267
2268             tryDeletePreload(input, preloadListBuilder);
2269         } catch (Exception e) {
2270             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
2271             responseBuilder.setResponseCode("500");
2272             responseBuilder.setResponseMessage(e.getMessage());
2273             responseBuilder.setAckFinalIndicator("Y");
2274             log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2275             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2276                     .<PreloadNetworkTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
2277             return Futures.immediateFuture(rpcResult);
2278         }
2279
2280         // Update succeeded
2281         responseBuilder.setResponseCode(responseObject.getStatusCode());
2282         responseBuilder.setAckFinalIndicator(ackFinal);
2283         trySetResponseMessage(responseBuilder, responseObject);
2284         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, preloadId);
2285         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2286
2287         RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2288                 .<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2289         return Futures.immediateFuture(rpcResult);
2290     }
2291
2292     private boolean hasInvalidPreloadNetwork(PreloadNetworkTopologyOperationInput input) {
2293         return input == null || input.getPreloadNetworkTopologyInformation() == null
2294                 || input.getPreloadNetworkTopologyInformation().getNetworkTopologyIdentifierStructure() == null;
2295     }
2296
2297     private boolean hasInvalidPreloadId(String preloadId) {
2298         return preloadId == null || preloadId.length() == 0;
2299     }
2300
2301     private void trySetSvcRequestId(PreloadNetworkTopologyOperationInput input,
2302             PreloadNetworkTopologyOperationOutputBuilder responseBuilder) {
2303         if (input.getSdncRequestHeader() != null) {
2304             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2305         }
2306     }
2307
2308     private Properties tryGetProperties(String svcOperation, Properties parms, PreloadDataBuilder preloadDataBuilder,
2309             ResponseObject responseObject) {
2310         try {
2311             if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2312                 try {
2313                     return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", preloadDataBuilder, parms);
2314                 } catch (Exception e) {
2315                     log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2316                     responseObject.setMessage(e.getMessage());
2317                     responseObject.setStatusCode("500");
2318                 }
2319             } else {
2320                 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2321                 responseObject.setStatusCode("503");
2322             }
2323         } catch (Exception e) {
2324             responseObject.setMessage(e.getMessage());
2325             responseObject.setStatusCode("500");
2326             log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2327         }
2328
2329         return null;
2330     }
2331
2332     private void trySetResponseMessage(PreloadNetworkTopologyOperationOutputBuilder responseBuilder,
2333             ResponseObject responseObject) {
2334         if (responseObject.getMessage() != null) {
2335             if (!responseObject.getMessage().isEmpty()) {
2336                 responseBuilder.setResponseMessage(responseObject.getMessage());
2337             }
2338         }
2339     }
2340
2341     private void tryDeletePreload(PreloadNetworkTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
2342         if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
2343             log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
2344             deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
2345             deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
2346         }
2347     }
2348
2349     @Override
2350     public Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2351             PreloadVfModuleTopologyOperationInput input) {
2352
2353         final String svcOperation = "preload-vf-module-topology-operation";
2354         PreloadData preloadData;
2355         Properties properties = new Properties();
2356
2357         log.info(CALLED_STR, svcOperation);
2358         // create a new response object
2359         PreloadVfModuleTopologyOperationOutputBuilder responseBuilder = new PreloadVfModuleTopologyOperationOutputBuilder();
2360
2361         if (hasInvalidPreloadVfModule(input)) {
2362             log.debug(
2363                     "exiting {} because of null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name",
2364                     svcOperation);
2365             responseBuilder.setResponseCode("403");
2366             responseBuilder.setResponseMessage(
2367                     "invalid input, null or empty preload-vf-module-topology-information.vf-module-topology.vf-module-topology-identifier.vf-module-name");
2368             responseBuilder.setAckFinalIndicator("Y");
2369
2370             RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2371                     .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2372
2373             return Futures.immediateFuture(rpcResult);
2374         }
2375
2376         // Grab the preload ID from the input buffer
2377         String preloadId = input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
2378                 .getVfModuleTopologyIdentifier().getVfModuleName();
2379         String preloadType = "vf-module";
2380
2381         trySetSvcRequestId(input, responseBuilder);
2382
2383         PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2384         getPreloadData(preloadId, preloadType, preloadDataBuilder);
2385
2386         PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2387         getPreloadData(preloadId, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2388
2389         //
2390         // setup a preload-data object builder
2391         // ACTION preload-vf-module-topology-operation
2392         // INPUT:
2393         // uses sdnc-request-header;
2394         // uses request-information;
2395         // uses preload-vnf-topology-information;
2396         // OUTPUT:
2397         // uses preload-topology-response-body;
2398         //
2399         // container preload-data
2400         // uses preload-vf-module-topology-information;
2401         // uses preload-oper-status;
2402
2403         log.info(ADDING_INPUT_DATA_LOG, svcOperation, preloadId, input);
2404         PreloadVfModuleTopologyOperationInputBuilder inputBuilder = new PreloadVfModuleTopologyOperationInputBuilder(
2405                 input);
2406         GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
2407         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, preloadId, input);
2408         GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
2409
2410         // Call SLI sync method
2411         ResponseObject responseObject = new ResponseObject("200", "");
2412         String ackFinal = "Y";
2413         Properties respProps = tryGetProperties(svcOperation, properties, preloadDataBuilder, responseObject);
2414
2415         if (respProps != null) {
2416             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2417             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2418             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2419         }
2420
2421         if (failed(responseObject)) {
2422             responseBuilder.setResponseCode(responseObject.getStatusCode());
2423             responseBuilder.setResponseMessage(responseObject.getMessage());
2424             responseBuilder.setAckFinalIndicator(ackFinal);
2425             log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2426             RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2427                     .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2428             return Futures.immediateFuture(rpcResult);
2429         }
2430
2431         // Got success from SLI
2432         try {
2433             preloadData = preloadDataBuilder.build();
2434             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, preloadId, preloadData);
2435
2436             // preload-list object
2437             PreloadListBuilder preloadListBuilder = new PreloadListBuilder();
2438             preloadListBuilder.setPreloadId(preloadId);
2439             preloadListBuilder.setPreloadType(preloadType);
2440             preloadListBuilder.setPreloadData(preloadData);
2441
2442             savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2443             log.info(UPDATING_TREE_INFO_MESSAGE);
2444             savePreloadList(preloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2445
2446             tryDeletePreload(input, preloadListBuilder);
2447
2448         } catch (Exception e) {
2449             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, preloadId, e);
2450             responseBuilder.setResponseCode("500");
2451             responseBuilder.setResponseMessage(e.getMessage());
2452             responseBuilder.setAckFinalIndicator("Y");
2453             log.error(RETURNED_FAILED_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2454             RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2455                     .<PreloadVfModuleTopologyOperationOutput>status(false).withResult(responseBuilder.build()).build();
2456             return Futures.immediateFuture(rpcResult);
2457         }
2458
2459         // Update succeeded
2460         responseBuilder.setResponseCode(responseObject.getStatusCode());
2461         responseBuilder.setAckFinalIndicator(ackFinal);
2462         trySetResponseMessage(responseBuilder, responseObject);
2463         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, preloadId);
2464         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, preloadId, responseBuilder.build());
2465
2466         RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
2467                 .<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2468         return Futures.immediateFuture(rpcResult);
2469     }
2470
2471     private boolean hasInvalidPreloadVfModule(PreloadVfModuleTopologyOperationInput input) {
2472         return input == null || input.getPreloadVfModuleTopologyInformation() == null
2473                 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology() == null
2474                 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology()
2475                         .getVfModuleTopologyIdentifier() == null
2476                 || input.getPreloadVfModuleTopologyInformation().getVfModuleTopology().getVfModuleTopologyIdentifier()
2477                         .getVfModuleName() == null;
2478     }
2479
2480     private void trySetSvcRequestId(PreloadVfModuleTopologyOperationInput input,
2481             PreloadVfModuleTopologyOperationOutputBuilder responseBuilder) {
2482         if (input.getSdncRequestHeader() != null) {
2483             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2484         }
2485     }
2486
2487     private void trySetResponseMessage(PreloadVfModuleTopologyOperationOutputBuilder responseBuilder,
2488             ResponseObject responseObject) {
2489         if (responseObject.getMessage() != null) {
2490             if (!responseObject.getMessage().isEmpty()) {
2491                 responseBuilder.setResponseMessage(responseObject.getMessage());
2492             }
2493         }
2494     }
2495
2496     private void tryDeletePreload(PreloadVfModuleTopologyOperationInput input, PreloadListBuilder preloadListBuilder) {
2497         if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
2498             log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
2499             deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
2500             deletePreloadList(preloadListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
2501         }
2502     }
2503
2504     @Override
2505     public Future<RpcResult<GenericConfigurationTopologyOperationOutput>> genericConfigurationTopologyOperation(
2506             GenericConfigurationTopologyOperationInput input) {
2507
2508         final String svcOperation = "generic-configuration-topology-operation";
2509         ServiceData serviceData;
2510         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2511         Properties parms = new Properties();
2512
2513         log.info(CALLED_STR, svcOperation);
2514         // create a new response object
2515         GenericConfigurationTopologyOperationOutputBuilder responseBuilder = new GenericConfigurationTopologyOperationOutputBuilder();
2516
2517         if (hasInvalidService(input)) {
2518             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2519             responseBuilder.setResponseCode("404");
2520             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2521             responseBuilder.setAckFinalIndicator("Y");
2522
2523             RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2524                     .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2525                     .build();
2526
2527             return Futures.immediateFuture(rpcResult);
2528         }
2529
2530         // Grab the service instance ID from the input buffer
2531         String siid = input.getServiceInformation().getServiceInstanceId();
2532
2533         trySetSvcRequestId(input, responseBuilder);
2534
2535         if (hasInvalidConfigurationIdOrType(input)) {
2536             log.debug("exiting {} because of null or empty configuration-id or configuration-type", svcOperation);
2537             responseBuilder.setResponseCode("404");
2538             responseBuilder.setResponseMessage("invalid input, null or empty configuration-id or configuration-type");
2539             responseBuilder.setAckFinalIndicator("Y");
2540             RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2541                     .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2542                     .build();
2543             return Futures.immediateFuture(rpcResult);
2544         }
2545
2546         // Grab the configuration ID from the input buffer
2547         String configId = input.getConfigurationInformation().getConfigurationId();
2548
2549         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2550         getServiceData(siid, serviceDataBuilder);
2551
2552         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
2553         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2554
2555         // Set the serviceStatus based on input
2556         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
2557         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
2558
2559         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2560         GenericConfigurationTopologyOperationInputBuilder inputBuilder = new GenericConfigurationTopologyOperationInputBuilder(
2561                 input);
2562         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2563
2564         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
2565         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2566
2567         // Call SLI sync method
2568
2569         ResponseObject responseObject = new ResponseObject("200", "");
2570         String ackFinal = "Y";
2571         String serviceObjectPath = "";
2572         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2573
2574         if (respProps != null) {
2575             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2576             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2577             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2578             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2579         }
2580
2581         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
2582         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
2583         serviceStatusBuilder.setRpcName(svcOperation);
2584
2585         if (failed(responseObject)) {
2586             responseBuilder.setResponseCode(responseObject.getStatusCode());
2587             responseBuilder.setResponseMessage(responseObject.getMessage());
2588             responseBuilder.setAckFinalIndicator(ackFinal);
2589
2590             ServiceBuilder serviceBuilder = new ServiceBuilder();
2591             serviceBuilder.setServiceInstanceId(siid);
2592             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2593             try {
2594                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2595             } catch (Exception e) {
2596                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2597             }
2598             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2599
2600             RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2601                     .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2602                     .build();
2603
2604             return Futures.immediateFuture(rpcResult);
2605         }
2606
2607         // Got success from SLI
2608         try {
2609             serviceData = serviceDataBuilder.build();
2610
2611             // service object
2612             ServiceBuilder serviceBuilder = new ServiceBuilder();
2613             serviceBuilder.setServiceData(serviceData);
2614             serviceBuilder.setServiceInstanceId(siid);
2615             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2616             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2617
2618             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2619             serviceResponseInformationBuilder.setInstanceId(siid);
2620             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2621             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2622             GcResponseInformationBuilder gcResponseInformationBuilder = new GcResponseInformationBuilder();
2623             gcResponseInformationBuilder.setInstanceId(configId);
2624             responseBuilder.setGcResponseInformation(gcResponseInformationBuilder.build());
2625
2626         } catch (Exception e) {
2627             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2628             responseBuilder.setResponseCode("500");
2629             responseBuilder.setResponseMessage(e.getMessage());
2630             responseBuilder.setAckFinalIndicator("Y");
2631             RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2632                     .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2633                     .build();
2634
2635             return Futures.immediateFuture(rpcResult);
2636         }
2637
2638         // Update succeeded
2639         responseBuilder.setResponseCode(responseObject.getStatusCode());
2640         responseBuilder.setAckFinalIndicator(ackFinal);
2641         trySetResponseMessage(responseBuilder, responseObject);
2642         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2643         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2644
2645         RpcResult<GenericConfigurationTopologyOperationOutput> rpcResult = RpcResultBuilder
2646                 .<GenericConfigurationTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2647
2648         return Futures.immediateFuture(rpcResult);
2649     }
2650
2651     private boolean hasInvalidService(GenericConfigurationTopologyOperationInput input) {
2652         return input == null || input.getServiceInformation() == null
2653                 || input.getServiceInformation().getServiceInstanceId() == null
2654                 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2655     }
2656
2657     private void trySetSvcRequestId(GenericConfigurationTopologyOperationInput input,
2658             GenericConfigurationTopologyOperationOutputBuilder responseBuilder) {
2659         if (input.getSdncRequestHeader() != null) {
2660             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2661         }
2662     }
2663
2664     private boolean hasInvalidConfigurationIdOrType(GenericConfigurationTopologyOperationInput input) {
2665         return input.getConfigurationInformation() == null
2666                 || input.getConfigurationInformation().getConfigurationId() == null
2667                 || input.getConfigurationInformation().getConfigurationType() == null;
2668     }
2669
2670     private void trySetResponseMessage(GenericConfigurationTopologyOperationOutputBuilder responseBuilder,
2671             ResponseObject responseObject) {
2672         if (responseObject.getMessage() != null) {
2673             if (!responseObject.getMessage().isEmpty()) {
2674                 responseBuilder.setResponseMessage(responseObject.getMessage());
2675             }
2676         }
2677     }
2678
2679     @Override
2680     public Future<RpcResult<Void>> genericConfigurationNotification(GenericConfigurationNotificationInput input) {
2681
2682         final String svcOperation = "generic-configuration-notification";
2683         ServiceData serviceData;
2684         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2685         Properties parms = new Properties();
2686
2687         log.info(CALLED_STR, svcOperation);
2688
2689         // Grab the service instance ID from the input buffer
2690         String siid = input.getServiceInformation().getServiceInstanceId();
2691
2692         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2693         getServiceData(siid, serviceDataBuilder);
2694
2695         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
2696         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2697
2698         // Set the serviceStatus based on input
2699         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
2700         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
2701
2702         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2703         GenericConfigurationNotificationInputBuilder inputBuilder = new GenericConfigurationNotificationInputBuilder(
2704                 input);
2705         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2706
2707         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
2708         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2709
2710         // Call SLI sync method
2711
2712         ResponseObject responseObject = new ResponseObject("200", "");
2713         String ackFinal = "Y";
2714         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2715
2716         if (respProps != null) {
2717             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2718             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2719             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2720         }
2721
2722         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
2723         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
2724         serviceStatusBuilder.setRpcName(svcOperation);
2725
2726         if (failed(responseObject)) {
2727             ServiceBuilder serviceBuilder = new ServiceBuilder();
2728             serviceBuilder.setServiceInstanceId(siid);
2729             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2730             try {
2731                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2732             } catch (Exception e) {
2733                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2734             }
2735
2736             RpcResult<Void> rpcResult = RpcResultBuilder.<Void>status(true).build();
2737
2738             return Futures.immediateFuture(rpcResult);
2739         }
2740
2741         // Got success from SLI
2742         try {
2743             serviceData = serviceDataBuilder.build();
2744
2745             // service object
2746             ServiceBuilder serviceBuilder = new ServiceBuilder();
2747             serviceBuilder.setServiceData(serviceData);
2748             serviceBuilder.setServiceInstanceId(siid);
2749             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2750             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2751
2752             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2753             serviceResponseInformationBuilder.setInstanceId(siid);
2754
2755         } catch (Exception e) {
2756             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2757             RpcResult<Void> rpcResult = RpcResultBuilder.<Void>status(true).build();
2758
2759             return Futures.immediateFuture(rpcResult);
2760         }
2761
2762         // Update succeeded
2763         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2764
2765         RpcResult<Void> rpcResult = RpcResultBuilder.<Void>status(true).build();
2766
2767         return Futures.immediateFuture(rpcResult);
2768     }
2769
2770     @Override
2771     public Future<RpcResult<GetpathsegmentTopologyOperationOutput>> getpathsegmentTopologyOperation(
2772             GetpathsegmentTopologyOperationInput input) {
2773
2774         final String svcOperation = "getpathsegment-topology-operation";
2775         ServiceData serviceData;
2776         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
2777         Properties parms = new Properties();
2778
2779         log.info(CALLED_STR, svcOperation);
2780         // create a new response object
2781         GetpathsegmentTopologyOperationOutputBuilder responseBuilder = new GetpathsegmentTopologyOperationOutputBuilder();
2782
2783         if (hasInvalidService(input)) {
2784             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2785             responseBuilder.setResponseCode("404");
2786             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2787             responseBuilder.setAckFinalIndicator("Y");
2788
2789             RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2790                     .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2791
2792             return Futures.immediateFuture(rpcResult);
2793         }
2794
2795         // Grab the service instance ID from the input buffer
2796         String siid = input.getServiceInformation().getServiceInstanceId();
2797
2798         trySetSvcRequestId(input, responseBuilder);
2799
2800         if (hasInvalidOnapModelInformation(input)) {
2801             log.debug("exiting {} because no model-uuid provided", svcOperation);
2802             responseBuilder.setResponseCode("404");
2803             responseBuilder.setResponseMessage("invalid input, no model-uuid provided");
2804             responseBuilder.setAckFinalIndicator("Y");
2805             RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2806                     .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2807             return Futures.immediateFuture(rpcResult);
2808         }
2809
2810         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
2811         getServiceData(siid, serviceDataBuilder);
2812
2813         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
2814         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2815
2816         // Set the serviceStatus based on input
2817         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
2818         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
2819
2820         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2821         GetpathsegmentTopologyOperationInputBuilder inputBuilder = new GetpathsegmentTopologyOperationInputBuilder(
2822                 input);
2823         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2824
2825         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
2826         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2827
2828         // Call SLI sync method
2829
2830         ResponseObject responseObject = new ResponseObject("200", "");
2831         String ackFinal = "Y";
2832         String serviceObjectPath = null;
2833         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
2834
2835         if (respProps != null) {
2836             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2837             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2838             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2839             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2840         }
2841
2842         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
2843         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
2844         serviceStatusBuilder.setRpcName(svcOperation);
2845
2846         if (failed(responseObject)) {
2847             responseBuilder.setResponseCode(responseObject.getStatusCode());
2848             responseBuilder.setResponseMessage(responseObject.getMessage());
2849             responseBuilder.setAckFinalIndicator(ackFinal);
2850
2851             ServiceBuilder serviceBuilder = new ServiceBuilder();
2852             serviceBuilder.setServiceInstanceId(siid);
2853             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2854             try {
2855                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2856             } catch (Exception e) {
2857                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2858             }
2859             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2860
2861             RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2862                     .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2863
2864             return Futures.immediateFuture(rpcResult);
2865         }
2866
2867         // Got success from SLI
2868         try {
2869             serviceData = serviceDataBuilder.build();
2870             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
2871
2872             // service object
2873             ServiceBuilder serviceBuilder = new ServiceBuilder();
2874             serviceBuilder.setServiceData(serviceData);
2875             serviceBuilder.setServiceInstanceId(siid);
2876             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
2877             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2878
2879             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2880             serviceResponseInformationBuilder.setInstanceId(siid);
2881             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2882             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2883
2884         } catch (Exception e) {
2885             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2886             responseBuilder.setResponseCode("500");
2887             responseBuilder.setResponseMessage(e.getMessage());
2888             responseBuilder.setAckFinalIndicator("Y");
2889             RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2890                     .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2891
2892             return Futures.immediateFuture(rpcResult);
2893         }
2894
2895         // Update succeeded
2896         responseBuilder.setResponseCode(responseObject.getStatusCode());
2897         responseBuilder.setAckFinalIndicator(ackFinal);
2898         trySetResponseMessage(responseBuilder, responseObject);
2899         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2900         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2901
2902         RpcResult<GetpathsegmentTopologyOperationOutput> rpcResult = RpcResultBuilder
2903                 .<GetpathsegmentTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2904
2905         return Futures.immediateFuture(rpcResult);
2906     }
2907
2908     private boolean hasInvalidService(GetpathsegmentTopologyOperationInput input) {
2909         return input == null || input.getServiceInformation() == null
2910                 || input.getServiceInformation().getServiceInstanceId() == null
2911                 || input.getServiceInformation().getServiceInstanceId().length() == 0;
2912     }
2913
2914     private void trySetSvcRequestId(GetpathsegmentTopologyOperationInput input,
2915             GetpathsegmentTopologyOperationOutputBuilder responseBuilder) {
2916         if (input.getSdncRequestHeader() != null) {
2917             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2918         }
2919     }
2920
2921     private boolean hasInvalidOnapModelInformation(GetpathsegmentTopologyOperationInput input) {
2922         return input.getServiceInformation() == null || input.getServiceInformation().getOnapModelInformation() == null
2923                 || input.getServiceInformation().getOnapModelInformation().getModelUuid() == null;
2924     }
2925
2926     private void trySetResponseMessage(GetpathsegmentTopologyOperationOutputBuilder responseBuilder,
2927             ResponseObject responseObject) {
2928         if (responseObject.getMessage() != null) {
2929             if (!responseObject.getMessage().isEmpty()) {
2930                 responseBuilder.setResponseMessage(responseObject.getMessage());
2931             }
2932         }
2933     }
2934
2935     @Override
2936     public Future<RpcResult<PolicyUpdateNotifyOperationOutput>> policyUpdateNotifyOperation(
2937             PolicyUpdateNotifyOperationInput input) {
2938
2939         final String svcOperation = "policy-update-notify-operation";
2940         Properties parms = new Properties();
2941
2942         log.info(CALLED_STR, svcOperation);
2943
2944         // create a new response object
2945         PolicyUpdateNotifyOperationOutputBuilder responseBuilder = new PolicyUpdateNotifyOperationOutputBuilder();
2946
2947         // Make sure we have a valid input
2948         if (hasInvalidInput(input)) {
2949             log.debug("exiting {} because policy name, update type, or version id was not provided", svcOperation);
2950             responseBuilder.setErrorCode("404");
2951             responseBuilder.setErrorMsg("Invalid input, missing input data");
2952             RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
2953                     .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2954             return Futures.immediateFuture(rpcResult);
2955         }
2956
2957         log.info("Adding INPUT data for {} input: {}", svcOperation, input);
2958         PolicyUpdateNotifyOperationInputBuilder inputBuilder = new PolicyUpdateNotifyOperationInputBuilder(input);
2959         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2960
2961         // Call SLI sync method
2962         ResponseObject responseObject = new ResponseObject("200", "");
2963         String ackFinal = "Y";
2964         String serviceObjectPath = null;
2965         Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2966
2967         if (respProps != null) {
2968             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2969             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2970             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2971             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2972         }
2973
2974         if (failed(responseObject)) {
2975             responseBuilder.setErrorCode(responseObject.getStatusCode());
2976             responseBuilder.setErrorMsg(responseObject.getMessage());
2977             log.error(RETURNED_FAILED_MESSAGE, svcOperation, "policy update", responseBuilder.build());
2978
2979             RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
2980                     .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2981
2982             return Futures.immediateFuture(rpcResult);
2983         }
2984
2985         // Got success from SLI
2986         responseBuilder.setErrorCode(responseObject.getStatusCode());
2987         if (responseObject.getMessage() != null) {
2988             responseBuilder.setErrorMsg(responseObject.getMessage());
2989         }
2990         log.info("Returned SUCCESS for " + svcOperation + responseBuilder.build());
2991         RpcResult<PolicyUpdateNotifyOperationOutput> rpcResult = RpcResultBuilder
2992                 .<PolicyUpdateNotifyOperationOutput>status(true).withResult(responseBuilder.build()).build();
2993         // return success
2994         return Futures.immediateFuture(rpcResult);
2995     }
2996
2997     private boolean hasInvalidInput(PolicyUpdateNotifyOperationInput input) {
2998         return (input.getPolicyName() == null) || (input.getUpdateType() == null) || (input.getVersionId() == null);
2999     }
3000
3001     @Override
3002     public Future<RpcResult<PortMirrorTopologyOperationOutput>> portMirrorTopologyOperation(
3003             final PortMirrorTopologyOperationInput input) {
3004
3005         final String svcOperation = "port-mirror-topology-operation";
3006         ServiceData serviceData = null;
3007         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3008         Properties properties = new Properties();
3009
3010         log.info(CALLED_STR, svcOperation);
3011
3012         // create a new response object
3013         PortMirrorTopologyOperationOutputBuilder responseBuilder = new PortMirrorTopologyOperationOutputBuilder();
3014
3015         if (hasInvalidService(input)) {
3016             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3017             responseBuilder.setResponseCode("404");
3018             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
3019             responseBuilder.setAckFinalIndicator("Y");
3020             RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3021                     .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3022             // return error
3023             return Futures.immediateFuture(rpcResult);
3024         }
3025
3026         if (hasInvalidConfigurationId(input)) {
3027             log.debug("exiting {} because of null or empty configuration-id", svcOperation);
3028             responseBuilder.setResponseCode("404");
3029             responseBuilder.setResponseMessage("invalid input, null or empty configuration-id");
3030             responseBuilder.setAckFinalIndicator("Y");
3031             RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3032                     .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3033             return Futures.immediateFuture(rpcResult);
3034         }
3035
3036         // Grab the service instance ID from the input buffer
3037         String siid = input.getServiceInformation().getServiceInstanceId();
3038
3039         trySetSvcRequestId(input, responseBuilder);
3040
3041         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3042         getServiceData(siid, serviceDataBuilder);
3043
3044         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3045         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3046
3047         // Set the serviceStatus based on input
3048         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3049         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3050
3051         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3052         PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3053         GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
3054
3055         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3056         GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
3057
3058         // Call SLI sync method
3059         ResponseObject responseObject = new ResponseObject("200", "");
3060         String ackFinal = "Y";
3061         String serviceObjectPath = null;
3062         String portMirrorObjectPath = null;
3063         Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
3064
3065         if (respProps != null) {
3066             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3067             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3068             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3069             serviceObjectPath = respProps.getProperty("service-object-path");
3070             portMirrorObjectPath = respProps.getProperty("port-mirror-object-path");
3071         }
3072
3073         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3074         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3075         serviceStatusBuilder.setRpcName(svcOperation);
3076
3077         if (failed(responseObject)) {
3078             responseBuilder.setResponseCode(responseObject.getStatusCode());
3079             responseBuilder.setResponseMessage(responseObject.getMessage());
3080             responseBuilder.setAckFinalIndicator(ackFinal);
3081
3082             ServiceBuilder serviceBuilder = new ServiceBuilder();
3083             serviceBuilder.setServiceInstanceId(siid);
3084             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3085             try {
3086                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3087             } catch (Exception e) {
3088                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3089             }
3090             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3091
3092             RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3093                     .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3094
3095             // return error
3096             return Futures.immediateFuture(rpcResult);
3097         }
3098
3099         // Got success from SLI
3100         try {
3101             serviceData = serviceDataBuilder.build();
3102             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3103
3104             // service object
3105             ServiceBuilder serviceBuilder = new ServiceBuilder();
3106             serviceBuilder.setServiceData(serviceData);
3107             serviceBuilder.setServiceInstanceId(siid);
3108             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3109             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3110
3111             if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3112                 // Only update operational tree on activate or delete
3113                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3114                         || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3115                     log.info(UPDATING_TREE_INFO_MESSAGE);
3116                     saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3117                 }
3118             }
3119
3120             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3121             serviceResponseInformationBuilder.setInstanceId(siid);
3122             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3123             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
3124             PortMirrorResponseInformationBuilder portMirrorResponseInformationBuilder = new PortMirrorResponseInformationBuilder();
3125             portMirrorResponseInformationBuilder
3126                     .setInstanceId(input.getConfigurationInformation().getConfigurationId());
3127             portMirrorResponseInformationBuilder.setObjectPath(portMirrorObjectPath);
3128             responseBuilder.setPortMirrorResponseInformation(portMirrorResponseInformationBuilder.build());
3129
3130         } catch (Exception e) {
3131             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3132             responseBuilder.setResponseCode("500");
3133             responseBuilder.setResponseMessage(e.getMessage());
3134             responseBuilder.setAckFinalIndicator("Y");
3135             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3136             RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3137                     .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3138             return Futures.immediateFuture(rpcResult);
3139         }
3140
3141         // Update succeeded
3142         responseBuilder.setResponseCode(responseObject.getStatusCode());
3143         responseBuilder.setAckFinalIndicator(ackFinal);
3144         trySetResponseMessage(responseBuilder, responseObject);
3145         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3146         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3147
3148         RpcResult<PortMirrorTopologyOperationOutput> rpcResult = RpcResultBuilder
3149                 .<PortMirrorTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
3150
3151         if (ackFinal.equals("N")) {
3152             // Spawn background thread to invoke the Async DG
3153             Runnable backgroundThread = new Runnable() {
3154                 public void run() {
3155                     log.info(BACKGROUND_THREAD_STARTED_MESSAGE);
3156                     processAsyncPortMirrorTopologyOperation(input);
3157                 }
3158             };
3159             new Thread(backgroundThread).start();
3160         }
3161
3162         // return success
3163         return Futures.immediateFuture(rpcResult);
3164     }
3165
3166     private boolean hasInvalidService(PortMirrorTopologyOperationInput input) {
3167         return input == null || input.getServiceInformation() == null
3168                 || input.getServiceInformation().getServiceInstanceId() == null
3169                 || input.getServiceInformation().getServiceInstanceId().length() == 0;
3170     }
3171
3172     private boolean hasInvalidConfigurationId(PortMirrorTopologyOperationInput input) {
3173         return input.getConfigurationInformation() == null
3174                 || input.getConfigurationInformation().getConfigurationId() == null
3175                 || input.getConfigurationInformation().getConfigurationId().length() == 0;
3176     }
3177
3178     private void trySetSvcRequestId(PortMirrorTopologyOperationInput input,
3179             PortMirrorTopologyOperationOutputBuilder responseBuilder) {
3180         if (input.getSdncRequestHeader() != null) {
3181             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
3182         }
3183     }
3184
3185     private void trySetResponseMessage(PortMirrorTopologyOperationOutputBuilder responseBuilder,
3186             ResponseObject responseObject) {
3187         if (responseObject.getMessage() != null) {
3188             if (!responseObject.getMessage().isEmpty()) {
3189                 responseBuilder.setResponseMessage(responseObject.getMessage());
3190             }
3191         }
3192     }
3193
3194     public void processAsyncPortMirrorTopologyOperation(PortMirrorTopologyOperationInput input) {
3195         log.info(BACKGROUND_THREAD_INFO, input.getConfigurationInformation().getConfigurationId());
3196
3197         final String svcOperation = "port-mirror-topology-operation-async";
3198         ServiceData serviceData = null;
3199         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3200         Properties parms = new Properties();
3201
3202         log.info(CALLED_STR, svcOperation);
3203
3204         // Grab the service instance ID from the input buffer
3205         String siid = input.getServiceInformation().getServiceInstanceId();
3206
3207         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3208         getServiceData(siid, serviceDataBuilder);
3209
3210         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3211         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3212
3213         // Set the serviceStatus based on input
3214         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3215         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3216
3217         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3218         PortMirrorTopologyOperationInputBuilder inputBuilder = new PortMirrorTopologyOperationInputBuilder(input);
3219         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3220
3221         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3222         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3223
3224         // Call SLI sync method
3225         ResponseObject responseObject = new ResponseObject("200", "");
3226         String ackFinal = "Y";
3227         String serviceObjectPath = null;
3228         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3229
3230         if (respProps != null) {
3231             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3232             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3233             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3234         }
3235
3236         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3237         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3238         serviceStatusBuilder.setRpcName(svcOperation);
3239
3240         if (failed(responseObject)) {
3241             ServiceBuilder serviceBuilder = new ServiceBuilder();
3242             serviceBuilder.setServiceInstanceId(siid);
3243             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3244             try {
3245                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
3246             } catch (Exception e) {
3247                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3248             }
3249
3250             // return error
3251             return;
3252         }
3253
3254         // Got success from SLI
3255         try {
3256             serviceData = serviceDataBuilder.build();
3257             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
3258
3259             // service object
3260             ServiceBuilder serviceBuilder = new ServiceBuilder();
3261             serviceBuilder.setServiceData(serviceData);
3262             serviceBuilder.setServiceInstanceId(siid);
3263             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
3264             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
3265
3266             if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
3267                 // Only update operational tree on activate or delete
3268                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign)
3269                         || input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
3270                     log.info(UPDATING_TREE_INFO_MESSAGE);
3271                     saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
3272                 }
3273             }
3274
3275             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
3276             serviceResponseInformationBuilder.setInstanceId(siid);
3277             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
3278
3279         } catch (Exception e) {
3280             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
3281             return;
3282         }
3283
3284         // Update succeeded
3285         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
3286
3287         return;
3288     }
3289
3290     @Override
3291     public Future<RpcResult<VnfGetResourceRequestOutput>> vnfGetResourceRequest(VnfGetResourceRequestInput input) {
3292
3293         final String svcOperation = "vnf-get-resource-request";
3294         ServiceData serviceData;
3295         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
3296         Properties parms = new Properties();
3297
3298         log.info(CALLED_STR, svcOperation);
3299         // create a new response object
3300         VnfGetResourceRequestOutputBuilder responseBuilder = new VnfGetResourceRequestOutputBuilder();
3301
3302         if (hasInvalidService(input)) {
3303             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
3304             RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3305                     .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3306             // return error
3307             return Futures.immediateFuture(rpcResult);
3308         }
3309
3310         // Grab the service instance ID from the input buffer
3311         String siid = input.getServiceInformation().getServiceInstanceId();
3312
3313         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
3314         getServiceData(siid, serviceDataBuilder);
3315
3316         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
3317         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
3318
3319         // Set the serviceStatus based on input
3320         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
3321         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
3322
3323         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
3324         VnfGetResourceRequestInputBuilder inputBuilder = new VnfGetResourceRequestInputBuilder(input);
3325         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
3326
3327         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid, operDataBuilder.build());
3328         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
3329
3330         // Call SLI sync method
3331
3332         ResponseObject responseObject = new ResponseObject("200", "");
3333         String ackFinal = "Y";
3334         String serviceObjectPath = null;
3335         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
3336
3337         if (respProps != null) {
3338             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
3339             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
3340             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
3341             serviceObjectPath = respProps.getProperty("service-object-path");
3342         }
3343
3344         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
3345         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
3346         serviceStatusBuilder.setRpcName(svcOperation);
3347
3348         if (failed(responseObject)) {
3349             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
3350             RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder
3351                     .<VnfGetResourceRequestOutput>status(true).withResult(responseBuilder.build()).build();
3352             // return error
3353             return Futures.immediateFuture(rpcResult);
3354         }
3355
3356         // Got success from SLI
3357         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
3358
3359         if (respProps != null) {
3360             GenericResourceApiUtil.toBuilder(respProps, responseBuilder);
3361         }
3362
3363         RpcResult<VnfGetResourceRequestOutput> rpcResult = RpcResultBuilder.<VnfGetResourceRequestOutput>status(true)
3364                 .withResult(responseBuilder.build()).build();
3365
3366         // return success
3367         return Futures.immediateFuture(rpcResult);
3368     }
3369
3370     private boolean hasInvalidService(VnfGetResourceRequestInput input) {
3371         return input == null || input.getServiceInformation() == null
3372                 || input.getServiceInformation().getServiceInstanceId() == null
3373                 || input.getServiceInformation().getServiceInstanceId().length() == 0;
3374     }
3375 }