/** * @return all the remote repositories */ private Collection<ExtensionRepository> getRepositories() { return this.repositoryManager.getRepositories(); }
/** * @param priority the priority in the list of repositories * @param repository add an existing repository * @since 8.3M1 */ default void addRepository(ExtensionRepository repository, int priority) { addRepository(repository); }
@Override public boolean isFilterable() { return this.repositories.isFilterable(); }
@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 IterableResult<Extension> search(ExtensionQuery inputQuery) throws SearchException { ExtensionQuery query = new ExtensionQuery(inputQuery); query.addFilters(this.filters); return this.repositories.search(query); } }
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; }
@Override public boolean isSortable() { return this.repositories.isSortable(); }
@Override public ExtensionRepository getRepository(String repositoryId) { // Try internal repositories ExtensionRepository repository = this.standardRepositories.get(repositoryId); // Try component repositories ComponentManager componentManager = this.componentManagerProvider.get(); if (componentManager.hasComponent(ExtensionRepository.class, repositoryId)) { try { return componentManager.getInstance(ExtensionRepository.class, repositoryId); } catch (ComponentLookupException e) { this.logger.error("Failed to lookup component", e); } } // Try remote repositories if (repository == null) { repository = this.repositoryManager.getRepository(repositoryId); } return repository; }
/** * @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 IterableResult<Extension> searchFlavors(FlavorQuery query) throws SearchException { IterableResult<Extension> result = null; // Search local flavors try { result = RepositoryUtils.appendSearchResults(result, this.localRepository.search(query)); } catch (SearchException e) { this.logger.error("Failed to search in local repository", e); } // Search remote flavors result = RepositoryUtils.appendSearchResults(result, this.extensionRepositoryManager.search(query)); return result; }
/** * Return ordered (ascendent) versions for the provided extension id. * * @param id the id of the extensions for which to return versions * @param offset the offset from where to start returning versions * @param nb the maximum number of versions to return * @return the versions of the provided extension id */ public IterableResult<Version> resolveVersions(String id, int offset, int nb) { setError(null); IterableResult<Version> versions = null; try { versions = this.repositoryManager.resolveVersions(id, offset, nb); } catch (Exception e) { setError(e); } return versions; }
/** * @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; }
/** * @return all the remote repositories */ public Collection<ExtensionRepository> getRepositories() { return safe(this.repositoryManager.getRepositories()); }
/** * Search among all remote (those listed in xwiki.properties) * {@link org.xwiki.extension.repository.search.AdvancedSearchable} repositories for extensions matching the search * query. * * @param query the search query * @return the found extensions descriptors, empty list if nothing could be found and null if an expected error has * been catched * @see org.xwiki.extension.repository.search.Searchable * @since 7.1RC1 */ public IterableResult<Extension> search(ExtensionQuery query) { setError(null); IterableResult<Extension> result = null; try { result = this.repositoryManager.search(query); } catch (Exception e) { setError(e); } return result; }
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 repository add an existing repository */ void addRepository(ExtensionRepository repository);
/** * @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); } } }
@Override public void onEvent(Event arg0, Object arg1, Object arg2) { // Make sure installed extensions are initialized (it might have already been done but it's OK since initialize // is automatically called only once) this.extensionInitializer.get(); // Update core extension informations // Only if enabled and only if there is any remote extension repositories enabled CoreExtensionRepository coreExtensions = this.coreExtensionsProvider.get(); if (coreExtensions instanceof DefaultCoreExtensionRepository && this.configuration.get().resolveCoreExtensions() && !this.repositoryManagerProvider.get().getRepositories().isEmpty()) { ((DefaultCoreExtensionRepository) coreExtensions).updateExtensions(); } } }
/** * Search among all remote (those listed in xwiki.properties) * {@link org.xwiki.extension.repository.search.Searchable} repositories for extensions matching the search terms. * * @param pattern the words to search for * @param offset the offset from where to start returning search results, 0-based * @param nb the maximum number of search results to return. -1 indicate no limit. 0 indicate that no result will be * returned but it can be used to get the total hits. * @return the found extensions descriptors, empty list if nothing could be found and null if an expected error has * been catched * @see org.xwiki.extension.repository.search.Searchable */ public IterableResult<Extension> search(String pattern, int offset, int nb) { setError(null); IterableResult<Extension> result = null; try { return this.repositoryManager.search(pattern, offset, nb); } catch (Exception e) { setError(e); } return result; }
/** * {@inheritDoc} * * @see org.xwiki.component.phase.Initializable#initialize() */ public void initialize() throws InitializationException { // Load extension repositories for (ExtensionRepositorySource repositoriesSource : this.repositoriesSources) { for (ExtensionRepositoryId repositoryId : repositoriesSource.getExtensionRepositories()) { try { this.repositoryManager.addRepository(repositoryId); } catch (ExtensionRepositoryException e) { getLogger().error("Failed to add repository [" + repositoryId + "]", e); } } } }