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