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.List;
   5 import java.util.Optional;
   6 import java.util.stream.Collectors;
   7 import org.onap.aai.domain.yang.GenericVnf;
   8 import org.onap.aai.domain.yang.L3Network;
   9 import org.onap.aai.domain.yang.LInterface;
  10 import org.onap.aai.domain.yang.Service;
  11 import org.onap.aai.domain.yang.ServiceInstance;
  12 import org.onap.aai.domain.yang.Tenant;
  13 import org.onap.aai.domain.yang.VfModule;
  14 import org.onap.aai.domain.yang.VfModules;
  15 import org.onap.aai.domain.yang.VolumeGroup;
  16 import org.onap.aai.domain.yang.VolumeGroups;
  17 import org.onap.aaiclient.client.aai.AAIDSLQueryClient;
  18 import org.onap.aaiclient.client.aai.AAIResourcesClient;
  19 import org.onap.aaiclient.client.aai.entities.AAIResultWrapper;
  20 import org.onap.aaiclient.client.aai.entities.uri.AAIPluralResourceUri;
  21 import org.onap.aaiclient.client.aai.entities.uri.AAIUriFactory;
  22 import org.onap.aaiclient.client.generated.fluentbuilders.AAIFluentTypeBuilder;
  23 import org.onap.aaiclient.client.generated.fluentbuilders.AAIFluentTypeBuilder.Types;
  24 import org.onap.aaiclient.client.graphinventory.entities.DSLQuery;
  25 import org.onap.aaiclient.client.graphinventory.entities.DSLQueryBuilder;
  26 import org.onap.aaiclient.client.graphinventory.entities.DSLStartNode;
  27 import org.onap.aaiclient.client.graphinventory.entities.Node;
  28 import org.onap.aaiclient.client.graphinventory.entities.Start;
  29 import org.onap.aaiclient.client.graphinventory.entities.TraversalBuilder;
  30 import org.onap.aaiclient.client.graphinventory.entities.__;
  31 import org.onap.so.apihandlerinfra.infra.rest.exception.AAIEntityNotFound;
  32 import org.onap.so.serviceinstancebeans.CloudConfiguration;
  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(Types.SERVICE_INSTANCE.getFragment(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,
  61                         AAIUriFactory.createResourceUri(
  62                                 AAIFluentTypeBuilder.network().genericVnf(vnfId).vfModule(vfModuleId)))
  63                 .orElseGet(() -> {
  64                     logger.debug("No Vf Module found in A&AI VnfId: {}" + ", VfModuleId: {}", vnfId, vfModuleId);
  65                     return null;
  66                 });
  67     }
  68
  69     public GenericVnf getGenericVnf(String vnfId) {
  70         return this.getAaiResourcesClient()
  71                 .get(GenericVnf.class,
  72                         AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().genericVnf(vnfId)))
  73                 .orElseGet(() -> {
  74                     logger.debug("No Generic VNF found in A&AI VnfId: {}", vnfId);
  75                     return null;
  76                 });
  77     }
  78
  79     public VolumeGroup getVolumeGroup(String vnfId, String volumeGroupId) throws AAIEntityNotFound {
  80         AAIResultWrapper wrapper = this.getAaiResourcesClient()
  81                 .get(AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().genericVnf(vnfId))
  82                         .relatedTo(Types.VOLUME_GROUP.getFragment(volumeGroupId)));
  83         Optional<VolumeGroup> volume = wrapper.asBean(VolumeGroup.class);
  84         if (volume.isPresent()) {
  85             return volume.get();
  86         } else {
  87             logger.debug("No VolumeGroup in A&AI found: {}", vnfId);
  88             return null;
  89         }
  90     }
  91
  92     public L3Network getNetwork(String networkId) {
  93         return this.getAaiResourcesClient()
  94                 .get(L3Network.class,
  95                         AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().l3Network(networkId)))
  96                 .orElseGet(() -> {
  97                     logger.debug("No Network found in A&AI NetworkId: {}", networkId);
  98                     return null;
  99                 });
 100     }
 101
 102
 103     public boolean isVolumeGroupRelatedToVFModule(CloudConfiguration cloudConfig, String volumeGroupId) {
 104         return this.getAaiResourcesClient()
 105                 .exists(AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.cloudInfrastructure()
 106                         .cloudRegion(cloudConfig.getCloudOwner(), cloudConfig.getLcpCloudRegionId())
 107                         .volumeGroup(volumeGroupId)).relatedTo(Types.VF_MODULES.getFragment()));
 108     }
 109
 110     public boolean isVnfRelatedToVolumes(String vnfId) {
 111         return this.getAaiResourcesClient()
 112                 .exists(AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().genericVnf(vnfId))
 113                         .relatedTo(Types.VOLUME_GROUPS.getFragment()));
 114     }
 115
 116     public boolean isNetworkRelatedToModules(String networkId) {
 117         return this.getAaiResourcesClient()
 118                 .exists(AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().l3Network(networkId))
 119                         .relatedTo(Types.VF_MODULES.getFragment()));
 120     }
 121
 122     public boolean isServiceRelatedToNetworks(String serviceInstanceId) {
 123         return this.getAaiResourcesClient()
 124                 .exists(AAIUriFactory.createResourceUri(Types.SERVICE_INSTANCE.getFragment(serviceInstanceId))
 125                         .relatedTo(Types.L3_NETWORKS.getFragment()));
 126     }
 127
 128     public boolean isServiceRelatedToGenericVnf(String serviceInstanceId) {
 129         return this.getAaiResourcesClient()
 130                 .exists(AAIUriFactory.createResourceUri(Types.SERVICE_INSTANCE.getFragment(serviceInstanceId))
 131                         .relatedTo(Types.GENERIC_VNFS.getFragment()));
 132     }
 133
 134     public boolean isServiceRelatedToConfiguration(String serviceInstanceId) {
 135         return this.getAaiResourcesClient()
 136                 .exists(AAIUriFactory.createResourceUri(Types.SERVICE_INSTANCE.getFragment(serviceInstanceId))
 137                         .relatedTo(Types.CONFIGURATIONS.getFragment()));
 138     }
 139
 140     public Service getService(String serviceId) {
 141         return this.getAaiResourcesClient()
 142                 .get(Service.class,
 143                         AAIUriFactory
 144                                 .createResourceUri(AAIFluentTypeBuilder.serviceDesignAndCreation().service(serviceId)))
 145                 .orElseGet(() -> {
 146                     logger.debug("No Service found in A&AI ServiceId: {}", serviceId);
 147                     return null;
 148                 });
 149     }
 150
 151     public Tenant getTenant(String cloudOwner, String cloudRegion, String tenantId) {
 152         return this.getAaiResourcesClient().get(Tenant.class, AAIUriFactory.createResourceUri(
 153                 AAIFluentTypeBuilder.cloudInfrastructure().cloudRegion(cloudOwner, cloudRegion).tenant(tenantId)))
 154                 .orElseGet(() -> {
 155                     logger.debug("No Tenant found in A&AI TenantId: {}", tenantId);
 156                     return null;
 157                 });
 158     }
 159
 160     public List<LInterface> getLinterfacesOfVnf(String vnfId) {
 161         DSLStartNode startNode = new DSLStartNode(Types.GENERIC_VNF, __.key("vnf-id", vnfId));
 162         DSLQueryBuilder<Start, Node> builder =
 163                 TraversalBuilder.fragment(startNode).to(__.node(Types.VSERVER).to(__.node(Types.L_INTERFACE).output()));
 164         List<LInterface> linterfaces =
 165                 getAAIDSLQueryClient().querySingleResource(new DSLQuery(builder.build()), LInterface.class);
 166         return linterfaces;
 167     }
 168
 169     private AAIDSLQueryClient getAAIDSLQueryClient() {
 170         if (aaiDslQueryClient == null) {
 171             aaiDslQueryClient = new AAIDSLQueryClient();
 172         }
 173         return aaiDslQueryClient;
 174     }
 175
 176     protected AAIResourcesClient getAaiResourcesClient() {
 177         if (aaiResourcesClient == null) {
 178             aaiResourcesClient = new AAIResourcesClient();
 179         }
 180         return aaiResourcesClient;
 181     }
 182
 183     public boolean isVnfRelatedToVFModule(String vnfId) {
 184         return !getVfModulesOfVnf(vnfId).isEmpty();
 185     }
 186
 187     public List<VfModule> getVfModulesOfVnf(String vnfId) {
 188         List<VfModule> vfModuleList = new ArrayList<VfModule>();
 189         AAIPluralResourceUri uri =
 190                 AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().genericVnf(vnfId).vfModules());
 191         Optional<VfModules> vfModules = getAaiResourcesClient().get(VfModules.class, uri);
 192         if (!vfModules.isPresent() || vfModules.get().getVfModule().isEmpty()) {
 193             logger.debug("No VfModules attached to Vnf in AAI : {}", vnfId);
 194         } else {
 195             vfModuleList = vfModules.get().getVfModule();
 196         }
 197         return vfModuleList;
 198     }
 199
 200     public Optional<String> getVfModuleIdsByVnfId(String vnfId) {
 201         List<VfModule> vfModulesList = getVfModulesOfVnf(vnfId);
 202         if (!vfModulesList.isEmpty()) {
 203             return Optional.of(vfModulesList.stream().map(item -> item.getVfModuleId()).collect(Collectors.toList())
 204                     .stream().sorted().collect(Collectors.joining(",")));
 205         } else {
 206             return Optional.empty();
 207         }
 208     }
 209
 210     public List<VolumeGroup> getVolumeGroupsOfVnf(String vnfId) {
 211         List<VolumeGroup> volumeGroupList = new ArrayList<VolumeGroup>();
 212         AAIPluralResourceUri uri = AAIUriFactory.createResourceUri(AAIFluentTypeBuilder.network().genericVnf(vnfId))
 213                 .relatedTo(Types.VOLUME_GROUPS.getFragment());
 214         Optional<VolumeGroups> volumeGroups = getAaiResourcesClient().get(VolumeGroups.class, uri);
 215         if (!volumeGroups.isPresent() || volumeGroups.get().getVolumeGroup().isEmpty()) {
 216             logger.debug("No VolumeGroups attached to Vnf in AAI : {}", vnfId);
 217         } else {
 218             volumeGroupList = volumeGroups.get().getVolumeGroup();
 219         }
 220         return volumeGroupList;
 221     }
 222
 223     public Optional<String> getVolumeGroupIdsByVnfId(String vnfId) {
 224         List<VolumeGroup> volumeGroupList = getVolumeGroupsOfVnf(vnfId);
 225         if (!volumeGroupList.isEmpty()) {
 226             return Optional.of(volumeGroupList.stream().map(item -> item.getVolumeGroupId())
 227                     .collect(Collectors.toList()).stream().sorted().collect(Collectors.joining(",")));
 228         } else {
 229             return Optional.empty();
 230         }
 231     }
 232 }