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