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

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