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