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       // restrict to localhost
 116       connector.setHost("localhost");
 117       server.addConnector(connector);
 118
 119       /*
 120        * HttpServer shuts down with Jalview process
 121        */
 122       server.setStopAtShutdown(true);
 123
 124       /*
 125        * Create a mutable set of handlers (can add handlers while the server is
 126        * running). Using vanilla handlers here rather than servlets
 127        */
 128       // TODO how to properly configure context root "/jalview"
 129       contextHandlers = new HandlerCollection(true);
 130       server.setHandler(contextHandlers);
 131       server.start();
 132       // System.out.println(String.format(
 133       // "HttpServer started with %d threads", server.getThreadPool()
 134       // .getThreads()));
 135       contextRoot = server.getURI();
 136     } catch (Exception e)
 137     {
 138       System.err.println("Error trying to start HttpServer: "
 139               + e.getMessage());
 140       try
 141       {
 142         server.stop();
 143       } catch (Exception e1)
 144       {
 145         e1.printStackTrace();
 146       }
 147     }
 148     if (server == null)
 149     {
 150       throw new BindException("HttpServer failed to allocate a port");
 151     }
 152   }
 153
 154   /**
 155    * Returns the URI on which we are listening
 156    *
 157    * @return
 158    */
 159   public URI getUri()
 160   {
 161     return server == null ? null : server.getURI();
 162   }
 163
 164   /**
 165    * For debug - write HTTP request details to stdout
 166    *
 167    * @param request
 168    * @param response
 169    */
 170   protected void dumpRequest(HttpServletRequest request,
 171           HttpServletResponse response)
 172   {
 173     for (String hdr : Collections.list(request.getHeaderNames()))
 174     {
 175       for (String val : Collections.list(request.getHeaders(hdr)))
 176       {
 177         System.out.println(hdr + ": " + val);
 178       }
 179     }
 180     for (String param : Collections.list(request.getParameterNames()))
 181     {
 182       for (String val : request.getParameterValues(param))
 183       {
 184         System.out.println(param + "=" + val);
 185       }
 186     }
 187   }
 188
 189   /**
 190    * Stop the Http server.
 191    */
 192   public void stopServer()
 193   {
 194     if (server != null)
 195     {
 196       if (server.isStarted())
 197       {
 198         try
 199         {
 200           server.stop();
 201         } catch (Exception e)
 202         {
 203           System.err.println("Error stopping Http Server on "
 204                   + server.getURI() + ": " + e.getMessage());
 205         }
 206       }
 207     }
 208   }
 209
 210   /**
 211    * Register a handler for the given path and set its URI
 212    *
 213    * @param handler
 214    * @return
 215    * @throws IllegalStateException
 216    *           if handler path has not been set
 217    */
 218   public void registerHandler(AbstractRequestHandler handler)
 219   {
 220     String path = handler.getPath();
 221     if (path == null)
 222     {
 223       throw new IllegalStateException(
 224               "Must set handler path before registering handler");
 225     }
 226
 227     // http://stackoverflow.com/questions/20043097/jetty-9-embedded-adding-handlers-during-runtime
 228     ContextHandler ch = new ContextHandler();
 229     ch.setAllowNullPathInfo(true);
 230     ch.setContextPath("/" + JALVIEW_PATH + "/" + path);
 231     ch.setResourceBase(".");
 232     ch.setClassLoader(Thread.currentThread()
 233             .getContextClassLoader());
 234     ch.setHandler(handler);
 235
 236     /*
 237      * Remember the association so we can remove it later
 238      */
 239     this.myHandlers.put(handler, ch);
 240
 241     /*
 242      * A handler added to a running server must be started explicitly
 243      */
 244     contextHandlers.addHandler(ch);
 245     try
 246     {
 247       ch.start();
 248     } catch (Exception e)
 249     {
 250       System.err.println("Error starting handler for " + path + ": "
 251               + e.getMessage());
 252     }
 253
 254     handler.setUri(this.contextRoot + ch.getContextPath().substring(1));
 255     System.out.println("Jalview " + handler.getName()
 256             + " handler started on " + handler.getUri());
 257   }
 258
 259   /**
 260    * Removes the handler from the server; more precisely, remove the
 261    * ContextHandler wrapping the specified handler
 262    *
 263    * @param handler
 264    */
 265   public void removeHandler(AbstractRequestHandler handler)
 266   {
 267     /*
 268      * Have to use this cached lookup table since there is no method
 269      * ContextHandler.getHandler()
 270      */
 271     ContextHandler ch = myHandlers.get(handler);
 272     if (ch != null)
 273     {
 274       contextHandlers.removeHandler(ch);
 275       myHandlers.remove(handler);
 276       System.out.println("Stopped Jalview " + handler.getName()
 277               + " handler on " + handler.getUri());
 278     }
 279   }
 280 }