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