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     private void DeleteVnfList (final VnfList entry, LogicalDatastoreType storeType) throws IllegalStateException {
 803         // Each entry will be identifiable by a unique key, we have to create that identifier
 804                 InstanceIdentifier.InstanceIdentifierBuilder<VnfList> vnfListIdBuilder =
 805                                 InstanceIdentifier.<Vnfs>builder(Vnfs.class)
 806                                 .child(VnfList.class, entry.getKey());
 807                 InstanceIdentifier<VnfList> path = vnfListIdBuilder.toInstance();
 808
 809         int tries = 2;
 810         while (true) {
 811             try {
 812                 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 813                 tx.delete(storeType, path);
 814                 tx.submit().checkedGet();
 815                 log.debug("DataStore delete succeeded");
 816                 break;
 817             } catch (final TransactionCommitFailedException e) {
 818                 if (e instanceof OptimisticLockFailedException) {
 819                     if (--tries <= 0) {
 820                         log.debug("Got OptimisticLockFailedException on last try - failing ");
 821                         throw new IllegalStateException(e);
 822                     }
 823                     log.debug("Got OptimisticLockFailedException - trying again ");
 824                 } else {
 825                     log.debug("Delete DataStore failed");
 826                     throw new IllegalStateException(e);
 827                 }
 828             }
 829         }
 830     }
 831
 832         //1610 vnf-instance
 833         private void SaveVnfInstanceList (final VnfInstanceList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException {
 834                 // Each entry will be identifiable by a unique key, we have to create that identifier
 835                 InstanceIdentifier.InstanceIdentifierBuilder<VnfInstanceList> vnfInstanceListIdBuilder =
 836                                 InstanceIdentifier.<VnfInstances>builder(VnfInstances.class)
 837                                 .child(VnfInstanceList.class, entry.getKey());
 838                 InstanceIdentifier<VnfInstanceList> path = vnfInstanceListIdBuilder.toInstance();
 839
 840                 int tries = 2;
 841                 while(true) {
 842                         try {
 843                                 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 844                                 if (merge) {
 845                                         tx.merge(storeType, path, entry);
 846                                 } else {
 847                                         tx.put(storeType, path, entry);
 848                                 }
 849                                 tx.submit().checkedGet();
 850                                 log.debug("Update DataStore succeeded");
 851                                 break;
 852                         } catch (final TransactionCommitFailedException e) {
 853                                 if(e instanceof OptimisticLockFailedException) {
 854                                         if(--tries <= 0) {
 855                                                 log.debug("Got OptimisticLockFailedException on last try - failing ");
 856                                                 throw new IllegalStateException(e);
 857                                         }
 858                                         log.debug("Got OptimisticLockFailedException - trying again ");
 859                                 } else {
 860                                         log.debug("Update DataStore failed");
 861                                         throw new IllegalStateException(e);
 862                                 }
 863                         }
 864                 }
 865         }
 866
 867         //1610 vf-module
 868         private void SaveVfModuleList (final VfModuleList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException {
 869                 // Each entry will be identifiable by a unique key, we have to create that identifier
 870                 InstanceIdentifier.InstanceIdentifierBuilder<VfModuleList> vfModuleListIdBuilder =
 871                                 InstanceIdentifier.<VfModules>builder(VfModules.class)
 872                                 .child(VfModuleList.class, entry.getKey());
 873                 InstanceIdentifier<VfModuleList> path = vfModuleListIdBuilder.toInstance();
 874
 875                 int tries = 2;
 876                 while(true) {
 877                         try {
 878                                 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 879                                 if (merge) {
 880                                         tx.merge(storeType, path, entry);
 881                                 } else {
 882                                         tx.put(storeType, path, entry);
 883                                 }
 884                                 tx.submit().checkedGet();
 885                                 log.debug("Update DataStore succeeded");
 886                                 break;
 887                         } catch (final TransactionCommitFailedException e) {
 888                                 if(e instanceof OptimisticLockFailedException) {
 889                                         if(--tries <= 0) {
 890                                                 log.debug("Got OptimisticLockFailedException on last try - failing ");
 891                                                 throw new IllegalStateException(e);
 892                                         }
 893                                         log.debug("Got OptimisticLockFailedException - trying again ");
 894                                 } else {
 895                                         log.debug("Update DataStore failed");
 896                                         throw new IllegalStateException(e);
 897                                 }
 898                         }
 899                 }
 900         }
 901
 902         private void SavePreloadList(final VnfPreloadList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException{
 903
 904                 // Each entry will be identifiable by a unique key, we have to create that identifier
 905                 InstanceIdentifier.InstanceIdentifierBuilder<VnfPreloadList> vnfListIdBuilder =
 906                                 InstanceIdentifier.<PreloadVnfs>builder(PreloadVnfs.class)
 907                                 .child(VnfPreloadList.class, entry.getKey());
 908                 InstanceIdentifier<VnfPreloadList> path = vnfListIdBuilder.toInstance();
 909                 int tries = 2;
 910                 while(true) {
 911                         try {
 912                                 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 913                                 if (merge) {
 914                                         tx.merge(storeType, path, entry);
 915                                 } else {
 916                                         tx.put(storeType, path, entry);
 917                                 }
 918                                 tx.submit().checkedGet();
 919                                 log.debug("Update DataStore succeeded");
 920                                 break;
 921                         } catch (final TransactionCommitFailedException e) {
 922                                 if(e instanceof OptimisticLockFailedException) {
 923                                         if(--tries <= 0) {
 924                                                 log.debug("Got OptimisticLockFailedException on last try - failing ");
 925                                                 throw new IllegalStateException(e);
 926                                         }
 927                                         log.debug("Got OptimisticLockFailedException - trying again ");
 928                                 } else {
 929                                         log.debug("Update DataStore failed");
 930                                         throw new IllegalStateException(e);
 931                                 }
 932                         }
 933                 }
 934         }
 935
 936     //1610 preload vnf-instance
 937         private void SaveVnfInstancePreloadList(final VnfInstancePreloadList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException{
 938
 939                 // Each entry will be identifiable by a unique key, we have to create that identifier
 940                 InstanceIdentifier.InstanceIdentifierBuilder<VnfInstancePreloadList> vnfInstanceListIdBuilder =
 941                                 InstanceIdentifier.<PreloadVnfInstances>builder(PreloadVnfInstances.class)
 942                                 .child(VnfInstancePreloadList.class, entry.getKey());
 943                 InstanceIdentifier<VnfInstancePreloadList> path = vnfInstanceListIdBuilder.toInstance();
 944                 int tries = 2;
 945                 while(true) {
 946                         try {
 947                                 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 948                                 if (merge) {
 949                                         tx.merge(storeType, path, entry);
 950                                 } else {
 951                                         tx.put(storeType, path, entry);
 952                                 }
 953                                 tx.submit().checkedGet();
 954                                 log.debug("Update DataStore succeeded");
 955                                 break;
 956                         } catch (final TransactionCommitFailedException e) {
 957                                 if(e instanceof OptimisticLockFailedException) {
 958                                         if(--tries <= 0) {
 959                                                 log.debug("Got OptimisticLockFailedException on last try - failing ");
 960                                                 throw new IllegalStateException(e);
 961                                         }
 962                                         log.debug("Got OptimisticLockFailedException - trying again ");
 963                                 } else {
 964                                         log.debug("Update DataStore failed");
 965                                         throw new IllegalStateException(e);
 966                                 }
 967                         }
 968                 }
 969         }
 970
 971     //1610 preload vf-module
 972         private void SaveVfModulePreloadList(final VfModulePreloadList entry, boolean merge, LogicalDatastoreType storeType) throws IllegalStateException{
 973
 974                 // Each entry will be identifiable by a unique key, we have to create that identifier
 975                 InstanceIdentifier.InstanceIdentifierBuilder<VfModulePreloadList> vfModuleListIdBuilder =
 976                                 InstanceIdentifier.<PreloadVfModules>builder(PreloadVfModules.class)
 977                                 .child(VfModulePreloadList.class, entry.getKey());
 978                 InstanceIdentifier<VfModulePreloadList> path = vfModuleListIdBuilder.toInstance();
 979                 int tries = 2;
 980                 while(true) {
 981                         try {
 982                                 WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
 983                                 if (merge) {
 984                                         tx.merge(storeType, path, entry);
 985                                 } else {
 986                                         tx.put(storeType, path, entry);
 987                                 }
 988                                 tx.submit().checkedGet();
 989                                 log.debug("Update DataStore succeeded");
 990                                 break;
 991                         } catch (final TransactionCommitFailedException e) {
 992                                 if(e instanceof OptimisticLockFailedException) {
 993                                         if(--tries <= 0) {
 994                                                 log.debug("Got OptimisticLockFailedException on last try - failing ");
 995                                                 throw new IllegalStateException(e);
 996                                         }
 997                                         log.debug("Got OptimisticLockFailedException - trying again ");
 998                                 } else {
 999                                         log.debug("Update DataStore failed");
1000                                         throw new IllegalStateException(e);
1001                                 }
1002                         }
1003                 }
1004         }
1005
1006         //1610 vnf-instance-topology-operation
1007         @Override
1008         public Future<RpcResult<VnfInstanceTopologyOperationOutput>> vnfInstanceTopologyOperation(
1009                         VnfInstanceTopologyOperationInput input) {
1010
1011                 final String SVC_OPERATION = "vnf-instance-topology-operation";
1012                 VnfInstanceServiceData vnfInstanceServiceData = null;
1013                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1014                 Properties parms = new Properties();
1015
1016                 log.info( SVC_OPERATION +" called." );
1017                 // create a new response object
1018                 VnfInstanceTopologyOperationOutputBuilder responseBuilder = new VnfInstanceTopologyOperationOutputBuilder();
1019
1020                 //if(input == null || input.getVnfInstanceRequestInformation().getVnfInstanceTopologyIdentifier().getVnfInstanceId() == null )
1021                 if(input == null ||
1022             input.getVnfInstanceRequestInformation() == null  ||
1023                         input.getVnfInstanceRequestInformation().getVnfInstanceId() == null )
1024         {
1025                         log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-instance-id");
1026                         responseBuilder.setResponseCode("403");
1027                         responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1028                         responseBuilder.setAckFinalIndicator("Y");
1029                         RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1030                                         RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1031                         // return error
1032                         return Futures.immediateFuture(rpcResult);
1033                 }
1034
1035                 // Grab the service instance ID from the input buffer
1036                 String viid = input.getVnfInstanceRequestInformation().getVnfInstanceId();
1037                 String preload_name  = input.getVnfInstanceRequestInformation().getVnfInstanceName();
1038                 String preload_type = input.getVnfInstanceRequestInformation().getVnfModelId();
1039
1040                 // Make sure we have a valid viid
1041                 if(viid == null || viid.length() == 0 ) {
1042                         log.debug("exiting "+SVC_OPERATION+" because of invalid vnf-instance-id");
1043                         responseBuilder.setResponseCode("403");
1044                         responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1045                         responseBuilder.setAckFinalIndicator("Y");
1046                         RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1047                                         RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1048                         // return error
1049                         return Futures.immediateFuture(rpcResult);
1050                 }
1051
1052                 if (input.getSdncRequestHeader() != null) {
1053                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1054                 }
1055
1056         // Get vnf-instance-preload-data
1057                 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
1058                 getVnfInstancePreloadData(preload_name, preload_type, vnfInstancePreloadDataBuilder);
1059
1060         // Get service-data
1061                 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1062                 getVnfInstanceServiceData(viid,vnfInstanceServiceDataBuilder);
1063
1064         // Get operational-data
1065                 VnfInstanceServiceDataBuilder operDataBuilder = new VnfInstanceServiceDataBuilder();
1066                 getVnfInstanceServiceData(viid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1067
1068                 // Set the serviceStatus based on input
1069                 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1070                 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1071
1072                 //
1073                 // setup a service-data object builder
1074                 // ACTION vnf-topology-operation
1075                 // INPUT:
1076                 //  USES sdnc-request-header;
1077                 //  USES request-information;
1078                 //  USES service-information;
1079                 //  USES vnf-request-information
1080                 // OUTPUT:
1081                 //  USES vnf-topology-response-body;
1082                 //  USES vnf-information
1083                 //  USES service-information
1084                 //
1085                 // container service-data
1086         //   uses vnf-configuration-information;
1087         //   uses oper-status;
1088
1089                 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+viid+"] input: " + input);
1090                 VnfInstanceTopologyOperationInputBuilder inputBuilder = new VnfInstanceTopologyOperationInputBuilder(input);
1091                 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1092
1093                 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+viid+"] operational-data: " + operDataBuilder.build());
1094                 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1095
1096                 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " + vnfInstancePreloadDataBuilder.build());
1097                 VnfSdnUtil.toProperties(parms, "vnf-instance-preload-data", vnfInstancePreloadDataBuilder);
1098
1099                 // Call SLI sync method
1100                 // Get SvcLogicService reference
1101
1102                 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
1103                 Properties respProps = null;
1104
1105                 String errorCode = "200";
1106                 String errorMessage = null;
1107                 String ackFinal = "Y";
1108
1109
1110                 try
1111                 {
1112                         if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1113                         {
1114
1115                                 try
1116                                 {
1117                                         respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", vnfInstanceServiceDataBuilder, parms);
1118                                 }
1119                                 catch (Exception e)
1120                                 {
1121                                         log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1122                                         errorMessage = e.getMessage();
1123                                         errorCode = "500";
1124                                 }
1125                         } else {
1126                                 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1127                                 errorCode = "503";
1128                         }
1129                 }
1130                 catch (Exception e)
1131                 {
1132                         errorCode = "500";
1133                         errorMessage = e.getMessage();
1134                         log.error("Caught exception looking for service logic", e);
1135                 }
1136
1137
1138                 if (respProps != null)
1139                 {
1140                         errorCode = respProps.getProperty("error-code");
1141                         errorMessage = respProps.getProperty("error-message");
1142                         ackFinal = respProps.getProperty("ack-final", "Y");
1143                 }
1144
1145                 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
1146                 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1147                 serviceStatusBuilder.setRpcName(RpcName.VnfInstanceTopologyOperation);
1148
1149                 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1150                         responseBuilder.setResponseCode(errorCode);
1151                         responseBuilder.setResponseMessage(errorMessage);
1152                         responseBuilder.setAckFinalIndicator(ackFinal);
1153                         VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1154                         vnfInstanceListBuilder.setVnfInstanceId(viid);
1155                         vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1156                         try {
1157                                 SaveVnfInstanceList (vnfInstanceListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
1158                         } catch (Exception e) {
1159                                 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+viid+"] \n",e);
1160                         }
1161                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+viid+"] " + responseBuilder.build());
1162                         RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1163                                         RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1164                         // return error
1165                         return Futures.immediateFuture(rpcResult);
1166                 }
1167
1168                 // Got success from SLI
1169                 try {
1170                         vnfInstanceServiceData = vnfInstanceServiceDataBuilder.build();
1171                         log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+viid+"] VnfInstanceServiceData: " + vnfInstanceServiceData);
1172                         // svc-configuration-list
1173                         VnfInstanceListBuilder vnfInstanceListBuilder = new VnfInstanceListBuilder();
1174                         vnfInstanceListBuilder.setVnfInstanceServiceData(vnfInstanceServiceData);
1175                         vnfInstanceListBuilder.setVnfInstanceId(vnfInstanceServiceData.getVnfInstanceId());
1176                         //siid = vnfInstanceServiceData.getVnfInstanceId();
1177                         vnfInstanceListBuilder.setServiceStatus(serviceStatusBuilder.build());
1178                         SaveVnfInstanceList (vnfInstanceListBuilder.build(), false,LogicalDatastoreType.CONFIGURATION);
1179                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1180                         {
1181                                 // Only update operational tree on Delete or Activate
1182                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
1183                                     input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1184                                 {
1185                                         log.info("Updating OPERATIONAL tree.");
1186                                         SaveVnfInstanceList (vnfInstanceListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1187                                 }
1188                         }
1189                         VnfInstanceInformationBuilder vnfInstanceInformationBuilder = new VnfInstanceInformationBuilder();
1190                         vnfInstanceInformationBuilder.setVnfInstanceId(viid);
1191                         responseBuilder.setVnfInstanceInformation(vnfInstanceInformationBuilder.build());
1192                         responseBuilder.setServiceInformation(vnfInstanceServiceData.getServiceInformation());
1193                 } catch (Exception e) {
1194                         log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+viid+"] \n",e);
1195                         responseBuilder.setResponseCode("500");
1196                         responseBuilder.setResponseMessage(e.toString());
1197                         responseBuilder.setAckFinalIndicator("Y");
1198                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+viid+"] " + responseBuilder.build());
1199                         RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1200                                         RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1201                         // return error
1202                         return Futures.immediateFuture(rpcResult);
1203                 }
1204
1205                 // Update succeeded
1206                 responseBuilder.setResponseCode(errorCode);
1207                 responseBuilder.setAckFinalIndicator(ackFinal);
1208                 if (errorMessage != null)
1209                 {
1210                         responseBuilder.setResponseMessage(errorMessage);
1211                 }
1212                 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+viid+"] ");
1213                 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+viid+"] " + responseBuilder.build());
1214
1215                 RpcResult<VnfInstanceTopologyOperationOutput> rpcResult =
1216                                 RpcResultBuilder.<VnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1217                 // return success
1218                 return Futures.immediateFuture(rpcResult);
1219         }
1220
1221         //1610 vf-module-topology-operation
1222         @Override
1223         public Future<RpcResult<VfModuleTopologyOperationOutput>> vfModuleTopologyOperation(
1224                         VfModuleTopologyOperationInput input) {
1225
1226                 final String SVC_OPERATION = "vf-module-topology-operation";
1227                 VfModuleServiceData vfModuleServiceData = null;
1228                 VnfInstanceServiceData vnfInstanceServiceData = null;
1229                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1230                 Properties parms = new Properties();
1231
1232                 log.info( SVC_OPERATION +" called." );
1233                 // create a new response object
1234                 VfModuleTopologyOperationOutputBuilder responseBuilder = new VfModuleTopologyOperationOutputBuilder();
1235
1236         // Validate vf-module-id from vf-module-request-information
1237         if(input == null ||
1238             input.getVfModuleRequestInformation() == null ||
1239                 input.getVfModuleRequestInformation().getVfModuleId() == null)
1240         {
1241                         log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vf-module-id");
1242                         responseBuilder.setResponseCode("403");
1243                         responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1244                         responseBuilder.setAckFinalIndicator("Y");
1245                         RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1246                                         RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1247                         // return error
1248                         return Futures.immediateFuture(rpcResult);
1249                 }
1250
1251                 // Grab the vf-module-request-information.vf-module-id from the input buffer
1252                 String vfid  = input.getVfModuleRequestInformation().getVfModuleId();
1253                 String preload_name  = input.getVfModuleRequestInformation().getVfModuleName();
1254                 String preload_type = input.getVfModuleRequestInformation().getVfModuleModelId();
1255
1256                 // Make sure we have a valid siid
1257                 if(vfid == null || vfid.length() == 0 ) {
1258                         log.debug("exiting "+SVC_OPERATION+" because of invalid vf-module-id");
1259                         responseBuilder.setResponseCode("403");
1260                         responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1261                         responseBuilder.setAckFinalIndicator("Y");
1262                         RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1263                                         RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1264                         // return error
1265                         return Futures.immediateFuture(rpcResult);
1266                 }
1267
1268         // 1610 add vf-module-id to vnf-instance-list.vf-module-relationship-list
1269                 String viid = input.getVfModuleRequestInformation().getVnfInstanceId();
1270
1271                 if(viid == null || viid.length() == 0 ) {
1272                         log.debug("exiting "+SVC_OPERATION+" because of invalid vnf-instance-id");
1273                         responseBuilder.setResponseCode("403");
1274                         responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-id");
1275                         responseBuilder.setAckFinalIndicator("Y");
1276                         RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1277                                         RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1278                         // return error
1279                         return Futures.immediateFuture(rpcResult);
1280                 }
1281
1282                 if (input.getSdncRequestHeader() != null) {
1283                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1284                 }
1285
1286         // Get vf-module-preload-data
1287                 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
1288                 getVfModulePreloadData(preload_name, preload_type, vfModulePreloadDataBuilder);
1289
1290         // Get vf-module-service-data
1291                 VfModuleServiceDataBuilder vfModuleServiceDataBuilder = new VfModuleServiceDataBuilder();
1292                 getVfModuleServiceData(vfid,vfModuleServiceDataBuilder);
1293
1294         // Get vf-module operation-data
1295                 VfModuleServiceDataBuilder operDataBuilder = new VfModuleServiceDataBuilder();
1296                 getVfModuleServiceData(vfid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1297
1298         // save service-data builder object for rollback
1299                 VfModuleServiceDataBuilder rb_vfModuleServiceDataBuilder = vfModuleServiceDataBuilder;
1300                 VfModuleServiceDataBuilder rb_operDataBuilder = operDataBuilder;
1301
1302         // 1610 Need to pull vnf-instance-list.vf-module-relationship-list from MD-SAL
1303                 VnfInstanceServiceDataBuilder vnfInstanceServiceDataBuilder = new VnfInstanceServiceDataBuilder();
1304                 getVnfInstanceServiceData(viid, vnfInstanceServiceDataBuilder);
1305
1306         // vnf-instance operational-data
1307                 VnfInstanceServiceDataBuilder vnfInstanceOperDataBuilder = new VnfInstanceServiceDataBuilder();
1308                 getVnfInstanceServiceData(viid, vnfInstanceOperDataBuilder, LogicalDatastoreType.OPERATIONAL );
1309
1310         // save operational builder object for rollback
1311                 VnfInstanceServiceDataBuilder rb_vnfInstanceServiceDataBuilder = vnfInstanceServiceDataBuilder;
1312                 VnfInstanceServiceDataBuilder rb_vnfInstanceOperDataBuilder = vnfInstanceOperDataBuilder;
1313
1314                 // Set the serviceStatus based on input
1315                 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1316                 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1317
1318                 //
1319                 // setup a service-data object builder
1320                 // ACTION vnf-topology-operation
1321                 // INPUT:
1322                 //  USES sdnc-request-header;
1323                 //  USES request-information;
1324                 //  USES service-information;
1325                 //  USES vnf-request-information
1326                 // OUTPUT:
1327                 //  USES vnf-topology-response-body;
1328                 //  USES vnf-information
1329                 //  USES service-information
1330                 //
1331                 // container service-data
1332         //   uses vnf-configuration-information;
1333         //   uses oper-status;
1334
1335                 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+vfid+"] input: " + input);
1336                 VfModuleTopologyOperationInputBuilder inputBuilder = new VfModuleTopologyOperationInputBuilder(input);
1337                 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1338
1339                 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+vfid+"] vf-module operational-data: " + operDataBuilder.build());
1340                 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1341
1342                 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] vf-module-preload-data: " + vfModulePreloadDataBuilder.build());
1343                 VnfSdnUtil.toProperties(parms, "vf-module-preload-data", vfModulePreloadDataBuilder);
1344
1345                 log.info("Adding vnf-instance CONFIG data for "+SVC_OPERATION+" ["+viid+"] vnf-instance-service-data: " + vnfInstanceServiceDataBuilder.build());
1346                 VnfSdnUtil.toProperties(parms, "vnf-instance-service-data", vnfInstanceServiceDataBuilder);
1347
1348                 log.info("Adding vnf-instance OPERATIONAL data for "+SVC_OPERATION+" ["+viid+"] vnf-instance operational-data: " + vnfInstanceOperDataBuilder.build());
1349                 VnfSdnUtil.toProperties(parms, "vnf-instance-operational-data", vnfInstanceOperDataBuilder);
1350
1351                 // Call SLI sync method
1352                 // Get SvcLogicService reference
1353
1354                 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
1355                 Properties respProps = null;
1356
1357                 String errorCode = "200";
1358                 String errorMessage = null;
1359                 String ackFinal = "Y";
1360
1361
1362                 try
1363                 {
1364                         if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1365                         {
1366
1367                                 try
1368                                 {
1369                                         respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", vfModuleServiceDataBuilder, parms);
1370                                 }
1371                                 catch (Exception e)
1372                                 {
1373                                         log.error("Caught exception executing service logic on vf-module for "+ SVC_OPERATION, e);
1374                                         errorMessage = e.getMessage();
1375                                         errorCode = "500";
1376                                 }
1377
1378                         } else {
1379                                 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1380                                 errorCode = "503";
1381                         }
1382                 }
1383                 catch (Exception e)
1384                 {
1385                         errorCode = "500";
1386                         errorMessage = e.getMessage();
1387                         log.error("Caught exception looking for service logic", e);
1388                 }
1389
1390
1391                 if (respProps != null) {
1392                         errorCode = respProps.getProperty("error-code");
1393                         errorMessage = respProps.getProperty("error-message");
1394                         ackFinal = respProps.getProperty("ack-final", "Y");
1395                 }
1396
1397                 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
1398                 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1399                 serviceStatusBuilder.setRpcName(RpcName.VfModuleTopologyOperation);
1400
1401                 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1402                         responseBuilder.setResponseCode(errorCode);
1403                         responseBuilder.setResponseMessage(errorMessage);
1404                         responseBuilder.setAckFinalIndicator(ackFinal);
1405                         VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1406                         vfModuleListBuilder.setVfModuleId(vfid);
1407                         vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1408                         try {
1409                                 SaveVfModuleList (vfModuleListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
1410                         } catch (Exception e) {
1411                                 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+vfid+"] \n",e);
1412                         }
1413                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+vfid+"] " + responseBuilder.build());
1414                         RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1415                                         RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1416                         // return error
1417                         return Futures.immediateFuture(rpcResult);
1418                 }
1419
1420                 // Got success from SLI
1421         // save vf-module-service-data in MD-SAL
1422                 try {
1423                         vfModuleServiceData = vfModuleServiceDataBuilder.build();
1424                         log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+vfid+"] VfModuleServiceData: " + vfModuleServiceData);
1425                         // vf-module-list
1426                         VfModuleListBuilder vfModuleListBuilder = new VfModuleListBuilder();
1427                         vfModuleListBuilder.setVfModuleServiceData(vfModuleServiceData);
1428                         vfModuleListBuilder.setVfModuleId(vfModuleServiceData.getVfModuleId());
1429                         //vfid = vfModuleServiceData.getVfModuleId();
1430                         vfModuleListBuilder.setServiceStatus(serviceStatusBuilder.build());
1431                         SaveVfModuleList (vfModuleListBuilder.build(), false,LogicalDatastoreType.CONFIGURATION);
1432                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1433                         {
1434                                 // Only update operational tree on Delete or Activate
1435                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
1436                                     input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate))
1437                                 {
1438                                         log.info("Updating OPERATIONAL tree.");
1439                                         SaveVfModuleList (vfModuleListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1440                                 }
1441                         }
1442                         VfModuleInformationBuilder vfModuleInformationBuilder = new VfModuleInformationBuilder();
1443                         vfModuleInformationBuilder.setVfModuleId(vfid);
1444                         responseBuilder.setVfModuleInformation(vfModuleInformationBuilder.build());
1445                         responseBuilder.setServiceInformation(vfModuleServiceData.getServiceInformation());
1446                 } catch (Exception e) {
1447                         log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+vfid+"] \n",e);
1448                         responseBuilder.setResponseCode("500");
1449                         responseBuilder.setResponseMessage(e.toString());
1450                         responseBuilder.setAckFinalIndicator("Y");
1451                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+vfid+"] " + responseBuilder.build());
1452                         RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1453                                         RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1454                         // return error
1455                         return Futures.immediateFuture(rpcResult);
1456                 }
1457
1458                 // Update succeeded
1459                 responseBuilder.setResponseCode(errorCode);
1460                 responseBuilder.setAckFinalIndicator(ackFinal);
1461                 if (errorMessage != null)
1462                 {
1463                         responseBuilder.setResponseMessage(errorMessage);
1464                 }
1465                 log.info("Updated vf-module in MD-SAL for "+SVC_OPERATION+" ["+vfid+"] ");
1466                 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+vfid+"] " + responseBuilder.build());
1467
1468                 RpcResult<VfModuleTopologyOperationOutput> rpcResult =
1469                                 RpcResultBuilder.<VfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1470                 // return success
1471                 return Futures.immediateFuture(rpcResult);
1472         }
1473
1474
1475         @Override
1476         public Future<RpcResult<VnfTopologyOperationOutput>> vnfTopologyOperation(
1477                         VnfTopologyOperationInput input) {
1478
1479                 final String SVC_OPERATION = "vnf-topology-operation";
1480                 ServiceData serviceData = null;
1481                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1482                 Properties parms = new Properties();
1483
1484                 log.info( SVC_OPERATION +" called." );
1485                 // create a new response object
1486                 VnfTopologyOperationOutputBuilder responseBuilder = new VnfTopologyOperationOutputBuilder();
1487
1488                 if(input == null ||
1489             input.getServiceInformation() == null ||
1490                 input.getServiceInformation().getServiceInstanceId() == null ||
1491                     input.getServiceInformation().getServiceInstanceId().length() == 0)
1492         {
1493                         log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty service-instance-id");
1494                         responseBuilder.setResponseCode("403");
1495                         responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1496                         responseBuilder.setAckFinalIndicator("Y");
1497                         RpcResult<VnfTopologyOperationOutput> rpcResult =
1498                                         RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1499                         // return error
1500                         return Futures.immediateFuture(rpcResult);
1501                 }
1502
1503                 if(input.getVnfRequestInformation() == null ||
1504                 input.getVnfRequestInformation().getVnfId() == null ||
1505                     input.getVnfRequestInformation().getVnfId().length() == 0)
1506         {
1507                         log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vf-module-id");
1508                         responseBuilder.setResponseCode("403");
1509                         responseBuilder.setResponseMessage("invalid input, null or empty vf-module-id");
1510                         responseBuilder.setAckFinalIndicator("Y");
1511                         RpcResult<VnfTopologyOperationOutput> rpcResult =
1512                                         RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1513                         // return error
1514                         return Futures.immediateFuture(rpcResult);
1515                 }
1516
1517                 // Grab the service instance ID from the input buffer
1518                 String siid = input.getVnfRequestInformation().getVnfId();
1519                 String preload_name  = input.getVnfRequestInformation().getVnfName();
1520                 String preload_type = input.getVnfRequestInformation().getVnfType();
1521
1522         /*
1523                 // Make sure we have a valid siid
1524                 if(siid == null || siid.length() == 0 ) {
1525                         log.debug("exiting "+SVC_OPERATION+" because of invalid siid");
1526                         responseBuilder.setResponseCode("403");
1527                         responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1528                         responseBuilder.setAckFinalIndicator("Y");
1529                         RpcResult<VnfTopologyOperationOutput> rpcResult =
1530                                         RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1531                         // return error
1532                         return Futures.immediateFuture(rpcResult);
1533                 }
1534         */
1535
1536                 if (input.getSdncRequestHeader() != null) {
1537                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1538                 }
1539
1540                 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1541                 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1542
1543                 ServiceDataBuilder serviceDataBuilder = new ServiceDataBuilder();
1544                 getServiceData(siid,serviceDataBuilder);
1545
1546                 ServiceDataBuilder operDataBuilder = new ServiceDataBuilder();
1547                 getServiceData(siid,operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1548
1549                 // Set the serviceStatus based on input
1550                 setServiceStatus(serviceStatusBuilder, input.getSdncRequestHeader());
1551                 setServiceStatus(serviceStatusBuilder, input.getRequestInformation());
1552
1553                 //
1554                 // setup a service-data object builder
1555                 // ACTION vnf-topology-operation
1556                 // INPUT:
1557                 //  USES sdnc-request-header;
1558                 //  USES request-information;
1559                 //  USES service-information;
1560                 //  USES vnf-request-information
1561                 // OUTPUT:
1562                 //  USES vnf-topology-response-body;
1563                 //  USES vnf-information
1564                 //  USES service-information
1565                 //
1566                 // container service-data
1567         //   uses vnf-configuration-information;
1568         //   uses oper-status;
1569
1570                 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+siid+"] input: " + input);
1571                 VnfTopologyOperationInputBuilder inputBuilder = new VnfTopologyOperationInputBuilder(input);
1572                 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1573
1574                 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+siid+"] operational-data: " + operDataBuilder.build());
1575                 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1576
1577                 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " + preloadDataBuilder.build());
1578                 VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1579
1580                 // Call SLI sync method
1581                 // Get SvcLogicService reference
1582
1583                 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
1584                 Properties respProps = null;
1585
1586                 String errorCode = "200";
1587                 String errorMessage = null;
1588                 String ackFinal = "Y";
1589
1590
1591                 try
1592                 {
1593                         if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1594                         {
1595
1596                                 try
1597                                 {
1598                                         respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", serviceDataBuilder, parms);
1599                                 }
1600                                 catch (Exception e)
1601                                 {
1602                                         log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1603                                         errorMessage = e.getMessage();
1604                                         errorCode = "500";
1605                                 }
1606                         } else {
1607                                 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1608                                 errorCode = "503";
1609                         }
1610                 }
1611                 catch (Exception e)
1612                 {
1613                         errorCode = "500";
1614                         errorMessage = e.getMessage();
1615                         log.error("Caught exception looking for service logic", e);
1616                 }
1617
1618
1619                 if (respProps != null)
1620                 {
1621                         errorCode = respProps.getProperty("error-code");
1622                         errorMessage = respProps.getProperty("error-message");
1623                         ackFinal = respProps.getProperty("ack-final", "Y");
1624                 }
1625
1626                 setServiceStatus(serviceStatusBuilder,errorCode, errorMessage, ackFinal);
1627                 serviceStatusBuilder.setRequestStatus(RequestStatus.Synccomplete);
1628                 serviceStatusBuilder.setRpcName(RpcName.VnfTopologyOperation);
1629
1630                 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1631                         responseBuilder.setResponseCode(errorCode);
1632                         responseBuilder.setResponseMessage(errorMessage);
1633                         responseBuilder.setAckFinalIndicator(ackFinal);
1634                         VnfListBuilder vnfListBuilder = new VnfListBuilder();
1635                         vnfListBuilder.setVnfId(siid);
1636                         vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1637                         try {
1638                                 SaveVnfList (vnfListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
1639                         } catch (Exception e) {
1640                                 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
1641                         }
1642                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1643                         RpcResult<VnfTopologyOperationOutput> rpcResult =
1644                                         RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1645                         // return error
1646                         return Futures.immediateFuture(rpcResult);
1647                 }
1648
1649                 // Got success from SLI
1650                 try {
1651                         serviceData = serviceDataBuilder.build();
1652                         log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] ServiceData: " + serviceData);
1653                         // svc-configuration-list
1654                         VnfListBuilder vnfListBuilder = new VnfListBuilder();
1655                         vnfListBuilder.setServiceData(serviceData);
1656                         vnfListBuilder.setVnfId(serviceData.getVnfId());
1657                         siid = serviceData.getVnfId();
1658                         vnfListBuilder.setServiceStatus(serviceStatusBuilder.build());
1659                         SaveVnfList (vnfListBuilder.build(), false,LogicalDatastoreType.CONFIGURATION);
1660                         if (input.getSdncRequestHeader() != null && input.getSdncRequestHeader().getSvcAction() != null)
1661                         {
1662                                 // Only update operational tree on Delete or Activate
1663                                 if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Activate)) {
1664                                         log.info("Updating OPERATIONAL tree.");
1665                                         SaveVnfList (vnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
1666                                 }
1667                                 else if (input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Delete) ||
1668                                     input.getSdncRequestHeader().getSvcAction().equals(SvcAction.Rollback)) {
1669                                             log.info("Delete OPERATIONAL tree.");
1670                                             DeleteVnfList (vnfListBuilder.build(), LogicalDatastoreType.CONFIGURATION);
1671                                             DeleteVnfList (vnfListBuilder.build(), LogicalDatastoreType.OPERATIONAL);
1672                 }
1673                         }
1674                         VnfInformationBuilder vnfInformationBuilder = new VnfInformationBuilder();
1675                         vnfInformationBuilder.setVnfId(siid);
1676                         responseBuilder.setVnfInformation(vnfInformationBuilder.build());
1677                         responseBuilder.setServiceInformation(serviceData.getServiceInformation());
1678                 } catch (Exception e) {
1679                         log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
1680                         responseBuilder.setResponseCode("500");
1681                         responseBuilder.setResponseMessage(e.toString());
1682                         responseBuilder.setAckFinalIndicator("Y");
1683                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1684                         RpcResult<VnfTopologyOperationOutput> rpcResult =
1685                                         RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1686                         // return error
1687                         return Futures.immediateFuture(rpcResult);
1688                 }
1689
1690                 // Update succeeded
1691                 responseBuilder.setResponseCode(errorCode);
1692                 responseBuilder.setAckFinalIndicator(ackFinal);
1693                 if (errorMessage != null)
1694                 {
1695                         responseBuilder.setResponseMessage(errorMessage);
1696                 }
1697                 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+siid+"] ");
1698                 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1699
1700                 RpcResult<VnfTopologyOperationOutput> rpcResult =
1701                                 RpcResultBuilder.<VnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1702                 // return success
1703                 return Futures.immediateFuture(rpcResult);
1704         }
1705
1706
1707         @Override
1708         public Future<RpcResult<NetworkTopologyOperationOutput>> networkTopologyOperation(
1709                         NetworkTopologyOperationInput input) {
1710
1711                 final String SVC_OPERATION = "network-topology-operation";
1712                 ServiceData serviceData = null;
1713                 ServiceStatusBuilder serviceStatusBuilder = new ServiceStatusBuilder();
1714                 Properties parms = new Properties();
1715
1716                 log.info( SVC_OPERATION +" called." );
1717                 // create a new response object
1718                 NetworkTopologyOperationOutputBuilder responseBuilder = new NetworkTopologyOperationOutputBuilder();
1719
1720                 if(input == null ||
1721             input.getServiceInformation() == null ||
1722                 input.getServiceInformation().getServiceInstanceId() == null ||
1723                     input.getServiceInformation().getServiceInstanceId().length() == 0)
1724         {
1725                         log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty service-instance-id");
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                 if(input.getNetworkRequestInformation() == null || input.getNetworkRequestInformation().getNetworkName() == null) {
1736                         log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty service-instance-id");
1737                         responseBuilder.setResponseCode("403");
1738                         responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1739                         responseBuilder.setAckFinalIndicator("Y");
1740                         RpcResult<NetworkTopologyOperationOutput> rpcResult =
1741                                         RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1742                         // return error
1743                         return Futures.immediateFuture(rpcResult);
1744                 }
1745
1746                 // Grab the service instance ID from the input buffer
1747                 String siid = null;
1748         if (input.getSdncRequestHeader().getSvcAction().equals("assign")) {
1749                     siid = input.getNetworkRequestInformation().getNetworkName();
1750         }
1751         else {
1752                     siid = input.getNetworkRequestInformation().getNetworkId();
1753         }
1754                 String preload_name  = input.getNetworkRequestInformation().getNetworkName();
1755                 String preload_type = input.getNetworkRequestInformation().getNetworkType();
1756
1757         /*
1758                 if(siid == null || siid.length() == 0 ) {
1759                         log.debug("exiting "+SVC_OPERATION+" because of invalid siid");
1760                         responseBuilder.setResponseCode("403");
1761                         responseBuilder.setResponseMessage("invalid input, null or empty service-instance-id");
1762                         responseBuilder.setAckFinalIndicator("Y");
1763                         RpcResult<NetworkTopologyOperationOutput> rpcResult =
1764                                         RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1765                         // return error
1766                         return Futures.immediateFuture(rpcResult);
1767                 }
1768         */
1769
1770                 if (input.getSdncRequestHeader() != null) {
1771                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1772                 }
1773
1774                 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1775                 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1776
1777                 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+siid+"] input: " + input);
1778                 NetworkTopologyOperationInputBuilder inputBuilder = new NetworkTopologyOperationInputBuilder(input);
1779                 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1780
1781 /*
1782                 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+siid+"] operational-data: " + operDataBuilder.build());
1783                 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1784
1785                 log.info("Adding CONFIG data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preload-data: " + preloadDataBuilder.build());
1786                 VnfSdnUtil.toProperties(parms, "preload-data", preloadDataBuilder);
1787 */
1788
1789                 // Call SLI sync method
1790                 // Get SvcLogicService reference
1791
1792                 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
1793                 Properties respProps = null;
1794
1795                 String errorCode = "200";
1796                 String errorMessage = null;
1797                 String ackFinal = "Y";
1798                 String networkId = "error";
1799
1800
1801                 try
1802                 {
1803                         if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1804                         {
1805
1806                                 try
1807                                 {
1808                                         respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1809                                 }
1810                                 catch (Exception e)
1811                                 {
1812                                         log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1813                                         errorMessage = e.getMessage();
1814                                         errorCode = "500";
1815                                 }
1816                         } else {
1817                                 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1818                                 errorCode = "503";
1819                         }
1820                 }
1821                 catch (Exception e)
1822                 {
1823                         errorCode = "500";
1824                         errorMessage = e.getMessage();
1825                         log.error("Caught exception looking for service logic", e);
1826                 }
1827
1828
1829                 if (respProps != null)
1830                 {
1831                         errorCode = respProps.getProperty("error-code");
1832                         errorMessage = respProps.getProperty("error-message");
1833                         ackFinal = respProps.getProperty("ack-final", "Y");
1834                         networkId = respProps.getProperty("networkId","0");
1835                 }
1836
1837                 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
1838                         responseBuilder.setResponseCode(errorCode);
1839                         responseBuilder.setResponseMessage(errorMessage);
1840                         responseBuilder.setAckFinalIndicator(ackFinal);
1841
1842                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1843
1844                         RpcResult<NetworkTopologyOperationOutput> rpcResult =
1845                                         RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1846                         // return error
1847                         return Futures.immediateFuture(rpcResult);
1848                 }
1849
1850                 // Got success from SLI
1851                 try {
1852                         NetworkInformationBuilder networkInformationBuilder = new NetworkInformationBuilder();
1853                         networkInformationBuilder.setNetworkId(networkId);
1854                         responseBuilder.setNetworkInformation(networkInformationBuilder.build());
1855                         responseBuilder.setServiceInformation(input.getServiceInformation());
1856                 } catch (IllegalStateException e) {
1857                         log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+siid+"] \n",e);
1858                         responseBuilder.setResponseCode("500");
1859                         responseBuilder.setResponseMessage(e.toString());
1860                         responseBuilder.setAckFinalIndicator("Y");
1861                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1862                         RpcResult<NetworkTopologyOperationOutput> rpcResult =
1863                                         RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1864                         // return error
1865                         return Futures.immediateFuture(rpcResult);
1866                 }
1867
1868                 // Update succeeded
1869                 responseBuilder.setResponseCode(errorCode);
1870                 responseBuilder.setAckFinalIndicator(ackFinal);
1871                 if (errorMessage != null)
1872                 {
1873                         responseBuilder.setResponseMessage(errorMessage);
1874                 }
1875                 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+siid+"] ");
1876                 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+siid+"] " + responseBuilder.build());
1877
1878                 RpcResult<NetworkTopologyOperationOutput> rpcResult =
1879                                 RpcResultBuilder.<NetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1880                 // return success
1881                 return Futures.immediateFuture(rpcResult);
1882         }
1883
1884         @Override
1885         public Future<RpcResult<PreloadVnfTopologyOperationOutput>> preloadVnfTopologyOperation(
1886                         PreloadVnfTopologyOperationInput input) {
1887
1888                 final String SVC_OPERATION = "preload-vnf-topology-operation";
1889                 PreloadData preloadData = null;
1890                 Properties parms = new Properties();
1891
1892                 log.info( SVC_OPERATION +" called." );
1893                 // create a new response object
1894                 PreloadVnfTopologyOperationOutputBuilder responseBuilder = new PreloadVnfTopologyOperationOutputBuilder();
1895
1896                 // Result from savePreloadData
1897                 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
1898
1899                 if(input == null || input.getVnfTopologyInformation() == null || input.getVnfTopologyInformation().getVnfTopologyIdentifier() == null || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName() == null || input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType() == null) {
1900                         log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-name and vnf-type");
1901                         responseBuilder.setResponseCode("403");
1902                         responseBuilder.setResponseMessage("invalid input, null or empty vnf-name and vnf-type");
1903                         responseBuilder.setAckFinalIndicator("Y");
1904                         RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1905                                 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1906                         return Futures.immediateFuture(rpcResult);
1907                 }
1908
1909                 // Grab the name and type from the input buffer
1910                 String preload_name = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfName();
1911                 String preload_type = input.getVnfTopologyInformation().getVnfTopologyIdentifier().getVnfType();
1912
1913                 // Make sure we have a preload_name and preload_type
1914                 if(preload_name == null || preload_name.length() == 0 ) {
1915                         log.debug("exiting "+SVC_OPERATION+" because of invalid preload-name");
1916                         responseBuilder.setResponseCode("403");
1917                         responseBuilder.setResponseMessage("invalid input, invalid preload-name");
1918                         responseBuilder.setAckFinalIndicator("Y");
1919                         RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1920                                 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1921                         return Futures.immediateFuture(rpcResult);
1922                 }
1923                 if(preload_type == null || preload_type.length() == 0 ) {
1924                         log.debug("exiting "+SVC_OPERATION+" because of invalid preload-type");
1925                         responseBuilder.setResponseCode("403");
1926                         responseBuilder.setResponseMessage("invalid input, invalid preload-type");
1927                         responseBuilder.setAckFinalIndicator("Y");
1928                         RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
1929                                 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
1930                         return Futures.immediateFuture(rpcResult);
1931                 }
1932
1933                 if (input.getSdncRequestHeader() != null) {
1934                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
1935                 }
1936
1937                 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
1938                 getPreloadData(preload_name, preload_type, preloadDataBuilder);
1939                 //preloadData = preloadDataBuilder.build();
1940
1941                 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
1942                 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
1943
1944                 //
1945                 // setup a preload-data object builder
1946                 // ACTION vnf-topology-operation
1947                 // INPUT:
1948                 //  USES sdnc-request-header;
1949                 //  USES request-information;
1950         //  uses vnf-topology-information;
1951                 // OUTPUT:
1952                 //  USES vnf-topology-response-body;
1953                 //
1954                 // container preload-data
1955         //   uses vnf-configuration-information;
1956
1957
1958                 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
1959                 PreloadVnfTopologyOperationInputBuilder inputBuilder = new PreloadVnfTopologyOperationInputBuilder(input);
1960                 VnfSdnUtil.toProperties(parms, inputBuilder.build());
1961                 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
1962                 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
1963
1964                 // Call SLI sync method
1965                 // Get SvcLogicService reference
1966
1967                 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
1968                 Properties respProps = null;
1969
1970                 String errorCode = "200";
1971                 String errorMessage = null;
1972                 String ackFinal = "Y";
1973
1974
1975                 try
1976                 {
1977                         if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
1978                         {
1979
1980                                 try
1981                                 {
1982                                         respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
1983                                 }
1984                                 catch (Exception e)
1985                                 {
1986                                         log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
1987                                         errorMessage = e.getMessage();
1988                                         errorCode = "500";
1989                                 }
1990                         } else {
1991                                 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
1992                                 errorCode = "503";
1993                         }
1994                 }
1995                 catch (Exception e)
1996                 {
1997                         errorCode = "500";
1998                         errorMessage = e.getMessage();
1999                         log.error("Caught exception looking for service logic", e);
2000                 }
2001
2002
2003                 if (respProps != null)
2004                 {
2005                         errorCode = respProps.getProperty("error-code");
2006                         errorMessage = respProps.getProperty("error-message");
2007                         ackFinal = respProps.getProperty("ack-final", "Y");
2008                         // internalError = respProps.getProperty("internal-error", "false");
2009                 }
2010
2011                 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2012
2013                         responseBuilder.setResponseCode(errorCode);
2014                         responseBuilder.setResponseMessage(errorMessage);
2015                         responseBuilder.setAckFinalIndicator(ackFinal);
2016
2017                         VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2018                         preloadVnfListBuilder.setVnfName(preload_name);
2019                         preloadVnfListBuilder.setVnfType(preload_type);
2020                         preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2021                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
2022                         try {
2023                                 SavePreloadList (preloadVnfListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
2024                         } catch (Exception e) {
2025                                 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2026                         }
2027                         log.debug("Sending Success rpc result due to external error");
2028                         RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2029                                 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2030                         return Futures.immediateFuture(rpcResult);
2031                 }
2032
2033                 // Got success from SLI
2034                 try {
2035                         preloadData = preloadDataBuilder.build();
2036                         log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + preloadData);
2037                         // svc-configuration-list
2038                         VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2039                         preloadVnfListBuilder.setVnfName(preload_name);
2040                         preloadVnfListBuilder.setVnfType(preload_type);
2041                         preloadVnfListBuilder.setPreloadData(preloadData);
2042
2043                         // SDNGC-989 set merge flag to false
2044                         SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2045                         log.info("Updating OPERATIONAL tree.");
2046                         SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2047                 } catch (Exception e) {
2048                         log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2049                         responseBuilder.setResponseCode("500");
2050                         responseBuilder.setResponseMessage(e.toString());
2051                         responseBuilder.setAckFinalIndicator("Y");
2052                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2053                         RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2054                                 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2055                         return Futures.immediateFuture(rpcResult);
2056                 }
2057
2058                 // Update succeeded
2059                 responseBuilder.setResponseCode(errorCode);
2060                 responseBuilder.setAckFinalIndicator(ackFinal);
2061                 if (errorMessage != null)
2062                 {
2063                         responseBuilder.setResponseMessage(errorMessage);
2064                 }
2065                 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
2066                 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2067
2068                 RpcResult<PreloadVnfTopologyOperationOutput> rpcResult =
2069                                 RpcResultBuilder.<PreloadVnfTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2070                 return Futures.immediateFuture(rpcResult);
2071         }
2072
2073     //1610 preload-vnf-instance-topology-operation
2074         @Override
2075         public Future<RpcResult<PreloadVnfInstanceTopologyOperationOutput>> preloadVnfInstanceTopologyOperation(
2076                         PreloadVnfInstanceTopologyOperationInput input) {
2077
2078                 final String SVC_OPERATION = "preload-vnf-instance-topology-operation";
2079                 VnfInstancePreloadData vnfInstancePreloadData = null;
2080                 Properties parms = new Properties();
2081
2082                 log.info( SVC_OPERATION +" called." );
2083                 // create a new response object
2084                 PreloadVnfInstanceTopologyOperationOutputBuilder responseBuilder = new PreloadVnfInstanceTopologyOperationOutputBuilder();
2085
2086                 // Result from savePreloadData
2087                 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2088
2089                 if(input == null ||
2090             input.getVnfInstanceTopologyInformation() == null ||
2091                 input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName() == null ||
2092                     input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId() == null)
2093         {
2094                         log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-instance-name and vnf-model-id");
2095                         responseBuilder.setResponseCode("403");
2096                         responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name and vnf-model-id");
2097                         responseBuilder.setAckFinalIndicator("Y");
2098                         RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2099                                 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2100                         return Futures.immediateFuture(rpcResult);
2101                 }
2102
2103                 // Grab the name and type from the input buffer
2104                 String preload_name = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfInstanceName();
2105                 String preload_type = input.getVnfInstanceTopologyInformation().getVnfInstanceIdentifiers().getVnfModelId();
2106
2107                 // Make sure we have a preload_name and preload_type
2108                 if(preload_name == null || preload_name.length() == 0 ) {
2109                         log.debug("exiting "+SVC_OPERATION+" because of invalid preload-name");
2110                         responseBuilder.setResponseCode("403");
2111                         responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2112                         responseBuilder.setAckFinalIndicator("Y");
2113                         RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2114                                 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2115                         return Futures.immediateFuture(rpcResult);
2116                 }
2117                 if(preload_type == null || preload_type.length() == 0 ) {
2118                         log.debug("exiting "+SVC_OPERATION+" because of invalid preload-type");
2119                         responseBuilder.setResponseCode("403");
2120                         responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2121                         responseBuilder.setAckFinalIndicator("Y");
2122                         RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2123                                 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2124                         return Futures.immediateFuture(rpcResult);
2125                 }
2126
2127                 if (input.getSdncRequestHeader() != null) {
2128                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2129                 }
2130
2131                 VnfInstancePreloadDataBuilder vnfInstancePreloadDataBuilder = new VnfInstancePreloadDataBuilder();
2132                 getVnfInstancePreloadData(preload_name, preload_type, vnfInstancePreloadDataBuilder);
2133                 //preloadData = preloadDataBuilder.build();
2134
2135                 VnfInstancePreloadDataBuilder operDataBuilder = new VnfInstancePreloadDataBuilder();
2136                 getVnfInstancePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
2137
2138                 //
2139                 // setup a preload-data object builder
2140                 // ACTION vnf-topology-operation
2141                 // INPUT:
2142                 //  USES sdnc-request-header;
2143                 //  USES request-information;
2144         //  uses vnf-topology-information;
2145                 // OUTPUT:
2146                 //  USES vnf-topology-response-body;
2147                 //
2148                 // container preload-data
2149         //   uses vnf-configuration-information;
2150
2151
2152                 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
2153                 PreloadVnfInstanceTopologyOperationInputBuilder inputBuilder = new PreloadVnfInstanceTopologyOperationInputBuilder(input);
2154                 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2155                 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
2156                 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2157
2158                 // Call SLI sync method
2159                 // Get SvcLogicService reference
2160
2161                 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
2162                 Properties respProps = null;
2163
2164                 String errorCode = "200";
2165                 String errorMessage = null;
2166                 String ackFinal = "Y";
2167
2168
2169                 try
2170                 {
2171                         if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
2172                         {
2173
2174                                 try
2175                                 {
2176                                         respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", vnfInstancePreloadDataBuilder, parms);
2177                                 }
2178                                 catch (Exception e)
2179                                 {
2180                                         log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
2181                                         errorMessage = e.getMessage();
2182                                         errorCode = "500";
2183                                 }
2184                         } else {
2185                                 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2186                                 errorCode = "503";
2187                         }
2188                 }
2189                 catch (Exception e)
2190                 {
2191                         errorCode = "500";
2192                         errorMessage = e.getMessage();
2193                         log.error("Caught exception looking for service logic", e);
2194                 }
2195
2196
2197                 if (respProps != null)
2198                 {
2199                         errorCode = respProps.getProperty("error-code");
2200                         errorMessage = respProps.getProperty("error-message");
2201                         ackFinal = respProps.getProperty("ack-final", "Y");
2202                         // internalError = respProps.getProperty("internal-error", "false");
2203                 }
2204
2205                 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2206
2207                         responseBuilder.setResponseCode(errorCode);
2208                         responseBuilder.setResponseMessage(errorMessage);
2209                         responseBuilder.setAckFinalIndicator(ackFinal);
2210
2211                         VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2212                         vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2213                         vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2214                         vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadDataBuilder.build());
2215                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
2216                         try {
2217                                 SaveVnfInstancePreloadList (vnfInstancePreloadListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
2218                         } catch (Exception e) {
2219                                 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2220                         }
2221                         log.debug("Sending Success rpc result due to external error");
2222                         RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2223                                 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2224                         return Futures.immediateFuture(rpcResult);
2225                 }
2226
2227                 // Got success from SLI
2228                 try {
2229                         vnfInstancePreloadData = vnfInstancePreloadDataBuilder.build();
2230                         log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + vnfInstancePreloadData);
2231                         // svc-configuration-list
2232                         VnfInstancePreloadListBuilder vnfInstancePreloadListBuilder = new VnfInstancePreloadListBuilder();
2233                         vnfInstancePreloadListBuilder.setVnfInstanceName(preload_name);
2234                         vnfInstancePreloadListBuilder.setVnfModelId(preload_type);
2235                         vnfInstancePreloadListBuilder.setVnfInstancePreloadData(vnfInstancePreloadData);
2236
2237                         // SDNGC-989 set merge flag to false
2238                         SaveVnfInstancePreloadList (vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2239                         log.info("Updating OPERATIONAL tree.");
2240                         SaveVnfInstancePreloadList (vnfInstancePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2241                 } catch (Exception e) {
2242                         log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2243                         responseBuilder.setResponseCode("500");
2244                         responseBuilder.setResponseMessage(e.toString());
2245                         responseBuilder.setAckFinalIndicator("Y");
2246                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2247                         RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2248                                 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2249                         return Futures.immediateFuture(rpcResult);
2250                 }
2251
2252                 // Update succeeded
2253                 responseBuilder.setResponseCode(errorCode);
2254                 responseBuilder.setAckFinalIndicator(ackFinal);
2255                 if (errorMessage != null)
2256                 {
2257                         responseBuilder.setResponseMessage(errorMessage);
2258                 }
2259                 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
2260                 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2261
2262                 RpcResult<PreloadVnfInstanceTopologyOperationOutput> rpcResult =
2263                                 RpcResultBuilder.<PreloadVnfInstanceTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2264                 return Futures.immediateFuture(rpcResult);
2265         }
2266
2267
2268     //1610 preload-vf-module-topology-operation
2269         @Override
2270         public Future<RpcResult<PreloadVfModuleTopologyOperationOutput>> preloadVfModuleTopologyOperation(
2271                         PreloadVfModuleTopologyOperationInput input) {
2272
2273                 final String SVC_OPERATION = "preload-vf-module-topology-operation";
2274                 VfModulePreloadData vfModulePreloadData = null;
2275                 Properties parms = new Properties();
2276
2277                 log.info( SVC_OPERATION +" called." );
2278                 // create a new response object
2279                 PreloadVfModuleTopologyOperationOutputBuilder responseBuilder = new PreloadVfModuleTopologyOperationOutputBuilder();
2280
2281                 // Result from savePreloadData
2282                 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2283
2284                 if(input == null ||
2285             input.getVfModuleTopologyInformation() == null ||
2286                 input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName() == null ||
2287                     input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId() == null)
2288         {
2289                         log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-instance-name and vnf-model-id");
2290                         responseBuilder.setResponseCode("403");
2291                         responseBuilder.setResponseMessage("invalid input, null or empty vnf-instance-name and vnf-model-id");
2292                         responseBuilder.setAckFinalIndicator("Y");
2293                         RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2294                                 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2295                         return Futures.immediateFuture(rpcResult);
2296                 }
2297
2298                 // Grab the name and type from the input buffer
2299                 String preload_name = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleName();
2300                 String preload_type = input.getVfModuleTopologyInformation().getVfModuleIdentifiers().getVfModuleModelId();
2301
2302                 // Make sure we have a preload_name and preload_type
2303                 if(preload_name == null || preload_name.length() == 0 ) {
2304                         log.debug("exiting "+SVC_OPERATION+" because of invalid preload-name");
2305                         responseBuilder.setResponseCode("403");
2306                         responseBuilder.setResponseMessage("invalid input, invalid preload-name");
2307                         responseBuilder.setAckFinalIndicator("Y");
2308                         RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2309                                 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2310                         return Futures.immediateFuture(rpcResult);
2311                 }
2312                 if(preload_type == null || preload_type.length() == 0 ) {
2313                         log.debug("exiting "+SVC_OPERATION+" because of invalid preload-type");
2314                         responseBuilder.setResponseCode("403");
2315                         responseBuilder.setResponseMessage("invalid input, invalid preload-type");
2316                         responseBuilder.setAckFinalIndicator("Y");
2317                         RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2318                                 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2319                         return Futures.immediateFuture(rpcResult);
2320                 }
2321
2322                 if (input.getSdncRequestHeader() != null) {
2323                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2324                 }
2325
2326                 VfModulePreloadDataBuilder vfModulePreloadDataBuilder = new VfModulePreloadDataBuilder();
2327                 getVfModulePreloadData(preload_name, preload_type, vfModulePreloadDataBuilder);
2328                 //preloadData = preloadDataBuilder.build();
2329
2330                 VfModulePreloadDataBuilder operDataBuilder = new VfModulePreloadDataBuilder();
2331                 getVfModulePreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
2332
2333                 //
2334                 // setup a preload-data object builder
2335                 // ACTION vnf-topology-operation
2336                 // INPUT:
2337                 //  USES sdnc-request-header;
2338                 //  USES request-information;
2339         //  uses vnf-topology-information;
2340                 // OUTPUT:
2341                 //  USES vnf-topology-response-body;
2342                 //
2343                 // container preload-data
2344         //   uses vnf-configuration-information;
2345
2346
2347                 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
2348                 PreloadVfModuleTopologyOperationInputBuilder inputBuilder = new PreloadVfModuleTopologyOperationInputBuilder(input);
2349                 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2350                 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
2351                 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2352
2353                 // Call SLI sync method
2354                 // Get SvcLogicService reference
2355
2356                 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
2357                 Properties respProps = null;
2358
2359                 String errorCode = "200";
2360                 String errorMessage = null;
2361                 String ackFinal = "Y";
2362
2363
2364                 try
2365                 {
2366                         if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
2367                         {
2368
2369                                 try
2370                                 {
2371                                         respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", vfModulePreloadDataBuilder, parms);
2372                                 }
2373                                 catch (Exception e)
2374                                 {
2375                                         log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
2376                                         errorMessage = e.getMessage();
2377                                         errorCode = "500";
2378                                 }
2379                         } else {
2380                                 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2381                                 errorCode = "503";
2382                         }
2383                 }
2384                 catch (Exception e)
2385                 {
2386                         errorCode = "500";
2387                         errorMessage = e.getMessage();
2388                         log.error("Caught exception looking for service logic", e);
2389                 }
2390
2391
2392                 if (respProps != null)
2393                 {
2394                         errorCode = respProps.getProperty("error-code");
2395                         errorMessage = respProps.getProperty("error-message");
2396                         ackFinal = respProps.getProperty("ack-final", "Y");
2397                         // internalError = respProps.getProperty("internal-error", "false");
2398                 }
2399
2400                 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2401
2402                         responseBuilder.setResponseCode(errorCode);
2403                         responseBuilder.setResponseMessage(errorMessage);
2404                         responseBuilder.setAckFinalIndicator(ackFinal);
2405
2406                         VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2407                         vfModulePreloadListBuilder.setVfModuleName(preload_name);
2408                         vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2409                         vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadDataBuilder.build());
2410                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
2411                         try {
2412                                 SaveVfModulePreloadList (vfModulePreloadListBuilder.build(), true,LogicalDatastoreType.CONFIGURATION);
2413                         } catch (Exception e) {
2414                                 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2415                         }
2416                         log.debug("Sending Success rpc result due to external error");
2417                         RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2418                                 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2419                         return Futures.immediateFuture(rpcResult);
2420                 }
2421
2422                 // Got success from SLI
2423                 try {
2424                         vfModulePreloadData = vfModulePreloadDataBuilder.build();
2425                         log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + vfModulePreloadData);
2426                         // svc-configuration-list
2427                         VfModulePreloadListBuilder vfModulePreloadListBuilder = new VfModulePreloadListBuilder();
2428                         vfModulePreloadListBuilder.setVfModuleName(preload_name);
2429                         vfModulePreloadListBuilder.setVfModuleModelId(preload_type);
2430                         vfModulePreloadListBuilder.setVfModulePreloadData(vfModulePreloadData);
2431
2432                         // SDNGC-989 set merge flag to false
2433                         SaveVfModulePreloadList (vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2434                         log.info("Updating OPERATIONAL tree.");
2435                         SaveVfModulePreloadList (vfModulePreloadListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2436                 } catch (Exception e) {
2437                         log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2438                         responseBuilder.setResponseCode("500");
2439                         responseBuilder.setResponseMessage(e.toString());
2440                         responseBuilder.setAckFinalIndicator("Y");
2441                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2442                         RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2443                                 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2444                         return Futures.immediateFuture(rpcResult);
2445                 }
2446
2447                 // Update succeeded
2448                 responseBuilder.setResponseCode(errorCode);
2449                 responseBuilder.setAckFinalIndicator(ackFinal);
2450                 if (errorMessage != null)
2451                 {
2452                         responseBuilder.setResponseMessage(errorMessage);
2453                 }
2454                 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
2455                 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2456
2457                 RpcResult<PreloadVfModuleTopologyOperationOutput> rpcResult =
2458                                 RpcResultBuilder.<PreloadVfModuleTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2459                 return Futures.immediateFuture(rpcResult);
2460         }
2461
2462
2463         @Override
2464         public Future<RpcResult<PreloadNetworkTopologyOperationOutput>> preloadNetworkTopologyOperation(
2465                         PreloadNetworkTopologyOperationInput input) {
2466
2467                 final String SVC_OPERATION = "preload-network-topology-operation";
2468                 PreloadData preloadData = null;
2469                 Properties parms = new Properties();
2470
2471                 log.info( SVC_OPERATION +" called." );
2472                 // create a new response object
2473                 PreloadNetworkTopologyOperationOutputBuilder responseBuilder = new PreloadNetworkTopologyOperationOutputBuilder();
2474
2475                 // Result from savePreloadData
2476                 final SettableFuture<RpcResult<Void>> futureResult = SettableFuture.create();
2477
2478                 if(input == null || input.getNetworkTopologyInformation() == null || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier() == null || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName() == null || input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType() == null) {
2479                         log.debug("exiting " +SVC_OPERATION+ " because of invalid input, null or empty vnf-name and vnf-type");
2480                         responseBuilder.setResponseCode("403");
2481                         responseBuilder.setResponseMessage("input, null or empty vnf-name and vnf-type");
2482                         responseBuilder.setAckFinalIndicator("Y");
2483                         RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2484                                 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2485                         return Futures.immediateFuture(rpcResult);
2486                 }
2487
2488                 // Grab the name and type from the input buffer
2489                 String preload_name = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkName();
2490                 String preload_type = input.getNetworkTopologyInformation().getNetworkTopologyIdentifier().getNetworkType();
2491
2492                 // Make sure we have a preload_name and preload_type
2493                 if(preload_name == null || preload_name.length() == 0 ) {
2494                         log.debug("exiting "+SVC_OPERATION+" because of invalid preload-name");
2495                         responseBuilder.setResponseCode("403");
2496                         responseBuilder.setResponseMessage("input, invalid preload-name");
2497                         responseBuilder.setAckFinalIndicator("Y");
2498                         RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2499                                 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2500                         return Futures.immediateFuture(rpcResult);
2501                 }
2502                 if(preload_type == null || preload_type.length() == 0 ) {
2503                         log.debug("exiting "+SVC_OPERATION+" because of invalid preload-type");
2504                         responseBuilder.setResponseCode("403");
2505                         responseBuilder.setResponseMessage("input, invalid preload-type");
2506                         responseBuilder.setAckFinalIndicator("Y");
2507                         RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2508                                 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2509                         return Futures.immediateFuture(rpcResult);
2510                 }
2511
2512                 if (input.getSdncRequestHeader() != null) {
2513                         responseBuilder.setSvcRequestId(input.getSdncRequestHeader().getSvcRequestId());
2514                 }
2515
2516                 PreloadDataBuilder preloadDataBuilder = new PreloadDataBuilder();
2517                 getPreloadData(preload_name, preload_type, preloadDataBuilder);
2518
2519                 PreloadDataBuilder operDataBuilder = new PreloadDataBuilder();
2520                 getPreloadData(preload_name, preload_type, operDataBuilder, LogicalDatastoreType.OPERATIONAL );
2521
2522                 //
2523                 // setup a preload-data object builder
2524                 // ACTION vnf-topology-operation
2525                 // INPUT:
2526                 //  USES sdnc-request-header;
2527                 //  USES request-information;
2528         //  uses vnf-topology-information;
2529                 // OUTPUT:
2530                 //  USES vnf-topology-response-body;
2531                 //
2532                 // container preload-data
2533         //   uses vnf-configuration-information;
2534
2535
2536                 log.info("Adding INPUT data for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] input: " + input);
2537                 PreloadNetworkTopologyOperationInputBuilder inputBuilder = new PreloadNetworkTopologyOperationInputBuilder(input);
2538                 VnfSdnUtil.toProperties(parms, inputBuilder.build());
2539                 log.info("Adding OPERATIONAL data for "+SVC_OPERATION+" ["+preload_name+","+preload_type +"] operational-data: " + operDataBuilder.build());
2540                 VnfSdnUtil.toProperties(parms, "operational-data", operDataBuilder);
2541
2542                 // Call SLI sync method
2543                 // Get SvcLogicService reference
2544
2545                 VNFSDNSvcLogicServiceClient svcLogicClient = new VNFSDNSvcLogicServiceClient();
2546                 Properties respProps = null;
2547
2548                 String errorCode = "200";
2549                 String errorMessage = null;
2550                 String ackFinal = "Y";
2551
2552
2553                 try
2554                 {
2555                         if (svcLogicClient.hasGraph("VNF-API", SVC_OPERATION , null, "sync"))
2556                         {
2557
2558                                 try
2559                                 {
2560                                         respProps = svcLogicClient.execute("VNF-API", SVC_OPERATION, null, "sync", preloadDataBuilder, parms);
2561                                 }
2562                                 catch (Exception e)
2563                                 {
2564                                         log.error("Caught exception executing service logic for "+ SVC_OPERATION, e);
2565                                         errorMessage = e.getMessage();
2566                                         errorCode = "500";
2567                                 }
2568                         } else {
2569                                 errorMessage = "No service logic active for VNF-API: '" + SVC_OPERATION + "'";
2570                                 errorCode = "503";
2571                         }
2572                 }
2573                 catch (Exception e)
2574                 {
2575                         errorCode = "500";
2576                         errorMessage = e.getMessage();
2577                         log.error("Caught exception looking for service logic", e);
2578                 }
2579
2580
2581                 if (respProps != null)
2582                 {
2583                         errorCode = respProps.getProperty("error-code");
2584                         errorMessage = respProps.getProperty("error-message");
2585                         ackFinal = respProps.getProperty("ack-final", "Y");
2586                         // internalError = respProps.getProperty("internal-error", "false");
2587                 }
2588
2589                 if ( errorCode != null && errorCode.length() != 0 && !( errorCode.equals("0")|| errorCode.equals("200"))) {
2590
2591                         responseBuilder.setResponseCode(errorCode);
2592                         responseBuilder.setResponseMessage(errorMessage);
2593                         responseBuilder.setAckFinalIndicator(ackFinal);
2594
2595                         VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2596                         preloadVnfListBuilder.setVnfName(preload_name);
2597                         preloadVnfListBuilder.setVnfType(preload_type);
2598                         preloadVnfListBuilder.setPreloadData(preloadDataBuilder.build());
2599                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] error code: '" + errorCode + "', Reason: '" + errorMessage + "'");
2600                         try {
2601                                 SavePreloadList (preloadVnfListBuilder.build(),true,LogicalDatastoreType.CONFIGURATION);
2602                         } catch (Exception e) {
2603                                 log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2604
2605                         }
2606                         log.debug("Sending Success rpc result due to external error");
2607                         RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2608                                 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2609                         return Futures.immediateFuture(rpcResult);
2610                 }
2611
2612                 // Got success from SLI
2613                 try {
2614                         preloadData = preloadDataBuilder.build();
2615                         log.info("Updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] preloadData: " + preloadData);
2616                         // svc-configuration-list
2617                         VnfPreloadListBuilder preloadVnfListBuilder = new VnfPreloadListBuilder();
2618                         preloadVnfListBuilder.setVnfName(preload_name);
2619                         preloadVnfListBuilder.setVnfType(preload_type);
2620                         preloadVnfListBuilder.setPreloadData(preloadData);
2621
2622                         // SDNGC-989 set merge flag to false
2623                         SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.CONFIGURATION);
2624                         log.info("Updating OPERATIONAL tree.");
2625                         SavePreloadList (preloadVnfListBuilder.build(), false, LogicalDatastoreType.OPERATIONAL);
2626                 } catch (Exception e) {
2627                         log.error("Caught Exception updating MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] \n",e);
2628                         responseBuilder.setResponseCode("500");
2629                         responseBuilder.setResponseMessage(e.toString());
2630                         responseBuilder.setAckFinalIndicator("Y");
2631                         log.error("Returned FAILED for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2632                         RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2633                                 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(false).withResult(responseBuilder.build()).build();
2634                         return Futures.immediateFuture(rpcResult);
2635                 }
2636
2637                 // Update succeeded
2638                 responseBuilder.setResponseCode(errorCode);
2639                 responseBuilder.setAckFinalIndicator(ackFinal);
2640                 if (errorMessage != null)
2641                 {
2642                         responseBuilder.setResponseMessage(errorMessage);
2643                 }
2644                 log.info("Updated MD-SAL for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] ");
2645                 log.info("Returned SUCCESS for "+SVC_OPERATION+" ["+preload_name+","+preload_type+"] " + responseBuilder.build());
2646
2647                 RpcResult<PreloadNetworkTopologyOperationOutput> rpcResult =
2648                                 RpcResultBuilder.<PreloadNetworkTopologyOperationOutput> status(true).withResult(responseBuilder.build()).build();
2649                 return Futures.immediateFuture(rpcResult);
2650         }
2651 }