private void validateExtension(LocalExtension localExtension, Map<String, Set<String>> validatedExtension, String namespace) { Set<String> extensions = validatedExtension.get(namespace); if (extensions == null) { extensions = new HashSet<String>(); validatedExtension.put(namespace, extensions); } if (!extensions.contains(localExtension.getId().getId())) { validateExtension(localExtension, extensions, namespace); } }
private void removeFromBackwardDependencies(LocalExtension localExtension) { Collection<String> namespaces = localExtension.getNamespaces(); if (namespaces == null) { this.backwardDependenciesMap.remove(localExtension.getId().getId()); } else { Map<String, Set<LocalExtension>> namespaceBackwardDependencies = this.backwardDependenciesMap.get(localExtension.getId().getId()); for (String namespace : namespaces) { namespaceBackwardDependencies.remove(namespace); } } }
private void saveDescriptor(LocalExtension extension) throws ParserConfigurationException, TransformerException, IOException { File file = getDescriptorFile(extension.getId()); FileOutputStream fos = new FileOutputStream(file); try { this.extensionSerializer.saveDescriptor(extension, fos); } finally { fos.close(); } }
private void addLocalExtension(LocalExtension localExtension) { // extensions this.extensions.put(localExtension.getId(), localExtension); // versions List<LocalExtension> extensionsVersions = this.extensionsVersions.get(localExtension.getId().getId()); if (extensionsVersions == null) { extensionsVersions = new ArrayList<LocalExtension>(); this.extensionsVersions.put(localExtension.getId().getId(), extensionsVersions); extensionsVersions.add(localExtension); } else { int index = 0; while (index < extensionsVersions.size() && versionManager.compareVersions(localExtension.getId().getVersion(), extensionsVersions.get(index) .getId().getVersion()) > 0) { ++index; } extensionsVersions.add(index, localExtension); } }
public Map<String, Collection<LocalExtension>> getBackwardDependencies(ExtensionId extensionId) throws ResolveException { Map<String, Collection<LocalExtension>> result; LocalExtension localExtension = (LocalExtension) resolve(extensionId); Collection<String> namespaces = localExtension.getNamespaces(); Map<String, Set<LocalExtension>> backwardDependencies = this.backwardDependenciesMap.get(localExtension.getId().getId()); if (backwardDependencies != null) { result = new HashMap<String, Collection<LocalExtension>>(); for (Map.Entry<String, Set<LocalExtension>> entry : backwardDependencies.entrySet()) { if (namespaces == null || namespaces.contains(entry.getKey())) { result.put(entry.getKey(), Collections.unmodifiableCollection(entry.getValue())); } } } else { result = Collections.emptyMap(); } return result; } }
@Override public void removeExtension(LocalExtension extension) throws ResolveException { DefaultLocalExtension localExtension = resolve(extension.getId()); try { this.storage.removeExtension(localExtension); } catch (IOException e) { // Should not happen if the local extension exists this.logger.error("Failed to remove extension [" + extension + "]", e); } // Remove the extension from the caches removeCachedExtension(localExtension); } }
@Override public void setProperties(LocalExtension localExtension, Map<String, Object> properties) throws LocalExtensionRepositoryException { DefaultLocalExtension extension = this.extensions.get(localExtension.getId()); if (extension != null) { extension.setProperties(properties); try { this.storage.saveDescriptor(extension); } catch (Exception e) { throw new LocalExtensionRepositoryException( "Failed to save descriptor for extension [" + localExtension + "]", e); } } }
@Override public void initialize(LocalExtension localExtension, String namespace) throws ExtensionException { try { ExtensionHandler extensionHandler = getExtensionHandler(localExtension); extensionHandler.initialize(localExtension, namespace); } catch (Exception e) { throw new InstallException("Failed to initialize extension [" + localExtension.getId() + "]", e); } } }
public void uninstallExtension(LocalExtension localExtension, String namespace) throws UninstallException { LocalExtension existingExtension = getInstalledExtension(localExtension.getId().getId(), namespace); if (existingExtension == localExtension) { uninstallLocalExtension((DefaultLocalExtension) localExtension, namespace); } }
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; }
/** * Register a newly installed extension in backward dependencies map. * * @param localExtension the local extension to register * @param namespace the namespace * @param valid is the extension valid * @return the new {@link DefaultInstalledExtension} */ private DefaultInstalledExtension addInstalledExtension(LocalExtension localExtension, String namespace, boolean valid) { DefaultInstalledExtension installedExtension = this.extensions.get(localExtension.getId()); if (installedExtension == null) { installedExtension = new DefaultInstalledExtension(localExtension, this); } installedExtension.setInstalled(true, namespace); installedExtension.setValid(namespace, valid); addInstalledExtension(installedExtension, namespace); return installedExtension; }
public void saveDescriptor(LocalExtension extension, FileOutputStream fos) throws ParserConfigurationException, TransformerException, IOException { DocumentBuilder documentBuilder = this.documentBuilderFactory.newDocumentBuilder(); Document document = documentBuilder.newDocument(); Element extensionElement = document.createElement("extension"); document.appendChild(extensionElement); addElement(document, extensionElement, "id", extension.getId().getId()); addElement(document, extensionElement, "version", extension.getId().getVersion()); addElement(document, extensionElement, "type", extension.getType()); addElement(document, extensionElement, "dependency", String.valueOf(extension.isDependency())); addElement(document, extensionElement, "installed", String.valueOf(extension.isInstalled())); addElement(document, extensionElement, "description", extension.getDescription()); addElement(document, extensionElement, "author", extension.getAuthor()); addElement(document, extensionElement, "website", extension.getWebSite()); addDependencies(document, extensionElement, extension); addNamespaces(document, extensionElement, extension); TransformerFactory transfac = TransformerFactory.newInstance(); Transformer trans = transfac.newTransformer(); trans.setOutputProperty(OutputKeys.INDENT, "yes"); DOMSource source = new DOMSource(document); Result result = new StreamResult(fos); trans.transform(source, result); }
@Override public void install(LocalExtension localExtension, String namespace, Request request) throws InstallException { ExtensionHandler extensionHandler; try { extensionHandler = getExtensionHandler(localExtension); } catch (ComponentLookupException e) { throw new InstallException(LOOKUPERROR + '[' + localExtension + ']', e); } try { extensionHandler.install(localExtension, namespace, request); } catch (Exception e) { throw new InstallException("Failed to install extension [" + localExtension.getId() + "]", e); } }
private void getInstalledLocalExtension(LocalExtension localExtension) { getInstalledLocalExtension(localExtension.getId().getId(), localExtension); for (ExtensionId feature : localExtension.getExtensionFeatures()) { getInstalledLocalExtension(feature.getId(), localExtension); } }
public void install(LocalExtension localExtension, String namespace) throws InstallException { ExtensionHandler extensionHandler; try { // Load extension extensionHandler = getExtensionHandler(localExtension); } catch (ComponentLookupException e) { throw new InstallException("Can't find any extension handler for the extension type [" + localExtension + "]", e); } try { extensionHandler.install(localExtension, namespace); } catch (Exception e) { // TODO: cleanup throw new InstallException("Failed to install extension [" + localExtension.getId() + "]", e); } }
@Override public void upgrade(Collection<InstalledExtension> previousLocalExtensions, LocalExtension newLocalExtension, String namespace, Request request) throws InstallException { ExtensionHandler extensionHandler; try { extensionHandler = getExtensionHandler(newLocalExtension); } catch (ComponentLookupException e) { throw new InstallException(LOOKUPERROR + '[' + newLocalExtension + ']', e); } try { extensionHandler.upgrade(previousLocalExtensions, newLocalExtension, namespace, request); } catch (InstallException e) { throw e; } catch (Exception e) { throw new InstallException("Failed to upgrade from extension [" + previousLocalExtensions + "] to extension [" + newLocalExtension.getId() + "]", e); } }
this.observationManager.notify(new ExtensionUpgraded(localExtension.getId()), localExtension, previousExtension); } else { this.extensionHandlerManager.install(localExtension, namespace); this.observationManager.notify(new ExtensionInstalled(localExtension.getId()), localExtension, previousExtension);
public LocalExtension installExtension(Extension extension, boolean dependency, String namespace) throws InstallException { LocalExtension localExtension = getInstalledExtension(extension.getId().getId(), namespace); if (localExtension == null || !extension.getId().getVersion().equals(localExtension.getId().getVersion()) || (localExtension.getNamespaces() != null && !localExtension.getNamespaces().contains(namespace))) { localExtension = createExtension(extension, dependency); try { extension.download(localExtension.getFile()); saveDescriptor(localExtension); addLocalExtension(localExtension, namespace); } catch (Exception e) { // TODO: clean throw new InstallException("Failed to download extension [" + extension + "]", e); } } return 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); }
private LocalExtension installExtension(ExtensionId extensionId, boolean dependency, String namespace) throws InstallException { if (this.coreExtensionRepository.exists(extensionId.getId())) { throw new InstallException("[" + extensionId.getId() + "]: core extension"); } LocalExtension previousExtension = null; LocalExtension localExtension = this.localExtensionRepository.getInstalledExtension(extensionId.getId(), namespace); if (localExtension != null) { int diff = this.versionManager.compareVersions(extensionId.getVersion(), localExtension.getId().getVersion()); if (diff == 0) { throw new InstallException("[" + extensionId.getId() + "]: already installed"); } else if (diff < 0) { throw new InstallException("[" + extensionId.getId() + "]: a more recent version is already installed"); } else { // upgrade previousExtension = localExtension; } } return installExtension(previousExtension, extensionId, dependency, namespace); }