vnfapi/provider/src/main/java/org/onap/sdnc/vnfapi/VnfApiProvider.java

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