org.jfrog.build.util.DependenciesHelper Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of build-info-client Show documentation
There is a newer version: 2.41.24
package org.jfrog.build.util;

import com.google.common.base.Predicate;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import org.apache.commons.lang.StringUtils;
import org.jfrog.build.api.Dependency;
import org.jfrog.build.api.dependency.DownloadableArtifact;
import org.jfrog.build.api.dependency.PatternResultFileSet;
import org.jfrog.build.api.dependency.PropertySearchResult;
import org.jfrog.build.api.dependency.pattern.BuildDependencyPattern;
import org.jfrog.build.api.dependency.pattern.DependencyPattern;
import org.jfrog.build.api.util.Log;
import org.jfrog.build.client.PatternMatcher;

import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Set;

/**
 * Helper class for parsing custom resolved dependencies
 *
 * @author Shay Yaakov
 */
public class DependenciesHelper {

    private DependenciesDownloader downloader;
    private Log log;

    public DependenciesHelper(DependenciesDownloader downloader, Log log) {
        this.downloader = downloader;
        this.log = log;
    }

    public List retrievePublishedDependencies(String resolvePattern)
            throws IOException, InterruptedException {
        if (StringUtils.isBlank(resolvePattern)) {
            return Collections.emptyList();
        }

        List patternLines = PublishedItemsHelper.parsePatternsFromProperty(resolvePattern);
        List dependencies = Collections.emptyList();

        // Don't run if dependencies mapping came out to be empty.
        if (patternLines.isEmpty()) {
            return dependencies;
        }

        log.info("Beginning to resolve Build Info published dependencies.");
        dependencies = downloader.download(collectArtifactsToDownload(patternLines));
        log.info("Finished resolving Build Info published dependencies.");

        return dependencies;
    }

    private Set collectArtifactsToDownload(List patternLines)
            throws IOException, InterruptedException {
        Set downloadableArtifacts = Sets.newHashSet();
        for (String patternLine : patternLines) {
            DependencyPattern dependencyPattern = PatternFactory.create(patternLine);
            if (!(dependencyPattern instanceof BuildDependencyPattern)) {
                downloadableArtifacts.addAll(handleDependencyPattern(dependencyPattern));
            }
        }

        return downloadableArtifacts;
    }

    private Set handleDependencyPattern(DependencyPattern dependencyPattern) throws IOException {
        String pattern = dependencyPattern.getPattern();
        log.info("Resolving published dependencies with pattern " + pattern);
        if (StringUtils.contains(pattern, "**")) {
            if (StringUtils.isNotBlank(dependencyPattern.getMatrixParams())) {
                return performPropertySearch(dependencyPattern);
            } else {
                throw new IllegalArgumentException(
                        "Wildcard '**' is not allowed without matrix params for pattern '" + pattern + "'");
            }
        } else {
            return performPatternSearch(dependencyPattern);
        }
    }

    private Set performPropertySearch(DependencyPattern dependencyPattern) throws IOException {
        Set downloadableArtifacts = Sets.newHashSet();
        String pattern = dependencyPattern.getPattern();
        String matrixParams = dependencyPattern.getMatrixParams();
        PropertySearchResult propertySearchResult = downloader.getClient().searchArtifactsByProperties(matrixParams);
        List filteredEntries = filterResultEntries(
                propertySearchResult.getResults(), pattern);
        log.info("Found " + filteredEntries.size() + " dependencies.");
        for (PropertySearchResult.SearchEntry searchEntry : filteredEntries) {
            downloadableArtifacts.add(
                    new DownloadableArtifact(searchEntry.getRepoUri(), dependencyPattern.getTargetDirectory(),
                            searchEntry.getFilePath(), matrixParams, pattern, dependencyPattern.getPatternType()));
        }

        return downloadableArtifacts;
    }

    private List filterResultEntries(List results,
            String pattern) {
        final String patternStr = pattern.replaceFirst(":", "/");
        return Lists.newArrayList(Iterables.filter(results, new Predicate() {
            @Override
            public boolean apply(PropertySearchResult.SearchEntry input) {
                return PatternMatcher.match(patternStr, input.getRepoPath(), false);
            }
        }));
    }

    private Set performPatternSearch(DependencyPattern dependencyPattern) throws IOException {
        Set downloadableArtifacts = Sets.newHashSet();
        String pattern = dependencyPattern.getPattern();
        PatternResultFileSet fileSet = downloader.getClient().searchArtifactsByPattern(pattern);
        Set filesToDownload = fileSet.getFiles();
        log.info("Found " + filesToDownload.size() + " dependencies.");
        for (String fileToDownload : filesToDownload) {
            downloadableArtifacts.add(
                    new DownloadableArtifact(fileSet.getRepoUri(), dependencyPattern.getTargetDirectory(),
                            fileToDownload, dependencyPattern.getMatrixParams(), pattern,
                            dependencyPattern.getPatternType()));
        }

        return downloadableArtifacts;
    }
}