/******************************************************************************* | |
* Copyright (c) 2010 Oracle. | |
* All rights reserved. This program and the accompanying materials | |
* are made available under the terms of the Eclipse Public License v1.0 | |
* and Apache License v2.0 which accompanies this distribution. | |
* The Eclipse Public License is available at | |
* http://www.eclipse.org/legal/epl-v10.html | |
* and the Apache License v2.0 is available at | |
* http://www.opensource.org/licenses/apache2.0.php. | |
* You may elect to redistribute this code under either of these licenses. | |
* | |
* Contributors: | |
* Hal Hildebrand - Initial JMX support | |
* Christopher Frost - 5.0 spec changes | |
******************************************************************************/ | |
package org.eclipse.gemini.management.framework; | |
import java.io.IOException; | |
import java.io.InputStream; | |
import java.net.URL; | |
import java.util.ArrayList; | |
import java.util.Arrays; | |
import java.util.Collection; | |
import java.util.Collections; | |
import java.util.HashSet; | |
import java.util.List; | |
import javax.management.openmbean.CompositeData; | |
import org.eclipse.gemini.management.framework.internal.BundleBatchActionResult; | |
import org.eclipse.gemini.management.framework.internal.BundleBatchInstallResult; | |
import org.eclipse.gemini.management.framework.internal.BundleBatchResolveResult; | |
import org.osgi.framework.Bundle; | |
import org.osgi.framework.BundleContext; | |
import org.osgi.framework.BundleException; | |
import org.osgi.framework.FrameworkEvent; | |
import org.osgi.framework.FrameworkListener; | |
import org.osgi.framework.startlevel.BundleStartLevel; | |
import org.osgi.framework.startlevel.FrameworkStartLevel; | |
import org.osgi.framework.wiring.FrameworkWiring; | |
import org.osgi.jmx.framework.FrameworkMBean; | |
/** | |
* {@inheritDoc} | |
*/ | |
public final class Framework implements FrameworkMBean { | |
private BundleContext bundleContext; | |
private FrameworkStartLevel frameworkStartLevel; | |
private FrameworkWiring frameworkWiring; | |
public Framework(BundleContext bc) { | |
this.bundleContext = bc; | |
this.frameworkStartLevel = bc.getBundle(0).adapt(FrameworkStartLevel.class); | |
this.frameworkWiring = bc.getBundle(0).adapt(FrameworkWiring.class); | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public int getFrameworkStartLevel() throws IOException { | |
return frameworkStartLevel.getStartLevel(); | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public int getInitialBundleStartLevel() throws IOException { | |
return frameworkStartLevel.getInitialBundleStartLevel(); | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public long installBundle(String location) throws IOException { | |
try { | |
return bundleContext.installBundle(location).getBundleId(); | |
} catch (Throwable e) { | |
throw new IOException("Unable to install bundle: " + e); | |
} | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public long installBundleFromURL(String location, String url) throws IOException { | |
InputStream is = null; | |
try { | |
is = new URL(url).openStream(); | |
return bundleContext.installBundle(location, is).getBundleId(); | |
} catch (Throwable e) { | |
throw new IOException("Unable to install bundle: " + e); | |
} finally { | |
if (is != null) { | |
try { | |
is.close(); | |
} catch (IOException e) { | |
} | |
} | |
} | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public CompositeData installBundles(String[] locations) throws IOException { | |
if (locations == null) { | |
throw new IOException("locations must not be null"); | |
} | |
Long ids[] = new Long[locations.length]; | |
for (int i = 0; i < locations.length; i++) { | |
try { | |
ids[i] = bundleContext.installBundle(locations[i]).getBundleId(); | |
} catch (Throwable e) { | |
Long[] completed = new Long[i]; | |
System.arraycopy(ids, 0, completed, 0, completed.length); | |
String[] remaining = new String[locations.length - i - 1]; | |
System.arraycopy(locations, i + 1, remaining, 0, remaining.length); | |
return new BundleBatchInstallResult(e.toString(), completed, locations[i], remaining).asCompositeData(); | |
} | |
} | |
return new BundleBatchInstallResult(ids).asCompositeData(); | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public CompositeData installBundlesFromURL(String[] locations, String[] urls) throws IOException { | |
if (locations == null) { | |
throw new IOException("locations must not be null"); | |
} | |
if (urls == null) { | |
throw new IOException("urls must not be null"); | |
} | |
Long ids[] = new Long[locations.length]; | |
for (int i = 0; i < locations.length; i++) { | |
InputStream is = null; | |
try { | |
is = new URL(urls[i]).openStream(); | |
ids[i] = bundleContext.installBundle(locations[i], is).getBundleId(); | |
} catch (Throwable e) { | |
Long[] completed = new Long[i]; | |
System.arraycopy(ids, 0, completed, 0, completed.length); | |
String[] remaining = new String[locations.length - i - 1]; | |
System.arraycopy(locations, i + 1, remaining, 0, remaining.length); | |
return new BundleBatchInstallResult(e.toString(), completed, locations[i], remaining).asCompositeData(); | |
} finally { | |
if (is != null) { | |
try { | |
is.close(); | |
} catch (IOException e) { | |
} | |
} | |
} | |
} | |
return new BundleBatchInstallResult(ids).asCompositeData(); | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public void refreshBundle(long bundleIdentifier) throws IOException { | |
Collection<Bundle> bundles = Arrays.asList(bundle(bundleIdentifier)); | |
this.frameworkWiring.refreshBundles(bundles); | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public void refreshBundles(long[] bundleIdentifiers) throws IOException { | |
List<Bundle> bundles = new ArrayList<Bundle>(); | |
if (bundleIdentifiers != null) { | |
for (int i = 0; i < bundleIdentifiers.length; i++) { | |
try { | |
bundles.add(bundle(bundleIdentifiers[i])); | |
} catch (Throwable e) { | |
IOException iox = new IOException("Unable to refresh packages"); | |
iox.initCause(e); | |
throw iox; | |
} | |
} | |
} | |
try { | |
this.frameworkWiring.refreshBundles(bundles); | |
} catch (Throwable e) { | |
IOException iox = new IOException("Unable to refresh packages"); | |
iox.initCause(e); | |
throw iox; | |
} | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public boolean resolveBundle(long bundleIdentifier) throws IOException { | |
Collection<Bundle> bundles = Arrays.asList(bundle(bundleIdentifier)); | |
return this.frameworkWiring.resolveBundles(bundles); | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public boolean resolveBundles(long[] bundleIdentifiers) throws IOException { | |
List<Bundle> bundles = new ArrayList<Bundle>(); | |
if (bundleIdentifiers != null) { | |
for (int i = 0; i < bundleIdentifiers.length; i++) { | |
bundles.add(bundle(bundleIdentifiers[i])); | |
} | |
} | |
return this.frameworkWiring.resolveBundles(bundles); | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public void restartFramework() throws IOException { | |
try { | |
bundle(0).update(); | |
} catch (BundleException e) { | |
throw new IOException("Unable to restart framework: " + e); | |
} | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public void setBundleStartLevel(long bundleIdentifier, int newlevel) throws IOException { | |
try { | |
bundle(bundleIdentifier).adapt(BundleStartLevel.class).setStartLevel(newlevel); | |
} catch (Throwable e) { | |
IOException iox = new IOException("Cannot set start level: " + e); | |
iox.initCause(e); | |
throw iox; | |
} | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public CompositeData setBundleStartLevels(long[] bundleIdentifiers, int[] newlevels) throws IOException { | |
if (bundleIdentifiers == null) { | |
throw new IOException("Bundle identifiers must not be null"); | |
} | |
if (newlevels == null) { | |
throw new IOException("new start levels must not be null"); | |
} | |
for (int i = 0; i < bundleIdentifiers.length; i++) { | |
try { | |
bundle(bundleIdentifiers[i]).adapt(BundleStartLevel.class).setStartLevel(newlevels[i]); | |
} catch (Throwable e) { | |
return this.handleUpdateException(bundleIdentifiers, i, e); | |
} | |
} | |
return new BundleBatchActionResult().asCompositeData(); | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public void setFrameworkStartLevel(int newlevel) throws IOException { | |
try { | |
this.frameworkStartLevel.setStartLevel(newlevel); | |
} catch (Throwable e) { | |
IOException iox = new IOException("Cannot set start level: " + e); | |
iox.initCause(e); | |
throw iox; | |
} | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public void setInitialBundleStartLevel(int newlevel) throws IOException { | |
try { | |
this.frameworkStartLevel.setInitialBundleStartLevel(newlevel); | |
} catch (Throwable e) { | |
IOException iox = new IOException("Cannot set start level: " + e); | |
iox.initCause(e); | |
throw iox; | |
} | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public void shutdownFramework() throws IOException { | |
try { | |
bundle(0).stop(); | |
} catch (Throwable be) { | |
throw new IOException("Shutting down not implemented in this framework: " + be); | |
} | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public void startBundle(long bundleIdentifier) throws IOException { | |
try { | |
bundle(bundleIdentifier).start(); | |
} catch (Throwable e) { | |
throw new IOException("Unable to start bundle: " + e); | |
} | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public CompositeData startBundles(long[] bundleIdentifiers) throws IOException { | |
if (bundleIdentifiers == null) { | |
throw new IOException("Bundle identifiers must not be null"); | |
} | |
for (int i = 0; i < bundleIdentifiers.length; i++) { | |
try { | |
bundle(bundleIdentifiers[i]).start(); | |
} catch (Throwable e) { | |
return this.handleUpdateException(bundleIdentifiers, i, e); | |
} | |
} | |
return new BundleBatchActionResult().asCompositeData(); | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public void stopBundle(long bundleIdentifier) throws IOException { | |
try { | |
bundle(bundleIdentifier).stop(); | |
} catch (Throwable e) { | |
throw new IOException("Unable to stop bundle: " + e); | |
} | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public CompositeData stopBundles(long[] bundleIdentifiers) throws IOException { | |
if (bundleIdentifiers == null) { | |
throw new IOException("Bundle identifiers must not be null"); | |
} | |
for (int i = 0; i < bundleIdentifiers.length; i++) { | |
try { | |
bundle(bundleIdentifiers[i]).stop(); | |
} catch (Throwable e) { | |
return this.handleUpdateException(bundleIdentifiers, i, e); | |
} | |
} | |
return new BundleBatchActionResult().asCompositeData(); | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public void uninstallBundle(long bundleIdentifier) throws IOException { | |
try { | |
bundle(bundleIdentifier).uninstall(); | |
} catch (BundleException e) { | |
throw new IOException("Unable to uninstall bundle: " + e); | |
} | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public CompositeData uninstallBundles(long[] bundleIdentifiers) throws IOException { | |
if (bundleIdentifiers == null) { | |
throw new IOException("Bundle identifiers must not be null"); | |
} | |
for (int i = 0; i < bundleIdentifiers.length; i++) { | |
try { | |
bundle(bundleIdentifiers[i]).uninstall(); | |
} catch (Throwable e) { | |
return this.handleUpdateException(bundleIdentifiers, i, e); | |
} | |
} | |
return new BundleBatchActionResult().asCompositeData(); | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public void updateBundle(long bundleIdentifier) throws IOException { | |
try { | |
bundle(bundleIdentifier).update(); | |
} catch (Throwable e) { | |
throw new IOException("Unable to update bundle: " + e); | |
} | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public void updateBundleFromURL(long bundleIdentifier, String url) throws IOException { | |
InputStream is = null; | |
try { | |
is = new URL(url).openStream(); | |
bundle(bundleIdentifier).update(is); | |
} catch (Throwable e) { | |
throw new IOException("Unable to update bundle: " + e); | |
} finally { | |
if (is != null) { | |
try { | |
is.close(); | |
} catch (IOException e) { | |
} | |
} | |
} | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public CompositeData updateBundles(long[] bundleIdentifiers) throws IOException { | |
if (bundleIdentifiers == null) { | |
throw new IOException("Bundle identifiers must not be null"); | |
} | |
for (int i = 0; i < bundleIdentifiers.length; i++) { | |
try { | |
bundle(bundleIdentifiers[i]).update(); | |
} catch (Throwable e) { | |
return this.handleUpdateException(bundleIdentifiers, i, e); | |
} | |
} | |
return new BundleBatchActionResult().asCompositeData(); | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public CompositeData updateBundlesFromURL(long[] bundleIdentifiers, String[] urls) throws IOException { | |
if (bundleIdentifiers == null) { | |
throw new IOException("Bundle identifiers must not be null"); | |
} | |
for (int i = 0; i < bundleIdentifiers.length; i++) { | |
InputStream is = null; | |
try { | |
is = new URL(urls[i]).openStream(); | |
bundle(bundleIdentifiers[i]).update(is); | |
} catch (Throwable e) { | |
return this.handleUpdateException(bundleIdentifiers, i, e); | |
} finally { | |
if (is != null) { | |
try { | |
is.close(); | |
} catch (IOException e) { | |
} | |
} | |
} | |
} | |
return new BundleBatchActionResult().asCompositeData(); | |
} | |
private CompositeData handleUpdateException(long[] bundleIdentifiers, int currentPostion, Throwable e){ | |
Long[] completed = this.convertToNonPrimativeArray(bundleIdentifiers, currentPostion); | |
Long[] remaining = new Long[bundleIdentifiers.length - currentPostion - 1]; | |
for (int j = 0; j < remaining.length; j++) { | |
remaining[j] = bundleIdentifiers[currentPostion + 1 + j]; | |
} | |
return new BundleBatchActionResult(e.toString(), completed, bundleIdentifiers[currentPostion], remaining).asCompositeData(); | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public void updateFramework() throws IOException { | |
try { | |
Bundle b = bundle(0); | |
if(b != null){ | |
b.update(); | |
} | |
} catch (BundleException be) { | |
throw new IOException("Update of the framework is not implemented: " + be); | |
} | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public long[] getDependencyClosure(long[] bundleIdentifiers) throws IOException { | |
Collection<Bundle> bundles = this.frameworkWiring.getDependencyClosure(this.getBundles(bundleIdentifiers)); | |
long[] result = new long[bundles.size()]; | |
int i = 0; | |
for (Bundle bundle : bundles) { | |
result[i++] = bundle.getBundleId(); | |
} | |
return result; | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public String getProperty(String key) throws IOException { | |
return this.bundleContext.getProperty(key); | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public long[] getRemovalPendingBundles() throws IOException { | |
Collection<Bundle> removalPendingBundles = this.frameworkWiring.getRemovalPendingBundles(); | |
long[] result = new long[removalPendingBundles.size()]; | |
int i = 0; | |
for (Bundle bundle : removalPendingBundles) { | |
result[i++] = bundle.getBundleId(); | |
} | |
return result; | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public boolean refreshBundleAndWait(long bundleIdentifier) throws IOException { | |
Collection<Bundle> bundles = new HashSet<Bundle>(); | |
Bundle bundle = this.bundle(bundleIdentifier); | |
bundles.add(bundle); | |
StandardFrameworkListener standardFrameworkListener = new StandardFrameworkListener(); | |
this.frameworkWiring.refreshBundles(bundles, standardFrameworkListener); | |
standardFrameworkListener.getResult(); | |
return bundle.getState() >= Bundle.RESOLVED; | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public CompositeData refreshBundlesAndWait(long[] bundleIdentifiers) throws IOException { | |
Collection<Bundle> bundles; | |
StandardFrameworkListener standardFrameworkListener = new StandardFrameworkListener(); | |
if(bundleIdentifiers == null){ | |
bundles = Arrays.asList(this.bundleContext.getBundles()); | |
this.frameworkWiring.refreshBundles(null, standardFrameworkListener); | |
} else { | |
bundles = this.getBundles(bundleIdentifiers); | |
this.frameworkWiring.refreshBundles(bundles, standardFrameworkListener); | |
} | |
boolean operationResult = standardFrameworkListener.getResult(); | |
ArrayList<Long> completedBundles = new ArrayList<Long>(); | |
boolean result = true; | |
for (Bundle bundle : bundles) { | |
if(bundle.getState() >= Bundle.RESOLVED){ | |
completedBundles.add(bundle.getBundleId()); | |
}else{ | |
result = false; | |
} | |
} | |
if(!operationResult){ | |
result = false; | |
} | |
return new BundleBatchResolveResult(completedBundles.toArray(new Long[completedBundles.size()]), result).asCompositeData(); | |
} | |
/** | |
* {@inheritDoc} | |
*/ | |
public CompositeData resolve(long[] bundleIdentifiers) throws IOException { | |
Collection<Bundle> bundles; | |
if(bundleIdentifiers == null){ | |
bundles = new HashSet<Bundle>(); | |
Bundle[] allBundles = this.bundleContext.getBundles(); | |
for (Bundle bundle : allBundles) { | |
if(bundle.getState() < Bundle.RESOLVED){ | |
bundles.add(bundle); | |
} | |
} | |
}else{ | |
bundles = this.getBundles(bundleIdentifiers); | |
} | |
boolean operationResult = this.frameworkWiring.resolveBundles(bundles); | |
boolean result = true; | |
ArrayList<Long> completedBundles = new ArrayList<Long>(); | |
for (Bundle bundle : bundles) { | |
if(bundle.getState() >= Bundle.RESOLVED){ | |
completedBundles.add(bundle.getBundleId()); | |
}else{ | |
result = false; | |
} | |
} | |
if(!operationResult){ | |
result = false; | |
} | |
return new BundleBatchResolveResult(completedBundles.toArray(new Long[completedBundles.size()]), result).asCompositeData(); | |
} | |
private Collection<Bundle> getBundles(long[] bundleIdentifiers) throws IOException{ | |
Collection<Bundle> bundles = new HashSet<Bundle>(); | |
for (int i = 0; i < bundleIdentifiers.length; i++) { | |
bundles.add(this.bundle(bundleIdentifiers[i])); | |
} | |
return bundles; | |
} | |
private Bundle bundle(long bundleIdentifier) throws IOException { | |
Bundle b; | |
try{ | |
b = bundleContext.getBundle(bundleIdentifier); | |
} catch(IllegalStateException e){ | |
return null; | |
} | |
if (b == null) { | |
throw new IOException("Bundle <" + bundleIdentifier + "> does not exist"); | |
} | |
return b; | |
} | |
private Long[] convertToNonPrimativeArray(long[] src, int length){ | |
if(src == null || src.length == 0){ | |
return new Long[0]; | |
} | |
Long[] dest = new Long[length]; | |
for (int i = 0; i < length; i++) { | |
dest[i] = src[i]; | |
} | |
return dest; | |
} | |
/** | |
* | |
* @author Christopher Frost | |
* | |
* This class is thread safe and will only block until a framework event is received. | |
* | |
*/ | |
private static class StandardFrameworkListener implements FrameworkListener { | |
private final Object monitor = new Object(); | |
private volatile boolean sucsess = false; | |
private volatile boolean completed = false; | |
@Override | |
public void frameworkEvent(FrameworkEvent event) { | |
if(FrameworkEvent.PACKAGES_REFRESHED == event.getType()){ | |
this.sucsess = true; | |
} else if(FrameworkEvent.ERROR == event.getType()){ | |
this.sucsess = false; | |
} | |
this.completed = true; | |
this.monitor.notifyAll(); | |
} | |
public boolean getResult(){ | |
synchronized (monitor) { | |
while(!this.completed){ | |
try { | |
this.monitor.wait(5000); //Just to make sure as it is possible that we could get to wait after notify has been called | |
} catch (InterruptedException e) { | |
// no-op | |
} | |
} | |
return this.sucsess; | |
} | |
} | |
} | |
} |