private void addDependenciesToClasspathUrls(ClassLoaderModel.ClassLoaderModelBuilder classLoaderModelBuilder, Set<BundleDependency> dependencies) { dependencies.stream() .filter(dependency -> !MULE_PLUGIN_CLASSIFIER.equals(dependency.getDescriptor().getClassifier().orElse(null))) .filter(dependency -> dependency.getBundleUri() != null) .forEach(dependency -> { try { classLoaderModelBuilder.containing(dependency.getBundleUri().toURL()); } catch (MalformedURLException e) { throw new MuleRuntimeException(e); } }); }
@Override public boolean matches(Object o) { if (!(o instanceof BundleDependency)) { return false; } BundleDependency bundleDependency = (BundleDependency) o; return bundleDependency.getScope().equals(COMPILE) && !bundleDependency.getDescriptor().getClassifier().isPresent() && bundleDependency.getDescriptor().getArtifactId().equals("commons-collections") && bundleDependency.getDescriptor().getGroupId().equals("commons-collections") && bundleDependency.getDescriptor().getVersion().equals("3.2.2"); } };
public void includeAdditionalPluginDependencies() { if (deployableArtifactDescriptor != null) { deployableArtifactDescriptor.getClassLoaderModel().getDependencies().stream() .filter(bundleDescriptor -> bundleDescriptor.getDescriptor().isPlugin()) .filter(bundleDescriptor -> bundleDescriptor.getDescriptor().getGroupId() .equals(this.artifactBundleDescriptor.getGroupId()) && bundleDescriptor.getDescriptor().getArtifactId().equals(this.artifactBundleDescriptor.getArtifactId())) .filter(bundleDependency -> bundleDependency.getAdditionalDependencies() != null && !bundleDependency.getAdditionalDependencies().isEmpty()) .forEach( bundleDependency -> processPluginAdditionalDependenciesURIs(bundleDependency) .forEach(uri -> { try { containing(uri.toURL()); } catch (MalformedURLException e) { throw new ArtifactDescriptorCreateException( format("There was an exception obtaining the URL for the artifact [%s], file [%s]", artifactFolder.getAbsolutePath(), uri), e); } })); } }
private void exportBundleDependencyAndTransitiveDependencies(final BundleDependency bundleDependency) { BundleDependency resolvedBundleDependency = bundleDependency; if (bundleDependency.getBundleUri() == null) { resolvedBundleDependency = this.nonProvidedDependencies.stream() .filter(nonProvidedDependency -> nonProvidedDependency.getDescriptor().getGroupId() .equals(bundleDependency.getDescriptor().getGroupId()) && nonProvidedDependency.getDescriptor().getArtifactId().equals(bundleDependency.getDescriptor().getArtifactId())) .findAny() .orElse(bundleDependency); } JarInfo jarInfo = fileJarExplorer.explore(resolvedBundleDependency.getBundleUri()); this.exportingPackages(jarInfo.getPackages()); this.exportingResources(jarInfo.getResources()); resolvedBundleDependency.getTransitiveDependencies() .forEach(this::exportBundleDependencyAndTransitiveDependencies); }
protected Optional<BundleDependency> findBundleDependency(String groupId, String artifactId, Optional<String> classifierOptional) { return dependencies.stream() .filter(bundleDependency -> bundleDependency.getDescriptor().getArtifactId().equals(artifactId) && bundleDependency.getDescriptor().getGroupId().equals(groupId) && classifierOptional .map(classifier -> classifier.equals(bundleDependency.getDescriptor().getClassifier().orElse(null))).orElse(true)) .findFirst(); }
.forEach(dependency -> { Optional<ArtifactPluginDescriptor> resolvedPluginApplicationLevelOptional = findPlugin(pluginDescriptorsWithDependences, dependency.getDescriptor()); if (isPlugin(dependency) && !isResolvedDependency(visited, dependency.getDescriptor())) { File mulePluginLocation; if (dependency.getBundleUri() != null) { mulePluginLocation = new File(dependency.getBundleUri()); } else { throw new PluginResolutionError(format("Bundle URL should have been resolved for %s.", dependency.getDescriptor())); logger .warn(format("Transitive plugin dependency '[%s -> %s]' is greater than the one resolved for the application '%s', it will be ignored.", pluginDescriptor.getBundleDescriptor(), dependency.getDescriptor(), artifactPluginDescriptorResolved.getBundleDescriptor())); ClassLoaderModel originalClassLoaderModel = pluginDescriptor.getClassLoaderModel(); new BundleDependency.Builder() .setDescriptor(artifactPluginDescriptorResolved.getBundleDescriptor()) .setScope(dependency.getScope()) .build())) .build()); ArtifactPluginDescriptor artifactPluginDescriptor = artifactDescriptorFactory.create(mulePluginLocation, empty()); artifactPluginDescriptor.setBundleDescriptor(dependency.getDescriptor()); foundDependencies.add(artifactPluginDescriptor); visited.add(dependency.getDescriptor());
protected void findAndExportSharedLibrary(String groupId, String artifactId) { Optional<BundleDependency> bundleDependencyOptional = findBundleDependency(groupId, artifactId, empty()); BundleDependency bundleDependency = bundleDependencyOptional.orElseThrow(() -> new MuleRuntimeException(I18nMessageFactory .createStaticMessage(format( "Dependency %s:%s could not be found within the artifact %s. It must be declared within the maven dependencies of the artifact.", groupId, artifactId, artifactFolder.getName())))); JarInfo jarInfo = fileJarExplorer.explore(bundleDependency.getBundleUri()); this.exportingPackages(jarInfo.getPackages()); this.exportingResources(jarInfo.getResources()); }
@Override protected List<URI> processPluginAdditionalDependenciesURIs(BundleDependency bundleDependency) { return bundleDependency.getAdditionalDependencies().stream().map(BundleDependency::getBundleUri).collect(toList()); }
private boolean isPlugin(BundleDependency dependency) { return dependency.getDescriptor().isPlugin(); }
new HashMap<>(deployableArtifactAdditionalLibrariesMap); nonProvidedDependencies.stream() .filter(bundleDependency -> MULE_PLUGIN.equals(bundleDependency.getDescriptor().getClassifier().orElse(null))) .forEach(bundleDependency -> { Model effectiveModel; try { if (bundleDependency.getScope().equals(SYSTEM)) { effectiveModel = mavenClient.getEffectiveModel(toFile(bundleDependency.getBundleUri().toURL()), of(temporaryFolder)); } else { BundleDescriptor descriptor = bundleDependency.getDescriptor(); effectiveModel = mavenClient.getEffectiveModel(toFile(mavenClient .resolveBundleDescriptor(new org.mule.maven.client.api.model.BundleDescriptor.Builder()
public BundleDependency convert(org.mule.maven.client.api.model.BundleDependency mavenBundleDependency) { BundleDependency bundleDependency = cache.get(mavenBundleDependency.getDescriptor()); if ((bundleDependency != null && bundleDependency.getBundleUri() != null) || (bundleDependency != null && mavenBundleDependency.getBundleUri() == null)) { return bundleDependency; } BundleDependency.Builder builder = new BundleDependency.Builder() .setScope(BundleScope.valueOf(mavenBundleDependency.getScope().name())) .setBundleUri(mavenBundleDependency.getBundleUri()) .setTransitiveDependencies(mavenBundleDependency.getTransitiveDependencies().stream() .filter(transitiveDependency -> !org.mule.maven.client.api.model.BundleScope.PROVIDED .equals(transitiveDependency.getScope())) .map(this::convert) .collect(toSet())) .setDescriptor(convertBundleDescriptor(mavenBundleDependency.getDescriptor())); bundleDependency = builder.build(); cache.put(mavenBundleDependency.getDescriptor(), bundleDependency); return bundleDependency; }
@Override protected List<URI> processPluginAdditionalDependenciesURIs(BundleDependency bundleDependency) { return resolveDependencies(bundleDependency.getAdditionalDependencies()).stream() .map(org.mule.maven.client.api.model.BundleDependency::getBundleUri).collect(toList()); }
private Set<ArtifactPluginDescriptor> createArtifactPluginDescriptors(T descriptor) throws IOException { Set<ArtifactPluginDescriptor> pluginDescriptors = new HashSet<>(); for (BundleDependency bundleDependency : descriptor.getClassLoaderModel().getDependencies()) { if (bundleDependency.getDescriptor().isPlugin()) { if (bundleDependency.getBundleUri() == null) { LOGGER .warn(format("Plugin '%s' is declared as 'provided' which means that it will not be added to the artifact's classpath", bundleDependency.getDescriptor())); } else { File pluginFile = new File(bundleDependency.getBundleUri()); pluginDescriptors.add(artifactPluginDescriptorLoader.load(pluginFile, descriptor)); } } } return pluginDescriptors; } }
private DefaultArtifact toArtifact(BundleDependency bundleDependency) { return new DefaultArtifact(bundleDependency.getDescriptor().getGroupId(), bundleDependency.getDescriptor().getArtifactId(), bundleDependency.getDescriptor().getClassifier().orElse(null), bundleDependency.getDescriptor().getType(), bundleDependency.getDescriptor().getVersion()); } }
@Override public boolean matches(Object o) { if (!(o instanceof BundleDependency)) { return false; } BundleDependency bundleDependency = (BundleDependency) o; return bundleDependency.getScope().equals(COMPILE) && !bundleDependency.getDescriptor().getClassifier().isPresent() && bundleDependency.getDescriptor().getArtifactId().equals("commons-collections") && bundleDependency.getDescriptor().getGroupId().equals("commons-collections") && bundleDependency.getDescriptor().getVersion().equals("3.2.2"); } };
@Test public void classLoaderModelWithPluginDependencyWithAnotherPlugin() throws Exception { D desc = createArtifactDescriptor(getArtifactRootFolder() + "/plugin-dependency-with-another-plugin"); ClassLoaderModel classLoaderModel = desc.getClassLoaderModel(); assertThat(classLoaderModel.getDependencies().size(), is(2)); assertThat(classLoaderModel.getDependencies(), hasItems(dependantPluginDependencyMatcher(), emptyPluginDependencyMatcher())); assertThat(classLoaderModel.getUrls().length, is(1)); classLoaderModel.getDependencies().stream() .forEach(bundleDependency -> { assertThat(asList(classLoaderModel.getUrls()), not(hasItem(bundleDependency.getBundleUri()))); }); }
private Set<ArtifactPluginDescriptor> parseArtifactPluginDescriptors(PolicyTemplateDescriptor descriptor) { Set<BundleDependency> pluginDependencies = descriptor.getClassLoaderModel().getDependencies().stream() .filter(dependency -> dependency.getDescriptor().isPlugin()).collect(toSet()); return pluginDependencies.stream().map(dependency -> { try { return artifactPluginDescriptorLoader.load(new File(dependency.getBundleUri())); } catch (IOException e) { throw new MuleRuntimeException(e); } }).collect(toSet()); }
/** * @return the optional descriptor of the domain on which the application is deployed into */ public Optional<BundleDescriptor> getDomainDescriptor() { if (domainDescriptor == null) { synchronized (this) { if (domainDescriptor == null) { Optional<BundleDependency> domain = getClassLoaderModel().getDependencies().stream().filter(d -> d.getDescriptor().getClassifier().isPresent() ? d.getDescriptor().getClassifier().get().equals(MULE_DOMAIN_CLASSIFIER) : false).findFirst(); if (domain.isPresent()) { domainDescriptor = ofNullable(domain.get().getDescriptor()); } else { domainDescriptor = Optional.empty(); } } } } return domainDescriptor; }
@Override public boolean matches(Object o) { if (!(o instanceof BundleDependency)) { return false; } BundleDependency bundleDependency = (BundleDependency) o; return bundleDependency.getScope().equals(COMPILE) && bundleDependency.getDescriptor().getClassifier().isPresent() && bundleDependency.getDescriptor().getClassifier().get().equals(MULE_PLUGIN_CLASSIFIER) && bundleDependency.getDescriptor().getArtifactId().equals(artifactId) && bundleDependency.getDescriptor().getGroupId().equals("org.mule.tests") && bundleDependency.getDescriptor().getVersion().equals(MULE_PROJECT_VERSION); } };
@Test public void classLoaderModelWithSingleDependency() throws Exception { D desc = createArtifactDescriptor(getArtifactRootFolder() + "/single-dependency"); ClassLoaderModel classLoaderModel = desc.getClassLoaderModel(); assertThat(classLoaderModel.getDependencies(), hasSize(1)); BundleDependency commonsCollectionDependency = classLoaderModel.getDependencies().iterator().next(); assertThat(commonsCollectionDependency, commonsCollectionDependencyMatcher()); assertThat(classLoaderModel.getUrls().length, is(2)); assertThat(asList(classLoaderModel.getUrls()), hasItem(commonsCollectionDependency.getBundleUri().toURL())); }