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(); }
private boolean isPlugin(BundleDependency dependency) { return dependency.getDescriptor().isPlugin(); }
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()); } }
/** * @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; }
private boolean areSameDependency(org.mule.tools.api.classloader.model.Plugin plugin, BundleDependency dependency) { return StringUtils.equals(dependency.getDescriptor().getGroupId(), plugin.getGroupId()) && StringUtils.equals(dependency.getDescriptor().getArtifactId(), plugin.getArtifactId()); }
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()); }
private boolean isDependencyPlugin(Set<BundleDependency> dependencies, ArtifactPluginDescriptor dependencyPluginDescriptor) { for (BundleDependency pluginDependency : dependencies) { if (pluginDependency.getDescriptor().getArtifactId() .equals(dependencyPluginDescriptor.getBundleDescriptor().getArtifactId()) && pluginDependency.getDescriptor().getGroupId() .equals(dependencyPluginDescriptor.getBundleDescriptor().getGroupId()) && MULE_PLUGIN_CLASSIFIER.equals(pluginDependency.getDescriptor().getClassifier().orElse(null))) { return true; } } return false; }
private static ArtifactPluginDescriptor findArtifactPluginDescriptor(BundleDependency bundleDependency, List<ArtifactPluginDescriptor> resolvedPlugins) { ArtifactPluginDescriptor result = null; for (ArtifactPluginDescriptor resolvedPlugin : resolvedPlugins) { BundleDescriptor resolvedBundleDescriptor = resolvedPlugin.getBundleDescriptor(); if (isResolvedDependency(resolvedBundleDescriptor, bundleDependency.getDescriptor())) { result = resolvedPlugin; break; } } return result; }
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); } }); }
private boolean hasPluginDependenciesResolved(Set<BundleDependency> pluginDependencies, List<ArtifactPluginDescriptor> resolvedPlugins) { boolean resolvedDependency = true; for (BundleDependency dependency : pluginDependencies) { if (dependency.getDescriptor().isPlugin() && findArtifactPluginDescriptor(dependency, resolvedPlugins) == null) { resolvedDependency = false; break; } } return resolvedDependency; } }
@Override protected void findAndExportSharedLibrary(String groupId, String artifactId) { Pair<String, String> sharedLibraryKey = new Pair<>(groupId, artifactId); if (sharedLibraryAlreadyExported.containsKey(sharedLibraryKey)) { return; } sharedLibraryAlreadyExported.put(sharedLibraryKey, true); Optional<BundleDependency> matchingLibrary = this.nonProvidedDependencies.stream() .filter(bundleDependency -> bundleDependency.getDescriptor().getGroupId().equals(groupId) && bundleDependency.getDescriptor().getArtifactId().equals(artifactId)) .findAny(); BundleDependency bundleDependency = matchingLibrary.orElseThrow(() -> new MuleRuntimeException(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())))); exportBundleDependencyAndTransitiveDependencies(bundleDependency); }
protected static String createResolutionErrorMessage(List<ArtifactPluginDescriptor> unresolvedPlugins, List<ArtifactPluginDescriptor> resolvedPlugins) { StringBuilder builder = new StringBuilder("Unable to resolve plugin dependencies:"); for (ArtifactPluginDescriptor unresolvedPlugin : unresolvedPlugins) { builder.append("\nPlugin: ").append(unresolvedPlugin.getName()).append(" missing dependencies:"); List<BundleDependency> missingDependencies = new ArrayList<>(); for (BundleDependency dependency : unresolvedPlugin.getClassLoaderModel().getDependencies()) { Optional<String> classifierOptional = dependency.getDescriptor().getClassifier(); if (classifierOptional.isPresent() && MULE_PLUGIN_CLASSIFIER.equals(classifierOptional.get())) { final ArtifactPluginDescriptor dependencyDescriptor = findArtifactPluginDescriptor(dependency, resolvedPlugins); if (dependencyDescriptor == null) { missingDependencies.add(dependency); } } } builder.append(missingDependencies); } return builder.toString(); }
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); }
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 Set<String> findDependencyPackageClosure(Set<BundleDependency> pluginDependencies, List<ArtifactPluginDescriptor> resolvedPlugins) { Set<String> exportedPackages = new HashSet<>(); for (BundleDependency pluginDependency : pluginDependencies) { final Optional<String> classifier = pluginDependency.getDescriptor().getClassifier(); if (classifier.isPresent() && MULE_PLUGIN_CLASSIFIER.equals(classifier.get())) { ArtifactPluginDescriptor dependencyDescriptor = findArtifactPluginDescriptor(pluginDependency, resolvedPlugins); exportedPackages.addAll(dependencyDescriptor.getClassLoaderModel().getExportedPackages()); exportedPackages .addAll(findDependencyPackageClosure(dependencyDescriptor.getClassLoaderModel().getDependencies(), resolvedPlugins)); } } return exportedPackages; }
@Override public boolean matches(Object o) { if (!(o instanceof BundleDependency)) { return false; } BundleDependency bundleDependency = (BundleDependency) o; return 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); } };
private Set<ArtifactPluginDescriptor> getArtifactPluginDescriptors(ApplicationDescriptor descriptor) { if (descriptor.getPlugins().isEmpty()) { Set<ArtifactPluginDescriptor> pluginDescriptors = new HashSet<>(); for (BundleDependency bundleDependency : descriptor.getClassLoaderModel().getDependencies()) { if (bundleDependency.getDescriptor().isPlugin()) { File pluginZip = new File(bundleDependency.getBundleUri()); try { pluginDescriptors.add(artifactPluginDescriptorLoader.load(pluginZip)); } catch (IOException e) { throw new IllegalStateException("Cannot create plugin descriptor: " + pluginZip.getAbsolutePath(), e); } } } return pluginDescriptors; } else { return descriptor.getPlugins(); } }
@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"); } };
@Override public boolean matches(Object o) { if (!(o instanceof BundleDependency)) { return false; } BundleDependency bundleDependency = (BundleDependency) o; return bundleDependency.getDescriptor().getClassifier().isPresent() && bundleDependency.getDescriptor().getClassifier().get().equals(MULE_PLUGIN_CLASSIFIER) && bundleDependency.getDescriptor().getArtifactId().equals("test-empty-plugin") && bundleDependency.getDescriptor().getGroupId().equals("org.mule.tests") && bundleDependency.getDescriptor().getVersion().equals(MULE_PROJECT_VERSION) && (hasUri ? bundleDependency.getBundleUri() != null : bundleDependency.getBundleUri() == null); } };
private void testPatchedDependency(String application, int totalExpectedDependencies, String patchedArtifactId, String patchedArtifactVersion) throws InvalidDescriptorLoaderException, IOException { URL patchedAppUrl = getClass().getClassLoader().getResource(Paths.get(APPS_FOLDER, application).toString()); ClassLoaderModel classLoaderModel = buildClassLoaderModel(toFile(patchedAppUrl)); Set<BundleDependency> dependencies = classLoaderModel.getDependencies(); assertThat(dependencies, hasSize(totalExpectedDependencies)); List<BundleDependency> connectorsFound = dependencies.stream() .filter(bundleDependency -> bundleDependency.getDescriptor().getArtifactId().equals(patchedArtifactId)) .collect(Collectors.toList()); assertThat(connectorsFound, hasSize(1)); assertThat(connectorsFound.get(0).getDescriptor().getVersion(), is(patchedArtifactVersion)); }