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

   1 /*
   2  * Copyright (C) 2018 Bell Canada.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
   5  * the License. You may obtain a copy of the License at
   6  *
   7  * http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
  10  * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
  11  * specific language governing permissions and limitations under the License.
  12  */
  13 package org.onap.so.heatbridge.helpers;
  14
  15 import com.google.common.base.Preconditions;
  16 import com.google.common.collect.ImmutableMap;
  17 import java.util.ArrayList;
  18 import java.util.Collection;
  19 import java.util.HashMap;
  20 import java.util.List;
  21 import java.util.Map;
  22 import java.util.stream.Collectors;
  23 import org.apache.commons.collections.CollectionUtils;
  24 import org.onap.aai.domain.yang.Flavor;
  25 import org.onap.aai.domain.yang.Image;
  26 import org.onap.aai.domain.yang.Relationship;
  27 import org.onap.aai.domain.yang.RelationshipData;
  28 import org.onap.aai.domain.yang.RelationshipList;
  29 import org.onap.aai.domain.yang.SriovVf;
  30 import org.onap.aai.domain.yang.Vserver;
  31 import org.onap.so.heatbridge.constants.HeatBridgeConstants;
  32 import org.openstack4j.model.compute.Server;
  33
  34 /**
  35  * This class provides wrapper methods to manage creation of AAI objects and extracting objects from AAI and
  36  * transforming into required objects.
  37  */
  38 public class AaiHelper {
  39
  40     /**
  41      * Build vserver relationship object to entities: pserver, vf-module, image, flavor
  42      *
  43      * @param cloudOwner AAI cloudOwner value
  44      * @param cloudRegionId AAI cloud-region identifier
  45      * @param genericVnfId AAI generic-vnf identifier
  46      * @param vfModuleId AAI vf-module identifier
  47      * @param server Openstack Server object
  48      */
  49     public RelationshipList getVserverRelationshipList(final String cloudOwner, final String cloudRegionId,
  50             final String genericVnfId, final String vfModuleId, final Server server) {
  51         RelationshipList relationshipList = new RelationshipList();
  52         List<Relationship> relationships = relationshipList.getRelationship();
  53
  54         // vserver to pserver relationship
  55         Relationship pserverRelationship =
  56                 buildRelationship(HeatBridgeConstants.AAI_PSERVER, ImmutableMap.<String, String>builder()
  57                         .put(HeatBridgeConstants.AAI_PSERVER_HOSTNAME, server.getHypervisorHostname()).build());
  58         relationships.add(pserverRelationship);
  59
  60         // vserver to vf-module relationship
  61         Relationship vfModuleRelationship = buildRelationship(HeatBridgeConstants.AAI_VF_MODULE,
  62                 ImmutableMap.<String, String>builder().put(HeatBridgeConstants.AAI_GENERIC_VNF_ID, genericVnfId)
  63                         .put(HeatBridgeConstants.AAI_VF_MODULE_ID, vfModuleId).build());
  64         relationships.add(vfModuleRelationship);
  65
  66         // vserver to image relationship
  67         Relationship imageRel = buildRelationship(HeatBridgeConstants.AAI_IMAGE,
  68                 ImmutableMap.<String, String>builder().put(HeatBridgeConstants.AAI_CLOUD_OWNER, cloudOwner)
  69                         .put(HeatBridgeConstants.AAI_CLOUD_REGION_ID, cloudRegionId)
  70                         .put(HeatBridgeConstants.AAI_IMAGE_ID, server.getImage().getId()).build());
  71         relationships.add(imageRel);
  72
  73         // vserver to flavor relationship
  74         Relationship flavorRel = buildRelationship(HeatBridgeConstants.AAI_FLAVOR,
  75                 ImmutableMap.<String, String>builder().put(HeatBridgeConstants.AAI_CLOUD_OWNER, cloudOwner)
  76                         .put(HeatBridgeConstants.AAI_CLOUD_REGION_ID, cloudRegionId)
  77                         .put(HeatBridgeConstants.AAI_FLAVOR_ID, server.getFlavor().getId()).build());
  78         relationships.add(flavorRel);
  79         return relationshipList;
  80     }
  81
  82     public RelationshipList getLInterfaceRelationshipList(final String pserverName, final String pIfName,
  83             final String pfPciId) {
  84         RelationshipList relationshipList = new RelationshipList();
  85         List<Relationship> relationships = relationshipList.getRelationship();
  86
  87         // sriov-vf to sriov-pf relationship
  88         Relationship sriovPfRelationship = buildRelationship(HeatBridgeConstants.AAI_SRIOV_PF,
  89                 ImmutableMap.<String, String>builder().put(HeatBridgeConstants.AAI_PSERVER_HOSTNAME, pserverName)
  90                         .put(HeatBridgeConstants.AAI_P_INTERFACE_NAME, pIfName)
  91                         .put(HeatBridgeConstants.AAI_SRIOV_PF_PCI_ID, pfPciId).build());
  92         relationships.add(sriovPfRelationship);
  93
  94         return relationshipList;
  95     }
  96
  97     /**
  98      * Transform Openstack Server object to AAI Vserver object
  99      *
 100      * @param serverId Openstack server identifier
 101      * @param server Openstack server object
 102      * @return AAI Vserver object
 103      */
 104     public Vserver buildVserver(final String serverId, final Server server) {
 105         Vserver vserver = new Vserver();
 106         vserver.setInMaint(false);
 107         vserver.setIsClosedLoopDisabled(false);
 108         vserver.setVserverId(serverId);
 109         vserver.setVserverName(server.getName());
 110         vserver.setVserverName2(server.getName());
 111         vserver.setProvStatus(server.getStatus().value());
 112         server.getLinks().stream().filter(link -> link.getRel().equals(HeatBridgeConstants.OS_RESOURCES_SELF_LINK_KEY))
 113                 .findFirst().ifPresent(link -> vserver.setVserverSelflink(link.getHref()));
 114         return vserver;
 115     }
 116
 117     /**
 118      * Transform Openstack Image object to AAI Image object
 119      *
 120      * @param image Openstack Image object
 121      * @return AAI Image object
 122      */
 123     public Image buildImage(final org.openstack4j.model.compute.Image image) {
 124         Image aaiImage = new Image();
 125         aaiImage.setImageId(image.getId());
 126         aaiImage.setImageName(image.getName());
 127         aaiImage.setImageOsDistro(HeatBridgeConstants.OS_UNKNOWN_KEY);
 128         aaiImage.setImageOsVersion(HeatBridgeConstants.OS_UNKNOWN_KEY);
 129         image.getLinks().stream().filter(link -> link.getRel().equals(HeatBridgeConstants.OS_RESOURCES_SELF_LINK_KEY))
 130                 .findFirst().ifPresent(link -> aaiImage.setImageSelflink(link.getHref()));
 131         return aaiImage;
 132     }
 133
 134     /**
 135      * Transform Openstack Flavor object to AAI Flavor object
 136      *
 137      * @param flavor Openstack Flavor object
 138      * @return AAI Flavor object
 139      */
 140     public Flavor buildFlavor(final org.openstack4j.model.compute.Flavor flavor) {
 141         Flavor aaiFlavor = new Flavor();
 142         aaiFlavor.setFlavorId(flavor.getId());
 143         aaiFlavor.setFlavorName(flavor.getName());
 144         flavor.getLinks().stream().filter(link -> link.getRel().equals(HeatBridgeConstants.OS_RESOURCES_SELF_LINK_KEY))
 145                 .findFirst().ifPresent(link -> aaiFlavor.setFlavorSelflink(link.getHref()));
 146         return aaiFlavor;
 147     }
 148
 149     /**
 150      * Extract a list of flavors URI associated with the list of vservers
 151      *
 152      * @param vservers List of vserver AAI objects
 153      * @return a list of related flavor related-links
 154      */
 155     public List<String> getFlavorsUriFromVserver(final List<Vserver> vservers) {
 156         List<String> flavorUris = new ArrayList<>();
 157         vservers.forEach(vserver -> flavorUris.addAll(
 158                 filterRelatedLinksByRelatedToProperty(vserver.getRelationshipList(), HeatBridgeConstants.AAI_FLAVOR)));
 159         return flavorUris;
 160     }
 161
 162     /**
 163      * Extract a list of images URI associated with the list of vservers
 164      *
 165      * @param vservers List of vserver AAI objects
 166      * @return a list of related image related-links
 167      */
 168     public List<String> getImagesUriFromVserver(final List<Vserver> vservers) {
 169         List<String> imageUris = new ArrayList<>();
 170         vservers.forEach(vserver -> imageUris.addAll(
 171                 filterRelatedLinksByRelatedToProperty(vserver.getRelationshipList(), HeatBridgeConstants.AAI_IMAGE)));
 172         return imageUris;
 173     }
 174
 175     /**
 176      * From the list vserver objects build a map of compute hosts's name and the PCI IDs linked to it.
 177      *
 178      * @param vservers List of vserver AAI objects
 179      * @return a map of compute names to the PCI ids associated with the compute
 180      */
 181     public Map<String, List<String>> getPserverToPciIdMap(final List<Vserver> vservers) {
 182         Map<String, List<String>> pserverToPciIdMap = new HashMap<>();
 183         for (Vserver vserver : vservers) {
 184             if (vserver.getLInterfaces() != null) {
 185                 List<String> pciIds = vserver.getLInterfaces().getLInterface().stream()
 186                         .filter(lInterface -> lInterface.getSriovVfs() != null
 187                                 && CollectionUtils.isNotEmpty(lInterface.getSriovVfs().getSriovVf()))
 188                         .flatMap(lInterface -> lInterface.getSriovVfs().getSriovVf().stream()).map(SriovVf::getPciId)
 189                         .collect(Collectors.toList());
 190                 if (CollectionUtils.isNotEmpty(pciIds)) {
 191                     List<String> matchingPservers = extractRelationshipDataValue(vserver.getRelationshipList(),
 192                             HeatBridgeConstants.AAI_PSERVER, HeatBridgeConstants.AAI_PSERVER_HOSTNAME);
 193                     Preconditions.checkState(matchingPservers != null && matchingPservers.size() == 1,
 194                             "Invalid pserver relationships for vserver: " + vserver.getVserverName());
 195                     pserverToPciIdMap.put(matchingPservers.get(0), pciIds);
 196                 }
 197             }
 198         }
 199         return pserverToPciIdMap;
 200     }
 201
 202     /**
 203      * Extract from relationship-list object all the relationship-value that match the related-to and relationship-key
 204      * fields.
 205      *
 206      * @param relationshipListObj AAI relationship-list object
 207      * @param relatedToProperty related-to value
 208      * @param relationshipKey relationship-key value
 209      * @return relationship-value matching the key requested for the relationship object of type related-to property
 210      */
 211     private List<String> extractRelationshipDataValue(final RelationshipList relationshipListObj,
 212             final String relatedToProperty, final String relationshipKey) {
 213         if (relationshipListObj != null && relationshipListObj.getRelationship() != null) {
 214             return relationshipListObj.getRelationship().stream()
 215                     .filter(relationship -> relationship.getRelatedTo().equals(relatedToProperty))
 216                     .map(Relationship::getRelationshipData).flatMap(Collection::stream)
 217                     .filter(data -> data.getRelationshipKey() != null
 218                             && relationshipKey.equals(data.getRelationshipKey()))
 219                     .map(RelationshipData::getRelationshipValue).collect(Collectors.toList());
 220         }
 221         return new ArrayList<>();
 222     }
 223
 224     /**
 225      * Extract and filter the related-links to all objects that match the type specified by the filter property
 226      *
 227      * @param relationshipListObj AAI object representing relationship object
 228      * @param relatedToProperty Value identifying the type of AAI object for related-to field
 229      * @return a list of related-links filtered by the specified related-to property
 230      */
 231     private List<String> filterRelatedLinksByRelatedToProperty(final RelationshipList relationshipListObj,
 232             final String relatedToProperty) {
 233         if (relationshipListObj != null && relationshipListObj.getRelationship() != null) {
 234             return relationshipListObj.getRelationship().stream()
 235                     .filter(relationship -> relationship.getRelatedTo().equals(relatedToProperty))
 236                     .map(Relationship::getRelatedLink).collect(Collectors.toList());
 237         }
 238         return new ArrayList<>();
 239     }
 240
 241     /**
 242      * Build the relationship object
 243      *
 244      * @param relatedTo Related to entity value
 245      * @param relationshipKeyValues Key value pairs of relationship data
 246      * @return AAI Relationship object
 247      */
 248     private Relationship buildRelationship(final String relatedTo, final Map<String, String> relationshipKeyValues) {
 249         Relationship relationship = new Relationship();
 250         relationship.setRelatedTo(relatedTo);
 251         relationshipKeyValues.keySet().forEach(k -> {
 252             RelationshipData relationshipData = new RelationshipData();
 253             relationshipData.setRelationshipKey(k);
 254             relationshipData.setRelationshipValue(relationshipKeyValues.get(k));
 255             relationship.getRelationshipData().add(relationshipData);
 256         });
 257         return relationship;
 258     }
 259 }