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

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