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

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