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 java.text.DateFormat;
   7 import java.text.SimpleDateFormat;
   8 import java.util.Date;
   9 import java.util.Properties;
  10 import java.util.TimeZone;
  11 import java.util.concurrent.ExecutionException;
  12 import java.util.concurrent.ExecutorService;
  13 import java.util.concurrent.Executors;
  14 import java.util.concurrent.Future;
  15 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  16 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
  17 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  18 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  19 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  20 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
  21 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  22 import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
  23 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  24 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationInput;
  25 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationInputBuilder;
  26 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationOutput;
  27 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.BrgTopologyOperationOutputBuilder;
  28 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationInput;
  29 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationInputBuilder;
  30 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationOutput;
  31 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ConnectionAttachmentTopologyOperationOutputBuilder;
  32 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInput;
  33 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationInputBuilder;
  34 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutput;
  35 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ContrailRouteTopologyOperationOutputBuilder;
  36 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.GENERICRESOURCEAPIService;
  37 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInput;
  38 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationInputBuilder;
  39 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutput;
  40 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.NetworkTopologyOperationOutputBuilder;
  41 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInput;
  42 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationInputBuilder;
  43 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutput;
  44 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadNetworkTopologyOperationOutputBuilder;
  45 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationInput;
  46 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationInputBuilder;
  47 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationOutput;
  48 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfTopologyOperationOutputBuilder;
  49 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfs;
  50 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.PreloadVnfsBuilder;
  51 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInput;
  52 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationInputBuilder;
  53 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutput;
  54 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.SecurityZoneTopologyOperationOutputBuilder;
  55 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInput;
  56 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationInputBuilder;
  57 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutput;
  58 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServiceTopologyOperationOutputBuilder;
  59 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.Services;
  60 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.ServicesBuilder;
  61 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInput;
  62 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationInputBuilder;
  63 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutput;
  64 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.TunnelxconnTopologyOperationOutputBuilder;
  65 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInput;
  66 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationInputBuilder;
  67 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutput;
  68 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VfModuleTopologyOperationOutputBuilder;
  69 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInput;
  70 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationInputBuilder;
  71 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutput;
  72 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.VnfTopologyOperationOutputBuilder;
  73 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.brg.response.information.BrgResponseInformationBuilder;
  74 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.connection.attachment.response.information.ConnectionAttachmentResponseInformationBuilder;
  75 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.contrail.route.response.information.ContrailRouteResponseInformationBuilder;
  76 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.network.response.information.NetworkResponseInformationBuilder;
  77 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadData;
  78 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.data.PreloadDataBuilder;
  79 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadList;
  80 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadListBuilder;
  81 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.preload.model.information.VnfPreloadListKey;
  82 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.request.information.RequestInformation;
  83 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader;
  84 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.sdnc.request.header.SdncRequestHeader.SvcAction;
  85 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.security.zone.response.information.SecurityZoneResponseInformationBuilder;
  86 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceData;
  87 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.data.ServiceDataBuilder;
  88 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.Service;
  89 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceBuilder;
  90 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.model.infrastructure.ServiceKey;
  91 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.response.information.ServiceResponseInformationBuilder;
  92 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RequestStatus;
  93 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatus.RpcAction;
  94 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.service.status.ServiceStatusBuilder;
  95 import org.opendaylight.yang.gen.v1.org.onap.sdnc.northbound.generic.resource.rev170824.tunnelxconn.response.information.TunnelxconnResponseInformationBuilder;
  96 import org.opendaylight.yangtools.yang.binding.DataObject;
  97 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  98 import org.opendaylight.yangtools.yang.common.RpcResult;
  99 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
 100 import org.slf4j.Logger;
 101 import org.slf4j.LoggerFactory;
 102
 103 /**
 104  * Defines a base implementation for your provider. This class extends from a helper class which provides storage for
 105  * the most commonly used components of the MD-SAL. Additionally the base class provides some basic logging and
 106  * initialization / clean up methods.
 107  *
 108  * To use this, copy and paste (overwrite) the following method into the TestApplicationProviderModule class which is
 109  * auto generated under src/main/java in this project (created only once during first compilation):
 110  *
 111  * <pre>
 112  *
 113  * &#64;Override
 114  * public java.lang.AutoCloseable createInstance() {
 115  *
 116  *      // final GENERIC-RESOURCE-APIProvider provider = new
 117  *      // GENERIC-RESOURCE-APIProvider();
 118  *      final GenericResourceApiProvider provider = new GenericResourceApiProvider();
 119  *      provider.setDataBroker(getDataBrokerDependency());
 120  *      provider.setNotificationService(getNotificationServiceDependency());
 121  *      provider.setRpcRegistry(getRpcRegistryDependency());
 122  *      provider.initialize();
 123  *      return new AutoCloseable() {
 124  *
 125  *              &#64;Override
 126  *              public void close() throws Exception {
 127  *                      // TODO: CLOSE ANY REGISTRATION OBJECTS CREATED USING ABOVE
 128  *                      // BROKER/NOTIFICATION
 129  *                      // SERVIE/RPC REGISTRY
 130  *                      provider.close();
 131  *        }
 132  *    };
 133  * }
 134  *
 135  * </pre>
 136  */
 137
 138 public class GenericResourceApiProvider implements AutoCloseable, GENERICRESOURCEAPIService {
 139
 140     protected static final String APP_NAME = "generic-resource-api";
 141     private static final String CALLED_STR = "{} called.";
 142     private static final String NULL_OR_EMPTY_ERROR_MESSAGE = "exiting {} because of null or empty service-instance-id";
 143     protected static final String NULL_OR_EMPTY_ERROR_PARAM = "invalid input, null or empty service-instance-id";
 144     private static final String ADDING_INPUT_DATA_LOG = "Adding INPUT data for {} [{}] input: {}";
 145     private static final String ADDING_OPERATIONAL_DATA_LOG = "Adding OPERATIONAL data for {} [{}] operational-data: {}";
 146     private static final String OPERATIONAL_DATA_PARAM = "operational-data";
 147     protected static final String NO_SERVICE_LOGIC_ACTIVE = "No service logic active for ";
 148     private static final String SERVICE_LOGIC_SEARCH_ERROR_MESSAGE = "Caught exception looking for service logic";
 149     private static final String ERROR_CODE_PARAM = "error-code";
 150     private static final String ERROR_MESSAGE_PARAM = "error-message";
 151     private static final String ACK_FINAL_PARAM = "ack-final";
 152     private static final String SERVICE_OBJECT_PATH_PARAM = "service-object-path";
 153     private static final String UPDATING_MDSAL_ERROR_MESSAGE = "Caught Exception updating MD-SAL for {} [{}] \n";
 154     private static final String UPDATING_MDSAL_ERROR_MESSAGE_2 = "Caught Exception updating MD-SAL for {} [{},{}] \n";
 155     private static final String RETURNED_FAILED_MESSAGE = "Returned FAILED for {} [{}] {}";
 156     private static final String UPDATING_MDSAL_INFO_MESSAGE = "Updating MD-SAL for {} [{}] ServiceData: {}";
 157     private static final String UPDATED_MDSAL_INFO_MESSAGE = "Updated MD-SAL for {} [{}]";
 158     private static final String RETURNED_SUCCESS_MESSAGE = "Returned SUCCESS for {} [{}] {}";
 159     private static final String NON_NULL_PARAM = "non-null";
 160     private static final String NULL_PARAM = "null";
 161     private static final String SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE = "Caught exception executing service logic for {} ";
 162     private static final String UPDATING_TREE_INFO_MESSAGE = "Updating OPERATIONAL tree.";
 163     private static final String EMPTY_SERVICE_INSTANCE_MESSAGE = "exiting {} because the service-instance does not have any service data in SDNC";
 164     protected static final String INVALID_INPUT_ERROR_MESSAGE = "invalid input: the service-instance does not have any service data in SDNC";
 165     private static final String ALLOTTED_RESOURCE_ID_PARAM = "allotted-resource-id";
 166     private static final String ERROR_NETWORK_ID = "error";
 167
 168     private final Logger log = LoggerFactory.getLogger(GenericResourceApiProvider.class);
 169     private final ExecutorService executor;
 170     private final GenericResourceApiSvcLogicServiceClient svcLogicClient;
 171
 172     protected DataBroker dataBroker;
 173     protected NotificationPublishService notificationService;
 174     protected RpcProviderRegistry rpcRegistry;
 175     protected BindingAwareBroker.RpcRegistration<GENERICRESOURCEAPIService> rpcRegistration;
 176
 177     public GenericResourceApiProvider(
 178         DataBroker dataBroker,
 179         NotificationPublishService notificationPublishService,
 180         RpcProviderRegistry rpcProviderRegistry,
 181         GenericResourceApiSvcLogicServiceClient client
 182     ) {
 183         log.info("Creating provider for {}", APP_NAME);
 184         executor = Executors.newFixedThreadPool(1);
 185         setDataBroker(dataBroker);
 186         setNotificationService(notificationPublishService);
 187         setRpcRegistry(rpcProviderRegistry);
 188         svcLogicClient = client;
 189         initialize();
 190
 191     }
 192
 193     public void initialize() {
 194         log.info("Initializing provider for {}", APP_NAME);
 195         // Create the top level containers
 196         createContainers();
 197         try {
 198             GenericResourceApiUtil.loadProperties();
 199         } catch (Exception e) {
 200             log.error("Caught Exception while trying to load properties file", e);
 201         }
 202
 203         log.info("Initialization complete for {}", APP_NAME);
 204     }
 205
 206     protected void initializeChild() {
 207         // Override if you have custom initialization intelligence
 208     }
 209
 210     @Override
 211     public void close() throws Exception {
 212         log.info("Closing provider for {}", APP_NAME);
 213         executor.shutdown();
 214         rpcRegistration.close();
 215         log.info("Successfully closed provider for {}", APP_NAME);
 216     }
 217
 218     private static class Iso8601Util {
 219
 220         private static TimeZone timeZone = TimeZone.getTimeZone("UTC");
 221         private static DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
 222
 223         private Iso8601Util() {
 224         }
 225
 226         static {
 227             dateFormat.setTimeZone(timeZone);
 228         }
 229
 230         private static String now() {
 231             return dateFormat.format(new Date());
 232         }
 233     }
 234
 235     public void setDataBroker(DataBroker dataBroker) {
 236         this.dataBroker = dataBroker;
 237         if (log.isDebugEnabled()) {
 238             log.debug("DataBroker set to {}", dataBroker == null ? NULL_PARAM : NON_NULL_PARAM);
 239         }
 240     }
 241
 242     public void setNotificationService(NotificationPublishService notificationService) {
 243         this.notificationService = notificationService;
 244         if (log.isDebugEnabled()) {
 245             log.debug("Notification Service set to {}", notificationService == null ? NULL_PARAM : NON_NULL_PARAM);
 246         }
 247     }
 248
 249     public void setRpcRegistry(RpcProviderRegistry rpcRegistry) {
 250         this.rpcRegistry = rpcRegistry;
 251         if (log.isDebugEnabled()) {
 252             log.debug("RpcRegistry set to {}", rpcRegistry == null ? NULL_PARAM : NON_NULL_PARAM);
 253         }
 254     }
 255
 256     private void createContainers() {
 257
 258         final WriteTransaction t = dataBroker.newReadWriteTransaction();
 259
 260         // Create the service-instance container
 261         t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Services.class),
 262             new ServicesBuilder().build());
 263         t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(Services.class),
 264             new ServicesBuilder().build());
 265
 266         // Create the PreloadVnfs container
 267         t.merge(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(PreloadVnfs.class),
 268             new PreloadVnfsBuilder().build());
 269         t.merge(LogicalDatastoreType.OPERATIONAL, InstanceIdentifier.create(PreloadVnfs.class),
 270             new PreloadVnfsBuilder().build());
 271
 272         try {
 273             CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = t.submit();
 274             checkedFuture.get();
 275             log.info("Create containers succeeded!");
 276
 277         } catch (InterruptedException | ExecutionException e) {
 278             log.error("Create containers failed: ", e);
 279         }
 280     }
 281
 282     private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, String errorCode, String errorMessage,
 283         String ackFinal) {
 284         serviceStatusBuilder.setResponseCode(errorCode);
 285         serviceStatusBuilder.setResponseMessage(errorMessage);
 286         serviceStatusBuilder.setFinalIndicator(ackFinal);
 287         serviceStatusBuilder.setResponseTimestamp(Iso8601Util.now());
 288     }
 289
 290     private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, RequestInformation requestInformation) {
 291         if (requestInformation != null && requestInformation.getRequestAction() != null) {
 292             serviceStatusBuilder.setAction(requestInformation.getRequestAction().toString());
 293         }
 294     }
 295
 296     private void setServiceStatus(ServiceStatusBuilder serviceStatusBuilder, SdncRequestHeader requestHeader) {
 297         if (requestHeader != null && requestHeader.getSvcAction() != null) {
 298             switch (requestHeader.getSvcAction()) {
 299                 case Assign:
 300                     serviceStatusBuilder.setRpcAction(RpcAction.Assign);
 301                     break;
 302                 case Unassign:
 303                     serviceStatusBuilder.setRpcAction(RpcAction.Unassign);
 304                     break;
 305                 case Activate:
 306                     serviceStatusBuilder.setRpcAction(RpcAction.Activate);
 307                     break;
 308                 case Deactivate:
 309                     serviceStatusBuilder.setRpcAction(RpcAction.Deactivate);
 310                     break;
 311                 case Delete:
 312                     serviceStatusBuilder.setRpcAction(RpcAction.Delete);
 313                     break;
 314                 default:
 315                     log.error("Unknown SvcAction: {}", requestHeader.getSvcAction());
 316                     break;
 317             }
 318         }
 319     }
 320
 321     private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder) {
 322         // default to config
 323         getServiceData(siid, serviceDataBuilder, LogicalDatastoreType.CONFIGURATION);
 324     }
 325
 326     private void getServiceData(String siid, ServiceDataBuilder serviceDataBuilder, LogicalDatastoreType type) {
 327         // See if any data exists yet for this siid, if so grab it.
 328         InstanceIdentifier<Service> serviceInstanceIdentifier = InstanceIdentifier
 329             .builder(Services.class)
 330             .child(Service.class, new ServiceKey(siid))
 331             .build();
 332
 333         ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
 334         Optional<Service> data = Optional.absent();
 335         try {
 336             data = readTx.read(type, serviceInstanceIdentifier).get();
 337         } catch (InterruptedException | ExecutionException e) {
 338             log.error("Caught Exception reading MD-SAL ({}) data for [{}] ", type, siid, e);
 339         }
 340
 341         if (data != null && data.isPresent()) {
 342             ServiceData serviceData = data.get().getServiceData();
 343             if (serviceData != null) {
 344                 log.info("Read MD-SAL ({}) data for [{}] ServiceData: {}", type, siid, serviceData);
 345                 serviceDataBuilder.setSdncRequestHeader(serviceData.getSdncRequestHeader());
 346                 serviceDataBuilder.setRequestInformation(serviceData.getRequestInformation());
 347                 serviceDataBuilder.setServiceInformation(serviceData.getServiceInformation());
 348                 serviceDataBuilder.setServiceRequestInput(serviceData.getServiceRequestInput());
 349                 serviceDataBuilder.setServiceTopology(serviceData.getServiceTopology());
 350                 serviceDataBuilder.setServiceLevelOperStatus(serviceData.getServiceLevelOperStatus());
 351                 serviceDataBuilder.setNetworks(serviceData.getNetworks());
 352                 serviceDataBuilder.setVnfs(serviceData.getVnfs());
 353                 serviceDataBuilder.setProvidedAllottedResources(serviceData.getProvidedAllottedResources());
 354                 serviceDataBuilder.setConsumedAllottedResources(serviceData.getConsumedAllottedResources());
 355                 // service-instance-id needs to be set
 356             } else {
 357                 log.info("No service-data found in MD-SAL ({}) for [{}]", type, siid);
 358             }
 359         } else {
 360             log.info("No data found in MD-SAL ({}) for [{}]", type, siid);
 361         }
 362     }
 363
 364     private void getPreloadData(String vnfName, String vnfType, PreloadDataBuilder preloadDataBuilder) {
 365         // default to config
 366         getPreloadData(vnfName, vnfType, preloadDataBuilder, LogicalDatastoreType.CONFIGURATION);
 367     }
 368
 369     private void getPreloadData(String preloadName, String preloadType, PreloadDataBuilder preloadDataBuilder,
 370         LogicalDatastoreType type) {
 371         // See if any data exists yet for this name/type, if so grab it.
 372         InstanceIdentifier<VnfPreloadList> preloadInstanceIdentifier = InstanceIdentifier
 373             .builder(PreloadVnfs.class)
 374             .child(VnfPreloadList.class, new VnfPreloadListKey(preloadName, preloadType))
 375             .build();
 376
 377         ReadOnlyTransaction readTx = dataBroker.newReadOnlyTransaction();
 378         Optional<VnfPreloadList> data = Optional.absent();
 379         try {
 380             data = readTx.read(type, preloadInstanceIdentifier).get();
 381         } catch (InterruptedException | ExecutionException e) {
 382             log.error("Caught Exception reading MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType, e);
 383         }
 384
 385         if (data != null && data.isPresent()) {
 386             PreloadData preloadData = data.get().getPreloadData();
 387             if (preloadData != null) {
 388                 log.info("Read MD-SAL ({}) data for [{},{}] PreloadData: {}", type, preloadName, preloadType,
 389                     preloadData);
 390                 preloadDataBuilder.setVnfTopologyInformation(preloadData.getVnfTopologyInformation());
 391                 preloadDataBuilder.setNetworkTopologyInformation(preloadData.getNetworkTopologyInformation());
 392                 preloadDataBuilder.setOperStatus(preloadData.getOperStatus());
 393             } else {
 394                 log.info("No preload-data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
 395             }
 396         } else {
 397             log.info("No data found in MD-SAL ({}) for [{},{}] ", type, preloadName, preloadType);
 398         }
 399     }
 400
 401     private void saveService(final Service entry, boolean merge, LogicalDatastoreType storeType) {
 402         // Each entry will be identifiable by a unique key, we have to create that
 403         // identifier
 404         InstanceIdentifier<Service> path = InstanceIdentifier
 405             .builder(Services.class)
 406             .child(Service.class, entry.getKey())
 407             .build();
 408
 409         trySaveEntry(entry, merge, storeType, path);
 410     }
 411
 412     private void savePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) {
 413
 414         // Each entry will be identifiable by a unique key, we have to create that
 415         // identifier
 416         InstanceIdentifier<VnfPreloadList> path = InstanceIdentifier
 417             .builder(PreloadVnfs.class)
 418             .child(VnfPreloadList.class, entry.getKey())
 419             .build();
 420
 421         trySaveEntry(entry, merge, storeType, path);
 422     }
 423
 424     private <T extends DataObject> void trySaveEntry(T entry, boolean merge, LogicalDatastoreType storeType,
 425         InstanceIdentifier<T> path) {
 426         int tries = 2;
 427         while (true) {
 428             try {
 429                 save(entry, merge, storeType, path);
 430                 break;
 431             } catch (OptimisticLockFailedException e) {
 432                 if (--tries <= 0) {
 433                     log.debug("Got OptimisticLockFailedException on last try - failing ");
 434                     throw new IllegalStateException(e);
 435                 }
 436                 log.debug("Got OptimisticLockFailedException - trying again ");
 437             } catch (TransactionCommitFailedException ex) {
 438                 log.debug("Update DataStore failed");
 439                 throw new IllegalStateException(ex);
 440             }
 441         }
 442     }
 443
 444     private <T extends DataObject> void save(T entry, boolean merge, LogicalDatastoreType storeType,
 445         InstanceIdentifier<T> path)
 446         throws TransactionCommitFailedException {
 447         WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 448         if (merge) {
 449             tx.merge(storeType, path, entry);
 450         } else {
 451             tx.put(storeType, path, entry);
 452         }
 453         tx.submit().checkedGet();
 454         log.debug("Update DataStore succeeded");
 455     }
 456
 457     private void deleteService(final Service entry, LogicalDatastoreType storeType) {
 458         // Each entry will be identifiable by a unique key, we have to create
 459         // that identifier
 460         InstanceIdentifier<Service> path = InstanceIdentifier
 461             .builder(Services.class)
 462             .child(Service.class, entry.getKey())
 463             .build();
 464
 465         tryDeleteEntry(storeType, path);
 466     }
 467
 468     private void tryDeleteEntry(LogicalDatastoreType storeType, InstanceIdentifier<Service> path) {
 469         int tries = 2;
 470         while (true) {
 471             try {
 472                 delete(storeType, path);
 473                 break;
 474             } catch (OptimisticLockFailedException e) {
 475                 if (--tries <= 0) {
 476                     log.debug("Got OptimisticLockFailedException on last try - failing ");
 477                     throw new IllegalStateException(e);
 478                 }
 479                 log.debug("Got OptimisticLockFailedException - trying again ");
 480             } catch (TransactionCommitFailedException ex) {
 481                 log.debug("Update DataStore failed");
 482                 throw new IllegalStateException(ex);
 483             }
 484         }
 485     }
 486
 487     private void delete(LogicalDatastoreType storeType, InstanceIdentifier<Service> path)
 488         throws TransactionCommitFailedException {
 489         WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 490         tx.delete(storeType, path);
 491         tx.submit().checkedGet();
 492         log.debug("DataStore delete succeeded");
 493     }
 494
 495     @Override
 496     public Future<RpcResult<ServiceTopologyOperationOutput>> serviceTopologyOperation(
 497         ServiceTopologyOperationInput input) {
 498
 499         final String svcOperation = "service-topology-operation";
 500         ServiceData serviceData;
 501         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
 502         Properties parms = new Properties();
 503
 504         log.info(CALLED_STR, svcOperation);
 505         // create a new response object
 506         ServiceTopologyOperationOutputBuilder responseBuilder = new ServiceTopologyOperationOutputBuilder();
 507
 508         if (hasInvalidServiceId(input)) {
 509             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
 510             responseBuilder.setResponseCode("404");
 511             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
 512             responseBuilder.setAckFinalIndicator("Y");
 513
 514             RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
 515                 .<ServiceTopologyOperationOutput>status(true)
 516                 .withResult(responseBuilder.build())
 517                 .build();
 518
 519             return Futures.immediateFuture(rpcResult);
 520         }
 521
 522         // Grab the service instance ID from the input buffer
 523         String siid = input.getServiceInformation().getServiceInstanceId();
 524
 525         trySetSvcRequestId(input, responseBuilder);
 526
 527         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
 528         getServiceData(siid, serviceDataBuilder);
 529
 530         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
 531         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
 532
 533         // Set the serviceStatus based on input
 534         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
 535         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
 536
 537                 /*
 538          * // setup a service-data object builder // ACTION service-topology-operation
 539                  * // INPUT: // USES uses service-operation-information // OUTPUT: // uses
 540                  * topology-response-common; // uses service-response-information;
 541                  */
 542
 543         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
 544         ServiceTopologyOperationInputBuilder inputBuilder = new ServiceTopologyOperationInputBuilder(input);
 545         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
 546
 547         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
 548             operDataBuilder.build());
 549         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
 550
 551         // Call SLI sync method
 552         // Get SvcLogicService reference
 553
 554         ResponseObject responseObject = new ResponseObject("200", "");
 555         String ackFinal = "Y";
 556         String serviceObjectPath = null;
 557         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
 558
 559         if (respProps != null) {
 560             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
 561             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
 562             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
 563             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
 564         }
 565
 566         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
 567         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
 568         serviceStatusBuilder.setRpcName(svcOperation);
 569
 570         if (failed(responseObject)) {
 571             responseBuilder.setResponseCode(responseObject.getStatusCode());
 572             responseBuilder.setResponseMessage(responseObject.getMessage());
 573             responseBuilder.setAckFinalIndicator(ackFinal);
 574
 575             ServiceBuilder serviceBuilder = new ServiceBuilder();
 576             serviceBuilder.setServiceInstanceId(siid);
 577             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
 578             try {
 579                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
 580             } catch (Exception e) {
 581                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
 582             }
 583             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
 584
 585             RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
 586                 .<ServiceTopologyOperationOutput>status(true)
 587                 .withResult(responseBuilder.build())
 588                 .build();
 589
 590             return Futures.immediateFuture(rpcResult);
 591         }
 592
 593         // Got success from SLI
 594         try {
 595             serviceData = serviceDataBuilder.build();
 596             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
 597
 598             // service object
 599             ServiceBuilder serviceBuilder = new ServiceBuilder();
 600             serviceBuilder.setServiceData(serviceData);
 601             serviceBuilder.setServiceInstanceId(siid);
 602             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
 603             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
 604
 605             tryDeleteService(input, serviceBuilder);
 606
 607             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
 608             serviceResponseInformationBuilder.setInstanceId(siid);
 609             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
 610             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
 611
 612         } catch (Exception e) {
 613             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
 614             responseBuilder.setResponseCode("500");
 615             responseBuilder.setResponseMessage(e.getMessage());
 616             responseBuilder.setAckFinalIndicator("Y");
 617             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
 618
 619             RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
 620                 .<ServiceTopologyOperationOutput>status(true)
 621                 .withResult(responseBuilder.build())
 622                 .build();
 623
 624             return Futures.immediateFuture(rpcResult);
 625         }
 626
 627         // Update succeeded
 628         responseBuilder.setResponseCode(responseObject.getStatusCode());
 629         responseBuilder.setAckFinalIndicator(ackFinal);
 630         trySetResponseMessage(responseBuilder, responseObject);
 631         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
 632         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
 633
 634         RpcResult<ServiceTopologyOperationOutput> rpcResult = RpcResultBuilder
 635             .<ServiceTopologyOperationOutput>status(true)
 636             .withResult(responseBuilder.build())
 637             .build();
 638
 639         return Futures.immediateFuture(rpcResult);
 640     }
 641
 642     private void trySetResponseMessage(ServiceTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
 643         if (!error.getMessage().isEmpty()) {
 644             responseBuilder.setResponseMessage(error.getMessage());
 645         }
 646     }
 647
 648     private boolean hasInvalidServiceId(ServiceTopologyOperationInput input) {
 649         return input == null || input.getServiceInformation() == null
 650             || input.getServiceInformation().getServiceInstanceId() == null
 651             || input.getServiceInformation().getServiceInstanceId().length() == 0;
 652     }
 653
 654     private void trySetSvcRequestId(ServiceTopologyOperationInput input,
 655         ServiceTopologyOperationOutputBuilder responseBuilder) {
 656         if (input.getSdncRequestHeader() != null) {
 657             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
 658         }
 659     }
 660
 661     private void tryDeleteService(ServiceTopologyOperationInput input, ServiceBuilder serviceBuilder) {
 662         if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete)) {
 663             // Only update operational tree on delete
 664             log.info("Delete from both CONFIGURATION and OPERATIONAL tree.");
 665             deleteService(serviceBuilder.build(), LogicalDatastoreType.OPERATIONAL);
 666             deleteService(serviceBuilder.build(), LogicalDatastoreType.CONFIGURATION);
 667         }
 668     }
 669
 670     private Properties tryGetProperties(String svcOperation, Properties parms, ServiceDataBuilder serviceDataBuilder,
 671         ResponseObject responseObject) {
 672         try {
 673             if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
 674                 try {
 675                     return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
 676                 } catch (Exception e) {
 677                     log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
 678                     responseObject.setMessage(e.getMessage());
 679                     responseObject.setStatusCode("500");
 680                 }
 681             } else {
 682                 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
 683                 responseObject.setStatusCode("503");
 684             }
 685         } catch (Exception e) {
 686             responseObject.setMessage(e.getMessage());
 687             responseObject.setStatusCode("500");
 688             log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
 689         }
 690
 691         return null;
 692     }
 693
 694     private boolean failed(ResponseObject error) {
 695         return
 696             !error.getStatusCode().isEmpty() && !("0".equals(error.getStatusCode()) || "200"
 697                 .equals(error.getStatusCode()));
 698     }
 699
 700     private boolean isValidRequest(ServiceTopologyOperationInput input) {
 701         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
 702     }
 703
 704     @Override
 705     public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
 706
 707         final String svcOperation = "vnf-topology-operation";
 708         ServiceData serviceData;
 709         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
 710         Properties properties = new Properties();
 711
 712         log.info(CALLED_STR, svcOperation);
 713         // create a new response object
 714         VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
 715
 716         if (hasInvalidServiceId(input)) {
 717
 718             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
 719             responseBuilder.setResponseCode("404");
 720             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
 721             responseBuilder.setAckFinalIndicator("Y");
 722             RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder.<VnfTopologyOperationOutput>status(true)
 723                 .withResult(responseBuilder.build()).build();
 724             // return error
 725             return Futures.immediateFuture(rpcResult);
 726         }
 727
 728         // Grab the service instance ID from the input buffer
 729         String siid = input.getServiceInformation().getServiceInstanceId();
 730
 731         trySetSvcRequestId(input, responseBuilder);
 732
 733         if (hasInvalidVnfId(input)) {
 734             log.debug("exiting {} because of null or empty vnf-id", svcOperation);
 735             responseBuilder.setResponseCode("404");
 736             responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
 737             responseBuilder.setAckFinalIndicator("Y");
 738
 739             RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
 740                 .<VnfTopologyOperationOutput>status(true)
 741                 .withResult(responseBuilder.build())
 742                 .build();
 743
 744             return Futures.immediateFuture(rpcResult);
 745         }
 746
 747         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
 748         getServiceData(siid, serviceDataBuilder);
 749
 750         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
 751         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
 752
 753         // Set the serviceStatus based on input
 754         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
 755         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
 756
 757         //
 758         // setup a service-data object builder
 759         // ACTION vnf-topology-operation
 760         // INPUT:
 761         // USES sdnc-request-header;
 762         // USES request-information;
 763         // USES service-information;
 764         // USES vnf-request-information
 765         // OUTPUT:
 766         // USES vnf-topology-response-body;
 767         // USES vnf-information
 768         // USES service-information
 769         //
 770         // container service-data
 771         // uses vnf-configuration-information;
 772         // uses oper-status;
 773
 774         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
 775         VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
 776         GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
 777
 778         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
 779             operDataBuilder.build());
 780         GenericResourceApiUtil.toProperties(properties, OPERATIONAL_DATA_PARAM, operDataBuilder);
 781
 782         // Call SLI sync method
 783         // Get SvcLogicService reference
 784
 785         ResponseObject responseObject = new ResponseObject("200", "");
 786         String ackFinal = "Y";
 787         String serviceObjectPath = null;
 788         Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
 789
 790         if (respProps != null) {
 791             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
 792             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
 793             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
 794
 795             //FIXME if needed
 796             /*before was "vfn-object-path", but it didn't make sense, since everywhere else,
 797               when extracting service object path the "service-object-path" property is used*/
 798             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
 799         }
 800
 801         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
 802         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
 803         serviceStatusBuilder.setRpcName(svcOperation);
 804
 805         if (failed(responseObject)) {
 806             responseBuilder.setResponseCode(responseObject.getStatusCode());
 807             responseBuilder.setResponseMessage(responseObject.getMessage());
 808             responseBuilder.setAckFinalIndicator(ackFinal);
 809
 810             ServiceBuilder serviceBuilder = new ServiceBuilder();
 811             serviceBuilder.setServiceInstanceId(siid);
 812             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
 813             try {
 814                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
 815                 trySaveService(input, serviceBuilder);
 816             } catch (Exception e) {
 817                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
 818             }
 819             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
 820
 821             RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
 822                 .<VnfTopologyOperationOutput>status(true)
 823                 .withResult(responseBuilder.build())
 824                 .build();
 825
 826             // return error
 827             return Futures.immediateFuture(rpcResult);
 828         }
 829
 830         // Got success from SLI
 831         try {
 832             serviceData = serviceDataBuilder.build();
 833             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
 834
 835             // service object
 836             ServiceBuilder serviceBuilder = new ServiceBuilder();
 837             serviceBuilder.setServiceData(serviceData);
 838             serviceBuilder.setServiceInstanceId(siid);
 839             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
 840             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
 841
 842             if (isValidRequest(input) && input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
 843                 // Only update operational tree on Assign
 844
 845                 log.info(UPDATING_TREE_INFO_MESSAGE);
 846                 saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
 847             }
 848
 849             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
 850             serviceResponseInformationBuilder.setInstanceId(siid);
 851             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
 852             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
 853
 854         } catch (Exception e) {
 855             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
 856             responseBuilder.setResponseCode("500");
 857             responseBuilder.setResponseMessage(e.getMessage());
 858             responseBuilder.setAckFinalIndicator("Y");
 859             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
 860
 861             RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
 862                 .<VnfTopologyOperationOutput>status(true)
 863                 .withResult(responseBuilder.build())
 864                 .build();
 865
 866             return Futures.immediateFuture(rpcResult);
 867         }
 868
 869         // Update succeeded
 870         responseBuilder.setResponseCode(responseObject.getStatusCode());
 871         responseBuilder.setAckFinalIndicator(ackFinal);
 872         trySetResponseMessage(responseBuilder, responseObject);
 873         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
 874         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
 875
 876         RpcResult<VnfTopologyOperationOutput> rpcResult = RpcResultBuilder
 877             .<VnfTopologyOperationOutput>status(true)
 878             .withResult(responseBuilder.build())
 879             .build();
 880
 881         // return success
 882         return Futures.immediateFuture(rpcResult);
 883     }
 884
 885     private void trySetResponseMessage(VnfTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
 886         if (!error.getMessage().isEmpty()) {
 887             responseBuilder.setResponseMessage(error.getMessage());
 888         }
 889     }
 890
 891     private void trySaveService(VnfTopologyOperationInput input, ServiceBuilder serviceBuilder) {
 892         if (isValidRequest(input) &&
 893             (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
 894                 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
 895
 896             // Only update operational tree on activate or delete
 897             log.info(UPDATING_TREE_INFO_MESSAGE);
 898             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
 899         }
 900     }
 901
 902     private boolean hasInvalidVnfId(VnfTopologyOperationInput input) {
 903         return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
 904             || input.getVnfInformation().getVnfId().length() == 0;
 905     }
 906
 907     private boolean hasInvalidServiceId(VnfTopologyOperationInput input) {
 908         return input == null || input.getServiceInformation() == null
 909             || input.getServiceInformation().getServiceInstanceId() == null
 910             || input.getServiceInformation().getServiceInstanceId().length() == 0;
 911     }
 912
 913     private void trySetSvcRequestId(VnfTopologyOperationInput input,
 914         VnfTopologyOperationOutputBuilder responseBuilder) {
 915         if (input.getSdncRequestHeader() != null) {
 916             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
 917         }
 918     }
 919
 920     private boolean isValidRequest(VnfTopologyOperationInput input) {
 921         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
 922     }
 923
 924     @Override
 925     public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
 926         VfModuleTopologyOperationInput input) {
 927
 928         final String svcOperation = "vf-module-topology-operation";
 929         ServiceData serviceData;
 930         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
 931         Properties parms = new Properties();
 932
 933         log.info(CALLED_STR, svcOperation);
 934         // create a new response object
 935         VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
 936
 937         if (hasInvalidServiceId(input)) {
 938             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
 939             responseBuilder.setResponseCode("403");
 940             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
 941             responseBuilder.setAckFinalIndicator("Y");
 942
 943             RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
 944                 .<VfModuleTopologyOperationOutput>status(true)
 945                 .withResult(responseBuilder.build())
 946                 .build();
 947
 948             // return error
 949             return Futures.immediateFuture(rpcResult);
 950         }
 951
 952         if (hasInvalidVnfId(input)) {
 953             log.debug("exiting {} because of null or empty vnf-id", svcOperation);
 954             responseBuilder.setResponseCode("403");
 955             responseBuilder.setResponseMessage("invalid input, null or empty vnf-id");
 956             responseBuilder.setAckFinalIndicator("Y");
 957             RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
 958                 .<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
 959             return Futures.immediateFuture(rpcResult);
 960         }
 961
 962         if (hasInvalidVfModuleId(input)) {
 963             log.debug("exiting {} because of null or empty vf-module-id", svcOperation);
 964             responseBuilder.setResponseCode("403");
 965             responseBuilder.setResponseMessage("invalid input, vf-module-id is null or empty");
 966             responseBuilder.setAckFinalIndicator("Y");
 967
 968             RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
 969                 .<VfModuleTopologyOperationOutput>status(true)
 970                 .withResult(responseBuilder.build())
 971                 .build();
 972
 973             return Futures.immediateFuture(rpcResult);
 974         }
 975
 976         // Grab the service instance ID from the input buffer
 977         String siid = input.getServiceInformation().getServiceInstanceId();
 978
 979         trySetSvcRequestId(input, responseBuilder);
 980
 981         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
 982         getServiceData(siid, serviceDataBuilder);
 983
 984         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
 985         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
 986
 987         // Set the serviceStatus based on input
 988         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
 989         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
 990
 991         //
 992         // setup a service-data object builder
 993         // ACTION vnf-topology-operation
 994         // INPUT:
 995         // USES sdnc-request-header;
 996         // USES request-information;
 997         // USES service-information;
 998         // USES vnf-request-information
 999         // OUTPUT:
1000         // USES vnf-topology-response-body;
1001         // USES vnf-information
1002         // USES service-information
1003         //
1004         // container service-data
1005         // uses vnf-configuration-information;
1006         // uses oper-status;
1007
1008         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1009         VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1010         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1011
1012         log.info(ADDING_OPERATIONAL_DATA_LOG, svcOperation, siid,
1013             operDataBuilder.build());
1014         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
1015
1016         // Call SLI sync method
1017         // Get SvcLogicService reference
1018
1019         ResponseObject responseObject = new ResponseObject("200", "");
1020         String ackFinal = "Y";
1021         String serviceObjectPath = null;
1022         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1023
1024         if (respProps != null) {
1025             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1026             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1027             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1028
1029
1030             //FIXME if needed
1031             /*before was "vf-module-object-path", but it didnt make sense, since everywhere else,
1032               when extracting service object path the "service-object-path" property is used*/
1033             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1034         }
1035
1036         setServiceStatus(serviceStatusBuilder, responseObject.getStatusCode(), responseObject.getMessage(), ackFinal);
1037         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1038         serviceStatusBuilder.setRpcName(svcOperation);
1039
1040         if (failed(responseObject)) {
1041             responseBuilder.setResponseCode(responseObject.getStatusCode());
1042             responseBuilder.setResponseMessage(responseObject.getMessage());
1043             responseBuilder.setAckFinalIndicator(ackFinal);
1044
1045             ServiceBuilder serviceBuilder = new ServiceBuilder();
1046             serviceBuilder.setServiceInstanceId(siid);
1047             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1048             try {
1049                 saveService(serviceBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1050             } catch (Exception e) {
1051                 log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1052             }
1053             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1054
1055             RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1056                 .<VfModuleTopologyOperationOutput>status(true)
1057                 .withResult(responseBuilder.build())
1058                 .build();
1059
1060             // return error
1061             return Futures.immediateFuture(rpcResult);
1062         }
1063
1064         // Got success from SLI
1065         try {
1066             serviceData = serviceDataBuilder.build();
1067             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1068
1069             // service object
1070             ServiceBuilder serviceBuilder = new ServiceBuilder();
1071             serviceBuilder.setServiceData(serviceData);
1072             serviceBuilder.setServiceInstanceId(siid);
1073             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1074             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1075
1076             trySaveService(input, serviceBuilder);
1077
1078             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1079             serviceResponseInformationBuilder.setInstanceId(siid);
1080             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1081             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1082
1083         } catch (Exception e) {
1084             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1085             responseBuilder.setResponseCode("500");
1086             responseBuilder.setResponseMessage(e.getMessage());
1087             responseBuilder.setAckFinalIndicator("Y");
1088             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1089
1090             RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1091                 .<VfModuleTopologyOperationOutput>status(true)
1092                 .withResult(responseBuilder.build())
1093                 .build();
1094
1095             return Futures.immediateFuture(rpcResult);
1096         }
1097
1098         // Update succeeded
1099         responseBuilder.setResponseCode(responseObject.getStatusCode());
1100         responseBuilder.setAckFinalIndicator(ackFinal);
1101         trySetResponseMessage(responseBuilder, responseObject);
1102         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1103         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1104
1105         RpcResult<VfModuleTopologyOperationOutput> rpcResult = RpcResultBuilder
1106             .<VfModuleTopologyOperationOutput>status(true)
1107             .withResult(responseBuilder.build())
1108             .build();
1109
1110         // return success
1111         return Futures.immediateFuture(rpcResult);
1112     }
1113
1114     private void trySetResponseMessage(VfModuleTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
1115         if (!error.getMessage().isEmpty()) {
1116             responseBuilder.setResponseMessage(error.getMessage());
1117         }
1118     }
1119
1120     private void trySaveService(VfModuleTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1121         if (isValidRequest(input) &&
1122             (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1123                 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1124             // Only update operational tree on activate or delete
1125
1126             log.info(UPDATING_TREE_INFO_MESSAGE);
1127             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1128         }
1129     }
1130
1131     private void trySetSvcRequestId(VfModuleTopologyOperationInput input,
1132         VfModuleTopologyOperationOutputBuilder responseBuilder) {
1133         if (input.getSdncRequestHeader() != null) {
1134             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1135         }
1136     }
1137
1138     private boolean hasInvalidVfModuleId(VfModuleTopologyOperationInput input) {
1139         return input.getVfModuleInformation() == null || input.getVfModuleInformation().getVfModuleId() == null
1140             || input.getVfModuleInformation().getVfModuleId().length() == 0;
1141     }
1142
1143     private boolean hasInvalidVnfId(VfModuleTopologyOperationInput input) {
1144         return input.getVnfInformation() == null || input.getVnfInformation().getVnfId() == null
1145             || input.getVnfInformation().getVnfId().length() == 0;
1146     }
1147
1148     private boolean hasInvalidServiceId(VfModuleTopologyOperationInput input) {
1149         return input == null || input.getServiceInformation() == null
1150             || input.getServiceInformation().getServiceInstanceId() == null
1151             || input.getServiceInformation().getServiceInstanceId().length() == 0;
1152     }
1153
1154     private boolean isValidRequest(VfModuleTopologyOperationInput input) {
1155         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1156     }
1157
1158     @Override
1159     public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1160         NetworkTopologyOperationInput input) {
1161
1162         final String svcOperation = "network-topology-operation";
1163         ServiceData serviceData;
1164         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1165         Properties parms = new Properties();
1166
1167         log.info(CALLED_STR, svcOperation);
1168         // create a new response object
1169         NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1170
1171         if (hasInvalidServiceId(input)) {
1172             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1173             return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1174         }
1175
1176         String siid = input.getServiceInformation().getServiceInstanceId();
1177
1178         // Get the service-instance service data from MD-SAL
1179         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1180         getServiceData(siid, serviceDataBuilder);
1181
1182         this.trySetSvcRequestId(input, responseBuilder);
1183
1184         ServiceData sd = serviceDataBuilder.build();
1185         if (isInvalidServiceData(sd)) {
1186             log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1187             return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1188         }
1189
1190         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1191         NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1192         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1193
1194         // Call SLI sync method
1195         // Get SvcLogicService reference
1196
1197         ResponseObject responseObject = new ResponseObject("200", "");
1198         String ackFinal = "Y";
1199         String networkId = ERROR_NETWORK_ID;
1200         String serviceObjectPath = null;
1201         String networkObjectPath = null;
1202         Properties respProps = tryGetProperties(svcOperation, parms, serviceDataBuilder, responseObject);
1203
1204         if (respProps != null) {
1205             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1206             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1207             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1208             networkId = respProps.getProperty("networkId");
1209             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1210             networkObjectPath = respProps.getProperty("network-object-path");
1211         }
1212
1213         if (failed(responseObject)) {
1214             responseBuilder.setResponseCode(responseObject.getStatusCode());
1215             responseBuilder.setResponseMessage(responseObject.getMessage());
1216             responseBuilder.setAckFinalIndicator(ackFinal);
1217
1218             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1219
1220             RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1221                 .<NetworkTopologyOperationOutput>status(true)
1222                 .withResult(responseBuilder.build())
1223                 .build();
1224
1225             return Futures.immediateFuture(rpcResult);
1226         }
1227
1228         // Got success from SLI
1229         try {
1230
1231             serviceData = serviceDataBuilder.build();
1232             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1233
1234             // service object
1235             ServiceBuilder serviceBuilder = new ServiceBuilder();
1236             serviceBuilder.setServiceData(serviceData);
1237             serviceBuilder.setServiceInstanceId(siid);
1238             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1239             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1240
1241             trySaveService(input, serviceBuilder);
1242
1243             NetworkResponseInformationBuilder networkResponseInformationBuilder = new NetworkResponseInformationBuilder();
1244             networkResponseInformationBuilder.setInstanceId(networkId);
1245             networkResponseInformationBuilder.setObjectPath(networkObjectPath);
1246             responseBuilder.setNetworkResponseInformation(networkResponseInformationBuilder.build());
1247
1248             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1249             serviceResponseInformationBuilder.setInstanceId(siid);
1250             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1251             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1252
1253         } catch (IllegalStateException e) {
1254             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1255             responseBuilder.setResponseCode("500");
1256             responseBuilder.setResponseMessage(e.getMessage());
1257             responseBuilder.setAckFinalIndicator("Y");
1258             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1259
1260             RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1261                 .<NetworkTopologyOperationOutput>status(true)
1262                 .withResult(responseBuilder.build())
1263                 .build();
1264
1265             return Futures.immediateFuture(rpcResult);
1266         }
1267
1268         // Update succeeded
1269         responseBuilder.setResponseCode(responseObject.getStatusCode());
1270         responseBuilder.setAckFinalIndicator(ackFinal);
1271         trySetResponseMessage(responseBuilder, responseObject);
1272         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1273         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1274
1275         RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1276             .<NetworkTopologyOperationOutput>status(true)
1277             .withResult(responseBuilder.build())
1278             .build();
1279
1280         return Futures.immediateFuture(rpcResult);
1281     }
1282
1283     private void trySetResponseMessage(NetworkTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
1284         if (!error.getMessage().isEmpty()) {
1285             responseBuilder.setResponseMessage(error.getMessage());
1286         }
1287     }
1288
1289     private void trySetSvcRequestId(NetworkTopologyOperationInput input,
1290         NetworkTopologyOperationOutputBuilder responseBuilder) {
1291         if (input.getSdncRequestHeader() != null) {
1292             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1293         }
1294     }
1295
1296     private void trySaveService(NetworkTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1297         if (isValidRequest(input) &&
1298             (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate) ||
1299                 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Create))) {
1300             // Only update operational tree on Activate
1301             log.info(UPDATING_TREE_INFO_MESSAGE);
1302             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1303         }
1304     }
1305
1306     private boolean hasInvalidServiceId(NetworkTopologyOperationInput input) {
1307         return input == null || input.getServiceInformation() == null
1308             || input.getServiceInformation().getServiceInstanceId() == null
1309             || input.getServiceInformation().getServiceInstanceId().length() == 0;
1310     }
1311
1312     private Future<RpcResult<NetworkTopologyOperationOutput>> buildRpcResultFuture(
1313         NetworkTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1314
1315         responseBuilder.setResponseCode("404");
1316         responseBuilder
1317             .setResponseMessage(responseMessage);
1318         responseBuilder.setAckFinalIndicator("Y");
1319
1320         RpcResult<NetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
1321             .<NetworkTopologyOperationOutput>status(true)
1322             .withResult(responseBuilder.build())
1323             .build();
1324
1325         return Futures.immediateFuture(rpcResult);
1326     }
1327
1328     private boolean isValidRequest(NetworkTopologyOperationInput input) {
1329         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1330     }
1331
1332     @Override
1333     public Future<RpcResult<ContrailRouteTopologyOperationOutput>> contrailRouteTopologyOperation(
1334         ContrailRouteTopologyOperationInput input) {
1335
1336         final String svcOperation = "contrail-route-topology-operation";
1337         ServiceData serviceData;
1338         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1339         Properties properties = new Properties();
1340
1341         log.info(CALLED_STR, svcOperation);
1342         // create a new response object
1343         ContrailRouteTopologyOperationOutputBuilder responseBuilder = new ContrailRouteTopologyOperationOutputBuilder();
1344
1345         if (hasInvalidServiceId(input)) {
1346             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1347             return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1348         }
1349
1350         String siid = input.getServiceInformation().getServiceInstanceId();
1351
1352         // Get the service-instance service data from MD-SAL
1353         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1354         getServiceData(siid, serviceDataBuilder);
1355
1356         trySetSvcRequestId(input, responseBuilder);
1357
1358         ServiceData sd = serviceDataBuilder.build();
1359         if (isInvalidServiceData(sd)) {
1360             log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1361             return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1362         }
1363
1364         log.info("Adding INPUT data for " + svcOperation + " [" + siid + "] input: " + input);
1365         ContrailRouteTopologyOperationInputBuilder inputBuilder = new ContrailRouteTopologyOperationInputBuilder(input);
1366         GenericResourceApiUtil.toProperties(properties, inputBuilder.build());
1367
1368         // Call SLI sync method
1369         // Get SvcLogicService reference
1370         ResponseObject error = new ResponseObject("200", "");
1371         String ackFinal = "Y";
1372         String allottedResourceId = ERROR_NETWORK_ID;
1373         String serviceObjectPath = null;
1374         String contrailRouteObjectPath = null;
1375         Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, error);
1376
1377         if (respProps != null) {
1378             error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1379             error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1380             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1381             allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1382             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1383             contrailRouteObjectPath = respProps.getProperty("contrail-route-object-path");
1384         }
1385
1386         if (failed(error)) {
1387             responseBuilder.setResponseCode(error.getStatusCode());
1388             responseBuilder.setResponseMessage(error.getMessage());
1389             responseBuilder.setAckFinalIndicator(ackFinal);
1390             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1391
1392             RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1393                 .<ContrailRouteTopologyOperationOutput>status(true)
1394                 .withResult(responseBuilder.build())
1395                 .build();
1396
1397             return Futures.immediateFuture(rpcResult);
1398         }
1399
1400         // Got success from SLI
1401         try {
1402             serviceData = serviceDataBuilder.build();
1403             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1404
1405             // service object
1406             ServiceBuilder serviceBuilder = new ServiceBuilder();
1407             serviceBuilder.setServiceData(serviceData);
1408             serviceBuilder.setServiceInstanceId(siid);
1409             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1410             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1411
1412             trySaveService(input, serviceBuilder);
1413
1414             ContrailRouteResponseInformationBuilder contrailRouteResponseInformationBuilder = new ContrailRouteResponseInformationBuilder();
1415             contrailRouteResponseInformationBuilder.setInstanceId(allottedResourceId);
1416             contrailRouteResponseInformationBuilder.setObjectPath(contrailRouteObjectPath);
1417             responseBuilder.setContrailRouteResponseInformation(contrailRouteResponseInformationBuilder.build());
1418
1419             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1420             serviceResponseInformationBuilder.setInstanceId(siid);
1421             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1422             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1423
1424         } catch (IllegalStateException e) {
1425             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1426             responseBuilder.setResponseCode("500");
1427             responseBuilder.setResponseMessage(e.getMessage());
1428             responseBuilder.setAckFinalIndicator("Y");
1429             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1430
1431             RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1432                 .<ContrailRouteTopologyOperationOutput>status(true)
1433                 .withResult(responseBuilder.build())
1434                 .build();
1435
1436             return Futures.immediateFuture(rpcResult);
1437         }
1438
1439         // Update succeeded
1440         responseBuilder.setResponseCode(error.getStatusCode());
1441         responseBuilder.setAckFinalIndicator(ackFinal);
1442         trySetResponseMessage(responseBuilder, error);
1443         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1444         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1445
1446         RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1447             .<ContrailRouteTopologyOperationOutput>status(true)
1448             .withResult(responseBuilder.build())
1449             .build();
1450
1451         return Futures.immediateFuture(rpcResult);
1452     }
1453
1454     private void trySetResponseMessage(ContrailRouteTopologyOperationOutputBuilder responseBuilder,
1455         ResponseObject error) {
1456         if (!error.getMessage().isEmpty()) {
1457             responseBuilder.setResponseMessage(error.getMessage());
1458         }
1459     }
1460
1461     private void trySaveService(ContrailRouteTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1462         if (isValidRequest(input) &&
1463             (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1464                 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1465             // Only update operational tree on activate or delete
1466             log.info(UPDATING_TREE_INFO_MESSAGE);
1467             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1468         }
1469     }
1470
1471     private void trySetSvcRequestId(ContrailRouteTopologyOperationInput input,
1472         ContrailRouteTopologyOperationOutputBuilder responseBuilder) {
1473         if (input.getSdncRequestHeader() != null) {
1474             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1475         }
1476     }
1477
1478     private boolean hasInvalidServiceId(ContrailRouteTopologyOperationInput input) {
1479         return input == null || input.getServiceInformation() == null
1480             || input.getServiceInformation().getServiceInstanceId() == null
1481             || input.getServiceInformation().getServiceInstanceId().length() == 0;
1482     }
1483
1484     private Future<RpcResult<ContrailRouteTopologyOperationOutput>>
1485     buildRpcResultFuture(ContrailRouteTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1486
1487         responseBuilder.setResponseCode("404");
1488         responseBuilder.setResponseMessage(responseMessage);
1489         responseBuilder.setAckFinalIndicator("Y");
1490
1491         RpcResult<ContrailRouteTopologyOperationOutput> rpcResult = RpcResultBuilder
1492             .<ContrailRouteTopologyOperationOutput>status(true)
1493             .withResult(responseBuilder.build())
1494             .build();
1495
1496         return Futures.immediateFuture(rpcResult);
1497     }
1498
1499     private boolean isValidRequest(ContrailRouteTopologyOperationInput input) {
1500         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1501     }
1502
1503     @Override
1504     public Future<RpcResult<SecurityZoneTopologyOperationOutput>> securityZoneTopologyOperation(
1505         SecurityZoneTopologyOperationInput input) {
1506
1507         final String svcOperation = "security-zone-topology-operation";
1508         ServiceData serviceData;
1509         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1510         Properties parms = new Properties();
1511
1512         log.info(CALLED_STR, svcOperation);
1513         // create a new response object
1514         SecurityZoneTopologyOperationOutputBuilder responseBuilder = new SecurityZoneTopologyOperationOutputBuilder();
1515
1516         if (this.hasInvalidServiceId(input)) {
1517             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1518             return buildRpcResultFuture(responseBuilder, NULL_OR_EMPTY_ERROR_PARAM);
1519         }
1520
1521         String siid = input.getServiceInformation().getServiceInstanceId();
1522
1523         // Get the service-instance service data from MD-SAL
1524         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1525         getServiceData(siid, serviceDataBuilder);
1526         trySetSvcRequestId(input, responseBuilder);
1527
1528         ServiceData sd = serviceDataBuilder.build();
1529         if (isInvalidServiceData(sd)) {
1530             log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1531             return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1532         }
1533
1534         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1535         SecurityZoneTopologyOperationInputBuilder inputBuilder = new SecurityZoneTopologyOperationInputBuilder(input);
1536         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1537
1538         // Call SLI sync method
1539         // Get SvcLogicService reference
1540
1541         Properties respProps = null;
1542
1543         ResponseObject responseObject = new ResponseObject("200", "");
1544         String ackFinal = "Y";
1545         String allottedResourceId = ERROR_NETWORK_ID;
1546         String serviceObjectPath = null;
1547         String securityZoneObjectPath = null;
1548
1549         try {
1550             if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
1551
1552                 try {
1553                     respProps = svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", serviceDataBuilder, parms);
1554                 } catch (Exception e) {
1555                     log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
1556                     responseObject.setMessage(e.getMessage());
1557                     responseObject.setStatusCode("500");
1558                 }
1559             } else {
1560                 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
1561                 responseObject.setStatusCode("503");
1562             }
1563         } catch (Exception e) {
1564             responseObject.setStatusCode("500");
1565             responseObject.setMessage(e.getMessage());
1566             log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
1567         }
1568
1569         if (respProps != null) {
1570             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1571             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1572             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1573             allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1574             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1575             securityZoneObjectPath = respProps.getProperty("security-zone-object-path");
1576         }
1577
1578         if (failed(responseObject)) {
1579             responseBuilder.setResponseCode(responseObject.getStatusCode());
1580             responseBuilder.setResponseMessage(responseObject.getMessage());
1581             responseBuilder.setAckFinalIndicator(ackFinal);
1582             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1583
1584             RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1585                 .<SecurityZoneTopologyOperationOutput>status(true)
1586                 .withResult(responseBuilder.build())
1587                 .build();
1588
1589             return Futures.immediateFuture(rpcResult);
1590         }
1591
1592         // Got success from SLI
1593         try {
1594
1595             serviceData = serviceDataBuilder.build();
1596             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1597
1598             // service object
1599             ServiceBuilder serviceBuilder = new ServiceBuilder();
1600             serviceBuilder.setServiceData(serviceData);
1601             serviceBuilder.setServiceInstanceId(siid);
1602             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1603             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1604
1605             trySaveService(input, serviceBuilder);
1606
1607             SecurityZoneResponseInformationBuilder securityZoneResponseInformationBuilder = new SecurityZoneResponseInformationBuilder();
1608             securityZoneResponseInformationBuilder.setInstanceId(allottedResourceId);
1609             securityZoneResponseInformationBuilder.setObjectPath(securityZoneObjectPath);
1610             responseBuilder.setSecurityZoneResponseInformation(securityZoneResponseInformationBuilder.build());
1611
1612             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1613             serviceResponseInformationBuilder.setInstanceId(siid);
1614             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1615             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1616
1617         } catch (IllegalStateException e) {
1618             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1619             responseBuilder.setResponseCode("500");
1620             responseBuilder.setResponseMessage(e.getMessage());
1621             responseBuilder.setAckFinalIndicator("Y");
1622             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1623
1624             RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1625                 .<SecurityZoneTopologyOperationOutput>status(true)
1626                 .withResult(responseBuilder.build())
1627                 .build();
1628
1629             return Futures.immediateFuture(rpcResult);
1630         }
1631
1632         // Update succeeded
1633         responseBuilder.setResponseCode(responseObject.getStatusCode());
1634         responseBuilder.setAckFinalIndicator(ackFinal);
1635         trySetResponseMessage(responseBuilder, responseObject);
1636         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1637         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1638
1639         RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1640             .<SecurityZoneTopologyOperationOutput>status(true)
1641             .withResult(responseBuilder.build())
1642             .build();
1643
1644         return Futures.immediateFuture(rpcResult);
1645     }
1646
1647     private void trySetResponseMessage(SecurityZoneTopologyOperationOutputBuilder responseBuilder,
1648         ResponseObject error) {
1649         if (!error.getMessage().isEmpty()) {
1650             responseBuilder.setResponseMessage(error.getMessage());
1651         }
1652     }
1653
1654     private void trySaveService(SecurityZoneTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1655         if (isValidRequest(input) &&
1656             (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1657                 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1658             // Only update operational tree on activate or delete
1659             log.info(UPDATING_TREE_INFO_MESSAGE);
1660             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1661         }
1662     }
1663
1664     private void trySetSvcRequestId(SecurityZoneTopologyOperationInput input,
1665         SecurityZoneTopologyOperationOutputBuilder responseBuilder) {
1666         if (input.getSdncRequestHeader() != null) {
1667             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1668         }
1669     }
1670
1671     private boolean isInvalidServiceData(ServiceData sd) {
1672         return sd == null || sd.getServiceLevelOperStatus() == null;
1673     }
1674
1675     private boolean hasInvalidServiceId(SecurityZoneTopologyOperationInput input) {
1676         return input == null || input.getServiceInformation() == null
1677             || input.getServiceInformation().getServiceInstanceId() == null
1678             || input.getServiceInformation().getServiceInstanceId().length() == 0;
1679     }
1680
1681     private Future<RpcResult<SecurityZoneTopologyOperationOutput>>
1682     buildRpcResultFuture(SecurityZoneTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1683
1684         responseBuilder.setResponseCode("404");
1685         responseBuilder.setResponseMessage(responseMessage);
1686         responseBuilder.setAckFinalIndicator("Y");
1687
1688         RpcResult<SecurityZoneTopologyOperationOutput> rpcResult = RpcResultBuilder
1689             .<SecurityZoneTopologyOperationOutput>status(true)
1690             .withResult(responseBuilder.build())
1691             .build();
1692
1693         return Futures.immediateFuture(rpcResult);
1694     }
1695
1696     private boolean isValidRequest(SecurityZoneTopologyOperationInput input) {
1697         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1698     }
1699
1700     @Override
1701     public Future<RpcResult<TunnelxconnTopologyOperationOutput>> tunnelxconnTopologyOperation(
1702         TunnelxconnTopologyOperationInput input) {
1703
1704         final String svcOperation = "tunnelxconn-topology-operation";
1705         Properties parms = new Properties();
1706         log.info(CALLED_STR, svcOperation);
1707
1708         // create a new response object
1709         TunnelxconnTopologyOperationOutputBuilder responseBuilder = new TunnelxconnTopologyOperationOutputBuilder();
1710         if (hasInvalidServiceId(input)) {
1711             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1712             responseBuilder.setResponseCode("404");
1713             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1714             responseBuilder.setAckFinalIndicator("Y");
1715
1716             RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1717                 .<TunnelxconnTopologyOperationOutput>status(true)
1718                 .withResult(responseBuilder.build())
1719                 .build();
1720
1721             return Futures.immediateFuture(rpcResult);
1722         }
1723         String siid = input.getServiceInformation().getServiceInstanceId();
1724         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1725         TunnelxconnTopologyOperationInputBuilder inputBuilder = new TunnelxconnTopologyOperationInputBuilder(input);
1726         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1727
1728         // Call SLI sync method
1729         // Get SvcLogicService reference
1730         ResponseObject responseObject = new ResponseObject("200", "");
1731         String ackFinal = "Y";
1732         String allottedResourceId = ERROR_NETWORK_ID;
1733         String serviceObjectPath = null;
1734         String tunnelxconnObjectPath = null;
1735         Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
1736
1737         if (respProps != null) {
1738             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1739             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1740             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1741             allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1742             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1743             tunnelxconnObjectPath = respProps.getProperty("tunnelxconn-object-path");
1744         }
1745
1746         if (failed(responseObject)) {
1747             responseBuilder.setResponseCode(responseObject.getStatusCode());
1748             responseBuilder.setResponseMessage(responseObject.getMessage());
1749             responseBuilder.setAckFinalIndicator(ackFinal);
1750
1751             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1752
1753             RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1754                 .<TunnelxconnTopologyOperationOutput>status(true)
1755                 .withResult(responseBuilder.build())
1756                 .build();
1757
1758             return Futures.immediateFuture(rpcResult);
1759         }
1760
1761         // Got success from SLI
1762         try {
1763             TunnelxconnResponseInformationBuilder tunnelxconnResponseInformationBuilder = new TunnelxconnResponseInformationBuilder();
1764             tunnelxconnResponseInformationBuilder.setInstanceId(allottedResourceId);
1765             tunnelxconnResponseInformationBuilder.setObjectPath(tunnelxconnObjectPath);
1766             responseBuilder.setTunnelxconnResponseInformation(tunnelxconnResponseInformationBuilder.build());
1767
1768             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1769             serviceResponseInformationBuilder.setInstanceId(siid);
1770             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1771             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1772
1773         } catch (IllegalStateException e) {
1774             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1775             responseBuilder.setResponseCode("500");
1776             responseBuilder.setResponseMessage(e.toString());
1777             responseBuilder.setAckFinalIndicator("Y");
1778             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1779
1780             RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1781                 .<TunnelxconnTopologyOperationOutput>status(true)
1782                 .withResult(responseBuilder.build())
1783                 .build();
1784
1785             return Futures.immediateFuture(rpcResult);
1786         }
1787
1788         // Update succeeded
1789         responseBuilder.setResponseCode(responseObject.getStatusCode());
1790         responseBuilder.setAckFinalIndicator(ackFinal);
1791         trySetResponseMessage(responseBuilder, responseObject);
1792         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1793         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1794
1795         RpcResult<TunnelxconnTopologyOperationOutput> rpcResult = RpcResultBuilder
1796             .<TunnelxconnTopologyOperationOutput>status(true)
1797             .withResult(responseBuilder.build())
1798             .build();
1799
1800         return Futures.immediateFuture(rpcResult);
1801     }
1802
1803     private boolean hasInvalidServiceId(ConnectionAttachmentTopologyOperationInput input) {
1804         return input == null || input.getServiceInformation() == null
1805             || input.getServiceInformation().getServiceInstanceId() == null
1806             || input.getServiceInformation().getServiceInstanceId().length() == 0;
1807     }
1808
1809     private void trySetResponseMessage(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder,
1810         ResponseObject error) {
1811         if (!error.getMessage().isEmpty()) {
1812             responseBuilder.setResponseMessage(error.getMessage());
1813         }
1814     }
1815
1816     private void trySetSvcRequestId(ConnectionAttachmentTopologyOperationInput input,
1817         ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder) {
1818         if (input.getSdncRequestHeader() != null) {
1819             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1820         }
1821     }
1822
1823     private Future<RpcResult<ConnectionAttachmentTopologyOperationOutput>>
1824     buildRpcResultFuture(ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder, String responseMessage) {
1825
1826         responseBuilder.setResponseCode("404");
1827         responseBuilder.setResponseMessage(responseMessage);
1828         responseBuilder.setAckFinalIndicator("Y");
1829
1830         RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1831             .<ConnectionAttachmentTopologyOperationOutput>status(true)
1832             .withResult(responseBuilder.build())
1833             .build();
1834
1835         return Futures.immediateFuture(rpcResult);
1836     }
1837
1838     private void trySaveService(ConnectionAttachmentTopologyOperationInput input, ServiceBuilder serviceBuilder) {
1839         if (isValidRequest(input) &&
1840             (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Unassign) ||
1841                 input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))) {
1842             // Only update operational tree on activate or delete
1843             log.info(UPDATING_TREE_INFO_MESSAGE);
1844             saveService(serviceBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1845         }
1846     }
1847
1848     private boolean isValidRequest(ConnectionAttachmentTopologyOperationInput input) {
1849         return input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null;
1850     }
1851
1852     @Override
1853     public Future<RpcResult<ConnectionAttachmentTopologyOperationOutput>> connectionAttachmentTopologyOperation(ConnectionAttachmentTopologyOperationInput input) {
1854         final String svcOperation = "connectionAttachment-topology-operation";
1855         Properties parms = new Properties();
1856         log.info(CALLED_STR, svcOperation);
1857
1858         // create a new response object
1859         ConnectionAttachmentTopologyOperationOutputBuilder responseBuilder = new ConnectionAttachmentTopologyOperationOutputBuilder();
1860         if (hasInvalidServiceId(input)) {
1861             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
1862             responseBuilder.setResponseCode("404");
1863             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
1864             responseBuilder.setAckFinalIndicator("Y");
1865
1866             RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1867                 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1868                 .withResult(responseBuilder.build())
1869                 .build();
1870
1871             return Futures.immediateFuture(rpcResult);
1872         }
1873
1874         ServiceData serviceData;
1875         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1876         Properties properties = new Properties();
1877
1878         String siid = input.getServiceInformation().getServiceInstanceId();
1879         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
1880
1881         // Get the service-instance service data from MD-SAL
1882         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1883         getServiceData(siid, serviceDataBuilder);
1884
1885         trySetSvcRequestId(input, responseBuilder);
1886
1887         ServiceData sd = serviceDataBuilder.build();
1888         if (isInvalidServiceData(sd)) {
1889             log.debug(EMPTY_SERVICE_INSTANCE_MESSAGE, svcOperation);
1890             return buildRpcResultFuture(responseBuilder, INVALID_INPUT_ERROR_MESSAGE);
1891         }
1892
1893         ConnectionAttachmentTopologyOperationInputBuilder inputBuilder = new ConnectionAttachmentTopologyOperationInputBuilder(input);
1894         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
1895
1896         // Call SLI sync method
1897         // Get SvcLogicService reference
1898         ResponseObject responseObject = new ResponseObject("200", "");
1899         String ackFinal = "Y";
1900         String allottedResourceId = ERROR_NETWORK_ID;
1901         String serviceObjectPath = null;
1902         String connectionAttachmentObjectPath = null;
1903
1904         Properties respProps = tryGetProperties(svcOperation, properties, serviceDataBuilder, responseObject);
1905
1906         if (respProps != null) {
1907             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
1908             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
1909             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
1910             allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
1911             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
1912             connectionAttachmentObjectPath = respProps.getProperty("connectionAttachment-object-path");
1913         }
1914
1915         if (failed(responseObject)) {
1916             responseBuilder.setResponseCode(responseObject.getStatusCode());
1917             responseBuilder.setResponseMessage(responseObject.getMessage());
1918             responseBuilder.setAckFinalIndicator(ackFinal);
1919
1920             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1921
1922             RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1923                 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1924                 .withResult(responseBuilder.build())
1925                 .build();
1926
1927             return Futures.immediateFuture(rpcResult);
1928         }
1929
1930         // Got success from SLI
1931         try {
1932
1933             serviceData = serviceDataBuilder.build();
1934             log.info(UPDATING_MDSAL_INFO_MESSAGE, svcOperation, siid, serviceData);
1935
1936             // service object
1937             ServiceBuilder serviceBuilder = new ServiceBuilder();
1938             serviceBuilder.setServiceData(serviceData);
1939             serviceBuilder.setServiceInstanceId(siid);
1940             serviceBuilder.setServiceStatus(serviceStatusBuilder.build());
1941             saveService(serviceBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1942
1943             trySaveService(input, serviceBuilder);
1944
1945             ConnectionAttachmentResponseInformationBuilder connectionAttachmentResponseInformationBuilder = new ConnectionAttachmentResponseInformationBuilder();
1946             connectionAttachmentResponseInformationBuilder.setInstanceId(allottedResourceId);
1947             connectionAttachmentResponseInformationBuilder.setObjectPath(connectionAttachmentObjectPath);
1948             responseBuilder.setConnectionAttachmentResponseInformation(connectionAttachmentResponseInformationBuilder.build());
1949
1950             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
1951             serviceResponseInformationBuilder.setInstanceId(siid);
1952             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
1953             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
1954
1955         } catch (IllegalStateException e) {
1956             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
1957             responseBuilder.setResponseCode("500");
1958             responseBuilder.setResponseMessage(e.toString());
1959             responseBuilder.setAckFinalIndicator("Y");
1960             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
1961
1962             RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1963                 .<ConnectionAttachmentTopologyOperationOutput>status(true)
1964                 .withResult(responseBuilder.build())
1965                 .build();
1966
1967             return Futures.immediateFuture(rpcResult);
1968         }
1969
1970         // Update succeeded
1971         responseBuilder.setResponseCode(responseObject.getStatusCode());
1972         responseBuilder.setAckFinalIndicator(ackFinal);
1973         trySetResponseMessage(responseBuilder, responseObject);
1974         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
1975         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
1976
1977         RpcResult<ConnectionAttachmentTopologyOperationOutput> rpcResult = RpcResultBuilder
1978             .<ConnectionAttachmentTopologyOperationOutput>status(true)
1979             .withResult(responseBuilder.build())
1980             .build();
1981
1982         return Futures.immediateFuture(rpcResult);
1983     }
1984
1985     private void trySetResponseMessage(TunnelxconnTopologyOperationOutputBuilder responseBuilder,
1986         ResponseObject error) {
1987         if (!error.getMessage().isEmpty()) {
1988             responseBuilder.setResponseMessage(error.getMessage());
1989         }
1990     }
1991
1992     private boolean hasInvalidServiceId(TunnelxconnTopologyOperationInput input) {
1993         return input == null || input.getServiceInformation() == null
1994             || input.getServiceInformation().getServiceInstanceId() == null
1995             || input.getServiceInformation().getServiceInstanceId().length() == 0;
1996     }
1997
1998     private Properties tryGetProperties(String svcOperation, Properties parms, ResponseObject responseObject) {
1999         try {
2000             if (svcLogicClient.hasGraph(APP_NAME, svcOperation, null, "sync")) {
2001
2002                 try {
2003                     return svcLogicClient.execute(APP_NAME, svcOperation, null, "sync", parms);
2004                 } catch (Exception e) {
2005                     log.error(SERVICE_LOGIC_EXECUTION_ERROR_MESSAGE, svcOperation, e);
2006                     responseObject.setMessage(e.getMessage());
2007                     responseObject.setStatusCode("500");
2008                 }
2009             } else {
2010                 responseObject.setMessage(NO_SERVICE_LOGIC_ACTIVE + APP_NAME + ": '" + svcOperation + "'");
2011                 responseObject.setStatusCode("503");
2012             }
2013         } catch (Exception e) {
2014             responseObject.setMessage(e.getMessage());
2015             responseObject.setStatusCode("500");
2016             log.error(SERVICE_LOGIC_SEARCH_ERROR_MESSAGE, e);
2017         }
2018         return null;
2019     }
2020
2021     @Override
2022     public Future<RpcResult<BrgTopologyOperationOutput>> brgTopologyOperation(BrgTopologyOperationInput input) {
2023         final String svcOperation = "brg-topology-operation";
2024         Properties parms = new Properties();
2025
2026         log.info(CALLED_STR, svcOperation);
2027         // create a new response object
2028         BrgTopologyOperationOutputBuilder responseBuilder = new BrgTopologyOperationOutputBuilder();
2029
2030         if (this.hasInvalidServiceId(input)) {
2031
2032             log.debug(NULL_OR_EMPTY_ERROR_MESSAGE, svcOperation);
2033             responseBuilder.setResponseCode("404");
2034             responseBuilder.setResponseMessage(NULL_OR_EMPTY_ERROR_PARAM);
2035             responseBuilder.setAckFinalIndicator("Y");
2036
2037             RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
2038                 .<BrgTopologyOperationOutput>status(true)
2039                 .withResult(responseBuilder.build())
2040                 .build();
2041
2042             return Futures.immediateFuture(rpcResult);
2043         }
2044
2045         String siid = input.getServiceInformation().getServiceInstanceId();
2046
2047         log.info(ADDING_INPUT_DATA_LOG, svcOperation, siid, input);
2048         BrgTopologyOperationInputBuilder inputBuilder = new BrgTopologyOperationInputBuilder(input);
2049         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2050
2051         // Call SLI sync method
2052         // Get SvcLogicService reference
2053         ResponseObject error = new ResponseObject("200", "");
2054         String ackFinal = "Y";
2055         String allottedResourceId = ERROR_NETWORK_ID;
2056         String serviceObjectPath = null;
2057         String brgObjectPath = null;
2058         Properties respProps = tryGetProperties(svcOperation, parms, error);
2059
2060         if (respProps != null) {
2061             error.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2062             error.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2063             ackFinal = respProps.getProperty(ACK_FINAL_PARAM, "Y");
2064             allottedResourceId = respProps.getProperty(ALLOTTED_RESOURCE_ID_PARAM);
2065             serviceObjectPath = respProps.getProperty(SERVICE_OBJECT_PATH_PARAM);
2066             brgObjectPath = respProps.getProperty("brg-object-path");
2067         }
2068
2069         if (failed(error)) {
2070             responseBuilder.setResponseCode(error.getStatusCode());
2071             responseBuilder.setResponseMessage(error.getMessage());
2072             responseBuilder.setAckFinalIndicator(ackFinal);
2073
2074             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2075             RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
2076                 .<BrgTopologyOperationOutput>status(true)
2077                 .withResult(responseBuilder.build())
2078                 .build();
2079
2080             return Futures.immediateFuture(rpcResult);
2081         }
2082
2083         // Got success from SLI
2084         try {
2085
2086             BrgResponseInformationBuilder brgResponseInformationBuilder = new BrgResponseInformationBuilder();
2087             brgResponseInformationBuilder.setInstanceId(allottedResourceId);
2088             brgResponseInformationBuilder.setObjectPath(brgObjectPath);
2089             responseBuilder.setBrgResponseInformation(brgResponseInformationBuilder.build());
2090
2091             ServiceResponseInformationBuilder serviceResponseInformationBuilder = new ServiceResponseInformationBuilder();
2092             serviceResponseInformationBuilder.setInstanceId(siid);
2093             serviceResponseInformationBuilder.setObjectPath(serviceObjectPath);
2094             responseBuilder.setServiceResponseInformation(serviceResponseInformationBuilder.build());
2095
2096         } catch (IllegalStateException e) {
2097             log.error(UPDATING_MDSAL_ERROR_MESSAGE, svcOperation, siid, e);
2098             responseBuilder.setResponseCode("500");
2099             responseBuilder.setResponseMessage(e.toString());
2100             responseBuilder.setAckFinalIndicator("Y");
2101             log.error(RETURNED_FAILED_MESSAGE, svcOperation, siid, responseBuilder.build());
2102
2103             RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
2104                 .<BrgTopologyOperationOutput>status(true)
2105                 .withResult(responseBuilder.build())
2106                 .build();
2107
2108             return Futures.immediateFuture(rpcResult);
2109         }
2110
2111         // Update succeeded
2112         responseBuilder.setResponseCode(error.getStatusCode());
2113         responseBuilder.setAckFinalIndicator(ackFinal);
2114         trySetResponseMessage(responseBuilder, error);
2115         log.info(UPDATED_MDSAL_INFO_MESSAGE, svcOperation, siid);
2116         log.info(RETURNED_SUCCESS_MESSAGE, svcOperation, siid, responseBuilder.build());
2117
2118         RpcResult<BrgTopologyOperationOutput> rpcResult = RpcResultBuilder
2119             .<BrgTopologyOperationOutput>status(true)
2120             .withResult(responseBuilder.build())
2121             .build();
2122
2123         return Futures.immediateFuture(rpcResult);
2124     }
2125
2126     private void trySetResponseMessage(BrgTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
2127         if (!error.getMessage().isEmpty()) {
2128             responseBuilder.setResponseMessage(error.getMessage());
2129         }
2130     }
2131
2132     private boolean hasInvalidServiceId(BrgTopologyOperationInput input) {
2133         return input == null || input.getServiceInformation() == null
2134             || input.getServiceInformation().getServiceInstanceId() == null
2135             || input.getServiceInformation().getServiceInstanceId().length() == 0;
2136     }
2137
2138     @Override
2139     public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
2140         PreloadVnfTopologyOperationInput input) {
2141
2142         final String svcOperation = "preload-vnf-topology-operation";
2143         Properties parms = new Properties();
2144
2145         log.info(CALLED_STR, svcOperation);
2146         // create a new response object
2147         PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
2148
2149         if (hasInvalidVnfTopology(input)) {
2150
2151             log.debug("exiting {} because of null input", svcOperation);
2152             responseBuilder.setResponseCode("403");
2153             responseBuilder.setResponseMessage("invalid input: input is null");
2154             responseBuilder.setAckFinalIndicator("Y");
2155
2156             RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2157                 .<PreloadVnfTopologyOperationOutput>status(true)
2158                 .withResult(responseBuilder.build())
2159                 .build();
2160
2161             return Futures.immediateFuture(rpcResult);
2162         }
2163
2164         // Grab the name and type from the input buffer
2165         String preloadName = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
2166         String preloadType = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
2167
2168         // Make sure we have a preload_name and preload_type
2169         if (invalidPreloadData(preloadName, preloadType)) {
2170             log.debug("exiting {} vnf-name or vnf-type is null or empty", svcOperation);
2171             responseBuilder.setResponseCode("403");
2172             responseBuilder.setResponseMessage("invalid input: vnf-name or vnf-type is null or empty");
2173             responseBuilder.setAckFinalIndicator("Y");
2174
2175             RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2176                 .<PreloadVnfTopologyOperationOutput>status(true)
2177                 .withResult(responseBuilder.build())
2178                 .build();
2179
2180             return Futures.immediateFuture(rpcResult);
2181         }
2182
2183         trySetSvcRequestId(input, responseBuilder);
2184
2185         PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2186         getPreloadData(preloadName, preloadType, preloadDataBuilder);
2187
2188         PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2189         getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2190
2191         // setup a preload-data object builder
2192         // ACTION preload-vnf-topology-operation
2193         // INPUT:
2194         // USES sdnc-request-header;
2195         // USES request-information;
2196         // uses vnf-topology-information;
2197         // OUTPUT:
2198         // USES vnf-topology-response-body;
2199         //
2200         // container preload-data
2201         // uses vnf-topology-information;
2202         // uses network-topology-information;
2203         // uses oper-status;
2204
2205         log.info("Adding INPUT data for {} [{},{}] input: {}", svcOperation, preloadName, preloadType, input);
2206         PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
2207         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2208         log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", svcOperation, preloadName,
2209             preloadType, operDataBuilder.build());
2210         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2211
2212         // Call SLI sync method
2213         // Get SvcLogicService reference
2214         ResponseObject responseObject = new ResponseObject("200", "");
2215         Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2216         String ackFinal = resolveAckFinal(responseObject, respProps);
2217
2218         if (failed(responseObject)) {
2219
2220             responseBuilder.setResponseCode(responseObject.getStatusCode());
2221             responseBuilder.setResponseMessage(responseObject.getMessage());
2222             responseBuilder.setAckFinalIndicator(ackFinal);
2223
2224             VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2225             preloadVnfListBuilder.setVnfName(preloadName);
2226             preloadVnfListBuilder.setVnfType(preloadType);
2227             preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2228             log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", svcOperation, preloadName,
2229                 preloadType, responseObject.getStatusCode(), responseObject.getMessage());
2230             try {
2231                 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2232             } catch (Exception e) {
2233                 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName,
2234                     preloadType, e);
2235             }
2236             log.debug("Sending Success rpc result due to external error");
2237
2238             RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2239                 .<PreloadVnfTopologyOperationOutput>status(true)
2240                 .withResult(responseBuilder.build())
2241                 .build();
2242
2243             return Futures.immediateFuture(rpcResult);
2244         }
2245
2246         // Got success from SLI
2247         try {
2248             updatePreloadData(svcOperation, preloadName, preloadType, preloadDataBuilder);
2249         } catch (Exception e) {
2250             log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName, preloadType,
2251                 e);
2252             responseBuilder.setResponseCode("500");
2253             responseBuilder.setResponseMessage(e.getMessage());
2254             responseBuilder.setAckFinalIndicator("Y");
2255             log.error("Returned FAILED for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2256                 responseBuilder.build());
2257
2258             RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2259                 .<PreloadVnfTopologyOperationOutput>status(false)
2260                 .withResult(responseBuilder.build())
2261                 .build();
2262
2263             return Futures.immediateFuture(rpcResult);
2264         }
2265
2266         // Update succeeded
2267         responseBuilder.setResponseCode(responseObject.getStatusCode());
2268         responseBuilder.setAckFinalIndicator(ackFinal);
2269         trySetResponseMessage(responseBuilder, responseObject);
2270
2271         log.info("Updated MD-SAL for {} [{},{}]", svcOperation, preloadName, preloadType);
2272         log.info("Returned SUCCESS for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2273             responseBuilder.build());
2274
2275         RpcResult<PreloadVnfTopologyOperationOutput> rpcResult = RpcResultBuilder
2276             .<PreloadVnfTopologyOperationOutput>status(true)
2277             .withResult(responseBuilder.build())
2278             .build();
2279
2280         return Futures.immediateFuture(rpcResult);
2281     }
2282
2283     private String resolveAckFinal(ResponseObject responseObject, Properties respProps) {
2284         if (respProps != null) {
2285             responseObject.setStatusCode(respProps.getProperty(ERROR_CODE_PARAM));
2286             responseObject.setMessage(respProps.getProperty(ERROR_MESSAGE_PARAM));
2287             return respProps.getProperty(ACK_FINAL_PARAM, "Y");
2288         }
2289         return "Y";
2290     }
2291
2292     private void trySetResponseMessage(PreloadVnfTopologyOperationOutputBuilder responseBuilder, ResponseObject error) {
2293         if (!error.getMessage().isEmpty()) {
2294             responseBuilder.setResponseMessage(error.getMessage());
2295         }
2296     }
2297
2298     private void trySetSvcRequestId(PreloadVnfTopologyOperationInput input,
2299         PreloadVnfTopologyOperationOutputBuilder responseBuilder) {
2300         if (input.getSdncRequestHeader() != null) {
2301             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2302         }
2303     }
2304
2305     private boolean hasInvalidVnfTopology(PreloadVnfTopologyOperationInput input) {
2306         return input == null || input.getVnfTopologyInformation() == null
2307             || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null;
2308     }
2309
2310     private void updatePreloadData(String svcOperation, String preloadName, String preloadType,
2311         PreloadDataBuilder preloadDataBuilder) {
2312         PreloadData preloadData;
2313         preloadData = preloadDataBuilder.build();
2314         log.info("Updating MD-SAL for {} [{},{}] preloadData: {}", svcOperation, preloadName, preloadType,
2315             preloadData);
2316         // svc-configuration-list
2317         VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2318         preloadVnfListBuilder.setVnfName(preloadName);
2319         preloadVnfListBuilder.setVnfType(preloadType);
2320         preloadVnfListBuilder.setPreloadData(preloadData);
2321
2322         // merge flag sets to false to allow it to be overwritten (not appended)
2323         savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2324         log.info(UPDATING_TREE_INFO_MESSAGE);
2325         savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2326     }
2327
2328     @Override
2329     public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2330         PreloadNetworkTopologyOperationInput input) {
2331
2332         final String svcOperation = "preload-network-topology-operation";
2333         Properties parms = new Properties();
2334
2335         log.info(CALLED_STR, svcOperation);
2336         // create a new response object
2337         PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2338
2339         if (hasInvalidNetworkTopology(input)) {
2340
2341             log.debug("exiting {} because of null input", svcOperation);
2342             responseBuilder.setResponseCode("403");
2343             responseBuilder.setResponseMessage("input is null");
2344             responseBuilder.setAckFinalIndicator("Y");
2345
2346             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2347                 .<PreloadNetworkTopologyOperationOutput>status(true)
2348                 .withResult(responseBuilder.build())
2349                 .build();
2350
2351             return Futures.immediateFuture(rpcResult);
2352         }
2353
2354         // Grab the name and type from the input buffer
2355         String preloadName = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2356         String preloadType = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2357
2358         // Make sure we have a preload_name and preload_type
2359         if (invalidPreloadData(preloadName, preloadType)) {
2360             log.debug("exiting {} because of invalid preload-name or preload-type", svcOperation);
2361             responseBuilder.setResponseCode("403");
2362             responseBuilder.setResponseMessage("invalid input: network-name or network-type is null or empty");
2363             responseBuilder.setAckFinalIndicator("Y");
2364
2365             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2366                 .<PreloadNetworkTopologyOperationOutput>status(true)
2367                 .withResult(responseBuilder.build())
2368                 .build();
2369
2370             return Futures.immediateFuture(rpcResult);
2371         }
2372
2373         trySetSvcRequestId(input, responseBuilder);
2374
2375         PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2376         getPreloadData(preloadName, preloadType, preloadDataBuilder);
2377
2378         PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2379         getPreloadData(preloadName, preloadType, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2380
2381         //
2382         // setup a preload-data object builder
2383         // ACTION preload-network-topology-operation
2384         // INPUT:
2385         // USES sdnc-request-header;
2386         // USES request-information;
2387         // uses network-topology-information;
2388         // OUTPUT:
2389         // USES vnf-topology-response-body;
2390         //
2391         // container preload-data
2392         // uses vnf-topology-information;
2393         // uses network-topology-information;
2394         // uses oper-status;
2395
2396         log.info("Adding INPUT data for {} [{},{}] input: {}", svcOperation, preloadName, preloadType, input);
2397         PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(
2398             input);
2399         GenericResourceApiUtil.toProperties(parms, inputBuilder.build());
2400         log.info("Adding OPERATIONAL data for {} [{},{}] operational-data: {}", svcOperation, preloadName,
2401             preloadType, operDataBuilder.build());
2402         GenericResourceApiUtil.toProperties(parms, OPERATIONAL_DATA_PARAM, operDataBuilder);
2403
2404         // Call SLI sync method
2405         // Get SvcLogicService reference
2406         ResponseObject responseObject = new ResponseObject("200", "");
2407         Properties respProps = tryGetProperties(svcOperation, parms, responseObject);
2408
2409         String ackFinal = resolveAckFinal(responseObject, respProps);
2410
2411         if (failed(responseObject)) {
2412
2413             responseBuilder.setResponseCode(responseObject.getStatusCode());
2414             responseBuilder.setResponseMessage(responseObject.getMessage());
2415             responseBuilder.setAckFinalIndicator(ackFinal);
2416
2417             VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2418             preloadVnfListBuilder.setVnfName(preloadName);
2419             preloadVnfListBuilder.setVnfType(preloadType);
2420             preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2421             log.error("Returned FAILED for {} [{},{}] error code: '{}', Reason: '{}'", svcOperation, preloadName,
2422                 preloadType, responseObject.getStatusCode(), responseObject.getMessage());
2423             try {
2424                 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2425             } catch (Exception e) {
2426                 log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName,
2427                     preloadType, e);
2428
2429             }
2430             log.debug("Sending Success rpc result due to external error");
2431
2432             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2433                 .<PreloadNetworkTopologyOperationOutput>status(true)
2434                 .withResult(responseBuilder.build())
2435                 .build();
2436
2437             return Futures.immediateFuture(rpcResult);
2438         }
2439
2440         // Got success from SLI
2441         try {
2442             updatePreloadData(svcOperation, preloadName, preloadType, preloadDataBuilder);
2443         } catch (Exception e) {
2444             log.error(UPDATING_MDSAL_ERROR_MESSAGE_2, svcOperation, preloadName, preloadType, e);
2445             responseBuilder.setResponseCode("500");
2446             responseBuilder.setResponseMessage(e.getMessage());
2447             responseBuilder.setAckFinalIndicator("Y");
2448             log.error("Returned FAILED for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2449                 responseBuilder.build());
2450
2451             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2452                 .<PreloadNetworkTopologyOperationOutput>status(false)
2453                 .withResult(responseBuilder.build())
2454                 .build();
2455
2456             return Futures.immediateFuture(rpcResult);
2457         }
2458
2459         // Update succeeded
2460         responseBuilder.setResponseCode(responseObject.getStatusCode());
2461         responseBuilder.setAckFinalIndicator(ackFinal);
2462         trySetResponseMessage(responseBuilder, responseObject);
2463
2464         log.info("Updated MD-SAL for {} [{},{}]", svcOperation, preloadName, preloadType);
2465         log.info("Returned SUCCESS for {} [{},{}] {}", svcOperation, preloadName, preloadType,
2466             responseBuilder.build());
2467
2468         RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult = RpcResultBuilder
2469             .<PreloadNetworkTopologyOperationOutput>status(true)
2470             .withResult(responseBuilder.build())
2471             .build();
2472
2473         return Futures.immediateFuture(rpcResult);
2474     }
2475
2476     private void trySetResponseMessage(PreloadNetworkTopologyOperationOutputBuilder responseBuilder,
2477         ResponseObject error) {
2478         if (!error.getMessage().isEmpty()) {
2479             responseBuilder.setResponseMessage(error.getMessage());
2480         }
2481     }
2482
2483     private void trySetSvcRequestId(PreloadNetworkTopologyOperationInput input,
2484         PreloadNetworkTopologyOperationOutputBuilder responseBuilder) {
2485         if (input.getSdncRequestHeader() != null) {
2486             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2487         }
2488     }
2489
2490     private boolean invalidPreloadData(String preloadName, String preloadType) {
2491         return preloadName == null || preloadName.length() == 0 || preloadType == null || preloadType.length() == 0;
2492     }
2493
2494     private boolean hasInvalidNetworkTopology(PreloadNetworkTopologyOperationInput input) {
2495         return input == null || input.getNetworkTopologyInformation() == null
2496             || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null;
2497     }
2498
2499 }