src/jalview/httpserver/HttpServer.java

   1 package jalview.httpserver;
   2
   3 import jalview.rest.RestHandler;
   4
   5 import java.net.BindException;
   6 import java.net.URI;
   7 import java.util.Collections;
   8 import java.util.HashMap;
   9 import java.util.Map;
  10
  11 import javax.servlet.http.HttpServletRequest;
  12 import javax.servlet.http.HttpServletResponse;
  13
  14 import org.eclipse.jetty.server.Handler;
  15 import org.eclipse.jetty.server.Server;
  16 import org.eclipse.jetty.server.ServerConnector;
  17 import org.eclipse.jetty.server.handler.ContextHandler;
  18 import org.eclipse.jetty.server.handler.HandlerCollection;
  19 import org.eclipse.jetty.util.thread.QueuedThreadPool;
  20
  21 /**
  22  * An HttpServer built on Jetty. To use it
  23  * <ul>
  24  * <li>call getInstance() to create and start the server</li>
  25  * <li>call registerHandler to add a handler for a path (below /jalview)</li>
  26  * <li>when finished, call removedHandler</li>
  27  * </ul>
  28  *
  29  * @author gmcarstairs
  30  * @see http://eclipse.org/jetty/documentation/current/embedding-jetty.html
  31  */
  32 public class HttpServer
  33 {
  34   /*
  35    * 'context root' - actually just prefixed to the path for each handler for
  36    * now - see registerHandler
  37    */
  38   private static final String JALVIEW_PATH = "jalview";
  39
  40   /*
  41    * Singleton instance of this server
  42    */
  43   private static HttpServer instance;
  44
  45   /*
  46    * The Http server
  47    */
  48   private Server server;
  49
  50   /*
  51    * Registered handlers for context paths
  52    */
  53   private HandlerCollection contextHandlers;
  54
  55   /*
  56    * Lookup of ContextHandler by its wrapped handler
  57    */
  58   Map<Handler, ContextHandler> myHandlers = new HashMap<Handler, ContextHandler>();
  59
  60   /*
  61    * The context root for the server
  62    */
  63   private URI contextRoot;
  64
  65   /**
  66    * Returns the singleton instance of this class.
  67    *
  68    * @return
  69    * @throws BindException
  70    */
  71   public static HttpServer getInstance() throws BindException
  72   {
  73     synchronized (HttpServer.class)
  74     {
  75       if (instance == null) {
  76         instance = new HttpServer();
  77       }
  78       return instance;
  79     }
  80   }
  81
  82   /**
  83    * Private constructor to enforce use of singleton
  84    *
  85    * @throws BindException
  86    *           if no free port can be assigned
  87    */
  88   private HttpServer() throws BindException
  89   {
  90     startServer();
  91
  92     /*
  93      * Provides a REST server by default; add more programmatically as required
  94      */
  95     registerHandler(RestHandler.getInstance());
  96   }
  97
  98   /**
  99    * Start the http server
 100    *
 101    * @throws BindException
 102    */
 103   private void startServer() throws BindException
 104   {
 105     try
 106     {
 107       /*
 108        * Create a server with a small number of threads; jetty will allocate a
 109        * free port
 110        */
 111       QueuedThreadPool tp = new QueuedThreadPool(4, 1); // max, min
 112       server = new Server(tp);
 113       // 2 selector threads to handle incoming connections
 114       ServerConnector connector = new ServerConnector(server, 0, 2);
 115       server.addConnector(connector);
 116
 117       /*
 118        * HttpServer shuts down with Jalview process
 119        */
 120       server.setStopAtShutdown(true);
 121
 122       /*
 123        * Create a mutable set of handlers (can add handlers while the server is
 124        * running). Using vanilla handlers here rather than servlets
 125        */
 126       // TODO how to properly configure context root "/jalview"
 127       contextHandlers = new HandlerCollection(true);
 128       server.setHandler(contextHandlers);
 129       server.start();
 130       // System.out.println(String.format(
 131       // "HttpServer started with %d threads", server.getThreadPool()
 132       // .getThreads()));
 133       contextRoot = server.getURI();
 134     } catch (Exception e)
 135     {
 136       System.err.println("Error trying to start HttpServer: "
 137               + e.getMessage());
 138       try
 139       {
 140         server.stop();
 141       } catch (Exception e1)
 142       {
 143         e1.printStackTrace();
 144       }
 145     }
 146     if (server == null)
 147     {
 148       throw new BindException("HttpServer failed to allocate a port");
 149     }
 150   }
 151
 152   /**
 153    * Returns the URI on which we are listening
 154    *
 155    * @return
 156    */
 157   public URI getUri()
 158   {
 159     return server == null ? null : server.getURI();
 160   }
 161
 162   /**
 163    * For debug - write HTTP request details to stdout
 164    *
 165    * @param request
 166    * @param response
 167    */
 168   protected void dumpRequest(HttpServletRequest request,
 169           HttpServletResponse response)
 170   {
 171     for (String hdr : Collections.list(request.getHeaderNames()))
 172     {
 173       for (String val : Collections.list(request.getHeaders(hdr)))
 174       {
 175         System.out.println(hdr + ": " + val);
 176       }
 177     }
 178     for (String param : Collections.list(request.getParameterNames()))
 179     {
 180       for (String val : request.getParameterValues(param))
 181       {
 182         System.out.println(param + "=" + val);
 183       }
 184     }
 185   }
 186
 187   /**
 188    * Stop the Http server.
 189    */
 190   public void stopServer()
 191   {
 192     if (server != null)
 193     {
 194       if (server.isStarted())
 195       {
 196         try
 197         {
 198           server.stop();
 199         } catch (Exception e)
 200         {
 201           System.err.println("Error stopping Http Server on "
 202                   + server.getURI() + ": " + e.getMessage());
 203         }
 204       }
 205     }
 206   }
 207
 208   /**
 209    * Register a handler for the given path and set its URI
 210    *
 211    * @param handler
 212    * @return
 213    * @throws IllegalStateException
 214    *           if handler path has not been set
 215    */
 216   public void registerHandler(AbstractRequestHandler handler)
 217   {
 218     String path = handler.getPath();
 219     if (path == null)
 220     {
 221       throw new IllegalStateException(
 222               "Must set handler path before registering handler");
 223     }
 224
 225     // http://stackoverflow.com/questions/20043097/jetty-9-embedded-adding-handlers-during-runtime
 226     ContextHandler ch = new ContextHandler();
 227     ch.setAllowNullPathInfo(true);
 228     ch.setContextPath("/" + JALVIEW_PATH + "/" + path);
 229     ch.setResourceBase(".");
 230     ch.setClassLoader(Thread.currentThread()
 231             .getContextClassLoader());
 232     ch.setHandler(handler);
 233
 234     /*
 235      * Remember the association so we can remove it later
 236      */
 237     this.myHandlers.put(handler, ch);
 238
 239     /*
 240      * A handler added to a running server must be started explicitly
 241      */
 242     contextHandlers.addHandler(ch);
 243     try
 244     {
 245       ch.start();
 246     } catch (Exception e)
 247     {
 248       System.err.println("Error starting handler for " + path + ": "
 249               + e.getMessage());
 250     }
 251
 252     handler.setUri(this.contextRoot + ch.getContextPath().substring(1));
 253     System.out.println("Jalview " + handler.getName()
 254             + " handler started on " + handler.getUri());
 255   }
 256
 257   /**
 258    * Removes the handler from the server; more precisely, remove the
 259    * ContextHandler wrapping the specified handler
 260    *
 261    * @param handler
 262    */
 263   public void removeHandler(AbstractRequestHandler handler)
 264   {
 265     /*
 266      * Have to use this cached lookup table since there is no method
 267      * ContextHandler.getHandler()
 268      */
 269     ContextHandler ch = myHandlers.get(handler);
 270     if (ch != null)
 271     {
 272       contextHandlers.removeHandler(ch);
 273       myHandlers.remove(handler);
 274       System.out.println("Stopped Jalview " + handler.getName()
 275               + " handler on " + handler.getUri());
 276     }
 277   }
 278 }