vnfapi/provider/src/main/java/org/onap/sdnc/vnfapi/VnfApiProvider.java

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