io.undertow.websockets.spi.WebSocketHttpExchange Java Examples

private void processWebSocketRequest(Request request, Response response) {
        HttpServletRequest servletRequest = request.getHttpServletRequest();
        HttpServletResponse servletResponse = response.getHttpServletResponse();

        WebSocketHttpExchange exchange = new ServletWebSocketHttpExchange(servletRequest, servletResponse, peerConnections);
//        exchange.putAttachment(HandshakeUtil.PATH_PARAMS, Collections.<String, String>emptyMap());

        Handshake handshake = getHandshake(exchange);

        exchange.upgradeChannel((connection, serverExchange) -> {
            WebSocketChannel channel = handshake.createChannel(exchange, connection, exchange.getBufferPool());
            peerConnections.add(channel);
            createWebSocketAdapter(request).onConnect(exchange, channel);
        });

        handshake.handshake(exchange);
    }
 

@Override
public void onConnect(WebSocketHttpExchange exchange, WebSocketChannel channel) {
    if (this.hasAuthentication) {
        String header = null;
        if (exchange.getRequestHeader(Header.COOKIE.toString()) != null) {
            header = exchange.getRequestHeader(Header.COOKIE.toString());
        }
        
        if (RequestUtils.hasValidAuthentication(header)) {
            channel.getReceiveSetter().set((ChannelListener<? super WebSocketChannel>) Application.getInstance(this.controllerClass));
            channel.resumeReceives();
            channel.addCloseTask(Application.getInstance(WebSocketCloseListener.class));
            Application.getInstance(WebSocketService.class).addChannel(channel);
        } else {
            MangooUtils.closeQuietly(channel);
        }
    } else {
        channel.getReceiveSetter().set((ChannelListener<? super WebSocketChannel>) Application.getInstance(this.controllerClass));
        channel.resumeReceives();
        channel.addCloseTask(Application.getInstance(WebSocketCloseListener.class));
        Application.getInstance(WebSocketService.class).addChannel(channel);
    }
}
 

@Override
public void onConnect(WebSocketHttpExchange exchange, WebSocketChannel channel) {
    try {
        Cookie sid = getRequestCookies(exchange).get("PYX-Session");

        User user;
        if (sid == null || (user = Sessions.get().getUser(sid.getValue())) == null) {
            sendConnectionError(exchange, channel, new JsonWrapper(Consts.ErrorCode.NOT_REGISTERED));
        } else if (!user.isValid()) {
            sendConnectionError(exchange, channel, new JsonWrapper(Consts.ErrorCode.SESSION_EXPIRED));
        } else {
            if (user.getEventsSender() == null) user.establishedEventsConnection(new EventsSender(user, channel));
            else user.getEventsSender().addChannel(channel);

            channel.getCloseSetter().set((ChannelListener<AbstractFramedChannel>) newChannel -> {
                if (user.getEventsSender() != null)
                    user.getEventsSender().removeChannel((WebSocketChannel) newChannel);
            });
        }
    } catch (Throwable ex) {
        logger.error("Failed handling incoming connection.", ex);
        throw ex;
    }
}
 

@Override
public void onConnect(WebSocketHttpExchange exchange, WebSocketChannel channel) {

    String uri = exchange.getRequestURI();
    final String subscriptionId = uri.substring(path.length() + 1);
    EventReservationsHandler.Reservation reservation = eventReservationsHandler.claimReservation(subscriptionId);
    if (reservation == null) {
        send(channel, "error", "Invalid subscription: not reserved");
        safeClose(channel);
        return;
    }
    LOG.debug("Principal is: {}", reservation.getPrincipal());
    send(channel, "message", "connected");
    bus.subscribe(subscriptionId, (type, data) -> {
        if (channel.isOpen()) {
            send(channel, type, data);
        } else {
            bus.unsubscribe(subscriptionId);
        }
    });
}
 

protected void handshakeInternal(final WebSocketHttpExchange exchange) {

        String origin = exchange.getRequestHeader(Headers.SEC_WEB_SOCKET_ORIGIN_STRING);
        if (origin != null) {
            exchange.setResponseHeader(Headers.SEC_WEB_SOCKET_ORIGIN_STRING, origin);
        }
        selectSubprotocol(exchange);
        selectExtensions(exchange);
        exchange.setResponseHeader(Headers.SEC_WEB_SOCKET_LOCATION_STRING, getWebSocketLocation(exchange));

        final String key = exchange.getRequestHeader(Headers.SEC_WEB_SOCKET_KEY_STRING);
        try {
            final String solution = solve(key);
            exchange.setResponseHeader(Headers.SEC_WEB_SOCKET_ACCEPT_STRING, solution);
            performUpgrade(exchange);
        } catch (NoSuchAlgorithmException e) {
            IoUtils.safeClose(exchange);
            exchange.endExchange();
            return;
        }

    }
 

@Override
protected void handshakeInternal(final WebSocketHttpExchange exchange) {
    String origin = exchange.getRequestHeader(Headers.ORIGIN_STRING);
    if (origin != null) {
        exchange.setResponseHeader(Headers.ORIGIN_STRING, origin);
    }
    selectSubprotocol(exchange);
    selectExtensions(exchange);
    exchange.setResponseHeader(Headers.SEC_WEB_SOCKET_LOCATION_STRING, getWebSocketLocation(exchange));

    final String key = exchange.getRequestHeader(Headers.SEC_WEB_SOCKET_KEY_STRING);
    try {
        final String solution = solve(key);
        exchange.setResponseHeader(Headers.SEC_WEB_SOCKET_ACCEPT_STRING, solution);
        performUpgrade(exchange);
    } catch (NoSuchAlgorithmException e) {
        IoUtils.safeClose(exchange);
        exchange.endExchange();
        return;
    }
}
 

/**
 * Create the {@code ExtensionFunction} list associated with the negotiated extensions defined in the exchange's response.
 *
 * @param exchange the exchange used to retrieve negotiated extensions
 * @return         a list of {@code ExtensionFunction} with the implementation of the extensions
 */
protected final List<ExtensionFunction> initExtensions(final WebSocketHttpExchange exchange) {
    String extHeader = exchange.getResponseHeaders().get(Headers.SEC_WEB_SOCKET_EXTENSIONS_STRING) != null ?
            exchange.getResponseHeaders().get(Headers.SEC_WEB_SOCKET_EXTENSIONS_STRING).get(0) : null;

    List<ExtensionFunction> negotiated = new ArrayList<>();
    if (extHeader != null) {
        List<WebSocketExtension> extensions = WebSocketExtension.parse(extHeader);
        if (extensions != null && !extensions.isEmpty()) {
            for (WebSocketExtension ext : extensions) {
                for (ExtensionHandshake extHandshake : availableExtensions) {
                    if (extHandshake.getName().equals(ext.getName())) {
                        negotiated.add(extHandshake.create());
                    }
                }
            }
        }
    }
    return negotiated;
}
 

protected void upgradeChannel(final WebSocketHttpExchange exchange, final byte[] data) {
    if (data.length > 0) {
        writePayload(exchange, ByteBuffer.wrap(data));
    } else {
        exchange.endExchange();
    }
}
 

@Override
public void onConnect(WebSocketHttpExchange exchange, WebSocketChannel channel) {
    connection = new UndertowWebSocketConnection(exchange, channel);
    connections.add(connection);

    context = new WebSocketContext(connectionsReadOnly, connection, pathParameters);

    handler.onOpen(context);

    channel.addCloseTask(ch -> connections.remove(connection));
    channel.getReceiveSetter().set(this);
    channel.resumeReceives();
}
 

private Handshake getHandshake(WebSocketHttpExchange exchange) {
    for (Handshake handshake : handshakes) {
        if (handshake.matches(exchange)) {
            return handshake;
        }
    }

    throw new PippoRuntimeException("No matching Undertow Handshake found: {}", exchange.getRequestHeaders());
}
 

@Override
public boolean matches(final WebSocketHttpExchange exchange) {
    if (exchange.getRequestHeader(Headers.SEC_WEB_SOCKET_KEY_STRING) != null &&
            exchange.getRequestHeader(Headers.SEC_WEB_SOCKET_VERSION_STRING) != null) {
        return exchange.getRequestHeader(Headers.SEC_WEB_SOCKET_VERSION_STRING)
                .equals(getVersion().toHttpHeaderValue());
    }
    return false;
}
 

protected final void selectExtensions(final WebSocketHttpExchange exchange) {
    List<WebSocketExtension> requestedExtensions = WebSocketExtension.parse(exchange.getRequestHeader(Headers.SEC_WEB_SOCKET_EXTENSIONS_STRING));
    List<WebSocketExtension> extensions = selectedExtension(requestedExtensions);
    if (extensions != null && !extensions.isEmpty()) {
        exchange.setResponseHeader(Headers.SEC_WEB_SOCKET_EXTENSIONS_STRING, WebSocketExtension.toExtensionHeader(extensions));
    }

}
 

/**
 * Selects the first matching supported sub protocol and add it the the headers of the exchange.
 *
 */
protected final void selectSubprotocol(final WebSocketHttpExchange exchange) {
    String requestedSubprotocols = exchange.getRequestHeader(Headers.SEC_WEB_SOCKET_PROTOCOL_STRING);
    if (requestedSubprotocols == null) {
        return;
    }

    String[] requestedSubprotocolArray = PATTERN.split(requestedSubprotocols);
    String subProtocol = supportedSubprotols(requestedSubprotocolArray);
    if (subProtocol != null && !subProtocol.isEmpty()) {
        exchange.setResponseHeader(Headers.SEC_WEB_SOCKET_PROTOCOL_STRING, subProtocol);
    }

}
 

private static void writePayload(final WebSocketHttpExchange exchange, final ByteBuffer payload) {
    exchange.sendData(payload).addNotifier(new IoFuture.Notifier<Void, Object>() {
        @Override
        public void notify(final IoFuture<? extends Void> ioFuture, final Object attachment) {
            if (ioFuture.getStatus() == IoFuture.Status.DONE) {
                exchange.endExchange();
            } else {
                exchange.close();
            }
        }
    }, null);
}
 

@Override
public void onConnect(WebSocketHttpExchange exchange, WebSocketChannel channel) {
	UndertowWebSocketSession session = createSession(channel);
	UndertowWebSocketHandlerAdapter adapter = new UndertowWebSocketHandlerAdapter(session);

	channel.getReceiveSetter().set(adapter);
	channel.resumeReceives();

	this.handler.handle(session)
			.checkpoint(exchange.getRequestURI() + " [UndertowRequestUpgradeStrategy]")
			.subscribe(session);
}
 

/**
 * convenience method to perform the upgrade
 */
protected final void performUpgrade(final WebSocketHttpExchange exchange, final byte[] data) {
    exchange.setResponseHeader(Headers.CONTENT_LENGTH_STRING, String.valueOf(data.length));
    exchange.setResponseHeader(Headers.UPGRADE_STRING, "WebSocket");
    exchange.setResponseHeader(Headers.CONNECTION_STRING, "Upgrade");
    upgradeChannel(exchange, data);
}
 

@Override
public void onConnect(WebSocketHttpExchange httpExchange, WebSocketChannel channel) {
	UndertowWebSocketSession session = createSession(channel);
	UndertowWebSocketHandlerAdapter adapter = new UndertowWebSocketHandlerAdapter(session);

	channel.getReceiveSetter().set(adapter);
	channel.resumeReceives();

	this.handler.handle(session).subscribe(session);
}
 

/**
 * Return the full url of the websocket location of the given {@link WebSocketHttpExchange}
 */
protected static String getWebSocketLocation(WebSocketHttpExchange exchange) {
    String scheme;
    if ("https".equals(exchange.getRequestScheme())) {
        scheme = "wss";
    } else {
        scheme = "ws";
    }
    return scheme + "://" + exchange.getRequestHeader(Headers.HOST_STRING) + exchange.getRequestURI();
}
 

@Override
public void onConnect(WebSocketHttpExchange webSocketHttpExchange, WebSocketChannel webSocketChannel) {
    final Graph graph = builder.build();
    graph.setProperty("ws.source", webSocketChannel.getSourceAddress().getAddress());
    graph.connect(new Callback<Boolean>() {
        @Override
        public void on(Boolean result) {
            webSocketChannel.getReceiveSetter().set(new PeerInternalListener(graph));
            webSocketChannel.resumeReceives();
            peers.add(webSocketChannel);
        }
    });
}
 

@Override
public void onConnect(WebSocketHttpExchange webSocketHttpExchange, WebSocketChannel webSocketChannel) {
    webSocketChannel.getReceiveSetter().set(new InternalListener());
    webSocketChannel.resumeReceives();
    webSocketChannel.setAttribute("id", channelCounter.get());
    peers.put(channelCounter.getAndIncrement(), webSocketChannel);
    if (channelCounter.get() == Integer.MAX_VALUE) {
        channelCounter.set(0);
    }
}
 

@Override
public WebSocketChannel createChannel(WebSocketHttpExchange exchange, final StreamConnection channel, final ByteBufferPool pool) {
    List<ExtensionFunction> extensionFunctions = initExtensions(exchange);
    return new WebSocket07Channel(channel, pool, getWebSocketLocation(exchange), exchange.getResponseHeader(Headers.SEC_WEB_SOCKET_PROTOCOL_STRING), false, !extensionFunctions.isEmpty(), CompositeExtensionFunction.compose(extensionFunctions), exchange.getPeerConnections(), exchange.getOptions());
}
 

@Override
public void onConnect(WebSocketHttpExchange webSocketHttpExchange, WebSocketChannel webSocketChannel) {
    webSocketChannel.getReceiveSetter().set(new PeerInternalListener());
    webSocketChannel.resumeReceives();
    peers.add(webSocketChannel);
}
 

@Override
public void onConnect(WebSocketHttpExchange webSocketHttpExchange, WebSocketChannel webSocketChannel) {
    webSocketChannel.getReceiveSetter().set(new PeerInternalListener(webSocketChannel));
    webSocketChannel.resumeReceives();
    peers.add(webSocketChannel);
}
 

public WebSocketHttpExchange getExchange() {
    return exchange;
}
 

public UndertowWebSocketConnection(WebSocketHttpExchange exchange, WebSocketChannel channel) {
    this.exchange = exchange;
    this.channel = channel;
}
 

private static void sendConnectionError(WebSocketHttpExchange exchange, WebSocketChannel channel, JsonWrapper error) {
    WebSockets.sendText(error.toString(), channel, null);
    exchange.endExchange();
}
 

private static Map<String, Cookie> getRequestCookies(WebSocketHttpExchange exchange) {
    return Cookies.parseRequestCookies(200, false, exchange.getRequestHeaders().get(Headers.COOKIE_STRING));
}
 

@Override
public WebSocketChannel createChannel(final WebSocketHttpExchange exchange, final StreamConnection channel, final ByteBufferPool pool) {
    List<ExtensionFunction> extensionFunctions = initExtensions(exchange);
    return new WebSocket08Channel(channel, pool, getWebSocketLocation(exchange), exchange.getResponseHeader(Headers.SEC_WEB_SOCKET_PROTOCOL_STRING), false, !extensionFunctions.isEmpty(), CompositeExtensionFunction.compose(extensionFunctions), exchange.getPeerConnections(), exchange.getOptions());

}
 

@Override
public WebSocketChannel createChannel(WebSocketHttpExchange exchange, final StreamConnection channel, final ByteBufferPool pool) {
    List<ExtensionFunction> extensionFunctions = initExtensions(exchange);
    return new WebSocket13Channel(channel, pool, getWebSocketLocation(exchange), exchange.getResponseHeader(Headers.SEC_WEB_SOCKET_PROTOCOL_STRING), false, !extensionFunctions.isEmpty(), CompositeExtensionFunction.compose(extensionFunctions), exchange.getPeerConnections(), exchange.getOptions());
}
 

/**
 * Perform the upgrade using no payload
 */
protected final void performUpgrade(final WebSocketHttpExchange exchange) {
    performUpgrade(exchange, EMPTY);
}