@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); } } } }
@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() { 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); } } } }
WebSocketServerFactory webSocketServerFactory = new WebSocketServerFactory( sch.getServletContext(), wsConfig); webSocketServerFactory.setCreator((req, rsp) -> { JettyWebSocket ws = new JettyWebSocket(); req.getHttpServletRequest().setAttribute(JettyWebSocket.class.getName(), ws);
@Override public WebSocketServletFactory createFactory(WebSocketPolicy policy) { return new WebSocketServerFactory(policy); }
WebSocketServerFactory factory = new WebSocketServerFactory(); factory.getPolicy().setAsyncWriteTimeout(1000); factory.setCreator(new WebSocketCreator() { @Override public Object createWebSocket(ServletUpgradeRequest req, ServletUpgradeResponse resp) { if ("websocket".equalsIgnoreCase(req.getHeader("Upgrade")) && factory.acceptWebSocket(req, resp)) { apiRequest.setResponseCode(101); apiRequest.commit();
@Override protected boolean acceptWebSocket(Request request, Response response) throws IOException, ServletException { return super.acceptWebSocket(request, response) && webSocketFactory .acceptWebSocket(request.getHttpServletRequest(), response.getHttpServletResponse()); }
ExtensionStack extensionStack = new ExtensionStack(getExtensionFactory()); extensionStack.negotiate(request.getExtensions()); UpgradeContext context = getActiveUpgradeContext(); LogicalConnection connection = context.getConnection(); session.setPolicy(getPolicy().clonePolicy()); session.setUpgradeRequest(request); response.setExtensions(extensionStack.getNegotiatedExtensions());
@Override public boolean acceptWebSocket(HttpServletRequest request, HttpServletResponse response) throws IOException { return acceptWebSocket(getCreator(), request, response); }
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 init() throws Exception { start(); }
ExtensionStack extensionStack = new ExtensionStack(getExtensionFactory()); WebSocketSession session = createSession(request.getRequestURI(), driver, wsConnection); session.setUpgradeRequest(request); this.addManaged(session); LOG.debug("Handshake Response: {}", handshaker); if (getSendServerVersion(connector)) response.setHeader("Server", HttpConfiguration.SERVER_VERSION);
/** * 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 WebSocketServletFactory createFactory(WebSocketPolicy policy) { return new WebSocketServerFactory(policy); }
WebSocketServerFactory webSocketServerFactory = new WebSocketServerFactory( sch.getServletContext(), wsConfig); webSocketServerFactory.setCreator((req, rsp) -> { JettyWebSocket ws = new JettyWebSocket(); req.getHttpServletRequest().setAttribute(JettyWebSocket.class.getName(), ws);
@Override protected boolean acceptWebSocket(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { req.setAttribute(SHIRO_SUBJECT, SecurityUtils.getSubject()); return super.acceptWebSocket(req, resp) && webSocketFactory.acceptWebSocket(req, resp); }
ExtensionStack extensionStack = new ExtensionStack(getExtensionFactory()); extensionStack.negotiate(request.getExtensions()); UpgradeContext context = getActiveUpgradeContext(); LogicalConnection connection = context.getConnection(); session.setPolicy(getPolicy().clonePolicy()); session.setUpgradeRequest(request); response.setExtensions(extensionStack.getNegotiatedExtensions());
configureContext.getWebSocketServerFactory().getExtensionFactory().unregister("permessage-deflate");
@Override public void init() throws Exception { start(); }
@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); } } }