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