/** Check if the getSubBuilders properly predicts the output. */
public static void testSubBuilders() throws Exception {
Workspace ws = Workspace.getWorkspace(new File("test/ws"));
Project project = ws.getProject("p4-sub");
Collection<? extends Builder> bs = project.getSubBuilders();
assertNotNull(bs);
assertEquals(3, bs.size());
Set<String> names = new HashSet<String>();
for (Builder b : bs) {
names.add(b.getBsn());
}
assertTrue(names.contains("p4-sub.a"));
assertTrue(names.contains("p4-sub.b"));
assertTrue(names.contains("p4-sub.c"));
File[] files = project.build();
assertTrue(project.check());
System.err.println(Processor.join(project.getErrors(), "\n"));
System.err.println(Processor.join(project.getWarnings(), "\n"));
assertEquals(0, project.getErrors().size());
assertEquals(0, project.getWarnings().size());
assertNotNull(files);
assertEquals(3, files.length);
for (File file : files) {
Jar jar = new Jar(file);
Manifest m = jar.getManifest();
assertTrue(names.contains(m.getMainAttributes().getValue("Bundle-SymbolicName")));
}
}
private void copy(File workspaceDir, InputStream in, Pattern glob, boolean overwrite)
throws Exception {
Jar jar = new Jar("dot", in);
try {
for (Entry<String, Resource> e : jar.getResources().entrySet()) {
String path = e.getKey();
bnd.trace("path %s", path);
if (glob != null && !glob.matcher(path).matches()) continue;
Resource r = e.getValue();
File dest = Processor.getFile(workspaceDir, path);
if (overwrite
|| !dest.isFile()
|| dest.lastModified() < r.lastModified()
|| r.lastModified() <= 0) {
bnd.trace("copy %s to %s", path, dest);
File dp = dest.getParentFile();
if (!dp.exists() && !dp.mkdirs()) {
throw new IOException("Could not create directory " + dp);
}
IO.copy(r.openInputStream(), dest);
}
}
} finally {
jar.close();
}
}
/** Test default package versions. */
public static void testDefaultPackageVersion() throws Exception {
Builder a = new Builder();
a.addClasspath(new File("bin"));
a.setProperty("Bundle-Version", "1.2.3");
a.setProperty("Export-Package", "test.refer");
Jar jar = a.build();
Manifest m = jar.getManifest();
Parameters exports =
Processor.parseHeader(m.getMainAttributes().getValue(Constants.EXPORT_PACKAGE), null);
Map<String, String> attrs = exports.get("test.refer");
assertNotNull(attrs);
assertEquals("1.2.3", attrs.get("version"));
}
public File getAndroidResourcesFile() throws AndrolibException {
try {
return Jar.getResourceAsFile("/brut/androlib/android-framework.jar");
} catch (BrutException ex) {
throw new AndrolibException(ex);
}
}
/** Test import provide:. */
public static void testExportProvided() throws Exception {
Builder a = new Builder();
a.addClasspath(IO.getFile("jar/osgi.jar"));
a.addClasspath(new File("bin"));
a.setProperty("Private-Package", "test.refer");
a.setProperty("Export-Package", "org.osgi.service.http;provide:=true");
Jar jar = a.build();
Map<String, String> event = a.getImports().getByFQN("org.osgi.service.event");
assertEquals("[1.0,2)", event.get("version"));
Map<String, String> http = a.getImports().getByFQN("org.osgi.service.http");
assertEquals("[1.2,1.3)", http.get("version"));
Manifest m = jar.getManifest();
String imports = m.getMainAttributes().getValue(Constants.IMPORT_PACKAGE);
assertFalse(imports.contains(Constants.PROVIDE_DIRECTIVE));
}
/**
* Test if the implementation of "AnnotatedProviderInterface", which is annotated with OSGi
* R6 @ProviderType, causes import of the api package to use the provider version policy
*/
public static void testProviderTypeR6() throws Exception {
Builder b = new Builder();
b.addClasspath(new File("bin"));
b.setPrivatePackage("test.versionpolicy.implemented.osgi");
b.setProperty("build", "123");
Jar jar = b.build();
assertTrue(b.check());
Manifest m = jar.getManifest();
m.write(System.err);
Domain d = Domain.domain(m);
Parameters params = d.getImportPackage();
Attrs attrs = params.get("test.version.annotations.osgi");
assertNotNull(attrs);
assertEquals("[1.2,1.3)", attrs.get("version"));
}
/**
* Tests if the implementation of the EventHandler (which is marked as a ConsumerType) causes the
* import of the api package to use the consumer version policy.
*/
public static void testConsumerType() throws Exception {
Builder a = new Builder();
a.addClasspath(new File("bin"));
a.setPrivatePackage("test.versionpolicy.uses");
a.setExportPackage("test.versionpolicy.api");
a.setProperty("build", "123");
Jar jar = a.build();
assertTrue(a.check());
Manifest m = jar.getManifest();
m.write(System.err);
Domain d = Domain.domain(m);
Parameters parameters = d.getImportPackage();
Attrs attrs = parameters.get("test.versionpolicy.api");
assertNotNull(attrs);
assertEquals("[1.2,2)", attrs.get("version"));
}
private File create(String bsn, Version v) throws Exception {
String name = bsn + "-" + v;
Builder b = new Builder();
b.setBundleSymbolicName(bsn);
b.setBundleVersion(v);
b.setProperty("Random", random++ + "");
b.setProperty("-resourceonly", true + "");
b.setIncludeResource("foo;literal='foo'");
Jar jar = b.build();
assertTrue(b.check());
File file = IO.getFile(tmp, name + ".jar");
file.getParentFile().mkdirs();
jar.updateModified(System.currentTimeMillis(), "Force it to now");
jar.write(file);
b.close();
return file;
}
/**
* Tests if the implementation of the EventAdmin (which is marked as a ProviderType) causes the
* import of the api package to use the provider version policy.
*/
public static void testProviderType() throws Exception {
Builder a = new Builder();
a.addClasspath(new File("bin"));
a.setPrivatePackage("test.versionpolicy.implemented");
a.setExportPackage("test.versionpolicy.api");
a.setImportPackage("test.versionpolicy.api"); // what changed so this is
// not automatically
// added?
a.setProperty("build", "123");
Jar jar = a.build();
assertTrue(a.check());
Manifest m = jar.getManifest();
m.write(System.err);
Domain d = Domain.domain(m);
Parameters parameters = d.getImportPackage();
Attrs attrs = parameters.get("test.versionpolicy.api");
assertNotNull(attrs);
assertEquals("[1.2,1.3)", attrs.get("version"));
}
/**
* We create a JAR with the test.classreferenc.ClassReference class. This class contains a
* javax.swing.Box.class reference Prior to Java 1.5, this was done in a silly way that is handled
* specially. After 1.5 it is a normal reference.
*
* @throws Exception
*/
public void testReference() throws Exception {
Properties properties = new Properties();
properties.put("-classpath", "compilerversions/compilerversions.jar");
String[] packages = {
"sun_1_1",
"sun_1_6",
"eclipse_1_1",
"sun_1_2",
"sun_1_3",
"sun_1_4",
"sun_1_5",
"sun_jsr14",
"eclipse_1_5",
"eclipse_1_6",
"eclipse_1_2",
"eclipse_1_3",
"eclipse_1_4",
"eclipse_jsr14"
};
for (int i = 0; i < packages.length; i++) {
Builder builder = new Builder();
properties.put("Export-Package", packages[i]);
builder.setProperties(properties);
Jar jar = builder.build();
System.out.println(builder.getErrors());
System.out.println(builder.getWarnings());
assertEquals(0, builder.getErrors().size());
assertEquals(0, builder.getWarnings().size());
Manifest manifest = jar.getManifest();
String imports = manifest.getMainAttributes().getValue("Import-Package");
assertTrue(
"Package " + packages[i] + "contains swing ref", imports.indexOf("javax.swing") >= 0);
assertFalse(
"Package " + packages[i] + "should not contain ClassRef",
imports.indexOf("ClassRef") >= 0);
}
}
public Jar buildJar(JarFile jarFile, List ignorePackages) throws Exception {
Jar jar = new JarImpl(jarFile.getFileName());
while (jarFile.hasMoreClasses()) {
String className = jarFile.nextClass();
try {
BCELPublicClass javaClass =
new BCELPublicClass(jarFile.getFileName(), className, ignorePackages);
String packageName = javaClass.getPackageName();
JarPackage javaPackage = null;
if (jar.containsPackage(packageName)) {
javaPackage = jar.getPackage(packageName);
} else {
javaPackage = new JarPackageImpl(packageName);
jar.addPackage(javaPackage);
}
javaPackage.addClass(javaClass);
} catch (IOException e) {
e.printStackTrace();
}
}
jarFile.close();
return jar;
}
/**
* Tests the handling of the -sub facility
*
* @throws Exception
*/
public static void testSub() throws Exception {
Workspace ws = Workspace.getWorkspace(new File("test/ws"));
Project project = ws.getProject("p4-sub");
File[] files = project.build();
Arrays.sort(files);
System.err.println(Processor.join(project.getErrors(), "\n"));
System.err.println(Processor.join(project.getWarnings(), "\n"));
assertEquals(0, project.getErrors().size());
assertEquals(0, project.getWarnings().size());
assertNotNull(files);
assertEquals(3, files.length);
Jar a = new Jar(files[0]);
Jar b = new Jar(files[1]);
Manifest ma = a.getManifest();
Manifest mb = b.getManifest();
assertEquals("base", ma.getMainAttributes().getValue("Base-Header"));
assertEquals("base", mb.getMainAttributes().getValue("Base-Header"));
assertEquals("a", ma.getMainAttributes().getValue("Sub-Header"));
assertEquals("b", mb.getMainAttributes().getValue("Sub-Header"));
}
private void doManifest(
Jar jar, String[] digestNames, MessageDigest[] algorithms, OutputStream out)
throws Exception {
for (Map.Entry<String, Resource> entry : jar.getResources().entrySet()) {
String name = entry.getKey();
if (!METAINFDIR.matcher(name).matches()) {
out.write("\r\n".getBytes("UTF-8"));
out.write("Name: ".getBytes("UTF-8"));
out.write(name.getBytes("UTF-8"));
out.write("\r\n".getBytes("UTF-8"));
digest(algorithms, entry.getValue());
for (int a = 0; a < algorithms.length; a++) {
if (algorithms[a] != null) {
byte[] digest = algorithms[a].digest();
String header = digestNames[a] + "-Digest: " + new Base64(digest) + "\r\n";
out.write(header.getBytes("UTF-8"));
}
}
}
}
}
public void signJar(Jar jar) {
if (digestNames == null || digestNames.length == 0)
error("Need at least one digest algorithm name, none are specified");
if (keystoreFile == null || !keystoreFile.getAbsoluteFile().exists()) {
error("No such keystore file: " + keystoreFile);
return;
}
if (alias == null) {
error("Private key alias not set for signing");
return;
}
MessageDigest digestAlgorithms[] = new MessageDigest[digestNames.length];
getAlgorithms(digestNames, digestAlgorithms);
try {
Manifest manifest = jar.getManifest();
manifest.getMainAttributes().putValue("Signed-By", "Bnd");
// Create a new manifest that contains the
// Name parts with the specified digests
ByteArrayOutputStream o = new ByteArrayOutputStream();
manifest.write(o);
doManifest(jar, digestNames, digestAlgorithms, o);
o.flush();
byte newManifestBytes[] = o.toByteArray();
jar.putResource("META-INF/MANIFEST.MF", new EmbeddedResource(newManifestBytes, 0));
// Use the bytes from the new manifest to create
// a signature file
byte[] signatureFileBytes = doSignatureFile(digestNames, digestAlgorithms, newManifestBytes);
jar.putResource("META-INF/BND.SF", new EmbeddedResource(signatureFileBytes, 0));
// Now we must create an RSA signature
// this requires the private key from the keystore
KeyStore keystore = KeyStore.getInstance(KeyStore.getDefaultType());
KeyStore.PrivateKeyEntry privateKeyEntry = null;
java.io.FileInputStream keystoreInputStream = null;
try {
keystoreInputStream = new java.io.FileInputStream(keystoreFile);
char[] pw = password == null ? new char[0] : password.toCharArray();
keystore.load(keystoreInputStream, pw);
keystoreInputStream.close();
privateKeyEntry =
(PrivateKeyEntry) keystore.getEntry(alias, new KeyStore.PasswordProtection(pw));
} catch (Exception e) {
error(
"No able to load the private key from the give keystore("
+ keystoreFile.getAbsolutePath()
+ ") with alias "
+ alias
+ " : "
+ e);
return;
} finally {
IO.close(keystoreInputStream);
}
PrivateKey privateKey = privateKeyEntry.getPrivateKey();
Signature signature = Signature.getInstance("MD5withRSA");
signature.initSign(privateKey);
signature.update(signatureFileBytes);
signature.sign();
// TODO, place the SF in a PCKS#7 structure ...
// no standard class for this? The following
// is an idea but we will to have do ASN.1 BER
// encoding ...
ByteArrayOutputStream tmpStream = new ByteArrayOutputStream();
jar.putResource("META-INF/BND.RSA", new EmbeddedResource(tmpStream.toByteArray(), 0));
} catch (Exception e) {
error("During signing: " + e);
}
}