org.argeo.cms.lib.jetty/src/org/argeo/cms/jetty/JettyHttpContext.java

   1 package org.argeo.cms.jetty;
   2
   3 import java.util.AbstractMap;
   4 import java.util.ArrayList;
   5 import java.util.Enumeration;
   6 import java.util.HashSet;
   7 import java.util.List;
   8 import java.util.Map;
   9 import java.util.Objects;
  10 import java.util.Set;
  11
  12 import javax.servlet.ServletContext;
  13 import javax.websocket.DeploymentException;
  14 import javax.websocket.server.ServerContainer;
  15
  16 import org.argeo.cms.servlet.httpserver.HttpContextServlet;
  17 import org.argeo.cms.websocket.server.WebsocketEndpoints;
  18 import org.eclipse.jetty.server.session.SessionHandler;
  19 import org.eclipse.jetty.servlet.ServletContextHandler;
  20 import org.eclipse.jetty.servlet.ServletHolder;
  21 import org.eclipse.jetty.websocket.javax.server.config.JavaxWebSocketServletContainerInitializer;
  22 import org.eclipse.jetty.websocket.javax.server.config.JavaxWebSocketServletContainerInitializer.Configurator;
  23
  24 import com.sun.net.httpserver.Authenticator;
  25 import com.sun.net.httpserver.Filter;
  26 import com.sun.net.httpserver.HttpContext;
  27 import com.sun.net.httpserver.HttpHandler;
  28 import com.sun.net.httpserver.HttpServer;
  29
  30 /** Trivial implementation of @{HttpContext}. */
  31 class JettyHttpContext extends HttpContext {
  32         private final JettyHttpServer httpServer;
  33         private final String path;
  34         private final ServletContextHandler contextHandler;
  35         private final ContextAttributes attributes;
  36         private final List<Filter> filters = new ArrayList<>();
  37
  38         private HttpHandler handler;
  39         private Authenticator authenticator;
  40
  41         public JettyHttpContext(JettyHttpServer httpServer, String path) {
  42                 this.httpServer = httpServer;
  43                 this.path = path;
  44
  45                 // Jetty context handler
  46                 ServletContextHandler servletContextHandler = new ServletContextHandler();
  47                 servletContextHandler.setContextPath(path);
  48                 HttpContextServlet servlet = new HttpContextServlet(this);
  49                 servletContextHandler.addServlet(new ServletHolder(servlet), "/*");
  50                 SessionHandler sessionHandler = new SessionHandler();
  51                 // FIXME find a better default
  52                 sessionHandler.setMaxInactiveInterval(-1);
  53                 servletContextHandler.setSessionHandler(sessionHandler);
  54                 contextHandler = servletContextHandler;
  55
  56                 attributes = new ContextAttributes();
  57         }
  58
  59         @Override
  60         public HttpHandler getHandler() {
  61                 return handler;
  62         }
  63
  64         @Override
  65         public void setHandler(HttpHandler handler) {
  66                 if (this.handler != null)
  67                         throw new IllegalArgumentException("Handler is already set");
  68                 Objects.requireNonNull(handler);
  69                 this.handler = handler;
  70
  71                 // web socket
  72                 if (handler instanceof WebsocketEndpoints) {
  73                         JavaxWebSocketServletContainerInitializer.configure(contextHandler, new Configurator() {
  74
  75                                 @Override
  76                                 public void accept(ServletContext servletContext, ServerContainer serverContainer)
  77                                                 throws DeploymentException {
  78 //                                      CmsWebSocketConfigurator wsEndpointConfigurator = new CmsWebSocketConfigurator();
  79
  80                                         for (Class<?> clss : ((WebsocketEndpoints) handler).getEndPoints()) {
  81 //                                              Class<?> clss = websocketEndpoints.get(path);
  82 //                                              ServerEndpointConfig config = ServerEndpointConfig.Builder.create(clss, path)
  83 //                                                              .configurator(wsEndpointConfigurator).build();
  84                                                 serverContainer.addEndpoint(clss);
  85                                         }
  86                                 }
  87                         });
  88                 }
  89
  90                 if (httpServer.isStarted())
  91                         try {
  92                                 contextHandler.start();
  93                         } catch (Exception e) {
  94                                 throw new IllegalStateException("Cannot start context handler", e);
  95                         }
  96         }
  97
  98         @Override
  99         public String getPath() {
 100                 return path;
 101         }
 102
 103         @Override
 104         public HttpServer getServer() {
 105                 return httpServer;
 106         }
 107
 108         @Override
 109         public Map<String, Object> getAttributes() {
 110                 return attributes;
 111         }
 112
 113         @Override
 114         public List<Filter> getFilters() {
 115                 return filters;
 116         }
 117
 118         @Override
 119         public Authenticator setAuthenticator(Authenticator auth) {
 120                 Authenticator previousAuthenticator = authenticator;
 121                 this.authenticator = auth;
 122                 return previousAuthenticator;
 123         }
 124
 125         @Override
 126         public Authenticator getAuthenticator() {
 127                 return authenticator;
 128         }
 129
 130         ServletContextHandler getContextHandler() {
 131                 return contextHandler;
 132         }
 133
 134         private class ContextAttributes extends AbstractMap<String, Object> {
 135                 @Override
 136                 public Set<Entry<String, Object>> entrySet() {
 137                         Set<Entry<String, Object>> entries = new HashSet<>();
 138                         for (Enumeration<String> keys = contextHandler.getAttributeNames(); keys.hasMoreElements();) {
 139                                 entries.add(new ContextAttributeEntry(keys.nextElement()));
 140                         }
 141                         return entries;
 142                 }
 143
 144                 @Override
 145                 public Object put(String key, Object value) {
 146                         Object previousValue = get(key);
 147                         contextHandler.setAttribute(key, value);
 148                         return previousValue;
 149                 }
 150
 151                 private class ContextAttributeEntry implements Map.Entry<String, Object> {
 152                         private final String key;
 153
 154                         public ContextAttributeEntry(String key) {
 155                                 this.key = key;
 156                         }
 157
 158                         @Override
 159                         public String getKey() {
 160                                 return key;
 161                         }
 162
 163                         @Override
 164                         public Object getValue() {
 165                                 return contextHandler.getAttribute(key);
 166                         }
 167
 168                         @Override
 169                         public Object setValue(Object value) {
 170                                 Object previousValue = getValue();
 171                                 contextHandler.setAttribute(key, value);
 172                                 return previousValue;
 173                         }
 174
 175                 }
 176         }
 177 }