adapters/mso-openstack-adapters/src/main/java/org/onap/so/heatbridge/HeatBridgeImpl.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * ONAP - SO
   4  * ================================================================================
   5  * Copyright (C) 2017 - 2019 AT&T Intellectual Property. All rights reserved.
   6  * ================================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END=========================================================
  19  */
  20
  21 /*
  22  * Copyright (C) 2018 Bell Canada. All rights reserved.
  23  *
  24  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
  25  * the License. You may obtain a copy of the License at
  26  *
  27  * http://www.apache.org/licenses/LICENSE-2.0
  28  *
  29  * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
  30  * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
  31  * specific language governing permissions and limitations under the License.
  32  */
  33 package org.onap.so.heatbridge;
  34
  35 import java.util.HashMap;
  36 import java.util.List;
  37 import java.util.Map;
  38 import java.util.Objects;
  39 import java.util.Optional;
  40 import java.util.concurrent.ConcurrentHashMap;
  41 import java.util.function.Function;
  42 import java.util.function.Predicate;
  43 import java.util.stream.Collectors;
  44 import javax.annotation.Nonnull;
  45 import javax.ws.rs.WebApplicationException;
  46 import org.apache.commons.collections.CollectionUtils;
  47 import org.apache.commons.validator.routines.InetAddressValidator;
  48 import org.onap.aai.domain.yang.Flavor;
  49 import org.onap.aai.domain.yang.Image;
  50 import org.onap.aai.domain.yang.L3InterfaceIpv4AddressList;
  51 import org.onap.aai.domain.yang.LInterface;
  52 import org.onap.aai.domain.yang.PInterface;
  53 import org.onap.aai.domain.yang.Pserver;
  54 import org.onap.aai.domain.yang.SriovPf;
  55 import org.onap.aai.domain.yang.SriovPfs;
  56 import org.onap.aai.domain.yang.SriovVf;
  57 import org.onap.aai.domain.yang.SriovVfs;
  58 import org.onap.aai.domain.yang.Vlan;
  59 import org.onap.aai.domain.yang.Vlans;
  60 import org.onap.aai.domain.yang.Vserver;
  61 import org.onap.aai.domain.yang.VfModule;
  62 import org.onap.so.client.aai.AAIObjectType;
  63 import org.onap.so.client.aai.AAIResourcesClient;
  64 import org.onap.so.client.aai.AAISingleTransactionClient;
  65 import org.onap.so.client.aai.entities.AAIResultWrapper;
  66 import org.onap.so.client.aai.entities.Relationships;
  67 import org.onap.so.client.aai.entities.uri.AAIResourceUri;
  68 import org.onap.so.client.aai.entities.uri.AAIUriFactory;
  69 import org.onap.so.client.graphinventory.entities.uri.Depth;
  70 import org.onap.so.client.graphinventory.exceptions.BulkProcessFailed;
  71 import org.onap.so.db.catalog.beans.CloudIdentity;
  72 import org.onap.so.heatbridge.constants.HeatBridgeConstants;
  73 import org.onap.so.heatbridge.factory.MsoCloudClientFactoryImpl;
  74 import org.onap.so.heatbridge.helpers.AaiHelper;
  75 import org.onap.so.heatbridge.openstack.api.OpenstackClient;
  76 import org.onap.so.heatbridge.openstack.factory.OpenstackClientFactoryImpl;
  77 import org.onap.so.heatbridge.utils.HeatBridgeUtils;
  78 import org.onap.logging.filter.base.ErrorCode;
  79 import org.onap.so.logger.LoggingAnchor;
  80 import org.onap.so.logger.MessageEnum;
  81 import org.openstack4j.model.compute.Server;
  82 import org.openstack4j.model.heat.Resource;
  83 import org.openstack4j.model.network.IP;
  84 import org.openstack4j.model.network.Network;
  85 import org.openstack4j.model.network.NetworkType;
  86 import org.openstack4j.model.network.Port;
  87 import org.slf4j.Logger;
  88 import org.slf4j.LoggerFactory;
  89 import com.google.common.base.Preconditions;
  90 import com.google.common.base.Strings;
  91 import com.google.common.collect.ImmutableMap;
  92
  93 /**
  94  * This class provides an implementation of {@link HeatBridgeApi}
  95  */
  96 public class HeatBridgeImpl implements HeatBridgeApi {
  97
  98     private static final Logger logger = LoggerFactory.getLogger(HeatBridgeImpl.class);
  99     private static final String ERR_MSG_NULL_OS_CLIENT =
 100             "Initialization error: Null openstack client. Authenticate with Keystone first.";
 101     private static final String OOB_MGT_NETWORK_IDENTIFIER = "Management";
 102     private OpenstackClient osClient;
 103     private AAIResourcesClient resourcesClient;
 104     private AAISingleTransactionClient transaction;
 105     private String cloudOwner;
 106     private String cloudRegionId;
 107     private String regionId;
 108     private String tenantId;
 109     private AaiHelper aaiHelper = new AaiHelper();
 110     private CloudIdentity cloudIdentity;
 111
 112     public HeatBridgeImpl(AAIResourcesClient resourcesClient, final CloudIdentity cloudIdentity,
 113             @Nonnull final String cloudOwner, @Nonnull final String cloudRegionId, @Nonnull final String regionId,
 114             @Nonnull final String tenantId) {
 115         Objects.requireNonNull(cloudOwner, "Null cloud-owner value!");
 116         Objects.requireNonNull(cloudRegionId, "Null cloud-region identifier!");
 117         Objects.requireNonNull(tenantId, "Null tenant identifier!");
 118         Objects.requireNonNull(regionId, "Null regionId identifier!");
 119
 120         this.cloudIdentity = cloudIdentity;
 121         this.cloudOwner = cloudOwner;
 122         this.cloudRegionId = cloudRegionId;
 123         this.regionId = regionId;
 124         this.tenantId = tenantId;
 125         this.resourcesClient = resourcesClient;
 126         this.transaction = resourcesClient.beginSingleTransaction();
 127     }
 128
 129     public HeatBridgeImpl() {
 130         this.resourcesClient = new AAIResourcesClient();
 131         this.transaction = resourcesClient.beginSingleTransaction();
 132     }
 133
 134     @Override
 135     public OpenstackClient authenticate() throws HeatBridgeException {
 136         this.osClient = new MsoCloudClientFactoryImpl(new OpenstackClientFactoryImpl()).getOpenstackClient(
 137                 cloudIdentity.getIdentityUrl(), cloudIdentity.getMsoId(), cloudIdentity.getMsoPass(), regionId,
 138                 tenantId);
 139         logger.debug("Successfully authenticated with keystone for tenant: " + tenantId + " and region: " + regionId);
 140         return osClient;
 141     }
 142
 143     @Override
 144     public List<Resource> queryNestedHeatStackResources(final String heatStackId) {
 145         Objects.requireNonNull(osClient, ERR_MSG_NULL_OS_CLIENT);
 146         Preconditions.checkState(!Strings.isNullOrEmpty(heatStackId), "Invalid heatStackId!");
 147         List<Resource> stackBasedResources =
 148                 osClient.getStackBasedResources(heatStackId, HeatBridgeConstants.OS_DEFAULT_HEAT_NESTING);
 149         logger.debug(stackBasedResources.size() + " heat stack resources are extracted for stack: " + heatStackId);
 150         return stackBasedResources;
 151     }
 152
 153     @Override
 154     public List<String> extractStackResourceIdsByResourceType(final List<Resource> stackResources,
 155             final String resourceType) {
 156         return stackResources.stream().filter(stackResource -> stackResource.getType().equals(resourceType))
 157                 .map(Resource::getPhysicalResourceId).collect(Collectors.toList());
 158     }
 159
 160     @Override
 161     public List<String> extractNetworkIds(final List<String> networkNameList) {
 162         Objects.requireNonNull(osClient, ERR_MSG_NULL_OS_CLIENT);
 163         return networkNameList.stream()
 164                 .map(netName -> osClient
 165                         .listNetworksByFilter(ImmutableMap.of(HeatBridgeConstants.OS_NAME_KEY, netName)))
 166                 .filter(nets -> nets != null && nets.size() == 1) // extract network-id only if network-name is unique
 167                 .map(nets -> nets.get(0).getId()).collect(Collectors.toList());
 168     }
 169
 170     @Override
 171     public List<Server> getAllOpenstackServers(final List<Resource> stackResources) {
 172         Objects.requireNonNull(osClient, ERR_MSG_NULL_OS_CLIENT);
 173
 174         // Filter Openstack Compute resources
 175         List<String> serverIds =
 176                 extractStackResourceIdsByResourceType(stackResources, HeatBridgeConstants.OS_SERVER_RESOURCE_TYPE);
 177         return serverIds.stream().map(serverId -> osClient.getServerById(serverId)).collect(Collectors.toList());
 178     }
 179
 180     @Override
 181     public List<org.openstack4j.model.compute.Image> extractOpenstackImagesFromServers(final List<Server> servers) {
 182         Objects.requireNonNull(osClient, ERR_MSG_NULL_OS_CLIENT);
 183         return servers.stream().map(Server::getImage)
 184                 .filter(distinctByProperty(org.openstack4j.model.compute.Image::getId)).collect(Collectors.toList());
 185     }
 186
 187     @Override
 188     public List<org.openstack4j.model.compute.Flavor> extractOpenstackFlavorsFromServers(final List<Server> servers) {
 189         Objects.requireNonNull(osClient, ERR_MSG_NULL_OS_CLIENT);
 190         return servers.stream().map(Server::getFlavor)
 191                 .filter(distinctByProperty(org.openstack4j.model.compute.Flavor::getId)).collect(Collectors.toList());
 192     }
 193
 194     @Override
 195     public void buildAddImagesToAaiAction(final List<org.openstack4j.model.compute.Image> images)
 196             throws HeatBridgeException {
 197         for (org.openstack4j.model.compute.Image image : images) {
 198             Image aaiImage = aaiHelper.buildImage(image);
 199             try {
 200                 AAIResourceUri uri = AAIUriFactory.createResourceUri(AAIObjectType.IMAGE, cloudOwner, cloudRegionId,
 201                         aaiImage.getImageId());
 202                 if (!resourcesClient.exists(uri)) {
 203                     transaction.create(uri, aaiImage);
 204                     logger.debug("Queuing AAI command to add image: " + aaiImage.getImageId());
 205                 } else {
 206                     logger.debug("Nothing to add since image: " + aaiImage.getImageId() + "already exists in AAI.");
 207                 }
 208             } catch (WebApplicationException e) {
 209                 throw new HeatBridgeException(
 210                         "Failed to update image to AAI: " + aaiImage.getImageId() + ". Error" + " cause: " + e, e);
 211             }
 212         }
 213     }
 214
 215     @Override
 216     public void buildAddFlavorsToAaiAction(final List<org.openstack4j.model.compute.Flavor> flavors)
 217             throws HeatBridgeException {
 218         for (org.openstack4j.model.compute.Flavor flavor : flavors) {
 219             Flavor aaiFlavor = aaiHelper.buildFlavor(flavor);
 220             try {
 221                 AAIResourceUri uri = AAIUriFactory.createResourceUri(AAIObjectType.FLAVOR, cloudOwner, cloudRegionId,
 222                         aaiFlavor.getFlavorId());
 223                 if (!resourcesClient.exists(uri)) {
 224                     transaction.create(uri, aaiFlavor);
 225                     logger.debug("Queuing AAI command to add flavor: " + aaiFlavor.getFlavorId());
 226                 } else {
 227                     logger.debug("Nothing to add since flavor: " + aaiFlavor.getFlavorId() + "already exists in AAI.");
 228                 }
 229             } catch (WebApplicationException e) {
 230                 throw new HeatBridgeException(
 231                         "Failed to update flavor to AAI: " + aaiFlavor.getFlavorId() + ". Error" + " cause: " + e, e);
 232             }
 233         }
 234     }
 235
 236     @Override
 237     public void buildAddVserversToAaiAction(final String genericVnfId, final String vfModuleId,
 238             final List<Server> servers) {
 239         servers.forEach(server -> {
 240             Vserver vserver = aaiHelper.buildVserver(server.getId(), server);
 241
 242             // Build vserver relationships to: image, flavor, pserver, vf-module
 243             vserver.setRelationshipList(
 244                     aaiHelper.getVserverRelationshipList(cloudOwner, cloudRegionId, genericVnfId, vfModuleId, server));
 245             transaction.create(AAIUriFactory.createResourceUri(AAIObjectType.VSERVER, cloudOwner, cloudRegionId,
 246                     tenantId, vserver.getVserverId()), vserver);
 247         });
 248     }
 249
 250     @Override
 251     public void buildAddVserverLInterfacesToAaiAction(final List<Resource> stackResources,
 252             final List<String> oobMgtNetIds) {
 253         Objects.requireNonNull(osClient, ERR_MSG_NULL_OS_CLIENT);
 254         List<String> portIds =
 255                 extractStackResourceIdsByResourceType(stackResources, HeatBridgeConstants.OS_PORT_RESOURCE_TYPE);
 256         for (String portId : portIds) {
 257             Port port = osClient.getPortById(portId);
 258             LInterface lIf = new LInterface();
 259             lIf.setInterfaceId(port.getId());
 260             lIf.setInterfaceName(port.getName());
 261             lIf.setMacaddr(port.getMacAddress());
 262             if (oobMgtNetIds != null && oobMgtNetIds.contains(port.getNetworkId())) {
 263                 lIf.setInterfaceRole(OOB_MGT_NETWORK_IDENTIFIER);
 264             } else {
 265                 lIf.setInterfaceRole(port.getvNicType());
 266             }
 267
 268             updateLInterfaceIps(port, lIf);
 269             updateLInterfaceVlan(port, lIf);
 270
 271             // Update l-interface to the vserver
 272             transaction.create(AAIUriFactory.createResourceUri(AAIObjectType.L_INTERFACE, cloudOwner, cloudRegionId,
 273                     tenantId, port.getDeviceId(), lIf.getInterfaceName()), lIf);
 274         }
 275     }
 276
 277     @Override
 278     public void createPserversAndPinterfacesIfNotPresentInAai(final List<Resource> stackResources)
 279             throws HeatBridgeException {
 280         Map<String, Pserver> serverHostnames = getPserverMapping(stackResources);
 281         createPServerIfNotExists(serverHostnames);
 282         List<String> portIds =
 283                 extractStackResourceIdsByResourceType(stackResources, HeatBridgeConstants.OS_PORT_RESOURCE_TYPE);
 284         for (String portId : portIds) {
 285             Port port = osClient.getPortById(portId);
 286             if (port.getvNicType().equalsIgnoreCase(HeatBridgeConstants.OS_SRIOV_PORT_TYPE)) {
 287                 createPServerPInterfaceIfNotExists(serverHostnames.get(port.getHostId()).getHostname(),
 288                         aaiHelper.buildPInterface(port));
 289             }
 290         }
 291     }
 292
 293     private Map<String, Pserver> getPserverMapping(final List<Resource> stackResources) {
 294         List<Server> osServers = getAllOpenstackServers(stackResources);
 295         Map<String, Pserver> pserverMap = new HashMap<>();
 296         for (Server server : osServers) {
 297             pserverMap.put(server.getHost(), aaiHelper.buildPserver(server));
 298         }
 299         return pserverMap;
 300     }
 301
 302     private void createPServerIfNotExists(Map<String, Pserver> serverHostnames) {
 303         for (Pserver pserver : serverHostnames.values()) {
 304             AAIResourceUri uri = AAIUriFactory.createResourceUri(AAIObjectType.PSERVER, pserver.getHostname());
 305             resourcesClient.createIfNotExists(uri, Optional.of(pserver));
 306         }
 307     }
 308
 309     private void createPServerPInterfaceIfNotExists(String pserverHostname, PInterface pInterface) {
 310         AAIResourceUri uri = AAIUriFactory.createResourceUri(AAIObjectType.P_INTERFACE, pserverHostname,
 311                 pInterface.getInterfaceName());
 312         resourcesClient.createIfNotExists(uri, Optional.of(pInterface));
 313     }
 314
 315     private void updateLInterfaceVlan(final Port port, final LInterface lIf) {
 316         Vlan vlan = new Vlan();
 317         Network network = osClient.getNetworkById(port.getNetworkId());
 318         lIf.setNetworkName(network.getName());
 319         if (network.getNetworkType().equals(NetworkType.VLAN)) {
 320             vlan.setVlanInterface(network.getProviderSegID());
 321             Vlans vlans = new Vlans();
 322             List<Vlan> vlanList = vlans.getVlan();
 323             vlanList.add(vlan);
 324             lIf.setVlans(vlans);
 325         }
 326         // Build sriov-vf to the l-interface
 327         if (port.getvNicType().equalsIgnoreCase(HeatBridgeConstants.OS_SRIOV_PORT_TYPE)) {
 328             SriovVfs sriovVfs = new SriovVfs();
 329             // JAXB does not generate setters for list, however getter ensures its creation.
 330             // Thus, all list manipulations must be made on live list.
 331             List<SriovVf> sriovVfList = sriovVfs.getSriovVf();
 332             SriovVf sriovVf = new SriovVf();
 333             sriovVf.setPciId(port.getProfile().get(HeatBridgeConstants.OS_PCI_SLOT_KEY).toString());
 334             sriovVf.setNeutronNetworkId(port.getNetworkId());
 335             if (port.getVifDetails() != null) {
 336                 sriovVf.setVfVlanFilter((String) port.getVifDetails().get(HeatBridgeConstants.OS_VLAN_NETWORK_KEY));
 337             }
 338             sriovVfList.add(sriovVf);
 339
 340             lIf.setSriovVfs(sriovVfs);
 341
 342             // For the given port create sriov-pf for host pserver/p-interface if absent
 343             updateSriovPfToPserver(port, lIf);
 344         }
 345     }
 346
 347     /**
 348      * Needs to be corrected according to the specification that is in draft If pserver/p-interface does not have a
 349      * SRIOV-PF object matching the PCI-ID of the Openstack port object, then create it in AAI. Openstack SRIOV Port
 350      * object has pci-id (to match sriov-pf on pserver/p-interface), physical-network ID (that matches the p-interface
 351      * name).
 352      *
 353      * @param port Openstack port object
 354      * @param lIf AAI l-interface object
 355      */
 356     private void updateSriovPfToPserver(final Port port, final LInterface lIf) {
 357         if (port.getProfile() == null || Strings
 358                 .isNullOrEmpty(port.getProfile().get(HeatBridgeConstants.OS_PHYSICAL_NETWORK_KEY).toString())) {
 359             logger.debug("The SRIOV port:" + port.getName() + " is missing physical-network-id, cannot update "
 360                     + "sriov-pf object for host pserver: " + port.getHostId());
 361             return;
 362         }
 363         Optional<String> matchingPifName = HeatBridgeUtils.getMatchingPserverPifName(
 364                 port.getProfile().get(HeatBridgeConstants.OS_PHYSICAL_NETWORK_KEY).toString());
 365         if (matchingPifName.isPresent()) {
 366             // Update l-interface description
 367             String pserverHostName = port.getHostId();
 368             lIf.setInterfaceDescription("Attached to SR-IOV port: " + pserverHostName + "::" + matchingPifName.get());
 369             try {
 370                 Optional<PInterface> matchingPIf = resourcesClient.get(PInterface.class,
 371                         AAIUriFactory
 372                                 .createResourceUri(AAIObjectType.P_INTERFACE, pserverHostName, matchingPifName.get())
 373                                 .depth(Depth.ONE));
 374                 if (matchingPIf.isPresent()) {
 375                     SriovPfs pIfSriovPfs = matchingPIf.get().getSriovPfs();
 376                     if (pIfSriovPfs == null) {
 377                         pIfSriovPfs = new SriovPfs();
 378                     }
 379                     // Extract PCI-ID from OS port object
 380                     String pfPciId = port.getProfile().get(HeatBridgeConstants.OS_PCI_SLOT_KEY).toString();
 381
 382                     List<SriovPf> existingSriovPfs = pIfSriovPfs.getSriovPf();
 383                     if (CollectionUtils.isEmpty(existingSriovPfs) || existingSriovPfs.stream()
 384                             .noneMatch(existingSriovPf -> existingSriovPf.getPfPciId().equals(pfPciId))) {
 385                         // Add sriov-pf object with PCI-ID to AAI
 386                         SriovPf sriovPf = new SriovPf();
 387                         sriovPf.setPfPciId(pfPciId);
 388                         logger.debug("Queuing AAI command to update sriov-pf object to pserver: " + pserverHostName
 389                                 + "/" + matchingPifName.get());
 390                         transaction.create(AAIUriFactory.createResourceUri(AAIObjectType.SRIOV_PF, pserverHostName,
 391                                 matchingPifName.get(), sriovPf.getPfPciId()), sriovPf);
 392                     }
 393                 }
 394             } catch (WebApplicationException e) {
 395                 // Silently log that we failed to update the Pserver p-interface with PCI-ID
 396                 logger.error(LoggingAnchor.NINE, MessageEnum.GENERAL_EXCEPTION, pserverHostName, matchingPifName.get(),
 397                         cloudOwner, tenantId, "OpenStack", "Heatbridge", ErrorCode.DataError.getValue(),
 398                         "Exception - Failed to add sriov-pf object to pserver", e);
 399             }
 400         }
 401     }
 402
 403     private void updateLInterfaceIps(final Port port, final LInterface lIf) {
 404         List<L3InterfaceIpv4AddressList> lInterfaceIps = lIf.getL3InterfaceIpv4AddressList();
 405         for (IP ip : port.getFixedIps()) {
 406             String ipAddress = ip.getIpAddress();
 407             if (InetAddressValidator.getInstance().isValidInet4Address(ipAddress)) {
 408                 L3InterfaceIpv4AddressList lInterfaceIp = new L3InterfaceIpv4AddressList();
 409                 lInterfaceIp.setL3InterfaceIpv4Address(ipAddress);
 410                 lInterfaceIp.setNeutronNetworkId(port.getNetworkId());
 411                 lInterfaceIp.setNeutronSubnetId(ip.getSubnetId());
 412                 lInterfaceIp.setL3InterfaceIpv4PrefixLength(32L);
 413                 lInterfaceIps.add(lInterfaceIp);
 414             }
 415         }
 416     }
 417
 418     @Override
 419     public void submitToAai() throws HeatBridgeException {
 420         try {
 421             transaction.execute();
 422         } catch (BulkProcessFailed e) {
 423             String msg = "Failed to commit transaction";
 424             logger.debug(msg + " with error: " + e);
 425             throw new HeatBridgeException(msg, e);
 426         }
 427     }
 428
 429     @Override
 430     public void deleteVfModuleData(@Nonnull final String vnfId, @Nonnull final String vfModuleId)
 431             throws HeatBridgeException {
 432         Objects.requireNonNull(vnfId, "Null vnf-id!");
 433         Objects.requireNonNull(vfModuleId, "Null vf-module-id!");
 434         try {
 435             Optional<VfModule> vfModule = resourcesClient.get(VfModule.class,
 436                     AAIUriFactory.createResourceUri(AAIObjectType.VF_MODULE, vnfId, vfModuleId).depth(Depth.ONE));
 437             if (vfModule.isPresent()) {
 438
 439                 AAIResultWrapper resultWrapper = new AAIResultWrapper(vfModule);
 440                 Optional<Relationships> relationships = resultWrapper.getRelationships();
 441                 if (relationships.isPresent()) {
 442                     List<AAIResourceUri> vserverUris = relationships.get().getRelatedUris(AAIObjectType.VSERVER);
 443                     createTransactionToDeleteSriovPfFromPserver(vserverUris);
 444                     if (!vserverUris.isEmpty()) {
 445                         for (AAIResourceUri vserverUri : vserverUris) {
 446                             resourcesClient.delete(vserverUri);
 447                         }
 448                     }
 449                 }
 450             }
 451         } catch (Exception e) {
 452             String msg = "Failed to commit delete heatbridge data transaction";
 453             logger.debug(msg + " with error: " + e);
 454             throw new HeatBridgeException(msg, e);
 455         }
 456     }
 457
 458     private void createTransactionToDeleteSriovPfFromPserver(List<AAIResourceUri> vserverUris) {
 459         Map<String, List<String>> pserverToPciIdMap = getPserverToPciIdMap(vserverUris);
 460         for (Map.Entry<String, List<String>> entry : pserverToPciIdMap.entrySet()) {
 461             String pserverName = entry.getKey();
 462             List<String> pciIds = entry.getValue();
 463             Optional<Pserver> pserver = resourcesClient.get(Pserver.class,
 464                     AAIUriFactory.createResourceUri(AAIObjectType.PSERVER, pserverName).depth(Depth.TWO));
 465             if (pserver.isPresent()) {
 466                 // For each pserver/p-interface match sriov-vfs by pic-id and delete them.
 467                 pserver.get().getPInterfaces().getPInterface().stream().filter(
 468                         pIf -> pIf.getSriovPfs() != null && CollectionUtils.isNotEmpty(pIf.getSriovPfs().getSriovPf()))
 469                         .forEach(pIf -> pIf.getSriovPfs().getSriovPf().forEach(sriovPf -> {
 470                             if (pciIds.contains(sriovPf.getPfPciId())) {
 471                                 logger.debug("creating transaction to delete SR-IOV PF: " + pIf.getInterfaceName()
 472                                         + " from PServer: " + pserverName);
 473                                 resourcesClient.delete(AAIUriFactory.createResourceUri(AAIObjectType.SRIOV_PF,
 474                                         pserverName, pIf.getInterfaceName(), sriovPf.getPfPciId()));
 475                             }
 476                         }));
 477             }
 478         }
 479     }
 480
 481     private Map<String, List<String>> getPserverToPciIdMap(List<AAIResourceUri> vserverUris) {
 482         Map<String, List<String>> pserverToPciIdMap = new HashMap<>();
 483         for (AAIResourceUri vserverUri : vserverUris) {
 484             AAIResultWrapper vserverWrapper = resourcesClient.get(vserverUri.depth(Depth.TWO));
 485             Optional<Relationships> vserverRelationships = vserverWrapper.getRelationships();
 486             if (vserverRelationships.isPresent()
 487                     && CollectionUtils.isNotEmpty(vserverRelationships.get().getRelatedLinks(AAIObjectType.PSERVER))) {
 488                 Vserver vserver = vserverWrapper.asBean(Vserver.class).get();
 489                 List<String> pciIds = HeatBridgeUtils.extractPciIdsFromVServer(vserver);
 490                 if (CollectionUtils.isNotEmpty(pciIds)) {
 491                     List<String> matchingPservers = vserverRelationships.get().getRelatedLinks(AAIObjectType.PSERVER);
 492                     if (matchingPservers != null && matchingPservers.size() == 1) {
 493                         pserverToPciIdMap.put(matchingPservers.get(0), pciIds);
 494                     }
 495                 }
 496             }
 497         }
 498         return pserverToPciIdMap;
 499     }
 500
 501     private <T> Predicate<T> distinctByProperty(Function<? super T, Object> keyExtractor) {
 502         Map<Object, Boolean> map = new ConcurrentHashMap<>();
 503         return t -> map.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
 504     }
 505 }