| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.felix.bundlerepository.impl; |
| |
| import java.io.*; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.net.URL; |
| import java.net.URLConnection; |
| import java.text.SimpleDateFormat; |
| import java.util.Date; |
| import java.util.Dictionary; |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.Set; |
| import java.util.jar.Attributes; |
| import java.util.jar.JarFile; |
| import java.util.jar.Manifest; |
| import java.util.zip.GZIPInputStream; |
| import java.util.zip.ZipEntry; |
| import java.util.zip.ZipInputStream; |
| |
| import org.apache.felix.bundlerepository.Capability; |
| import org.apache.felix.bundlerepository.DataModelHelper; |
| import org.apache.felix.bundlerepository.Property; |
| import org.apache.felix.bundlerepository.Repository; |
| import org.apache.felix.bundlerepository.Requirement; |
| import org.apache.felix.bundlerepository.Resource; |
| import org.apache.felix.utils.filter.FilterImpl; |
| import org.apache.felix.utils.manifest.Attribute; |
| import org.apache.felix.utils.manifest.Clause; |
| import org.apache.felix.utils.manifest.Directive; |
| import org.apache.felix.utils.manifest.Parser; |
| import org.apache.felix.utils.version.VersionCleaner; |
| import org.apache.felix.utils.version.VersionRange; |
| import org.osgi.framework.Bundle; |
| import org.osgi.framework.Constants; |
| import org.osgi.framework.Filter; |
| import org.osgi.framework.InvalidSyntaxException; |
| import org.osgi.framework.Version; |
| |
| public class DataModelHelperImpl implements DataModelHelper |
| { |
| |
| public static final String BUNDLE_LICENSE = "Bundle-License"; |
| public static final String BUNDLE_SOURCE = "Bundle-Source"; |
| |
| public Requirement requirement(String name, String filter) |
| { |
| RequirementImpl req = new RequirementImpl(); |
| req.setName(name); |
| if (filter != null) |
| { |
| req.setFilter(filter); |
| } |
| return req; |
| } |
| |
| public Filter filter(String filter) |
| { |
| try |
| { |
| return FilterImpl.newInstance(filter); |
| } |
| catch (InvalidSyntaxException e) |
| { |
| IllegalArgumentException ex = new IllegalArgumentException(); |
| ex.initCause(e); |
| throw ex; |
| } |
| } |
| |
| public Repository repository(final URL url) throws Exception |
| { |
| InputStream is = null; |
| |
| try |
| { |
| if (url.getPath().endsWith(".zip")) |
| { |
| ZipInputStream zin = new ZipInputStream(FileUtil.openURL(url)); |
| ZipEntry entry = zin.getNextEntry(); |
| while (entry != null) |
| { |
| if (entry.getName().equals("repository.xml") || entry.getName().equals("index.xml")) |
| { |
| is = zin; |
| break; |
| } |
| entry = zin.getNextEntry(); |
| } |
| // as the ZipInputStream is not used further it would not be closed. |
| if (is == null) |
| { |
| try |
| { |
| zin.close(); |
| } |
| catch (IOException ex) |
| { |
| // Not much we can do. |
| } |
| } |
| } |
| else if (url.getPath().endsWith(".gz")) |
| { |
| is = new GZIPInputStream(FileUtil.openURL(url)); |
| } |
| else |
| { |
| is = FileUtil.openURL(url); |
| } |
| |
| if (is != null) |
| { |
| String repositoryUri = url.toExternalForm(); |
| String baseUri; |
| if (repositoryUri.endsWith(".zip")) { |
| baseUri = new StringBuilder("jar:").append(repositoryUri).append("!/").toString(); |
| } else if (repositoryUri.endsWith(".xml")) { |
| baseUri = repositoryUri.substring(0, repositoryUri.lastIndexOf('/') + 1); |
| } else { |
| baseUri = repositoryUri; |
| } |
| RepositoryImpl repository = repository(is, URI.create(baseUri)); |
| repository.setURI(repositoryUri); |
| |
| return repository; |
| } |
| else |
| { |
| // This should not happen. |
| throw new Exception("Unable to get input stream for repository."); |
| } |
| } |
| finally |
| { |
| try |
| { |
| if (is != null) |
| { |
| is.close(); |
| } |
| } |
| catch (IOException ex) |
| { |
| // Not much we can do. |
| } |
| } |
| } |
| |
| public RepositoryImpl repository(InputStream is, URI baseURI) throws Exception |
| { |
| RepositoryParser parser = RepositoryParser.getParser(); |
| RepositoryImpl repository = parser.parseRepository(is, baseURI); |
| |
| return repository; |
| } |
| |
| public Repository repository(Resource[] resources) |
| { |
| return new RepositoryImpl(resources); |
| } |
| |
| public Capability capability(String name, Map properties) |
| { |
| CapabilityImpl cap = new CapabilityImpl(name); |
| for (Iterator it = properties.entrySet().iterator(); it.hasNext();) |
| { |
| Map.Entry e = (Map.Entry) it.next(); |
| cap.addProperty((String) e.getKey(), (String) e.getValue()); |
| } |
| return cap; |
| } |
| |
| public String writeRepository(Repository repository) |
| { |
| try |
| { |
| StringWriter sw = new StringWriter(); |
| writeRepository(repository, sw); |
| return sw.toString(); |
| } |
| catch (IOException e) |
| { |
| IllegalStateException ex = new IllegalStateException(e); |
| ex.initCause(e); |
| throw ex; |
| } |
| } |
| |
| public void writeRepository(Repository repository, Writer writer) throws IOException |
| { |
| XmlWriter w = new XmlWriter(writer); |
| toXml(w, repository); |
| } |
| |
| public String writeResource(Resource resource) |
| { |
| try |
| { |
| StringWriter sw = new StringWriter(); |
| writeResource(resource, sw); |
| return sw.toString(); |
| } |
| catch (IOException e) |
| { |
| IllegalStateException ex = new IllegalStateException(e); |
| ex.initCause(e); |
| throw ex; |
| } |
| } |
| |
| public void writeResource(Resource resource, Writer writer) throws IOException |
| { |
| XmlWriter w = new XmlWriter(writer); |
| toXml(w, resource); |
| } |
| |
| public String writeCapability(Capability capability) |
| { |
| try |
| { |
| StringWriter sw = new StringWriter(); |
| writeCapability(capability, sw); |
| return sw.toString(); |
| } |
| catch (IOException e) |
| { |
| IllegalStateException ex = new IllegalStateException(e); |
| ex.initCause(e); |
| throw ex; |
| } |
| } |
| |
| public void writeCapability(Capability capability, Writer writer) throws IOException |
| { |
| XmlWriter w = new XmlWriter(writer); |
| toXml(w, capability); |
| } |
| |
| public String writeRequirement(Requirement requirement) |
| { |
| try |
| { |
| StringWriter sw = new StringWriter(); |
| writeRequirement(requirement, sw); |
| return sw.toString(); |
| } |
| catch (IOException e) |
| { |
| IllegalStateException ex = new IllegalStateException(e); |
| ex.initCause(e); |
| throw ex; |
| } |
| } |
| |
| public void writeRequirement(Requirement requirement, Writer writer) throws IOException |
| { |
| XmlWriter w = new XmlWriter(writer); |
| toXml(w, requirement); |
| } |
| |
| public String writeProperty(Property property) |
| { |
| try |
| { |
| StringWriter sw = new StringWriter(); |
| writeProperty(property, sw); |
| return sw.toString(); |
| } |
| catch (IOException e) |
| { |
| IllegalStateException ex = new IllegalStateException(e); |
| ex.initCause(e); |
| throw ex; |
| } |
| } |
| |
| public void writeProperty(Property property, Writer writer) throws IOException |
| { |
| XmlWriter w = new XmlWriter(writer); |
| toXml(w, property); |
| } |
| |
| private static void toXml(XmlWriter w, Repository repository) throws IOException |
| { |
| SimpleDateFormat format = new SimpleDateFormat("yyyyMMddhhmmss.SSS"); |
| w.element(RepositoryParser.REPOSITORY) |
| .attribute(RepositoryParser.NAME, repository.getName()) |
| .attribute(RepositoryParser.LASTMODIFIED, format.format(new Date(repository.getLastModified()))); |
| |
| if (repository instanceof RepositoryImpl) |
| { |
| Referral[] referrals = ((RepositoryImpl) repository).getReferrals(); |
| for (int i = 0; referrals != null && i < referrals.length; i++) |
| { |
| w.element(RepositoryParser.REFERRAL) |
| .attribute(RepositoryParser.DEPTH, new Integer(referrals[i].getDepth())) |
| .attribute(RepositoryParser.URL, referrals[i].getUrl()) |
| .end(); |
| } |
| } |
| |
| Resource[] resources = repository.getResources(); |
| for (int i = 0; resources != null && i < resources.length; i++) |
| { |
| toXml(w, resources[i]); |
| } |
| |
| w.end(); |
| } |
| |
| private static void toXml(XmlWriter w, Resource resource) throws IOException |
| { |
| w.element(RepositoryParser.RESOURCE) |
| .attribute(Resource.ID, resource.getId()) |
| .attribute(Resource.SYMBOLIC_NAME, resource.getSymbolicName()) |
| .attribute(Resource.PRESENTATION_NAME, resource.getPresentationName()) |
| .attribute(Resource.URI, getRelativeUri(resource, Resource.URI)) |
| .attribute(Resource.VERSION, resource.getVersion().toString()); |
| |
| w.textElement(Resource.DESCRIPTION, resource.getProperties().get(Resource.DESCRIPTION)) |
| .textElement(Resource.SIZE, resource.getProperties().get(Resource.SIZE)) |
| .textElement(Resource.DOCUMENTATION_URI, getRelativeUri(resource, Resource.DOCUMENTATION_URI)) |
| .textElement(Resource.SOURCE_URI, getRelativeUri(resource, Resource.SOURCE_URI)) |
| .textElement(Resource.JAVADOC_URI, getRelativeUri(resource, Resource.JAVADOC_URI)) |
| .textElement(Resource.LICENSE_URI, getRelativeUri(resource, Resource.LICENSE_URI)); |
| |
| String[] categories = resource.getCategories(); |
| for (int i = 0; categories != null && i < categories.length; i++) |
| { |
| w.element(RepositoryParser.CATEGORY) |
| .attribute(RepositoryParser.ID, categories[i]) |
| .end(); |
| } |
| Capability[] capabilities = resource.getCapabilities(); |
| for (int i = 0; capabilities != null && i < capabilities.length; i++) |
| { |
| toXml(w, capabilities[i]); |
| } |
| Requirement[] requirements = resource.getRequirements(); |
| for (int i = 0; requirements != null && i < requirements.length; i++) |
| { |
| toXml(w, requirements[i]); |
| } |
| w.end(); |
| } |
| |
| private static String getRelativeUri(Resource resource, String name) |
| { |
| String uri = (String) resource.getProperties().get(name); |
| if (resource instanceof ResourceImpl) |
| { |
| try |
| { |
| uri = URI.create(((ResourceImpl) resource).getRepository().getURI()).relativize(URI.create(uri)).toASCIIString(); |
| } |
| catch (Throwable t) |
| { |
| } |
| } |
| return uri; |
| } |
| |
| private static void toXml(XmlWriter w, Capability capability) throws IOException |
| { |
| w.element(RepositoryParser.CAPABILITY) |
| .attribute(RepositoryParser.NAME, capability.getName()); |
| Property[] props = capability.getProperties(); |
| for (int j = 0; props != null && j < props.length; j++) |
| { |
| toXml(w, props[j]); |
| } |
| w.end(); |
| } |
| |
| private static void toXml(XmlWriter w, Property property) throws IOException |
| { |
| w.element(RepositoryParser.P) |
| .attribute(RepositoryParser.N, property.getName()) |
| .attribute(RepositoryParser.T, property.getType()) |
| .attribute(RepositoryParser.V, property.getValue()) |
| .end(); |
| } |
| |
| private static void toXml(XmlWriter w, Requirement requirement) throws IOException |
| { |
| w.element(RepositoryParser.REQUIRE) |
| .attribute(RepositoryParser.NAME, requirement.getName()) |
| .attribute(RepositoryParser.FILTER, requirement.getFilter()) |
| .attribute(RepositoryParser.EXTEND, Boolean.toString(requirement.isExtend())) |
| .attribute(RepositoryParser.MULTIPLE, Boolean.toString(requirement.isMultiple())) |
| .attribute(RepositoryParser.OPTIONAL, Boolean.toString(requirement.isOptional())) |
| .text(requirement.getComment().trim()) |
| .end(); |
| } |
| |
| public Resource createResource(final Bundle bundle) |
| { |
| final Dictionary dict = bundle.getHeaders(); |
| return createResource(new Headers() |
| { |
| public String getHeader(String name) |
| { |
| return (String) dict.get(name); |
| } |
| }); |
| } |
| |
| public Resource createResource(final URL bundleUrl) throws IOException |
| { |
| ResourceImpl resource = createResource(new Headers() |
| { |
| private final Manifest manifest; |
| private Properties localization; |
| { |
| // Do not use a JarInputStream so that we can read the manifest even if it's not |
| // the first entry in the JAR. |
| byte[] man = loadEntry(JarFile.MANIFEST_NAME); |
| if (man == null) |
| { |
| throw new IllegalArgumentException("The specified url is not a valid jar (can't read manifest): " + bundleUrl); |
| } |
| manifest = new Manifest(new ByteArrayInputStream(man)); |
| } |
| public String getHeader(String name) |
| { |
| String value = manifest.getMainAttributes().getValue(name); |
| if (value != null && value.startsWith("%")) |
| { |
| if (localization == null) |
| { |
| try |
| { |
| localization = new Properties(); |
| String path = manifest.getMainAttributes().getValue(Constants.BUNDLE_LOCALIZATION); |
| if (path == null) |
| { |
| path = Constants.BUNDLE_LOCALIZATION_DEFAULT_BASENAME; |
| } |
| path += ".properties"; |
| byte[] loc = loadEntry(path); |
| if (loc != null) |
| { |
| localization.load(new ByteArrayInputStream(loc)); |
| } |
| } |
| catch (IOException e) |
| { |
| // TODO: ? |
| } |
| } |
| value = value.substring(1); |
| value = localization.getProperty(value, value); |
| } |
| return value; |
| } |
| private byte[] loadEntry(String name) throws IOException |
| { |
| ZipInputStream zis = new ZipInputStream(FileUtil.openURL(bundleUrl)); |
| try |
| { |
| for (ZipEntry e = zis.getNextEntry(); e != null; e = zis.getNextEntry()) |
| { |
| if (name.equalsIgnoreCase(e.getName())) |
| { |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| byte[] buf = new byte[1024]; |
| int n; |
| while ((n = zis.read(buf, 0, buf.length)) > 0) |
| { |
| baos.write(buf, 0, n); |
| } |
| return baos.toByteArray(); |
| } |
| } |
| } |
| finally |
| { |
| zis.close(); |
| } |
| return null; |
| } |
| }); |
| if (resource != null) |
| { |
| if ("file".equals(bundleUrl.getProtocol())) |
| { |
| try { |
| File f = new File(bundleUrl.toURI()); |
| resource.put(Resource.SIZE, Long.toString(f.length()), null); |
| } catch (URISyntaxException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| resource.put(Resource.URI, bundleUrl.toExternalForm(), null); |
| } |
| return resource; |
| } |
| |
| public Resource createResource(final Attributes attributes) |
| { |
| return createResource(new Headers() |
| { |
| public String getHeader(String name) |
| { |
| return attributes.getValue(name); |
| } |
| }); |
| } |
| |
| public ResourceImpl createResource(Headers headers) |
| { |
| String bsn = headers.getHeader(Constants.BUNDLE_SYMBOLICNAME); |
| if (bsn == null) |
| { |
| return null; |
| } |
| ResourceImpl resource = new ResourceImpl(); |
| populate(headers, resource); |
| return resource; |
| } |
| |
| static void populate(Headers headers, ResourceImpl resource) |
| { |
| String bsn = getSymbolicName(headers); |
| String v = getVersion(headers); |
| |
| resource.put(Resource.ID, bsn + "/" + v); |
| resource.put(Resource.SYMBOLIC_NAME, bsn); |
| resource.put(Resource.VERSION, v); |
| if (headers.getHeader(Constants.BUNDLE_NAME) != null) |
| { |
| resource.put(Resource.PRESENTATION_NAME, headers.getHeader(Constants.BUNDLE_NAME)); |
| } |
| if (headers.getHeader(Constants.BUNDLE_DESCRIPTION) != null) |
| { |
| resource.put(Resource.DESCRIPTION, headers.getHeader(Constants.BUNDLE_DESCRIPTION)); |
| } |
| if (headers.getHeader(BUNDLE_LICENSE) != null) |
| { |
| resource.put(Resource.LICENSE_URI, headers.getHeader(BUNDLE_LICENSE)); |
| } |
| if (headers.getHeader(Constants.BUNDLE_COPYRIGHT) != null) |
| { |
| resource.put(Resource.COPYRIGHT, headers.getHeader(Constants.BUNDLE_COPYRIGHT)); |
| } |
| if (headers.getHeader(Constants.BUNDLE_DOCURL) != null) |
| { |
| resource.put(Resource.DOCUMENTATION_URI, headers.getHeader(Constants.BUNDLE_DOCURL)); |
| } |
| if (headers.getHeader(BUNDLE_SOURCE) != null) |
| { |
| resource.put(Resource.SOURCE_URI, headers.getHeader(BUNDLE_SOURCE)); |
| } |
| |
| doCategories(resource, headers); |
| doBundle(resource, headers); |
| doImportExportServices(resource, headers); |
| doFragment(resource, headers); |
| doRequires(resource, headers); |
| doExports(resource, headers); |
| doImports(resource, headers); |
| doExecutionEnvironment(resource, headers); |
| doProvides(resource, headers); |
| } |
| |
| 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()); |
| } |
| } |
| |
| 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 String createServiceFilter(Clause clause) { |
| String f = clause.getAttribute("filter"); |
| StringBuffer filter = new StringBuffer(); |
| if (f != null) { |
| filter.append("(&"); |
| } |
| filter.append("("); |
| filter.append(Capability.SERVICE); |
| filter.append("="); |
| filter.append(clause.getName()); |
| filter.append(")"); |
| if (f != null) { |
| if (!f.startsWith("(")) |
| { |
| filter.append("(").append(f).append(")"); |
| } |
| else |
| { |
| filter.append(f); |
| } |
| filter.append(")"); |
| } |
| return filter.toString(); |
| } |
| |
| private static CapabilityImpl createServiceCapability(Clause clause) { |
| CapabilityImpl capability = new CapabilityImpl(Capability.SERVICE); |
| capability.addProperty(Capability.SERVICE, clause.getName()); |
| Attribute[] attributes = clause.getAttributes(); |
| for (int i = 0; attributes != null && i < attributes.length; i++) |
| { |
| capability.addProperty(attributes[i].getName(), attributes[i].getValue()); |
| } |
| return capability; |
| } |
| |
| 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); |
| } |
| } |
| |
| 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); |
| } |
| } |
| |
| private static void doBundle(ResourceImpl resource, Headers headers) { |
| CapabilityImpl capability = new CapabilityImpl(Capability.BUNDLE); |
| capability.addProperty(Resource.SYMBOLIC_NAME, getSymbolicName(headers)); |
| if (headers.getHeader(Constants.BUNDLE_NAME) != null) |
| { |
| capability.addProperty(Resource.PRESENTATION_NAME, headers.getHeader(Constants.BUNDLE_NAME)); |
| } |
| capability.addProperty(Resource.VERSION, Property.VERSION, getVersion(headers)); |
| capability.addProperty(Resource.MANIFEST_VERSION, getManifestVersion(headers)); |
| resource.addCapability(capability); |
| } |
| |
| 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); |
| } |
| } |
| |
| private static void doProvides(ResourceImpl resource, Headers headers) { |
| Clause[] clauses = Parser.parseHeader(headers.getHeader(Constants.PROVIDE_CAPABILITY)); |
| |
| if (clauses != null) { |
| for (Clause clause : clauses) { |
| CapabilityImpl capability = createCapability(clause.getName(), clause); |
| resource.addCapability(capability); |
| } |
| } |
| } |
| |
| private static CapabilityImpl createCapability(String name, Clause clause) |
| { |
| CapabilityImpl capability = new CapabilityImpl(NamespaceTranslator.getFelixNamespace(name)); |
| capability.addProperty(name, clause.getName()); |
| capability.addProperty(Resource.VERSION, Property.VERSION, getVersion(clause)); |
| Attribute[] attributes = clause.getAttributes(); |
| for (int i = 0; attributes != null && i < attributes.length; i++) |
| { |
| String key = attributes[i].getName(); |
| if (key.equalsIgnoreCase(Constants.PACKAGE_SPECIFICATION_VERSION) || key.equalsIgnoreCase(Constants.VERSION_ATTRIBUTE) || key.equalsIgnoreCase("version:Version")) |
| { |
| continue; |
| } |
| else |
| { |
| String value = attributes[i].getValue(); |
| capability.addProperty(key, value); |
| } |
| } |
| Directive[] directives = clause.getDirectives(); |
| for (int i = 0; directives != null && i < directives.length; i++) |
| { |
| String key = directives[i].getName(); |
| String value = directives[i].getValue(); |
| capability.addProperty(key + ":", value); |
| } |
| return capability; |
| } |
| |
| 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 createImportFilter(RequirementImpl requirement, String name, Clause clause) |
| { |
| StringBuffer filter = new StringBuffer(); |
| filter.append("(&("); |
| filter.append(name); |
| filter.append("="); |
| filter.append(clause.getName()); |
| filter.append(")"); |
| appendVersion(filter, getVersionRange(clause)); |
| Attribute[] attributes = clause.getAttributes(); |
| Set attrs = doImportPackageAttributes(requirement, filter, attributes); |
| |
| // The next code is using the subset operator |
| // to check mandatory attributes, it seems to be |
| // impossible to rewrite. It must assert that whateber |
| // is in mandatory: must be in any of the attributes. |
| // This is a fundamental shortcoming of the filter language. |
| if (attrs.size() > 0) |
| { |
| String del = ""; |
| filter.append("(mandatory:<*"); |
| for (Iterator i = attrs.iterator(); i.hasNext();) |
| { |
| filter.append(del); |
| filter.append(i.next()); |
| del = ", "; |
| } |
| filter.append(")"); |
| } |
| filter.append(")"); |
| requirement.setFilter(filter.toString()); |
| } |
| |
| private static Set doImportPackageAttributes(RequirementImpl requirement, StringBuffer filter, Attribute[] attributes) |
| { |
| HashSet set = new HashSet(); |
| for (int i = 0; attributes != null && i < attributes.length; i++) |
| { |
| String name = attributes[i].getName(); |
| String value = attributes[i].getValue(); |
| if (name.equalsIgnoreCase(Constants.PACKAGE_SPECIFICATION_VERSION) || name.equalsIgnoreCase(Constants.VERSION_ATTRIBUTE)) |
| { |
| continue; |
| } |
| else if (name.equalsIgnoreCase(Constants.RESOLUTION_DIRECTIVE + ":")) |
| { |
| requirement.setOptional(Constants.RESOLUTION_OPTIONAL.equalsIgnoreCase(value)); |
| } |
| if (name.endsWith(":")) |
| { |
| // Ignore |
| } |
| else |
| { |
| filter.append("("); |
| filter.append(name); |
| filter.append("="); |
| filter.append(value); |
| filter.append(")"); |
| set.add(name); |
| } |
| } |
| return set; |
| } |
| |
| 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 String getVersion(Clause clause) |
| { |
| String v = clause.getAttribute(Constants.VERSION_ATTRIBUTE); |
| if (v == null) |
| { |
| v = clause.getAttribute(Constants.PACKAGE_SPECIFICATION_VERSION); |
| } |
| if (v == null) |
| { |
| v = clause.getAttribute(Constants.BUNDLE_VERSION_ATTRIBUTE); |
| } |
| if (v == null) |
| { |
| v = clause.getAttribute("version:Version"); |
| } |
| |
| return VersionCleaner.clean(v); |
| } |
| |
| private static VersionRange getVersionRange(Clause clause) |
| { |
| String v = clause.getAttribute(Constants.VERSION_ATTRIBUTE); |
| if (v == null) |
| { |
| v = clause.getAttribute(Constants.PACKAGE_SPECIFICATION_VERSION); |
| } |
| if (v == null) |
| { |
| v = clause.getAttribute(Constants.BUNDLE_VERSION_ATTRIBUTE); |
| } |
| return VersionRange.parseVersionRange(v); |
| } |
| |
| 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 String getVersion(Headers headers) |
| { |
| String v = headers.getHeader(Constants.BUNDLE_VERSION); |
| return VersionCleaner.clean(v); |
| } |
| |
| private static String getManifestVersion(Headers headers) |
| { |
| String v = headers.getHeader(Constants.BUNDLE_MANIFESTVERSION); |
| if (v == null) |
| { |
| v = "1"; |
| } |
| return v; |
| } |
| |
| private static void appendVersion(StringBuffer filter, VersionRange version) |
| { |
| if (version != null) |
| { |
| if ( !version.isOpenFloor() ) |
| { |
| if ( !Version.emptyVersion.equals(version.getFloor()) ) |
| { |
| filter.append("("); |
| filter.append(Constants.VERSION_ATTRIBUTE); |
| filter.append(">="); |
| filter.append(version.getFloor()); |
| filter.append(")"); |
| } |
| } |
| else |
| { |
| filter.append("(!("); |
| filter.append(Constants.VERSION_ATTRIBUTE); |
| filter.append("<="); |
| filter.append(version.getFloor()); |
| filter.append("))"); |
| } |
| |
| if (!VersionRange.INFINITE_VERSION.equals(version.getCeiling())) |
| { |
| if ( !version.isOpenCeiling() ) |
| { |
| filter.append("("); |
| filter.append(Constants.VERSION_ATTRIBUTE); |
| filter.append("<="); |
| filter.append(version.getCeiling()); |
| filter.append(")"); |
| } |
| else |
| { |
| filter.append("(!("); |
| filter.append(Constants.VERSION_ATTRIBUTE); |
| filter.append(">="); |
| filter.append(version.getCeiling()); |
| filter.append("))"); |
| } |
| } |
| } |
| } |
| |
| interface Headers |
| { |
| String getHeader(String name); |
| } |
| |
| public Repository readRepository(String xml) throws Exception |
| { |
| try |
| { |
| return readRepository(new StringReader(xml)); |
| } |
| catch (IOException e) |
| { |
| IllegalStateException ex = new IllegalStateException(e); |
| ex.initCause(e); |
| throw ex; |
| } |
| } |
| |
| public Repository readRepository(Reader reader) throws Exception |
| { |
| return RepositoryParser.getParser().parseRepository(reader); |
| } |
| |
| public Resource readResource(String xml) throws Exception |
| { |
| try |
| { |
| return readResource(new StringReader(xml)); |
| } |
| catch (IOException e) |
| { |
| IllegalStateException ex = new IllegalStateException(e); |
| ex.initCause(e); |
| throw ex; |
| } |
| } |
| |
| public Resource readResource(Reader reader) throws Exception |
| { |
| return RepositoryParser.getParser().parseResource(reader); |
| } |
| |
| public Capability readCapability(String xml) throws Exception |
| { |
| try |
| { |
| return readCapability(new StringReader(xml)); |
| } |
| catch (IOException e) |
| { |
| IllegalStateException ex = new IllegalStateException(e); |
| ex.initCause(e); |
| throw ex; |
| } |
| } |
| |
| public Capability readCapability(Reader reader) throws Exception |
| { |
| return RepositoryParser.getParser().parseCapability(reader); |
| } |
| |
| public Requirement readRequirement(String xml) throws Exception |
| { |
| try |
| { |
| return readRequirement(new StringReader(xml)); |
| } |
| catch (IOException e) |
| { |
| IllegalStateException ex = new IllegalStateException(e); |
| ex.initCause(e); |
| throw ex; |
| } |
| } |
| |
| public Requirement readRequirement(Reader reader) throws Exception |
| { |
| return RepositoryParser.getParser().parseRequirement(reader); |
| } |
| |
| public Property readProperty(String xml) throws Exception |
| { |
| try |
| { |
| return readProperty(new StringReader(xml)); |
| } |
| catch (IOException e) |
| { |
| IllegalStateException ex = new IllegalStateException(e); |
| ex.initCause(e); |
| throw ex; |
| } |
| } |
| |
| public Property readProperty(Reader reader) throws Exception |
| { |
| return RepositoryParser.getParser().parseProperty(reader); |
| } |
| } |
