Java tutorial
/** * Copyright 2003-2008 Luck Consulting Pty Ltd * * Licensed 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 net.sf.ehcache.server.standalone; import org.apache.commons.daemon.Daemon; import org.apache.commons.daemon.DaemonContext; import org.apache.commons.daemon.DaemonController; import org.glassfish.embeddable.Deployer; import org.glassfish.embeddable.GlassFish; import org.glassfish.embeddable.GlassFishException; import org.glassfish.embeddable.GlassFishProperties; import org.glassfish.embeddable.GlassFishRuntime; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.io.File; /** * The ehcache server. * <p/> * By default the server listens for HTTP at 8080 and JMX at 8081. * <p/> * The HTTP Port may be passed in. The JMX port is always the HTTP port + 1. So, if the HTTP port is 9076, the JMX * listening port will be 9077. * <p/> * No other ports are opened. * * @author <a href="mailto:gluck@gregluck.com">Greg Luck</a> * @version $Id$ */ public class Server implements Daemon { /** * Default port: 8080 */ public static final Integer DEFAULT_BASE_PORT = 8080; private static final Logger LOG = LoggerFactory.getLogger(Server.class); private static ServerThread serverThread; private DaemonController controller; private File war; private Integer httpPort = DEFAULT_BASE_PORT; /** * Empty constructor. * This will create a server listening on the default port of 9998 and using the LightWeight HTTP Server * * @see #Server(Integer, java.io.File) */ public Server() { // } /** * Constructs a server listening at the given HTTP port * * @param httpPort the HTTP port to listen on. The JMX connector port is always to set to the HTTP port + 1. * @param ehcacheServerWar the ehcache-server.war */ public Server(Integer httpPort, File ehcacheServerWar) { this.httpPort = httpPort; this.war = ehcacheServerWar; } /** * Invoked by Jsvc with a context which includes the arguments passed to Jsvc. The main() method * also calls through here so that the server can be started using either Jsvc or java -jar... * * @param daemonContext * @throws Exception */ public void init(DaemonContext daemonContext) throws Exception { String[] args = daemonContext.getArguments(); if (args.length < 1 || args.length > 2 || (args.length == 1 && args[0].matches("--help"))) { System.out.println("Usage: java -jar ... [http httpPort] warfile | wardir "); System.exit(0); } if (args.length == 1) { war = new File(args[0]); if (!war.exists()) { System.err.println("Error: War file or exploded directory " + war + " does not exist."); System.exit(1); } } if (args.length == 2) { httpPort = Integer.parseInt(args[0]); war = new File(args[1]); if (!war.exists()) { System.err.println("Error: War file or exploded directory " + war + " does not exist."); System.exit(1); } } /* Dump a message */ System.err.println("\nEhcache standalone server initializing..."); /* Set up this simple daemon */ this.controller = daemonContext.getController(); } /** * Starts the server. This method is called by Jsvc. The main() method * also calls through here so that the server can be started using either Jsvc or java -jar... * * @throws Exception */ public void start() throws Exception { System.out.println("\nStarting standalone ehcache server on httpPort " + httpPort + " with WAR file or directory " + war); serverThread = new GlassfishServerThread(); serverThread.start(); } /** * A method for stopping a server. This is meant to be used by integration tests thus the package protected. * * @throws InterruptedException if the server is interrupted while stopping */ static void stopStatic() throws InterruptedException, GlassFishException { serverThread.stopServer(); //wait indefinitely until it shuts down serverThread.join(); } /** * Shuts down the HTTP server in an orderly way. */ public void stop() throws InterruptedException, GlassFishException { System.out.println("\nEhcache standalone server stopping..."); stopStatic(); System.out.println("\nEhcache standalone server stopped."); } /** * Interrupts the server thread. */ public void destroy() { System.out.println("\nEhcache standalone server destroyed."); serverThread.interrupt(); } /** * A mock DaemonContext which allows the main() method to call <code>init</code>. */ static class MockDaemonContext implements DaemonContext { private String[] args; /** * Constructor. * * @param args the <code>main()</code> method arguments. */ public MockDaemonContext(String[] args) { this.args = args; } /** * @return null as it is not a real Daemon */ public DaemonController getController() { return null; } /** * @return the arguments <code>main()</code> was invoked with. */ public String[] getArguments() { return args; } } /** * Wires in main() to use the Jsvc invocation path. * <p/> * Usage: java -jar ... [http port] warfile | wardir * <p/> * The port is optional. It should be <= 65536 * <p/> * If no war is specified, the LightWeight Http server is used. Otherwise Glassfish is used. * * @param args The first argument is the server port. The second is optional and is the path to the ehcache-server.war. * @throws Exception */ public static void main(String[] args) throws Exception { // String[] arguments = {"9090", "target/war/work/net.sf.ehcache/ehcache-server/greg.war"}; Server server = new Server(); server.init(new MockDaemonContext(args)); server.start(); } /** * Forks the Server into its own thread. */ abstract class ServerThread extends Thread { /** * Stops the server. */ public abstract void stopServer() throws GlassFishException; } /** * Embedded Glassfish implementation */ class GlassfishServerThread extends ServerThread { private GlassFish server; /** * Creates a server in a separate thread. * <p/> * This permits the calling thread to immediately return */ public void run() { startWithGlassfish(); } private void startWithGlassfish() { try { GlassFishRuntime gfr = GlassFishRuntime.bootstrap(); GlassFishProperties glassfishProps = new GlassFishProperties(); glassfishProps.setPort("http-listener", httpPort); Integer jmxPort = httpPort + 1; // todo embeddedInfo.setJmxConnectorPort(jmxPort); // Jerome Dochez confirmed 4 March 2010 this did not make it into 3 embedded server = gfr.newGlassFish(glassfishProps); server.start(); Deployer deployer = server.getDeployer(); deployer.deploy(war, "--contextroot=ehcache", "--enabled=true", "--force=true"); LOG.info("Glassfish server running on httpPort " + httpPort + " with WAR " + war); //+ ". JMX is listening at " + jmxPort); } catch (Exception e) { LOG.error("Cannot start server. ", e); } } /** * Stops the server */ public void stopServer() throws GlassFishException { //will cause the startsWithGlassfish method to return, and thus run() thus ending the thread. server.stop(); } } }