/** * @param managedDependencies the managed dependencies * @param extension the extension for which to append managed dependencies * @return the new map of managed dependencies */ public static Map<String, ExtensionDependency> append(Map<String, ExtensionDependency> managedDependencies, Extension extension) { Map<String, ExtensionDependency> newManagedDependencies = managedDependencies != null ? new HashMap<>(managedDependencies) : new HashMap<>(); for (ExtensionDependency dependency : extension.getManagedDependencies()) { newManagedDependencies.put(dependency.getId(), dependency); } return newManagedDependencies; }
private void addLocalExtensionBackwardDependencies(LocalExtension localExtension, String namespace) { for (ExtensionDependency dependency : localExtension.getDependencies()) { Map<String, Set<LocalExtension>> namespaceBackwardDependencies = this.backwardDependenciesMap.get(dependency.getId()); if (namespaceBackwardDependencies == null) { namespaceBackwardDependencies = new HashMap<String, Set<LocalExtension>>(); this.backwardDependenciesMap.put(dependency.getId(), namespaceBackwardDependencies); } Set<LocalExtension> backwardDependencies = namespaceBackwardDependencies.get(namespace); if (backwardDependencies == null) { backwardDependencies = new HashSet<LocalExtension>(); namespaceBackwardDependencies.put(namespace, backwardDependencies); } backwardDependencies.add(localExtension); } }
/** * Extract extension with the provided id from the provided extension. * * @param extension the extension * @param dependencyId the id of the dependency * @return the extension dependency or null if none has been found */ private ExtensionDependency getDependency(Extension extension, String dependencyId) { for (ExtensionDependency dependency : extension.getDependencies()) { if (dependency.getId().equals(dependencyId)) { return dependency; } } return null; }
/** * @param dependency the initial dependency * @param managedDependencies the managed dependencies * @param extension the extension with the passed dependency * @return the actual dependency to resolve */ public static ExtensionDependency getDependency(ExtensionDependency dependency, Map<String, ExtensionDependency> managedDependencies, Extension extension) { ExtensionDependency managedDependency = managedDependencies.get(dependency.getId()); // If the dependency does not have any version try to find it in extension managed dependencies if (managedDependency == null && dependency.getVersionConstraint() == null) { for (ExtensionDependency extensionManagedDependency : extension.getManagedDependencies()) { if (extensionManagedDependency.getId().equals(dependency.getId())) { managedDependency = extensionManagedDependency; } } } return managedDependency != null ? managedDependency : dependency; }
private void removeFromBackwardDependencies(DefaultInstalledExtension installedExtension, String namespace) { // Clean provided extension dependencies backward dependencies for (ExtensionDependency dependency : installedExtension.getDependencies()) { if (this.coreExtensionRepository.getCoreExtension(dependency.getId()) == null) { InstalledFeature installedFeature = getInstalledFeatureFromCache(dependency.getId(), namespace); if (installedFeature != null) { installedFeature.root.backwardDependencies.remove(installedExtension); } } } }
private boolean hasIncompatileRootDependency(ExtensionDependency extensionDependency) { InstalledExtension rootExtension = this.installedExtensionRepository.getInstalledExtension(extensionDependency.getId(), null); return rootExtension != null && !extensionDependency.isCompatible(rootExtension); }
private void updateMissingBackwardDependencies(DefaultInstalledExtension installedExtension, String namespace) { // Add the extension as backward dependency for (ExtensionDependency dependency : installedExtension.getDependencies()) { if (!dependency.isOptional() && !this.coreExtensionRepository.exists(dependency.getId())) { // Get the extension for the dependency feature for the provided namespace DefaultInstalledExtension dependencyLocalExtension = (DefaultInstalledExtension) getInstalledExtension(dependency.getId(), namespace); if (dependencyLocalExtension != null) { ExtensionId feature = dependencyLocalExtension.getExtensionFeature(dependency.getId()); // Make sure to register backward dependency on the right namespace InstalledFeature dependencyInstalledExtension = addInstalledFeatureToCache(feature, namespace, dependencyLocalExtension, false); dependencyInstalledExtension.root.backwardDependencies.add(installedExtension); } } } }
private void addDependencies(Document document, Element parentElement, Extension extension) { if (extension.getDependencies() != null && !extension.getDependencies().isEmpty()) { Element dependenciesElement = document.createElement("dependencies"); parentElement.appendChild(dependenciesElement); for (ExtensionDependency dependency : extension.getDependencies()) { Element dependencyElement = document.createElement("dependency"); dependenciesElement.appendChild(dependencyElement); addElement(document, dependencyElement, "id", dependency.getId()); addElement(document, dependencyElement, "version", dependency.getVersion()); } } }
/** * Indicate if the passed extension id is compatible with this dependency. * * @param extensionId the extension to check * @return true if the passed extension id is compatible, false otherwise * @since 8.1M1 */ default boolean isCompatible(ExtensionId extensionId) { return getId().equals(extensionId.getId()) && getVersionConstraint().isCompatible(extensionId.getVersion()); }
private void addDependencies(Document document, Element parentElement, String fieldName, Collection<ExtensionDependency> dependencies) { if (dependencies != null && !dependencies.isEmpty()) { Element dependenciesElement = document.createElement(fieldName); parentElement.appendChild(dependenciesElement); for (ExtensionDependency dependency : dependencies) { Element dependencyElement = document.createElement(ELEMENT_DDEPENDENCY); dependenciesElement.appendChild(dependencyElement); addElement(document, dependencyElement, ELEMENT_ID, dependency.getId()); addElement(document, dependencyElement, ELEMENT_VERSION, dependency.getVersionConstraint().getValue()); addElement(document, dependencyElement, ELEMENT_DDOPTIONAL, dependency.isOptional()); addProperties(document, dependencyElement, dependency.getProperties()); } } }
@Override public boolean equals(Object obj) { if (this == obj) { return true; } boolean equals; if (obj instanceof ExtensionDependency) { ExtensionDependency otherDependency = (ExtensionDependency) obj; EqualsBuilder builder = new EqualsBuilder(); builder.append(getId(), otherDependency.getId()); builder.append(getVersionConstraint(), otherDependency.getVersionConstraint()); builder.append(isOptional(), otherDependency.isOptional()); builder.append(getRepositories(), otherDependency.getRepositories()); builder.append(getProperties(), otherDependency.getProperties()); equals = builder.isEquals(); } else { equals = false; } return equals; } }
private LocalExtension getInstalledLocalExtension(ExtensionDependency dependency, String namespace) { Map<String, Set<LocalExtension>> localInstallExtensionFeature = this.localInstalledExtensionsCache.get(dependency.getId()); if (localInstallExtensionFeature != null) { Set<LocalExtension> localInstallExtensionNamespace = localInstallExtensionFeature.get(namespace); if (localInstallExtensionNamespace != null) { for (LocalExtension dependencyVersion : localInstallExtensionNamespace) { if (isCompatible(dependencyVersion.getId().getVersion(), dependency.getVersionConstraint())) { return dependencyVersion; } } } } // Try on root namespace if (namespace != null) { return getInstalledLocalExtension(dependency, null); } return null; }
private LocalExtension installExtensionDependency(ExtensionDependency extensionDependency, String namespace) throws InstallException { if (this.coreExtensionRepository.exists(extensionDependency.getId())) { return null; } LocalExtension previousExtension = null; LocalExtension localExtension = this.localExtensionRepository.getInstalledExtension(extensionDependency.getId(), namespace); if (localExtension != null) { int diff = this.versionManager.compareVersions(extensionDependency.getVersion(), localExtension.getId() .getVersion()); if (diff > 0) { // upgrade previousExtension = localExtension; } else { return null; } } return installExtension(previousExtension, new ExtensionId(extensionDependency.getId(), extensionDependency.getVersion()), true, namespace); }
@Override public E resolve(ExtensionDependency extensionDependency) throws ResolveException { List<E> versions = this.extensionsVersions.get(extensionDependency.getId()); if (versions != null) { for (E extension : versions) { if (extensionDependency.getVersionConstraint().containsVersion(extension.getId().getVersion())) { // Return the higher version which satisfy the version constraint return extension; } } } throw new ExtensionNotFoundException("Can't find extension dependency [" + extensionDependency + "]"); }
/** * Create new instance by cloning the provided one with different version constraint. * * @param dependency the extension dependency to copy * @param versionConstraint the version constraint to set */ public AbstractExtensionDependency(ExtensionDependency dependency, VersionConstraint versionConstraint) { this(dependency.getId(), versionConstraint != null ? versionConstraint : dependency.getVersionConstraint(), dependency.isOptional(), dependency.getProperties()); setRepositories(dependency.getRepositories()); }
/** * @param dependency the initial dependency * @param configuration the configuration * @param factory the factory * @return the modified {@link ExtensionDependency} or null if it does not match any recommended dependency or the * found recommendation is already equals to the passed one * @since 9.6 */ public static ExtensionDependency getRecommendedDependency(ExtensionDependency dependency, ExtensionManagerConfiguration configuration, ExtensionFactory factory) { VersionConstraint recommendedVersionConstraint = configuration.getRecomendedVersionConstraint(dependency.getId(), dependency.getVersionConstraint()); if (recommendedVersionConstraint != null) { try { recommendedVersionConstraint = dependency.getVersionConstraint().merge(recommendedVersionConstraint); return factory.getExtensionDependency(dependency.getId(), recommendedVersionConstraint, dependency.isOptional(), dependency.getProperties()); } catch (IncompatibleVersionConstraintException e) { // Not compatible, don't use the recommended version } } return null; }
private boolean checkCoreDependency(ExtensionDependency extensionDependency, List<ModifableExtensionPlanNode> parentBranch) throws InstallException { CoreExtension coreExtension = this.coreExtensionRepository.getCoreExtension(extensionDependency.getId()); if (coreExtension != null) { ExtensionId feature = coreExtension.getExtensionFeature(extensionDependency.getId()); if (!extensionDependency.getVersionConstraint().isCompatible(feature.getVersion())) { throw new InstallException("Dependency [" + extensionDependency + "] is not compatible with core extension feature [" + feature + "] ([" + coreExtension + "])"); } else { if (getRequest().isVerbose()) { this.logger.debug( "There is already a core extension feature [{}] ([{}]) covering extension dependency [{}]", feature, coreExtension, extensionDependency); } ModifableExtensionPlanNode node = new ModifableExtensionPlanNode(extensionDependency, extensionDependency.getVersionConstraint()); node.setAction( new DefaultExtensionPlanAction(coreExtension, coreExtension, null, Action.NONE, null, true)); parentBranch.add(node); return true; } } return false; }
@Override public CoreExtension resolve(ExtensionDependency extensionDependency) throws ResolveException { CoreExtension extension = getCoreExtension(extensionDependency.getId()); if (extension == null || (!extensionDependency.getVersionConstraint().containsVersion(extension.getId().getVersion()))) { throw new ExtensionNotFoundException("Could not find extension dependency [" + extensionDependency + "]"); } return extension; }
@Override public Extension resolveExtension(ExtensionDependency extensionDependency, String namespace) throws ResolveException { try { return this.coreExtensionRepository.resolve(extensionDependency); } catch (ResolveException notACoreExtension) { InstalledExtension extension = this.installedExtensionRepository.getInstalledExtension(extensionDependency.getId(), namespace); if (extension != null && extensionDependency.getVersionConstraint().containsVersion(extension.getId().getVersion())) { return extension; } try { return this.localExtensionRepository.resolve(extensionDependency); } catch (ResolveException notALocalExtension) { return this.repositoryManager.resolve(extensionDependency); } } }
private AetherExtension resolveMaven(ExtensionDependency extensionDependency) throws ResolveException { Artifact artifact; String artifactExtension; try (XWikiRepositorySystemSession session = createRepositorySystemSession()) { if (extensionDependency instanceof AetherExtensionDependency) { artifact = ((AetherExtensionDependency) extensionDependency).getAetherDependency().getArtifact(); artifactExtension = ((AetherExtensionDependency) extensionDependency).getAetherDependency() .getArtifact().getExtension(); // Find the right version if (!extensionDependency.getVersionConstraint().getRanges().isEmpty()) { artifact = artifact.setVersion(resolveVersionConstraint(artifact, session).toString()); } } else { artifact = AetherUtils.createArtifact(extensionDependency.getId(), extensionDependency.getVersionConstraint().getValue()); artifactExtension = null; // Find the right version if (!extensionDependency.getVersionConstraint().getRanges().isEmpty()) { artifact = artifact.setVersion(resolveVersionConstraint(extensionDependency.getId(), extensionDependency.getVersionConstraint(), session).toString()); } } } return resolveMaven(artifact, artifactExtension); }