gerrit.onap Code Review - so.git/blob

   1 package org.onap.so.apihandlerinfra.infra.rest;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collection;
   5 import java.util.List;
   6 import java.util.Optional;
   7 import java.util.stream.Collectors;
   8 import org.onap.aai.domain.yang.GenericVnf;
   9 import org.onap.aai.domain.yang.L3Network;
  10 import org.onap.aai.domain.yang.LInterface;
  11 import org.onap.aai.domain.yang.Service;
  12 import org.onap.aai.domain.yang.ServiceInstance;
  13 import org.onap.aai.domain.yang.Tenant;
  14 import org.onap.aai.domain.yang.VfModule;
  15 import org.onap.aai.domain.yang.VfModules;
  16 import org.onap.aai.domain.yang.VolumeGroup;
  17 import org.onap.aai.domain.yang.VolumeGroups;
  18 import org.onap.so.apihandlerinfra.infra.rest.exception.AAIEntityNotFound;
  19 import org.onap.aaiclient.client.aai.AAIDSLQueryClient;
  20 import org.onap.aaiclient.client.aai.AAIObjectPlurals;
  21 import org.onap.aaiclient.client.aai.AAIObjectType;
  22 import org.onap.aaiclient.client.aai.AAIResourcesClient;
  23 import org.onap.aaiclient.client.aai.entities.AAIResultWrapper;
  24 import org.onap.aaiclient.client.aai.entities.uri.AAIPluralResourceUri;
  25 import org.onap.aaiclient.client.aai.entities.uri.AAIUriFactory;
  26 import org.onap.aaiclient.client.graphinventory.entities.DSLQuery;
  27 import org.onap.aaiclient.client.graphinventory.entities.DSLQueryBuilder;
  28 import org.onap.aaiclient.client.graphinventory.entities.DSLStartNode;
  29 import org.onap.aaiclient.client.graphinventory.entities.Node;
  30 import org.onap.aaiclient.client.graphinventory.entities.Start;
  31 import org.onap.aaiclient.client.graphinventory.entities.TraversalBuilder;
  32 import org.onap.aaiclient.client.graphinventory.entities.__;
  33 import org.slf4j.Logger;
  34 import org.slf4j.LoggerFactory;
  35 import org.springframework.stereotype.Component;
  36
  37 @Component
  38 public class AAIDataRetrieval {
  39
  40     private static final String VF_MODULE_NOT_FOUND_IN_INVENTORY_VNF_ID = "VF Module Not Found In Inventory, VnfId: ";
  41
  42     private AAIResourcesClient aaiResourcesClient;
  43
  44     private AAIDSLQueryClient aaiDslQueryClient;
  45
  46     private static final Logger logger = LoggerFactory.getLogger(AAIDataRetrieval.class);
  47
  48     public ServiceInstance getServiceInstance(String serviceInstanceId) {
  49         return this.getAaiResourcesClient()
  50                 .get(ServiceInstance.class,
  51                         AAIUriFactory.createResourceUri(AAIObjectType.SERVICE_INSTANCE, serviceInstanceId))
  52                 .orElseGet(() -> {
  53                     logger.debug("No Service Instance found in A&AI ServiceInstanceId: {}", serviceInstanceId);
  54                     return null;
  55                 });
  56     }
  57
  58     public VfModule getAAIVfModule(String vnfId, String vfModuleId) {
  59         return this.getAaiResourcesClient()
  60                 .get(VfModule.class, AAIUriFactory.createResourceUri(AAIObjectType.VF_MODULE, vnfId, vfModuleId))
  61                 .orElseGet(() -> {
  62                     logger.debug("No Vf Module found in A&AI VnfId: {}" + ", VfModuleId: {}", vnfId, vfModuleId);
  63                     return null;
  64                 });
  65     }
  66
  67     public GenericVnf getGenericVnf(String vnfId) {
  68         return this.getAaiResourcesClient()
  69                 .get(GenericVnf.class, AAIUriFactory.createResourceUri(AAIObjectType.GENERIC_VNF, vnfId))
  70                 .orElseGet(() -> {
  71                     logger.debug("No Generic VNF found in A&AI VnfId: {}", vnfId);
  72                     return null;
  73                 });
  74     }
  75
  76     public VolumeGroup getVolumeGroup(String vnfId, String volumeGroupId) throws AAIEntityNotFound {
  77         AAIResultWrapper wrapper =
  78                 this.getAaiResourcesClient().get(AAIUriFactory.createResourceUri(AAIObjectType.GENERIC_VNF, vnfId)
  79                         .relatedTo(AAIObjectType.VOLUME_GROUP, volumeGroupId));
  80         Optional<VolumeGroup> volume = wrapper.asBean(VolumeGroup.class);
  81         if (volume.isPresent()) {
  82             return volume.get();
  83         } else {
  84             logger.debug("No VolumeGroup in A&AI found: {}", vnfId);
  85             return null;
  86         }
  87     }
  88
  89     public L3Network getNetwork(String networkId) {
  90         return this.getAaiResourcesClient()
  91                 .get(L3Network.class, AAIUriFactory.createResourceUri(AAIObjectType.L3_NETWORK, networkId))
  92                 .orElseGet(() -> {
  93                     logger.debug("No Network found in A&AI NetworkId: {}", networkId);
  94                     return null;
  95                 });
  96     }
  97
  98
  99     public boolean isVolumeGroupRelatedToVFModule(String volumeGroupId) {
 100         return this.getAaiResourcesClient().exists(AAIUriFactory
 101                 .createResourceUri(AAIObjectType.VOLUME_GROUP, volumeGroupId).relatedTo(AAIObjectPlurals.VF_MODULE));
 102     }
 103
 104     public boolean isVnfRelatedToVolumes(String vnfId) {
 105         return this.getAaiResourcesClient().exists(AAIUriFactory.createResourceUri(AAIObjectType.GENERIC_VNF, vnfId)
 106                 .relatedTo(AAIObjectPlurals.VOLUME_GROUP));
 107     }
 108
 109     public boolean isNetworkRelatedToModules(String networkId) {
 110         return this.getAaiResourcesClient().exists(AAIUriFactory.createResourceUri(AAIObjectType.L3_NETWORK, networkId)
 111                 .relatedTo(AAIObjectPlurals.VF_MODULE));
 112     }
 113
 114     public boolean isServiceRelatedToNetworks(String serviceInstanceId) {
 115         return this.getAaiResourcesClient()
 116                 .exists(AAIUriFactory.createResourceUri(AAIObjectType.SERVICE_INSTANCE, serviceInstanceId)
 117                         .relatedTo(AAIObjectPlurals.L3_NETWORK));
 118     }
 119
 120     public boolean isServiceRelatedToGenericVnf(String serviceInstanceId) {
 121         return this.getAaiResourcesClient()
 122                 .exists(AAIUriFactory.createResourceUri(AAIObjectType.SERVICE_INSTANCE, serviceInstanceId)
 123                         .relatedTo(AAIObjectPlurals.GENERIC_VNF));
 124     }
 125
 126     public boolean isServiceRelatedToConfiguration(String serviceInstanceId) {
 127         return this.getAaiResourcesClient()
 128                 .exists(AAIUriFactory.createResourceUri(AAIObjectType.SERVICE_INSTANCE, serviceInstanceId)
 129                         .relatedTo(AAIObjectPlurals.CONFIGURATION));
 130     }
 131
 132     public Service getService(String serviceId) {
 133         return this.getAaiResourcesClient()
 134                 .get(Service.class, AAIUriFactory.createResourceUri(AAIObjectType.SERVICE, serviceId)).orElseGet(() -> {
 135                     logger.debug("No Service found in A&AI ServiceId: {}", serviceId);
 136                     return null;
 137                 });
 138     }
 139
 140     public Tenant getTenant(String cloudOwner, String cloudRegion, String tenantId) {
 141         return this.getAaiResourcesClient()
 142                 .get(Tenant.class,
 143                         AAIUriFactory.createResourceUri(AAIObjectType.TENANT, cloudOwner, cloudRegion, tenantId))
 144                 .orElseGet(() -> {
 145                     logger.debug("No Tenant found in A&AI TenantId: {}", tenantId);
 146                     return null;
 147                 });
 148     }
 149
 150     public List<LInterface> getLinterfacesOfVnf(String vnfId) {
 151         DSLStartNode startNode = new DSLStartNode(AAIObjectType.GENERIC_VNF, __.key("vnf-id", vnfId));
 152         DSLQueryBuilder<Start, Node> builder = TraversalBuilder.fragment(startNode)
 153                 .to(__.node(AAIObjectType.VSERVER).to(__.node(AAIObjectType.L_INTERFACE).output()));
 154         List<LInterface> linterfaces =
 155                 getAAIDSLQueryClient().querySingleResource(new DSLQuery(builder.build()), LInterface.class);
 156         return linterfaces;
 157     }
 158
 159     private AAIDSLQueryClient getAAIDSLQueryClient() {
 160         if (aaiDslQueryClient == null) {
 161             aaiDslQueryClient = new AAIDSLQueryClient();
 162         }
 163         return aaiDslQueryClient;
 164     }
 165
 166     protected AAIResourcesClient getAaiResourcesClient() {
 167         if (aaiResourcesClient == null) {
 168             aaiResourcesClient = new AAIResourcesClient();
 169         }
 170         return aaiResourcesClient;
 171     }
 172
 173     public boolean isVnfRelatedToVFModule(String vnfId) {
 174         return !getVfModulesOfVnf(vnfId).isEmpty();
 175     }
 176
 177     public List<VfModule> getVfModulesOfVnf(String vnfId) {
 178         List<VfModule> vfModuleList = new ArrayList<VfModule>();
 179         AAIPluralResourceUri uri = AAIUriFactory.createResourceUri(AAIObjectPlurals.VF_MODULE, vnfId);
 180         Optional<VfModules> vfModules = getAaiResourcesClient().get(VfModules.class, uri);
 181         if (!vfModules.isPresent() || vfModules.get().getVfModule().isEmpty()) {
 182             logger.debug("No VfModules attached to Vnf in AAI : {}", vnfId);
 183         } else {
 184             vfModuleList = vfModules.get().getVfModule();
 185         }
 186         return vfModuleList;
 187     }
 188
 189     public Optional<String> getVfModuleIdsByVnfId(String vnfId) {
 190         List<VfModule> vfModulesList = getVfModulesOfVnf(vnfId);
 191         if (!vfModulesList.isEmpty()) {
 192             return Optional.of(vfModulesList.stream().map(item -> item.getVfModuleId()).collect(Collectors.toList())
 193                     .stream().sorted().collect(Collectors.joining(",")));
 194         } else {
 195             return Optional.empty();
 196         }
 197     }
 198
 199     public List<VolumeGroup> getVolumeGroupsOfVnf(String vnfId) {
 200         List<VolumeGroup> volumeGroupList = new ArrayList<VolumeGroup>();
 201         AAIPluralResourceUri uri = AAIUriFactory.createResourceUri(AAIObjectType.GENERIC_VNF, vnfId)
 202                 .relatedTo(AAIObjectPlurals.VOLUME_GROUP);
 203         Optional<VolumeGroups> volumeGroups = getAaiResourcesClient().get(VolumeGroups.class, uri);
 204         if (!volumeGroups.isPresent() || volumeGroups.get().getVolumeGroup().isEmpty()) {
 205             logger.debug("No VolumeGroups attached to Vnf in AAI : {}", vnfId);
 206         } else {
 207             volumeGroupList = volumeGroups.get().getVolumeGroup();
 208         }
 209         return volumeGroupList;
 210     }
 211
 212     public Optional<String> getVolumeGroupIdsByVnfId(String vnfId) {
 213         List<VolumeGroup> volumeGroupList = getVolumeGroupsOfVnf(vnfId);
 214         if (!volumeGroupList.isEmpty()) {
 215             return Optional.of(volumeGroupList.stream().map(item -> item.getVolumeGroupId())
 216                     .collect(Collectors.toList()).stream().sorted().collect(Collectors.joining(",")));
 217         } else {
 218             return Optional.empty();
 219         }
 220     }
 221 }