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