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