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

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