private void checkCoreExtension(String feature) throws InstallException { if (this.coreExtensionRepository.exists(feature)) { throw new InstallException( String.format("There is already a core extension covering feature [%s]", feature)); } }
private LocalExtension installExtension(LocalExtension previousExtension, ExtensionId extensionId, boolean dependency, String namespace) throws InstallException { // Resolve extension Extension remoteExtension; try { remoteExtension = this.repositoryManager.resolve(extensionId); } catch (ResolveException e) { throw new InstallException("Failed to resolve extension [" + extensionId + "]", e); } if (remoteExtension == null) { throw new InstallException("Failed to resolve extension [" + extensionId + "]"); } try { return installExtension(previousExtension, remoteExtension, dependency, namespace); } catch (Exception e) { throw new InstallException("Failed to install extension", e); } }
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 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); } }
@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); } }
public void upgrade(LocalExtension previousLocalExtension, LocalExtension newLocalExtension, String namespace) throws InstallException { try { uninstall(previousLocalExtension, namespace); } catch (UninstallException e) { throw new InstallException("Failed to uninstall previous extension [" + previousLocalExtension + "]"); } install(newLocalExtension, namespace); } }
@Override public void upgrade(Collection<InstalledExtension> previousInstalledExtensions, LocalExtension newLocalExtension, String namespace, Request request) throws InstallException { for (InstalledExtension previousExtension : previousInstalledExtensions) { try { uninstall(previousExtension, namespace, request); } catch (UninstallException e) { throw new InstallException("Failed to uninstall previous extension [" + previousExtension + "]", e); } } install(newLocalExtension, namespace, null); }
public void upgrade(LocalExtension previousLocalExtension, LocalExtension newLocalExtension, String namespace) throws InstallException { try { // Load extension ExtensionHandler extensionInstaller = getExtensionHandler(previousLocalExtension); extensionInstaller.upgrade(previousLocalExtension, newLocalExtension, namespace); } catch (ComponentLookupException e) { throw new InstallException("Can't find any extension handler for the extension type [" + newLocalExtension + "]"); } } }
/** * @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; }
/** * @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; }
@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); } } }
private boolean checkRootExtension(String feature) throws InstallException { InstalledExtension rootExtension = this.installedExtensionRepository.getInstalledExtension(feature, null); if (rootExtension != null) { if (!getRequest().isRootModificationsAllowed()) { throw new InstallException( String.format("An extension with feature [%s] is already installed on root namespace ([%s])", feature, rootExtension.getId())); } return true; } return false; }
protected void checkTypeInstall(Extension extension, String namespace) throws InstallException { 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()); }
&& installedExtension.isValid(namespace)) { if (installedExtension.isDependency(namespace) == dependency) { throw new InstallException(String.format("The extension [%s] is already installed on namespace [%s]", installedExtension, namespace)); installedExtension.getProperties()); } catch (Exception e) { throw new InstallException("Failed to modify extension descriptor", e); throw new InstallException(String.format("The extension [%s] need to be stored first", extension));
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); }
private Extension checkInstalledExtension(Extension extension, String namespace) throws InstallException { // Check if the extension conflict with an extension installed on root namespace if (namespace != null) { checkRootExtension(extension); } // Check if the exact same valid extension is already installed on target namespace InstalledExtension installedExtension = this.installedExtensionRepository.getInstalledExtension(extension.getId()); if (installedExtension != null && installedExtension.isInstalled(namespace)) { if (installedExtension.isValid(namespace)) { throw new InstallException(String.format("Extension [%s] is already installed on namespace [%s]", extension.getId(), namespace)); } // In case the extension is already installed on the namespace but is invalid continue with it to make clear // to following code we are actually repairing it return installedExtension; } return extension; }
@Override public void install(LocalExtension localExtension, String namespace, Request request) throws InstallException { NamespaceURLClassLoader classLoader = this.jarExtensionClassLoader.getURLClassLoader(namespace, true); // 1) load jar into classloader try { classLoader.addURL(getExtensionURL(localExtension)); } catch (MalformedURLException e) { throw new InstallException("Failed to load jar file", e); } // 2) load and register components (only for standard jars) if (containsComponents(localExtension)) { loadComponents(localExtension.getFile(), classLoader, namespace); } }
private boolean checkExistingPlanNodeExtension(ExtensionId extensionId, boolean isId, String namespace) throws InstallException { ModifableExtensionPlanNode existingNode = getExtensionNode(extensionId.getId(), namespace); if (existingNode != null) { if (isId && existingNode.getAction().getExtension().getId().equals(extensionId)) { // Same extension already planned for install return true; } if (existingNode.versionConstraint != null) { if (!existingNode.versionConstraint.isCompatible(extensionId.getVersion())) { throw new InstallException( String.format("Extension feature [%s] is incompatible with existing constraint [%s]", extensionId, existingNode.versionConstraint)); } } } return false; }
private VersionConstraint checkExistingPlanNodeDependency(ExtensionDependency extensionDependency, String namespace, List<ModifableExtensionPlanNode> parentBranch, VersionConstraint previousVersionConstraint) throws InstallException { VersionConstraint versionConstraint = previousVersionConstraint; ModifableExtensionPlanNode existingNode = getExtensionNode(extensionDependency.getId(), namespace); if (existingNode != null) { if (versionConstraint.isCompatible(existingNode.getAction().getExtension().getId().getVersion())) { ModifableExtensionPlanNode node = new ModifableExtensionPlanNode(extensionDependency, existingNode); addExtensionNode(node); parentBranch.add(node); return null; } else { if (existingNode.versionConstraint != null) { try { versionConstraint = versionConstraint.merge(existingNode.versionConstraint); } catch (IncompatibleVersionConstraintException e) { throw new InstallException("Dependency [" + extensionDependency + "] is incompatible with current constaint [" + existingNode.versionConstraint + "]", e); } } else { throw new InstallException("Dependency [" + extensionDependency + "] incompatible with extension [" + existingNode.getAction().getExtension() + "]"); } } } return versionConstraint; }
installedExtension.getProperties()); } catch (Exception e) { throw new InstallException("Failed to modify extension descriptor", e);