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

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