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

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