/** * @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; }
/** * 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 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()); } } }
private boolean hasIncompatileRootDependency(ExtensionDependency extensionDependency) { InstalledExtension rootExtension = this.installedExtensionRepository.getInstalledExtension(extensionDependency.getId(), null); return rootExtension != null && !extensionDependency.isCompatible(rootExtension); }
/** * @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 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); } } } }
@Override public VersionConstraint getInitialVersionConstraint() { return this.initialDependency != null ? this.initialDependency.getVersionConstraint() : null; }
/** * Install provided extension dependency. * * @param extensionDependency the extension dependency to install * @param namespace the namespace where to install the extension * @param parentBranch the children of the parent {@link DefaultExtensionPlanNode} * @param managedDependencies the managed dependencies * @param parents the parents extensions (which triggered this extension install) * @throws InstallException error when trying to install provided extension * @throws ResolveException * @throws IncompatibleVersionConstraintException */ private void installExtensionDependency(ExtensionDependency extensionDependency, String namespace, List<ModifableExtensionPlanNode> parentBranch, Map<String, ExtensionDependency> managedDependencies, Set<String> parents) throws InstallException, IncompatibleVersionConstraintException, ResolveException { if (extensionDependency.isOptional()) { installOptionalExtensionDependency(extensionDependency, namespace, parentBranch, managedDependencies, parents); } else { installMandatoryExtensionDependency(extensionDependency, namespace, parentBranch, managedDependencies, parents); } }
/** * Indicate if the passed extension is compatible with this dependency. * * @param extension the extension to check * @return true if the passed extension is compatible, false otherwise * @since 8.1M1 */ default boolean isCompatible(Extension extension) { if (isCompatible(extension.getId())) { return true; } for (ExtensionId extensionId : extension.getExtensionFeatures()) { if (isCompatible(extensionId)) { return true; } } return false; }
for (ExtensionRepositoryDescriptor repositoryDescriptor : extensionDependency.getRepositories()) { if (checkedRepositories.contains(repositoryDescriptor)) { continue; } catch (ExtensionRepositoryException e) { this.logger.warn("Invalid repository [{}] in extension dependency", extensionDependency.getRepositories(), extensionDependency, ExceptionUtils.getRootCauseMessage(e));
/** * 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; }
if (!this.coreExtensionRepository.exists(dependency.getId())) { InstalledExtension dependencyExtension = this.installedExtensionRepository.getInstalledExtension(dependency.getId(), namespace); initializeExtensionInNamespace(dependencyExtension, namespace, initializedExtensions); } catch (Exception e) { if (dependency.isOptional()) { this.logger.warn("Failed to initialize dependency [{}]: {}", dependency, ExceptionUtils.getRootCauseMessage(e));
/** * @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; }
if (!dependency.isOptional()) {
/** * 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()); }
/** * @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 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); } }
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 + "]"); }
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()); } } }