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