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