/** * @param patternMatcher matches a set of elements * @param extension the extension to match * @return true if one of the element is matched */ public static boolean matches(Pattern patternMatcher, Extension extension) { return matches( patternMatcher, extension.getId().getId(), extension.getDescription(), extension.getSummary(), extension.getName(), extension.getFeatures()); }
/** * Check if provided id/version is compatible with provided extensions dependencies constraints. */ private boolean isCompatible( Collection<? extends Extension> extensions, String id, Version version) { if (extensions != null) { for (Extension extension : extensions) { for (ExtensionDependency dependency : extension.getDependencies()) { if (dependency.getId().equals(id)) { if (!dependency.getVersionConstraint().isCompatible(version)) { return false; } } } } } return true; }
/** * 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 filter the filter * @param extension the extension to match * @return true if the extension is matched by the filer * @since 7.0M2 */ public static boolean matches(Filter filter, Extension extension) { Object value = extension.get(filter.getField()); if (value != null) { return matches(filter, value); } // Unknown field // FIXME: not sure if it's should be true or false in this case return true; }
/** * Matches an extension in a case insensitive way. * * @param patternMatcher the pattern to match * @param filters the filters * @param extension the extension to match * @return true if one of the element is matched * @since 7.0M2 */ public static boolean matches( Pattern patternMatcher, Collection<Filter> filters, Extension extension) { if (matches( patternMatcher, extension.getId().getId(), extension.getDescription(), extension.getSummary(), extension.getName(), extension.getFeatures())) { for (Filter filter : filters) { if (!matches(filter, extension)) { return false; } } return true; } return false; }
/** * Indicate if the extension as been installed as a dependency of another one. * * @param extension the extension * @param namespace the namespace to look at, null indicate the root namespace * @return true if the the extension has been installed only because it was a dependency of * another extension * @see InstalledExtension#isDependency(String) * @since 8.2RC1 */ public static boolean isDependency(Extension extension, String namespace) { boolean isDependency = false; if (namespace == null) { isDependency = extension.getProperty(PKEY_DEPENDENCY, false); } else { Object namespacesObject = extension.getProperty(PKEY_NAMESPACES); // RETRO-COMPATIBILITY: used to be a String collection with just the actual namespaces if (namespacesObject instanceof Map) { Map<String, Object> installedNamespace = ((Map<String, Map<String, Object>>) namespacesObject).get(namespace); isDependency = installedNamespace != null ? (installedNamespace.get(PKEY_NAMESPACES_DEPENDENCY) == Boolean.TRUE) : isDependency(extension, null); } else { isDependency = isDependency(extension, null); } } return isDependency; }
/** * @param extension the extension * @return the namespaces in which this extension is enabled. Null means root namespace (i.e all * namespaces). */ public static Collection<String> getNamespaces(Extension extension) { Collection<String> namespaces; Object namespacesObject = extension.getProperty(PKEY_NAMESPACES); // RETRO-COMPATIBILITY: used to be a String collection with just the actual namespaces if (namespacesObject == null) { namespaces = null; } else if (namespacesObject instanceof Collection) { namespaces = (Collection<String>) namespacesObject; } else { namespaces = ((Map<String, Map<String, Object>>) namespacesObject).keySet(); } return namespaces; }
/** * @param previousExtension the previous installed version of the extension to install * @param extension the new extension to install * @param dependency indicate if the extension is installed as a dependency * @param namespace the namespace where to install the extension * @return the install plan node for the provided extension * @param initialDependency the initial dependency used to resolve the extension * @throws InstallException error when trying to install provided extension */ private ModifableExtensionPlanNode installExtension( InstalledExtension previousExtension, Extension extension, boolean dependency, String namespace, ExtensionDependency initialDependency) throws InstallException, ResolveException { // Is feature core extension for (String feature : extension.getFeatures()) { if (this.coreExtensionRepository.exists(feature)) { throw new InstallException( String.format("There is already a core extension with the id [%s]", feature)); } } // Find all previous version of the extension Set<InstalledExtension> previousExtensions = new LinkedHashSet<InstalledExtension>(); if (previousExtension != null) { previousExtensions.add(previousExtension); } if (!extension.getFeatures().isEmpty()) { for (String feature : extension.getFeatures()) { InstalledExtension installedExtension = checkAlreadyInstalledExtension(feature, extension.getId().getVersion(), namespace); if (installedExtension != null) { previousExtensions.add(installedExtension); } } } ExtensionHandler extensionHandler; // Is type supported ? try { extensionHandler = this.componentManager.getInstance(ExtensionHandler.class, extension.getType()); } catch (ComponentLookupException e) { throw new InstallException(String.format("Unsupported type [%s]", extension.getType()), e); } // Is installing the extension allowed ? extensionHandler.checkInstall(extension, namespace, getRequest()); // Check dependencies Collection<? extends ExtensionDependency> dependencies = extension.getDependencies(); notifyPushLevelProgress(dependencies.size() + 1); try { List<ModifableExtensionPlanNode> children = null; if (!dependencies.isEmpty()) { children = new ArrayList<ModifableExtensionPlanNode>(); for (ExtensionDependency dependencyDependency : extension.getDependencies()) { installExtensionDependency(dependencyDependency, namespace, children); notifyStepPropress(); } } ModifableExtensionPlanNode node = initialDependency != null ? new ModifableExtensionPlanNode( initialDependency, initialDependency.getVersionConstraint()) : new ModifableExtensionPlanNode(); node.setChildren(children); Action action; if (!previousExtensions.isEmpty()) { if (previousExtensions .iterator() .next() .getId() .getVersion() .compareTo(extension.getId().getVersion()) > 0) { action = Action.DOWNGRADE; } else { action = Action.UPGRADE; } } else { action = Action.INSTALL; } node.setAction( new DefaultExtensionPlanAction( extension, previousExtensions, action, namespace, dependency)); return node; } finally { notifyPopLevelProgress(); } }
/** * @param extension the extension * @return true if the extension is installed * @see InstalledExtension#isInstalled() */ public static boolean isInstalled(Extension extension) { return extension.getProperty(PKEY_INSTALLED, false); }