private boolean checkBundle(String bundleName, String version) { VersionRange vr = VersionRange.parseVersionRange(version); Bundle[] bundles = bundleContext.getBundles(); for (int i = 0; (bundles != null) && (i < bundles.length); i++) { String sym = bundles[i].getSymbolicName(); if ((sym != null) && sym.equals(bundleName)) { if (vr.contains(bundles[i].getVersion())) { return true; } } } return false; }
private boolean checkBundle(String bundleName, String version) { VersionRange vr = VersionRange.parseVersionRange(version); Bundle[] bundles = bundleContext.getBundles(); for (int i = 0; (bundles != null) && (i < bundles.length); i++) { String sym = bundles[i].getSymbolicName(); if ((sym != null) && sym.equals(bundleName)) { if (vr.contains(bundles[i].getVersion())) { return true; } } } return false; }
private Set<Feature> getMatching(String nameAndVersion) { FeatureReq req = new FeatureReq(nameAndVersion); Set<Feature> versionToFeatures = featuresCache.get(req.getName()); if (versionToFeatures == null) { return Collections.emptySet(); } return versionToFeatures.stream() .filter(f -> f.getName().equals(req.getName()) && req.getVersionRange().contains(VersionTable.getVersion(f.getVersion()))) .collect(Collectors.toSet()); } }
private static Feature getLatestFeature(Map<String, Feature> versions, VersionRange versionRange) { Feature feature = null; if (versions != null && !versions.isEmpty()) { Version latest = Version.emptyVersion; for (String available : versions.keySet()) { Version availableVersion = VersionTable.getVersion(available); if (availableVersion.compareTo(latest) >= 0 && versionRange.contains(availableVersion)) { Feature possiblyBlacklisted = versions.get(available); // return only if there are no more non-blaclisted features if (feature == null || !possiblyBlacklisted.isBlacklisted()) { feature = possiblyBlacklisted; } latest = availableVersion; } } } return feature; }
private Set<Feature> getMatching(String nameAndVersion) { FeatureReq req = new FeatureReq(nameAndVersion); Set<Feature> versionToFeatures = featuresCache.get(req.getName()); if (versionToFeatures == null) { return Collections.emptySet(); } return versionToFeatures.stream() .filter(f -> f.getName().equals(req.getName()) && req.getVersionRange().contains(VersionTable.getVersion(f.getVersion()))) .collect(Collectors.toSet()); } }
protected void findBundlesWithFramentsToRefresh(Set<Bundle> toRefresh) { for (Bundle b : toRefresh) { if (b.getState() != Bundle.UNINSTALLED) { String hostHeader = (String) b.getHeaders().get(Constants.FRAGMENT_HOST); if (hostHeader != null) { Clause[] clauses = Parser.parseHeader(hostHeader); if (clauses != null && clauses.length > 0) { Clause path = clauses[0]; for (Bundle hostBundle : bundleContext.getBundles()) { if (hostBundle.getSymbolicName().equals(path.getName())) { String ver = path.getAttribute(Constants.BUNDLE_VERSION_ATTRIBUTE); if (ver != null) { VersionRange v = VersionRange.parseVersionRange(ver); if (v.contains(hostBundle.getVersion())) { toRefresh.add(hostBundle); } } else { toRefresh.add(hostBundle); } } } } } } } }
protected void findBundlesWithFragmentsToRefresh(Set<Bundle> toRefresh) { for (Bundle b : toRefresh) { if (b.getState() != Bundle.UNINSTALLED) { String hostHeader = b.getHeaders().get(Constants.FRAGMENT_HOST); if (hostHeader != null) { Clause[] clauses = Parser.parseHeader(hostHeader); if (clauses != null && clauses.length > 0) { Clause path = clauses[0]; for (Bundle hostBundle : bundleContext.getBundles()) { if (hostBundle.getSymbolicName().equals(path.getName())) { String ver = path.getAttribute(Constants.BUNDLE_VERSION_ATTRIBUTE); if (ver != null) { VersionRange v = VersionRange.parseVersionRange(ver); if (v.contains(hostBundle.getVersion())) { toRefresh.add(hostBundle); } } else { toRefresh.add(hostBundle); } } } } } } } }
protected void findBundlesWithFragmentsToRefresh(Set<Bundle> toRefresh) { Set<Bundle> fragments = new HashSet<Bundle>(); Set<Bundle> bundles = getScopedBundles(fragmentScope); for (Bundle b : toRefresh) { if (b.getState() != Bundle.UNINSTALLED) { String hostHeader = b.getHeaders().get(Constants.FRAGMENT_HOST); if (hostHeader != null) { Clause[] clauses = Parser.parseHeader(hostHeader); if (clauses != null && clauses.length > 0) { Clause path = clauses[0]; for (Bundle hostBundle : bundles) { if (hostBundle.getSymbolicName() != null && hostBundle.getSymbolicName().equals(path.getName())) { String ver = path.getAttribute(Constants.BUNDLE_VERSION_ATTRIBUTE); if (ver != null) { VersionRange v = VersionRange.parseVersionRange(ver); if (v.contains(VersionTable.getVersion(hostBundle.getHeaders().get(Constants.BUNDLE_VERSION)))) { fragments.add(hostBundle); } } else { fragments.add(hostBundle); } } } } } } } toRefresh.addAll(fragments); }
/** * Returns <code>true</code> if this feature pattern matches given feature/version * @param featureName * @param featureVersion * @return */ public boolean matches(String featureName, String featureVersion) { if (featureName == null) { return false; } boolean match = namePattern.matcher(featureName).matches(); if (!match) { return false; } if (featureVersion == null) { featureVersion = "0"; } Version otherVersion = new Version(VersionCleaner.clean(featureVersion)); if (versionRange != null) { match = versionRange.contains(otherVersion); } else if (version != null) { match = version.equals(otherVersion); } return match; }
private boolean checkPackage(String packageName, String version) { VersionRange range = VersionRange.parseVersionRange(version); if (admin != null) { ExportedPackage[] packages = admin.getExportedPackages(packageName); if (packages != null) { for (ExportedPackage export : packages) { if (range.contains(export.getVersion())) { return true; } } } } return false; }
private boolean checkPackage(String packageName, String version) { VersionRange range = VersionRange.parseVersionRange(version); Bundle[] bundles = bundleContext.getBundles(); for (int i = 0; (bundles != null) && (i < bundles.length); i++) { BundleWiring wiring = bundles[i].adapt(BundleWiring.class); List<BundleCapability> caps = wiring != null ? wiring.getCapabilities(BundleRevision.PACKAGE_NAMESPACE) : null; if (caps != null) { for (BundleCapability cap : caps) { String n = getAttribute(cap, BundleRevision.PACKAGE_NAMESPACE); String v = getAttribute(cap, Constants.VERSION_ATTRIBUTE); if (packageName.equals(n) && range.contains(VersionTable.getVersion(v))) { return true; } } } } return false; }
private void doCollectPrerequisites(Set<String> prereqs) { for (Subsystem child : children) { child.doCollectPrerequisites(prereqs); } if (feature != null) { boolean match = false; for (String prereq : prereqs) { String[] p = prereq.split("/"); if (feature.getName().equals(p[0]) && VersionRange.parseVersionRange(p[1]).contains(Version.parseVersion(feature.getVersion()))) { // our feature is already among prerequisites, so ... match = true; break; } } // ... we won't be adding its prerequisites - they'll be handled after another PartialDeploymentException if (!match) { for (Dependency dep : feature.getDependencies()) { if (dep.isPrerequisite()) { prereqs.add(dep.toString()); } } } } }
private boolean checkPackage(String packageName, String version) { VersionRange range = VersionRange.parseVersionRange(version); Bundle[] bundles = bundleContext.getBundles(); for (int i = 0; (bundles != null) && (i < bundles.length); i++) { BundleWiring wiring = bundles[i].adapt(BundleWiring.class); List<BundleCapability> caps = wiring != null ? wiring.getCapabilities(BundleRevision.PACKAGE_NAMESPACE) : null; if (caps != null) { for (BundleCapability cap : caps) { String n = getAttribute(cap, BundleRevision.PACKAGE_NAMESPACE); String v = getAttribute(cap, Constants.VERSION_ATTRIBUTE); if (packageName.equals(n) && range.contains(VersionTable.getVersion(v))) { return true; } } } } return false; }
private boolean checkPackage(String packageName, String version) { VersionRange range = VersionRange.parseVersionRange(version); PackageAdmin admin = getPackageAdmin(); if (admin != null) { ExportedPackage[] packages = admin.getExportedPackages(packageName); if (packages != null) { for (ExportedPackage export : packages) { if (range.contains(export.getVersion())) { return true; } } } } return false; } }
private boolean checkPackage(String packageName, String version) { VersionRange range = VersionRange.parseVersionRange(version); PackageAdmin admin = getPackageAdmin(); if (admin != null) { ExportedPackage[] packages = admin.getExportedPackages(packageName); if (packages != null) { for (ExportedPackage export : packages) { if (range.contains(export.getVersion())) { return true; } } } } return false; } }
private void createNodeForImport(Node node, Bundle bundle, Import i) { ExportedPackage[] exporters = getPackageAdmin().getExportedPackages(i.getPackage()); boolean foundMatch = false; if (exporters != null) { for (ExportedPackage ep : exporters) { if (i.getVersion().contains(ep.getVersion())) { if (bundle.equals(ep.getExportingBundle())) { foundMatch = true; } else { Node child = node.addChild(ep.getExportingBundle()); System.out.printf("- import %s: resolved using %s%n", i, ep.getExportingBundle()); foundMatch = true; createNode(child); } } } } if (!foundMatch) { System.out.printf("- import %s: WARNING - unable to find matching export%n", i); } }
private void createNodeForImport(Node<Bundle> node, Bundle bundle, Clause i) { VersionRange range = VersionRange.parseVersionRange(i.getAttribute(Constants.VERSION_ATTRIBUTE)); boolean foundMatch = false; for (Bundle b : bundleContext.getBundles()) { BundleWiring wiring = b.adapt(BundleWiring.class); if (wiring != null) { List<BundleCapability> caps = wiring.getCapabilities(BundleRevision.PACKAGE_NAMESPACE); if (caps != null) { for (BundleCapability cap : caps) { String n = getAttribute(cap, BundleRevision.PACKAGE_NAMESPACE); String v = getAttribute(cap, Constants.VERSION_ATTRIBUTE); if (i.getName().equals(n) && range.contains(VersionTable.getVersion(v))) { boolean existing = tree.flatten().contains(b); System.out.printf("- import %s: resolved using %s%n", i, b); foundMatch = true; if (!node.hasChild(b)) { Node<Bundle> child = node.addChild(b); if (!existing) { createNode(child); } } } } } } } if (!foundMatch) { System.out.printf("- import %s: WARNING - unable to find matching export%n", i); } }
protected Feature extractFeatureFromDependency(Dependency dependency) throws Exception { Feature[] features = featuresService.listFeatures(); VersionRange range = org.apache.karaf.features.internal.model.Feature.DEFAULT_VERSION.equals(dependency.getVersion()) ? VersionRange.ANY_VERSION : new VersionRange(dependency.getVersion(), true, true); Feature fi = null; for(Feature f: features) { if (f.getName().equals(dependency.getName())) { Version v = VersionTable.getVersion(f.getVersion()); if (range.contains(v) && (fi == null || VersionTable.getVersion(fi.getVersion()).compareTo(v) < 0)) { fi = f; break; } } } return fi; }
/** * Returns the owningFeature if this feature or any of its dependent features contains a bundle matching the prefix location or null if there is no match */ protected Feature featureMatchesBundleLocationPrefix(Iterable<Feature> allFeatures, Feature feature, String prefix, Feature owningFeature, boolean includeDependencies) { for (BundleInfo bi : feature.getBundles()) { if (!bi.isDependency() && bi.getLocation().startsWith(prefix)) { return owningFeature; } } if (includeDependencies) { for (Dependency dependency: feature.getDependencies()) { for (Feature f : allFeatures) { if (f.getName().equals(dependency.getName()) && new VersionRange(dependency.getVersion()).contains(VersionTable.getVersion(f.getVersion()))) { Feature answer = featureMatchesBundleLocationPrefix(allFeatures, f, prefix, owningFeature, true); if (answer != null) { return answer; } } } } } return null; }
/** * @param resource resource to be overriden * @param explicitRange range set on the override clause * @return if the resource should be overriden by the given override */ private static <T extends Resource> boolean shouldOverride(Resource resource, T override, String explicitRange) { if (!getSymbolicName(resource).equals(getSymbolicName(override))) { return false; } VersionRange range; if (explicitRange == null) { // default to micro version compatibility Version v1 = getVersion(resource); Version v2 = new Version(v1.getMajor(), v1.getMinor() + 1, 0); range = new VersionRange(false, v1, v2, true); } else { range = VersionRange.parseVersionRange(explicitRange); } return range.contains(getVersion(override)) && getVersion(resource).compareTo(getVersion(override)) < 0; }