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

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