/**
  * @param patternMatcher matches a set of elements
  * @param extension the extension to match
  * @return true if one of the element is matched
  */
 public static boolean matches(Pattern patternMatcher, Extension extension) {
   return matches(
       patternMatcher,
       extension.getId().getId(),
       extension.getDescription(),
       extension.getSummary(),
       extension.getName(),
       extension.getFeatures());
 }
  /**
   * Check if provided id/version is compatible with provided extensions dependencies constraints.
   */
  private boolean isCompatible(
      Collection<? extends Extension> extensions, String id, Version version) {
    if (extensions != null) {
      for (Extension extension : extensions) {
        for (ExtensionDependency dependency : extension.getDependencies()) {
          if (dependency.getId().equals(id)) {
            if (!dependency.getVersionConstraint().isCompatible(version)) {
              return false;
            }
          }
        }
      }
    }

    return true;
  }
  /**
   * Extract extension with the provided id from the provided extension.
   *
   * @param extension the extension
   * @param dependencyId the id of the dependency
   * @return the extension dependency or null if none has been found
   */
  private ExtensionDependency getDependency(Extension extension, String dependencyId) {
    for (ExtensionDependency dependency : extension.getDependencies()) {
      if (dependency.getId().equals(dependencyId)) {
        return dependency;
      }
    }

    return null;
  }
Пример #4
0
  /**
   * @param filter the filter
   * @param extension the extension to match
   * @return true if the extension is matched by the filer
   * @since 7.0M2
   */
  public static boolean matches(Filter filter, Extension extension) {
    Object value = extension.get(filter.getField());

    if (value != null) {
      return matches(filter, value);
    }

    // Unknown field
    // FIXME: not sure if it's should be true or false in this case
    return true;
  }
Пример #5
0
  /**
   * Matches an extension in a case insensitive way.
   *
   * @param patternMatcher the pattern to match
   * @param filters the filters
   * @param extension the extension to match
   * @return true if one of the element is matched
   * @since 7.0M2
   */
  public static boolean matches(
      Pattern patternMatcher, Collection<Filter> filters, Extension extension) {
    if (matches(
        patternMatcher,
        extension.getId().getId(),
        extension.getDescription(),
        extension.getSummary(),
        extension.getName(),
        extension.getFeatures())) {
      for (Filter filter : filters) {
        if (!matches(filter, extension)) {
          return false;
        }
      }

      return true;
    }

    return false;
  }
  /**
   * Indicate if the extension as been installed as a dependency of another one.
   *
   * @param extension the extension
   * @param namespace the namespace to look at, null indicate the root namespace
   * @return true if the the extension has been installed only because it was a dependency of
   *     another extension
   * @see InstalledExtension#isDependency(String)
   * @since 8.2RC1
   */
  public static boolean isDependency(Extension extension, String namespace) {
    boolean isDependency = false;

    if (namespace == null) {
      isDependency = extension.getProperty(PKEY_DEPENDENCY, false);
    } else {
      Object namespacesObject = extension.getProperty(PKEY_NAMESPACES);

      // RETRO-COMPATIBILITY: used to be a String collection with just the actual namespaces
      if (namespacesObject instanceof Map) {
        Map<String, Object> installedNamespace =
            ((Map<String, Map<String, Object>>) namespacesObject).get(namespace);

        isDependency =
            installedNamespace != null
                ? (installedNamespace.get(PKEY_NAMESPACES_DEPENDENCY) == Boolean.TRUE)
                : isDependency(extension, null);
      } else {
        isDependency = isDependency(extension, null);
      }
    }

    return isDependency;
  }
  /**
   * @param extension the extension
   * @return the namespaces in which this extension is enabled. Null means root namespace (i.e all
   *     namespaces).
   */
  public static Collection<String> getNamespaces(Extension extension) {
    Collection<String> namespaces;

    Object namespacesObject = extension.getProperty(PKEY_NAMESPACES);

    // RETRO-COMPATIBILITY: used to be a String collection with just the actual namespaces
    if (namespacesObject == null) {
      namespaces = null;
    } else if (namespacesObject instanceof Collection) {
      namespaces = (Collection<String>) namespacesObject;
    } else {
      namespaces = ((Map<String, Map<String, Object>>) namespacesObject).keySet();
    }

    return namespaces;
  }
  /**
   * @param previousExtension the previous installed version of the extension to install
   * @param extension the new extension to install
   * @param dependency indicate if the extension is installed as a dependency
   * @param namespace the namespace where to install the extension
   * @return the install plan node for the provided extension
   * @param initialDependency the initial dependency used to resolve the extension
   * @throws InstallException error when trying to install provided extension
   */
  private ModifableExtensionPlanNode installExtension(
      InstalledExtension previousExtension,
      Extension extension,
      boolean dependency,
      String namespace,
      ExtensionDependency initialDependency)
      throws InstallException, ResolveException {
    // Is feature core extension
    for (String feature : extension.getFeatures()) {
      if (this.coreExtensionRepository.exists(feature)) {
        throw new InstallException(
            String.format("There is already a core extension with the id [%s]", feature));
      }
    }

    // Find all previous version of the extension
    Set<InstalledExtension> previousExtensions = new LinkedHashSet<InstalledExtension>();
    if (previousExtension != null) {
      previousExtensions.add(previousExtension);
    }
    if (!extension.getFeatures().isEmpty()) {
      for (String feature : extension.getFeatures()) {
        InstalledExtension installedExtension =
            checkAlreadyInstalledExtension(feature, extension.getId().getVersion(), namespace);
        if (installedExtension != null) {
          previousExtensions.add(installedExtension);
        }
      }
    }

    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());

    // Check dependencies
    Collection<? extends ExtensionDependency> dependencies = extension.getDependencies();

    notifyPushLevelProgress(dependencies.size() + 1);

    try {
      List<ModifableExtensionPlanNode> children = null;
      if (!dependencies.isEmpty()) {
        children = new ArrayList<ModifableExtensionPlanNode>();
        for (ExtensionDependency dependencyDependency : extension.getDependencies()) {
          installExtensionDependency(dependencyDependency, namespace, children);

          notifyStepPropress();
        }
      }

      ModifableExtensionPlanNode node =
          initialDependency != null
              ? new ModifableExtensionPlanNode(
                  initialDependency, initialDependency.getVersionConstraint())
              : new ModifableExtensionPlanNode();

      node.setChildren(children);

      Action action;
      if (!previousExtensions.isEmpty()) {
        if (previousExtensions
                .iterator()
                .next()
                .getId()
                .getVersion()
                .compareTo(extension.getId().getVersion())
            > 0) {
          action = Action.DOWNGRADE;
        } else {
          action = Action.UPGRADE;
        }
      } else {
        action = Action.INSTALL;
      }

      node.setAction(
          new DefaultExtensionPlanAction(
              extension, previousExtensions, action, namespace, dependency));

      return node;
    } finally {
      notifyPopLevelProgress();
    }
  }
 /**
  * @param extension the extension
  * @return true if the extension is installed
  * @see InstalledExtension#isInstalled()
  */
 public static boolean isInstalled(Extension extension) {
   return extension.getProperty(PKEY_INSTALLED, false);
 }