| /* |
| * 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.sling.launchpad.app; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.PrintStream; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.text.DateFormat; |
| import java.text.SimpleDateFormat; |
| import java.util.Date; |
| import java.util.HashMap; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| |
| import org.apache.sling.launchpad.base.shared.Launcher; |
| import org.apache.sling.launchpad.base.shared.Loader; |
| import org.apache.sling.launchpad.base.shared.Notifiable; |
| import org.apache.sling.launchpad.base.shared.SharedConstants; |
| |
| /** |
| * The <code>Main</code> is the externally visible Standalone Java Application |
| * launcher for Sling. Please refer to the full description <i>The Sling |
| * Launchpad</i> on the Sling Web Site for a full description of this class. |
| * <p> |
| * Logging goes to standard output for informational messages and to standard |
| * error for error messages. |
| * <p> |
| * This class goes into the secondary artifact with the classifier <i>app</i> to |
| * be used as the main class when starting the Java Application. |
| * |
| * @see <a href="http://sling.apache.org/site/the-sling-launchpad.html">The |
| * Sling Launchpad</a> |
| */ |
| public class Main { |
| |
| // The name of the environment variable to consult to find out |
| // about sling.home |
| private static final String ENV_SLING_HOME = "SLING_HOME"; |
| |
| /** |
| * The name of the configuration property indicating the |
| * {@link ControlAction} to be taken in the {@link #doControlAction()} |
| * method. |
| */ |
| protected static final String PROP_CONTROL_ACTION = "sling.control.action"; |
| |
| /** |
| * The name of the configuration property indicating the socket to use for |
| * the control connection. The value of this property is either just a port |
| * number (in which case the host is assumed to be <code>localhost</code>) |
| * or a host name (or IP address) and port number separated by a colon. |
| */ |
| protected static final String PROP_CONTROL_SOCKET = "sling.control.socket"; |
| |
| /** The Sling configuration property name setting the initial log level */ |
| private static final String PROP_LOG_LEVEL = "org.apache.sling.commons.log.level"; |
| |
| /** The Sling configuration property name setting the initial log file */ |
| private static final String PROP_LOG_FILE = "org.apache.sling.commons.log.file"; |
| |
| /** |
| * The configuration property setting the port on which the HTTP service |
| * listens |
| */ |
| private static final String PROP_PORT = "org.osgi.service.http.port"; |
| |
| /** |
| * The configuration property setting the context path where the HTTP service |
| * mounts itself. |
| */ |
| private static final String PROP_CONTEXT_PATH = "org.apache.felix.http.context_path"; |
| |
| /** |
| * Host name or IP Address of the interface to listen on. |
| */ |
| private static final String PROP_HOST = "org.apache.felix.http.host"; |
| |
| /** |
| * Name of the configuration property (or system property) indicating |
| * whether the shutdown hook should be installed or not. If this property is |
| * not set or set to {@code true} (case insensitive), the shutdown hook |
| * properly shutting down the framework is installed on startup. Otherwise, |
| * if this property is set to any value other than {@code true} (case |
| * insensitive) the shutdown hook is not installed. |
| * <p> |
| * The respective command line option is {@code -n}. |
| */ |
| private static final String PROP_SHUTDOWN_HOOK = "sling.shutdown.hook"; |
| |
| /** |
| * The main entry point to the Sling Launcher Standalone Java Application. |
| * This method is generally only called by the Java VM to launch Sling. |
| * |
| * @param args The command line arguments supplied when starting the Sling |
| * Launcher through the Java VM. |
| */ |
| public static void main(final String[] args) { |
| final Map<String, String> rawArgs = parseCommandLine(args); |
| |
| // support usage first |
| if (doHelp(rawArgs)) { |
| System.exit(0); |
| } |
| |
| final Map<String, String> props = convertCommandLineArgs(rawArgs); |
| if (props == null) { |
| System.exit(1); |
| } |
| |
| final Main main = new Main(props); |
| |
| // check for control commands |
| int rc = main.doControlAction(); |
| if (rc >= 0) { |
| main.terminateVM(rc); |
| } |
| |
| // finally start Sling |
| if (!main.doStart()) { |
| error("Failed to start Sling; terminating", null); |
| main.terminateVM(1); |
| } |
| } |
| |
| /** |
| * The map of command line arguments where the keys are the actual |
| * property names as known to the OSGi Framework and its installed |
| * bundles. |
| */ |
| private final Map<String, String> commandLineArgs; |
| |
| /** |
| * Whether to install the shutdown hook. |
| * |
| * @see #PROP_SHUTDOWN_HOOK |
| * @see #installShutdownHook(Map) |
| * @see #addShutdownHook() |
| */ |
| private boolean installShutdownHook; |
| |
| /** |
| * The shutdown hook installed into the Java VM after Sling has been |
| * started. The hook is removed again when Sling is being shut down |
| * or the {@link Notified notifier} is notified of the framework shutdown. |
| * |
| * @see #addShutdownHook() |
| * @see #removeShutdownHook() |
| */ |
| private Thread shutdownHook; |
| |
| /** |
| * The absolute path to the home directory of the launched Sling |
| * application. This corresponds to the value of the <code>sling.home</code> |
| * framework property. |
| * |
| * @see #getSlingHome(Map) |
| */ |
| private final String slingHome; |
| |
| /** |
| * The {@link Loader} class used to create the Framework class loader and |
| * to launch the framework. |
| */ |
| private Loader loader; |
| |
| /** |
| * The actual launcher accessed through the {@link #loader} to launch |
| * the OSGi Framework. |
| */ |
| private Launcher sling; |
| |
| /** |
| * Flag to indicate if Sling has already been started. |
| */ |
| private boolean started = false; |
| |
| /** |
| * Creates an instance of this main loader class. The provided arguments are |
| * used to configure the OSGi framework being launched with the |
| * {@link #doStart(URL)} method. |
| * |
| * @param args The map of configuration properties to be supplied to the |
| * OSGi framework. The keys in this map are assumed to be usefull |
| * without translation to the launcher and the OSGi Framework. If |
| * this parameter is <code>null</code> and empty map without |
| * configuration is assumed. |
| */ |
| protected Main(Map<String, String> args) { |
| this.commandLineArgs = (args == null) |
| ? new HashMap<String, String>() |
| : args; |
| |
| this.installShutdownHook = installShutdownHook(this.commandLineArgs); |
| |
| // sling.home from the command line or system properties, else default |
| String home = getSlingHome(commandLineArgs); |
| final File slingHomeFile = new File(home); |
| if (!slingHomeFile.isAbsolute()) { |
| home = slingHomeFile.getAbsolutePath(); |
| } |
| this.slingHome = home; |
| } |
| |
| /** |
| * After instantiating this class, this method may be called to help with |
| * the communication with a running Sling instance. To setup this |
| * communication the configuration properties supplied to the constructor |
| * are evaluated as follows: |
| * <p> |
| * <table> |
| * <tr> |
| * <td><code>{@value #PROP_CONTROL_SOCKET}</code></td> |
| * <td>Specifies the socket to use for the control connection. This |
| * specification is of the form <i>host:port</i> where the host can be a |
| * host name or IP Address and may be omitted (along with the separating |
| * colon) and port is just the numeric port number at which to listen. The |
| * default is <i>localhost:63000</i>. It is suggested to not use an |
| * externally accessible interface for security reasons because there is no |
| * added security on this control channel for now.</td> |
| * </tr> |
| * <tr> |
| * <td><code>{@value #PROP_CONTROL_ACTION}</code></td> |
| * <td>The actual action to execute: |
| * <ul> |
| * <b>start</b> -- Start the listener on the configured socket and expect |
| * commands there. This action is useful only when launching the Sling |
| * application since this action helps manage a running system. |
| * </ul> |
| * <ul> |
| * <b>stop</b> -- Connects to the listener running on the configured socket |
| * and send the command to terminate the Sling Application. If this command |
| * is used, it is expected the Sling Application will not start. |
| * </ul> |
| * <ul> |
| * <b>status</b> -- Connects to the listener running on the configured |
| * socket and query about its status. If this command is used, it is |
| * expected the Sling Application will not start. |
| * </ul> |
| * </td> |
| * </tr> |
| * </table> |
| * <p> |
| * After this method has executed the <code>j</code> and |
| * {@link #PROP_CONTROL_ACTION} properties have been removed from the |
| * configuration properties. |
| * <p> |
| * While the {@link #doStart()} and {@link #doStop()} methods may be called |
| * multiple times this method should only be called once after creating this |
| * class's instance. |
| * |
| * @return An code indicating whether the Java VM is expected to be |
| * terminated or not. If <code>-1</code> is returned, the VM should |
| * continue as intended, maybe starting the Sling Application. This |
| * code is returned if the start action (or no action at all) is |
| * supplied. Otherwise the VM should terminate with the returned |
| * code as its exit code. For the stop action, this will be zero. |
| * For the status action, this will be a LSB compliant code for |
| * daemon status check: 0 (application running), 1 (Program Dead), |
| * 3 (Program Not Running), 4 (Unknown Problem). |
| * @see <a |
| * href="http://refspecs.linuxbase.org/LSB_3.1.0/LSB-Core-generic/LSB-Core-generic/iniscrptact.html">Init Script Actions</a> |
| * for a definition of the LSB status codes |
| */ |
| protected int doControlAction() { |
| final ControlAction action = getControlAction(); |
| if (action != null) { |
| final ControlListener sl = new ControlListener(this, |
| commandLineArgs.remove(PROP_CONTROL_SOCKET)); |
| switch (action) { |
| case START: |
| if (!sl.listen()) { |
| // assume service already running |
| return 0; |
| } |
| break; |
| case STATUS: |
| return sl.statusServer(); |
| case STOP: |
| return sl.shutdownServer(); |
| case THREADS: |
| return sl.dumpThreads(); |
| } |
| } |
| |
| return -1; |
| } |
| |
| /** |
| * Terminates the VM which was started by calling the |
| * {@link #main(String[])} method of this class using the |
| * <code>status</code> value as the application exit status code. |
| * <p> |
| * This method does not return. |
| * |
| * @param status The application status exit code. |
| */ |
| // default accessor to enable overwriting for unit tests |
| void terminateVM(final int status) { |
| System.exit(status); |
| } |
| |
| private ControlAction getControlAction() { |
| Object action = this.commandLineArgs.remove(PROP_CONTROL_ACTION); |
| if (action != null) { |
| if (action instanceof ControlAction) { |
| return (ControlAction) action; |
| } |
| |
| try { |
| return ControlAction.valueOf(action.toString().toUpperCase()); |
| } catch (IllegalArgumentException iae) { |
| error("Illegal control action value: " + action, null); |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Starts the application with the configuration supplied with the |
| * configuration properties when this instance has been created. |
| * <p> |
| * Calling this method multiple times before calling {@link #doStop()} will |
| * cause a message to be printed and <code>true</code> being returned. |
| * |
| * @return <code>true</code> if startup was successful or the application |
| * is considered to be started already. Otherwise an error message |
| * has been logged and <code>false</code> is returned. |
| */ |
| protected boolean doStart() { |
| // ensure up-to-date launcher jar |
| return doStart(getClass().getResource( |
| SharedConstants.DEFAULT_SLING_LAUNCHER_JAR)); |
| } |
| |
| protected boolean doStart(final URL launcherJar) { |
| |
| // prevent duplicate start |
| if ( this.started) { |
| info("Apache Sling has already been started", null); |
| return true; |
| } |
| |
| info("Starting Apache Sling in " + slingHome, null); |
| this.started = true; |
| |
| Loader loaderTmp = null; |
| try { |
| final File launchpadHome = getLaunchpadHome(slingHome, |
| commandLineArgs); |
| loaderTmp = new Loader(launchpadHome) { |
| @Override |
| protected void info(String msg) { |
| Main.info(msg, null); |
| } |
| }; |
| } catch (IllegalArgumentException iae) { |
| error( |
| "Cannot launch: Launchpad folder cannot be used: " |
| + iae.getMessage(), null); |
| return false; |
| } |
| this.loader = loaderTmp; |
| |
| if (launcherJar != null) { |
| try { |
| loader.installLauncherJar(launcherJar); |
| } catch (IOException ioe) { |
| error("Cannot launch: Cannot install " + launcherJar |
| + " for use", ioe); |
| return false; |
| } |
| } else { |
| info("No Launcher JAR to install", null); |
| } |
| |
| Object object = null; |
| try { |
| object = loader.loadLauncher(SharedConstants.DEFAULT_SLING_MAIN); |
| } catch (IllegalArgumentException iae) { |
| error("Cannot launch: Failed loading Sling class " |
| + SharedConstants.DEFAULT_SLING_MAIN, iae); |
| return false; |
| } |
| |
| if (object instanceof Launcher) { |
| |
| // configure the launcher |
| Launcher sling = (Launcher) object; |
| sling.setNotifiable(new Notified()); |
| sling.setCommandLine(commandLineArgs); |
| sling.setSlingHome(slingHome); |
| |
| // launch it |
| info("Starting launcher ...", null); |
| if (sling.start()) { |
| info("Startup completed", null); |
| this.sling = sling; |
| addShutdownHook(); |
| return true; |
| } |
| |
| error("Cannot launch: Launcher.start() returned false", null); |
| |
| } else { |
| |
| error("Cannot launch: Class " + SharedConstants.DEFAULT_SLING_MAIN + " is not a Launcher class", null); |
| |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Maybe called by the application to cause the Sling Application to |
| * properly terminate by stopping the OSGi Framework. |
| * <p> |
| * After calling this method the Sling Application can be started again |
| * by calling the {@link #doStart()} method. |
| * <p> |
| * Calling this method multiple times without calling the {@link #doStart()} |
| * method in between has no effect after the Sling Application has been |
| * terminated. |
| */ |
| protected void doStop() { |
| removeShutdownHook(); |
| |
| // now really shutdown sling |
| if (this.sling != null) { |
| info("Stopping Apache Sling", null); |
| this.sling.stop(); |
| this.sling = null; |
| } |
| |
| // clean and VM caches |
| if (this.loader != null) { |
| this.loader.cleanupVM(); |
| this.loader = null; |
| } |
| |
| // further cleanup |
| this.started = false; |
| } |
| |
| private void addShutdownHook() { |
| if (this.installShutdownHook && this.shutdownHook == null) { |
| this.shutdownHook = new Thread(new ShutdownHook(), "Apache Sling Terminator"); |
| Runtime.getRuntime().addShutdownHook(this.shutdownHook); |
| } |
| } |
| |
| private void removeShutdownHook() { |
| // remove the shutdown hook, will fail if called from the |
| // shutdown hook itself. Otherwise this prevents shutdown |
| // from being called again |
| Thread shutdownHook = this.shutdownHook; |
| this.shutdownHook = null; |
| |
| if (shutdownHook != null) { |
| try { |
| Runtime.getRuntime().removeShutdownHook(shutdownHook); |
| } catch (Throwable t) { |
| // don't care for problems removing the hook |
| } |
| } |
| } |
| |
| /** |
| * Define the sling.home parameter implementing the algorithme defined on |
| * the wiki page to find the setting according to this algorithm: |
| * <ol> |
| * <li>Configuration property <code>sling.home</code></li> |
| * <li>System property <code>sling.home</code></li> |
| * <li>Environment variable <code>SLING_HOME</code></li> |
| * <li>Default value <code>sling</code></li> |
| * </ol> |
| * |
| * @param commandLine The command line arguments |
| * @return The value to use for sling.home |
| */ |
| private static String getSlingHome(Map<String, String> commandLine) { |
| String source = null; |
| |
| String slingHome = commandLine.get(SharedConstants.SLING_HOME); |
| if (slingHome != null) { |
| |
| source = "command line"; |
| |
| } else { |
| |
| slingHome = System.getProperty(SharedConstants.SLING_HOME); |
| if (slingHome != null) { |
| |
| source = "system property sling.home"; |
| |
| } else { |
| |
| slingHome = System.getenv(ENV_SLING_HOME); |
| if (slingHome != null) { |
| |
| source = "environment variable SLING_HOME"; |
| |
| } else { |
| |
| source = "default"; |
| slingHome = SharedConstants.SLING_HOME_DEFAULT; |
| |
| } |
| } |
| } |
| |
| info("Setting sling.home=" + slingHome + " (" + source + ")", null); |
| return slingHome; |
| } |
| |
| /** |
| * Return the absolute path to sling home |
| */ |
| public String getSlingHome() { |
| return this.slingHome; |
| } |
| |
| /** |
| * Define the sling.launchpad parameter implementing the algorithm defined |
| * on the wiki page to find the setting according to this algorithm: |
| * <ol> |
| * <li>Configuration property <code>sling.launchpad</code>. This path is |
| * resolved against the <code>slingHome</code> folder if relative.</li> |
| * <li>Default to same as <code>sling.home</code></li> |
| * </ol> |
| * |
| * @param slingHome The absolute path to the Sling Home folder (aka the |
| * <code>sling.home</code>. |
| * @param commandLineArgs The configuration properties from where to get the |
| * <code>sling.launchpad</code> property. |
| * @return The absolute <code>File</code> indicating the launchpad folder. |
| */ |
| private static File getLaunchpadHome(final String slingHome, |
| final Map<String, String> commandLineArgs) { |
| final String launchpadHomeParam = commandLineArgs.get(SharedConstants.SLING_LAUNCHPAD); |
| if (launchpadHomeParam == null || launchpadHomeParam.length() == 0) { |
| commandLineArgs.put(SharedConstants.SLING_LAUNCHPAD, slingHome); |
| return new File(slingHome); |
| } |
| |
| File launchpadHome = new File(launchpadHomeParam); |
| if (!launchpadHome.isAbsolute()) { |
| launchpadHome = new File(slingHome, launchpadHomeParam); |
| } |
| |
| commandLineArgs.put(SharedConstants.SLING_LAUNCHPAD, |
| launchpadHome.getAbsolutePath()); |
| return launchpadHome; |
| } |
| |
| // ---------- logging |
| |
| // emit an informational message to standard out |
| protected static void info(String message, Throwable t) { |
| log(System.out, "*INFO *", message, t); |
| } |
| |
| // emit an error message to standard err |
| protected static void error(String message, Throwable t) { |
| log(System.err, "*ERROR*", message, t); |
| } |
| |
| private static final DateFormat fmt = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss.SSS "); |
| |
| // helper method to format the message on the correct output channel |
| // the throwable if not-null is also prefixed line by line with the prefix |
| private static void log(PrintStream out, String prefix, String message, |
| Throwable t) { |
| |
| final StringBuilder linePrefixBuilder = new StringBuilder(); |
| synchronized (fmt) { |
| linePrefixBuilder.append(fmt.format(new Date())); |
| } |
| linePrefixBuilder.append(prefix); |
| linePrefixBuilder.append(" ["); |
| linePrefixBuilder.append(Thread.currentThread().getName()); |
| linePrefixBuilder.append("] "); |
| final String linePrefix = linePrefixBuilder.toString(); |
| |
| out.print(linePrefix); |
| out.println(message); |
| if (t != null) { |
| t.printStackTrace(new PrintStream(out) { |
| @Override |
| public void print(String x) { |
| super.print(linePrefix); |
| super.print(x); |
| } |
| }); |
| } |
| } |
| |
| /** |
| * Parses the command line arguments into a map of strings indexed by |
| * strings. This method supports single character option names only at the |
| * moment. Each pair of an option name and its value is stored into the |
| * map. If a single dash '-' character is encountered the rest of the command |
| * line are interpreted as option names and are stored in the map unmodified |
| * as entries with the same key and value. |
| * <table> |
| * <tr><th>Command Line</th><th>Mapping</th></tr> |
| * <tr><td>x</td><td>x -> x</td></tr> |
| * <tr><td>-y z</td><td>y -> z</td></tr> |
| * <tr><td>-yz</td><td>y -> z</td></tr> |
| * <tr><td>-y -z</td><td>y -> y, z -> z</td></tr> |
| * <tr><td>-y x - -z a</td><td>y -> x, -z -> -z, a -> a</td></tr> |
| * </table> |
| * |
| * @param args The command line to parse |
| * |
| * @return The map of command line options and their values |
| */ |
| // default accessor to enable unit tests without requiring reflection |
| static Map<String, String> parseCommandLine(String... args) { |
| Map<String, String> commandLine = new HashMap<String, String>(); |
| boolean readUnparsed = false; |
| for (int argc = 0; args != null && argc < args.length; argc++) { |
| String arg = args[argc]; |
| |
| if (readUnparsed) { |
| commandLine.put(arg, arg); |
| } else if (arg.startsWith("-")) { |
| if (arg.length() == 1) { |
| readUnparsed = true; |
| } else { |
| String key = String.valueOf(arg.charAt(1)); |
| if (arg.length() > 2) { |
| final String val; |
| final int indexOfEq = arg.indexOf('='); |
| if (indexOfEq != -1) { |
| //Handle case -Da=b |
| key = arg.substring(1, indexOfEq); |
| val = arg.substring(indexOfEq + 1); |
| } else { |
| val = arg.substring(2); |
| } |
| commandLine.put(key, val); |
| } else { |
| argc++; |
| if (argc < args.length |
| && (args[argc].equals("-") || !args[argc].startsWith("-"))) { |
| String val = args[argc]; |
| |
| //Special handling for -D a=b |
| if(key.equals("D")){ |
| final int indexOfEq = val.indexOf('='); |
| if (indexOfEq != -1) { |
| //Handle case -D a=b. Add key as Da |
| key = "D" + val.substring(0, indexOfEq); |
| val = val.substring(indexOfEq + 1); |
| } |
| } |
| commandLine.put(key, val); |
| } else { |
| commandLine.put(key, key); |
| argc--; |
| } |
| } |
| } |
| } else { |
| commandLine.put(arg, arg); |
| } |
| } |
| return commandLine; |
| } |
| |
| /** prints a simple usage plus optional error message */ |
| private static boolean doHelp(Map<String, String> args) { |
| if (args.remove("h") != null) { |
| System.out.println("usage: " |
| + Main.class.getName() |
| + " [ start | stop | status ] [ -j adr ] [ -l loglevel ] [ -f logfile ] [ -c slinghome ] [ -i launchpadhome ] [ -a address ] [ -p port ] { -Dn=v } [ -h ]"); |
| |
| System.out.println(" start listen for control connection (uses -j)"); |
| System.out.println(" stop terminate running Apache Sling (uses -j)"); |
| System.out.println(" status check whether Apache Sling is running (uses -j)"); |
| System.out.println(" threads request a thread dump from Apache Sling (uses -j)"); |
| System.out.println(" -j adr host and port to use for control connection in the format '[host:]port' (default 127.0.0.1:0)"); |
| System.out.println(" -l loglevel the initial loglevel (0..4, FATAL, ERROR, WARN, INFO, DEBUG)"); |
| System.out.println(" -f logfile the log file, \"-\" for stdout (default logs/error.log)"); |
| System.out.println(" -c slinghome the sling context directory (default sling)"); |
| System.out.println(" -i launchpadhome the launchpad directory (default slinghome)"); |
| System.out.println(" -a address the interfact to bind to (use 0.0.0.0 for any)"); |
| System.out.println(" -p port the port to listen to (default 8080)"); |
| System.out.println(" -r path the root servlet context path for the http service (default is /)"); |
| System.out.println(" -n don't install the shutdown hook"); |
| System.out.println(" -Dn=v sets property n to value v. Make sure to use this option *after* " + |
| "the jar filename. The JVM also has a -D option which has a " + |
| "different meaning"); |
| System.out.println(" -h prints this usage message"); |
| |
| return true; |
| } |
| return false; |
| } |
| |
| private static boolean installShutdownHook(Map<String, String> props) { |
| String prop = props.remove(PROP_SHUTDOWN_HOOK); |
| if (prop == null) { |
| prop = System.getProperty(PROP_SHUTDOWN_HOOK); |
| } |
| |
| return (prop == null) ? true : Boolean.valueOf(prop); |
| } |
| |
| // default accessor to enable unit tests without requiring reflection |
| static Map<String, String> convertCommandLineArgs( |
| Map<String, String> rawArgs) { |
| final HashMap<String, String> props = new HashMap<String, String>(); |
| boolean errorArg = false; |
| for (Entry<String, String> arg : rawArgs.entrySet()) { |
| if (arg.getKey().length() == 1 || arg.getKey().startsWith("D")) { |
| String value = arg.getValue(); |
| switch (arg.getKey().charAt(0)) { |
| case 'j': |
| if (value == arg.getKey()) { |
| errorArg("-j", "Missing host:port value"); |
| errorArg = true; |
| continue; |
| } |
| props.put(PROP_CONTROL_SOCKET, value); |
| break; |
| |
| case 'l': |
| if (value == arg.getKey()) { |
| errorArg("-l", "Missing log level value"); |
| errorArg = true; |
| continue; |
| } |
| props.put(PROP_LOG_LEVEL, value); |
| break; |
| |
| case 'f': |
| if (value == arg.getKey()) { |
| errorArg("-f", "Missing log file value"); |
| errorArg = true; |
| continue; |
| } else if ("-".equals(value)) { |
| value = ""; |
| } |
| props.put(PROP_LOG_FILE, value); |
| break; |
| |
| case 'c': |
| if (value == arg.getKey()) { |
| errorArg("-c", "Missing directory value"); |
| errorArg = true; |
| continue; |
| } |
| props.put(SharedConstants.SLING_HOME, value); |
| break; |
| |
| case 'i': |
| if (value == arg.getKey()) { |
| errorArg("-i", "Missing launchpad directory value"); |
| errorArg = true; |
| continue; |
| } |
| props.put(SharedConstants.SLING_LAUNCHPAD, value); |
| break; |
| |
| case 'a': |
| if (value == arg.getKey()) { |
| errorArg("-a", "Missing address value"); |
| errorArg = true; |
| continue; |
| } |
| props.put(PROP_HOST, value); |
| break; |
| |
| case 'p': |
| if (value == arg.getKey()) { |
| errorArg("-p", "Missing port value"); |
| errorArg = true; |
| continue; |
| } |
| try { |
| // just to verify it is a number |
| Integer.parseInt(value); |
| props.put(PROP_PORT, value); |
| } catch (RuntimeException e) { |
| errorArg("-p", "Bad port: " + value); |
| errorArg = true; |
| } |
| break; |
| |
| case 'r': |
| if (value == arg.getKey()) { |
| errorArg("-r", "Missing root path value"); |
| errorArg = true; |
| continue; |
| } |
| props.put(PROP_CONTEXT_PATH, value); |
| break; |
| |
| case 'n': |
| props.put(PROP_SHUTDOWN_HOOK, Boolean.FALSE.toString()); |
| break; |
| |
| case 'D': |
| if (value == arg.getKey()) { |
| errorArg("-D", "Missing property assignment"); |
| errorArg = true; |
| continue; |
| } |
| if (arg.getKey().length() > 1) { |
| //Dfoo=bar arg.key=Dfoo and arg.value=bar |
| props.put(arg.getKey().substring(1), arg.getValue()); |
| } else { |
| //D foo=bar arg.key=D and arg.value=foo=bar |
| String[] parts = value.split("="); |
| int valueIdx = (parts.length > 1) ? 1 : 0; |
| props.put(parts[0], parts[valueIdx]); |
| } |
| break; |
| |
| default: |
| errorArg("-" + arg.getKey(), "Unrecognized option"); |
| errorArg = true; |
| break; |
| } |
| } else if ("start".equals(arg.getKey()) |
| || "stop".equals(arg.getKey()) |
| || "status".equals(arg.getKey()) |
| || "threads".equals(arg.getKey())) { |
| props.put(PROP_CONTROL_ACTION, arg.getValue()); |
| } else { |
| errorArg(arg.getKey(), "Unrecognized option"); |
| errorArg = true; |
| } |
| } |
| return errorArg ? null : props; |
| } |
| |
| private static void errorArg(String option, String message) { |
| error(String.format("%s: %s (use -h for more information)", option, |
| message), null); |
| } |
| |
| /** |
| * Removes well-known stray threads and thread groups and removes framework |
| * thread context class loaders. Well-known stray threads and thread groups |
| * are: |
| * <ul> |
| * <li>The FileCleaningTracker$Reaper thread of the commons-io library</li> |
| * <li>The QuartzScheduler:ApacheSling thread group. See <a |
| * href="https://issues.apache.org/jira/browse/SLING-2535">SLING-2535 |
| * QuartzScheduler:ApacheSling thread group remaining after stopping the |
| * scheduler bundle</a></li> |
| * </ul> |
| */ |
| @SuppressWarnings("deprecation") |
| static void cleanupThreads() { |
| |
| // the current thread is the SlingNotifier thread part of |
| // the main thread group, whose parent is the system thread |
| // group. We only care for the main thread group here |
| ThreadGroup tg = Thread.currentThread().getThreadGroup(); |
| Thread[] active = new Thread[tg.activeCount()]; |
| tg.enumerate(active); |
| for (Thread thread : active) { |
| if (thread != null) { |
| if (thread.getName().equals("FileCleaningTracker$Reaper")) { |
| // I know, but this thread is stray ... |
| // Commons-IO bundle (or consumer of it) should |
| // actually stop it |
| thread.stop(); |
| } else { |
| ClassLoader loader = thread.getContextClassLoader(); |
| if (loader != null && loader.getClass().getName().startsWith("org.apache.felix.framework.")) { |
| thread.setContextClassLoader(null); |
| } |
| } |
| } |
| } |
| |
| // SLING-2535 - Scheduler thread group |
| ThreadGroup[] groups = new ThreadGroup[tg.activeGroupCount()]; |
| tg.enumerate(groups); |
| for (ThreadGroup group : groups) { |
| if (group != null && group.getName().equals("QuartzScheduler:ApacheSling")) { |
| group.destroy(); |
| } |
| } |
| } |
| |
| private class ShutdownHook implements Runnable { |
| @Override |
| public void run() { |
| Main.info("Java VM is shutting down", null); |
| Main.this.doStop(); |
| } |
| } |
| |
| private class Notified implements Notifiable { |
| |
| /** |
| * The framework has been stopped by calling the |
| * <code>Bundle.stop()</code> on the system bundle. This actually |
| * terminates the Sling Standalone application. |
| */ |
| @Override |
| public void stopped() { |
| /** |
| * This method is called if the framework is stopped from within by |
| * calling stop on the system bundle or if the framework is stopped |
| * because the VM is going down and the shutdown hook has initiated |
| * the shutdown. In any case we ensure the reference to the framework |
| * is removed and remove the shutdown hook (but don't care if that |
| * fails). |
| */ |
| |
| Main.info("Apache Sling has been stopped", null); |
| |
| Main.this.sling = null; |
| Main.this.doStop(); |
| } |
| |
| /** |
| * The framework has been stopped with the intent to be restarted by |
| * calling either of the <code>Bundle.update</code> methods on the |
| * system bundle. |
| * <p> |
| * If an <code>InputStream</code> was provided, this has been copied to |
| * a temporary file, which will be used in place of the existing |
| * launcher jar file. |
| * |
| * @param updateFile The temporary file to replace the existing launcher |
| * jar file. If <code>null</code> the existing launcher jar |
| * will be used again. |
| */ |
| @Override |
| public void updated(File updateFile) { |
| |
| Main.this.sling = null; |
| Main.this.doStop(); |
| |
| Main.cleanupThreads(); |
| |
| if (updateFile == null) { |
| |
| Main.info("Restarting Framework and Apache Sling", null); |
| if (!Main.this.doStart(null)) { |
| Main.error("Failed to restart Sling; terminating", null); |
| Main.this.terminateVM(1); |
| } |
| |
| } else { |
| |
| Main.info( |
| "Restarting Framework with update from " + updateFile, null); |
| boolean started = false; |
| try { |
| started = Main.this.doStart(updateFile.toURI().toURL()); |
| } catch (MalformedURLException mue) { |
| Main.error("Cannot get URL for file " + updateFile, mue); |
| } finally { |
| updateFile.delete(); |
| } |
| |
| if (!started) { |
| Main.error("Failed to restart Sling; terminating", null); |
| Main.this.terminateVM(1); |
| } |
| } |
| } |
| } |
| |
| } |
