src/jalview/rest/RestHandler.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.rest;
  22
  23 import java.io.BufferedReader;
  24 import java.io.IOException;
  25 import java.io.PrintWriter;
  26 import java.net.BindException;
  27 import java.util.HashMap;
  28 import java.util.Map;
  29
  30 import javax.servlet.http.HttpServletRequest;
  31 import javax.servlet.http.HttpServletResponse;
  32
  33 import jalview.bin.Cache;
  34 import jalview.httpserver.AbstractRequestHandler;
  35
  36 /**
  37  * A simple handler to process (or delegate) HTTP requests on /jalview/rest
  38  */
  39 public class RestHandler extends AbstractRequestHandler
  40 {
  41
  42   public enum Status
  43   {
  44     STARTED, IN_PROGRESS, FINISHED, ERROR
  45   }
  46
  47   public interface EndpointI
  48   {
  49     public String getName();
  50
  51     public void processEndpoint(HttpServletRequest request,
  52             HttpServletResponse response);
  53
  54   }
  55
  56   public interface EndpointOld
  57   {
  58     public void processEndpoint(String endpointName,
  59             HttpServletRequest request, HttpServletResponse response);
  60   }
  61
  62   private static final String MY_PATH = "rest";
  63
  64   private static final String MY_NAME = "Rest";
  65
  66   private String missingEndpointMessage = null;
  67
  68   private boolean init = false;
  69
  70   // map of method names and method handlers
  71   private Map<String, EndpointI> endpoints = null;
  72
  73   protected Map<String, EndpointI> getEndpoints()
  74   {
  75     return endpoints;
  76   }
  77
  78   /**
  79    * Singleton instance of this class
  80    */
  81   private static RestHandler instance = null;
  82
  83   /**
  84    * Returns the singleton instance of this class
  85    *
  86    * @return
  87    * @throws BindException
  88    */
  89   public static RestHandler getInstance() throws BindException
  90   {
  91     synchronized (RestHandler.class)
  92     {
  93       if (instance == null)
  94       {
  95         instance = new RestHandler();
  96       }
  97     }
  98     return instance;
  99   }
 100
 101   /**
 102    * Private constructor enforces use of singleton
 103    *
 104    * @throws BindException
 105    */
 106   protected RestHandler() throws BindException
 107   {
 108     init();
 109
 110     /*
 111      * We don't register the handler here - this is done as a special case in
 112      * HttpServer initialisation; to do it here would invite an infinite loop of
 113      * RestHandler/HttpServer constructor
 114      */
 115   }
 116
 117   /**
 118    * Handle a jalview/rest request
 119    *
 120    * @throws IOException
 121    */
 122   @Override
 123   protected void processRequest(HttpServletRequest request,
 124           HttpServletResponse response) throws IOException
 125   {
 126     /*
 127      * Currently just echoes the request; add helper classes as required to
 128      * process requests
 129      */
 130     System.out.println(request.toString());
 131     if (endpoints == null)
 132     {
 133       final String queryString = request.getQueryString();
 134       final String reply = "REST not yet implemented; received "
 135               + request.getMethod() + ": " + request.getRequestURL()
 136               + (queryString == null ? "" : "?" + queryString);
 137       System.out.println(reply);
 138
 139       response.setHeader("Cache-Control", "no-cache/no-store");
 140       response.setHeader("Content-type", "text/plain");
 141       final PrintWriter writer = response.getWriter();
 142       writer.write(reply);
 143       writer.close();
 144       return;
 145     }
 146
 147     String endpointName = getRequestedEndpointName(request);
 148
 149     if (!endpoints.containsKey(endpointName)
 150             || endpoints.get(endpointName) == null)
 151     {
 152
 153       response.setHeader("Cache-Control", "no-cache/no-store");
 154       response.setHeader("Content-type", "text/plain");
 155       response.setStatus(400);
 156       PrintWriter writer = response.getWriter();
 157       writer.write(missingEndpointMessage == null
 158               ? "REST endpoint '" + endpointName + "' not defined"
 159               : missingEndpointMessage);
 160       writer.close();
 161       return;
 162     }
 163
 164     response.setHeader("Cache-Control", "no-cache/no-store");
 165     response.setHeader("Content-type", "text/plain");
 166     EndpointI ep = endpoints.get(endpointName);
 167     ep.processEndpoint(request, response);
 168
 169     return;
 170   }
 171
 172   /**
 173    * Returns a display name for this service
 174    */
 175   @Override
 176   public String getName()
 177   {
 178     return MY_NAME;
 179   }
 180
 181   /**
 182    * Initialise methods
 183    *
 184    * @throws BindException
 185    */
 186   protected void init() throws BindException
 187   {
 188     init(MY_PATH);
 189   }
 190
 191   protected void init(String path) throws BindException
 192   {
 193     setPath(path);
 194     // Override this in extended class
 195     // e.g. registerHandler and addEndpoints
 196   }
 197
 198   protected boolean addEndpoint(EndpointI ep)
 199   {
 200     if (endpoints == null)
 201     {
 202       endpoints = new HashMap<>();
 203     }
 204     Endpoint e = (Endpoint) ep;
 205     endpoints.put(ep.getName(), ep);
 206     return true;
 207   }
 208
 209   protected String getRequestedEndpointName(HttpServletRequest request)
 210   {
 211     String pathInfo = request.getPathInfo();
 212     int slashpos = pathInfo.indexOf('/', 1);
 213     return slashpos > 1 ? pathInfo.substring(1, slashpos)
 214             : pathInfo.substring(1);
 215   }
 216
 217   protected String[] getEndpointPathParameters(HttpServletRequest request)
 218   {
 219     String pathInfo = request.getPathInfo();
 220     int slashpos = pathInfo.indexOf('/', 1);
 221     return slashpos < 1 ? null
 222             : pathInfo.substring(slashpos + 1).split("/");
 223   }
 224
 225   protected void returnError(HttpServletRequest request,
 226           HttpServletResponse response, String message)
 227   {
 228     response.setStatus(500); // set this to something better
 229     String endpointName = getRequestedEndpointName(request);
 230     Cache.error(this.MY_NAME + " error: endpoint " + endpointName
 231             + " failed: '" + message + "'");
 232     try
 233     {
 234       PrintWriter writer = response.getWriter();
 235       writer.write("Endpoint " + endpointName + ": " + message);
 236       writer.close();
 237     } catch (IOException e)
 238     {
 239       Cache.debug(e);
 240     }
 241   }
 242
 243   protected void returnStatus(HttpServletResponse response, String id,
 244           Status status)
 245   {
 246     try
 247     {
 248       PrintWriter writer = response.getWriter();
 249       if (id != null)
 250         writer.write("id=" + id + "\n");
 251       if (status != null)
 252         writer.write("status=" + status.toString() + "\n");
 253     } catch (IOException e)
 254     {
 255       Cache.debug(e);
 256     }
 257   }
 258
 259   protected String getRequestBody(HttpServletRequest request)
 260           throws IOException
 261   {
 262     StringBuilder sb = new StringBuilder();
 263     BufferedReader reader = request.getReader();
 264     try
 265     {
 266       String line;
 267       while ((line = reader.readLine()) != null)
 268       {
 269         sb.append(line).append('\n');
 270       }
 271     } finally
 272     {
 273       reader.close();
 274     }
 275     return sb.toString();
 276   }
 277
 278 }