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