예제 #1
0
  public void waitForFeature(String featureName, Predicate<FeatureState> predicate)
      throws Exception {
    boolean ready = false;

    long timeoutLimit = System.currentTimeMillis() + REQUIRED_BUNDLES_TIMEOUT;
    while (!ready) {
      FeaturesService featuresService = getFeaturesService();
      if (featuresService != null) {
        Feature feature = featuresService.getFeature(featureName);
        FeatureState state =
            featuresService.getState(feature.getName() + "/" + feature.getVersion());
        if (state == null) {
          LOGGER.warn("No Feature found for featureName: {}", featureName);
          return;
        } else if (predicate.test(state)) {
          ready = true;
        }
      }

      if (!ready) {
        if (System.currentTimeMillis() > timeoutLimit) {
          printInactiveBundles();
          fail(
              String.format(
                  "Feature did not change to State ["
                      + predicate.toString()
                      + "] within %d minutes.",
                  TimeUnit.MILLISECONDS.toMinutes(REQUIRED_BUNDLES_TIMEOUT)));
        }
        LOGGER.info("Feature [{}] not [{}], sleeping...", featureName, predicate.toString());
        Thread.sleep(1000);
      }
    }
  }
예제 #2
0
    @Override
    public boolean matches(DependencyTree dependencyTree) {
      boolean result = false;

      if (!getDependencyTreeFilter().matches(dependencyTree)) {
        try {
          Feature feature = Features.getFeatureForBundle(service.listFeatures(), dependencyTree);
          if (feature != null) {
            String replacement = String.format("%s/%s", feature.getName(), feature.getVersion());
            features.add(replacement);
            LOG.info(
                String.format(
                    "Installing feature %s for maven dependency %s/%s/%s",
                    replacement,
                    dependencyTree.getGroupId(),
                    dependencyTree.getArtifactId(),
                    dependencyTree.getVersion()));
            result = true;
          }
        } catch (Exception e) {
          LOG.debug(
              String.format(
                  "Unable to retrieve features information while processing dependency %s",
                  dependencyTree.getArtifactId()),
              e);
        }
      }

      return result;
    }
 /*
  * Get a list of bundle locations in a feature
  */
 private List<String> getBundleLocations(Feature feature) {
   List<String> result = new LinkedList<String>();
   if (feature != null && feature.getBundles() != null) {
     for (BundleInfo bundle : feature.getBundles()) {
       result.add(bundle.getLocation());
     }
   }
   return result;
 }
 /*
  * Validate if all features in a repository have bundles which can be resolved
  */
 private void validateImportsExports(Repository repository)
     throws ArtifactResolutionException, ArtifactNotFoundException, Exception {
   for (Feature feature : repository.getFeatures()) {
     // make sure the feature hasn't been validated before as a dependency
     if (!featureExports.containsKey(feature.getName())) {
       validateImportsExports(feature);
     }
   }
 }
 public Feature get(String name, String version) throws Exception {
   for (Feature feature : features) {
     if (name.equals(feature.getName()) && version.equals(feature.getVersion())) {
       return feature;
     }
   }
   throw new Exception(
       String.format("Unable to find definition for feature %s (version %s)", name, version));
 }
예제 #6
0
 public void assertFeatureInstalled(String featureName) {
   Feature[] features = featuresService.listInstalledFeatures();
   for (Feature feature : features) {
     if (featureName.equals(feature.getName())) {
       return;
     }
   }
   fail("Feature " + featureName + " should be installed but is not");
 }
예제 #7
0
  @Override
  public Set<BundleInfo> getBundles() throws ApplicationServiceException {
    Set<BundleInfo> bundles = new TreeSet<BundleInfo>(new BundleInfoComparator());
    for (Feature curFeature : getFeatures()) {
      bundles.addAll(curFeature.getBundles());
    }

    return bundles;
  }
 /*
  * Analyze exports in all features in the repository without validating the features
  * (e.g. used for <repository> elements found in a descriptor)
  */
 private void analyzeExports(Repository repository) throws Exception {
   for (Feature feature : repository.getFeatures()) {
     Set<Clause> exports = new HashSet<Clause>();
     for (String bundle : getBundleLocations(feature)) {
       exports.addAll(getExports(getManifest(bundle, bundles.get(bundle))));
     }
     info("    scanning feature %s for exports", feature.getName());
     featureExports.put(feature.getName(), exports);
   }
 }
 boolean featureUninstall(Feature feature) {
   String name = feature.getName();
   String version = feature.getVersion();
   try {
     featuresService.uninstallFeature(name, version);
     return true;
   } catch (Exception e) {
     logger.error("Unable to uninstall feature: " + name, e);
     return false;
   }
 }
 boolean featureInstall(Feature feature) {
   String name = feature.getName();
   String version = feature.getVersion();
   EnumSet<Option> options = EnumSet.of(Option.Verbose);
   try {
     featuresService.installFeature(name, version, options);
     return true;
   } catch (Exception e) {
     logger.error("Unable to uninstall feature: " + name, e);
     return false;
   }
 }
  /*
   * Validate if all imports for a feature are being matched with exports
   */
  private void validateImportsExports(Feature feature) throws Exception {
    Map<Clause, String> imports = new HashMap<Clause, String>();
    Set<Clause> exports = new HashSet<Clause>();
    for (Dependency dependency : feature.getDependencies()) {
      if (featureExports.containsKey(dependency.getName())) {
        exports.addAll(featureExports.get(dependency.getName()));
      } else {
        validateImportsExports(features.get(dependency.getName(), dependency.getVersion()));
      }
    }
    for (String bundle : getBundleLocations(feature)) {
      Manifest meta = manifests.get(bundles.get(bundle));
      exports.addAll(getExports(meta));
      for (Clause clause : getMandatoryImports(meta)) {
        imports.put(clause, bundle);
      }
    }

    // setting up the set of required imports
    Set<Clause> requirements = new HashSet<Clause>();
    requirements.addAll(imports.keySet());

    // now, let's remove requirements whenever we find a matching export for them
    for (Clause element : imports.keySet()) {
      if (systemExports.contains(element.getName())) {
        debug("%s is resolved by a system bundle export or provided bundle", element);
        requirements.remove(element);
        continue;
      }
      for (Clause export : exports) {
        if (matches(element, export)) {
          debug("%s is resolved by export %s", element, export);
          requirements.remove(element);
          continue;
        }
        debug("%s is not resolved by export %s", element, export);
      }
    }

    // if there are any more requirements left here, there's a problem with the feature
    if (!requirements.isEmpty()) {
      warn("Failed to validate feature %s", feature.getName());
      for (Clause entry : requirements) {
        warn("No export found to match %s (imported by %s)", entry, imports.get(entry));
      }
      throw new Exception(
          String.format(
              "%d unresolved imports in feature %s", requirements.size(), feature.getName()));
    }
    info("    OK: imports resolved for %s", feature.getName());
    featureExports.put(feature.getName(), exports);
  }
예제 #12
0
 private Set<String> getFeatureLocations() throws Exception {
   Set<String> bundleLocations = new LinkedHashSet<String>();
   for (Feature feature : featuresService.listFeatures()) {
     try {
       for (BundleInfo info : feature.getBundles()) {
         bundleLocations.add(info.getLocation());
       }
     } catch (Exception e) {
       // Ignore
     }
   }
   return bundleLocations;
 }
 @Override
 public Set<String> listCapabilities() {
   Set<String> ids = new HashSet<>();
   try {
     for (Feature feature : featuresService.listFeatures()) {
       ids.add(feature.getName());
     }
   } catch (Exception e) {
     logger.error("Unknown error trying to retrieve available Karaf features", e);
     return ids;
   }
   return ids;
 }
 @Override
 public Set<ICapability> getAllCapabilities() {
   Set<ICapability> capabilities = new HashSet<ICapability>();
   try {
     for (Feature feature : featuresService.listFeatures()) {
       ICapability capabilityById = this.getCapabilityById(feature.getName());
       if (capabilityById != null) {
         capabilities.add(capabilityById);
       }
     }
   } catch (Exception e) {
     logger.error("Unknown error trying to retrieve available Karaf features", e);
     return capabilities;
   }
   return capabilities;
 }
예제 #15
0
 /**
  * Get the list of features where the bundle is belonging.
  *
  * @param bundleLocation the bundle location.
  * @return the list of feature where the bundle is present.
  * @throws Exception in case of retrieval failure.
  */
 protected List<Feature> retrieveFeature(String bundleLocation) throws Exception {
   Feature[] features = featuresService.listFeatures();
   List<Feature> matchingFeatures = new ArrayList<Feature>();
   for (Feature feature : features) {
     List<BundleInfo> bundles = feature.getBundles();
     for (BundleInfo bundleInfo : bundles) {
       String location = bundleInfo.getLocation();
       if (location.equalsIgnoreCase(bundleLocation)) {
         matchingFeatures.add(feature);
         LOGGER.debug(
             "CELLAR BUNDLE: found a feature {} containing bundle {}",
             feature.getName(),
             bundleLocation);
       }
     }
   }
   return matchingFeatures;
 }
예제 #16
0
  @Override
  public List<Map<String, Object>> getInstallationProfiles() {
    List<Feature> installationProfiles = appService.getInstallationProfiles();
    List<Map<String, Object>> profiles = new ArrayList<Map<String, Object>>();

    for (Feature profile : installationProfiles) {
      Map<String, Object> profileMap = new HashMap<String, Object>();
      profileMap.put(INSTALL_PROFILE_NAME, profile.getName());
      profileMap.put(INSTALL_PROFILE_DESCRIPTION, profile.getDescription());

      List<String> includedFeatures = new ArrayList<>();
      profile.getDependencies().forEach(dep -> includedFeatures.add(dep.getName()));
      profileMap.put(INSTALL_PROFILE_DEFAULT_APPLICATIONS, includedFeatures);

      profiles.add(profileMap);
    }

    return profiles;
  }
  /**
   * Check if a feature is already installed locally.
   *
   * @param name the feature name.
   * @param version the feature version.
   * @return true if the feature is already installed locally, false else.
   */
  public Boolean isFeatureInstalledLocally(String name, String version) {
    if (featuresService != null) {
      try {
        Feature[] localFeatures = featuresService.listInstalledFeatures();

        if (localFeatures != null && localFeatures.length > 0) {
          for (Feature localFeature : localFeatures) {
            if (localFeature.getName().equals(name)
                && (localFeature.getVersion().equals(version) || version == null)) return true;
          }
        }
      } catch (Exception e) {
        LOGGER.warn(
            "CELLAR FEATURES: can't check if the feature {}/{} is installed locally",
            name,
            version,
            e);
      }
    }
    return false;
  }
예제 #18
0
  private void installPackage(final Map<String, Object> config) {
    Object packageName = config.get("package");
    String name = PREFIX + PREFIX_PACKAGE + ((String) packageName).trim();
    installFeature(name);

    // uninstall all other packages
    try {
      for (Feature feature : featuresService.listFeatures()) {
        if (feature.getName().startsWith(PREFIX + PREFIX_PACKAGE)
            && !feature.getName().equals(name)
            && featuresService.isInstalled(feature)) {
          try {
            featuresService.uninstallFeature(feature.getName());
          } catch (Exception e) {
            logger.error("Failed uninstalling '{}': {}", feature.getName(), e.getMessage());
          }
        }
      }
    } catch (Exception e) {
      logger.error("Failed retrieving features: {}", e.getMessage());
    }
  }
예제 #19
0
  /**
   * Creates a new instance of application.
   *
   * @param repo Creates the application from a Karaf Feature Repository object.
   */
  public ApplicationImpl(Repository repo) {
    location = repo.getURI();
    try {
      String[] parts = repo.getName().split("-[0-9]");
      if (parts.length != 0) {
        name = parts[0];
        version = repo.getName().substring(name.length() + 1);
      } else {
        name = repo.getName();
        version = "0.0.0";
      }
      features = new HashSet<>(Arrays.asList(repo.getFeatures()));
    } catch (Exception e) {
      logger.warn(
          "Error occured while trying to parse information for application. Application created but may have missing information.");
      features = new HashSet<>();
    }
    autoInstallFeatures = new HashSet<>();
    if (features.size() == 1) {
      autoInstallFeatures.add(features.iterator().next());
    } else {
      autoInstallFeatures.addAll(
          features
              .stream()
              .filter(
                  curFeature ->
                      StringUtils.equalsIgnoreCase(
                          Feature.DEFAULT_INSTALL_MODE, curFeature.getInstall()))
              .collect(Collectors.toList()));
    }
    // Determine mainFeature
    if (autoInstallFeatures.size() == 1) {
      mainFeature = autoInstallFeatures.iterator().next();
      name = mainFeature.getName();
      version = mainFeature.getVersion();
      description = mainFeature.getDescription();
    } else {
      Optional<Feature> first =
          autoInstallFeatures.stream().filter(f -> name.equals(f.getName())).findFirst();
      if (first.isPresent()) {
        mainFeature = first.get();
        name = mainFeature.getName();
        version = mainFeature.getVersion();
        description = mainFeature.getDescription();
      }
    }

    if (mainFeature == null) {
      logger.debug(
          "Could not determine main feature in {}, using defaults. Each application "
              + "should have 1 feature with the same name as the repository or 1 auto"
              + " install feature. This Application will take no action when started"
              + " or stopped.",
          name);
    }
  }
예제 #20
0
 public String getInstall() {
   return feature.getInstall();
 }
 public void watchForUnInstall(Feature feature, SettableFuture<Boolean> uninstallFuture) {
   futures.put(feature.getId(), new InstallFuture(uninstallFuture, UNINSTALL));
 }
 boolean isAutoInstall(Feature feature) {
   return feature.getInstall() != null
       && feature.getInstall().equals(Feature.DEFAULT_INSTALL_MODE);
 }