From 1cfb08779ea0e00be69e072a940b3063e049fe6b Mon Sep 17 00:00:00 2001 From: Ofir Sonsino Date: Wed, 31 Jan 2018 17:19:00 +0200 Subject: org.onap migration Change-Id: I52f0b2851f2c765752b6d21f49b32136d7d72a3d Issue-ID: VID-86 Signed-off-by: Ofir Sonsino --- .../java/org/onap/vid/services/AaiServiceImpl.java | 435 +++++++++++++++++++++ 1 file changed, 435 insertions(+) create mode 100644 vid-app-common/src/main/java/org/onap/vid/services/AaiServiceImpl.java (limited to 'vid-app-common/src/main/java/org/onap/vid/services/AaiServiceImpl.java') diff --git a/vid-app-common/src/main/java/org/onap/vid/services/AaiServiceImpl.java b/vid-app-common/src/main/java/org/onap/vid/services/AaiServiceImpl.java new file mode 100644 index 00000000..ffb43803 --- /dev/null +++ b/vid-app-common/src/main/java/org/onap/vid/services/AaiServiceImpl.java @@ -0,0 +1,435 @@ +package org.onap.vid.services; + +import org.apache.http.HttpStatus; +import org.onap.vid.aai.model.AaiGetAicZone.AicZones; +import org.openecomp.portalsdk.core.logging.logic.EELFLoggerDelegate; +import org.onap.vid.aai.*; +import org.onap.vid.aai.ServiceInstance; +import org.onap.vid.aai.ServiceSubscription; +import org.onap.vid.aai.Services; +import org.onap.vid.aai.model.AaiGetOperationalEnvironments.OperationalEnvironmentList; +import org.onap.vid.aai.model.AaiGetPnfs.Pnf; +import org.onap.vid.aai.model.AaiGetServicesRequestModel.GetServicesAAIRespone; +import org.onap.vid.aai.model.AaiGetTenatns.GetTenantsResponse; +import org.onap.vid.aai.model.*; +import org.onap.vid.asdc.beans.Service; +import org.onap.vid.model.ServiceInstanceSearchResult; +import org.onap.vid.model.SubscriberList; +import org.onap.vid.roles.RoleValidator; +import org.onap.vid.utils.Intersection; +import org.springframework.beans.factory.annotation.Autowired; + +import javax.ws.rs.core.Response; +import java.io.UnsupportedEncodingException; +import java.net.URLEncoder; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.stream.Collectors; + +/** + * Created by Oren on 7/4/17. + */ +public class AaiServiceImpl implements AaiService { + private String serviceInstanceId = "service-instance.service-instance-id"; + private String serviceType = "service-subscription.service-type"; + private String customerId = "customer.global-customer-id"; + private String serviceInstanceName = "service-instance.service-instance-name"; + private int indexOfSubscriberName = 6; + + @Autowired + private AaiClientInterface aaiClient; + + EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(AaiServiceImpl.class); + + private List convertModelToService(Model model) { + List services = new ArrayList<>(); + String category = ""; + + if(validateModel(model)){ + if(model.getModelType() != null) + category = model.getModelType(); + + for (ModelVer modelVer: model.getModelVers().getModelVer()) { + Service service = new Service(); + if (modelVer.getModelVersionId() != null) + service.setUuid(modelVer.getModelVersionId()); + if(model.getModelInvariantId() != null) + service.setInvariantUUID(model.getModelInvariantId()); + if(modelVer.getModelVersion() != null) + service.setVersion(modelVer.getModelVersion()); + if(modelVer.getModelName() != null) + service.setName(modelVer.getModelName()); + if(modelVer.getDistributionStatus() != null) + service.setDistributionStatus(Service.DistributionStatus.valueOf(modelVer.getDistributionStatus())); + service.setCategory(category); + + services.add(service); + } + } else { + return null; + } + + return services; + } + + private boolean validateModel(Model model){ + if(model != null){ + if(model.getModelVers() != null && model.getModelVers().getModelVer() != null && model.getModelVers().getModelVer().get(0).getModelVersionId() != null){ + return true; + } + } + return false; + } + + private List getServicesByOwningEntityId(List owningEntities, RoleValidator roleValidator) { + AaiResponse owningEntityResponse = aaiClient.getServicesByOwningEntityId(owningEntities); + List serviceInstanceSearchResultList = new ArrayList<>(); + if (owningEntityResponse.getT() != null) { + for (OwningEntity owningEntity : owningEntityResponse.getT().getOwningEntity()) { + if (owningEntity.getRelationshipList() != null) { + serviceInstanceSearchResultList = convertRelationshipToSearchResult(owningEntity, serviceInstanceSearchResultList, roleValidator); + } + } + } + return serviceInstanceSearchResultList; + } + + private List getServicesByProjectNames(List projectNames, RoleValidator roleValidator) { + AaiResponse projectByIdResponse = aaiClient.getServicesByProjectNames(projectNames); + List serviceInstanceSearchResultList = new ArrayList<>(); + if (projectByIdResponse.getT() != null) { + for (Project project : projectByIdResponse.getT().getProject()) { + if (project.getRelationshipList() != null) + serviceInstanceSearchResultList = convertRelationshipToSearchResult(project, serviceInstanceSearchResultList, roleValidator); + } + } + return serviceInstanceSearchResultList; + } + + private List convertRelationshipToSearchResult(AaiRelationResponse owningEntityResponse, List serviceInstanceSearchResultList, RoleValidator roleValidator) { + if (owningEntityResponse.getRelationshipList().getRelationship() != null) { + List relationshipList = owningEntityResponse.getRelationshipList().getRelationship(); + for (Relationship relationship : relationshipList) { + ServiceInstanceSearchResult serviceInstanceSearchResult = new ServiceInstanceSearchResult(); + extractRelationshipData(relationship, serviceInstanceSearchResult, roleValidator); + extractRelatedToProperty(relationship, serviceInstanceSearchResult); + serviceInstanceSearchResultList.add(serviceInstanceSearchResult); + } + } + return serviceInstanceSearchResultList; + } + + private void extractRelationshipData(Relationship relationship, ServiceInstanceSearchResult serviceInstanceSearchResult, RoleValidator roleValidator) { + List relationshipDataList = relationship.getRelationDataList(); + if (relationshipDataList != null) { + setSubscriberName(relationship, serviceInstanceSearchResult); + for (RelationshipData relationshipData : relationshipDataList) { + String key = relationshipData.getRelationshipKey(); + if (key.equals(serviceInstanceId)) { + serviceInstanceSearchResult.setServiceInstanceId(relationshipData.getRelationshipValue()); + } else if (key.equals(serviceType)) { + serviceInstanceSearchResult.setServiceType(relationshipData.getRelationshipValue()); + } else if (key.equals(customerId)) { + serviceInstanceSearchResult.setGlobalCustomerId(relationshipData.getRelationshipValue()); + } + } + + boolean isPermitted = roleValidator.isServicePermitted(serviceInstanceSearchResult.getSubscriberName(), serviceInstanceSearchResult.getServiceType()); + serviceInstanceSearchResult.setIsPermitted(isPermitted); + } + } + + private void setSubscriberName(Relationship relationship, ServiceInstanceSearchResult serviceInstanceSearchResult) { + String relatedLink = relationship.getRelatedLink(); + String[] subsciber = relatedLink.split("/"); + serviceInstanceSearchResult.setSubscriberName(subsciber[indexOfSubscriberName]); + } + + private void extractRelatedToProperty(Relationship relationship, ServiceInstanceSearchResult serviceInstanceSearchResult) { + List relatedToPropertyList = relationship.getRelatedToPropertyList(); + if (relatedToPropertyList != null) { + for (RelatedToProperty relatedToProperty : relatedToPropertyList) { + if (relatedToProperty.getPropertyKey().equals(serviceInstanceName)) { + serviceInstanceSearchResult.setServiceInstanceName(relatedToProperty.getPropertyValue()); + } + } + } + } + + @Override + public SubscriberFilteredResults getFullSubscriberList(RoleValidator roleValidator) { + AaiResponse subscriberResponse = aaiClient.getAllSubscribers(); + SubscriberFilteredResults subscriberFilteredResults = + new SubscriberFilteredResults(roleValidator, subscriberResponse.getT(), + subscriberResponse.getErrorMessage(), + subscriberResponse.getHttpCode()); + + return subscriberFilteredResults; + } + + @Override + public AaiResponse getOperationalEnvironments(String operationalEnvironmentType, String operationalEnvironmentStatus) { + AaiResponse subscriberResponse = aaiClient.getOperationalEnvironments(operationalEnvironmentType, operationalEnvironmentStatus); + return subscriberResponse; + } + + @Override + public AaiResponse getFullSubscriberList() { + AaiResponse subscriberResponse = aaiClient.getAllSubscribers(); + return subscriberResponse; + } + + @Override + public AaiResponse getSubscriberData(String subscriberId, RoleValidator roleValidator) { + AaiResponse subscriberResponse = aaiClient.getSubscriberData(subscriberId); + String subscriberGlobalId = subscriberResponse.getT().globalCustomerId; + for (ServiceSubscription serviceSubscription : subscriberResponse.getT().serviceSubscriptions.serviceSubscription) { + String serviceType = serviceSubscription.serviceType; + serviceSubscription.isPermitted = roleValidator.isServicePermitted(subscriberGlobalId, serviceType); + } + return subscriberResponse; + + } + + @Override + public AaiResponse getServiceInstanceSearchResults(String subscriberId, String instanceIdentifier, RoleValidator roleValidator, List owningEntities, List projects) { + List> resultList = new ArrayList<>(); + ServiceInstancesSearchResults serviceInstancesSearchResults = new ServiceInstancesSearchResults(); + + if (subscriberId != null || instanceIdentifier != null) { + resultList.add(getServicesBySubscriber(subscriberId, instanceIdentifier, roleValidator)); + } + if (owningEntities != null) { + resultList.add(getServicesByOwningEntityId(owningEntities, roleValidator)); + } + if (projects != null) { + resultList.add(getServicesByProjectNames(projects, roleValidator)); + } + if (resultList.size() > 0) { + Intersection intersection = new Intersection<>(); + serviceInstancesSearchResults.serviceInstances = intersection.intersectMultipileArray(resultList); + } + + return new AaiResponse<>(serviceInstancesSearchResults, null, HttpStatus.SC_OK); + } + + + private List getServicesBySubscriber(String subscriberId, String instanceIdentifier, RoleValidator roleValidator) { + AaiResponse subscriberResponse = aaiClient.getSubscriberData(subscriberId); + String subscriberGlobalId = subscriberResponse.getT().globalCustomerId; + String subscriberName = subscriberResponse.getT().subscriberName; + ServiceSubscriptions serviceSubscriptions = subscriberResponse.getT().serviceSubscriptions; + + return getSearchResultsForSubscriptions(serviceSubscriptions, subscriberId, instanceIdentifier, roleValidator, subscriberGlobalId, subscriberName); + + } + + + private ArrayList getSearchResultsForSubscriptions(ServiceSubscriptions serviceSubscriptions, String subscriberId, String instanceIdentifier, RoleValidator roleValidator, String subscriberGlobalId, String subscriberName) { + ArrayList results = new ArrayList<>(); + + if (serviceSubscriptions != null) { + for (ServiceSubscription serviceSubscription : serviceSubscriptions.serviceSubscription) { + String serviceType = serviceSubscription.serviceType; + serviceSubscription.isPermitted = roleValidator.isServicePermitted(subscriberGlobalId, serviceType); + ArrayList resultsForSubscription = getSearchResultsForSingleSubscription(serviceSubscription, subscriberId, instanceIdentifier, subscriberName, serviceType); + results.addAll(resultsForSubscription); + } + } + + return results; + } + + private ArrayList getSearchResultsForSingleSubscription(ServiceSubscription serviceSubscription, String subscriberId, String instanceIdentifier, String subscriberName, String serviceType) { + ArrayList results = new ArrayList<>(); + + if (serviceSubscription.serviceInstances != null) { + for (ServiceInstance serviceInstance : serviceSubscription.serviceInstances.serviceInstance) { + ServiceInstanceSearchResult serviceInstanceSearchResult = + new ServiceInstanceSearchResult(serviceInstance.serviceInstanceId, subscriberId, serviceType, serviceInstance.serviceInstanceName, + subscriberName, serviceInstance.modelInvariantId, serviceInstance.modelVersionId, serviceSubscription.isPermitted); + + if (instanceIdentifier == null) { + results.add(serviceInstanceSearchResult); + } else if (serviceInstanceMatchesIdentifier(instanceIdentifier, serviceInstance)) { + results.add(serviceInstanceSearchResult); + } + } + } + + return results; + } + + private boolean serviceInstanceMatchesIdentifier(String instanceIdentifier, ServiceInstance serviceInstance) { + return instanceIdentifier.equals(serviceInstance.serviceInstanceId) || instanceIdentifier.equals(serviceInstance.serviceInstanceName); + } + + @Override + public Response getVersionByInvariantId(List modelInvariantId) { + try { + return aaiClient.getVersionByInvariantId(modelInvariantId); + } catch (Exception e) { + e.printStackTrace(); + } + return null; + } + + @Override + public AaiResponse getSpecificPnf(String pnfId) { + return aaiClient.getSpecificPnf(pnfId); + } + + @Override + public AaiResponse getPNFData(String globalCustomerId, String serviceType, String modelVersionId, String modelInvariantId, String cloudRegion, String equipVendor, String equipModel) { + return aaiClient.getPNFData(globalCustomerId, serviceType, modelVersionId, modelInvariantId, cloudRegion, equipVendor, equipModel); + } + + + + @Override + public AaiResponse getServices(RoleValidator roleValidator) { + AaiResponse subscriberResponse = aaiClient.getServices(); + if (subscriberResponse.getT() != null) + for (org.onap.vid.aai.model.AaiGetServicesRequestModel.Service service : subscriberResponse.getT().service) { + service.isPermitted = true; + } + return subscriberResponse; + } + + @Override + public AaiResponse getTenants(String globalCustomerId, String serviceType, RoleValidator roleValidator) { + AaiResponse aaiGetTenantsResponse = aaiClient.getTenants(globalCustomerId, serviceType); + GetTenantsResponse[] tenants = aaiGetTenantsResponse.getT(); + if (tenants != null) { + for (int i = 0; i < tenants.length; i++) { + tenants[i].isPermitted = roleValidator.isTenantPermitted(globalCustomerId, serviceType, tenants[i].tenantName); + } + } + return aaiGetTenantsResponse; + + + } + + @Override + public AaiResponse getVNFData(String globalSubscriberId, String serviceType, String serviceInstanceId) { + return aaiClient.getVNFData(globalSubscriberId, serviceType, serviceInstanceId); + } + + @Override + public Response getVNFData(String globalSubscriberId, String serviceType) { + return aaiClient.getVNFData(globalSubscriberId, serviceType); + } + + @Override + public AaiResponse getAaiZones() { + AaiResponse response = aaiClient.getAllAicZones(); + return response; + } + + @Override + public AaiResponse getAicZoneForPnf(String globalCustomerId, String serviceType, String serviceId) { + String aicZone = ""; + + AaiResponse serviceInstanceResp = aaiClient.getServiceInstance(globalCustomerId, serviceType, serviceId); + if (serviceInstanceResp.getT() != null) { + List aicZoneList = getRelationshipDataByType(serviceInstanceResp.getT().getRelationshipList(), "zone", "zone.zone-id"); + if (aicZoneList.size() > 0) { + aicZone = aicZoneList.get(0); + } else { + logger.warn("aic zone not found for service instance " + serviceId); + } + } else { + if (serviceInstanceResp.getErrorMessage() != null) { + logger.error("get service instance " + serviceId + " return error", serviceInstanceResp.getErrorMessage()); + return new AaiResponse(aicZone , serviceInstanceResp.getErrorMessage() ,serviceInstanceResp.getHttpCode()); + } else { + logger.warn("get service instance " + serviceId + " return empty body"); + return new AaiResponse(aicZone , "get service instance " + serviceId + " return empty body" ,serviceInstanceResp.getHttpCode()); + } + } + + return new AaiResponse(aicZone , null ,HttpStatus.SC_OK); + } + + @Override + public AaiResponse getNodeTemplateInstances(String globalCustomerId, String serviceType, String modelVersionId, String modelInvariantId, String cloudRegion) { + return aaiClient.getNodeTemplateInstances(globalCustomerId, serviceType, modelVersionId, modelInvariantId, cloudRegion); + } + + @Override + public Collection getServicesByDistributionStatus() { + AaiResponse serviceModelsByDistributionStatusResponse = aaiClient.getServiceModelsByDistributionStatus(); + Collection services = new ArrayList<>(); + if (serviceModelsByDistributionStatusResponse.getT() != null) { + List results = serviceModelsByDistributionStatusResponse.getT().getResults(); + for (Result result : results) { + if(result.getModel() != null) { + List service = convertModelToService(result.getModel()); + if (service != null) { + services.addAll(service); + } + } + } + } + return services; + } + + @Override + public List getServiceInstanceAssociatedPnfs(String globalCustomerId, String serviceType, String serviceInstanceId) { + List pnfs = new ArrayList<>(); + + AaiResponse serviceInstanceResp = aaiClient.getServiceInstance(globalCustomerId, serviceType, serviceInstanceId); + if (serviceInstanceResp.getT() != null) { + List logicalLinks = getRelationshipDataByType(serviceInstanceResp.getT().getRelationshipList(), "logical-link", "logical-link.link-name"); + for (String logicalLink : logicalLinks) { + String link = ""; + try { + link = URLEncoder.encode(logicalLink, "UTF-8"); + AaiResponse logicalLinkResp = aaiClient.getLogicalLink(link); + if (logicalLinkResp.getT() != null) { + //lag-interface is the key for pnf - approved by Bracha + List linkPnfs = getRelationshipDataByType(logicalLinkResp.getT().getRelationshipList(), "lag-interface", "pnf.pnf-name"); + if (linkPnfs.size() > 0) { + pnfs.addAll(linkPnfs); + } else { + logger.warn("no pnf found for logical link " + logicalLink); + } + } else { + if (logicalLinkResp.getErrorMessage() != null) { + logger.error("get logical link " + logicalLink + " return error", logicalLinkResp.getErrorMessage()); + } else { + logger.warn("get logical link " + logicalLink + " return empty body"); + } + } + } catch (UnsupportedEncodingException e) { + logger.error("Failed to encode logical link: " + logicalLink, e.getMessage()); + } + } + } else { + if (serviceInstanceResp.getErrorMessage() != null) { + logger.error("get service instance " + serviceInstanceId + " return error", serviceInstanceResp.getErrorMessage()); + } else { + logger.warn("get service instance " + serviceInstanceId + " return empty body"); + } + } + + return pnfs.stream().distinct().collect(Collectors.toList()); + } + + private List getRelationshipDataByType(RelationshipList relationshipList, String relationshipType, String relationshipDataKey) { + List relationshipValues = new ArrayList<>(); + for (Relationship relationship : relationshipList.getRelationship()) { + if (relationship.getRelatedTo().equals(relationshipType)) { + relationshipValues.addAll( relationship.getRelationDataList().stream() + .filter(rel -> rel.getRelationshipKey().equals(relationshipDataKey)) + .map(RelationshipData::getRelationshipValue) + .collect(Collectors.toList()) + ); + } + } + + + return relationshipValues; + } +} -- cgit 1.2.3-korg