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