public void testInstallAtLocation() throws BundleException, MalformedURLException, IOException {
// create disconnected test regions
Region r1 = digraph.createRegion(getName() + ".1");
Region r2 = digraph.createRegion(getName() + ".2");
String location = bundleInstaller.getBundleLocation(PP1);
Bundle b1 = null;
Bundle b2 = null;
String l1 = null;
String l2 = null;
try {
URL url = new URL(location);
b1 = r1.installBundle(location + ".1", url.openStream());
l1 = b1.getLocation();
b2 = r2.installBundleAtLocation(location + ".2", url.openStream());
l2 = b2.getLocation();
} finally {
if (b1 != null) {
try {
b1.uninstall();
} catch (BundleException e) {
// ignore
}
}
if (b2 != null) {
try {
b2.uninstall();
} catch (BundleException e) {
// ignore
}
}
}
assertEquals("Wrong location found.", location + ".1#" + r1.getName(), l1);
assertEquals("Wrong location found.", location + ".2", l2);
}
private void assertInstallFail(String name, Region region) {
try {
Bundle b = bundleInstaller.installBundle(name, region);
b.uninstall();
fail("Expected a bundle exception on duplicate bundle install: " + region);
} catch (BundleException e) {
// expected
assertEquals("Wrong exception type.", BundleException.DUPLICATE_BUNDLE_ERROR, e.getType());
}
}
/**
* Retrieves a reference to the Gibberish bundle, stops it and uninstalls it and then reinstalls
* it in order to make sure that accounts are not reloaded once removed.
*
* @throws java.lang.Exception if something goes wrong while manipulating the bundles.
*/
public void testAccountUninstallationPersistence() throws Exception {
Bundle providerBundle = GibberishSlickFixture.providerBundle;
providerBundle.stop();
assertTrue(
"Couldn't stop the protocol provider bundle. State was " + providerBundle.getState(),
Bundle.ACTIVE != providerBundle.getState() && Bundle.STOPPING != providerBundle.getState());
providerBundle.uninstall();
assertEquals(
"Couldn't stop the protocol provider bundle.",
Bundle.UNINSTALLED,
providerBundle.getState());
// Now reinstall the bundle and restart the provider
providerBundle = GibberishSlickFixture.bc.installBundle(providerBundle.getLocation());
assertEquals(
"Couldn't re-install protocol provider bundle.",
Bundle.INSTALLED,
providerBundle.getState());
AccountManagerUtils.startBundleAndWaitStoredAccountsLoaded(
GibberishSlickFixture.bc, providerBundle, "Gibberish");
assertEquals(
"Couldn't re-start protocol provider bundle.", Bundle.ACTIVE, providerBundle.getState());
// verify that the provider is not reinstalled
ServiceReference[] gibberishProviderRefs = null;
try {
gibberishProviderRefs =
GibberishSlickFixture.bc.getServiceReferences(
ProtocolProviderService.class.getName(),
"(" + ProtocolProviderFactory.PROTOCOL + "=Gibberish)");
} catch (InvalidSyntaxException ex) {
fail("We apparently got our filter wrong " + ex.getMessage());
}
// make sure we didn't retrieve a service
assertTrue(
"A Gibberish Protocol Provider Service was still regged "
+ "as an osgi service after it was explicitly uninstalled",
gibberishProviderRefs == null || gibberishProviderRefs.length == 0);
// and a nasty hack at the end - delete the configuration file so that
// we get a fresh start on next run.
ServiceReference confReference =
GibberishSlickFixture.bc.getServiceReference(ConfigurationService.class.getName());
ConfigurationService configurationService =
(ConfigurationService) GibberishSlickFixture.bc.getService(confReference);
configurationService.purgeStoredConfiguration();
}
/**
* Invoked when an action occurs.
*
* @param e <tt>ActionEvent</tt>.
*/
public void actionPerformed(ActionEvent e) {
Object tmp = skinSelector.getSelectedItem();
if (tmp != null) {
if (tmp instanceof Bundle) {
try {
((Bundle) tmp).uninstall();
} catch (BundleException ex) {
}
}
}
}
public synchronized void cleanup() {
while ((!m_installed.isEmpty())) {
try {
Long id = m_installed.pop();
Bundle bundle = m_framework.getBundleContext().getBundle(id);
bundle.uninstall();
LOG.debug("Uninstalled bundle " + id);
} catch (BundleException e) {
e.printStackTrace();
}
}
}
public void testDefaultRegion() throws BundleException {
digraph.setDefaultRegion(null);
Region systemRegion = digraph.getRegion(regionBundle);
Region pp1Region = digraph.createRegion(PP1);
Bundle pp1Bundle = bundleInstaller.installBundle(PP1, null);
Region result = digraph.getRegion(pp1Bundle);
assertEquals("Wrong region", systemRegion, result);
pp1Bundle.uninstall();
digraph.setDefaultRegion(pp1Region);
pp1Bundle = bundleInstaller.installBundle(PP1, null);
result = digraph.getRegion(pp1Bundle);
assertEquals("Wrong region", pp1Region, result);
digraph.setDefaultRegion(null);
}
public void testPersistenceBug343020() throws BundleException, InvalidSyntaxException {
// get the system region
Region systemRegion = digraph.getRegion(0);
// create a test region
Region testRegion = digraph.createRegion(getName());
RegionFilterBuilder builder = digraph.createRegionFilterBuilder();
// Import the system bundle from the systemRegion
builder.allow(RegionFilter.VISIBLE_BUNDLE_NAMESPACE, "(id=0)");
// import PP1
builder.allow(RegionFilter.VISIBLE_PACKAGE_NAMESPACE, "(" + RegionFilter.VISIBLE_PACKAGE_NAMESPACE + "=pkg1.*)");
digraph.connect(testRegion, builder.build(), systemRegion);
// install CP2
Bundle cp2 = bundleInstaller.installBundle(CP2, testRegion);
bundleInstaller.resolveBundles(new Bundle[] {cp2});
assertEquals("Wrong state for pc1.", Bundle.INSTALLED, cp2.getState());
regionBundle.stop();
// install PP1 there is no region alive
bundleInstaller.installBundle(PP1);
// start region bundle and confirm we can resolve cp2 now
startRegionBundle();
bundleInstaller.refreshPackages(new Bundle[] {cp2});
assertEquals("Wrong state for pc1.", Bundle.RESOLVED, cp2.getState());
// stop region bundle to test uninstalling bundles while stopped
regionBundle.stop();
cp2.uninstall();
startRegionBundle();
testRegion = digraph.getRegion(getName());
assertNotNull("No test region found.", testRegion);
Set<Long> testIds = testRegion.getBundleIds();
assertEquals("Wrong number of test ids.", 0, testIds.size());
}
public void testBundleCollisionDisconnectedRegions() throws BundleException, InvalidSyntaxException {
// get the system region
Region systemRegion = digraph.getRegion(0);
Collection<Bundle> bundles = new HashSet<Bundle>();
// create 4 disconnected test regions and install each bundle into each region
int numRegions = 4;
String regionName = "IsolatedRegion_";
for (int i = 0; i < numRegions; i++) {
Region region = digraph.createRegion(regionName + i);
// Import the system bundle from the systemRegion
digraph.connect(region, digraph.createRegionFilterBuilder().allow(RegionFilter.VISIBLE_BUNDLE_NAMESPACE, "(id=0)").build(), systemRegion);
// must import Boolean services into systemRegion to test
digraph.connect(systemRegion, digraph.createRegionFilterBuilder().allow(RegionFilter.VISIBLE_SERVICE_NAMESPACE, "(objectClass=java.lang.Boolean)").build(), region);
for (String location : ALL) {
Bundle b = bundleInstaller.installBundle(location, region);
bundles.add(b);
}
}
assertEquals("Wrong number of bundles installed", numRegions * ALL.size(), bundles.size());
assertTrue("Could not resolve bundles.", bundleInstaller.resolveBundles(bundles.toArray(new Bundle[bundles.size()])));
// test install of duplicates
for (int i = 0; i < numRegions; i++) {
Region region = digraph.getRegion(regionName + i);
for (String name : ALL) {
String location = bundleInstaller.getBundleLocation(name);
try {
Bundle b = region.installBundle(getName() + "_expectToFail", new URL(location).openStream());
b.uninstall();
fail("Expected a bundle exception on duplicate bundle installation: " + name);
} catch (BundleException e) {
// expected
assertEquals("Wrong exception type.", BundleException.DUPLICATE_BUNDLE_ERROR, e.getType());
} catch (IOException e) {
fail("Failed to open bunldle location: " + e.getMessage());
}
}
}
// test update to a duplicate
for (int i = 0; i < numRegions; i++) {
Region region = digraph.getRegion(regionName + i);
Bundle regionPP1 = region.getBundle(PP1, new Version(1, 0, 0));
String locationSP1 = bundleInstaller.getBundleLocation(SP1);
try {
regionPP1.update(new URL(locationSP1).openStream());
fail("Expected a bundle exception on duplicate bundle update: " + region);
} catch (BundleException e) {
// expected
assertEquals("Wrong exception type.", BundleException.DUPLICATE_BUNDLE_ERROR, e.getType());
} catch (IOException e) {
fail("Failed to open bunldle location: " + e.getMessage());
}
// now uninstall SP1 and try to update PP1 to SP1 again
Bundle regionSP1 = region.getBundle(SP1, new Version(1, 0, 0));
regionSP1.uninstall();
try {
regionPP1.update(new URL(locationSP1).openStream());
} catch (IOException e) {
fail("Failed to open bunldle location: " + e.getMessage());
}
}
}
public void testSingletons() throws BundleException {
Region region1 = digraph.createRegion(getName() + "_1");
Region region2 = digraph.createRegion(getName() + "_2");
// first install into the same region; higher version 2 should resolve
Bundle singleton1 = bundleInstaller.installBundle(SINGLETON1, region1);
Bundle singleton2 = bundleInstaller.installBundle(SINGLETON2, region1);
assertFalse(bundleInstaller.resolveBundles(new Bundle[] {singleton1, singleton2}));
assertEquals("singleton1", Bundle.INSTALLED, singleton1.getState());
assertEquals("singleton2", Bundle.RESOLVED, singleton2.getState());
// now install into different regions; both 1 and 2 should resolve
singleton2.uninstall();
singleton2 = bundleInstaller.installBundle(SINGLETON2, region2);
assertTrue(bundleInstaller.resolveBundles(new Bundle[] {singleton1, singleton2}));
assertEquals("singleton1", Bundle.RESOLVED, singleton1.getState());
assertEquals("singleton2", Bundle.RESOLVED, singleton2.getState());
ServiceRegistration<ResolverHookFactory> disableHook = disableAllResolves();
try {
// now refresh to get us to an unresolved state again
bundleInstaller.refreshPackages(new Bundle[] {singleton1, singleton2});
// connect region2 -> region1
region2.connectRegion(region1, digraph.createRegionFilterBuilder().allowAll(RegionFilter.VISIBLE_BUNDLE_NAMESPACE).build());
// enable resolving again
disableHook.unregister();
disableHook = null;
assertFalse(bundleInstaller.resolveBundles(new Bundle[] {singleton1, singleton2}));
assertTrue("One and only singleton bundle should be resolved", (singleton1.getState() == Bundle.RESOLVED) ^ (singleton2.getState() == Bundle.RESOLVED));
singleton2.uninstall();
disableHook = disableAllResolves();
// now refresh to get us to an unresolved state again
bundleInstaller.refreshPackages(new Bundle[] {singleton1, singleton2});
// enable resolving again
disableHook.unregister();
disableHook = null;
// make sure singleton1 is resolved first
assertTrue(bundleInstaller.resolveBundles(new Bundle[] {singleton1}));
assertEquals("singleton1", Bundle.RESOLVED, singleton1.getState());
singleton2 = bundleInstaller.installBundle(SINGLETON2, region2);
assertFalse(bundleInstaller.resolveBundles(new Bundle[] {singleton2}));
assertEquals("singleton2", Bundle.INSTALLED, singleton2.getState());
singleton1.uninstall();
disableHook = disableAllResolves();
// now refresh to get us to an unresolved state again
bundleInstaller.refreshPackages(new Bundle[] {singleton1, singleton2});
// enable resolving again
disableHook.unregister();
disableHook = null;
// make sure singleton2 is resolved first
assertTrue(bundleInstaller.resolveBundles(new Bundle[] {singleton2}));
assertEquals("singleton2", Bundle.RESOLVED, singleton2.getState());
singleton1 = bundleInstaller.installBundle(SINGLETON1, region1);
assertFalse(bundleInstaller.resolveBundles(new Bundle[] {singleton1}));
assertEquals("singleton1", Bundle.INSTALLED, singleton1.getState());
} finally {
if (disableHook != null)
disableHook.unregister();
}
}
/**
* Stops and removes the tested bundle, verifies that it has unregistered its provider, then
* reloads and restarts the bundle and verifies that the protocol provider is reRegistered in the
* bundle context.
*
* @throws java.lang.Exception if an exception occurs during testing.
*/
public void testInstallationPersistency() throws Exception {
Bundle providerBundle = fixture.findProtocolProviderBundle(fixture.provider1);
// set the global providerBundle reference that we will be using
// in the last series of tests (Account uninstallation persistency)
SipSlickFixture.providerBundle = providerBundle;
assertNotNull("Couldn't find a bundle for the tested provider", providerBundle);
providerBundle.stop();
assertTrue(
"Couldn't stop the protocol provider bundle. State was " + providerBundle.getState(),
Bundle.ACTIVE != providerBundle.getState() && Bundle.STOPPING != providerBundle.getState());
providerBundle.uninstall();
assertEquals(
"Couldn't stop the protocol provider bundle.",
Bundle.UNINSTALLED,
providerBundle.getState());
// verify that the provider is no longer available
ServiceReference[] sipProviderRefs = null;
try {
sipProviderRefs =
fixture.bc.getServiceReferences(
ProtocolProviderService.class.getName(),
"(&"
+ "("
+ ProtocolProviderFactory.PROTOCOL
+ "="
+ ProtocolNames.SIP
+ ")"
+ "("
+ ProtocolProviderFactory.USER_ID
+ "="
+ fixture.userID1
+ ")"
+ ")");
} catch (InvalidSyntaxException ex) {
fail("We apparently got our filter wrong: " + ex.getMessage());
}
// make sure we didn't see a service
assertTrue(
"A Protocol Provider Service was still regged as an osgi service "
+ "for SIP URI:"
+ fixture.userID1
+ "After it was explicitly uninstalled",
sipProviderRefs == null || sipProviderRefs.length == 0);
// verify that the provider factory knows that we have uninstalled the
// provider.
assertTrue(
"The SIP provider factory kept a reference to the provider we just "
+ "uninstalled (uri="
+ fixture.userID1
+ ")",
fixture.providerFactory.getRegisteredAccounts().isEmpty()
&& fixture.providerFactory.getProviderForAccount(fixture.provider1.getAccountID())
== null);
// Now reinstall the bundle
providerBundle = fixture.bc.installBundle(providerBundle.getLocation());
// set the global providerBundle reference that we will be using
// in the last series of tests (Account uninstallation persistency)
SipSlickFixture.providerBundle = providerBundle;
assertEquals(
"Couldn't re-install protocol provider bundle.",
Bundle.INSTALLED,
providerBundle.getState());
AccountManagerUtils.startBundleAndWaitStoredAccountsLoaded(
fixture.bc, providerBundle, ProtocolNames.SIP);
assertEquals(
"Couldn't re-start protocol provider bundle.", Bundle.ACTIVE, providerBundle.getState());
// Make sure that the provider is there again.
// verify that the provider is no longer available
try {
sipProviderRefs =
fixture.bc.getServiceReferences(
ProtocolProviderService.class.getName(),
"(&"
+ "("
+ ProtocolProviderFactory.PROTOCOL
+ "="
+ ProtocolNames.SIP
+ ")"
+ "("
+ ProtocolProviderFactory.USER_ID
+ "="
+ fixture.userID1
+ ")"
+ ")");
} catch (InvalidSyntaxException ex) {
fail("We apparently got our filter wrong " + ex.getMessage());
}
// make sure we didn't see a service
assertTrue(
"A Protocol Provider Service was not restored after being"
+ "reinstalled. SIP URI:"
+ fixture.userID1,
sipProviderRefs != null && sipProviderRefs.length > 0);
ServiceReference[] sipFactoryRefs = null;
try {
sipFactoryRefs =
fixture.bc.getServiceReferences(
ProtocolProviderFactory.class.getName(),
"(" + ProtocolProviderFactory.PROTOCOL + "=" + ProtocolNames.SIP + ")");
} catch (InvalidSyntaxException ex) {
fail("We apparently got our filter wrong " + ex.getMessage());
}
// we're the ones who've reinstalled the factory so it's our
// responsibility to update the fixture.
fixture.providerFactory = (ProtocolProviderFactory) fixture.bc.getService(sipFactoryRefs[0]);
fixture.provider1 = (ProtocolProviderService) fixture.bc.getService(sipProviderRefs[0]);
// verify that the provider is also restored in the provider factory
// itself
assertTrue(
"The SIP provider did not restore its own reference to the provider "
+ "that we just reinstalled (URI="
+ fixture.userID1
+ ")",
!fixture.providerFactory.getRegisteredAccounts().isEmpty()
&& fixture.providerFactory.getProviderForAccount(fixture.provider1.getAccountID())
!= null);
}