@Override public void stop() { if (isRunning()) { this.running = false; if (this.factory != null) { try { this.factory.stop(); } catch (Throwable ex) { throw new IllegalStateException("Unable to stop Jetty WebSocketServerFactory", ex); } } } }
private List<WebSocketExtension> buildWebSocketExtensions() { Set<String> names = this.factory.getExtensionFactory().getExtensionNames(); List<WebSocketExtension> result = new ArrayList<>(names.size()); for (String name : names) { result.add(new WebSocketExtension(name)); } return result; }
@Override public void start() { synchronized (this.lifecycleMonitor) { ServletContext servletContext = this.servletContext; if (!isRunning() && servletContext != null) { this.running = true; try { this.factory = (this.webSocketPolicy != null ? new WebSocketServerFactory(servletContext, this.webSocketPolicy) : new WebSocketServerFactory(servletContext)); this.factory.setCreator((request, response) -> { WebSocketHandlerContainer container = adapterHolder.get(); String protocol = container.getProtocol(); if (protocol != null) { response.setAcceptedSubProtocol(protocol); } return container.getAdapter(); }); this.factory.start(); } catch (Throwable ex) { throw new IllegalStateException("Unable to start WebSocketServerFactory", ex); } } } }
@SuppressWarnings("unchecked") @Override public <T> T upgrade(final Class<T> type) throws Exception { if (type == NativeWebSocket.class && webSocketServerFactory.isUpgradeRequest(request, response) && webSocketServerFactory.acceptWebSocket(request, response)) { String key = JettyWebSocket.class.getName(); NativeWebSocket ws = (NativeWebSocket) request.getAttribute(key); if (ws != null) { request.removeAttribute(key); return (T) ws; } } else if (type == Sse.class) { return (T) new JettySse(baseRequest, (Response) response); } else if (type == NativePushPromise.class) { return (T) new JettyPush(baseRequest); } throw new UnsupportedOperationException("Not Supported: " + type); } };
WebSocketServerFactory webSocketServerFactory = new WebSocketServerFactory( sch.getServletContext(), wsConfig); webSocketServerFactory.setCreator((req, rsp) -> { JettyWebSocket ws = new JettyWebSocket(); req.getHttpServletRequest().setAttribute(JettyWebSocket.class.getName(), ws);
try { webSocketServletContextHandler = new ServletContextHandler(null, "/", true, false); WebSocketUpgradeFilter webSocketUpgradeFilter = WebSocketUpgradeFilter.configureContext(webSocketServletContextHandler); if (webSocketIdleTimeoutMillis.isPresent()) { webSocketUpgradeFilter.getFactory().getPolicy().setIdleTimeout(webSocketIdleTimeoutMillis.get()); for (String path : webSocketHandlers.keySet()) { WebSocketCreator webSocketCreator = WebSocketCreatorFactory.create(webSocketHandlers.get(path)); webSocketConfiguration.addMapping(new ServletPathSpec(path), webSocketCreator);
@Override public boolean acceptWebSocket(HttpServletRequest request, HttpServletResponse response) throws IOException { return acceptWebSocket(getCreator(), request, response); }
@Override protected boolean acceptWebSocket(Request request, Response response) throws IOException, ServletException { return super.acceptWebSocket(request, response) && webSocketFactory .acceptWebSocket(request.getHttpServletRequest(), response.getHttpServletResponse()); }
@Override public void addMapping(String rawspec, WebSocketCreator creator) { PathSpec spec = toPathSpec(rawspec); addMapping(spec, creator); }
/** * Used to configure the Default {@link WebSocketPolicy} used by all endpoints that * don't redeclare the values. * * @return the default policy for all WebSockets */ public WebSocketPolicy getPolicy() { return this.factory.getPolicy(); }
@Override public WebSocketCreator getMapping(String target) { return getConfiguration().getMapping(target); }
@Override public void addMapping(PathSpec spec, WebSocketCreator creator) { this.configuration.addMapping(spec, creator); }
@Override public boolean removeMapping(String spec) { return configuration.removeMapping(spec); }
@Override public void start() { if (!isRunning()) { this.running = true; try { if (this.factory == null) { this.factory = new WebSocketServerFactory(this.servletContext, this.policy); } this.factory.setCreator((request, response) -> { WebSocketHandlerContainer container = containerHolder.get(); Assert.state(container != null, "Expected WebSocketHandlerContainer"); response.setAcceptedSubProtocol(container.getSelectedProtocol()); response.setExtensions(container.getExtensionConfigs()); return container.getHandler(); }); this.factory.start(); } catch (Throwable ex) { throw new IllegalStateException("Unable to start Jetty WebSocketServerFactory", ex); } } }
@Override public void upgrade(ServerHttpRequest request, ServerHttpResponse response, String selectedProtocol, List<WebSocketExtension> selectedExtensions, Principal user, WebSocketHandler wsHandler, Map<String, Object> attributes) throws HandshakeFailureException { Assert.isInstanceOf(ServletServerHttpRequest.class, request, "ServletServerHttpRequest required"); HttpServletRequest servletRequest = ((ServletServerHttpRequest) request).getServletRequest(); Assert.isInstanceOf(ServletServerHttpResponse.class, response, "ServletServerHttpResponse required"); HttpServletResponse servletResponse = ((ServletServerHttpResponse) response).getServletResponse(); Assert.isTrue(this.factory.isUpgradeRequest(servletRequest, servletResponse), "Not a WebSocket handshake"); JettyWebSocketSession session = new JettyWebSocketSession(attributes, user); JettyWebSocketHandlerAdapter handlerAdapter = new JettyWebSocketHandlerAdapter(wsHandler, session); WebSocketHandlerContainer container = new WebSocketHandlerContainer(handlerAdapter, selectedProtocol, selectedExtensions); try { containerHolder.set(container); this.factory.acceptWebSocket(servletRequest, servletResponse); } catch (IOException ex) { throw new HandshakeFailureException( "Response update failed during upgrade to WebSocket: " + request.getURI(), ex); } finally { containerHolder.remove(); } }
@Override public void stop() { synchronized (this.lifecycleMonitor) { if (isRunning()) { this.running = false; if (this.factory != null) { try { this.factory.stop(); } catch (Throwable ex) { throw new IllegalStateException("Failed to stop WebSocketServerFactory", ex); } } } } }
configureContext.getWebSocketServerFactory().getExtensionFactory().unregister("permessage-deflate");
@Override public void init(FilterConfig filterConfig) throws ServletException { super.init(filterConfig); try { WebSocketPolicy serverPolicy = WebSocketPolicy.newServerPolicy(); String inputBufferSize = filterConfig.getInitParameter("inputBufferSize"); if (inputBufferSize != null) { serverPolicy.setInputBufferSize(Integer.parseInt(inputBufferSize)); } String idleTimeout = filterConfig.getInitParameter("idleTimeout"); if (idleTimeout != null) { serverPolicy.setIdleTimeout(Integer.parseInt(idleTimeout)); } String maxTextMessageSize = filterConfig.getInitParameter("maxTextMessageSize"); if (maxTextMessageSize != null) { serverPolicy.setMaxTextMessageSize(Integer.parseInt(maxTextMessageSize)); } webSocketFactory = new WebSocketServerFactory(filterConfig.getServletContext(), serverPolicy); webSocketFactory.setCreator((request, response) -> createWebSocketAdapter(request)); webSocketFactory.start(); } catch (ServletException e) { throw e; } catch (Exception e) { throw new ServletException(e); } }
@Override public Mono<Void> upgrade(ServerWebExchange exchange, WebSocketHandler handler, @Nullable String subProtocol, Supplier<HandshakeInfo> handshakeInfoFactory) { ServerHttpRequest request = exchange.getRequest(); ServerHttpResponse response = exchange.getResponse(); HttpServletRequest servletRequest = getHttpServletRequest(request); HttpServletResponse servletResponse = getHttpServletResponse(response); HandshakeInfo handshakeInfo = handshakeInfoFactory.get(); DataBufferFactory factory = response.bufferFactory(); JettyWebSocketHandlerAdapter adapter = new JettyWebSocketHandlerAdapter( handler, session -> new JettyWebSocketSession(session, handshakeInfo, factory)); startLazily(servletRequest); Assert.state(this.factory != null, "No WebSocketServerFactory available"); boolean isUpgrade = this.factory.isUpgradeRequest(servletRequest, servletResponse); Assert.isTrue(isUpgrade, "Not a WebSocket handshake"); try { adapterHolder.set(new WebSocketHandlerContainer(adapter, subProtocol)); this.factory.acceptWebSocket(servletRequest, servletResponse); } catch (IOException ex) { return Mono.error(ex); } finally { adapterHolder.remove(); } return Mono.empty(); }
@Override public void destroy() { if (webSocketFactory != null) { try { webSocketFactory.stop(); } catch (Exception e) { log.warn("A problem occurred while stopping the web socket factory", e); } } super.destroy(); }