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

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