@Override public VersionConstraint getInitialVersionConstraint() { return this.initialDependency != null ? this.initialDependency.getVersionConstraint() : null; }
/** * @param extensions the extensions containing the dependencies for which to merge the constraints * @param feature the id of the dependency * @param previousMergedVersionContraint if not null it's merged with the provided extension dependencies version * constraints * @return the merged version constraint * @throws IncompatibleVersionConstraintException the provided version constraint is compatible with the provided * version constraint */ private VersionConstraint mergeVersionConstraints(Collection<? extends Extension> extensions, String feature, VersionConstraint previousMergedVersionContraint) throws IncompatibleVersionConstraintException { VersionConstraint mergedVersionContraint = previousMergedVersionContraint; if (extensions != null) { for (Extension extension : extensions) { ExtensionDependency dependency = getDependency(extension, feature); if (dependency != null) { if (mergedVersionContraint == null) { mergedVersionContraint = dependency.getVersionConstraint(); } else { mergedVersionContraint = mergedVersionContraint.merge(dependency.getVersionConstraint()); } } } } return mergedVersionContraint; }
/** * 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()); } } }
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; }
/** * @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; }
@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; } }
@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 + "]"); }
/** * @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; }
/** * 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()); }
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); }
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; }
if (extensionDependency.getVersionConstraint() == null) { VersionConstraint versionConstraint = extensionDependency.getVersionConstraint(); targetDependency.getVersionConstraint()); targetDependency = new DefaultExtensionDependency(targetDependency, versionConstraint);
@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); } } }
if (!isCompatible(coreExtension.getId().getVersion(), dependency.getVersionConstraint())) { throw new InvalidExtensionException(String .format("Dependency [%s] is incompatible with the core extension [%s]", dependency, coreExtension));
? new ModifableExtensionPlanNode(initialDependency, initialDependency.getVersionConstraint()) : new ModifableExtensionPlanNode();