vnfapi/provider/src/main/java/org/onap/sdnc/vnfapi/vnfapiProvider.java

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