Example usage for org.springframework.messaging.simp.stomp StompCommand CONNECT

Introduction

In this page you can find the example usage for org.springframework.messaging.simp.stomp StompCommand CONNECT.

Prototype

StompCommand CONNECT

To view the source code for org.springframework.messaging.simp.stomp StompCommand CONNECT.

Click Source Link

Usage

From source file:org.springframework.messaging.simp.stomp.DefaultStompSession.java

@Override
public void afterConnected(TcpConnection<byte[]> connection) {
    this.connection = connection;
    if (logger.isDebugEnabled()) {
        logger.debug("Connection established in session id=" + this.sessionId);
    }//from   www  .  j  av a2s  .  co m
    StompHeaderAccessor accessor = createHeaderAccessor(StompCommand.CONNECT);
    accessor.addNativeHeaders(this.connectHeaders);
    accessor.setAcceptVersion("1.1,1.2");
    Message<byte[]> message = createMessage(accessor, EMPTY_PAYLOAD);
    execute(message);
}

---

From source file:org.springframework.messaging.simp.stomp.StompBrokerRelayMessageHandler.java

/**
 * Open a "system" session for sending messages from parts of the application
 * not assoicated with a client STOMP session.
 */// ww w  .java 2  s  .  c o m
private void openSystemSession() {

    RelaySession session = new RelaySession(STOMP_RELAY_SYSTEM_SESSION_ID) {
        @Override
        protected void sendMessageToClient(Message<?> message) {
            // ignore, only used to send messages
            // TODO: ERROR frame/reconnect
        }
    };
    this.relaySessions.put(STOMP_RELAY_SYSTEM_SESSION_ID, session);

    StompHeaderAccessor headers = StompHeaderAccessor.create(StompCommand.CONNECT);
    headers.setAcceptVersion("1.1,1.2");
    headers.setLogin(this.systemLogin);
    headers.setPasscode(this.systemPasscode);
    headers.setHeartbeat(0, 0); // TODO

    if (logger.isDebugEnabled()) {
        logger.debug("Sending STOMP CONNECT frame to initialize \"system\" TCP connection");
    }
    Message<?> message = MessageBuilder.withPayloadAndHeaders(new byte[0], headers).build();
    session.open(message);
}

---

From source file:org.springframework.messaging.simp.stomp.StompEncoder.java

private void writeHeaders(StompCommand command, Map<String, Object> headers, byte[] payload,
        DataOutputStream output) throws IOException {

    @SuppressWarnings("unchecked")
    Map<String, List<String>> nativeHeaders = (Map<String, List<String>>) headers
            .get(NativeMessageHeaderAccessor.NATIVE_HEADERS);

    if (logger.isTraceEnabled()) {
        logger.trace("Encoding STOMP " + command + ", headers=" + nativeHeaders);
    }/*from   w w  w .  j a  v  a  2 s. c  om*/

    if (nativeHeaders == null) {
        return;
    }

    boolean shouldEscape = (command != StompCommand.CONNECT && command != StompCommand.CONNECTED);

    for (Entry<String, List<String>> entry : nativeHeaders.entrySet()) {
        if (command.requiresContentLength() && "content-length".equals(entry.getKey())) {
            continue;
        }

        List<String> values = entry.getValue();
        if (StompCommand.CONNECT.equals(command)
                && StompHeaderAccessor.STOMP_PASSCODE_HEADER.equals(entry.getKey())) {
            values = Collections.singletonList(StompHeaderAccessor.getPasscode(headers));
        }

        byte[] encodedKey = encodeHeaderKey(entry.getKey(), shouldEscape);
        for (String value : values) {
            output.write(encodedKey);
            output.write(COLON);
            output.write(encodeHeaderValue(value, shouldEscape));
            output.write(LF);
        }
    }

    if (command.requiresContentLength()) {
        int contentLength = payload.length;
        output.write("content-length:".getBytes(StandardCharsets.UTF_8));
        output.write(Integer.toString(contentLength).getBytes(StandardCharsets.UTF_8));
        output.write(LF);
    }
}

---

From source file:org.springframework.web.socket.messaging.StompSubProtocolHandler.java

/**
 * Handle incoming WebSocket messages from clients.
 *///from   www . j av  a  2s.  c o  m
public void handleMessageFromClient(WebSocketSession session, WebSocketMessage<?> webSocketMessage,
        MessageChannel outputChannel) {

    List<Message<byte[]>> messages;
    try {
        ByteBuffer byteBuffer;
        if (webSocketMessage instanceof TextMessage) {
            byteBuffer = ByteBuffer.wrap(((TextMessage) webSocketMessage).asBytes());
        } else if (webSocketMessage instanceof BinaryMessage) {
            byteBuffer = ((BinaryMessage) webSocketMessage).getPayload();
        } else {
            return;
        }

        BufferingStompDecoder decoder = this.decoders.get(session.getId());
        if (decoder == null) {
            throw new IllegalStateException("No decoder for session id '" + session.getId() + "'");
        }

        messages = decoder.decode(byteBuffer);
        if (messages.isEmpty()) {
            if (logger.isTraceEnabled()) {
                logger.trace("Incomplete STOMP frame content received in session " + session + ", bufferSize="
                        + decoder.getBufferSize() + ", bufferSizeLimit=" + decoder.getBufferSizeLimit() + ".");
            }
            return;
        }
    } catch (Throwable ex) {
        if (logger.isErrorEnabled()) {
            logger.error("Failed to parse " + webSocketMessage + " in session " + session.getId()
                    + ". Sending STOMP ERROR to client.", ex);
        }
        handleError(session, ex, null);
        return;
    }

    for (Message<byte[]> message : messages) {
        try {
            StompHeaderAccessor headerAccessor = MessageHeaderAccessor.getAccessor(message,
                    StompHeaderAccessor.class);
            Assert.state(headerAccessor != null, "No StompHeaderAccessor");

            headerAccessor.setSessionId(session.getId());
            headerAccessor.setSessionAttributes(session.getAttributes());
            headerAccessor.setUser(getUser(session));
            headerAccessor.setHeader(SimpMessageHeaderAccessor.HEART_BEAT_HEADER,
                    headerAccessor.getHeartbeat());
            if (!detectImmutableMessageInterceptor(outputChannel)) {
                headerAccessor.setImmutable();
            }

            if (logger.isTraceEnabled()) {
                logger.trace("From client: " + headerAccessor.getShortLogMessage(message.getPayload()));
            }

            StompCommand command = headerAccessor.getCommand();
            boolean isConnect = StompCommand.CONNECT.equals(command);
            if (isConnect) {
                this.stats.incrementConnectCount();
            } else if (StompCommand.DISCONNECT.equals(command)) {
                this.stats.incrementDisconnectCount();
            }

            try {
                SimpAttributesContextHolder.setAttributesFromMessage(message);
                boolean sent = outputChannel.send(message);

                if (sent) {
                    if (isConnect) {
                        Principal user = headerAccessor.getUser();
                        if (user != null && user != session.getPrincipal()) {
                            this.stompAuthentications.put(session.getId(), user);
                        }
                    }
                    if (this.eventPublisher != null) {
                        Principal user = getUser(session);
                        if (isConnect) {
                            publishEvent(this.eventPublisher, new SessionConnectEvent(this, message, user));
                        } else if (StompCommand.SUBSCRIBE.equals(command)) {
                            publishEvent(this.eventPublisher, new SessionSubscribeEvent(this, message, user));
                        } else if (StompCommand.UNSUBSCRIBE.equals(command)) {
                            publishEvent(this.eventPublisher, new SessionUnsubscribeEvent(this, message, user));
                        }
                    }
                }
            } finally {
                SimpAttributesContextHolder.resetAttributes();
            }
        } catch (Throwable ex) {
            if (logger.isErrorEnabled()) {
                logger.error("Failed to send client message to application via MessageChannel" + " in session "
                        + session.getId() + ". Sending STOMP ERROR to client.", ex);
            }
            handleError(session, ex, message);
        }
    }
}

---