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