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