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.NotFoundException;
  46 import javax.ws.rs.WebApplicationException;
  47 import org.apache.commons.collections.CollectionUtils;
  48 import org.apache.commons.validator.routines.InetAddressValidator;
  49 import org.onap.aai.domain.yang.Flavor;
  50 import org.onap.aai.domain.yang.Image;
  51 import org.onap.aai.domain.yang.L3InterfaceIpv4AddressList;
  52 import org.onap.aai.domain.yang.LInterface;
  53 import org.onap.aai.domain.yang.PInterface;
  54 import org.onap.aai.domain.yang.Pserver;
  55 import org.onap.aai.domain.yang.SriovPf;
  56 import org.onap.aai.domain.yang.SriovPfs;
  57 import org.onap.aai.domain.yang.SriovVf;
  58 import org.onap.aai.domain.yang.SriovVfs;
  59 import org.onap.aai.domain.yang.VfModule;
  60 import org.onap.aai.domain.yang.Vlan;
  61 import org.onap.aai.domain.yang.Vlans;
  62 import org.onap.aai.domain.yang.Vserver;
  63 import org.onap.aaiclient.client.aai.AAIObjectType;
  64 import org.onap.aaiclient.client.aai.AAIResourcesClient;
  65 import org.onap.aaiclient.client.aai.AAISingleTransactionClient;
  66 import org.onap.aaiclient.client.aai.entities.AAIResultWrapper;
  67 import org.onap.aaiclient.client.aai.entities.Relationships;
  68 import org.onap.aaiclient.client.aai.entities.uri.AAIResourceUri;
  69 import org.onap.aaiclient.client.aai.entities.uri.AAIUriFactory;
  70 import org.onap.aaiclient.client.graphinventory.entities.uri.Depth;
  71 import org.onap.aaiclient.client.graphinventory.exceptions.BulkProcessFailed;
  72 import org.onap.logging.filter.base.ErrorCode;
  73 import org.onap.so.db.catalog.beans.CloudIdentity;
  74 import org.onap.so.db.catalog.beans.ServerType;
  75 import org.onap.so.heatbridge.constants.HeatBridgeConstants;
  76 import org.onap.so.heatbridge.factory.MsoCloudClientFactoryImpl;
  77 import org.onap.so.heatbridge.helpers.AaiHelper;
  78 import org.onap.so.heatbridge.openstack.api.OpenstackClient;
  79 import org.onap.so.heatbridge.openstack.factory.OpenstackClientFactoryImpl;
  80 import org.onap.so.heatbridge.utils.HeatBridgeUtils;
  81 import org.onap.so.logger.LoggingAnchor;
  82 import org.onap.so.logger.MessageEnum;
  83 import org.onap.so.spring.SpringContextHelper;
  84 import org.openstack4j.model.compute.Server;
  85 import org.openstack4j.model.heat.Resource;
  86 import org.openstack4j.model.network.IP;
  87 import org.openstack4j.model.network.Network;
  88 import org.openstack4j.model.network.NetworkType;
  89 import org.openstack4j.model.network.Port;
  90 import org.openstack4j.model.network.Subnet;
  91 import org.slf4j.Logger;
  92 import org.slf4j.LoggerFactory;
  93 import org.springframework.core.env.Environment;
  94 import com.google.common.base.Preconditions;
  95 import com.google.common.base.Strings;
  96 import com.google.common.collect.ImmutableMap;
  97 import inet.ipaddr.IPAddressString;
  98
  99 /**
 100  * This class provides an implementation of {@link HeatBridgeApi}
 101  */
 102 public class HeatBridgeImpl implements HeatBridgeApi {
 103
 104     private static final Logger logger = LoggerFactory.getLogger(HeatBridgeImpl.class);
 105     private static final String ERR_MSG_NULL_OS_CLIENT =
 106             "Initialization error: Null openstack client. Authenticate with Keystone first.";
 107     private static final String OOB_MGT_NETWORK_IDENTIFIER = "Management";
 108     private OpenstackClient osClient;
 109     private AAIResourcesClient resourcesClient;
 110     private AAISingleTransactionClient transaction;
 111     private String cloudOwner;
 112     private String cloudRegionId;
 113     private String regionId;
 114     private String tenantId;
 115     private AaiHelper aaiHelper = new AaiHelper();
 116     private CloudIdentity cloudIdentity;
 117     private Environment env;
 118
 119
 120     public HeatBridgeImpl(AAIResourcesClient resourcesClient, final CloudIdentity cloudIdentity,
 121             @Nonnull final String cloudOwner, @Nonnull final String cloudRegionId, @Nonnull final String regionId,
 122             @Nonnull final String tenantId) {
 123         Objects.requireNonNull(cloudOwner, "Null cloud-owner value!");
 124         Objects.requireNonNull(cloudRegionId, "Null cloud-region identifier!");
 125         Objects.requireNonNull(tenantId, "Null tenant identifier!");
 126         Objects.requireNonNull(regionId, "Null regionId identifier!");
 127
 128         this.cloudIdentity = cloudIdentity;
 129         this.cloudOwner = cloudOwner;
 130         this.cloudRegionId = cloudRegionId;
 131         this.regionId = regionId;
 132         this.tenantId = tenantId;
 133         this.resourcesClient = resourcesClient;
 134         if (resourcesClient != null)
 135             this.transaction = resourcesClient.beginSingleTransaction();
 136         if (SpringContextHelper.getAppContext() != null)
 137             this.env = SpringContextHelper.getAppContext().getEnvironment();
 138     }
 139
 140     public HeatBridgeImpl() {
 141         this.resourcesClient = new AAIResourcesClient();
 142         this.transaction = resourcesClient.beginSingleTransaction();
 143     }
 144
 145     @Override
 146     public OpenstackClient authenticate() throws HeatBridgeException {
 147         String keystoneVersion = "";
 148         if (ServerType.KEYSTONE.equals(cloudIdentity.getIdentityServerType()))
 149             keystoneVersion = "v2.0";
 150         else if (ServerType.KEYSTONE_V3.equals(cloudIdentity.getIdentityServerType())) {
 151             keystoneVersion = "v3";
 152         } else {
 153             keystoneVersion = "UNKNOWN";
 154         }
 155         logger.trace("Keystone Version: {} ", keystoneVersion);
 156         this.osClient = new MsoCloudClientFactoryImpl(new OpenstackClientFactoryImpl()).getOpenstackClient(
 157                 cloudIdentity.getIdentityUrl(), cloudIdentity.getMsoId(), cloudIdentity.getMsoPass(), regionId,
 158                 tenantId, keystoneVersion, cloudIdentity.getUserDomainName(), cloudIdentity.getProjectDomainName());
 159         logger.trace("Successfully authenticated with keystone for tenant: {} and region: {}", tenantId, regionId);
 160         return osClient;
 161     }
 162
 163     @Override
 164     public List<Resource> queryNestedHeatStackResources(final String heatStackId) {
 165         Objects.requireNonNull(osClient, ERR_MSG_NULL_OS_CLIENT);
 166         Preconditions.checkState(!Strings.isNullOrEmpty(heatStackId), "Invalid heatStackId!");
 167         List<Resource> stackBasedResources =
 168                 osClient.getStackBasedResources(heatStackId, HeatBridgeConstants.OS_DEFAULT_HEAT_NESTING);
 169         logger.debug(stackBasedResources.size() + " heat stack resources are extracted for stack: " + heatStackId);
 170         return stackBasedResources;
 171     }
 172
 173     @Override
 174     public List<String> extractStackResourceIdsByResourceType(final List<Resource> stackResources,
 175             final String resourceType) {
 176         return stackResources.stream().filter(stackResource -> stackResource.getType().equals(resourceType))
 177                 .map(Resource::getPhysicalResourceId).collect(Collectors.toList());
 178     }
 179
 180     @Override
 181     public List<String> extractNetworkIds(final List<String> networkNameList) {
 182         Objects.requireNonNull(osClient, ERR_MSG_NULL_OS_CLIENT);
 183         return networkNameList.stream()
 184                 .map(netName -> osClient
 185                         .listNetworksByFilter(ImmutableMap.of(HeatBridgeConstants.OS_NAME_KEY, netName)))
 186                 .filter(nets -> nets != null && nets.size() == 1) // extract network-id only if network-name is unique
 187                 .map(nets -> nets.get(0).getId()).collect(Collectors.toList());
 188     }
 189
 190     @Override
 191     public List<Server> getAllOpenstackServers(final List<Resource> stackResources) {
 192         Objects.requireNonNull(osClient, ERR_MSG_NULL_OS_CLIENT);
 193         // Filter Openstack Compute resources
 194         List<String> serverIds =
 195                 extractStackResourceIdsByResourceType(stackResources, HeatBridgeConstants.OS_SERVER_RESOURCE_TYPE);
 196         return serverIds.stream().map(serverId -> osClient.getServerById(serverId)).collect(Collectors.toList());
 197     }
 198
 199     @Override
 200     public List<org.openstack4j.model.compute.Image> extractOpenstackImagesFromServers(final List<Server> servers) {
 201         Objects.requireNonNull(osClient, ERR_MSG_NULL_OS_CLIENT);
 202         return servers.stream().map(Server::getImage)
 203                 .filter(distinctByProperty(org.openstack4j.model.compute.Image::getId)).collect(Collectors.toList());
 204     }
 205
 206     @Override
 207     public List<org.openstack4j.model.compute.Flavor> extractOpenstackFlavorsFromServers(final List<Server> servers) {
 208         Objects.requireNonNull(osClient, ERR_MSG_NULL_OS_CLIENT);
 209         return servers.stream().map(Server::getFlavor)
 210                 .filter(distinctByProperty(org.openstack4j.model.compute.Flavor::getId)).collect(Collectors.toList());
 211     }
 212
 213     @Override
 214     public void buildAddImagesToAaiAction(final List<org.openstack4j.model.compute.Image> images)
 215             throws HeatBridgeException {
 216         for (org.openstack4j.model.compute.Image image : images) {
 217             Image aaiImage = aaiHelper.buildImage(image);
 218             try {
 219                 AAIResourceUri uri = AAIUriFactory.createResourceUri(AAIObjectType.IMAGE, cloudOwner, cloudRegionId,
 220                         aaiImage.getImageId());
 221                 if (!resourcesClient.exists(uri)) {
 222                     transaction.create(uri, aaiImage);
 223                     logger.debug("Queuing AAI command to add image: " + aaiImage.getImageId());
 224                 } else {
 225                     logger.debug("Nothing to add since image: " + aaiImage.getImageId() + "already exists in AAI.");
 226                 }
 227             } catch (WebApplicationException e) {
 228                 throw new HeatBridgeException(
 229                         "Failed to update image to AAI: " + aaiImage.getImageId() + ". Error" + " cause: " + e, e);
 230             }
 231         }
 232     }
 233
 234     @Override
 235     public void buildAddFlavorsToAaiAction(final List<org.openstack4j.model.compute.Flavor> flavors)
 236             throws HeatBridgeException {
 237         for (org.openstack4j.model.compute.Flavor flavor : flavors) {
 238             Flavor aaiFlavor = aaiHelper.buildFlavor(flavor);
 239             try {
 240                 AAIResourceUri uri = AAIUriFactory.createResourceUri(AAIObjectType.FLAVOR, cloudOwner, cloudRegionId,
 241                         aaiFlavor.getFlavorId());
 242                 transaction.createIfNotExists(uri, Optional.of(aaiFlavor));
 243             } catch (WebApplicationException e) {
 244                 throw new HeatBridgeException(
 245                         "Failed to update flavor to AAI: " + aaiFlavor.getFlavorId() + ". Error" + " cause: " + e, e);
 246             }
 247         }
 248     }
 249
 250     @Override
 251     public void buildAddVserversToAaiAction(final String genericVnfId, final String vfModuleId,
 252             final List<Server> servers) {
 253         servers.forEach(server -> {
 254             Vserver vserver = aaiHelper.buildVserver(server.getId(), server);
 255
 256             // Build vserver relationships to: image, flavor, pserver, vf-module
 257             vserver.setRelationshipList(
 258                     aaiHelper.getVserverRelationshipList(cloudOwner, cloudRegionId, genericVnfId, vfModuleId, server));
 259             transaction.createIfNotExists(AAIUriFactory.createResourceUri(AAIObjectType.VSERVER, cloudOwner,
 260                     cloudRegionId, tenantId, vserver.getVserverId()), Optional.of(vserver));
 261         });
 262     }
 263
 264     @Override
 265     public void buildAddVserverLInterfacesToAaiAction(final List<Resource> stackResources,
 266             final List<String> oobMgtNetIds, String cloudOwner) {
 267         Objects.requireNonNull(osClient, ERR_MSG_NULL_OS_CLIENT);
 268         List<String> portIds =
 269                 extractStackResourceIdsByResourceType(stackResources, HeatBridgeConstants.OS_PORT_RESOURCE_TYPE);
 270         for (String portId : portIds) {
 271             Port port = osClient.getPortById(portId);
 272             Network network = osClient.getNetworkById(port.getNetworkId());
 273             LInterface lIf = new LInterface();
 274             lIf.setInterfaceId(port.getId());
 275             lIf.setInterfaceName(port.getName());
 276             lIf.setMacaddr(port.getMacAddress());
 277             lIf.setNetworkName(network.getName());
 278             lIf.setIsPortMirrored(false);
 279             lIf.setIsIpUnnumbered(false);
 280             lIf.setInMaint(false);
 281             if (oobMgtNetIds != null && oobMgtNetIds.contains(port.getNetworkId())) {
 282                 lIf.setInterfaceRole(OOB_MGT_NETWORK_IDENTIFIER);
 283             } else {
 284                 lIf.setInterfaceRole(port.getvNicType());
 285             }
 286             boolean isL2Multicast = false;
 287             if (port.getProfile().get("trusted") != null) {
 288                 String trusted = port.getProfile().get("trusted").toString();
 289                 if (Boolean.parseBoolean(trusted)) {
 290                     isL2Multicast = true;
 291                 }
 292             }
 293             lIf.setL2Multicasting(isL2Multicast);
 294             updateLInterfaceIps(port, lIf);
 295             if (cloudOwner.equals(env.getProperty("mso.cloudOwner.included", ""))) {
 296                 updateLInterfaceVlan(port, lIf);
 297             }
 298
 299             // Update l-interface to the vserver
 300             transaction.create(AAIUriFactory.createResourceUri(AAIObjectType.L_INTERFACE, cloudOwner, cloudRegionId,
 301                     tenantId, port.getDeviceId(), lIf.getInterfaceName()), lIf);
 302
 303             updateSriovPfToPserver(port, lIf);
 304         }
 305     }
 306
 307     @Override
 308     public void createPserversAndPinterfacesIfNotPresentInAai(final List<Resource> stackResources)
 309             throws HeatBridgeException {
 310         if (stackResources == null) {
 311             return;
 312         }
 313         Map<String, Pserver> serverHostnames = getPserverMapping(stackResources);
 314         createPServerIfNotExists(serverHostnames);
 315         List<String> portIds =
 316                 extractStackResourceIdsByResourceType(stackResources, HeatBridgeConstants.OS_PORT_RESOURCE_TYPE);
 317         for (String portId : portIds) {
 318             Port port = osClient.getPortById(portId);
 319             if (port.getvNicType().equalsIgnoreCase(HeatBridgeConstants.OS_SRIOV_PORT_TYPE)) {
 320                 createPServerPInterfaceIfNotExists(serverHostnames.get(port.getHostId()).getHostname(),
 321                         aaiHelper.buildPInterface(port));
 322             }
 323         }
 324     }
 325
 326     private Map<String, Pserver> getPserverMapping(final List<Resource> stackResources) {
 327         List<Server> osServers = getAllOpenstackServers(stackResources);
 328         Map<String, Pserver> pserverMap = new HashMap<>();
 329         if (osServers != null) {
 330             for (Server server : osServers) {
 331                 Pserver pserver = aaiHelper.buildPserver(server);
 332                 if (pserver != null) {
 333                     pserverMap.put(server.getHost(), pserver);
 334                 }
 335             }
 336         }
 337         return pserverMap;
 338     }
 339
 340     private void createPServerIfNotExists(Map<String, Pserver> serverHostnames) {
 341         for (Pserver pserver : serverHostnames.values()) {
 342             AAIResourceUri uri = AAIUriFactory.createResourceUri(AAIObjectType.PSERVER, pserver.getHostname());
 343             resourcesClient.createIfNotExists(uri, Optional.of(pserver));
 344         }
 345     }
 346
 347     private void createPServerPInterfaceIfNotExists(String pserverHostname, PInterface pInterface) {
 348         AAIResourceUri uri = AAIUriFactory.createResourceUri(AAIObjectType.P_INTERFACE, pserverHostname,
 349                 pInterface.getInterfaceName());
 350         resourcesClient.createIfNotExists(uri, Optional.of(pInterface));
 351     }
 352
 353     private void updateLInterfaceVlan(final Port port, final LInterface lIf) {
 354         Vlan vlan = new Vlan();
 355         Network network = osClient.getNetworkById(port.getNetworkId());
 356         if (network.getNetworkType() != null && network.getNetworkType().equals(NetworkType.VLAN)) {
 357             vlan.setVlanInterface(port.getName() + network.getProviderSegID());
 358             vlan.setVlanIdOuter(Long.parseLong(network.getProviderSegID()));
 359             vlan.setVlanIdInner(0L);
 360             vlan.setInMaint(false);
 361             vlan.setIsIpUnnumbered(false);
 362             vlan.setIsPrivate(false);
 363             Vlans vlans = new Vlans();
 364             List<Vlan> vlanList = vlans.getVlan();
 365             vlanList.add(vlan);
 366             lIf.setVlans(vlans);
 367         }
 368         // Build sriov-vf to the l-interface
 369         if (port.getvNicType() != null && port.getvNicType().equalsIgnoreCase(HeatBridgeConstants.OS_SRIOV_PORT_TYPE)) {
 370             SriovVfs sriovVfs = new SriovVfs();
 371             // JAXB does not generate setters for list, however getter ensures its creation.
 372             // Thus, all list manipulations must be made on live list.
 373             List<SriovVf> sriovVfList = sriovVfs.getSriovVf();
 374             SriovVf sriovVf = new SriovVf();
 375             sriovVf.setPciId(port.getProfile().get(HeatBridgeConstants.OS_PCI_SLOT_KEY).toString());
 376             sriovVf.setNeutronNetworkId(port.getNetworkId());
 377             sriovVf.setVfVlanFilter("0");
 378             sriovVf.setVfVlanAntiSpoofCheck(false);
 379             sriovVf.setVfMacAntiSpoofCheck(false);
 380             sriovVfList.add(sriovVf);
 381
 382             lIf.setSriovVfs(sriovVfs);
 383         }
 384     }
 385
 386     /**
 387      * Needs to be corrected according to the specification that is in draft If pserver/p-interface does not have a
 388      * SRIOV-PF object matching the PCI-ID of the Openstack port object, then create it in AAI. Openstack SRIOV Port
 389      * object has pci-id (to match sriov-pf on pserver/p-interface), physical-network ID (that matches the p-interface
 390      * name).
 391      *
 392      * @param port Openstack port object
 393      * @param lIf AAI l-interface object
 394      */
 395     private void updateSriovPfToPserver(final Port port, final LInterface lIf) {
 396         if (port.getvNicType().equalsIgnoreCase(HeatBridgeConstants.OS_SRIOV_PORT_TYPE)) {
 397             if (port.getProfile() == null || Strings
 398                     .isNullOrEmpty(port.getProfile().get(HeatBridgeConstants.OS_PHYSICAL_NETWORK_KEY).toString())) {
 399                 logger.debug("The SRIOV port:" + port.getName() + " is missing physical-network-id, cannot update "
 400                         + "sriov-pf object for host pserver: " + port.getHostId());
 401                 return;
 402             }
 403             Optional<String> matchingPifName = HeatBridgeUtils.getMatchingPserverPifName(
 404                     port.getProfile().get(HeatBridgeConstants.OS_PHYSICAL_NETWORK_KEY).toString());
 405             if (matchingPifName.isPresent()) {
 406                 // Update l-interface description
 407                 String pserverHostName = port.getHostId();
 408                 lIf.setInterfaceDescription(
 409                         "Attached to SR-IOV port: " + pserverHostName + "::" + matchingPifName.get());
 410                 try {
 411                     Optional<PInterface> matchingPIf = resourcesClient.get(PInterface.class, AAIUriFactory
 412                             .createResourceUri(AAIObjectType.P_INTERFACE, pserverHostName, matchingPifName.get())
 413                             .depth(Depth.ONE));
 414                     if (matchingPIf.isPresent()) {
 415                         SriovPfs pIfSriovPfs = matchingPIf.get().getSriovPfs();
 416                         if (pIfSriovPfs == null) {
 417                             pIfSriovPfs = new SriovPfs();
 418                         }
 419                         // Extract PCI-ID from OS port object
 420                         String pfPciId = port.getProfile().get(HeatBridgeConstants.OS_PCI_SLOT_KEY).toString();
 421
 422                         List<SriovPf> existingSriovPfs = pIfSriovPfs.getSriovPf();
 423                         if (CollectionUtils.isEmpty(existingSriovPfs) || existingSriovPfs.stream()
 424                                 .noneMatch(existingSriovPf -> existingSriovPf.getPfPciId().equals(pfPciId))) {
 425                             // Add sriov-pf object with PCI-ID to AAI
 426                             SriovPf sriovPf = new SriovPf();
 427                             sriovPf.setPfPciId(pfPciId);
 428                             logger.debug("Queuing AAI command to update sriov-pf object to pserver: " + pserverHostName
 429                                     + "/" + matchingPifName.get());
 430
 431                             AAIResourceUri sriovPfUri = AAIUriFactory.createResourceUri(AAIObjectType.SRIOV_PF,
 432                                     pserverHostName, matchingPifName.get(), sriovPf.getPfPciId());
 433
 434                             transaction.create(sriovPfUri, sriovPf);
 435
 436                             AAIResourceUri sriovVfUri = AAIUriFactory.createResourceUri(AAIObjectType.SRIOV_VF,
 437                                     cloudOwner, cloudRegionId, tenantId, port.getDeviceId(), lIf.getInterfaceName(),
 438                                     port.getProfile().get(HeatBridgeConstants.OS_PCI_SLOT_KEY).toString());
 439
 440                             transaction.connect(sriovPfUri, sriovVfUri);
 441                         }
 442                     }
 443                 } catch (WebApplicationException e) {
 444                     // Silently log that we failed to update the Pserver p-interface with PCI-ID
 445                     logger.error(LoggingAnchor.NINE, MessageEnum.GENERAL_EXCEPTION, pserverHostName,
 446                             matchingPifName.get(), cloudOwner, tenantId, "OpenStack", "Heatbridge",
 447                             ErrorCode.DataError.getValue(), "Exception - Failed to add sriov-pf object to pserver", e);
 448                 }
 449             }
 450         }
 451     }
 452
 453     private void updateLInterfaceIps(final Port port, final LInterface lIf) {
 454         List<L3InterfaceIpv4AddressList> lInterfaceIps = lIf.getL3InterfaceIpv4AddressList();
 455         for (IP ip : port.getFixedIps()) {
 456             String ipAddress = ip.getIpAddress();
 457             if (InetAddressValidator.getInstance().isValidInet4Address(ipAddress)) {
 458                 Subnet subnet = osClient.getSubnetById(ip.getSubnetId());
 459                 IPAddressString cidr = new IPAddressString(subnet.getCidr());
 460                 L3InterfaceIpv4AddressList lInterfaceIp = new L3InterfaceIpv4AddressList();
 461                 lInterfaceIp.setL3InterfaceIpv4Address(ipAddress);
 462                 lInterfaceIp.setNeutronNetworkId(port.getNetworkId());
 463                 lInterfaceIp.setNeutronSubnetId(ip.getSubnetId());
 464                 lInterfaceIp.setL3InterfaceIpv4PrefixLength(Long.parseLong(cidr.getNetworkPrefixLength().toString()));
 465                 lInterfaceIps.add(lInterfaceIp);
 466             }
 467         }
 468     }
 469
 470     @Override
 471     public void submitToAai(boolean dryrun) throws HeatBridgeException {
 472         try {
 473             transaction.execute(dryrun);
 474         } catch (BulkProcessFailed e) {
 475             String msg = "Failed to commit transaction";
 476             logger.debug(msg + " with error: " + e);
 477             throw new HeatBridgeException(msg, e);
 478         }
 479     }
 480
 481     @Override
 482     public void deleteVfModuleData(@Nonnull final String vnfId, @Nonnull final String vfModuleId)
 483             throws HeatBridgeException {
 484         Objects.requireNonNull(vnfId, "Null vnf-id!");
 485         Objects.requireNonNull(vfModuleId, "Null vf-module-id!");
 486         try {
 487             Optional<VfModule> vfModule = resourcesClient.get(
 488                     AAIUriFactory.createResourceUri(AAIObjectType.VF_MODULE, vnfId, vfModuleId, NotFoundException.class)
 489                             .depth(Depth.ONE))
 490                     .asBean(VfModule.class);
 491
 492             AAIResultWrapper resultWrapper = new AAIResultWrapper(vfModule.get());
 493             Optional<Relationships> relationships = resultWrapper.getRelationships();
 494             logger.debug("VfModule contains relationships in AAI: {}", relationships.isPresent());
 495             if (relationships.isPresent()) {
 496                 List<AAIResourceUri> vserverUris = relationships.get().getRelatedUris(AAIObjectType.VSERVER);
 497                 logger.debug("VServer contains {} relationships in AAI", vserverUris.size());
 498                 createTransactionToDeleteSriovPfFromPserver(vserverUris);
 499
 500                 if (!vserverUris.isEmpty()) {
 501                     for (AAIResourceUri vserverUri : vserverUris) {
 502                         if (env.getProperty("heatBridgeDryrun", Boolean.class, true)) {
 503                             logger.debug("Would delete Vserver: {}", vserverUri.build().toString());
 504                         } else {
 505                             resourcesClient.delete(vserverUri);
 506                         }
 507                     }
 508                 }
 509             }
 510
 511         } catch (NotFoundException e) {
 512             String msg = "Failed to commit delete heatbridge data transaction";
 513             logger.debug(msg + " with error: " + e);
 514             throw new HeatBridgeException(msg, e);
 515         } catch (Exception e) {
 516             String msg = "Failed to commit delete heatbridge data transaction";
 517             logger.debug(msg + " with error: " + e);
 518             throw new HeatBridgeException(msg, e);
 519         }
 520     }
 521
 522     private void createTransactionToDeleteSriovPfFromPserver(List<AAIResourceUri> vserverUris) {
 523         Map<String, List<String>> pserverToPciIdMap = getPserverToPciIdMap(vserverUris);
 524         for (Map.Entry<String, List<String>> entry : pserverToPciIdMap.entrySet()) {
 525             String pserverName = entry.getKey();
 526             List<String> pciIds = entry.getValue();
 527             Optional<Pserver> pserver = resourcesClient.get(Pserver.class,
 528                     AAIUriFactory.createResourceUri(AAIObjectType.PSERVER, pserverName).depth(Depth.TWO));
 529             if (pserver.isPresent()) {
 530                 // For each pserver/p-interface match sriov-vfs by pic-id and delete them.
 531                 pserver.get().getPInterfaces().getPInterface().stream().filter(
 532                         pIf -> pIf.getSriovPfs() != null && CollectionUtils.isNotEmpty(pIf.getSriovPfs().getSriovPf()))
 533                         .forEach(pIf -> pIf.getSriovPfs().getSriovPf().forEach(sriovPf -> {
 534                             if (pciIds.contains(sriovPf.getPfPciId())) {
 535                                 logger.debug("creating transaction to delete SR-IOV PF: " + pIf.getInterfaceName()
 536                                         + " from PServer: " + pserverName);
 537                                 if (env.getProperty("heatBridgeDryrun", Boolean.class, true)) {
 538                                     logger.debug("Would delete Sriov Pf: {}",
 539                                             AAIUriFactory
 540                                                     .createResourceUri(AAIObjectType.SRIOV_PF, pserverName,
 541                                                             pIf.getInterfaceName(), sriovPf.getPfPciId())
 542                                                     .build().toString());
 543                                 } else {
 544                                     resourcesClient.delete(AAIUriFactory.createResourceUri(AAIObjectType.SRIOV_PF,
 545                                             pserverName, pIf.getInterfaceName(), sriovPf.getPfPciId()));
 546                                 }
 547                             }
 548                         }));
 549             }
 550         }
 551     }
 552
 553     private Map<String, List<String>> getPserverToPciIdMap(List<AAIResourceUri> vserverUris) {
 554         Map<String, List<String>> pserverToPciIdMap = new HashMap<>();
 555         for (AAIResourceUri vserverUri : vserverUris) {
 556             AAIResultWrapper vserverWrapper = resourcesClient.get(vserverUri.depth(Depth.TWO));
 557             Optional<Relationships> vserverRelationships = vserverWrapper.getRelationships();
 558             if (vserverRelationships.isPresent()
 559                     && CollectionUtils.isNotEmpty(vserverRelationships.get().getRelatedLinks(AAIObjectType.PSERVER))) {
 560                 Vserver vserver = vserverWrapper.asBean(Vserver.class).get();
 561                 List<String> pciIds = HeatBridgeUtils.extractPciIdsFromVServer(vserver);
 562                 if (CollectionUtils.isNotEmpty(pciIds)) {
 563                     List<String> matchingPservers = vserverRelationships.get().getRelatedLinks(AAIObjectType.PSERVER);
 564                     if (matchingPservers != null && matchingPservers.size() == 1) {
 565                         pserverToPciIdMap.put(matchingPservers.get(0), pciIds);
 566                     }
 567                 }
 568             }
 569         }
 570         return pserverToPciIdMap;
 571     }
 572
 573     private <T> Predicate<T> distinctByProperty(Function<? super T, Object> keyExtractor) {
 574         Map<Object, Boolean> map = new ConcurrentHashMap<>();
 575         return t -> map.putIfAbsent(keyExtractor.apply(t), Boolean.TRUE) == null;
 576     }
 577 }