/** * Returns comparator that compares versions by distance to the base version. * @param base The base version. * @param versionParser Parser that will be used to parse the version. */ public VersionComparator(String base, VersionParser versionParser) { this.versionParser = versionParser; this.base = versionParser.parse(base); }
/** * Sets the suffix that distinguish product artifacts in the repository. * @param suffix Suffix of the product artifacts. */ public void setVersionSuffix(String suffix) { versionParser = new VersionParser(suffix); }
private SuffixedVersion parseVersion(Matcher versionMatcher, String version, String parseSuffix) throws NumberFormatException, IllegalArgumentException { if (!versionMatcher.matches()) { throw new IllegalArgumentException("Version " + version + "is unparsable"); } String majorString = versionMatcher.group("major"); String minorString = versionMatcher.group("minor"); String microString = versionMatcher.group("micro"); String qualifierString = versionMatcher.group("qualifier"); String suffixVersionString = versionMatcher.group("suffixversion"); int major = parseNumberString(majorString); int minor = parseNumberString(minorString); int micro = parseNumberString(microString); String qualifier = qualifierString == null ? "" : qualifierString; if (suffixVersionString == null) { return new SuffixedVersion(major, minor, micro, qualifier, version); } else { int suffixVersion = Integer.parseInt(suffixVersionString); return new SuffixedVersion(major, minor, micro, qualifier, parseSuffix, suffixVersion, version); } }
private WhiteArtifact createArtifact(String groupId, String artifactId, String version) { SuffixedVersion parsedVersion = versionParser.parse(version); final boolean is3rdParty = !parsedVersion.isSuffixed(); final String osgiVersion = VersionParser.getOSGiVersion(version); GA ga = gaDAO.findOrCreate(groupId, artifactId); WhiteArtifact a = new WhiteArtifact(ga, version, currentUser(), osgiVersion, is3rdParty); whiteArtifactDAO.create(a); return a; }
private void populateAdvancedArtifactReportFields(AdvancedArtifactReport advancedReport, ArtifactReport report, Set<GAV> modulesAnalyzed, File repoFolder) { VersionParser parser = new VersionParser(VersionParser.DEFAULT_SUFFIX); } else { if (parser.parse(dep.getVersion()).isSuffixed()) continue;
@Override public List<WhiteArtifact> getArtifacts(String groupId, String artifactId, String version) { // Black listed artifacts can't be queried if (blackArtifactService.isArtifactPresent(groupId, artifactId, version)) { return new ArrayList<>(); } String osgi = VersionParser.getOSGiVersion(version); List<WhiteArtifact> whites = new ArrayList<>(); Optional<WhiteArtifact> origArtifact = whiteArtifactDAO.findArtifact(groupId, artifactId, version); Optional<WhiteArtifact> normArtifact = whiteArtifactDAO.findArtifact(groupId, artifactId, osgi); origArtifact.ifPresent(x -> whites.add(x)); if (!normArtifact.equals(origArtifact)) { normArtifact.ifPresent(x -> whites.add(x)); } List<WhiteArtifact> nonDupWhites = new ArrayList<>(new LinkedHashSet<>(whites)); return nonDupWhites; }
public SuffixedVersion parse(String version) { SuffixedVersion suffixedVersion = parseVersion(versionPattern.matcher(version), version, suffix); if (!suffixedVersion.isSuffixed()) { suffixedVersion = parseVersion(defaultPattern.matcher(version), version, DEFAULT_SUFFIX); } return suffixedVersion; }
@Override public org.jboss.da.listings.api.service.ArtifactService.ArtifactStatus addArtifact( String groupId, String artifactId, String version) { String osgiVersion = VersionParser.getOSGiVersion(version); GA ga = gaDAO.findOrCreate(groupId, artifactId); BlackArtifact artifact = new BlackArtifact(ga, osgiVersion, currentUser()); if (blackArtifactDAO.findArtifact(groupId, artifactId, osgiVersion).isPresent()) { return ArtifactStatus.NOT_MODIFIED; } Set<WhiteArtifact> whites = new HashSet<>(); Optional<WhiteArtifact> rhA = whiteArtifactDAO.findArtifact(groupId, artifactId, osgiVersion); rhA.ifPresent(x -> whites.add(rhA.get())); Optional<WhiteArtifact> a = whiteArtifactDAO.findArtifact(groupId, artifactId, version); a.ifPresent(x -> whites.add(a.get())); ArtifactStatus status = ArtifactStatus.ADDED; if(!whites.isEmpty()){ status = ArtifactStatus.WAS_WHITELISTED; } blackArtifactDAO.create(artifact); return status; }
Set<ArtifactDiff> ret = new HashSet<>(); VersionComparator comparator = new VersionComparator(new VersionParser(VersionParser.DEFAULT_SUFFIX)); for(GA ga : allGAs){ String leftVersion = leftGAs.get(ga);
@Override public SortedSet<BlackArtifact> getArtifacts(String groupId, String artifactId) { Comparator<BlackArtifact> baComparator = Comparator .comparing((BlackArtifact a) -> versionParser.parse(a.getVersion())); SortedSet<BlackArtifact> ret = new TreeSet<>(baComparator); ret.addAll(blackArtifactDAO.findArtifacts(groupId, artifactId)); return ret; } }
private List<LookupReport> createLookupReports(LookupGAVsRequest request, Map<GA, CompletableFuture<Set<ProductArtifacts>>> gaProductArtifactsMap) throws CommunicationException { List<CompletableFuture<Void>> futures = new ArrayList<>(); List<LookupReport> reports = new ArrayList<>(); String suffix = request.getVersionSuffix(); VersionParser versionParser; if (suffix == null || suffix.isEmpty()) { versionParser = new VersionParser(VersionParser.DEFAULT_SUFFIX); }else{ versionParser = new VersionParser(suffix); } request.getGavs().stream() .distinct() .forEach((gav) -> { LookupReport lr = new LookupReport(gav); reports.add(lr); CompletableFuture<Set<ProductArtifacts>> artifacts = gaProductArtifactsMap.get(gav.getGA()); futures.add(analyzeVersions(versionParser, gav.getVersion(), artifacts).thenAccept(v -> { lr.setAvailableVersions(v.getAvailableVersions()); lr.setBestMatchVersion(v.getBestMatchVersion().orElse(null)); })); futures.add(artifacts.thenAccept(pas -> { lr.setWhitelisted(toWhitelisted(pas)); })); lr.setBlacklisted(blackArtifactService.isArtifactPresent(gav)); }); joinFutures(futures); return reports; }
public VersionAnalysisResult analyseVersions(String querry, Collection<String> versions){ VersionComparator comparator = new VersionComparator(querry, versionParser); List<String> sortedVersions = new ArrayList<>(); List<SuffixedVersion> parsedVersions = versions.stream() .sorted(comparator) .distinct() .peek(v -> sortedVersions.add(v)) .map(versionParser::parse) .collect(Collectors.toList()); SuffixedVersion version = versionParser.parse(querry); Optional<String> bmv = findBiggestMatchingVersion(version, parsedVersions); return new VersionAnalysisResult(bmv, sortedVersions); }
@Override public Set<BuiltReportModule> getBuiltReport(SCMLocator scml) throws ScmException, PomAnalysisException, CommunicationException { VersionParser versionParser = new VersionParser(VersionParser.DEFAULT_SUFFIX); Map<GA, Set<GAV>> dependenciesOfModules = scmConnector.getDependenciesOfModules( scml.getScmUrl(), scml.getRevision(), scml.getPomPath(), scml.getRepositories()); Set<CompletableFuture<BuiltReportModule>> builtSet = new HashSet<>(); for (Map.Entry<GA, Set<GAV>> e : dependenciesOfModules.entrySet()) { for (GAV gav : e.getValue()) { CompletableFuture<Set<ProductArtifacts>> artifacts = productProvider.getArtifacts(gav.getGA()); artifacts = filterBuiltArtifacts(artifacts); builtSet.add(analyzeVersions(versionParser, gav.getVersion(), artifacts) .thenApply(v -> toBuiltReportModule(gav, v))); } } return joinFutures(builtSet); }
private Stream<String> getVersionsStream(GA ga) { if (!ga.isValid()) { log.warn("Received nonvalid GA: " + ga); return Stream.empty(); } try { return aproxConnector.getVersionsOfGA(ga).stream() .filter(v -> versionParser.parse(v).isSuffixed()) .distinct(); } catch (CommunicationException ex) { throw new ProductException(ex); } }
private CompletableFuture<Void> fillArtifactReport(ArtifactReport report, Set<Product> products) { GAV gav = report.getGav(); CompletableFuture<Set<ProductArtifacts>> artifacts = productProvider.getArtifacts(gav .getGA()); artifacts = filterProductArtifacts(products, artifacts); report.setBlacklisted(blackArtifactService.isArtifactPresent(gav)); VersionParser parser = new VersionParser(VersionParser.DEFAULT_SUFFIX); CompletableFuture<Void> fillVersions = analyzeVersions(parser, gav.getVersion(), artifacts) .thenAccept(v -> { report.setAvailableVersions(v.getAvailableVersions()); report.setBestMatchVersion(v.getBestMatchVersion()); }); CompletableFuture<Void> fillWhitelist = artifacts.thenAccept(pas -> { List<Product> whiteProducts = pas.stream() .map(pa -> pa.getProduct()) .filter(p -> !UNKNOWN.equals(p)) .collect(Collectors.toList()); report.setWhitelisted(whiteProducts); }); return CompletableFuture.allOf(fillVersions, fillWhitelist); }
private Stream<String> getVersionsStream(GA ga, String repository) { if (!ga.isValid()) { log.warn("Received nonvalid GA: " + ga); return Stream.empty(); } try { return aproxConnector.getVersionsOfGA(ga, repository).stream() .filter(v -> versionParser.parse(v).isSuffixed()) .distinct(); } catch (CommunicationException ex) { throw new ProductException(ex); } }
boolean useUnknownProduct, Set<Long> productIds) throws ScmException, PomAnalysisException, CommunicationException { VersionParser versionParser = new VersionParser(VersionParser.DEFAULT_SUFFIX); Map<GA, Set<GAV>> dependenciesOfModules = scmConnector.getDependenciesOfModules( scml.getScmUrl(), scml.getRevision(), scml.getPomPath(), scml.getRepositories());
@Override public Optional<BlackArtifact> getArtifact(String groupId, String artifactId, String version) { SuffixedVersion parsedVersion = versionParser.parse(version); Optional<BlackArtifact> artifact = blackArtifactDAO.findArtifact(groupId, artifactId, parsedVersion.unsuffixedVesion()); if (parsedVersion.isSuffixed() && !artifact.isPresent()) { artifact = blackArtifactDAO.findArtifact(groupId, artifactId, version); } return artifact; }
/** * Return information about first part of version that is different. */ public VersionDifference difference(String version1, String version2) { SuffixedVersion v1 = versionParser.parse(version1); SuffixedVersion v2 = versionParser.parse(version2); if (v1.getMajor() != v2.getMajor()) { return VersionDifference.MAJOR; } if (v1.getMinor() != v2.getMinor()) { return VersionDifference.MINOR; } if (v1.getMicro() != v2.getMicro()) { return VersionDifference.MICRO; } if (!v1.getQualifier().equals(v2.getQualifier())) { return VersionDifference.QUALIFIER; } if (!v1.getSuffix().equals(v2.getSuffix())) { return VersionDifference.SUFFIX; } if (!v1.getSuffixVersion().equals(v2.getSuffixVersion())) { return VersionDifference.RH_SUFFIX; } return VersionDifference.EQUAL; }