/**
* @see com.liferay.modulesadmin.portlet.ModulesAdminPortlet#getBundle( BundleContext,
* InputStream)
*/
public Bundle getBundle(BundleContext bundleContext, InputStream inputStream)
throws PortalException {
try {
if (inputStream.markSupported()) {
// 1 megabyte is more than enough for even the largest manifest
// file
inputStream.mark(1024 * 1000);
}
JarInputStream jarInputStream = new JarInputStream(inputStream);
Manifest manifest = jarInputStream.getManifest();
if (inputStream.markSupported()) {
inputStream.reset();
}
Attributes attributes = manifest.getMainAttributes();
String bundleSymbolicNameAttributeValue = attributes.getValue(Constants.BUNDLE_SYMBOLICNAME);
Parameters parameters = OSGiHeader.parseHeader(bundleSymbolicNameAttributeValue);
Set<String> bundleSymbolicNameSet = parameters.keySet();
Iterator<String> bundleSymbolicNameIterator = bundleSymbolicNameSet.iterator();
String bundleSymbolicName = bundleSymbolicNameIterator.next();
String bundleVersionAttributeValue = attributes.getValue(Constants.BUNDLE_VERSION);
Version bundleVersion = Version.parseVersion(bundleVersionAttributeValue);
for (Bundle bundle : bundleContext.getBundles()) {
Version curBundleVersion = Version.parseVersion(String.valueOf(bundle.getVersion()));
if (bundleSymbolicName.equals(bundle.getSymbolicName())
&& bundleVersion.equals(curBundleVersion)) {
return bundle;
}
}
return null;
} catch (IOException ioe) {
throw new PortalException(ioe);
}
}
/**
* Test if we can select
*
* @throws Exception
*/
public void testSelect() throws Exception {
Jar bjara = getContractExporter("atest", "2.5", "${exports}");
Jar bjarb = getContractExporter("btest", "2.5", "${exports}");
Builder a = newBuilder();
a.setTrace(true);
a.addClasspath(bjara); // 1x
a.addClasspath(bjarb); // 2x
a.setProperty(Constants.CONTRACT, "atest;alpha=1");
a.setImportPackage("org.osgi.service.cm,*");
a.setProperty("Export-Package", "test.refer");
Jar ajar = a.build();
assertTrue(a.check());
ajar.getManifest().write(System.out);
Domain domain = Domain.domain(ajar.getManifest());
Parameters p = domain.getRequireCapability();
p.remove("osgi.ee");
assertNotNull(p);
assertEquals(1, p.size());
Attrs attrs = p.get("osgi.contract");
String alpha = attrs.get("alpha");
assertEquals("1", alpha);
assertEquals("(&(osgi.contract=atest)(version=2.5.0))", attrs.get("filter:"));
}
/** @throws Exception */
File[] getBundleClasspathFiles() throws Exception {
if (this.bundleClasspathExpansion != null) return bundleClasspathExpansion;
File file = getFile();
Manifest m = getManifest();
String bundleClassPath;
if (m == null
|| (bundleClassPath = m.getMainAttributes().getValue(Constants.BUNDLE_CLASSPATH)) == null) {
this.bundleClasspathExpansion = new File[] {file};
} else {
File bundleClasspathDirectory =
IO.getFile(file.getParentFile(), "." + file.getName() + "-bcp");
Parameters header = new Parameters(bundleClassPath);
this.bundleClasspathExpansion = new File[header.size()];
bundleClasspathDirectory.mkdir();
int n = 0;
Jar jar = null;
try {
for (Map.Entry<String, Attrs> entry : header.entrySet()) {
if (".".equals(entry.getKey())) {
this.bundleClasspathExpansion[n] = file;
} else {
File member = new File(bundleClasspathDirectory, n + "-" + toName(entry.getKey()));
if (!isCurrent(file, member)) {
if (jar == null) {
jar = new Jar(file);
}
Resource resource = jar.getResource(entry.getKey());
if (resource == null) {
warning += "Invalid bcp entry: " + entry.getKey() + "\n";
} else {
IO.copy(resource.openInputStream(), member);
member.setLastModified(file.lastModified());
}
}
this.bundleClasspathExpansion[n] = member;
}
n++;
}
} finally {
if (jar != null) jar.close();
}
}
return this.bundleClasspathExpansion;
}
/** 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"));
}
/**
* Called when a change in the IDE is detected. We will then upate from the project and then
* update the remote framework.
*/
@Override
public void update() throws Exception {
updateFromProject();
Parameters runremote = new Parameters(getProject().getProperty(Constants.RUNREMOTE));
for (RunSessionImpl session : sessions)
try {
Attrs attrs = runremote.get(session.getName());
RunRemoteDTO dto = Converter.cnv(RunRemoteDTO.class, attrs);
session.update(dto);
} catch (Exception e) {
getProject().exception(e, "Failed to update session %s", session.getName());
}
}
/** We parse the -runremote and create sessions for each one of them */
@Override
public void prepare() throws Exception {
if (prepared) return;
prepared = true;
updateFromProject();
Map<String, Object> properties = new HashMap<String, Object>(getRunProperties());
calculatedProperties(properties);
Collection<String> embeddedActivators = getActivators();
if (embeddedActivators != null && !embeddedActivators.isEmpty()) {
properties.put("biz.aQute.remote.embedded", Strings.join(embeddedActivators));
}
for (Entry<String, Attrs> entry : runremote.entrySet()) {
RunRemoteDTO dto = converter.convert(RunRemoteDTO.class, entry.getValue());
dto.name = entry.getKey();
Map<String, Object> sessionProperties = new HashMap<String, Object>(properties);
sessionProperties.putAll(entry.getValue());
sessionProperties.put("session.name", dto.name);
if (dto.jmx != null) {
tryJMXDeploy(dto.jmx, "biz.aQute.remote.agent");
}
RunSessionImpl session = new RunSessionImpl(this, dto, properties);
sessions.add(session);
}
}
/**
* 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"));
}
public static List<Capability> getCapabilitiesFrom(Parameters rr) throws Exception {
List<Capability> capabilities = new ArrayList<>();
for (Entry<String, Attrs> e : rr.entrySet()) {
capabilities.add(
getCapabilityFrom(Processor.removeDuplicateMarker(e.getKey()), e.getValue()));
}
return capabilities;
}
/**
* 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"));
}
public static List<Requirement> getRequirementsFrom(Parameters rr) throws Exception {
List<Requirement> requirements = new ArrayList<Requirement>();
for (Entry<String, Attrs> e : rr.entrySet()) {
requirements.add(
getRequirementFrom(Processor.removeDuplicateMarker(e.getKey()), e.getValue()));
}
return requirements;
}
/**
* Make sure we do not add a contract if not used
*
* @throws Exception
*/
public void testUnused() throws Exception {
Jar bjara = getContractExporter("atest", "2.5", "${exports}");
Builder a = newBuilder();
a.setTrace(true);
a.addClasspath(bjara);
a.setProperty(Constants.CONTRACT, "*");
a.setImportPackage("test.packageinfo,*");
a.setProperty("Export-Package", "test.refer");
Jar ajar = a.build();
assertTrue(a.check());
Domain domain = Domain.domain(ajar.getManifest());
Parameters p = domain.getRequireCapability();
p.remove("osgi.ee");
assertEquals(0, p.size());
}
/**
* Test the warnings that we have no no version
*
* @throws Exception
*/
public void testWarningVersion() throws Exception {
Jar bjara = getContractExporter("abc", null, "${exports}");
Builder a = newBuilder();
a.setTrace(true);
a.addClasspath(bjara);
a.setProperty(Constants.CONTRACT, "*");
a.setImportPackage("test.packageinfo,*");
a.setProperty("Export-Package", "test.refer");
Jar ajar = a.build();
assertTrue(
a.check(
"Contract \\[name=abc;version=0.0.0;from=biz.aQute.bndlib.tests] does not declare a version"));
Domain domain = Domain.domain(ajar.getManifest());
Parameters p = domain.getRequireCapability();
p.remove("osgi.ee");
assertEquals(0, p.size());
}
/**
* 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"));
}
private boolean _hasLazyActivationPolicy(Bundle bundle) {
Dictionary<String, String> headers = bundle.getHeaders();
String fragmentHost = headers.get(Constants.FRAGMENT_HOST);
if (fragmentHost != null) {
return false;
}
String activationPolicy = headers.get(Constants.BUNDLE_ACTIVATIONPOLICY);
if (activationPolicy == null) {
return false;
}
Parameters parameters = OSGiHeader.parseHeader(activationPolicy);
if (parameters.containsKey(Constants.ACTIVATION_LAZY)) {
return true;
}
return false;
}
/** Check implementation version policy. Uses the package test.versionpolicy.(uses|implemented) */
static void assertPolicy(String pack, String type) throws Exception {
Builder a = new Builder();
a.addClasspath(new File("bin"));
a.setProperty("Export-Package", "test.versionpolicy.api");
Jar jar = a.build();
Builder b = new Builder();
b.addClasspath(jar);
b.addClasspath(new File("bin"));
b.setProperty("-versionpolicy-impl", "IMPL");
b.setProperty("-versionpolicy-uses", "USES");
b.setProperty("Private-Package", pack);
b.build();
Manifest m = b.getJar().getManifest();
m.write(System.err);
Map<String, String> map = b.getImports().getByFQN("test.versionpolicy.api");
assertNotNull(map);
// String s = map.get(Constants.IMPLEMENTED_DIRECTIVE);
// assertEquals("true", s);
Parameters mp = Processor.parseHeader(m.getMainAttributes().getValue("Import-Package"), null);
assertEquals(type, mp.get("test.versionpolicy.api").get("version"));
}
public void testSimple() throws Exception {
Jar bjar = getContractExporter("test", "2.5", "${exports}");
Builder a = newBuilder();
a.setTrace(true);
a.addClasspath(bjar);
a.setProperty(Constants.CONTRACT, "*");
a.setImportPackage("org.osgi.service.cm,*");
a.setProperty("Export-Package", "test.refer");
Jar ajar = a.build();
assertTrue(a.check());
Domain domain = Domain.domain(ajar.getManifest());
Parameters rc = domain.getRequireCapability();
rc.remove("osgi.ee");
System.out.println(rc);
assertEquals(1, rc.size());
Packages ps = a.getImports();
assertTrue(ps.containsFQN("org.osgi.service.cm"));
Attrs attrs = ps.getByFQN("org.osgi.service.cm");
assertNotNull(attrs);
assertNull(attrs.getVersion());
}
public static void testCapability() throws Exception {
Parameters h =
OSGiHeader.parseHeader(
"test; version.list:List < Version > = \"1.0, 1.1, 1.2\"; effective:=\"resolve\"; test =\"aName\";version : Version=\"1.0\"; long :Long=\"100\"; "
+ "double: Double=\"1.001\"; string:String =\"aString\"; "
+ "long.list : List <Long >=\"1, 2, 3, 4\";double.list: List< Double>= \"1.001, 1.002, 1.003\"; "
+ "string.list :List<String >= \"aString,bString,cString\"");
assertEquals(Attrs.Type.VERSION, h.get("test").getType("version"));
assertEquals(Attrs.Type.LONG, h.get("test").getType("long"));
assertEquals(Attrs.Type.DOUBLE, h.get("test").getType("double"));
assertEquals(Attrs.Type.STRING, h.get("test").getType("string"));
assertEquals(Attrs.Type.STRING, h.get("test").getType("test"));
assertEquals(Attrs.Type.LONGS, h.get("test").getType("long.list"));
assertEquals(Attrs.Type.DOUBLES, h.get("test").getType("double.list"));
assertEquals(Attrs.Type.STRINGS, h.get("test").getType("string.list"));
assertEquals(Attrs.Type.VERSIONS, h.get("test").getType("version.list"));
}
public CommandData parseCommandData(ArtifactData artifact) throws Exception {
File source = new File(artifact.file);
if (!source.isFile()) throw new FileNotFoundException();
CommandData data = new CommandData();
data.sha = artifact.sha;
data.jpmRepoDir = repoDir.getCanonicalPath();
JarFile jar = new JarFile(source);
try {
reporter.trace("Parsing %s", source);
Manifest m = jar.getManifest();
Attributes main = m.getMainAttributes();
data.name = data.bsn = main.getValue("Bundle-SymbolicName");
String version = main.getValue("Bundle-Version");
if (version == null) data.version = Version.LOWEST;
else data.version = new Version(version);
data.main = main.getValue("Main-Class");
data.description = main.getValue("Bundle-Description");
data.title = main.getValue("JPM-Name");
reporter.trace("name " + data.name + " " + data.main + " " + data.title);
DependencyCollector path = new DependencyCollector(this);
path.add(artifact);
DependencyCollector bundles = new DependencyCollector(this);
if (main.getValue("JPM-Classpath") != null) {
Parameters requires = OSGiHeader.parseHeader(main.getValue("JPM-Classpath"));
for (Map.Entry<String, Attrs> e : requires.entrySet()) {
path.add(e.getKey(), e.getValue().get("name")); // coordinate
}
} else if (!artifact.local) { // No JPM-Classpath, falling back to
// server's revision
// Iterable<RevisionRef> closure =
// library.getClosure(artifact.sha,
// false);
// System.out.println("getting closure " + artifact.url + " " +
// Strings.join("\n",closure));
// if (closure != null) {
// for (RevisionRef ref : closure) {
// path.add(Hex.toHexString(ref.revision));
// }
// }
}
if (main.getValue("JPM-Runbundles") != null) {
Parameters jpmrunbundles = OSGiHeader.parseHeader(main.getValue("JPM-Runbundles"));
for (Map.Entry<String, Attrs> e : jpmrunbundles.entrySet()) {
bundles.add(e.getKey(), e.getValue().get("name"));
}
}
reporter.trace("collect digests runpath");
data.dependencies.addAll(path.getDigests());
reporter.trace("collect digests bundles");
data.runbundles.addAll(bundles.getDigests());
Parameters command = OSGiHeader.parseHeader(main.getValue("JPM-Command"));
if (command.size() > 1) reporter.error("Only one command can be specified");
for (Map.Entry<String, Attrs> e : command.entrySet()) {
data.name = e.getKey();
Attrs attrs = e.getValue();
if (attrs.containsKey("jvmargs")) data.jvmArgs = attrs.get("jvmargs");
if (attrs.containsKey("title")) data.title = attrs.get("title");
if (data.title != null) data.title = data.name;
}
return data;
} finally {
jar.close();
}
}
private void _processURL(StringBundler sb, URL url, String[] ignoredFragments) {
Manifest manifest = null;
try {
manifest = new Manifest(url.openStream());
} catch (IOException ioe) {
_log.error(ioe, ioe);
return;
}
Attributes attributes = manifest.getMainAttributes();
String bundleSymbolicName = attributes.getValue(Constants.BUNDLE_SYMBOLICNAME);
if (Validator.isNull(bundleSymbolicName)) {
String urlString = url.toString();
if (urlString.contains(PropsValues.LIFERAY_LIB_PORTAL_DIR)) {
manifest = _calculateManifest(url, manifest);
attributes = manifest.getMainAttributes();
bundleSymbolicName =
attributes.getValue(new Attributes.Name(Constants.BUNDLE_SYMBOLICNAME));
if (Validator.isNull(bundleSymbolicName)) {
return;
}
} else {
return;
}
}
String rootBundleSymbolicName = bundleSymbolicName;
int index = rootBundleSymbolicName.indexOf(StringPool.SEMICOLON);
if (index != -1) {
rootBundleSymbolicName = rootBundleSymbolicName.substring(0, index);
}
for (String ignoredFragment : ignoredFragments) {
String ignoredFramentPrefix = ignoredFragment.substring(0, ignoredFragment.length() - 1);
if (rootBundleSymbolicName.equals(ignoredFragment)
|| (ignoredFragment.endsWith(StringPool.STAR)
&& rootBundleSymbolicName.startsWith(ignoredFramentPrefix))) {
return;
}
}
String exportPackage = GetterUtil.getString(attributes.getValue(Constants.EXPORT_PACKAGE));
Parameters parameters = OSGiHeader.parseHeader(exportPackage);
for (Map.Entry<String, Attrs> entry : parameters.entrySet()) {
String key = entry.getKey();
List<URL> urls = _extraPackageMap.get(key);
if (urls == null) {
urls = new ArrayList<URL>();
_extraPackageMap.put(key, urls);
}
urls.add(url);
sb.append(key);
Attrs value = entry.getValue();
if (value.containsKey("version")) {
sb.append(";version=\"");
sb.append(value.get("version"));
sb.append("\"");
}
sb.append(StringPool.COMMA);
}
}
/**
* Create a standalone executable. All entries on the runpath are rolled out into the JAR and the
* runbundles are copied to a directory in the jar. The launcher will see that it starts in
* embedded mode and will automatically detect that it should load the bundles from inside. This
* is drive by the launcher.embedded flag.
*
* @throws Exception
*/
@Override
public Jar executable() throws Exception {
// TODO use constants in the future
Parameters packageHeader = OSGiHeader.parseHeader(project.getProperty("-package"));
boolean useShas = packageHeader.containsKey("jpm");
project.trace("Useshas %s %s", useShas, packageHeader);
Jar jar = new Jar(project.getName());
Builder b = new Builder();
project.addClose(b);
if (!project.getIncludeResource().isEmpty()) {
b.setIncludeResource(project.getIncludeResource().toString());
b.setProperty(Constants.RESOURCEONLY, "true");
b.build();
if (b.isOk()) {
jar.addAll(b.getJar());
}
project.getInfo(b);
}
List<String> runpath = getRunpath();
Set<String> runpathShas = new LinkedHashSet<String>();
Set<String> runbundleShas = new LinkedHashSet<String>();
List<String> classpath = new ArrayList<String>();
for (String path : runpath) {
project.trace("embedding runpath %s", path);
File file = new File(path);
if (file.isFile()) {
if (useShas) {
String sha = SHA1.digest(file).asHex();
runpathShas.add(sha + ";name=\"" + file.getName() + "\"");
} else {
String newPath = "jar/" + file.getName();
jar.putResource(newPath, new FileResource(file));
classpath.add(newPath);
}
}
}
// Copy the bundles to the JAR
List<String> runbundles = (List<String>) getRunBundles();
List<String> actualPaths = new ArrayList<String>();
for (String path : runbundles) {
project.trace("embedding run bundles %s", path);
File file = new File(path);
if (!file.isFile()) project.error("Invalid entry in -runbundles %s", file);
else {
if (useShas) {
String sha = SHA1.digest(file).asHex();
runbundleShas.add(sha + ";name=\"" + file.getName() + "\"");
actualPaths.add("${JPMREPO}/" + sha);
} else {
String newPath = "jar/" + file.getName();
jar.putResource(newPath, new FileResource(file));
actualPaths.add(newPath);
}
}
}
LauncherConstants lc = getConstants(actualPaths, true);
lc.embedded = !useShas;
lc.storageDir = null; // cannot use local info
final Properties p = lc.getProperties(new UTF8Properties());
ByteArrayOutputStream bout = new ByteArrayOutputStream();
p.store(bout, "");
jar.putResource(
LauncherConstants.DEFAULT_LAUNCHER_PROPERTIES,
new EmbeddedResource(bout.toByteArray(), 0L));
Manifest m = new Manifest();
Attributes main = m.getMainAttributes();
for (Entry<Object, Object> e : project.getFlattenedProperties().entrySet()) {
String key = (String) e.getKey();
if (key.length() > 0 && Character.isUpperCase(key.charAt(0)))
main.putValue(key, (String) e.getValue());
}
Instructions instructions = new Instructions(project.getProperty(Constants.REMOVEHEADERS));
Collection<Object> result = instructions.select(main.keySet(), false);
main.keySet().removeAll(result);
if (useShas) {
project.trace("Use JPM launcher");
m.getMainAttributes().putValue("Main-Class", JPM_LAUNCHER_FQN);
m.getMainAttributes().putValue("JPM-Classpath", Processor.join(runpathShas));
m.getMainAttributes().putValue("JPM-Runbundles", Processor.join(runbundleShas));
URLResource jpmLauncher = new URLResource(this.getClass().getResource("/" + JPM_LAUNCHER));
jar.putResource(JPM_LAUNCHER, jpmLauncher);
doStart(jar, JPM_LAUNCHER_FQN);
} else {
project.trace("Use Embedded launcher");
m.getMainAttributes().putValue("Main-Class", EMBEDDED_LAUNCHER_FQN);
m.getMainAttributes().putValue(EmbeddedLauncher.EMBEDDED_RUNPATH, Processor.join(classpath));
URLResource embeddedLauncher =
new URLResource(this.getClass().getResource("/" + EMBEDDED_LAUNCHER));
jar.putResource(EMBEDDED_LAUNCHER, embeddedLauncher);
doStart(jar, EMBEDDED_LAUNCHER_FQN);
}
if (project.getProperty(Constants.DIGESTS) != null)
jar.setDigestAlgorithms(project.getProperty(Constants.DIGESTS).trim().split("\\s*,\\s*"));
else jar.setDigestAlgorithms(new String[] {"SHA-1", "MD-5"});
jar.setManifest(m);
return jar;
}
