private static void doExports(ResourceImpl resource, Headers headers) {
Clause[] clauses = Parser.parseHeader(headers.getHeader(Constants.EXPORT_PACKAGE));
for (int i = 0; clauses != null && i < clauses.length; i++) {
CapabilityImpl capability = createCapability(Capability.PACKAGE, clauses[i]);
resource.addCapability(capability);
}
}
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);
}
}
}
}
}
}
}
}
private static void doFragment(ResourceImpl resource, Headers headers) {
// Check if we are a fragment
Clause[] clauses = Parser.parseHeader(headers.getHeader(Constants.FRAGMENT_HOST));
if (clauses != null && clauses.length == 1) {
// We are a fragment, create a requirement
// to our host.
RequirementImpl r = new RequirementImpl(Capability.BUNDLE);
StringBuffer sb = new StringBuffer();
sb.append("(&(symbolicname=");
sb.append(clauses[0].getName());
sb.append(")");
appendVersion(
sb,
VersionRange.parseVersionRange(
clauses[0].getAttribute(Constants.BUNDLE_VERSION_ATTRIBUTE)));
sb.append(")");
r.setFilter(sb.toString());
r.addText("Required Host " + clauses[0].getName());
r.setExtend(true);
r.setOptional(false);
r.setMultiple(false);
resource.addRequire(r);
// And insert a capability that we are available
// as a fragment. ### Do we need that with extend?
CapabilityImpl capability = new CapabilityImpl(Capability.FRAGMENT);
capability.addProperty("host", clauses[0].getName());
capability.addProperty("version", Property.VERSION, getVersion(clauses[0]));
resource.addCapability(capability);
}
}
protected List<Clause> getOptionalImports(String importsStr) {
Clause[] imports = Parser.parseHeader(importsStr);
List<Clause> result = new LinkedList<Clause>();
for (int i = 0; i < imports.length; i++) {
String resolution = imports[i].getDirective(Constants.RESOLUTION_DIRECTIVE);
if (Constants.RESOLUTION_OPTIONAL.equals(resolution)) {
result.add(imports[i]);
}
}
return result;
}
private static String getSymbolicName(Headers headers) {
String bsn = headers.getHeader(Constants.BUNDLE_SYMBOLICNAME);
if (bsn == null) {
bsn = headers.getHeader(Constants.BUNDLE_NAME);
if (bsn == null) {
bsn = "Untitled-" + headers.hashCode();
}
}
Clause[] clauses = Parser.parseHeader(bsn);
return clauses[0].getName();
}
private static void doImportExportServices(ResourceImpl resource, Headers headers) {
Clause[] imports = Parser.parseHeader(headers.getHeader(Constants.IMPORT_SERVICE));
for (int i = 0; imports != null && i < imports.length; i++) {
RequirementImpl ri = new RequirementImpl(Capability.SERVICE);
ri.setFilter(createServiceFilter(imports[i]));
ri.addText("Import Service " + imports[i].getName());
String avail = imports[i].getDirective("availability");
String mult = imports[i].getDirective("multiple");
ri.setOptional("optional".equalsIgnoreCase(avail));
ri.setMultiple(!"false".equalsIgnoreCase(mult));
resource.addRequire(ri);
}
Clause[] exports = Parser.parseHeader(headers.getHeader(Constants.EXPORT_SERVICE));
for (int i = 0; exports != null && i < exports.length; i++) {
CapabilityImpl cap = createServiceCapability(exports[i]);
resource.addCapability(cap);
}
}
private static void doImports(ResourceImpl resource, Headers headers) {
Clause[] clauses = Parser.parseHeader(headers.getHeader(Constants.IMPORT_PACKAGE));
for (int i = 0; clauses != null && i < clauses.length; i++) {
RequirementImpl requirement = new RequirementImpl(Capability.PACKAGE);
createImportFilter(requirement, Capability.PACKAGE, clauses[i]);
requirement.addText("Import package " + clauses[i]);
requirement.setOptional(
Constants.RESOLUTION_OPTIONAL.equalsIgnoreCase(
clauses[i].getDirective(Constants.RESOLUTION_DIRECTIVE)));
resource.addRequire(requirement);
}
}
private static void doExecutionEnvironment(ResourceImpl resource, Headers headers) {
Clause[] clauses =
Parser.parseHeader(headers.getHeader(Constants.BUNDLE_REQUIREDEXECUTIONENVIRONMENT));
if (clauses != null && clauses.length > 0) {
StringBuffer sb = new StringBuffer();
sb.append("(|");
for (int i = 0; i < clauses.length; i++) {
sb.append("(");
sb.append(Capability.EXECUTIONENVIRONMENT);
sb.append("=");
sb.append(clauses[i].getName());
sb.append(")");
}
sb.append(")");
RequirementImpl req = new RequirementImpl(Capability.EXECUTIONENVIRONMENT);
req.setFilter(sb.toString());
req.addText("Execution Environment " + sb.toString());
resource.addRequire(req);
}
}
private static void doRequires(ResourceImpl resource, Headers headers) {
Clause[] clauses = Parser.parseHeader(headers.getHeader(Constants.REQUIRE_BUNDLE));
for (int i = 0; clauses != null && i < clauses.length; i++) {
RequirementImpl r = new RequirementImpl(Capability.BUNDLE);
VersionRange v =
VersionRange.parseVersionRange(
clauses[i].getAttribute(Constants.BUNDLE_VERSION_ATTRIBUTE));
StringBuffer sb = new StringBuffer();
sb.append("(&(symbolicname=");
sb.append(clauses[i].getName());
sb.append(")");
appendVersion(sb, v);
sb.append(")");
r.setFilter(sb.toString());
r.addText("Require Bundle " + clauses[i].getName() + "; " + v);
r.setOptional(
Constants.RESOLUTION_OPTIONAL.equalsIgnoreCase(
clauses[i].getDirective(Constants.RESOLUTION_DIRECTIVE)));
resource.addRequire(r);
}
}
protected void formatHeader(
String header, ClauseFormatter formatter, StringBuilder builder, int indent) {
Clause[] clauses = Parser.parseHeader(header);
formatClauses(clauses, formatter, builder, indent);
}
protected void findBundlesWithOptionalPackagesToRefresh(Set<Bundle> toRefresh) {
// First pass: include all bundles contained in these features
Set<Bundle> bundles = new HashSet<Bundle>(Arrays.asList(bundleContext.getBundles()));
bundles.removeAll(toRefresh);
if (bundles.isEmpty()) {
return;
}
// Second pass: for each bundle, check if there is any unresolved optional package that could be
// resolved
Map<Bundle, List<Clause>> imports = new HashMap<Bundle, List<Clause>>();
for (Iterator<Bundle> it = bundles.iterator(); it.hasNext(); ) {
Bundle b = it.next();
String importsStr = (String) b.getHeaders().get(Constants.IMPORT_PACKAGE);
List<Clause> importsList = getOptionalImports(importsStr);
if (importsList.isEmpty()) {
it.remove();
} else {
imports.put(b, importsList);
}
}
if (bundles.isEmpty()) {
return;
}
// Third pass: compute a list of packages that are exported by our bundles and see if
// some exported packages can be wired to the optional imports
List<Clause> exports = new ArrayList<Clause>();
for (Bundle b : toRefresh) {
if (b.getState() != Bundle.UNINSTALLED) {
String exportsStr = (String) b.getHeaders().get(Constants.EXPORT_PACKAGE);
if (exportsStr != null) {
Clause[] exportsList = Parser.parseHeader(exportsStr);
exports.addAll(Arrays.asList(exportsList));
}
}
}
for (Iterator<Bundle> it = bundles.iterator(); it.hasNext(); ) {
Bundle b = it.next();
List<Clause> importsList = imports.get(b);
for (Iterator<Clause> itpi = importsList.iterator(); itpi.hasNext(); ) {
Clause pi = itpi.next();
boolean matching = false;
for (Clause pe : exports) {
if (pi.getName().equals(pe.getName())) {
String evStr = pe.getAttribute(Constants.VERSION_ATTRIBUTE);
String ivStr = pi.getAttribute(Constants.VERSION_ATTRIBUTE);
Version exported = evStr != null ? Version.parseVersion(evStr) : Version.emptyVersion;
VersionRange imported =
ivStr != null ? VersionRange.parseVersionRange(ivStr) : VersionRange.ANY_VERSION;
if (imported.contains(exported)) {
matching = true;
break;
}
}
}
if (!matching) {
itpi.remove();
}
}
if (importsList.isEmpty()) {
it.remove();
}
}
toRefresh.addAll(bundles);
}
private static void doCategories(ResourceImpl resource, Headers headers) {
Clause[] clauses = Parser.parseHeader(headers.getHeader(Constants.BUNDLE_CATEGORY));
for (int i = 0; clauses != null && i < clauses.length; i++) {
resource.addCategory(clauses[i].getName());
}
}
