/**
* Register the p-units of a given bundle.
*
* @param b the bundle the p-units are in
*/
public void registerPersistenceUnitsInBundle(Bundle b) {
debug("Extender.registerPersistenceUnitsInBundle: ", b);
if (!isAssigned(b)) {
warning("Register called on bundle " + b.getSymbolicName(), " but bundle was not assigned");
return;
}
if (areCompatibleBundles(b, mgr.getBundle())) {
debug("Extender provider compatible with bundle: ", b);
mgr.registerPersistenceUnits(unitsByBundle.get(b));
} else {
warning(
"Cannot support bundle "
+ b.getSymbolicName()
+ " because it is not JPA-compatible with the EclipseLink bundles. "
+ "This is because there are multiple bundles exporting javax.persistence "
+ "and the persistence unit bundle has resolved to a different one than "
+ "the EclipseLink bundles. "
+ "\nTo fix this, uninstall one of the bundles containing javax.persistence "
+ "so that both the persistence unit bundle and the provider bundles resolve "
+ "to the same javax.persistence package.");
unassignPersistenceUnitsInBundle(b);
// No point in updating or refreshing.
// It would likely just re-resolve to the same JPA interface package.
}
}
/**
* Loads the class <code>qualifiedName</code> from the specified <code>bundle</code> if possible.
*
* @param bundle The bundle from which to load the sought class.
* @param qualifiedName Qualified name of the class that is to be loaded.
* @return An instance of the class if it could be loaded, <code>null</code> otherwise.
*/
private Class<?> internalLoadClass(Bundle bundle, String qualifiedName) {
try {
WorkspaceClassInstance workspaceInstance = workspaceLoadedClasses.get(qualifiedName);
final Class<?> clazz;
if (workspaceInstance == null) {
clazz = bundle.loadClass(qualifiedName);
workspaceLoadedClasses.put(
qualifiedName, new WorkspaceClassInstance(clazz, bundle.getSymbolicName()));
} else if (workspaceInstance.isStale()) {
clazz = bundle.loadClass(qualifiedName);
workspaceInstance.setStale(false);
workspaceInstance.setClass(clazz);
} else {
clazz = workspaceInstance.getClassInstance();
}
return clazz;
} catch (ClassNotFoundException e) {
e.fillInStackTrace();
AcceleoCommonPlugin.log(
AcceleoCommonMessages.getString(
"BundleClassLookupFailure", //$NON-NLS-1$
qualifiedName,
bundle.getSymbolicName()),
e,
false);
}
return null;
}
@Override
public boolean uninstall(OTEStatusCallback<ConfigurationStatus> statusCallback) {
boolean result = true;
for (Bundle bundle : installedBundles) {
try {
bundle.uninstall();
} catch (BundleException ex) {
result = false;
statusCallback.error("Failed to uninstall " + bundle.getSymbolicName(), ex);
}
}
installedBundles.clear();
for (Bundle bundle : runningBundles) {
try {
String entry = bundle.getHeaders().get("Fragment-Host");
if (entry == null) {
bundle.stop();
}
bundle.uninstall();
} catch (BundleException ex) {
result = false;
statusCallback.error("Failed to stop and uninstall " + bundle.getSymbolicName(), ex);
}
}
runningBundles.clear();
return result;
}
/**
* Register namespaces defined in the bundle in the namespace table.
*
* @param bundle The bundle.
*/
private void registerNamespaces(Bundle bundle) {
final String definition = (String) bundle.getHeaders().get(NAMESPACES_BUNDLE_HEADER);
if (definition != null) {
log.debug(
"registerNamespaces: Bundle {} tries to register: {}",
bundle.getSymbolicName(),
definition);
final StringTokenizer st = new StringTokenizer(definition, ",");
final List<NamespaceEntry> entries = new ArrayList<NamespaceEntry>();
while (st.hasMoreTokens()) {
final String token = st.nextToken().trim();
int pos = token.indexOf('=');
if (pos == -1) {
log.warn(
"registerNamespaces: Bundle {} has an invalid namespace manifest header entry: {}",
bundle.getSymbolicName(),
token);
} else {
final String prefix = token.substring(0, pos).trim();
final String namespace = token.substring(pos + 1).trim();
entries.add(new NamespaceEntry(prefix, namespace));
}
}
if (entries.size() > 0) {
this.namespaceTable.put(
bundle.getBundleId(), entries.toArray(new NamespaceEntry[entries.size()]));
}
}
}
@Override
public boolean start(OTEStatusCallback<ConfigurationStatus> statusCallback) {
boolean pass = true;
sortBundles(installedBundles);
Iterator<Bundle> iter = installedBundles.iterator();
while (iter.hasNext()) {
Bundle bundle = iter.next();
try {
String entry = bundle.getHeaders().get("Fragment-Host");
if (entry == null) {
int bundleState = bundle.getState();
if (bundleState != Bundle.ACTIVE) {
bundle.start();
}
}
// We got here because bundle.start did not exception
runningBundles.add(bundle);
iter.remove();
statusCallback.log("started " + bundle.getSymbolicName());
} catch (BundleException ex) {
pass = false;
statusCallback.error("Failed to start " + bundle.getSymbolicName(), ex);
} finally {
statusCallback.incrememtUnitsWorked(1);
}
}
return pass;
}
@Test
public void shouldUseCorrectClassLoaderWhenCreatingInstances() throws ClassNotFoundException {
mockSampleFields();
mockEntity();
mockDataService();
Bundle ddeBundle = mock(Bundle.class);
Bundle entitiesBundle = mock(Bundle.class);
when(bundleContext.getBundles()).thenReturn(new Bundle[] {ddeBundle, entitiesBundle});
when(entity.getBundleSymbolicName()).thenReturn("org.motechproject.test");
when(entitiesBundle.getSymbolicName())
.thenReturn(Constants.BundleNames.MDS_ENTITIES_SYMBOLIC_NAME);
when(ddeBundle.getSymbolicName()).thenReturn("org.motechproject.test");
Class testClass = TestSample.class;
when(entitiesBundle.loadClass(testClass.getName())).thenReturn(testClass);
when(ddeBundle.loadClass(testClass.getName())).thenReturn(testClass);
EntityRecord entityRecord =
new EntityRecord(null, ENTITY_ID, Collections.<FieldRecord>emptyList());
when(entity.isDDE()).thenReturn(true);
instanceService.saveInstance(entityRecord);
verify(ddeBundle).loadClass(TestSample.class.getName());
when(entity.isDDE()).thenReturn(false);
instanceService.saveInstance(entityRecord);
verify(entitiesBundle).loadClass(TestSample.class.getName());
verify(motechDataService, times(2)).create(any(TestSample.class));
}
@Override
public boolean start(URI uri) {
final String warName = extractDecodedWarNameFromString(uri.toString());
String extractionFolderName =
WebBundleUtils.calculateCorrectSymbolicName(
extractDecodedWarNameFromString(uri.toString()));
Bundle bundle = getInstalledBundle(extractionFolderName);
if (bundle == null) {
this.eventLogger.log(WARDeployerLogEvents.NANO_STARTING_ERROR, uri);
logger.error(
"Cannot start deployable with URI + ["
+ uri
+ "]. There is no bundle installed with this URI.");
return false;
}
StatusFileModificator.deleteStatusFile(warName, this.pickupDir);
final long lastModified = new File(uri).lastModified();
this.eventLogger.log(
WARDeployerLogEvents.NANO_WEB_STARTING, bundle.getSymbolicName(), bundle.getVersion());
try {
bundle.start();
} catch (Exception e) {
this.eventLogger.log(
WARDeployerLogEvents.NANO_STARTING_ERROR,
e,
bundle.getSymbolicName(),
bundle.getVersion());
StatusFileModificator.createStatusFile(
warName,
this.pickupDir,
StatusFileModificator.OP_DEPLOY,
STATUS_ERROR,
bundle.getBundleId(),
lastModified);
return STATUS_ERROR;
}
this.eventLogger.log(
WARDeployerLogEvents.NANO_WEB_STARTED, bundle.getSymbolicName(), bundle.getVersion());
// now update bundle's info
if (!updateBundlesInfo(bundle, getLocationForBundlesInfo(extractionFolderName))) {
StatusFileModificator.createStatusFile(
warName,
this.pickupDir,
StatusFileModificator.OP_DEPLOY,
STATUS_ERROR,
bundle.getBundleId(),
lastModified);
return STATUS_ERROR;
}
StatusFileModificator.createStatusFile(
warName,
this.pickupDir,
StatusFileModificator.OP_DEPLOY,
STATUS_OK,
bundle.getBundleId(),
lastModified);
return STATUS_OK;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
*/
public void start(BundleContext context) throws Exception {
super.start(context);
plugin = this;
// create a new RobotDeviceListener
Bundle[] bundles = context.getBundles();
// ("org.eclipse.equinox.event");
Bundle r_osgi = null;
for (int i = 0; i < bundles.length; i++) {
Bundle bundle = bundles[i];
System.out.println("Bundle.getSymbolicName(): " + bundle.getSymbolicName());
if ("org.eclipse.equinox.event".equals(bundle.getSymbolicName())) {
bundle.start();
} else if ("org.eclipse.equinox.log".equals(bundle.getSymbolicName())) {
bundle.start();
} else if ("ch.ethz.iks.r_osgi.remote".equals(bundle.getSymbolicName())) {
r_osgi = bundle;
} else if ("org.leibnix.device.clocktimer.interfaces".equals(bundle.getSymbolicName())) {
bundle.start();
}
}
if (r_osgi != null) {
r_osgi.start();
}
// ServiceReference ref = context
// .getServiceReference(RemoteOSGiService.class.getName());
// if (ref != null) {
// remote = (RemoteOSGiService) context.getService(ref);
//
// DeviceListener listener = new DeviceListener(context, remote);
//
// // register for discovery
// context.registerService(DiscoveryListener.class.getName(),
// listener, null);
// }
// ServiceReference ref = context
// .getServiceReference(RemoteOSGiService.class.getName());
// if (ref != null) {
// RemoteOSGiService rs = (RemoteOSGiService) context.getService(ref);
// ServiceURL[] serviceURLs = rs.connect(InetAddress.getLocalHost(),
// 9278, null); // FIXME use remote host from preferences
//
// for (ServiceURL service : serviceURLs) {
// ServiceType serviceType = service.getServiceType();
//
// System.out.println(serviceType.getConcreteTypeName());
// if (serviceType.getConcreteTypeName().endsWith("ClockTimer")) {
// rs.fetchService(service);
// Object remoteService = rs.getFetchedService(service);
// // if (remoteService instanceof IClockTimer) {
// IClockTimer clock = (IClockTimer) remoteService;
// clock.addTimer("1");
// // }
// break;
// }
// }
// }
}
public void assertPluginsResolved(Bundle[] bundles) {
for (Bundle bundle : bundles) {
assertTrue(
"Plugin '" + bundle.getSymbolicName() + "' is not resolved", // $NON-NLS-1$ //$NON-NLS-2$
isPluginResolved(bundle.getSymbolicName()));
System.out.println(bundle.getSymbolicName() + " was resolved and activated");
}
}
public synchronized RuntimeContext createContext(Bundle bundle) throws Exception {
RuntimeContext ctx = contexts.get(bundle.getSymbolicName());
if (ctx == null) {
// hack to handle fragment bundles
ctx = new OSGiRuntimeContext(bundle);
contexts.put(bundle.getSymbolicName(), ctx);
loadComponents(bundle, ctx);
}
return ctx;
}
protected Bundle getInstalledBundle(String symbolicName) {
for (Bundle b : bundleContext.getBundles()) {
if (b.getSymbolicName().equals(symbolicName)) {
return b;
}
}
for (Bundle b : bundleContext.getBundles()) {
System.err.println("Bundle: " + b.getSymbolicName());
}
throw new RuntimeException("Bundle " + symbolicName + " does not exist");
}
private Map<String, Bundle> getBundlesToRestart(Set<String> bundleSymbolicNames) {
Map<String, Bundle> bundlesToRestart = new HashMap<>();
for (Bundle bundle : bundleCtx.getBundles()) {
if (bundleSymbolicNames.contains(bundle.getSymbolicName())) {
bundlesToRestart.put(bundle.getSymbolicName(), bundle);
}
}
return bundlesToRestart;
}
/**
* Go through the p-units in a given bundle and assign the ones that do not have a provider, or
* have a provider specified as this one.
*
* @param b the bundle to look for p-units in
*/
public void tryAssigningPersistenceUnitsInBundle(Bundle b) {
debug("Extender.tryAssigningPersistenceUnitsInBundle: ", b);
// If we have already assigned it then bail
if (isAssigned(b)) {
warning("Attempted to assign a bundle that was already assigned: ", b.toString());
return;
}
// Look for all of the persistence descriptor files in the bundle
List<PersistenceDescriptorInfo> descriptorInfos = bundleUtil.persistenceDescriptorInfos(b);
if (descriptorInfos.isEmpty()) {
// There were no descriptors specified in the manifest - check if there is any config from
// config admin
PersistenceUnitConfiguration config =
mgr.getConfigAdminListener().configForBundle(b.getSymbolicName());
if (config != null) {
// There is a config to go with this bundle.
// Create a special descriptorInfo with the descriptor string right inside it
debug("No persistence descriptors, but found a config for bundle ", b);
descriptorInfos.add(new InlinedDescriptorInfo(config));
} else {
// We can't assign it just yet. Add to the limbo list
warning("No persistence descriptors found in persistence bundle ", b.getSymbolicName());
debug("Putting bundle ", b, " in limbo");
inLimbo.put(b.getSymbolicName(), b);
// The bundle will be removed from being in limbo by the config admin listener when
// a config comes along that contains the bsn of this bundle. It will then be refreshed.
return;
}
}
// Do a partial parse of the descriptors
Set<PUnitInfo> pUnitInfos = bundleUtil.persistenceUnitInfoFromXmlFiles(descriptorInfos);
// Cycle through each p-unit info and see if a provider was specified
for (PUnitInfo info : pUnitInfos) {
if ((info.getProvider() == null)
|| (EclipseLinkProvider.ECLIPSELINK_PROVIDER_CLASS_NAME.equals(info.getProvider()))) {
// We can be the provider; claim the p-unit and add it to our list
info.setBundle(b);
info.setAssignedProvider(mgr.getProvider());
debug("Assigning punit ", info.getUnitName(), " to this provider");
addToBundleUnits(unitsByBundle, b, info);
}
}
// If we found any that were for us then move on to do the preResolve work
List<PUnitInfo> unitsFound = unitsByBundle.get(b);
if ((unitsFound != null) && (unitsFound.size() != 0)) {
mgr.preResolve(b, unitsByBundle.get(b));
}
}
@Test
public void testOSGi() throws Exception {
Assert.assertNotNull(bundleContext);
Bundle bundle = bundleContext.getBundle();
System.out.println("symbolic name " + bundle.getSymbolicName());
System.out.println("vendor " + bundleContext.getProperty(Constants.FRAMEWORK_VENDOR));
for (Bundle b : bundleContext.getBundles()) {
System.out.println(b.getSymbolicName() + " " + b.getBundleId());
}
}
/**
* Returns the bundle id of the bundle that contains the provided object, or <code>null</code> if
* the bundle could not be determined.
*/
public String getBundleId(Object object) {
if (bundleTracker == null) {
if (JobManager.DEBUG) JobMessages.message("Bundle tracker is not set"); // $NON-NLS-1$
return null;
}
PackageAdmin packageAdmin = (PackageAdmin) bundleTracker.getService();
if (object == null) return null;
if (packageAdmin == null) return null;
Bundle source = packageAdmin.getBundle(object.getClass());
if (source != null && source.getSymbolicName() != null) return source.getSymbolicName();
return null;
}
public void assertPluginsResolved(String[] ids) {
for (String id : ids) {
Bundle bundle = Platform.getBundle(id);
assertNotNull(MessageFormat.format("Could not get bundle {0} instance", id), bundle);
assertTrue(
MessageFormat.format(
"Plugin '{0}' is not resolved",
bundle.getSymbolicName()), // $NON-NLS-1$ //$NON-NLS-2$
isPluginResolved(bundle.getSymbolicName()));
System.out.println(
MessageFormat.format("{0} was resolved and activated", bundle.getSymbolicName()));
}
}
/**
* see {@link
* org.eclipse.objectteams.otequinox.hook.IAspectRegistry#getAdaptingAspectPlugins(Bundle)}
*/
public String[] getAdaptingAspectPlugins(Bundle baseBundle) {
InitState state = checkInitialization(baseBundle.getSymbolicName());
if (state == InitState.NOT_YET) return new String[0];
String[] result = this.otEquinox.getAdaptingAspectPlugins(baseBundle);
if (result.length > 0) {
if (state == InitState.TOO_LATE)
throw new RuntimeException(
"Boot order problem: base bundle "
+ baseBundle.getSymbolicName()
+ " was loaded before the transformer plug-in was ready!");
}
return result;
}
@Override
public void bundleChanged(BundleEvent event) {
Bundle bundle = event.getBundle();
if (event.getType() == BundleEvent.STARTED) {
logger.info(
String.format(
"Starting %s [%d] bundle.", bundle.getSymbolicName(), bundle.getBundleId()));
} else if (event.getType() == BundleEvent.STOPPED) {
logger.info(
String.format(
"Stopping %s [%d] bundle.", bundle.getSymbolicName(), bundle.getBundleId()));
}
}
public static Bundle getBundleByNameOrId(BundleContext bundleContext, String bundleId) {
Bundle result = null;
if (isLong(bundleId)) {
result = bundleContext.getBundle(Long.valueOf(bundleId));
} else {
for (Bundle bundle : bundleContext.getBundles()) {
if (bundle.getSymbolicName() != null && bundle.getSymbolicName().equals(bundleId)) {
result = bundle;
break;
}
}
}
return result;
}
/**
* You will get a list of bundles installed by default plus your testcase, wrapped into a bundle
* called pax-exam-probe
*/
@Test
public void listBundles() {
for (Bundle b : bundleContext.getBundles()) {
if (b.getState() != Bundle.ACTIVE && b.getState() != Bundle.RESOLVED)
fail("Bundle should be active: " + b);
Dictionary headers = b.getHeaders();
String ctxtPath = (String) headers.get(WEB_CONTEXT_PATH);
if (ctxtPath != null)
System.out.println(
"Bundle " + b.getBundleId() + " : " + b.getSymbolicName() + " : " + ctxtPath);
else System.out.println("Bundle " + b.getBundleId() + " : " + b.getSymbolicName());
}
}
@Override
public Enumeration<URL> getResources(String name) throws IOException {
log.warn(
"BundleClassLoaderProxy.getResources:" + name + " at Bundle:" + bundle.getSymbolicName());
// 如果是读取class文件，则交给真正的ClassLoader去处理
if (name.endsWith(".class")) {
return super.getResources(name);
}
List<URL> list = new ArrayList<URL>();
Enumeration<URL> urlEnum = bundleClassLoader.getResources(name);
if (urlEnum != null) {
while (urlEnum.hasMoreElements()) {
list.add(urlEnum.nextElement());
}
}
urlEnum = springClassLoader.getResources(name);
if (urlEnum != null) {
while (urlEnum.hasMoreElements()) {
list.add(urlEnum.nextElement());
}
}
return Collections.enumeration(list);
}
protected void loadComponents(Bundle bundle, RuntimeContext ctx) throws Exception {
String list = getComponentsList(bundle);
String name = bundle.getSymbolicName();
log.debug("Bundle: " + name + " components: " + list);
if (list == null) {
return;
}
StringTokenizer tok = new StringTokenizer(list, ", \t\n\r\f");
while (tok.hasMoreTokens()) {
String path = tok.nextToken();
URL url = bundle.getEntry(path);
log.debug("Loading component for: " + name + " path: " + path + " url: " + url);
if (url != null) {
try {
ctx.deploy(url);
} catch (Exception e) {
// just log error to know where is the cause of the
// exception
log.error("Error deploying resource: " + url);
Framework.handleDevError(e);
throw e;
}
} else {
String message = "Unknown component '" + path + "' referenced by bundle '" + name + "'";
log.error(message + ". Check the MANIFEST.MF");
Framework.handleDevError(null);
warnings.add(message);
}
}
}
@Test
public void testNullSymbolicName() throws Exception {
final JavaArchive archive = ShrinkWrap.create(JavaArchive.class, "null-symbolic-name");
archive.setManifest(
new Asset() {
public InputStream openStream() {
OSGiManifestBuilder builder = OSGiManifestBuilder.newInstance();
builder.addBundleName(archive.getName());
return builder.openStream();
}
});
Bundle bundle = installBundle(archive);
try {
assertBundleState(Bundle.INSTALLED, bundle.getState());
assertNull("Null symbolic name", bundle.getSymbolicName());
assertEquals("null-symbolic-name:0.0.0", bundle.toString());
bundle.start();
assertBundleState(Bundle.ACTIVE, bundle.getState());
} finally {
bundle.uninstall();
assertBundleState(Bundle.UNINSTALLED, bundle.getState());
}
}
public void startBundle(String bundleSymbolicName) throws BundleException {
for (Bundle bundle : bundleCtx.getBundles()) {
if (bundleSymbolicName.equals(bundle.getSymbolicName())) {
bundle.start();
}
}
}
/**
* @param appContext
* @return
*/
private URI determineApplicationModelURI(IApplicationContext appContext) {
Optional<String> appModelPath = getArgValue(IWorkbench.XMI_URI_ARG, appContext, false);
String appModelPathValue =
appModelPath
.filter(path -> !path.isEmpty())
.orElseGet(
() -> {
Bundle brandingBundle = appContext.getBrandingBundle();
if (brandingBundle != null) {
return brandingBundle.getSymbolicName()
+ "/"
+ E4Application.APPLICATION_MODEL_PATH_DEFAULT;
} else {
Logger logger = new WorkbenchLogger(PLUGIN_ID);
logger.error(
new Exception(),
"applicationXMI parameter not set and no branding plugin defined. "); //$NON-NLS-1$
}
return null;
});
URI applicationModelURI = null;
// check if the appModelPath is already a platform-URI and if so use it
if (URIHelper.isPlatformURI(appModelPathValue)) {
applicationModelURI = URI.createURI(appModelPathValue, true);
} else {
applicationModelURI = URI.createPlatformPluginURI(appModelPathValue, true);
}
return applicationModelURI;
}
/**
* test the supplementer registry with a supplemented bundle
*
* @throws Exception
*/
public void testSupplementerRegistryWithCombinedSupplementer() throws Exception {
Hashtable headers = new Hashtable();
headers.put("Eclipse-SupplementImporter", "test.import1");
headers.put("Eclipse-SupplementExporter", "test.export1");
headers.put("Eclipse-SupplementBundle", "symbolic-name-supplementedBundle1");
EasyMock.expect(bundle.getHeaders()).andStubReturn(headers);
EasyMock.expect(bundle.getSymbolicName()).andStubReturn("supplementer");
EasyMock.expect(context.getBundles()).andReturn(new Bundle[] {bundle});
EasyMock.expect(supplementedBundle1.getHeaders()).andStubReturn(new Hashtable());
headers = new Hashtable();
headers.put("Export-Package", "test.export1");
EasyMock.expect(supplementedBundle2.getHeaders()).andStubReturn(headers);
headers = new Hashtable();
headers.put("Import-Package", "test.import1");
EasyMock.expect(supplementedBundle3.getHeaders()).andStubReturn(headers);
EasyMock.replay(mocks);
registry.addBundle(bundle);
registry.addBundle(supplementedBundle1);
registry.addBundle(supplementedBundle2);
registry.addBundle(supplementedBundle3);
Supplementer[] supplementers = registry.getSupplementers(supplementedBundle1);
assertSame(bundle, supplementers[0].getSupplementerBundle());
supplementers = registry.getSupplementers(supplementedBundle2);
assertSame(bundle, supplementers[0].getSupplementerBundle());
supplementers = registry.getSupplementers(supplementedBundle3);
assertSame(bundle, supplementers[0].getSupplementerBundle());
EasyMock.verify(mocks);
}
/*
* Parses the specified content extension XML file into model elements.
*/
public ContentExtension[] parse(Bundle bundle, String path)
throws IOException, SAXException, ParserConfigurationException {
if (reader == null) {
reader = new DocumentReader();
}
URL url = FileLocator.find(bundle, new Path(path), null);
if (url != null) {
InputStream in = url.openStream();
UAElement extension = reader.read(in);
if (processor == null) {
processor =
new DocumentProcessor(
new ProcessorHandler[] {
new ValidationHandler(getRequiredAttributes(), getDeprecatedElements())
});
}
processor.process(extension, '/' + bundle.getSymbolicName() + '/' + path);
IUAElement[] children = extension.getChildren();
ContentExtension[] result = new ContentExtension[children.length];
System.arraycopy(children, 0, result, 0, children.length);
return result;
} else {
throw new FileNotFoundException();
}
}
public static void activateBundlesFromFile(BundleContext context, String bundleStartupFileName)
throws IOException, BundleException {
Map<String, Version> bundleMap =
readBundleActivationFile(context.getBundle(), bundleStartupFileName);
Map<String, Bundle> startupBundleMap = new HashMap<String, Bundle>();
for (Bundle b : context.getBundles()) {
String symbolicName = b.getSymbolicName();
if (bundleMap.containsKey(symbolicName)) {
Version version = b.getVersion();
Version reqVersion = bundleMap.get(symbolicName);
if (version.getMajor() == reqVersion.getMajor()
&& version.getMinor() >= reqVersion.getMinor()) {
if (startupBundleMap.containsKey(symbolicName)) {
Bundle previousBundle = startupBundleMap.get(symbolicName);
if (version.compareTo(previousBundle.getVersion()) <= 0) {
break;
}
}
startupBundleMap.put(symbolicName, b);
}
}
}
for (Bundle startupBundle : startupBundleMap.values()) {
logger.log(Level.INFO, "Starting bundle: " + startupBundle);
startupBundle.start();
}
}
@SuppressWarnings("deprecation")
public void testAllResolved() {
assertNotNull("Expected a Bundle Context", context);
StringBuilder sb = new StringBuilder();
for (Bundle b : context.getBundles()) {
if (b.getState() == Bundle.INSTALLED
&& b.getHeaders().get(aQute.bnd.osgi.Constants.FRAGMENT_HOST) == null) {
try {
b.start();
} catch (BundleException e) {
sb.append(b.getBundleId())
.append(" ")
.append(b.getSymbolicName())
.append(";")
.append(b.getVersion())
.append("\n");
sb.append(" ").append(e.getMessage()).append("\n\n");
System.err.println(e.getMessage());
}
}
}
Matcher matcher = IP_P.matcher(sb);
String out =
matcher.replaceAll(
"\n\n " + aQute.bnd.osgi.Constants.IMPORT_PACKAGE + ": $1;version=[$2,$3)\n");
assertTrue("Unresolved bundles\n" + out, sb.length() == 0);
}
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);
}
}
}
}
}
}
}
}