src/java/org/eclipse/jetty/server/Server.java - platform/external/jetty - Git at Google

 //
 //  ========================================================================
 //  Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd.
 //  ------------------------------------------------------------------------
 //  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
 //
 //      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.
 //  ========================================================================
 //

 package org.eclipse.jetty.server;

 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.util.Enumeration;

 import javax.servlet.AsyncContext;
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;

 import org.eclipse.jetty.http.HttpGenerator;
 import org.eclipse.jetty.http.HttpURI;
 import org.eclipse.jetty.server.handler.HandlerWrapper;
 import org.eclipse.jetty.server.nio.SelectChannelConnector;
 import org.eclipse.jetty.util.Attributes;
 import org.eclipse.jetty.util.AttributesMap;
 import org.eclipse.jetty.util.LazyList;
 import org.eclipse.jetty.util.MultiException;
 import org.eclipse.jetty.util.TypeUtil;
 import org.eclipse.jetty.util.URIUtil;
 import org.eclipse.jetty.util.component.Container;
 import org.eclipse.jetty.util.component.Destroyable;
 import org.eclipse.jetty.util.component.LifeCycle;
 import org.eclipse.jetty.util.log.Log;
 import org.eclipse.jetty.util.log.Logger;
 import org.eclipse.jetty.util.thread.QueuedThreadPool;
 import org.eclipse.jetty.util.thread.ShutdownThread;
 import org.eclipse.jetty.util.thread.ThreadPool;

 /* ------------------------------------------------------------ */
 /** Jetty HTTP Servlet Server.
  * This class is the main class for the Jetty HTTP Servlet server.
  * It aggregates Connectors (HTTP request receivers) and request Handlers.
  * The server is itself a handler and a ThreadPool.  Connectors use the ThreadPool methods
  * to run jobs that will eventually call the handle method.
  *
  *  @org.apache.xbean.XBean  description="Creates an embedded Jetty web server"
  */
 public class Server extends HandlerWrapper implements Attributes
 {
     private static final Logger LOG = Log.getLogger(Server.class);

     private static final String __version;
     static
     {
         if (Server.class.getPackage()!=null &&
             "Eclipse.org - Jetty".equals(Server.class.getPackage().getImplementationVendor()) &&
              Server.class.getPackage().getImplementationVersion()!=null)
             __version=Server.class.getPackage().getImplementationVersion();
         else
             __version=System.getProperty("jetty.version","8.y.z-SNAPSHOT");
     }

     private final Container _container=new Container();
     private final AttributesMap _attributes = new AttributesMap();
     private ThreadPool _threadPool;
     private Connector[] _connectors;
     private SessionIdManager _sessionIdManager;
     private boolean _sendServerVersion = true; //send Server: header
     private boolean _sendDateHeader = false; //send Date: header
     private int _graceful=0;
     private boolean _stopAtShutdown;
     private boolean _dumpAfterStart=false;
     private boolean _dumpBeforeStop=false;
     private boolean _uncheckedPrintWriter=false;


     /* ------------------------------------------------------------ */
     public Server()
     {
         setServer(this);
     }

     /* ------------------------------------------------------------ */
     /** Convenience constructor
      * Creates server and a {@link SelectChannelConnector} at the passed port.
      */
     public Server(int port)
     {
         setServer(this);

         Connector connector=new SelectChannelConnector();
         connector.setPort(port);
         setConnectors(new Connector[]{connector});
     }

     /* ------------------------------------------------------------ */
     /** Convenience constructor
      * Creates server and a {@link SelectChannelConnector} at the passed address.
      */
     public Server(InetSocketAddress addr)
     {
         setServer(this);

         Connector connector=new SelectChannelConnector();
         connector.setHost(addr.getHostName());
         connector.setPort(addr.getPort());
         setConnectors(new Connector[]{connector});
     }


     /* ------------------------------------------------------------ */
     public static String getVersion()
     {
         return __version;
     }

     /* ------------------------------------------------------------ */
     /**
      * @return Returns the container.
      */
     public Container getContainer()
     {
         return _container;
     }

     /* ------------------------------------------------------------ */
     public boolean getStopAtShutdown()
     {
         return _stopAtShutdown;
     }

     /* ------------------------------------------------------------ */
     public void setStopAtShutdown(boolean stop)
     {
         //if we now want to stop
         if (stop)
         {
             //and we weren't stopping before
             if (!_stopAtShutdown)
             {
                 //only register to stop if we're already started (otherwise we'll do it in doStart())
                 if (isStarted())
                     ShutdownThread.register(this);
             }
         }
         else
             ShutdownThread.deregister(this);

         _stopAtShutdown=stop;
     }

     /* ------------------------------------------------------------ */
     /**
      * @return Returns the connectors.
      */
     public Connector[] getConnectors()
     {
         return _connectors;
     }

     /* ------------------------------------------------------------ */
     public void addConnector(Connector connector)
     {
         setConnectors((Connector[])LazyList.addToArray(getConnectors(), connector, Connector.class));
     }

     /* ------------------------------------------------------------ */
     /**
      * Conveniance method which calls {@link #getConnectors()} and {@link #setConnectors(Connector[])} to
      * remove a connector.
      * @param connector The connector to remove.
      */
     public void removeConnector(Connector connector) {
         setConnectors((Connector[])LazyList.removeFromArray (getConnectors(), connector));
     }

     /* ------------------------------------------------------------ */
     /** Set the connectors for this server.
      * Each connector has this server set as it's ThreadPool and its Handler.
      * @param connectors The connectors to set.
      */
     public void setConnectors(Connector[] connectors)
     {
         if (connectors!=null)
         {
             for (int i=0;i<connectors.length;i++)
                 connectors[i].setServer(this);
         }

         _container.update(this, _connectors, connectors, "connector");
         _connectors = connectors;
     }

     /* ------------------------------------------------------------ */
     /**
      * @return Returns the threadPool.
      */
     public ThreadPool getThreadPool()
     {
         return _threadPool;
     }

     /* ------------------------------------------------------------ */
     /**
      * @param threadPool The threadPool to set.
      */
     public void setThreadPool(ThreadPool threadPool)
     {
         if (_threadPool!=null)
             removeBean(_threadPool);
         _container.update(this, _threadPool, threadPool, "threadpool",false);
         _threadPool = threadPool;
         if (_threadPool!=null)
             addBean(_threadPool);
     }

     /**
      * @return true if {@link #dumpStdErr()} is called after starting
      */
     public boolean isDumpAfterStart()
     {
         return _dumpAfterStart;
     }

     /**
      * @param dumpAfterStart true if {@link #dumpStdErr()} is called after starting
      */
     public void setDumpAfterStart(boolean dumpAfterStart)
     {
         _dumpAfterStart = dumpAfterStart;
     }

     /**
      * @return true if {@link #dumpStdErr()} is called before stopping
      */
     public boolean isDumpBeforeStop()
     {
         return _dumpBeforeStop;
     }

     /**
      * @param dumpBeforeStop true if {@link #dumpStdErr()} is called before stopping
      */
     public void setDumpBeforeStop(boolean dumpBeforeStop)
     {
         _dumpBeforeStop = dumpBeforeStop;
     }


     /* ------------------------------------------------------------ */
     @Override
     protected void doStart() throws Exception
     {
         if (getStopAtShutdown())
         {
             ShutdownThread.register(this);
         }

         ShutdownMonitor.getInstance().start(); // initialize

         LOG.info("jetty-"+__version);
         HttpGenerator.setServerVersion(__version);

         MultiException mex=new MultiException();

         if (_threadPool==null)
             setThreadPool(new QueuedThreadPool());

         try
         {
             super.doStart();
         }
         catch(Throwable e)
         {
             mex.add(e);
         }

         if (_connectors!=null && mex.size()==0)
         {
             for (int i=0;i<_connectors.length;i++)
             {
                 try{_connectors[i].start();}
                 catch(Throwable e)
                 {
                     mex.add(e);
                 }
             }
         }

         if (isDumpAfterStart())
             dumpStdErr();

         mex.ifExceptionThrow();
     }

     /* ------------------------------------------------------------ */
     @Override
     protected void doStop() throws Exception
     {
         if (isDumpBeforeStop())
             dumpStdErr();

         MultiException mex=new MultiException();

         if (_graceful>0)
         {
             if (_connectors!=null)
             {
                 for (int i=_connectors.length;i-->0;)
                 {
                     LOG.info("Graceful shutdown {}",_connectors[i]);
                     try{_connectors[i].close();}catch(Throwable e){mex.add(e);}
                 }
             }

             Handler[] contexts = getChildHandlersByClass(Graceful.class);
             for (int c=0;c<contexts.length;c++)
             {
                 Graceful context=(Graceful)contexts[c];
                 LOG.info("Graceful shutdown {}",context);
                 context.setShutdown(true);
             }
             Thread.sleep(_graceful);
         }

         if (_connectors!=null)
         {
             for (int i=_connectors.length;i-->0;)
                 try{_connectors[i].stop();}catch(Throwable e){mex.add(e);}
         }

         try {super.doStop(); } catch(Throwable e) { mex.add(e);}

         mex.ifExceptionThrow();

         if (getStopAtShutdown())
             ShutdownThread.deregister(this);
     }

     /* ------------------------------------------------------------ */
     /* Handle a request from a connection.
      * Called to handle a request on the connection when either the header has been received,
      * or after the entire request has been received (for short requests of known length), or
      * on the dispatch of an async request.
      */
     public void handle(AbstractHttpConnection connection) throws IOException, ServletException
     {
         final String target=connection.getRequest().getPathInfo();
         final Request request=connection.getRequest();
         final Response response=connection.getResponse();

         if (LOG.isDebugEnabled())
         {
             LOG.debug("REQUEST "+target+" on "+connection);
             handle(target, request, request, response);
             LOG.debug("RESPONSE "+target+"  "+connection.getResponse().getStatus()+" handled="+request.isHandled());
         }
         else
             handle(target, request, request, response);
     }

     /* ------------------------------------------------------------ */
     /* Handle a request from a connection.
      * Called to handle a request on the connection when either the header has been received,
      * or after the entire request has been received (for short requests of known length), or
      * on the dispatch of an async request.
      */
     public void handleAsync(AbstractHttpConnection connection) throws IOException, ServletException
     {
         final AsyncContinuation async = connection.getRequest().getAsyncContinuation();
         final AsyncContinuation.AsyncEventState state = async.getAsyncEventState();

         final Request baseRequest=connection.getRequest();
         final String path=state.getPath();

         if (path!=null)
         {
             // this is a dispatch with a path
             final String contextPath=state.getServletContext().getContextPath();
             HttpURI uri = new HttpURI(URIUtil.addPaths(contextPath,path));
             baseRequest.setUri(uri);
             baseRequest.setRequestURI(null);
             baseRequest.setPathInfo(baseRequest.getRequestURI());
             if (uri.getQuery()!=null)
                 baseRequest.mergeQueryString(uri.getQuery()); //we have to assume dispatch path and query are UTF8
         }

         final String target=baseRequest.getPathInfo();
         final HttpServletRequest request=(HttpServletRequest)async.getRequest();
         final HttpServletResponse response=(HttpServletResponse)async.getResponse();

         if (LOG.isDebugEnabled())
         {
             LOG.debug("REQUEST "+target+" on "+connection);
             handle(target, baseRequest, request, response);
             LOG.debug("RESPONSE "+target+"  "+connection.getResponse().getStatus());
         }
         else
             handle(target, baseRequest, request, response);

     }


     /* ------------------------------------------------------------ */
     public void join() throws InterruptedException
     {
         getThreadPool().join();
     }

     /* ------------------------------------------------------------ */
     /* ------------------------------------------------------------ */
     /**
      * @return Returns the sessionIdManager.
      */
     public SessionIdManager getSessionIdManager()
     {
         return _sessionIdManager;
     }

     /* ------------------------------------------------------------ */
     /* ------------------------------------------------------------ */
     /**
      * @param sessionIdManager The sessionIdManager to set.
      */
     public void setSessionIdManager(SessionIdManager sessionIdManager)
     {
         if (_sessionIdManager!=null)
             removeBean(_sessionIdManager);
         _container.update(this, _sessionIdManager, sessionIdManager, "sessionIdManager",false);
         _sessionIdManager = sessionIdManager;
         if (_sessionIdManager!=null)
             addBean(_sessionIdManager);
     }

     /* ------------------------------------------------------------ */
     public void setSendServerVersion (boolean sendServerVersion)
     {
         _sendServerVersion = sendServerVersion;
     }

     /* ------------------------------------------------------------ */
     public boolean getSendServerVersion()
     {
         return _sendServerVersion;
     }

     /* ------------------------------------------------------------ */
     /**
      * @param sendDateHeader
      */
     public void setSendDateHeader(boolean sendDateHeader)
     {
         _sendDateHeader = sendDateHeader;
     }

     /* ------------------------------------------------------------ */
     public boolean getSendDateHeader()
     {
         return _sendDateHeader;
     }

     /* ------------------------------------------------------------ */
     /**
      */
     @Deprecated
     public int getMaxCookieVersion()
     {
         return 1;
     }

     /* ------------------------------------------------------------ */
     /**
      */
     @Deprecated
     public void setMaxCookieVersion(int maxCookieVersion)
     {
     }

     /* ------------------------------------------------------------ */
     /**
      * Add a LifeCycle object to be started/stopped
      * along with the Server.
      * @deprecated Use {@link #addBean(Object)}
      * @param c
      */
     @Deprecated
     public void addLifeCycle (LifeCycle c)
     {
         addBean(c);
     }

     /* ------------------------------------------------------------ */
     /**
      * Add an associated bean.
      * The bean will be added to the servers {@link Container}
      * and if it is a {@link LifeCycle} instance, it will be
      * started/stopped along with the Server. Any beans that are also
      * {@link Destroyable}, will be destroyed with the server.
      * @param o the bean object to add
      */
     @Override
     public boolean addBean(Object o)
     {
         if (super.addBean(o))
         {
             _container.addBean(o);
             return true;
         }
         return false;
     }

     /**
      * Remove a LifeCycle object to be started/stopped
      * along with the Server
      * @deprecated Use {@link #removeBean(Object)}
      */
     @Deprecated
     public void removeLifeCycle (LifeCycle c)
     {
         removeBean(c);
     }

     /* ------------------------------------------------------------ */
     /**
      * Remove an associated bean.
      */
     @Override
     public boolean removeBean (Object o)
     {
         if (super.removeBean(o))
         {
             _container.removeBean(o);
             return true;
         }
         return false;
     }

     /* ------------------------------------------------------------ */
     /*
      * @see org.eclipse.util.AttributesMap#clearAttributes()
      */
     public void clearAttributes()
     {
         _attributes.clearAttributes();
     }

     /* ------------------------------------------------------------ */
     /*
      * @see org.eclipse.util.AttributesMap#getAttribute(java.lang.String)
      */
     public Object getAttribute(String name)
     {
         return _attributes.getAttribute(name);
     }

     /* ------------------------------------------------------------ */
     /*
      * @see org.eclipse.util.AttributesMap#getAttributeNames()
      */
     public Enumeration getAttributeNames()
     {
         return AttributesMap.getAttributeNamesCopy(_attributes);
     }

     /* ------------------------------------------------------------ */
     /*
      * @see org.eclipse.util.AttributesMap#removeAttribute(java.lang.String)
      */
     public void removeAttribute(String name)
     {
         _attributes.removeAttribute(name);
     }

     /* ------------------------------------------------------------ */
     /*
      * @see org.eclipse.util.AttributesMap#setAttribute(java.lang.String, java.lang.Object)
      */
     public void setAttribute(String name, Object attribute)
     {
         _attributes.setAttribute(name, attribute);
     }

     /* ------------------------------------------------------------ */
     /**
      * @return the graceful
      */
     public int getGracefulShutdown()
     {
         return _graceful;
     }

     /* ------------------------------------------------------------ */
     /**
      * Set graceful shutdown timeout.  If set, the internal <code>doStop()</code> method will not immediately stop the
      * server. Instead, all {@link Connector}s will be closed so that new connections will not be accepted
      * and all handlers that implement {@link Graceful} will be put into the shutdown mode so that no new requests
      * will be accepted, but existing requests can complete.  The server will then wait the configured timeout
      * before stopping.
      * @param timeoutMS the milliseconds to wait for existing request to complete before stopping the server.
      *
      */
     public void setGracefulShutdown(int timeoutMS)
     {
         _graceful=timeoutMS;
     }

     /* ------------------------------------------------------------ */
     @Override
     public String toString()
     {
         return this.getClass().getName()+"@"+Integer.toHexString(hashCode());
     }

     /* ------------------------------------------------------------ */
     @Override
     public void dump(Appendable out,String indent) throws IOException
     {
         dumpThis(out);
         dump(out,indent,TypeUtil.asList(getHandlers()),getBeans(),TypeUtil.asList(_connectors));
     }


     /* ------------------------------------------------------------ */
     public boolean isUncheckedPrintWriter()
     {
         return _uncheckedPrintWriter;
     }

     /* ------------------------------------------------------------ */
     public void setUncheckedPrintWriter(boolean unchecked)
     {
         _uncheckedPrintWriter=unchecked;
     }


     /* ------------------------------------------------------------ */
     /* A handler that can be gracefully shutdown.
      * Called by doStop if a {@link #setGracefulShutdown} period is set.
      * TODO move this somewhere better
      */
     public interface Graceful extends Handler
     {
         public void setShutdown(boolean shutdown);
     }

     /* ------------------------------------------------------------ */
     public static void main(String...args) throws Exception
     {
         System.err.println(getVersion());
     }
 }
	//
	// ========================================================================
	// Copyright (c) 1995-2014 Mort Bay Consulting Pty. Ltd.
	// ------------------------------------------------------------------------
	// 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
	//
	// 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.
	// ========================================================================
	//

	package org.eclipse.jetty.server;

	import java.io.IOException;
	import java.net.InetSocketAddress;
	import java.util.Enumeration;

	import javax.servlet.AsyncContext;
	import javax.servlet.ServletException;
	import javax.servlet.http.HttpServletRequest;
	import javax.servlet.http.HttpServletResponse;

	import org.eclipse.jetty.http.HttpGenerator;
	import org.eclipse.jetty.http.HttpURI;
	import org.eclipse.jetty.server.handler.HandlerWrapper;
	import org.eclipse.jetty.server.nio.SelectChannelConnector;
	import org.eclipse.jetty.util.Attributes;
	import org.eclipse.jetty.util.AttributesMap;
	import org.eclipse.jetty.util.LazyList;
	import org.eclipse.jetty.util.MultiException;
	import org.eclipse.jetty.util.TypeUtil;
	import org.eclipse.jetty.util.URIUtil;
	import org.eclipse.jetty.util.component.Container;
	import org.eclipse.jetty.util.component.Destroyable;
	import org.eclipse.jetty.util.component.LifeCycle;
	import org.eclipse.jetty.util.log.Log;
	import org.eclipse.jetty.util.log.Logger;
	import org.eclipse.jetty.util.thread.QueuedThreadPool;
	import org.eclipse.jetty.util.thread.ShutdownThread;
	import org.eclipse.jetty.util.thread.ThreadPool;

	/* ------------------------------------------------------------ */
	/** Jetty HTTP Servlet Server.
	* This class is the main class for the Jetty HTTP Servlet server.
	* It aggregates Connectors (HTTP request receivers) and request Handlers.
	* The server is itself a handler and a ThreadPool. Connectors use the ThreadPool methods
	* to run jobs that will eventually call the handle method.
	*
	* @org.apache.xbean.XBean description="Creates an embedded Jetty web server"
	*/
	public class Server extends HandlerWrapper implements Attributes
	{
	private static final Logger LOG = Log.getLogger(Server.class);

	private static final String __version;
	static
	{
	if (Server.class.getPackage()!=null &&
	"Eclipse.org - Jetty".equals(Server.class.getPackage().getImplementationVendor()) &&
	Server.class.getPackage().getImplementationVersion()!=null)
	__version=Server.class.getPackage().getImplementationVersion();
	else
	__version=System.getProperty("jetty.version","8.y.z-SNAPSHOT");
	}

	private final Container _container=new Container();
	private final AttributesMap _attributes = new AttributesMap();
	private ThreadPool _threadPool;
	private Connector[] _connectors;
	private SessionIdManager _sessionIdManager;
	private boolean _sendServerVersion = true; //send Server: header
	private boolean _sendDateHeader = false; //send Date: header
	private int _graceful=0;
	private boolean _stopAtShutdown;
	private boolean _dumpAfterStart=false;
	private boolean _dumpBeforeStop=false;
	private boolean _uncheckedPrintWriter=false;


	/* ------------------------------------------------------------ */
	public Server()
	{
	setServer(this);
	}

	/* ------------------------------------------------------------ */
	/** Convenience constructor
	* Creates server and a {@link SelectChannelConnector} at the passed port.
	*/
	public Server(int port)
	{
	setServer(this);

	Connector connector=new SelectChannelConnector();
	connector.setPort(port);
	setConnectors(new Connector[]{connector});
	}

	/* ------------------------------------------------------------ */
	/** Convenience constructor
	* Creates server and a {@link SelectChannelConnector} at the passed address.
	*/
	public Server(InetSocketAddress addr)
	{
	setServer(this);

	Connector connector=new SelectChannelConnector();
	connector.setHost(addr.getHostName());
	connector.setPort(addr.getPort());
	setConnectors(new Connector[]{connector});
	}


	/* ------------------------------------------------------------ */
	public static String getVersion()
	{
	return __version;
	}

	/* ------------------------------------------------------------ */
	/**
	* @return Returns the container.
	*/
	public Container getContainer()
	{
	return _container;
	}

	/* ------------------------------------------------------------ */
	public boolean getStopAtShutdown()
	{
	return _stopAtShutdown;
	}

	/* ------------------------------------------------------------ */
	public void setStopAtShutdown(boolean stop)
	{
	//if we now want to stop
	if (stop)
	{
	//and we weren't stopping before
	if (!_stopAtShutdown)
	{
	//only register to stop if we're already started (otherwise we'll do it in doStart())
	if (isStarted())
	ShutdownThread.register(this);
	}
	}
	else
	ShutdownThread.deregister(this);

	_stopAtShutdown=stop;
	}

	/* ------------------------------------------------------------ */
	/**
	* @return Returns the connectors.
	*/
	public Connector[] getConnectors()
	{
	return _connectors;
	}

	/* ------------------------------------------------------------ */
	public void addConnector(Connector connector)
	{
	setConnectors((Connector[])LazyList.addToArray(getConnectors(), connector, Connector.class));
	}

	/* ------------------------------------------------------------ */
	/**
	* Conveniance method which calls {@link #getConnectors()} and {@link #setConnectors(Connector[])} to
	* remove a connector.
	* @param connector The connector to remove.
	*/
	public void removeConnector(Connector connector) {
	setConnectors((Connector[])LazyList.removeFromArray (getConnectors(), connector));
	}

	/* ------------------------------------------------------------ */
	/** Set the connectors for this server.
	* Each connector has this server set as it's ThreadPool and its Handler.
	* @param connectors The connectors to set.
	*/
	public void setConnectors(Connector[] connectors)
	{
	if (connectors!=null)
	{
	for (int i=0;i<connectors.length;i++)
	connectors[i].setServer(this);
	}

	_container.update(this, _connectors, connectors, "connector");
	_connectors = connectors;
	}

	/* ------------------------------------------------------------ */
	/**
	* @return Returns the threadPool.
	*/
	public ThreadPool getThreadPool()
	{
	return _threadPool;
	}

	/* ------------------------------------------------------------ */
	/**
	* @param threadPool The threadPool to set.
	*/
	public void setThreadPool(ThreadPool threadPool)
	{
	if (_threadPool!=null)
	removeBean(_threadPool);
	_container.update(this, _threadPool, threadPool, "threadpool",false);
	_threadPool = threadPool;
	if (_threadPool!=null)
	addBean(_threadPool);
	}

	/**
	* @return true if {@link #dumpStdErr()} is called after starting
	*/
	public boolean isDumpAfterStart()
	{
	return _dumpAfterStart;
	}

	/**
	* @param dumpAfterStart true if {@link #dumpStdErr()} is called after starting
	*/
	public void setDumpAfterStart(boolean dumpAfterStart)
	{
	_dumpAfterStart = dumpAfterStart;
	}

	/**
	* @return true if {@link #dumpStdErr()} is called before stopping
	*/
	public boolean isDumpBeforeStop()
	{
	return _dumpBeforeStop;
	}

	/**
	* @param dumpBeforeStop true if {@link #dumpStdErr()} is called before stopping
	*/
	public void setDumpBeforeStop(boolean dumpBeforeStop)
	{
	_dumpBeforeStop = dumpBeforeStop;
	}



	/* ------------------------------------------------------------ */
	@Override
	protected void doStart() throws Exception
	{
	if (getStopAtShutdown())
	{
	ShutdownThread.register(this);
	}

	ShutdownMonitor.getInstance().start(); // initialize

	LOG.info("jetty-"+__version);
	HttpGenerator.setServerVersion(__version);

	MultiException mex=new MultiException();

	if (_threadPool==null)
	setThreadPool(new QueuedThreadPool());

	try
	{
	super.doStart();
	}
	catch(Throwable e)
	{
	mex.add(e);
	}

	if (_connectors!=null && mex.size()==0)
	{
	for (int i=0;i<_connectors.length;i++)
	{
	try{_connectors[i].start();}
	catch(Throwable e)
	{
	mex.add(e);
	}
	}
	}

	if (isDumpAfterStart())
	dumpStdErr();

	mex.ifExceptionThrow();
	}

	/* ------------------------------------------------------------ */
	@Override
	protected void doStop() throws Exception
	{
	if (isDumpBeforeStop())
	dumpStdErr();

	MultiException mex=new MultiException();

	if (_graceful>0)
	{
	if (_connectors!=null)
	{
	for (int i=_connectors.length;i-->0;)
	{
	LOG.info("Graceful shutdown {}",_connectors[i]);
	try{_connectors[i].close();}catch(Throwable e){mex.add(e);}
	}
	}

	Handler[] contexts = getChildHandlersByClass(Graceful.class);
	for (int c=0;c<contexts.length;c++)
	{
	Graceful context=(Graceful)contexts[c];
	LOG.info("Graceful shutdown {}",context);
	context.setShutdown(true);
	}
	Thread.sleep(_graceful);
	}

	if (_connectors!=null)
	{
	for (int i=_connectors.length;i-->0;)
	try{_connectors[i].stop();}catch(Throwable e){mex.add(e);}
	}

	try {super.doStop(); } catch(Throwable e) { mex.add(e);}

	mex.ifExceptionThrow();

	if (getStopAtShutdown())
	ShutdownThread.deregister(this);
	}

	/* ------------------------------------------------------------ */
	/* Handle a request from a connection.
	* Called to handle a request on the connection when either the header has been received,
	* or after the entire request has been received (for short requests of known length), or
	* on the dispatch of an async request.
	*/
	public void handle(AbstractHttpConnection connection) throws IOException, ServletException
	{
	final String target=connection.getRequest().getPathInfo();
	final Request request=connection.getRequest();
	final Response response=connection.getResponse();

	if (LOG.isDebugEnabled())
	{
	LOG.debug("REQUEST "+target+" on "+connection);
	handle(target, request, request, response);
	LOG.debug("RESPONSE "+target+" "+connection.getResponse().getStatus()+" handled="+request.isHandled());
	}
	else
	handle(target, request, request, response);
	}

	/* ------------------------------------------------------------ */
	/* Handle a request from a connection.
	* Called to handle a request on the connection when either the header has been received,
	* or after the entire request has been received (for short requests of known length), or
	* on the dispatch of an async request.
	*/
	public void handleAsync(AbstractHttpConnection connection) throws IOException, ServletException
	{
	final AsyncContinuation async = connection.getRequest().getAsyncContinuation();
	final AsyncContinuation.AsyncEventState state = async.getAsyncEventState();

	final Request baseRequest=connection.getRequest();
	final String path=state.getPath();

	if (path!=null)
	{
	// this is a dispatch with a path
	final String contextPath=state.getServletContext().getContextPath();
	HttpURI uri = new HttpURI(URIUtil.addPaths(contextPath,path));
	baseRequest.setUri(uri);
	baseRequest.setRequestURI(null);
	baseRequest.setPathInfo(baseRequest.getRequestURI());
	if (uri.getQuery()!=null)
	baseRequest.mergeQueryString(uri.getQuery()); //we have to assume dispatch path and query are UTF8
	}

	final String target=baseRequest.getPathInfo();
	final HttpServletRequest request=(HttpServletRequest)async.getRequest();
	final HttpServletResponse response=(HttpServletResponse)async.getResponse();

	if (LOG.isDebugEnabled())
	{
	LOG.debug("REQUEST "+target+" on "+connection);
	handle(target, baseRequest, request, response);
	LOG.debug("RESPONSE "+target+" "+connection.getResponse().getStatus());
	}
	else
	handle(target, baseRequest, request, response);

	}


	/* ------------------------------------------------------------ */
	public void join() throws InterruptedException
	{
	getThreadPool().join();
	}

	/* ------------------------------------------------------------ */
	/* ------------------------------------------------------------ */
	/**
	* @return Returns the sessionIdManager.
	*/
	public SessionIdManager getSessionIdManager()
	{
	return _sessionIdManager;
	}

	/* ------------------------------------------------------------ */
	/* ------------------------------------------------------------ */
	/**
	* @param sessionIdManager The sessionIdManager to set.
	*/
	public void setSessionIdManager(SessionIdManager sessionIdManager)
	{
	if (_sessionIdManager!=null)
	removeBean(_sessionIdManager);
	_container.update(this, _sessionIdManager, sessionIdManager, "sessionIdManager",false);
	_sessionIdManager = sessionIdManager;
	if (_sessionIdManager!=null)
	addBean(_sessionIdManager);
	}

	/* ------------------------------------------------------------ */
	public void setSendServerVersion (boolean sendServerVersion)
	{
	_sendServerVersion = sendServerVersion;
	}

	/* ------------------------------------------------------------ */
	public boolean getSendServerVersion()
	{
	return _sendServerVersion;
	}

	/* ------------------------------------------------------------ */
	/**
	* @param sendDateHeader
	*/
	public void setSendDateHeader(boolean sendDateHeader)
	{
	_sendDateHeader = sendDateHeader;
	}

	/* ------------------------------------------------------------ */
	public boolean getSendDateHeader()
	{
	return _sendDateHeader;
	}

	/* ------------------------------------------------------------ */
	/**
	*/
	@Deprecated
	public int getMaxCookieVersion()
	{
	return 1;
	}

	/* ------------------------------------------------------------ */
	/**
	*/
	@Deprecated
	public void setMaxCookieVersion(int maxCookieVersion)
	{
	}

	/* ------------------------------------------------------------ */
	/**
	* Add a LifeCycle object to be started/stopped
	* along with the Server.
	* @deprecated Use {@link #addBean(Object)}
	* @param c
	*/
	@Deprecated
	public void addLifeCycle (LifeCycle c)
	{
	addBean(c);
	}

	/* ------------------------------------------------------------ */
	/**
	* Add an associated bean.
	* The bean will be added to the servers {@link Container}
	* and if it is a {@link LifeCycle} instance, it will be
	* started/stopped along with the Server. Any beans that are also
	* {@link Destroyable}, will be destroyed with the server.
	* @param o the bean object to add
	*/
	@Override
	public boolean addBean(Object o)
	{
	if (super.addBean(o))
	{
	_container.addBean(o);
	return true;
	}
	return false;
	}

	/**
	* Remove a LifeCycle object to be started/stopped
	* along with the Server
	* @deprecated Use {@link #removeBean(Object)}
	*/
	@Deprecated
	public void removeLifeCycle (LifeCycle c)
	{
	removeBean(c);
	}

	/* ------------------------------------------------------------ */
	/**
	* Remove an associated bean.
	*/
	@Override
	public boolean removeBean (Object o)
	{
	if (super.removeBean(o))
	{
	_container.removeBean(o);
	return true;
	}
	return false;
	}

	/* ------------------------------------------------------------ */
	/*
	* @see org.eclipse.util.AttributesMap#clearAttributes()
	*/
	public void clearAttributes()
	{
	_attributes.clearAttributes();
	}

	/* ------------------------------------------------------------ */
	/*
	* @see org.eclipse.util.AttributesMap#getAttribute(java.lang.String)
	*/
	public Object getAttribute(String name)
	{
	return _attributes.getAttribute(name);
	}

	/* ------------------------------------------------------------ */
	/*
	* @see org.eclipse.util.AttributesMap#getAttributeNames()
	*/
	public Enumeration getAttributeNames()
	{
	return AttributesMap.getAttributeNamesCopy(_attributes);
	}

	/* ------------------------------------------------------------ */
	/*
	* @see org.eclipse.util.AttributesMap#removeAttribute(java.lang.String)
	*/
	public void removeAttribute(String name)
	{
	_attributes.removeAttribute(name);
	}

	/* ------------------------------------------------------------ */
	/*
	* @see org.eclipse.util.AttributesMap#setAttribute(java.lang.String, java.lang.Object)
	*/
	public void setAttribute(String name, Object attribute)
	{
	_attributes.setAttribute(name, attribute);
	}

	/* ------------------------------------------------------------ */
	/**
	* @return the graceful
	*/
	public int getGracefulShutdown()
	{
	return _graceful;
	}

	/* ------------------------------------------------------------ */
	/**
	* Set graceful shutdown timeout. If set, the internal <code>doStop()</code> method will not immediately stop the
	* server. Instead, all {@link Connector}s will be closed so that new connections will not be accepted
	* and all handlers that implement {@link Graceful} will be put into the shutdown mode so that no new requests
	* will be accepted, but existing requests can complete. The server will then wait the configured timeout
	* before stopping.
	* @param timeoutMS the milliseconds to wait for existing request to complete before stopping the server.
	*
	*/
	public void setGracefulShutdown(int timeoutMS)
	{
	_graceful=timeoutMS;
	}

	/* ------------------------------------------------------------ */
	@Override
	public String toString()
	{
	return this.getClass().getName()+"@"+Integer.toHexString(hashCode());
	}

	/* ------------------------------------------------------------ */
	@Override
	public void dump(Appendable out,String indent) throws IOException
	{
	dumpThis(out);
	dump(out,indent,TypeUtil.asList(getHandlers()),getBeans(),TypeUtil.asList(_connectors));
	}


	/* ------------------------------------------------------------ */
	public boolean isUncheckedPrintWriter()
	{
	return _uncheckedPrintWriter;
	}

	/* ------------------------------------------------------------ */
	public void setUncheckedPrintWriter(boolean unchecked)
	{
	_uncheckedPrintWriter=unchecked;
	}


	/* ------------------------------------------------------------ */
	/* A handler that can be gracefully shutdown.
	* Called by doStop if a {@link #setGracefulShutdown} period is set.
	* TODO move this somewhere better
	*/
	public interface Graceful extends Handler
	{
	public void setShutdown(boolean shutdown);
	}

	/* ------------------------------------------------------------ */
	public static void main(String...args) throws Exception
	{
	System.err.println(getVersion());
	}
	}