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

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