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