@Override public LocalExtension getLocalExtension(ExtensionId extensionId) { return safe(getWrapped().getLocalExtension(extensionId)); }
/** * @param extension the extension to store * @throws LocalExtensionRepositoryException failed to store extension */ private void storeExtension(Extension extension) throws LocalExtensionRepositoryException { if (!this.localExtensionRepository.exists(extension.getId())) { if (getRequest().isVerbose()) { this.logger.info(LOG_DOWNLOADING, "Downloading extension [{}]", extension.getId()); } this.localExtensionRepository.storeExtension(extension); } } }
/** * Get a list of cached extensions from the local extension repository. This doesn't include core extensions, only * custom extensions fetched or installed. * * @return a list of read-only handlers corresponding to the local extensions, an empty list if nothing is available * in the local repository */ public Collection<LocalExtension> getLocalExtensions() { return safe(this.localExtensionRepository.getLocalExtensions()); } }
LocalExtension localExtension = this.localRepository.getLocalExtension(extensionId); if (localExtension == null) { Extension extension; localExtension = this.localRepository.storeExtension(extension);
this.localRepository.setProperties(installedExtension.getLocalExtension(), installedExtension.getProperties()); } catch (Exception e) { LocalExtension localExtension = this.localRepository.getLocalExtension(extension.getId());
@Override @Deprecated public Extension resolveExtension(ExtensionDependency extensionDependency) throws ResolveException { try { return this.coreExtensionRepository.resolve(extensionDependency); } catch (ResolveException notACoreExtension) { try { return this.localExtensionRepository.resolve(extensionDependency); } catch (ResolveException notALocalExtension) { return this.repositoryManager.resolve(extensionDependency); } } }
@Override public LocalExtension storeExtension(Extension extension) { if (!this.hasProgrammingRight) { setError(new UnsupportedOperationException(FORBIDDEN)); return null; } setError(null); try { return safe(getWrapped().storeExtension(extension)); } catch (LocalExtensionRepositoryException e) { setError(e); } return null; }
@Override public void initialize() throws InitializationException { setDescriptor(new DefaultExtensionRepositoryDescriptor("installed", "installed", this.localRepository.getDescriptor().getURI())); // Wait for all installed extension to be registered // before calculating backward dependencies this.updateBackwardDependencies = false; // Get installed extensions from local repository this.localInstalledExtensionsCache = new HashMap<>(); for (LocalExtension localExtension : this.localRepository.getLocalExtensions()) { if (DefaultInstalledExtension.isInstalled(localExtension)) { getInstalledLocalExtension(localExtension); } } // Validate installed extensions validate(); // Update backward dependencies updateMissingBackwardDependencies(); // Put back backdependencies update for each extension add this.updateBackwardDependencies = true; // Reset temporary cache this.localInstalledExtensionsCache = null; }
@Override public void setProperties(LocalExtension localExtension, Map<String, Object> properties) { if (!this.hasProgrammingRight) { setError(new UnsupportedOperationException(FORBIDDEN)); } setError(null); try { getWrapped().setProperties(localExtension, properties); } catch (LocalExtensionRepositoryException e) { setError(e); } } }
private NavigableSet<Version> getVersions(String flavorId) { NavigableSet<Version> versionList = new TreeSet<>(); // Search local versions try { IterableResult<Version> localVersions = this.localExtensionRepository.resolveVersions(flavorId, 0, -1); for (Version version : localVersions) { versionList.add(version); } } catch (ResolveException e) { this.logger.debug("Failed to resolve local versions for extension id [{}]", flavorId, e); } // Search remote versions try { IterableResult<Version> remoteVersions = this.repositoryManager.resolveVersions(flavorId, 0, -1); for (Version version : remoteVersions) { versionList.add(version); } } catch (ResolveException e) { this.logger.debug("Failed to resolve remote versions for extension id [{}]", flavorId, e); } return versionList; }
for (LocalExtension backardDependency : this.localExtensionRepository.getBackwardDependencies( localExtension.getId().getId(), namespace)) { uninstallExtension(backardDependency, namespace); .getBackwardDependencies(localExtension.getId()).entrySet()) { String dependenciesNamespace = entry.getKey(); for (LocalExtension backardDependency : entry.getValue()) { this.localExtensionRepository.uninstallExtension(localExtension, namespace);
@Override public int countExtensions() { return getWrapped().countExtensions(); }
public Map<String, Collection<LocalExtension>> getBackwardDependencies(String id, String version) { setError(null); Map<String, Collection<LocalExtension>> extensions; try { extensions = this.localExtensionRepository.getBackwardDependencies(new ExtensionId(id, version)); } catch (Exception e) { setError(e); extensions = null; } return extensions; }
/** * @param extensionDependency describe the extension to install * @return the extension * @throws InstallException error when trying to resolve extension */ private Extension resolveExtension(ExtensionDependency extensionDependency) throws InstallException { // Check is the extension is already in local repository Extension extension; try { extension = this.localExtensionRepository.resolve(extensionDependency); } catch (ResolveException e) { this.logger.debug("Can't find extension dependency in local repository, trying to download it.", e); // Resolve extension try { extension = this.repositoryManager.resolve(extensionDependency); } catch (ResolveException e1) { throw new InstallException( String.format("Failed to resolve extension dependency [%s]", extensionDependency), e1); } } return extension; }
private void applyUninstallExtension(DefaultInstalledExtension installedExtension, String namespace) throws UninstallException { installedExtension.setInstalled(false, namespace); try { this.localRepository.setProperties(installedExtension.getLocalExtension(), installedExtension.getProperties()); } catch (Exception e) { throw new UninstallException("Failed to modify extension descriptor", e); } // Clean caches removeInstalledExtension(installedExtension, namespace); }
private NavigableSet<Version> getVersions(InstalledExtension extension, String namespace) { NavigableSet<Version> versionList = new TreeSet<>(); // Search local versions try { IterableResult<Version> versions = this.localExtensionRepository.resolveVersions(extension.getId().getId(), 0, -1); for (Version version : versions) { versionList.add(version); } } catch (ResolveException e) { this.logger.debug("Failed to resolve local versions for extension id [{}]", extension.getId().getId(), e); } // Search remote versions try { IterableResult<Version> versions = this.repositoryManager.resolveVersions(extension.getId().getId(), 0, -1); for (Version version : versions) { versionList.add(version); } } catch (ResolveException e) { this.logger.debug("Failed to resolve remote versions for extension id [{}]", extension.getId().getId(), e); } // Make sure the current version is included if the extension is invalid (it's possible this version does // not exist on any repository) if (!extension.isValid(namespace)) { versionList.add(extension.getId().getVersion()); } return versionList; }
/** * @param extensionId the extension identifier * @return the resolved extension * @throws ResolveException error when trying to resolve extension */ private Extension resolveExtensionFromInstalled(ExtensionId extensionId) throws ResolveException { try { return this.installedExtensionRepository.resolve(extensionId); } catch (ResolveException notAnInstalledExtension) { try { return this.localExtensionRepository.resolve(extensionId); } catch (ResolveException notALocalExtension) { return this.repositoryManager.resolve(extensionId); } } }
/** * @param extensionId the identifier of the extension to install * @return the extension * @throws InstallException error when trying to resolve extension */ private Extension resolveExtension(ExtensionId extensionId) throws InstallException { // Check if the extension is already in local repository Extension extension = this.localExtensionRepository.getLocalExtension(extensionId); if (extension == null) { this.logger.debug("Can't find extension in local repository, trying to download it."); // Resolve extension try { extension = this.repositoryManager.resolve(extensionId); } catch (ResolveException e1) { throw new InstallException(String.format("Failed to resolve extension [%s]", extensionId), e1); } } return extension; }
@Override public Collection<LocalExtension> getLocalExtensions() { return safe(getWrapped().getLocalExtensions()); }
this.localRepository.setProperties(installedExtension.getLocalExtension(), installedExtension.getProperties()); } catch (Exception e) {