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         // 1610 Need to pull vnf-instance-list.vf-module-relationship-list from MD-SAL
1241         VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1242         getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1243
1244         // vnf-instance operational-data
1245         VnfInstanceServiceDataBuilder vnfInstanceOperDataBuilder = new VnfInstanceServiceDataBuilder();
1246         getVnfInstanceServiceData(viid, vnfInstanceOperDataBuilder, LogicalDatastoreType.OPERATIONAL);
1247
1248
1249         // Set the serviceStatus based on input
1250         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1251         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1252
1253         //
1254         // setup a service-data object builder
1255         // ACTION vnf-topology-operation
1256         // INPUT:
1257         //  USES request-information;
1258         //  USES service-information;
1259         //  USES vnf-request-information
1260         // OUTPUT:
1261         //  USES vnf-information
1262         //  USES service-information
1263         //
1264         // container service-data
1265
1266         log.info(ADDING_INPUT_DATA_STR + SVC_OPERATION + " [" + vfid + INPUT_STR + input);
1267         VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1268         VnfSdnUtil.toProperties(parms, inputBuilder.build());
1269
1270         log.info(ADDING_OPERATIONAL_DATA_STR + SVC_OPERATION + " [" + vfid + "] vf-module operational-data: "
1271             + operDataBuilder.build());
1272         VnfSdnUtil.toProperties(parms, OPERATIONAL_DATA, operDataBuilder);
1273
1274         log.info(ADDING_CONFIG_DATA_STR + SVC_OPERATION + " [" + preloadName + "," + preloadType
1275             + "] vf-module-preload-data: " + vfModulePreloadDataBuilder.build());
1276         VnfSdnUtil.toProperties(parms, "vf-module-preload-data", vfModulePreloadDataBuilder);
1277
1278         log.info("Adding vnf-instance CONFIG data for " + SVC_OPERATION + " [" + viid + "] vnf-instance-service-data: "
1279             + vnfInstanceServiceDataBuilder.build());
1280         VnfSdnUtil.toProperties(parms, "vnf-instance-service-data", vnfInstanceServiceDataBuilder);
1281
1282         log.info("Adding vnf-instance OPERATIONAL data for " + SVC_OPERATION + " [" + viid
1283             + "] vnf-instance operational-data: " + vnfInstanceOperDataBuilder.build());
1284         VnfSdnUtil.toProperties(parms, "vnf-instance-operational-data", vnfInstanceOperDataBuilder);
1285
1286         // Call SLI sync method
1287         // Get SvcLogicService reference
1288
1289         Properties respProps = null;
1290         String errorCode = "200";
1291         String errorMessage = null;
1292         String ackFinal = "Y";
1293
1294         try {
1295             if (svcLogicClient.hasGraph(VNF_API, SVC_OPERATION, null, "sync")) {
1296
1297                 try {
1298                     respProps = svcLogicClient
1299                         .execute(VNF_API, SVC_OPERATION, null, "sync", vfModuleServiceDataBuilder, parms);
1300                 } catch (Exception e) {
1301                     log.error("Caught exception executing service logic on vf-module for " + SVC_OPERATION, e);
1302                     errorMessage = e.getMessage();
1303                     errorCode = "500";
1304                 }
1305
1306             } else {
1307                 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1308                 errorCode = "503";
1309             }
1310         } catch (Exception e) {
1311             errorCode = "500";
1312             errorMessage = e.getMessage();
1313             log.error("Caught exception looking for service logic", e);
1314         }
1315
1316         if (respProps != null) {
1317             errorCode = respProps.getProperty("error-code");
1318             errorMessage = respProps.getProperty("error-message");
1319             ackFinal = respProps.getProperty("ack-final", "Y");
1320         }
1321
1322         setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1323         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1324         serviceStatusBuilder.setRpcName(RpcName.VfModuleTopologyOperation);
1325
1326         if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1327             responseBuilder.setResponseCode(errorCode);
1328             responseBuilder.setResponseMessage(errorMessage);
1329             responseBuilder.setAckFinalIndicator(ackFinal);
1330             VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1331             vfModuleListBuilder.setVfModuleId(vfid);
1332             vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1333             try {
1334                 saveVfModuleList(vfModuleListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1335             } catch (Exception e) {
1336                 log.error(CAUGHT_EXCEPTION_STR + SVC_OPERATION + " [" + vfid + "] \n", e);
1337             }
1338             log.error(RETURNED_FAILED_STR + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1339             RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1340                 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1341                     .build();
1342             // return error
1343             return Futures.immediateFuture(rpcResult);
1344         }
1345
1346         // Got success from SLI
1347         // save vf-module-service-data in MD-SAL
1348         try {
1349             vfModuleServiceData = vfModuleServiceDataBuilder.build();
1350             log.info(
1351                 UPDATING_MD_SAL_STR + SVC_OPERATION + " [" + vfid + "] VfModuleServiceData: " + vfModuleServiceData);
1352             // vf-module-list
1353             VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1354             vfModuleListBuilder.setVfModuleServiceData(vfModuleServiceData);
1355             vfModuleListBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
1356             vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1357             saveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1358             if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1359                 // Only update operational tree on Delete or Activate
1360                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input.getSdncRequestHeader()
1361                     .getSvcAction().equals(SvcAction.Activate)) {
1362                     log.info(UPDATING_OPERATIONAL_TREE_STR);
1363                     saveVfModuleList(vfModuleListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1364                 }
1365             }
1366             VfModuleInformationBuilder vfModuleInformationBuilder = new VfModuleInformationBuilder();
1367             vfModuleInformationBuilder.setVfModuleId(vfid);
1368             responseBuilder.setVfModuleInformation(vfModuleInformationBuilder.build());
1369             responseBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
1370         } catch (Exception e) {
1371             log.error(CAUGHT_EXCEPTION_STR + SVC_OPERATION + " [" + vfid + "] \n", e);
1372             responseBuilder.setResponseCode("500");
1373             responseBuilder.setResponseMessage(e.toString());
1374             responseBuilder.setAckFinalIndicator("Y");
1375             log.error(RETURNED_FAILED_STR + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1376             RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1377                 RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1378                     .build();
1379             // return error
1380             return Futures.immediateFuture(rpcResult);
1381         }
1382
1383         // Update succeeded
1384         responseBuilder.setResponseCode(errorCode);
1385         responseBuilder.setAckFinalIndicator(ackFinal);
1386         if (errorMessage != null) {
1387             responseBuilder.setResponseMessage(errorMessage);
1388         }
1389         log.info("Updated vf-module in MD-SAL for " + SVC_OPERATION + " [" + vfid + "] ");
1390         log.info(RETURNED_SUCCESS_STR + SVC_OPERATION + " [" + vfid + "] " + responseBuilder.build());
1391
1392         RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1393             RpcResultBuilder.<VfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1394         // return success
1395         return Futures.immediateFuture(rpcResult);
1396     }
1397
1398     @Override
1399     public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(VnfTopologyOperationInput input) {
1400         final String SVC_OPERATION = "vnf-topology-operation";
1401         ServiceData serviceData;
1402         ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1403         Properties parms = new Properties();
1404
1405         log.info(SVC_OPERATION + " called.");
1406         // create a new response object
1407         VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1408
1409         if (input == null || input.getServiceInformation() == null
1410             || input.getServiceInformation().getServiceInstanceId() == null
1411             || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1412             log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1413             responseBuilder.setResponseCode("403");
1414             responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1415             responseBuilder.setAckFinalIndicator("Y");
1416             RpcResult<VnfTopologyOperationOutput> rpcResult =
1417                 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1418             // return error
1419             return Futures.immediateFuture(rpcResult);
1420         }
1421
1422         if (input.getVnfRequestInformation() == null || input.getVnfRequestInformation().getVnfId() == null
1423             || input.getVnfRequestInformation().getVnfId().length() == 0) {
1424             log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vf-module-id");
1425             responseBuilder.setResponseCode("403");
1426             responseBuilder.setResponseMessage("invalid input, null or empty vf-module-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         // Grab the service instance ID from the input buffer
1435         String siid = input.getVnfRequestInformation().getVnfId();
1436         String preload_name = input.getVnfRequestInformation().getVnfName();
1437         String preload_type = input.getVnfRequestInformation().getVnfType();
1438
1439         if (input.getSdncRequestHeader() != null) {
1440             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1441             setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1442         }
1443
1444         PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1445         getPreloadData(preload_name, preload_type, preloadDataBuilder);
1446
1447         ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1448         getServiceData(siid, serviceDataBuilder);
1449
1450         ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1451         getServiceData(siid, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1452
1453         // Set the serviceStatus based on input
1454         setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1455         setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1456
1457         //
1458         // setup a service-data object builder
1459         // ACTION vnf-topology-operation
1460         // INPUT:
1461         //  USES request-information;
1462         //  USES vnf-request-information
1463         // OUTPUT:
1464         //  USES vnf-information
1465         //  USES service-information
1466         //
1467         // container service-data
1468         //   uses oper-status;
1469
1470         log.info("Adding INPUT data for " + SVC_OPERATION + " [" + siid + "] input: " + input);
1471         VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1472         VnfSdnUtil.toProperties(parms, inputBuilder.build());
1473
1474         log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + siid + "] operational-data: " + operDataBuilder
1475             .build());
1476         VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1477
1478         log.info(
1479             "Adding CONFIG data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preload-data: "
1480                 + preloadDataBuilder.build());
1481         VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1482
1483         // Call SLI sync method
1484         // Get SvcLogicService reference
1485         Properties respProps = null;
1486         String errorCode = "200";
1487         String errorMessage = null;
1488         String ackFinal = "Y";
1489
1490         try {
1491             if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1492
1493                 try {
1494                     respProps =
1495                         svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1496                 } catch (Exception e) {
1497                     log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1498                     errorMessage = e.getMessage();
1499                     errorCode = "500";
1500                 }
1501             } else {
1502                 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1503                 errorCode = "503";
1504             }
1505         } catch (Exception e) {
1506             errorCode = "500";
1507             errorMessage = e.getMessage();
1508             log.error("Caught exception looking for service logic", e);
1509         }
1510
1511         if (respProps != null) {
1512             errorCode = respProps.getProperty("error-code");
1513             errorMessage = respProps.getProperty("error-message");
1514             ackFinal = respProps.getProperty("ack-final", "Y");
1515         }
1516
1517         setServiceStatus(serviceStatusBuilder, errorCode, errorMessage, ackFinal);
1518         serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1519         serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
1520
1521         if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1522             responseBuilder.setResponseCode(errorCode);
1523             responseBuilder.setResponseMessage(errorMessage);
1524             responseBuilder.setAckFinalIndicator(ackFinal);
1525             VnfListBuilder vnfListBuilder = new VnfListBuilder();
1526             vnfListBuilder.setVnfId(siid);
1527             vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1528             try {
1529                 saveVnfList(vnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1530             } catch (Exception e) {
1531                 log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1532             }
1533             log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1534             RpcResult<VnfTopologyOperationOutput> rpcResult =
1535                 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1536             // return error
1537             return Futures.immediateFuture(rpcResult);
1538         }
1539
1540         // Got success from SLI
1541         try {
1542             serviceData = serviceDataBuilder.build();
1543             log.info("Updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] ServiceData: " + serviceData);
1544             // svc-configuration-list
1545             VnfListBuilder vnfListBuilder = new VnfListBuilder();
1546             vnfListBuilder.setServiceData(serviceData);
1547             vnfListBuilder.setVnfId(serviceData.getVnfId());
1548             siid = serviceData.getVnfId();
1549             vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1550             saveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1551             if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null) {
1552                 // Only update operational tree on Delete or Activate
1553                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1554                     log.info("Updating OPERATIONAL tree.");
1555                     saveVnfList(vnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1556                 } else if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) || input
1557                     .getSdncRequestHeader().getSvcAction().equals(SvcAction.Rollback)) {
1558                     log.info("Delete OPERATIONAL tree.");
1559                     deleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
1560                     deleteVnfList(vnfListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
1561                 }
1562             }
1563             VnfInformationBuilder vnfInformationBuilder = new VnfInformationBuilder();
1564             vnfInformationBuilder.setVnfId(siid);
1565             responseBuilder.setVnfInformation(vnfInformationBuilder.build());
1566             responseBuilder.setServiceInformation(serviceData.getServiceInformation());
1567         } catch (Exception e) {
1568             log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1569             responseBuilder.setResponseCode("500");
1570             responseBuilder.setResponseMessage(e.toString());
1571             responseBuilder.setAckFinalIndicator("Y");
1572             log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1573             RpcResult<VnfTopologyOperationOutput> rpcResult =
1574                 RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1575             // return error
1576             return Futures.immediateFuture(rpcResult);
1577         }
1578
1579         // Update succeeded
1580         responseBuilder.setResponseCode(errorCode);
1581         responseBuilder.setAckFinalIndicator(ackFinal);
1582         if (errorMessage != null) {
1583             responseBuilder.setResponseMessage(errorMessage);
1584         }
1585         log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + siid + "] ");
1586         log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1587
1588         RpcResult<VnfTopologyOperationOutput> rpcResult =
1589             RpcResultBuilder.<VnfTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1590         // return success
1591         return Futures.immediateFuture(rpcResult);
1592     }
1593
1594     @Override public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1595         NetworkTopologyOperationInput input) {
1596
1597         final String SVC_OPERATION = "network-topology-operation";
1598         Properties parms = new Properties();
1599
1600         log.info(SVC_OPERATION + " called.");
1601         // create a new response object
1602         NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1603
1604         if (input == null || input.getServiceInformation() == null
1605             || input.getServiceInformation().getServiceInstanceId() == null
1606             || input.getServiceInformation().getServiceInstanceId().length() == 0) {
1607             log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1608             responseBuilder.setResponseCode("403");
1609             responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1610             responseBuilder.setAckFinalIndicator("Y");
1611             RpcResult<NetworkTopologyOperationOutput> rpcResult =
1612                 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1613                     .build();
1614             // return error
1615             return Futures.immediateFuture(rpcResult);
1616         }
1617
1618         if (input.getNetworkRequestInformation() == null
1619             || input.getNetworkRequestInformation().getNetworkName() == null) {
1620             log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty service-instance-id");
1621             responseBuilder.setResponseCode("403");
1622             responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1623             responseBuilder.setAckFinalIndicator("Y");
1624             RpcResult<NetworkTopologyOperationOutput> rpcResult =
1625                 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1626                     .build();
1627             // return error
1628             return Futures.immediateFuture(rpcResult);
1629         }
1630
1631         // Grab the service instance ID from the input buffer
1632         String siid;
1633         if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Assign)) {
1634             siid = input.getNetworkRequestInformation().getNetworkName();
1635         } else {
1636             siid = input.getNetworkRequestInformation().getNetworkId();
1637         }
1638         String preload_name = input.getNetworkRequestInformation().getNetworkName();
1639         String preload_type = input.getNetworkRequestInformation().getNetworkType();
1640
1641         if (input.getSdncRequestHeader() != null) {
1642             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1643             setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1644         }
1645
1646         PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1647         getPreloadData(preload_name, preload_type, preloadDataBuilder);
1648
1649         log.info("Adding INPUT data for " + SVC_OPERATION + " [" + siid + "] input: " + input);
1650         NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1651         VnfSdnUtil.toProperties(parms, inputBuilder.build());
1652
1653         // Call SLI sync method
1654         // Get SvcLogicService reference
1655         Properties respProps = null;
1656         String errorCode = "200";
1657         String errorMessage = null;
1658         String ackFinal = "Y";
1659         String networkId = "error";
1660
1661         try {
1662             if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1663
1664                 try {
1665                     respProps =
1666                         svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1667                 } catch (Exception e) {
1668                     log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1669                     errorMessage = e.getMessage();
1670                     errorCode = "500";
1671                 }
1672             } else {
1673                 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1674                 errorCode = "503";
1675             }
1676         } catch (Exception e) {
1677             errorCode = "500";
1678             errorMessage = e.getMessage();
1679             log.error("Caught exception looking for service logic", e);
1680         }
1681
1682         if (respProps != null) {
1683             errorCode = respProps.getProperty("error-code");
1684             errorMessage = respProps.getProperty("error-message");
1685             ackFinal = respProps.getProperty("ack-final", "Y");
1686             networkId = respProps.getProperty("networkId", "0");
1687         }
1688
1689         if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1690             responseBuilder.setResponseCode(errorCode);
1691             responseBuilder.setResponseMessage(errorMessage);
1692             responseBuilder.setAckFinalIndicator(ackFinal);
1693
1694             log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1695
1696             RpcResult<NetworkTopologyOperationOutput> rpcResult =
1697                 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1698                     .build();
1699             // return error
1700             return Futures.immediateFuture(rpcResult);
1701         }
1702
1703         // Got success from SLI
1704         try {
1705             NetworkInformationBuilder networkInformationBuilder = new NetworkInformationBuilder();
1706             networkInformationBuilder.setNetworkId(networkId);
1707             responseBuilder.setNetworkInformation(networkInformationBuilder.build());
1708             responseBuilder.setServiceInformation(input.getServiceInformation());
1709         } catch (IllegalStateException e) {
1710             log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + siid + "] \n", e);
1711             responseBuilder.setResponseCode("500");
1712             responseBuilder.setResponseMessage(e.toString());
1713             responseBuilder.setAckFinalIndicator("Y");
1714             log.error("Returned FAILED for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1715             RpcResult<NetworkTopologyOperationOutput> rpcResult =
1716                 RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1717                     .build();
1718             // return error
1719             return Futures.immediateFuture(rpcResult);
1720         }
1721
1722         // Update succeeded
1723         responseBuilder.setResponseCode(errorCode);
1724         responseBuilder.setAckFinalIndicator(ackFinal);
1725         if (errorMessage != null) {
1726             responseBuilder.setResponseMessage(errorMessage);
1727         }
1728         log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + siid + "] ");
1729         log.info("Returned SUCCESS for " + SVC_OPERATION + " [" + siid + "] " + responseBuilder.build());
1730
1731         RpcResult<NetworkTopologyOperationOutput> rpcResult =
1732             RpcResultBuilder.<NetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build()).build();
1733         // return success
1734         return Futures.immediateFuture(rpcResult);
1735     }
1736
1737     @Override public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1738         PreloadVnfTopologyOperationInput input) {
1739
1740         final String SVC_OPERATION = "preload-vnf-topology-operation";
1741         PreloadData preloadData;
1742         Properties parms = new Properties();
1743
1744         log.info(SVC_OPERATION + " called.");
1745         // create a new response object
1746         PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1747
1748         // Result from savePreloadData
1749
1750         if (input == null || input.getVnfTopologyInformation() == null
1751             || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null
1752             || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName() == null
1753             || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType() == null) {
1754             log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or empty vnf-name or vnf-type");
1755             responseBuilder.setResponseCode("403");
1756             responseBuilder.setResponseMessage("invalid input, null or empty vnf-name or vnf-type");
1757             responseBuilder.setAckFinalIndicator("Y");
1758             RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1759                 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1760                     .build();
1761             return Futures.immediateFuture(rpcResult);
1762         }
1763
1764         // Grab the name and type from the input buffer
1765         String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1766         String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1767
1768         // Make sure we have a preload_name and preload_type
1769         if (preload_name == null || preload_name.length() == 0) {
1770             log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
1771             responseBuilder.setResponseCode("403");
1772             responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1773             responseBuilder.setAckFinalIndicator("Y");
1774             RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1775                 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1776                     .build();
1777             return Futures.immediateFuture(rpcResult);
1778         }
1779         if (preload_type == null || preload_type.length() == 0) {
1780             log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
1781             responseBuilder.setResponseCode("403");
1782             responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1783             responseBuilder.setAckFinalIndicator("Y");
1784             RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1785                 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1786                     .build();
1787             return Futures.immediateFuture(rpcResult);
1788         }
1789
1790         if (input.getSdncRequestHeader() != null) {
1791             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1792             setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1793         }
1794
1795         PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1796         getPreloadData(preload_name, preload_type, preloadDataBuilder);
1797
1798         PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1799         getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1800
1801         //
1802         // setup a preload-data object builder
1803         // ACTION vnf-topology-operation
1804         // INPUT:
1805         //  USES request-information;
1806         //  uses vnf-topology-information;
1807         // OUTPUT:
1808         //
1809         // container preload-data
1810         log.info(
1811             "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
1812         PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1813         VnfSdnUtil.toProperties(parms, inputBuilder.build());
1814         log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1815             + "] operational-data: " + operDataBuilder.build());
1816         VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1817
1818         // Call SLI sync method
1819         // Get SvcLogicService reference
1820         Properties respProps = null;
1821         String errorCode = "200";
1822         String errorMessage = null;
1823         String ackFinal = "Y";
1824
1825         try {
1826             if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
1827
1828                 try {
1829                     respProps =
1830                         svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1831                 } catch (Exception e) {
1832                     log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
1833                     errorMessage = e.getMessage();
1834                     errorCode = "500";
1835                 }
1836             } else {
1837                 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1838                 errorCode = "503";
1839             }
1840         } catch (Exception e) {
1841             errorCode = "500";
1842             errorMessage = e.getMessage();
1843             log.error("Caught exception looking for service logic", e);
1844         }
1845
1846         if (respProps != null) {
1847             errorCode = respProps.getProperty("error-code");
1848             errorMessage = respProps.getProperty("error-message");
1849             ackFinal = respProps.getProperty("ack-final", "Y");
1850         }
1851
1852         if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
1853
1854             responseBuilder.setResponseCode(errorCode);
1855             responseBuilder.setResponseMessage(errorMessage);
1856             responseBuilder.setAckFinalIndicator(ackFinal);
1857
1858             VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1859             preloadVnfListBuilder.setVnfName(preload_name);
1860             preloadVnfListBuilder.setVnfType(preload_type);
1861             preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
1862             log.error(
1863                 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
1864                     + errorCode + "', Reason: '" + errorMessage + "'");
1865             try {
1866                 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
1867             } catch (Exception e) {
1868                 log.error(
1869                     "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1870                         + "] \n", e);
1871             }
1872             log.debug("Sending Success rpc result due to external error");
1873             RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1874                 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1875                     .build();
1876             return Futures.immediateFuture(rpcResult);
1877         }
1878
1879         // Got success from SLI
1880         try {
1881             preloadData = preloadDataBuilder.build();
1882             log.info(
1883                 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
1884                     + preloadData);
1885             // svc-configuration-list
1886             VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
1887             preloadVnfListBuilder.setVnfName(preload_name);
1888             preloadVnfListBuilder.setVnfType(preload_type);
1889             preloadVnfListBuilder.setPreloadData(preloadData);
1890
1891             // SDNGC-989 set merge flag to false
1892             savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
1893             log.info("Updating OPERATIONAL tree.");
1894             savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1895         } catch (Exception e) {
1896             log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
1897                 + "] \n", e);
1898             responseBuilder.setResponseCode("500");
1899             responseBuilder.setResponseMessage(e.toString());
1900             responseBuilder.setAckFinalIndicator("Y");
1901             log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
1902                 + responseBuilder.build());
1903             RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1904                 RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(false).withResult(responseBuilder.build())
1905                     .build();
1906             return Futures.immediateFuture(rpcResult);
1907         }
1908
1909         // Update succeeded
1910         responseBuilder.setResponseCode(errorCode);
1911         responseBuilder.setAckFinalIndicator(ackFinal);
1912         if (errorMessage != null) {
1913             responseBuilder.setResponseMessage(errorMessage);
1914         }
1915         log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
1916         log.info(
1917             "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
1918                 .build());
1919
1920         RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1921             RpcResultBuilder.<PreloadVnfTopologyOperationOutput>status(true).withResult(responseBuilder.build())
1922                 .build();
1923         return Futures.immediateFuture(rpcResult);
1924     }
1925
1926     //1610 preload-vnf-instance-topology-operation
1927     @Override public Future<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> preloadVnfInstanceTopologyOperation(
1928         PreloadVnfInstanceTopologyOperationInput input) {
1929
1930         final String SVC_OPERATION = "preload-vnf-instance-topology-operation";
1931         VnfInstancePreloadData vnfInstancePreloadData;
1932         Properties parms = new Properties();
1933
1934         log.info(SVC_OPERATION + " called.");
1935         // create a new response object
1936         PreloadVnfInstanceTopologyOperationOutputBuilder responseBuilder =
1937             new PreloadVnfInstanceTopologyOperationOutputBuilder();
1938
1939
1940         if (input == null || input.getVnfInstanceTopologyInformation() == null
1941             || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName() == null
1942             || input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId() == null) {
1943             log.debug("exiting " + SVC_OPERATION
1944                 + " because of invalid input, null or empty vnf-instance-name or vnf-model-id");
1945             responseBuilder.setResponseCode("403");
1946             responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name or vnf-model-id");
1947             responseBuilder.setAckFinalIndicator("Y");
1948             RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1949                 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1950                     .withResult(responseBuilder.build()).build();
1951             return Futures.immediateFuture(rpcResult);
1952         }
1953
1954         // Grab the name and type from the input buffer
1955         String preload_name =
1956             input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName();
1957         String preload_type = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId();
1958
1959         // Make sure we have a preload_name and preload_type
1960         if (preload_name == null || preload_name.length() == 0) {
1961             log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
1962             responseBuilder.setResponseCode("403");
1963             responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1964             responseBuilder.setAckFinalIndicator("Y");
1965             RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1966                 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1967                     .withResult(responseBuilder.build()).build();
1968             return Futures.immediateFuture(rpcResult);
1969         }
1970         if (preload_type == null || preload_type.length() == 0) {
1971             log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
1972             responseBuilder.setResponseCode("403");
1973             responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1974             responseBuilder.setAckFinalIndicator("Y");
1975             RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
1976                 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
1977                     .withResult(responseBuilder.build()).build();
1978             return Futures.immediateFuture(rpcResult);
1979         }
1980
1981         if (input.getSdncRequestHeader() != null) {
1982             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1983             setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
1984         }
1985
1986         VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
1987         getVnfInstancePreloadData(preload_name, preload_type, vnfInstancePreloadDataBuilder);
1988
1989
1990         VnfInstancePreloadDataBuilder operDataBuilder = new VnfInstancePreloadDataBuilder();
1991         getVnfInstancePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
1992
1993         //
1994         // setup a preload-data object builder
1995         // ACTION vnf-topology-operation
1996         // INPUT:
1997         //  uses vnf-topology-information;
1998         // OUTPUT:
1999         // container preload-data
2000         log.info(
2001             "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2002         PreloadVnfInstanceTopologyOperationInputBuilder inputBuilder =
2003             new PreloadVnfInstanceTopologyOperationInputBuilder(input);
2004         VnfSdnUtil.toProperties(parms, inputBuilder.build());
2005         log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2006             + "] operational-data: " + operDataBuilder.build());
2007         VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2008
2009         // Call SLI sync method
2010         // Get SvcLogicService reference
2011         Properties respProps = null;
2012         String errorCode = "200";
2013         String errorMessage = null;
2014         String ackFinal = "Y";
2015
2016         try {
2017             if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2018
2019                 try {
2020                     respProps = svcLogicClient
2021                         .execute("VNF-API", SVC_OPERATION, null, "sync", vnfInstancePreloadDataBuilder, parms);
2022                 } catch (Exception e) {
2023                     log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2024                     errorMessage = e.getMessage();
2025                     errorCode = "500";
2026                 }
2027             } else {
2028                 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2029                 errorCode = "503";
2030             }
2031         } catch (Exception e) {
2032             errorCode = "500";
2033             errorMessage = e.getMessage();
2034             log.error("Caught exception looking for service logic", e);
2035         }
2036
2037         if (respProps != null) {
2038             errorCode = respProps.getProperty("error-code");
2039             errorMessage = respProps.getProperty("error-message");
2040             ackFinal = respProps.getProperty("ack-final", "Y");
2041         }
2042
2043         if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2044
2045             responseBuilder.setResponseCode(errorCode);
2046             responseBuilder.setResponseMessage(errorMessage);
2047             responseBuilder.setAckFinalIndicator(ackFinal);
2048
2049             VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2050             vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2051             vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2052             vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadDataBuilder.build());
2053             log.error(
2054                 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2055                     + errorCode + "', Reason: '" + errorMessage + "'");
2056             try {
2057                 saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), true,
2058                     LogicalDatastoreType.CONFIGURATION);
2059             } catch (Exception e) {
2060                 log.error(
2061                     "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2062                         + "] \n", e);
2063             }
2064             log.debug("Sending Success rpc result due to external error");
2065             RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2066                 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true)
2067                     .withResult(responseBuilder.build()).build();
2068             return Futures.immediateFuture(rpcResult);
2069         }
2070
2071         // Got success from SLI
2072         try {
2073             vnfInstancePreloadData = vnfInstancePreloadDataBuilder.build();
2074             log.info(
2075                 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2076                     + vnfInstancePreloadData);
2077             // svc-configuration-list
2078             VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2079             vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2080             vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2081             vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadData);
2082
2083             // SDNGC-989 set merge flag to false
2084             saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false,
2085                 LogicalDatastoreType.CONFIGURATION);
2086             log.info("Updating OPERATIONAL tree.");
2087             saveVnfInstancePreloadList(vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2088         } catch (Exception e) {
2089             log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2090                 + "] \n", e);
2091             responseBuilder.setResponseCode("500");
2092             responseBuilder.setResponseMessage(e.toString());
2093             responseBuilder.setAckFinalIndicator("Y");
2094             log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2095                 + responseBuilder.build());
2096             RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2097                 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(false)
2098                     .withResult(responseBuilder.build()).build();
2099             return Futures.immediateFuture(rpcResult);
2100         }
2101
2102         // Update succeeded
2103         responseBuilder.setResponseCode(errorCode);
2104         responseBuilder.setAckFinalIndicator(ackFinal);
2105         if (errorMessage != null) {
2106             responseBuilder.setResponseMessage(errorMessage);
2107         }
2108         log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2109         log.info(
2110             "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2111                 .build());
2112
2113         RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2114             RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2115                 .build();
2116         return Futures.immediateFuture(rpcResult);
2117     }
2118
2119
2120     //1610 preload-vf-module-topology-operation
2121     @Override public Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2122         PreloadVfModuleTopologyOperationInput input) {
2123
2124         final String SVC_OPERATION = "preload-vf-module-topology-operation";
2125         VfModulePreloadData vfModulePreloadData;
2126         Properties parms = new Properties();
2127
2128         log.info(SVC_OPERATION + " called.");
2129         // create a new response object
2130         PreloadVfModuleTopologyOperationOutputBuilder responseBuilder =
2131             new PreloadVfModuleTopologyOperationOutputBuilder();
2132
2133         // Result from savePreloadData
2134
2135         if (input == null || input.getVfModuleTopologyInformation() == null
2136             || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName() == null
2137             || input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId() == null) {
2138             log.debug("exiting " + SVC_OPERATION
2139                 + " because of invalid input, null or empty vf-module-name or vf-module-model-id");
2140             responseBuilder.setResponseCode("403");
2141             responseBuilder.setResponseMessage("invalid input, null or empty vf-module-name or vf-module-model-id");
2142             responseBuilder.setAckFinalIndicator("Y");
2143             RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2144                 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2145                     .withResult(responseBuilder.build()).build();
2146             return Futures.immediateFuture(rpcResult);
2147         }
2148
2149         // Grab the name and type from the input buffer
2150         String preload_name = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName();
2151         String preload_type = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId();
2152
2153         // Make sure we have a preload_name and preload_type
2154         if (preload_name == null || preload_name.length() == 0) {
2155             log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
2156             responseBuilder.setResponseCode("403");
2157             responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2158             responseBuilder.setAckFinalIndicator("Y");
2159             RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2160                 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2161                     .withResult(responseBuilder.build()).build();
2162             return Futures.immediateFuture(rpcResult);
2163         }
2164         if (preload_type == null || preload_type.length() == 0) {
2165             log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
2166             responseBuilder.setResponseCode("403");
2167             responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2168             responseBuilder.setAckFinalIndicator("Y");
2169             RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2170                 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2171                     .withResult(responseBuilder.build()).build();
2172             return Futures.immediateFuture(rpcResult);
2173         }
2174
2175         if (input.getSdncRequestHeader() != null) {
2176             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2177             setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2178         }
2179
2180         VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
2181         getVfModulePreloadData(preload_name, preload_type, vfModulePreloadDataBuilder);
2182
2183         VfModulePreloadDataBuilder operDataBuilder = new VfModulePreloadDataBuilder();
2184         getVfModulePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2185
2186         //
2187         // setup a preload-data object builder
2188         // ACTION vnf-topology-operation
2189         // INPUT:
2190         //  USES request-information;
2191         //  uses vnf-topology-information;
2192         // OUTPUT:
2193         //
2194         // container preload-data
2195
2196         log.info(
2197             "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2198         PreloadVfModuleTopologyOperationInputBuilder inputBuilder =
2199             new PreloadVfModuleTopologyOperationInputBuilder(input);
2200         VnfSdnUtil.toProperties(parms, inputBuilder.build());
2201         log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2202             + "] operational-data: " + operDataBuilder.build());
2203         VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2204
2205         // Call SLI sync method
2206         // Get SvcLogicService reference
2207         Properties respProps = null;
2208         String errorCode = "200";
2209         String errorMessage = null;
2210         String ackFinal = "Y";
2211
2212         try {
2213             if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2214                 try {
2215                     respProps = svcLogicClient
2216                         .execute("VNF-API", SVC_OPERATION, null, "sync", vfModulePreloadDataBuilder, parms);
2217                 } catch (Exception e) {
2218                     log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2219                     errorMessage = e.getMessage();
2220                     errorCode = "500";
2221                 }
2222             } else {
2223                 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2224                 errorCode = "503";
2225             }
2226         } catch (Exception e) {
2227             errorCode = "500";
2228             errorMessage = e.getMessage();
2229             log.error("Caught exception looking for service logic", e);
2230         }
2231
2232         if (respProps != null) {
2233             errorCode = respProps.getProperty("error-code");
2234             errorMessage = respProps.getProperty("error-message");
2235             ackFinal = respProps.getProperty("ack-final", "Y");
2236         }
2237
2238         if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2239
2240             responseBuilder.setResponseCode(errorCode);
2241             responseBuilder.setResponseMessage(errorMessage);
2242             responseBuilder.setAckFinalIndicator(ackFinal);
2243
2244             VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2245             vfModulePreloadListBuilder.setVfModuleName(preload_name);
2246             vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2247             vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadDataBuilder.build());
2248             log.error(
2249                 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2250                     + errorCode + "', Reason: '" + errorMessage + "'");
2251             try {
2252                 saveVfModulePreloadList(vfModulePreloadListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2253             } catch (Exception e) {
2254                 log.error(
2255                     "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2256                         + "] \n", e);
2257             }
2258             log.debug("Sending Success rpc result due to external error");
2259             RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2260                 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true)
2261                     .withResult(responseBuilder.build()).build();
2262             return Futures.immediateFuture(rpcResult);
2263         }
2264
2265         // Got success from SLI
2266         try {
2267             vfModulePreloadData = vfModulePreloadDataBuilder.build();
2268             log.info(
2269                 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2270                     + vfModulePreloadData);
2271             // svc-configuration-list
2272             VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2273             vfModulePreloadListBuilder.setVfModuleName(preload_name);
2274             vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2275             vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadData);
2276
2277             // SDNGC-989 set merge flag to false
2278             saveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2279             log.info("Updating OPERATIONAL tree.");
2280             saveVfModulePreloadList(vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2281         } catch (Exception e) {
2282             log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2283                 + "] \n", e);
2284             responseBuilder.setResponseCode("500");
2285             responseBuilder.setResponseMessage(e.toString());
2286             responseBuilder.setAckFinalIndicator("Y");
2287             log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2288                 + responseBuilder.build());
2289             RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2290                 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(false)
2291                     .withResult(responseBuilder.build()).build();
2292             return Futures.immediateFuture(rpcResult);
2293         }
2294
2295         // Update succeeded
2296         responseBuilder.setResponseCode(errorCode);
2297         responseBuilder.setAckFinalIndicator(ackFinal);
2298         if (errorMessage != null) {
2299             responseBuilder.setResponseMessage(errorMessage);
2300         }
2301         log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2302         log.info(
2303             "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2304                 .build());
2305
2306         RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2307             RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2308                 .build();
2309         return Futures.immediateFuture(rpcResult);
2310     }
2311
2312
2313     @Override public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2314         PreloadNetworkTopologyOperationInput input) {
2315
2316         final String SVC_OPERATION = "preload-network-topology-operation";
2317         PreloadData preloadData;
2318         Properties parms = new Properties();
2319
2320         log.info(SVC_OPERATION + " called.");
2321         // create a new response object
2322         PreloadNetworkTopologyOperationOutputBuilder responseBuilder =
2323             new PreloadNetworkTopologyOperationOutputBuilder();
2324
2325         // Result from savePreloadData
2326
2327         if (input == null || input.getNetworkTopologyInformation() == null
2328             || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null
2329             || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName() == null
2330             || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType() == null) {
2331             log.debug("exiting " + SVC_OPERATION + " because of invalid input, null or" +
2332                     " empty network-name or network-type");
2333             responseBuilder.setResponseCode("403");
2334             responseBuilder.setResponseMessage("input, null or empty network-name or network-type");
2335             responseBuilder.setAckFinalIndicator("Y");
2336             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2337                 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2338                     .build();
2339             return Futures.immediateFuture(rpcResult);
2340         }
2341
2342         // Grab the name and type from the input buffer
2343         String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2344         String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2345
2346         // Make sure we have a preload_name and preload_type
2347         if (preload_name == null || preload_name.length() == 0) {
2348             log.debug("exiting " + SVC_OPERATION + " because of invalid preload-name");
2349             responseBuilder.setResponseCode("403");
2350             responseBuilder.setResponseMessage("input, invalid preload-name");
2351             responseBuilder.setAckFinalIndicator("Y");
2352             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2353                 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2354                     .build();
2355             return Futures.immediateFuture(rpcResult);
2356         }
2357
2358         if (preload_type == null || preload_type.length() == 0) {
2359             log.debug("exiting " + SVC_OPERATION + " because of invalid preload-type");
2360             responseBuilder.setResponseCode("403");
2361             responseBuilder.setResponseMessage("input, invalid preload-type");
2362             responseBuilder.setAckFinalIndicator("Y");
2363             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2364                 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2365                     .build();
2366             return Futures.immediateFuture(rpcResult);
2367         }
2368
2369         if (input.getSdncRequestHeader() != null) {
2370             responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2371             setRequestIdAsMDC(input.getSdncRequestHeader().getSvcRequestId());
2372         }
2373
2374         PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2375         getPreloadData(preload_name, preload_type, preloadDataBuilder);
2376
2377         PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2378         getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL);
2379
2380         //
2381         // setup a preload-data object builder
2382         // ACTION vnf-topology-operation
2383         // INPUT:
2384         //  USES request-information;
2385         //  uses vnf-topology-information;
2386         // OUTPUT:
2387         //
2388         // container preload-data
2389         log.info(
2390             "Adding INPUT data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] input: " + input);
2391         PreloadNetworkTopologyOperationInputBuilder inputBuilder =
2392             new PreloadNetworkTopologyOperationInputBuilder(input);
2393         VnfSdnUtil.toProperties(parms, inputBuilder.build());
2394         log.info("Adding OPERATIONAL data for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2395             + "] operational-data: " + operDataBuilder.build());
2396         VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2397
2398         // Call SLI sync method
2399         // Get SvcLogicService reference
2400         Properties respProps = null;
2401         String errorCode = "200";
2402         String errorMessage = null;
2403         String ackFinal = "Y";
2404
2405         try {
2406             if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION, null, "sync")) {
2407                 try {
2408                     respProps =
2409                         svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2410                 } catch (Exception e) {
2411                     log.error("Caught exception executing service logic for " + SVC_OPERATION, e);
2412                     errorMessage = e.getMessage();
2413                     errorCode = "500";
2414                 }
2415             } else {
2416                 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2417                 errorCode = "503";
2418             }
2419         } catch (Exception e) {
2420             errorCode = "500";
2421             errorMessage = e.getMessage();
2422             log.error("Caught exception looking for service logic", e);
2423         }
2424
2425
2426         if (respProps != null) {
2427             errorCode = respProps.getProperty("error-code");
2428             errorMessage = respProps.getProperty("error-message");
2429             ackFinal = respProps.getProperty("ack-final", "Y");
2430         }
2431
2432         if (errorCode != null && errorCode.length() != 0 && !("0".equals(errorCode) || "200".equals(errorCode))) {
2433             responseBuilder.setResponseCode(errorCode);
2434             responseBuilder.setResponseMessage(errorMessage);
2435             responseBuilder.setAckFinalIndicator(ackFinal);
2436
2437             VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2438             preloadVnfListBuilder.setVnfName(preload_name);
2439             preloadVnfListBuilder.setVnfType(preload_type);
2440             preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2441             log.error(
2442                 "Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] error code: '"
2443                     + errorCode + "', Reason: '" + errorMessage + "'");
2444             try {
2445                 savePreloadList(preloadVnfListBuilder.build(), true, LogicalDatastoreType.CONFIGURATION);
2446             } catch (Exception e) {
2447                 log.error(
2448                     "Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2449                         + "] \n", e);
2450
2451             }
2452             log.debug("Sending Success rpc result due to external error");
2453             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2454                 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2455                     .build();
2456             return Futures.immediateFuture(rpcResult);
2457         }
2458
2459         // Got success from SLI
2460         try {
2461             preloadData = preloadDataBuilder.build();
2462             log.info(
2463                 "Updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] preloadData: "
2464                     + preloadData);
2465             // svc-configuration-list
2466             VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2467             preloadVnfListBuilder.setVnfName(preload_name);
2468             preloadVnfListBuilder.setVnfType(preload_type);
2469             preloadVnfListBuilder.setPreloadData(preloadData);
2470
2471             // SDNGC-989 set merge flag to false
2472             savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2473             log.info("Updating OPERATIONAL tree.");
2474             savePreloadList(preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2475         } catch (Exception e) {
2476             log.error("Caught Exception updating MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type
2477                 + "] \n", e);
2478             responseBuilder.setResponseCode("500");
2479             responseBuilder.setResponseMessage(e.toString());
2480             responseBuilder.setAckFinalIndicator("Y");
2481             log.error("Returned FAILED for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] "
2482                 + responseBuilder.build());
2483             RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2484                 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(false)
2485                     .withResult(responseBuilder.build()).build();
2486             return Futures.immediateFuture(rpcResult);
2487         }
2488
2489         // Update succeeded
2490         responseBuilder.setResponseCode(errorCode);
2491         responseBuilder.setAckFinalIndicator(ackFinal);
2492         if (errorMessage != null) {
2493             responseBuilder.setResponseMessage(errorMessage);
2494         }
2495         log.info("Updated MD-SAL for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] ");
2496         log.info(
2497             "Returned SUCCESS for " + SVC_OPERATION + " [" + preload_name + "," + preload_type + "] " + responseBuilder
2498                 .build());
2499
2500         RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2501             RpcResultBuilder.<PreloadNetworkTopologyOperationOutput>status(true).withResult(responseBuilder.build())
2502                 .build();
2503         return Futures.immediateFuture(rpcResult);
2504     }
2505 }