diff options
Diffstat (limited to 'sca-java-2.x/tags/2.0.1-RC1/modules/node-launcher-equinox/src/main/java/org/apache/tuscany/sca/node/equinox/launcher/NodeLauncher.java')
| -rw-r--r-- | sca-java-2.x/tags/2.0.1-RC1/modules/node-launcher-equinox/src/main/java/org/apache/tuscany/sca/node/equinox/launcher/NodeLauncher.java | 375 |
1 files changed, 375 insertions, 0 deletions
diff --git a/sca-java-2.x/tags/2.0.1-RC1/modules/node-launcher-equinox/src/main/java/org/apache/tuscany/sca/node/equinox/launcher/NodeLauncher.java b/sca-java-2.x/tags/2.0.1-RC1/modules/node-launcher-equinox/src/main/java/org/apache/tuscany/sca/node/equinox/launcher/NodeLauncher.java new file mode 100644 index 0000000000..678d88dab7 --- /dev/null +++ b/sca-java-2.x/tags/2.0.1-RC1/modules/node-launcher-equinox/src/main/java/org/apache/tuscany/sca/node/equinox/launcher/NodeLauncher.java @@ -0,0 +1,375 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ + +package org.apache.tuscany.sca.node.equinox.launcher; + +import static org.apache.tuscany.sca.node.equinox.launcher.NodeLauncherUtil.node; + +import java.io.File; +import java.io.IOException; +import java.net.MalformedURLException; +import java.net.URL; +import java.util.List; +import java.util.logging.Level; +import java.util.logging.Logger; + +import org.apache.commons.cli.CommandLine; +import org.apache.commons.cli.CommandLineParser; +import org.apache.commons.cli.HelpFormatter; +import org.apache.commons.cli.Option; +import org.apache.commons.cli.Options; +import org.apache.commons.cli.PosixParser; +import org.osgi.framework.BundleContext; + +/** + * A launcher for SCA nodes. + * + * Agruments: + * [-config <equinoxConfiguration>]: The configuration folder for Equinox + * [-bundles <osgiBundles>]: A list of bundles to be installed + * [-c <compositeURI>]: The composite URI + * [-t <ttl>]: Time to live in milliseconds before the node is started + * contribution1 ... contributionN: A list of contribution files or URLs + * + * @version $Rev$ $Date$ + */ +public class NodeLauncher { + + static final Logger logger = Logger.getLogger(NodeLauncher.class.getName()); + private EquinoxHost equinoxHost; + private BundleContext bundleContext; + + /** + * Constructs a new node launcher. + */ + private NodeLauncher() { + equinoxHost = new EquinoxHost(); + bundleContext = equinoxHost.start(); + } + + /** + * Returns a new launcher instance. + * + * @return a new launcher instance + */ + public static NodeLauncher newInstance() { + return new NodeLauncher(); + } + + /** + * Creates a new SCA node from the configuration URL + * + * @param configurationURL the URL of the node configuration which is the ATOM feed + * that contains the URI of the composite and a collection of URLs for the contributions + * + * @return a new SCA node. + * @throws LauncherException + */ + public <T> T createNode(String configurationURL) throws LauncherException { + return (T)node(configurationURL, null, null, null, bundleContext); + } + + /** + * Creates a new SCA OSGi Node. + * + * @param compositeURI the URI of the composite to use + * @param contributions the URI of the contributions that provides the composites and related + * artifacts. If the list is empty, then we will use the thread context classloader to discover + * the contribution on the classpath + * + * @return a new SCA node. + * @throws LauncherException + */ + public <T> T createNode(String compositeURI, Contribution... contributions) throws LauncherException { + return (T)node(null, compositeURI, null, contributions, bundleContext); + } + + /** + * Creates a new SCA OSGi Node. + * + * @param compositeURI the URI of the composite to use + * @param compositeContent the XML content of the composite to use + * @param contributions the URI of the contributions that provides the composites and related artifacts + * @return a new SCA node. + * @throws LauncherException + */ + public <T> T createNode(String compositeURI, String compositeContent, Contribution... contributions) + throws LauncherException { + return (T)node(null, compositeURI, compositeContent, contributions, bundleContext); + } + + public static void main(String[] args) throws Exception { + CommandLineParser parser = new PosixParser(); + Options options = getCommandLineOptions(); + CommandLine cli = parser.parse(options, args); + + Object node = null; + ShutdownThread shutdown = null; + EquinoxHost equinox = null; + try { + + if (cli.hasOption("config")) { + System.setProperty("osgi.configuration.area", cli.getOptionValue("config")); + } + + while (true) { + if (cli.hasOption("node")) { + // Create a node from a configuration URI + String configurationURI = cli.getOptionValue("node"); + logger.info("SCA Node configuration: " + configurationURI); + + // Create a node launcher + NodeLauncher launcher = newInstance(); + equinox = launcher.equinoxHost; + + node = launcher.createNode(configurationURI); + } + else if (cli.hasOption("bundles")) { + /** + * osgi.bundles + * The comma-separated list of bundles which are automatically installed and optionally started once the system is up + * and running. Each entry is of the form: + * <URL | simple bundle location>[@ [<start-level>] [":start"]] + * If the start-level (>0 integer) is omitted then the framework will use the default start level for the bundle. + * If the "start" tag is added then the bundle will be marked as started after being installed. Simple bundle locations are + * interepreted as relative to the framework's parent directory. The start-level indicates the OSGi start level at which the + * bundle should run. If this value is not set, the system computes an appropriate default. + */ + String bundles = cli.getOptionValue("bundles"); + if (bundles != null) { + System.setProperty("osgi.bundles", cli.getOptionValue("bundles")); + } + + // Create a node launcher + NodeLauncher launcher = newInstance(); + equinox = launcher.equinoxHost; + + /* + List<String> bundleFiles = cli.getArgList(); + for (String bf : bundleFiles) { + File f = new File(bf); + equinox.installBundle(f.toURI().toURL(), null); + } + for (Bundle b : launcher.bundleContext.getBundles()) { + try { + if (b.getHeaders().get(Constants.FRAGMENT_HOST) == null) { + // Start the non-fragment bundle + b.start(); + } + } catch (Exception e) { + logger.severe(NodeLauncherUtil.string(b, false) + " " + e.getMessage()); + // logger.log(Level.SEVERE, e.getMessage(), e); + } + } + */ + + } + else { + // Create a node from a composite URI and a contribution location + String compositeURI = cli.getOptionValue("composite"); + List<String> contribs = cli.getArgList(); + Contribution[] contributions = null; + if (!contribs.isEmpty()) { + contributions = new Contribution[contribs.size()]; + int index = 0; + for (String contrib : contribs) { + logger.info("SCA contribution: " + contrib); + URL url = null; + try { + url = new URL(contrib); + } catch (MalformedURLException e) { + url = new File(contrib).toURI().toURL(); + } + contributions[index] = new Contribution("contribution-" + index, url.toString()); + index++; + } + } else { + HelpFormatter formatter = new HelpFormatter(); + formatter.setSyntaxPrefix("Usage: "); + formatter.printHelp("java " + NodeLauncher.class.getName() + + " [-config <equinoxConfiguration>]" + + " [-c <compositeURI>]" + + " [-b <bundles>]" + + " [-t <ttl>]" + + " contribution1 ... contributionN", options); + return; + } + // Create a node launcher + logger.info("SCA composite: " + compositeURI); + NodeLauncher launcher = newInstance(); + equinox = launcher.equinoxHost; + node = launcher.createNode(compositeURI, contributions); + } + + if (node != null) { + logger.info("Apache Tuscany SCA Node is starting..."); + + // Start the node + try { + node.getClass().getMethod("start").invoke(node); + } catch (Exception e) { + logger.log(Level.SEVERE, "SCA Node could not be started", e); + throw e; + } + logger.info("SCA Node is now started."); + } + // Install a shutdown hook + shutdown = new ShutdownThread(node, equinox); + Runtime.getRuntime().addShutdownHook(shutdown); + + long ttl = Long.parseLong(cli.getOptionValue("ttl", "-1")); + if (ttl >= 0) { + logger.info("Waiting for " + ttl + " milliseconds ..."); + Thread.sleep(ttl); + break; // Exit + } + + // Wait until the "Enter" is pressed + logger.info("Press 'q' to quit, 'r' to restart."); + int k = 0; + try { + while ((k != 'q') && (k != 'r')) { + k = System.in.read(); + } + } catch (IOException e) { + + // Wait forever + Object lock = new Object(); + synchronized (lock) { + lock.wait(); + } + } + + // Stop the node + if (node != null) { + Object n = node; + node = null; + stopNode(n); + } + + // Quit + if (k == 'q') { + break; + } + + } + } finally { + + // Remove the shutdown hook + if (shutdown != null) { + Runtime.getRuntime().removeShutdownHook(shutdown); + } + + // Stop the node + if (node != null) { + destroyNode(node); + } + if (equinox != null) { + equinox.stop(); + } + } + } + + static Options getCommandLineOptions() { + Options options = new Options(); + Option opt1 = new Option("c", "composite", true, "URI for the composite"); + opt1.setArgName("compositeURI"); + options.addOption(opt1); + Option opt2 = new Option("n", "node", true, "URI for the node configuration"); + opt2.setArgName("nodeConfigurationURI"); + options.addOption(opt2); + Option opt3 = new Option("config", "configuration", true, "Configuration"); + opt3.setArgName("equinoxConfiguration"); + options.addOption(opt3); + Option opt4 = new Option("t", "ttl", true, "Time to live"); + opt4.setArgName("timeToLiveInMilliseconds"); + // opt4.setType(long.class); + options.addOption(opt4); + + Option opt5 = new Option("b", "bundles", false, "OSGi bundles"); + opt4.setArgName("osgiBundles"); + options.addOption(opt5); + + return options; + } + + public void destroy() { + if (equinoxHost != null) { + equinoxHost.stop(); + bundleContext = null; + } + } + + /** + * Stop the given node. + * + * @param node + * @throws Exception + */ + private static void destroyNode(Object node) throws Exception { + try { + node.getClass().getMethod("stop").invoke(node); + logger.info("SCA Node is now stopped."); + } catch (Exception e) { + logger.log(Level.SEVERE, "SCA Node could not be stopped", e); + throw e; + } + } + + private static class ShutdownThread extends Thread { + private Object node; + private EquinoxHost equinox; + + public ShutdownThread(Object node, EquinoxHost equinox) { + super(); + this.node = node; + this.equinox = equinox; + } + + @Override + public void run() { + try { + destroyNode(node); + } catch (Exception e) { + // Ignore + } + try { + equinox.stop(); + } catch (Exception e) { + // Ignore + } + } + } + + /** + * Stop the given node. + * + * @param node + * @throws Exception + */ + private static void stopNode(Object node) throws Exception { + try { + node.getClass().getMethod("stop").invoke(node); + logger.info("SCA Node is now stopped."); + } catch (Exception e) { + logger.log(Level.SEVERE, "SCA Node could not be stopped", e); + throw e; + } + } +} |