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