private boolean isResolvedPlugin(ArtifactPluginDescriptor descriptor, List<ArtifactPluginDescriptor> resolvedPlugins) { boolean isResolved = descriptor.getClassLoaderModel().getDependencies().isEmpty(); if (!isResolved && hasPluginDependenciesResolved(descriptor.getClassLoaderModel().getDependencies(), resolvedPlugins)) { isResolved = true; } return isResolved; }
private List<ArtifactPluginDescriptor> getPluginDescriptors(ArtifactPluginDescriptor descriptor, List<ArtifactPluginDescriptor> artifactPluginDescriptors) { return artifactPluginDescriptors.stream() .filter(d -> isDependencyPlugin(descriptor.getClassLoaderModel().getDependencies(), d)).collect(toList()); }
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 LookupStrategy getClassLoaderLookupStrategy(ArtifactPluginDescriptor descriptor, ArtifactPluginDescriptor dependencyPluginDescriptor) { final LookupStrategy lookupStrategy; if (isDependencyPlugin(descriptor.getClassLoaderModel().getDependencies(), dependencyPluginDescriptor)) { lookupStrategy = PARENT_FIRST; } else { lookupStrategy = CHILD_ONLY; } return lookupStrategy; }
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(); }
/** * @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 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; }
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(); } }
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 ClassLoaderModelBuilder createBuilderWithoutDependency(ClassLoaderModel originalClassLoaderModel, BundleDependency dependencyToBeExcluded) { ClassLoaderModelBuilder classLoaderModelBuilder = new ClassLoaderModelBuilder() .dependingOn(originalClassLoaderModel.getDependencies().stream() .filter(dependency -> !dependency.equals(dependencyToBeExcluded)) .collect(toSet())) .exportingPackages(originalClassLoaderModel.getExportedPackages()) .exportingPrivilegedPackages(originalClassLoaderModel.getPrivilegedExportedPackages(), originalClassLoaderModel.getPrivilegedArtifacts()) .exportingResources(originalClassLoaderModel.getExportedResources()); for (URL url : originalClassLoaderModel.getUrls()) { classLoaderModelBuilder.containing(url); } return classLoaderModelBuilder; }
private void sanitizeExportedPackages(ArtifactPluginDescriptor pluginDescriptor, List<ArtifactPluginDescriptor> resolvedPlugins) { final Set<String> packagesExportedByDependencies = findDependencyPackageClosure(pluginDescriptor.getClassLoaderModel().getDependencies(), resolvedPlugins); ClassLoaderModel originalClassLoaderModel = pluginDescriptor.getClassLoaderModel(); final Set<String> exportedClassPackages = new HashSet<>(originalClassLoaderModel.getExportedPackages()); exportedClassPackages.removeAll(packagesExportedByDependencies); pluginDescriptor.setClassLoaderModel(createBuilderWithoutExportedPackages(originalClassLoaderModel) .exportingPackages(exportedClassPackages).build()); }
@Test public void createsClassLoaderModelFromFolder() throws Exception { File policyFolder = temporaryFolder.newFolder(); File libFolder = new File(policyFolder, LIB_DIR); assertThat(libFolder.mkdir(), is(true)); File file1 = new File(libFolder, "test1.jar"); stringToFile(file1.getAbsolutePath(), "foo"); File file2 = new File(libFolder, "test2.jar"); stringToFile(file2.getAbsolutePath(), "foo"); ClassLoaderModel classLoaderModel = classLoaderModelLoader.load(policyFolder, null, POLICY); assertThat(classLoaderModel.getUrls().length, equalTo(3)); assertThat(classLoaderModel.getUrls()[0], equalTo(policyFolder.toURI().toURL())); assertThat(asList(classLoaderModel.getUrls()), allOf(hasItem(file1.toURI().toURL()), hasItem(file2.toURI().toURL()))); assertThat(classLoaderModel.getDependencies(), is(empty())); assertThat(classLoaderModel.getExportedPackages(), is(empty())); assertThat(classLoaderModel.getExportedResources(), is(empty())); } }
@Test public void classLoaderModelWithPluginDependency() throws Exception { D desc = createArtifactDescriptor(getArtifactRootFolder() + "/plugin-dependency"); ClassLoaderModel classLoaderModel = desc.getClassLoaderModel(); assertThat(classLoaderModel.getDependencies().size(), is(1)); assertThat(classLoaderModel.getDependencies(), hasItem(testEmptyPluginDependencyMatcher())); assertThat(classLoaderModel.getUrls().length, is(1)); assertThat(asList(classLoaderModel.getUrls()), not(hasItem(classLoaderModel.getDependencies().iterator().next()))); }
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)); }
@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()))); }); }
@Test public void classLoaderModelWithPluginDependencyDeclaredAsProvided() throws Exception { D desc = createArtifactDescriptor(getArtifactRootFolder() + "/provided-plugin-dependency"); ClassLoaderModel classLoaderModel = desc.getClassLoaderModel(); assertThat(classLoaderModel.getDependencies().size(), is(1)); assertThat(classLoaderModel.getDependencies(), hasItem(testEmptyPluginDependencyMatcher(PROVIDED, false))); }
@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())); }
private ClassLoaderModel buildAndValidateModel(int expectedDependencies) throws Exception { File app = toFile(getClass().getClassLoader().getResource(Paths.get(APPS_FOLDER, "no-dependencies").toString())); MavenConfiguration mockMavenConfiguration = mock(MavenConfiguration.class, RETURNS_DEEP_STUBS); when(mockMavenConfiguration.getLocalMavenRepositoryLocation()).thenReturn(temporaryFolder.newFolder()); when(mockMavenClient.getMavenConfiguration()).thenReturn(mockMavenConfiguration); ClassLoaderModel classLoaderModel = buildClassLoaderModel(app); assertThat(classLoaderModel.getDependencies(), hasSize(expectedDependencies)); URL[] urls = classLoaderModel.getUrls(); assertThat(urls, hasItemInArray(app.toURI().toURL())); assertThat(urls, hasItemInArray(getDependencyUrl(API_BUNDLE))); assertThat(urls, hasItemInArray(getDependencyUrl(LIB_BUNDLE))); assertThat(urls, hasItemInArray(getDependencyUrl(TRAIT_BUNDLE))); return classLoaderModel; }
private ClassLoaderModelBuilder createBuilderWithoutExportedPackages(ClassLoaderModel originalClassLoaderModel) { ClassLoaderModelBuilder classLoaderModelBuilder = new ClassLoaderModelBuilder() .dependingOn(originalClassLoaderModel.getDependencies()) .exportingPrivilegedPackages(originalClassLoaderModel.getPrivilegedExportedPackages(), originalClassLoaderModel.getPrivilegedArtifacts()) .exportingResources(originalClassLoaderModel.getExportedResources()); for (URL url : originalClassLoaderModel.getUrls()) { classLoaderModelBuilder.containing(url); } return classLoaderModelBuilder; }
@Test public void loadsDescriptorFromJson() throws Exception { String artifactPath = getArtifactRootFolder() + "/no-dependencies"; D desc = createArtifactDescriptor(artifactPath); assertThat(desc.getMinMuleVersion(), is(new MuleVersion("4.0.0"))); assertThat(desc.getConfigResources(), hasSize(1)); assertThat(desc.getConfigResources(), hasItem(getDefaultConfigurationResourceLocation())); ClassLoaderModel classLoaderModel = desc.getClassLoaderModel(); assertThat(classLoaderModel.getDependencies().isEmpty(), is(true)); assertThat(classLoaderModel.getUrls().length, is(1)); assertThat(toFile(classLoaderModel.getUrls()[0]).getPath(), is(getArtifact(artifactPath).getAbsolutePath())); assertThat(classLoaderModel.getExportedPackages().isEmpty(), is(true)); assertThat(classLoaderModel.getExportedResources().isEmpty(), is(true)); assertThat(classLoaderModel.getDependencies().isEmpty(), is(true)); }