/** * Get a list of all currently installed extensions. This doesn't include core extensions, only custom extensions * installed by the administrators. * * @return a list of read-only handlers corresponding to the installed extensions, an empty list if nothing is * installed */ public Collection<InstalledExtension> getInstalledExtensions() { return safe(this.installedExtensionRepository.getInstalledExtensions()); }
private void getInstalledExtensions(String feature, String namespace, Set<InstalledExtension> installedExtensions) { if (namespace == null) { getInstalledExtensions(feature, installedExtensions); } else { InstalledExtension installedExtension = this.installedExtensionRepository.getInstalledExtension(feature, namespace); if (installedExtension != null) { installedExtensions.add(installedExtension); } } }
private Map<String, Set<InstalledExtension>> getBackwardDependencies( Collection<InstalledExtension> installedExtensions, String namespace) throws ResolveException { Map<String, Set<InstalledExtension>> backwardDependencies = new LinkedHashMap<>(); for (InstalledExtension installedExtension : installedExtensions) { if (namespace == null) { for (Map.Entry<String, Collection<InstalledExtension>> entry : this.installedExtensionRepository .getBackwardDependencies(installedExtension.getId()).entrySet()) { Set<InstalledExtension> namespaceBackwardDependencies = backwardDependencies.get(entry.getKey()); if (namespaceBackwardDependencies == null) { namespaceBackwardDependencies = new LinkedHashSet<>(); backwardDependencies.put(entry.getKey(), namespaceBackwardDependencies); } namespaceBackwardDependencies.addAll(entry.getValue()); } } else { for (InstalledExtension backwardDependency : this.installedExtensionRepository .getBackwardDependencies(installedExtension.getId().getId(), namespace)) { Set<InstalledExtension> namespaceBackwardDependencies = backwardDependencies.get(namespace); if (namespaceBackwardDependencies == null) { namespaceBackwardDependencies = new LinkedHashSet<>(); backwardDependencies.put(namespace, namespaceBackwardDependencies); } namespaceBackwardDependencies.add(backwardDependency); } } } return backwardDependencies; }
protected Collection<InstalledExtension> getInstalledExtensions() { Collection<ExtensionId> requestExtensions = getRequest().getExtensions(); Collection<InstalledExtension> installedExtensions; if (requestExtensions != null && !requestExtensions.isEmpty()) { installedExtensions = new ArrayList<>(requestExtensions.size()); for (ExtensionId requestExtension : requestExtensions) { InstalledExtension installedExtension = this.installedExtensionRepository.getInstalledExtension(requestExtension); installedExtensions.add(installedExtension); } } else { installedExtensions = this.installedExtensionRepository.getInstalledExtensions(); } return installedExtensions; }
@Override public InstalledExtension getFlavorExtension(Namespace namespace) { try { for (InstalledExtension extension : this.installedRepository .searchInstalledExtensions(namespace.serialize(), new FlavorQuery())) { // Assume there is only one non dependency with the tag "flavor" so return the first one found if (!extension.isDependency(namespace.serialize())) { // There should be only one flavor per wiki return extension; } } } catch (SearchException e) { // It should never happen with the local repository } // If nothing has been found, look for extensions that was not tagged as flavors but that are in the list of // old flavors for (String oldFlavor : getExtensionsConsideredAsFlavors()) { InstalledExtension installedExtension = this.installedRepository.getInstalledExtension(oldFlavor, namespace.serialize()); if (installedExtension != null) { return installedExtension; } } // It seems there is no known UI on this wiki return null; }
if (installedRepository.getInstalledExtension(localExtension.getId().getId(), namespace) == null) { for (ExtensionId feature : localExtension.getExtensionFeatures()) { if (installedRepository.getInstalledExtension(feature.getId(), namespace) != null) { installedRepository.installExtension(localExtension, namespace, false); } catch (Exception e) { this.logger.error("Failed to register extenion [{}] from the XAR", extensionId, e);
this.installedExtensionRepository.getInstalledExtension(extensionDependency.getId(), namespace); if (installedExtension.isInstalled(null)) { Map<String, Collection<InstalledExtension>> backwardDependencies = this.installedExtensionRepository.getBackwardDependencies(installedExtension.getId()); .getBackwardDependencies(installedExtension.getId().getId(), namespace);
/** * Search installed extensions based of the provided query. * * @param query the extension query used to filter and order the result * @return the found extensions descriptors, empty list if nothing could be found * @throws SearchException error when trying to search provided pattern * @since 8.1RC1 */ default IterableResult<InstalledExtension> searchInstalledExtensions(ExtensionQuery query) throws SearchException { return searchInstalledExtensions((String) null, query); }
this.installedExtensionRepository.installExtension(extension, namespace, dependency, properties); } finally { if (installedExtension != null) { this.installedExtensionRepository.uninstallExtension(previousExtension, namespace); } catch (UninstallException e) { this.logger.error("Failed to uninstall extension [" + previousExtension.getId() + "]", e); this.installedExtensionRepository.installExtension(extension, namespace, dependency, properties); } finally { if (installedExtension != null) {
@Override public InstalledExtension installExtension(LocalExtension extension, String namespace, boolean dependency, Map<String, Object> properties) { if (!this.hasProgrammingRight) { setError(new UnsupportedOperationException(FORBIDDEN)); return null; } setError(null); try { return safe(getWrapped().installExtension(extension, namespace, dependency, properties)); } catch (InstallException e) { setError(e); } return null; }
@Override public void uninstallExtension(InstalledExtension extension, String namespace) { if (!this.hasProgrammingRight) { setError(new UnsupportedOperationException(FORBIDDEN)); return; } setError(null); try { getWrapped().uninstallExtension(extension, namespace); } catch (UninstallException e) { setError(e); } }
protected Collection<InstalledExtension> getInstalledExtensions(String namespace) { Collection<ExtensionId> requestExtensions = getRequest().getExtensions(); Collection<InstalledExtension> installedExtensions; if (requestExtensions != null && !requestExtensions.isEmpty()) { installedExtensions = new ArrayList<>(requestExtensions.size()); for (ExtensionId requestExtension : requestExtensions) { InstalledExtension installedExtension = this.installedExtensionRepository.getInstalledExtension(requestExtension); if (installedExtension.isInstalled(namespace)) { installedExtensions.add(installedExtension); } } } else { installedExtensions = this.installedExtensionRepository.getInstalledExtensions(namespace); } return installedExtensions; }
/** * Search installed extensions based of the provided query and only in the passed namespaces. * * @param namespaces the namespaces where to search * @param query the extension query used to filter and order the result * @return the found extensions descriptors, empty list if nothing could be found * @throws SearchException error when trying to search provided pattern * @since 8.1RC1 */ default IterableResult<InstalledExtension> searchInstalledExtensions(Collection<String> namespaces, ExtensionQuery query) throws SearchException { return searchInstalledExtensions( namespaces != null && !namespaces.isEmpty() ? namespaces.iterator().next() : null, query); } }
/** * @param installedExtension the existing extension * @param namespace the namespace in which to perform the action * @throws ExtensionException failed to initialize extension */ private void repairExtension(InstalledExtension installedExtension, String namespace) throws ExtensionException { this.observationManager.notify(new ExtensionInstallingEvent(installedExtension.getId(), namespace), installedExtension); boolean success = false; try { // Initialize extension (invalid extensions are not initialized at startup) this.extensionHandlerManager.initialize(installedExtension, namespace); // Repair the extension this.installedExtensionRepository.installExtension(installedExtension, namespace, installedExtension.isDependency(namespace)); success = true; } finally { if (success) { this.observationManager.notify(new ExtensionInstalledEvent(installedExtension.getId(), namespace), installedExtension); } else { this.observationManager.notify(new ExtensionInstallFailedEvent(installedExtension.getId(), namespace), installedExtension); } } }
/** * @param installedExtension the existing extension * @param namespace the namespace in which to perform the action * @throws UninstallException failed to uninstall extension */ private void uninstallExtension(InstalledExtension installedExtension, String namespace) throws UninstallException { this.observationManager.notify(new ExtensionUninstallingEvent(installedExtension.getId(), namespace), installedExtension); boolean success = false; try { // Unload extension this.extensionHandlerManager.uninstall(installedExtension, namespace, getRequest()); // Uninstall from local repository this.installedExtensionRepository.uninstallExtension(installedExtension, namespace); success = true; } finally { if (success) { this.observationManager.notify(new ExtensionUninstalledEvent(installedExtension.getId(), namespace), installedExtension); } else { this.observationManager.notify(new ExtensionUninstallFailedEvent(installedExtension.getId(), namespace), installedExtension); } } }
/** * Return all the extensions available for the provide namespace. This also include root extension since namespaces * inherit from root. * <p> * This doesn't include core extensions, only extension installed through the API. * * @param namespace the target namespace for which to retrieve the list of installed extensions * @return a list of read-only handlers corresponding to the installed extensions, an empty list if nothing is * installed in the target namespace */ public Collection<InstalledExtension> getInstalledExtensions(String namespace) { return safe(this.installedExtensionRepository.getInstalledExtensions(namespace)); }
/** * Get the extension handler corresponding to the given installed extension ID or feature (virtual ID) provided by * the extension and namespace. * <p> * The returned handler can be used to get more information about the extension, such as the authors, an extension * description, its license... * * @param feature the extension id or provided feature (virtual extension) of the extension to resolve * @param namespace the optional namespace where the extension should be installed * @return the read-only handler corresponding to the requested extension, or {@code null} if the extension isn't * installed in the target namespace */ public InstalledExtension getInstalledExtension(String feature, String namespace) { return safe(this.installedExtensionRepository.getInstalledExtension(feature, namespace)); }
private void unloadJARFromNamespace(InstalledExtension installedExtension, String namespace, Map<String, Set<InstalledExtension>> unloadedExtensions, Set<InstalledExtension> unloadedExtensionsInNamespace) throws UninstallException { try { Collection<InstalledExtension> bDependencies = this.installedExtensionRepository .getBackwardDependencies(installedExtension.getId().getId(), namespace); for (InstalledExtension bDependency : bDependencies) { unloadJAR(bDependency, namespace, unloadedExtensions); } } catch (ResolveException e) { this.logger.error("Failed to get backward dependencies for installed extension [{}] on namespace [{}]", installedExtension, namespace, e); } this.jarHandler.uninstall(installedExtension, namespace, null); unloadedExtensionsInNamespace.add(installedExtension); } }
@Override public IterableResult<Extension> search(ExtensionQuery query) throws SearchException { return (IterableResult) (this.namespace != null ? getWrapped().searchInstalledExtensions(this.serializedNamespace, query) : getWrapped().searchInstalledExtensions(query)); } }
@Override public void initialize(String namespaceToInitialize, String type) { Map<String, Set<InstalledExtension>> initializedExtensions = new HashMap<>(); // Load extensions from local repository Collection<InstalledExtension> installedExtensions; if (namespaceToInitialize != null) { installedExtensions = this.installedExtensionRepository.getInstalledExtensions(namespaceToInitialize); } else { installedExtensions = this.installedExtensionRepository.getInstalledExtensions(); } for (InstalledExtension installedExtension : installedExtensions) { if (type == null || type.equals(installedExtension.getType())) { try { initializeExtension(installedExtension, namespaceToInitialize, initializedExtensions); } catch (Throwable t) { this.logger.error("Failed to initialize local extension [{}]", installedExtension.getId(), t); } } } }