--- /dev/null
+package org.argeo.slc.osgiboot;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.StringTokenizer;
+
+import org.argeo.slc.osgiboot.internal.springutil.AntPathMatcher;
+import org.argeo.slc.osgiboot.internal.springutil.PathMatcher;
+import org.argeo.slc.osgiboot.internal.springutil.SystemPropertyUtils;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.BundleContext;
+import org.osgi.framework.BundleException;
+import org.osgi.framework.Constants;
+
+public class OsgiBoot {
+ public final static String PROP_SLC_OSGI_START = "slc.osgi.start";
+ public final static String PROP_SLC_OSGI_BUNDLES = "slc.osgi.bundles";
+ public final static String PROP_SLC_OSGI_LOCATIONS = "slc.osgi.locations";
+ public final static String PROP_SLC_OSGI_BASE_URL = "slc.osgi.baseUrl";
+ public final static String PROP_SLC_OSGI_MODULES_URL = "slc.osgi.modulesUrl";
+
+ public final static String PROP_SLC_OSGIBOOT_DEBUG = "slc.osgiboot.debug";
+ public final static String PROP_SLC_OSGIBOOT_DEFAULT_TIMEOUT = "slc.osgiboot.defaultTimeout";
+ public final static String PROP_SLC_OSGIBOOT_MODULES_URL_SEPARATOR = "slc.osgiboot.modulesUrlSeparator";
+ public final static String PROP_SLC_OSGIBOOT_SYSTEM_PROPERTIES_FILE = "slc.osgiboot.systemPropertiesFile";
+
+ public final static String DEFAULT_BASE_URL = "reference:file:";
+ public final static String EXCLUDES_SVN_PATTERN = "**/.svn/**";
+
+ private boolean debug = Boolean.valueOf(
+ System.getProperty(PROP_SLC_OSGIBOOT_DEBUG, "false"))
+ .booleanValue();
+ /** Default is 10s (set in constructor) */
+ private long defaultTimeout;
+
+ private boolean excludeSvn = true;
+ /** Default is ',' (set in constructor) */
+ private String modulesUrlSeparator = ",";
+
+ private final BundleContext bundleContext;
+
+ public OsgiBoot(BundleContext bundleContext) {
+ this.bundleContext = bundleContext;
+ defaultTimeout = Long.parseLong(getProperty(
+ PROP_SLC_OSGIBOOT_DEFAULT_TIMEOUT, "10000"));
+ modulesUrlSeparator = getProperty(
+ PROP_SLC_OSGIBOOT_MODULES_URL_SEPARATOR, ",");
+ }
+
+ public void bootstrap() {
+ info("SLC OSGi bootstrap starting...");
+ installUrls(getBundlesUrls());
+ installUrls(getLocationsUrls());
+ installUrls(getModulesUrls());
+ startBundles();
+ info("SLC OSGi bootstrap completed");
+ }
+
+ public void installUrls(List urls) {
+ Map installedBundles = getInstalledBundles();
+ for (int i = 0; i < urls.size(); i++) {
+ String url = (String) urls.get(i);
+ try {
+ if (installedBundles.containsKey(url)) {
+ Bundle bundle = (Bundle) installedBundles.get(url);
+ // bundle.update();
+ if (debug)
+ debug("Bundle " + bundle.getSymbolicName()
+ + " already installed from " + url);
+ } else {
+ Bundle bundle = bundleContext.installBundle(url);
+ if (debug)
+ debug("Installed bundle " + bundle.getSymbolicName()
+ + " from " + url);
+ }
+ } catch (BundleException e) {
+ warn("Could not install bundle from " + url + ": "
+ + e.getMessage());
+ if (debug)
+ e.printStackTrace();
+ }
+ }
+
+ }
+
+ public void installOrUpdateUrls(Map urls) {
+ Map installedBundles = getBundles();
+
+ for (Iterator modules = urls.keySet().iterator(); modules.hasNext();) {
+ String moduleName = (String) modules.next();
+ String urlStr = (String) urls.get(moduleName);
+ if (installedBundles.containsKey(moduleName)) {
+ Bundle bundle = (Bundle) installedBundles.get(moduleName);
+ InputStream in;
+ try {
+ URL url = new URL(urlStr);
+ in = url.openStream();
+ bundle.update(in);
+ info("Updated bundle " + moduleName + " from " + urlStr);
+ } catch (Exception e) {
+ throw new RuntimeException("Cannot update " + moduleName
+ + " from " + urlStr);
+ }
+ if (in != null)
+ try {
+ in.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ } else {
+ try {
+ Bundle bundle = bundleContext.installBundle(urlStr);
+ if (debug)
+ debug("Installed bundle " + bundle.getSymbolicName()
+ + " from " + urlStr);
+ } catch (BundleException e) {
+ warn("Could not install bundle from " + urlStr + ": "
+ + e.getMessage());
+ }
+ }
+ }
+
+ }
+
+ public void startBundles() {
+ String bundlesToStart = getProperty(PROP_SLC_OSGI_START);
+ startBundles(bundlesToStart);
+ }
+
+ public void startBundles(String bundlesToStartStr) {
+ if (bundlesToStartStr == null)
+ return;
+
+ StringTokenizer st = new StringTokenizer(bundlesToStartStr, ",");
+ List bundlesToStart = new ArrayList();
+ while (st.hasMoreTokens()) {
+ String name = st.nextToken().trim();
+ bundlesToStart.add(name);
+ }
+ startBundles(bundlesToStart);
+ }
+
+ public void startBundles(List bundlesToStart) {
+ if (bundlesToStart.size() == 0)
+ return;
+
+ // used to log the bundles not found
+ List notFoundBundles = new ArrayList(bundlesToStart);
+
+ Bundle[] bundles = bundleContext.getBundles();
+ long startBegin = System.currentTimeMillis();
+ for (int i = 0; i < bundles.length; i++) {
+ Bundle bundle = bundles[i];
+ String symbolicName = bundle.getSymbolicName();
+ if (bundlesToStart.contains(symbolicName))
+ try {
+ try {
+ bundle.start();
+ } catch (Exception e) {
+ warn("Start of bundle " + symbolicName
+ + " failed because of " + e
+ + ", maybe bundle is not yet resolved,"
+ + " waiting and trying again.");
+ waitForBundleResolvedOrActive(startBegin, bundle);
+ bundle.start();
+ }
+ notFoundBundles.remove(symbolicName);
+ } catch (Exception e) {
+ warn("Bundle " + symbolicName + " cannot be started: "
+ + e.getMessage());
+ if (debug)
+ e.printStackTrace();
+ // was found even if start failed
+ notFoundBundles.remove(symbolicName);
+ }
+ }
+
+ for (int i = 0; i < notFoundBundles.size(); i++)
+ warn("Bundle " + notFoundBundles.get(i)
+ + " not started because it was not found.");
+ }
+
+ protected void waitForBundleResolvedOrActive(long startBegin, Bundle bundle)
+ throws Exception {
+ int originalState = bundle.getState();
+ if ((originalState == Bundle.RESOLVED)
+ || (originalState == Bundle.ACTIVE))
+ return;
+
+ String originalStateStr = stateAsString(originalState);
+
+ int currentState = bundle.getState();
+ while (!(currentState == Bundle.RESOLVED || currentState == Bundle.ACTIVE)) {
+ long now = System.currentTimeMillis();
+ if ((now - startBegin) > defaultTimeout)
+ throw new Exception("Bundle " + bundle.getSymbolicName()
+ + " was not RESOLVED or ACTIVE after "
+ + (now - startBegin) + "ms (originalState="
+ + originalStateStr + ", currentState="
+ + stateAsString(currentState) + ")");
+
+ try {
+ Thread.sleep(100l);
+ } catch (InterruptedException e) {
+ // silent
+ }
+ currentState = bundle.getState();
+ }
+ }
+
+ public static String stateAsString(int state) {
+ switch (state) {
+ case Bundle.UNINSTALLED:
+ return "UNINSTALLED";
+ case Bundle.INSTALLED:
+ return "INSTALLED";
+ case Bundle.RESOLVED:
+ return "RESOLVED";
+ case Bundle.STARTING:
+ return "STARTING";
+ case Bundle.ACTIVE:
+ return "ACTIVE";
+ case Bundle.STOPPING:
+ return "STOPPING";
+ default:
+ return Integer.toString(state);
+ }
+ }
+
+ /** Key is location */
+ public Map getInstalledBundles() {
+ Map installedBundles = new HashMap();
+
+ Bundle[] bundles = bundleContext.getBundles();
+ for (int i = 0; i < bundles.length; i++) {
+ installedBundles.put(bundles[i].getLocation(), bundles[i]);
+ }
+ return installedBundles;
+ }
+
+ /** Key is symbolic name */
+ public Map getBundles() {
+ Map namedBundles = new HashMap();
+ Bundle[] bundles = bundleContext.getBundles();
+ for (int i = 0; i < bundles.length; i++) {
+ namedBundles.put(bundles[i].getSymbolicName(), bundles[i]);
+ }
+ return namedBundles;
+ }
+
+ public List getLocationsUrls() {
+ String baseUrl = getProperty(PROP_SLC_OSGI_BASE_URL, DEFAULT_BASE_URL);
+ String bundleLocations = getProperty(PROP_SLC_OSGI_LOCATIONS);
+ return getLocationsUrls(baseUrl, bundleLocations);
+ }
+
+ public List getModulesUrls() {
+ List urls = new ArrayList();
+ String modulesUrlStr = getProperty(PROP_SLC_OSGI_MODULES_URL);
+ if (modulesUrlStr == null)
+ return urls;
+
+ String baseUrl = getProperty(PROP_SLC_OSGI_BASE_URL);
+
+ Map installedBundles = getBundles();
+
+ BufferedReader reader = null;
+ try {
+ URL modulesUrl = new URL(modulesUrlStr);
+ reader = new BufferedReader(new InputStreamReader(modulesUrl
+ .openStream()));
+ String line = null;
+ while ((line = reader.readLine()) != null) {
+ StringTokenizer st = new StringTokenizer(line,
+ modulesUrlSeparator);
+ String moduleName = st.nextToken();
+ String moduleVersion = st.nextToken();
+ String url = st.nextToken();
+ if (baseUrl != null)
+ url = baseUrl + url;
+
+ if (installedBundles.containsKey(moduleName)) {
+ Bundle bundle = (Bundle) installedBundles.get(moduleName);
+ String bundleVersion = bundle.getHeaders().get(
+ Constants.BUNDLE_VERSION).toString();
+ int comp = compareVersions(bundleVersion, moduleVersion);
+ if (comp > 0) {
+ warn("Installed version " + bundleVersion
+ + " of bundle " + moduleName
+ + " is newer than provided version "
+ + moduleVersion);
+ } else if (comp < 0) {
+ urls.add(url);
+ info("Updated bundle " + moduleName + " with version "
+ + moduleVersion + " (old version was "
+ + bundleVersion + ")");
+ } else {
+ // do nothing
+ }
+ } else {
+ urls.add(url);
+ }
+ }
+ } catch (Exception e1) {
+ throw new RuntimeException("Cannot read url " + modulesUrlStr, e1);
+ } finally {
+ if (reader != null)
+ try {
+ reader.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ }
+ }
+ return urls;
+ }
+
+ /**
+ * @return ==0: versions are identical, <0: tested version is newer, >0:
+ * currentVersion is newer.
+ */
+ protected int compareVersions(String currentVersion, String testedVersion) {
+ List cToks = new ArrayList();
+ StringTokenizer cSt = new StringTokenizer(currentVersion, ".");
+ while (cSt.hasMoreTokens())
+ cToks.add(cSt.nextToken());
+ List tToks = new ArrayList();
+ StringTokenizer tSt = new StringTokenizer(currentVersion, ".");
+ while (tSt.hasMoreTokens())
+ tToks.add(tSt.nextToken());
+
+ int comp = 0;
+ comp: for (int i = 0; i < cToks.size(); i++) {
+ if (tToks.size() <= i) {
+ // equals until then, tested shorter
+ comp = 1;
+ break comp;
+ }
+
+ String c = (String) cToks.get(i);
+ String t = (String) tToks.get(i);
+
+ try {
+ int cInt = Integer.parseInt(c);
+ int tInt = Integer.parseInt(t);
+ if (cInt == tInt)
+ continue comp;
+ else {
+ comp = (cInt - tInt);
+ break comp;
+ }
+ } catch (NumberFormatException e) {
+ if (c.equals(t))
+ continue comp;
+ else {
+ comp = c.compareTo(t);
+ break comp;
+ }
+ }
+ }
+
+ if (comp == 0 && tToks.size() > cToks.size()) {
+ // equals until then, current shorter
+ comp = -1;
+ }
+
+ return comp;
+ }
+
+ public List getLocationsUrls(String baseUrl, String bundleLocations) {
+ List urls = new ArrayList();
+
+ if (bundleLocations == null)
+ return urls;
+ bundleLocations = SystemPropertyUtils
+ .resolvePlaceholders(bundleLocations);
+ if (debug)
+ debug(PROP_SLC_OSGI_LOCATIONS + "=" + bundleLocations);
+
+ StringTokenizer st = new StringTokenizer(bundleLocations,
+ File.pathSeparator);
+ while (st.hasMoreTokens()) {
+ urls.add(locationToUrl(baseUrl, st.nextToken().trim()));
+ }
+ return urls;
+ }
+
+ public List getBundlesUrls() {
+ String baseUrl = getProperty(PROP_SLC_OSGI_BASE_URL, DEFAULT_BASE_URL);
+ String bundlePatterns = getProperty(PROP_SLC_OSGI_BUNDLES);
+ return getBundlesUrls(baseUrl, bundlePatterns);
+ }
+
+ public List getBundlesUrls(String baseUrl, String bundlePatterns) {
+ List urls = new ArrayList();
+
+ List bundlesSets = new ArrayList();
+ if (bundlePatterns == null)
+ return urls;
+ bundlePatterns = SystemPropertyUtils
+ .resolvePlaceholders(bundlePatterns);
+ if (debug)
+ debug(PROP_SLC_OSGI_BUNDLES + "=" + bundlePatterns
+ + " (excludeSvn=" + excludeSvn + ")");
+
+ StringTokenizer st = new StringTokenizer(bundlePatterns, ",");
+ while (st.hasMoreTokens()) {
+ bundlesSets.add(new BundlesSet(st.nextToken()));
+ }
+
+ List included = new ArrayList();
+ PathMatcher matcher = new AntPathMatcher();
+ for (int i = 0; i < bundlesSets.size(); i++) {
+ BundlesSet bundlesSet = (BundlesSet) bundlesSets.get(i);
+ for (int j = 0; j < bundlesSet.getIncludes().size(); j++) {
+ String pattern = (String) bundlesSet.getIncludes().get(j);
+ match(matcher, included, bundlesSet.getDir(), null, pattern);
+ }
+ }
+
+ List excluded = new ArrayList();
+ for (int i = 0; i < bundlesSets.size(); i++) {
+ BundlesSet bundlesSet = (BundlesSet) bundlesSets.get(i);
+ for (int j = 0; j < bundlesSet.getExcludes().size(); j++) {
+ String pattern = (String) bundlesSet.getExcludes().get(j);
+ match(matcher, excluded, bundlesSet.getDir(), null, pattern);
+ }
+ }
+
+ for (int i = 0; i < included.size(); i++) {
+ String fullPath = (String) included.get(i);
+ if (!excluded.contains(fullPath))
+ urls.add(locationToUrl(baseUrl, fullPath));
+ }
+
+ return urls;
+ }
+
+ protected void match(PathMatcher matcher, List matched, String base,
+ String currentPath, String pattern) {
+ if (currentPath == null) {
+ // Init
+ File baseDir = new File(base.replace('/', File.separatorChar));
+ File[] files = baseDir.listFiles();
+
+ if (files == null) {
+ warn("Base dir " + baseDir + " has no children, exists="
+ + baseDir.exists() + ", isDirectory="
+ + baseDir.isDirectory());
+ return;
+ }
+
+ for (int i = 0; i < files.length; i++)
+ match(matcher, matched, base, files[i].getName(), pattern);
+ } else {
+ String fullPath = base + '/' + currentPath;
+ if (matched.contains(fullPath))
+ return;// don't try deeper if already matched
+
+ boolean ok = matcher.match(pattern, currentPath);
+ if (debug)
+ debug(currentPath + " " + (ok ? "" : " not ")
+ + " matched with " + pattern);
+ if (ok) {
+ matched.add(fullPath);
+ return;
+ } else {
+ String newFullPath = relativeToFullPath(base, currentPath);
+ File newFile = new File(newFullPath);
+ File[] files = newFile.listFiles();
+ if (files != null) {
+ for (int i = 0; i < files.length; i++) {
+ String newCurrentPath = currentPath + '/'
+ + files[i].getName();
+ if (files[i].isDirectory()) {
+ if (matcher.matchStart(pattern, newCurrentPath)) {
+ // recurse only if start matches
+ match(matcher, matched, base, newCurrentPath,
+ pattern);
+ } else {
+ if (debug)
+ debug(newCurrentPath
+ + " does not start match with "
+ + pattern);
+
+ }
+ } else {
+ boolean nonDirectoryOk = matcher.match(pattern,
+ newCurrentPath);
+ if (debug)
+ debug(currentPath + " " + (ok ? "" : " not ")
+ + " matched with " + pattern);
+ if (nonDirectoryOk)
+ matched.add(relativeToFullPath(base,
+ newCurrentPath));
+ }
+ }
+ }
+ }
+ }
+ }
+
+ protected String locationToUrl(String baseUrl, String location) {
+ int extInd = location.lastIndexOf('.');
+ String ext = null;
+ if (extInd > 0)
+ ext = location.substring(extInd);
+
+ if (baseUrl.startsWith("reference:") && ".jar".equals(ext))
+ return "file:" + location;
+ else
+ return baseUrl + location;
+ }
+
+ /** Transforms a relative path in a full system path. */
+ protected String relativeToFullPath(String basePath, String relativePath) {
+ return (basePath + '/' + relativePath).replace('/', File.separatorChar);
+ }
+
+ protected static void info(Object obj) {
+ System.out.println("#OSGiBOOT# " + obj);
+ }
+
+ protected void debug(Object obj) {
+ if (debug)
+ System.out.println("#OSGiBOOT DEBUG# " + obj);
+ }
+
+ protected void warn(Object obj) {
+ System.out.println("# WARN " + obj);
+ // Because of a weird bug under Windows when starting it in a forked VM
+ // if (System.getProperty("os.name").contains("Windows"))
+ // System.out.println("# WARN " + obj);
+ // else
+ // System.err.println("# WARN " + obj);
+ }
+
+ protected String getProperty(String name, String defaultValue) {
+ final String value;
+ if (defaultValue != null)
+ value = System.getProperty(name, defaultValue);
+ else
+ value = System.getProperty(name);
+
+ if (value == null || value.equals(""))
+ return null;
+ else
+ return value;
+ }
+
+ protected String getProperty(String name) {
+ return getProperty(name, null);
+ }
+
+ public boolean getDebug() {
+ return debug;
+ }
+
+ public void setDebug(boolean debug) {
+ this.debug = debug;
+ }
+
+ public BundleContext getBundleContext() {
+ return bundleContext;
+ }
+
+ /** Whether to exclude Subversion directories (true by default) */
+ public boolean isExcludeSvn() {
+ return excludeSvn;
+ }
+
+ public void setExcludeSvn(boolean excludeSvn) {
+ this.excludeSvn = excludeSvn;
+ }
+
+ protected class BundlesSet {
+ private String baseUrl = "reference:file";// not used yet
+ private final String dir;
+ private List includes = new ArrayList();
+ private List excludes = new ArrayList();
+
+ public BundlesSet(String def) {
+ StringTokenizer st = new StringTokenizer(def, ";");
+
+ if (!st.hasMoreTokens())
+ throw new RuntimeException("Base dir not defined.");
+ try {
+ String dirPath = st.nextToken();
+
+ if (dirPath.startsWith("file:"))
+ dirPath = dirPath.substring("file:".length());
+
+ dir = new File(dirPath.replace('/', File.separatorChar))
+ .getCanonicalPath();
+ if (debug)
+ debug("Base dir: " + dir);
+ } catch (IOException e) {
+ throw new RuntimeException("Cannot convert to absolute path", e);
+ }
+
+ while (st.hasMoreTokens()) {
+ String tk = st.nextToken();
+ StringTokenizer stEq = new StringTokenizer(tk, "=");
+ String type = stEq.nextToken();
+ String pattern = stEq.nextToken();
+ if ("in".equals(type) || "include".equals(type)) {
+ includes.add(pattern);
+ } else if ("ex".equals(type) || "exclude".equals(type)) {
+ excludes.add(pattern);
+ } else if ("baseUrl".equals(type)) {
+ baseUrl = pattern;
+ } else {
+ System.err.println("Unkown bundles pattern type " + type);
+ }
+ }
+
+ if (excludeSvn && !excludes.contains(EXCLUDES_SVN_PATTERN)) {
+ excludes.add(EXCLUDES_SVN_PATTERN);
+ }
+ }
+
+ public String getDir() {
+ return dir;
+ }
+
+ public List getIncludes() {
+ return includes;
+ }
+
+ public List getExcludes() {
+ return excludes;
+ }
+
+ public String getBaseUrl() {
+ return baseUrl;
+ }
+
+ }
+
+ public void setDefaultTimeout(long defaultTimeout) {
+ this.defaultTimeout = defaultTimeout;
+ }
+
+ public void setModulesUrlSeparator(String modulesUrlSeparator) {
+ this.modulesUrlSeparator = modulesUrlSeparator;
+ }
+
+}
projects / lgpl / argeo-commons.git / blobdiff