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