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

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