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