org.jboss.shrinkwrap.resolver.api.maven.coordinate.MavenDependency Java Examples

public static URL[] resolve(final MavenDependency dep) {
    return CACHE.computeIfAbsent(dep, d -> {
        final ConfigurableMavenResolverSystem resolver = Maven
                .configureResolver()
                .withClassPathResolution(true)
                .workOffline(Boolean.getBoolean("talend.component.junit.maven.offline"));
        REPOSITORIES.forEach(resolver::withRemoteRepo);
        resolver.addDependency(dep);
        return Stream.of(resolver.resolve().using(STRATEGY).asFile()).distinct().map(f -> {
            try {
                return f.toURI().toURL();
            } catch (final MalformedURLException e) {
                throw new IllegalStateException(e);
            }
        }).toArray(URL[]::new);
    });
}
 

public static File[] resolve(File cacheFolder, MavenDependency[] dependencies) {
    String hash = hash(dependencies);
    File[] files;

    File cacheFile = getCacheFile(cacheFolder, hash);
    if (cacheFile.exists()) {
        files = readCache(cacheFile);
    } else {
        files = Maven.configureResolver()
            .addDependencies(dependencies)
            .resolve()
            .withTransitivity()
            .asFile();

        writeCache(getCacheFile(cacheFolder, hash), files);
    }
    return files;
}
 

public MavenDependency createMavenDependency(final ArtifactSpec spec) {
    final MavenCoordinate newCoordinate = MavenCoordinates.createCoordinate(
            spec.groupId(),
            spec.artifactId(),
            spec.version(),
            PackagingType.of(spec.type()),
            spec.classifier());
    return MavenDependencies.createDependency(newCoordinate, ScopeType.fromScopeType(spec.scope), false);
}
 

private ClassLoader resolveClasspathDependencies(ContainerAdapter targetAdapter, File resolverCacheFolder) {
    String[] dependencies = targetAdapter.dependencies();

    try {
        MavenDependency[] mavenDependencies = toMavenDependencies(dependencies, targetAdapter.excludes());

        File[] archives = Resolver.resolve(resolverCacheFolder, mavenDependencies);
        return new URLClassLoader(toURLs(archives), ChameleonContainer.class.getClassLoader());
    } catch (Exception e) {
        throw new RuntimeException("Could not resolve target " + targetAdapter + " adapter dependencies", e);
    }
}
 

public Container[] load(InputStream containers, File cacheFolder) throws Exception {

        MavenDependency[] mavenDependencies = Utils.toMavenDependencies(
            new String[] {"org.yaml:snakeyaml:1.24"},
            new String[] {});

        File[] archives = Resolver.resolve(cacheFolder, mavenDependencies);

        ClassLoader classloader = new URLClassLoader(Utils.toURLs(archives), null);
        return loadContainers(classloader, containers);
    }
 

public static MavenDependency[] toMavenDependencies(String[] dependencies, String[] exclusions) {
    MavenDependencyExclusion[] mavenExclusions = toMavenExclusions(exclusions);
    MavenDependency[] mavenDependencies = new MavenDependency[dependencies.length];
    for (int i = 0; i < dependencies.length; i++) {
        mavenDependencies[i] = MavenDependencies.createDependency(
            dependencies[i],
            ScopeType.COMPILE,
            false,
            mavenExclusions);
    }
    return mavenDependencies;
}
 

public WebArchiveBuilder addDependencies(MavenDependency... dependencies) {
    this.additionalDependencies.addAll(Arrays.asList(dependencies));
    return this;
}
 

@Override
protected MavenDependency[] rootDependencies() {
    return new MavenDependency[] { getRunnerDependency(), getComponentRuntimeBeamDependency() };
}
 

protected MavenDependency getRunnerDependency() {
    return createDependency(rootDependencyBase() + ":jar:" + beamVersion, RUNTIME, false);
}
 

protected MavenDependency getComponentRuntimeBeamDependency() {
    return createDependency("org.talend.sdk.component:component-runtime-beam:jar:" + kitVersion, RUNTIME, false);
}
 

public WebArchiveBuilder addDependencies(MavenDependency... dependencies) {
    this.additionalDependencies.addAll(Arrays.asList(dependencies));
    return this;
}
 

protected abstract MavenDependency[] rootDependencies();