Example usage for org.springframework.messaging.simp.stomp StompHeaderAccessor getCommand

List of usage examples for org.springframework.messaging.simp.stomp StompHeaderAccessor getCommand

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.messaging.simp.stomp.*
  5. StompHeaderAccessor
  6. getCommand

Introduction

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

Prototype

@Nullable
public StompCommand getCommand()

Source Link

Document

Return the STOMP command, or null if not yet set.

Usage

From source file:jp.pigumer.web.StompConfig.java

@Override
public void configureClientInboundChannel(ChannelRegistration registration) {
    registration.setInterceptors(new ChannelInterceptorAdapter() {
        @Override//from   w w  w.  jav a 2  s .  c o m
        public Message<?> preSend(Message<?> message, MessageChannel channel) {
            StompHeaderAccessor accessor = StompHeaderAccessor.wrap(message);
            if (accessor.getCommand() == StompCommand.SUBSCRIBE) {
                LOGGER.log(Level.INFO, String.format("%s: %s", channel, message));
            }
            return message;
        }
    });
}

From source file:com.company.project.config.PresenceChannelInterceptor.java

@Override
public void postSend(Message<?> message, MessageChannel channel, boolean sent) {

    StompHeaderAccessor sha = StompHeaderAccessor.wrap(message);

    // ignore non-STOMP messages like heartbeat messages
    if (sha.getCommand() == null) {
        return;//from  www  .  j  ava  2s. c  o m
    }

    String sessionId = sha.getSessionId();

    switch (sha.getCommand()) {
    case CONNECT:
        logger.debug("STOMP Connect [sessionId: " + sessionId + "]");
        break;
    case CONNECTED:
        logger.debug("STOMP Connected [sessionId: " + sessionId + "]");
        break;
    case DISCONNECT:
        logger.debug("STOMP Disconnect [sessionId: " + sessionId + "]");
        break;
    default:
        break;

    }
}

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

@Override
public void handleMessage(Message<byte[]> message) {
    StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
    Assert.state(accessor != null, "No StompHeaderAccessor");

    accessor.setSessionId(this.sessionId);
    StompCommand command = accessor.getCommand();
    Map<String, List<String>> nativeHeaders = accessor.getNativeHeaders();
    StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(nativeHeaders);
    boolean isHeartbeat = accessor.isHeartbeat();
    if (logger.isTraceEnabled()) {
        logger.trace("Received " + accessor.getDetailedLogMessage(message.getPayload()));
    }/*from w ww.  j  a  va 2  s  .  c o m*/

    try {
        if (StompCommand.MESSAGE.equals(command)) {
            DefaultSubscription subscription = this.subscriptions.get(stompHeaders.getSubscription());
            if (subscription != null) {
                invokeHandler(subscription.getHandler(), message, stompHeaders);
            } else if (logger.isDebugEnabled()) {
                logger.debug("No handler for: " + accessor.getDetailedLogMessage(message.getPayload())
                        + ". Perhaps just unsubscribed?");
            }
        } else {
            if (StompCommand.RECEIPT.equals(command)) {
                String receiptId = stompHeaders.getReceiptId();
                ReceiptHandler handler = this.receiptHandlers.get(receiptId);
                if (handler != null) {
                    handler.handleReceiptReceived();
                } else if (logger.isDebugEnabled()) {
                    logger.debug(
                            "No matching receipt: " + accessor.getDetailedLogMessage(message.getPayload()));
                }
            } else if (StompCommand.CONNECTED.equals(command)) {
                initHeartbeatTasks(stompHeaders);
                this.version = stompHeaders.getFirst("version");
                this.sessionFuture.set(this);
                this.sessionHandler.afterConnected(this, stompHeaders);
            } else if (StompCommand.ERROR.equals(command)) {
                invokeHandler(this.sessionHandler, message, stompHeaders);
            } else if (!isHeartbeat && logger.isTraceEnabled()) {
                logger.trace("Message not handled.");
            }
        }
    } catch (Throwable ex) {
        this.sessionHandler.handleException(this, command, stompHeaders, message.getPayload(), ex);
    }
}

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

@Override
public void handleMessage(Message<?> message) {

    StompHeaderAccessor headers = StompHeaderAccessor.wrap(message);
    String sessionId = headers.getSessionId();
    String destination = headers.getDestination();
    StompCommand command = headers.getCommand();
    SimpMessageType messageType = headers.getMessageType();

    if (!this.running) {
        if (logger.isTraceEnabled()) {
            logger.trace("STOMP broker relay not running. Ignoring message id=" + headers.getId());
        }/*  w w  w  .  j a  v  a2  s. c  om*/
        return;
    }

    if (SimpMessageType.MESSAGE.equals(messageType)) {
        sessionId = (sessionId == null) ? STOMP_RELAY_SYSTEM_SESSION_ID : sessionId;
        headers.setSessionId(sessionId);
        command = (command == null) ? StompCommand.SEND : command;
        headers.setCommandIfNotSet(command);
        message = MessageBuilder.withPayloadAndHeaders(message.getPayload(), headers).build();
    }

    if (headers.getCommand() == null) {
        logger.error("Ignoring message, no STOMP command: " + message);
        return;
    }
    if (sessionId == null) {
        logger.error("Ignoring message, no sessionId: " + message);
        return;
    }

    try {
        if (checkDestinationPrefix(command, destination)) {

            if (logger.isTraceEnabled()) {
                logger.trace("Processing message: " + message);
            }

            if (SimpMessageType.CONNECT.equals(messageType)) {
                headers.setHeartbeat(0, 0); // TODO: disable for now
                message = MessageBuilder.withPayloadAndHeaders(message.getPayload(), headers).build();
                RelaySession session = new RelaySession(sessionId);
                this.relaySessions.put(sessionId, session);
                session.open(message);
            } else if (SimpMessageType.DISCONNECT.equals(messageType)) {
                RelaySession session = this.relaySessions.remove(sessionId);
                if (session == null) {
                    if (logger.isTraceEnabled()) {
                        logger.trace("Session already removed, sessionId=" + sessionId);
                    }
                    return;
                }
                session.forward(message);
            } else {
                RelaySession session = this.relaySessions.get(sessionId);
                if (session == null) {
                    logger.warn("Session id=" + sessionId + " not found. Ignoring message: " + message);
                    return;
                }
                session.forward(message);
            }
        }
    } catch (Throwable t) {
        logger.error("Failed to handle message " + message, t);
    }
}

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

/**
 * Decode a single STOMP frame from the given {@code buffer} into a {@link Message}.
 *//*from   w  ww .j  a v  a 2s  . com*/
@Nullable
private Message<byte[]> decodeMessage(ByteBuffer byteBuffer, @Nullable MultiValueMap<String, String> headers) {
    Message<byte[]> decodedMessage = null;
    skipLeadingEol(byteBuffer);

    // Explicit mark/reset access via Buffer base type for compatibility
    // with covariant return type on JDK 9's ByteBuffer...
    Buffer buffer = byteBuffer;
    buffer.mark();

    String command = readCommand(byteBuffer);
    if (command.length() > 0) {
        StompHeaderAccessor headerAccessor = null;
        byte[] payload = null;
        if (byteBuffer.remaining() > 0) {
            StompCommand stompCommand = StompCommand.valueOf(command);
            headerAccessor = StompHeaderAccessor.create(stompCommand);
            initHeaders(headerAccessor);
            readHeaders(byteBuffer, headerAccessor);
            payload = readPayload(byteBuffer, headerAccessor);
        }
        if (payload != null) {
            if (payload.length > 0) {
                StompCommand stompCommand = headerAccessor.getCommand();
                if (stompCommand != null && !stompCommand.isBodyAllowed()) {
                    throw new StompConversionException(stompCommand + " shouldn't have a payload: length="
                            + payload.length + ", headers=" + headers);
                }
            }
            headerAccessor.updateSimpMessageHeadersFromStompHeaders();
            headerAccessor.setLeaveMutable(true);
            decodedMessage = MessageBuilder.createMessage(payload, headerAccessor.getMessageHeaders());
            if (logger.isTraceEnabled()) {
                logger.trace("Decoded " + headerAccessor.getDetailedLogMessage(payload));
            }
        } else {
            logger.trace("Incomplete frame, resetting input buffer...");
            if (headers != null && headerAccessor != null) {
                String name = NativeMessageHeaderAccessor.NATIVE_HEADERS;
                @SuppressWarnings("unchecked")
                MultiValueMap<String, String> map = (MultiValueMap<String, String>) headerAccessor
                        .getHeader(name);
                if (map != null) {
                    headers.putAll(map);
                }
            }
            buffer.reset();
        }
    } else {
        StompHeaderAccessor headerAccessor = StompHeaderAccessor.createForHeartbeat();
        initHeaders(headerAccessor);
        headerAccessor.setLeaveMutable(true);
        decodedMessage = MessageBuilder.createMessage(HEARTBEAT_PAYLOAD, headerAccessor.getMessageHeaders());
        if (logger.isTraceEnabled()) {
            logger.trace("Decoded " + headerAccessor.getDetailedLogMessage(null));
        }
    }

    return decodedMessage;
}

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

/**
 * Handle STOMP messages going back out to WebSocket clients.
 *//*www  .  j ava  2s  .  co  m*/
@Override
public void handleMessageToClient(WebSocketSession session, Message<?> message) {

    StompHeaderAccessor headers = StompHeaderAccessor.wrap(message);
    headers.setCommandIfNotSet(StompCommand.MESSAGE);

    if (StompCommand.CONNECTED.equals(headers.getCommand())) {
        // Ignore for now since we already sent it
        return;
    }

    if (StompCommand.MESSAGE.equals(headers.getCommand()) && (headers.getSubscriptionId() == null)) {
        // TODO: failed message delivery mechanism
        logger.error("Ignoring message, no subscriptionId header: " + message);
        return;
    }

    if (!(message.getPayload() instanceof byte[])) {
        // TODO: failed message delivery mechanism
        logger.error("Ignoring message, expected byte[] content: " + message);
        return;
    }

    try {
        message = MessageBuilder.withPayloadAndHeaders(message.getPayload(), headers).build();
        byte[] bytes = this.stompMessageConverter.fromMessage(message);
        session.sendMessage(new TextMessage(new String(bytes, Charset.forName("UTF-8"))));
    } catch (Throwable t) {
        sendErrorMessage(session, t);
    } finally {
        if (StompCommand.ERROR.equals(headers.getCommand())) {
            try {
                session.close(CloseStatus.PROTOCOL_ERROR);
            } catch (IOException e) {
            }
        }
    }
}

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

/**
 * Handle STOMP messages going back out to WebSocket clients.
 *//*from www .  ja va2  s . co  m*/
@Override
public void handleMessage(Message<?> message) {

    StompHeaderAccessor headers = StompHeaderAccessor.wrap(message);
    headers.setCommandIfNotSet(StompCommand.MESSAGE);

    if (StompCommand.CONNECTED.equals(headers.getCommand())) {
        // Ignore for now since we already sent it
        return;
    }

    String sessionId = headers.getSessionId();
    if (sessionId == null) {
        // TODO: failed message delivery mechanism
        logger.error("Ignoring message, no sessionId header: " + message);
        return;
    }

    WebSocketSession session = this.sessions.get(sessionId);
    if (session == null) {
        // TODO: failed message delivery mechanism
        logger.error("Ignoring message, sessionId not found: " + message);
        return;
    }

    if (StompCommand.MESSAGE.equals(headers.getCommand()) && (headers.getSubscriptionId() == null)) {
        // TODO: failed message delivery mechanism
        logger.error("Ignoring message, no subscriptionId header: " + message);
        return;
    }

    if (!(message.getPayload() instanceof byte[])) {
        // TODO: failed message delivery mechanism
        logger.error("Ignoring message, expected byte[] content: " + message);
        return;
    }

    try {
        message = MessageBuilder.withPayloadAndHeaders(message.getPayload(), headers).build();
        byte[] bytes = this.stompMessageConverter.fromMessage(message);
        session.sendMessage(new TextMessage(new String(bytes, Charset.forName("UTF-8"))));
    } catch (Throwable t) {
        sendErrorMessage(session, t);
    } finally {
        if (StompCommand.ERROR.equals(headers.getCommand())) {
            try {
                session.close(CloseStatus.PROTOCOL_ERROR);
            } catch (IOException e) {
            }
        }
    }
}

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

/**
 * Handle incoming WebSocket messages from clients.
 */// w  w  w. j  a v a 2  s.  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);
        }
    }
}

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

/**
 * Handle STOMP messages going back out to WebSocket clients.
 */// ww w.jav  a2 s  .c  om
@Override
@SuppressWarnings("unchecked")
public void handleMessageToClient(WebSocketSession session, Message<?> message) {
    if (!(message.getPayload() instanceof byte[])) {
        if (logger.isErrorEnabled()) {
            logger.error("Expected byte[] payload. Ignoring " + message + ".");
        }
        return;
    }

    StompHeaderAccessor accessor = getStompHeaderAccessor(message);
    StompCommand command = accessor.getCommand();

    if (StompCommand.MESSAGE.equals(command)) {
        if (accessor.getSubscriptionId() == null && logger.isWarnEnabled()) {
            logger.warn("No STOMP \"subscription\" header in " + message);
        }
        String origDestination = accessor.getFirstNativeHeader(SimpMessageHeaderAccessor.ORIGINAL_DESTINATION);
        if (origDestination != null) {
            accessor = toMutableAccessor(accessor, message);
            accessor.removeNativeHeader(SimpMessageHeaderAccessor.ORIGINAL_DESTINATION);
            accessor.setDestination(origDestination);
        }
    } else if (StompCommand.CONNECTED.equals(command)) {
        this.stats.incrementConnectedCount();
        accessor = afterStompSessionConnected(message, accessor, session);
        if (this.eventPublisher != null && StompCommand.CONNECTED.equals(command)) {
            try {
                SimpAttributes simpAttributes = new SimpAttributes(session.getId(), session.getAttributes());
                SimpAttributesContextHolder.setAttributes(simpAttributes);
                Principal user = getUser(session);
                publishEvent(this.eventPublisher,
                        new SessionConnectedEvent(this, (Message<byte[]>) message, user));
            } finally {
                SimpAttributesContextHolder.resetAttributes();
            }
        }
    }

    byte[] payload = (byte[]) message.getPayload();
    if (StompCommand.ERROR.equals(command) && getErrorHandler() != null) {
        Message<byte[]> errorMessage = getErrorHandler().handleErrorMessageToClient((Message<byte[]>) message);
        if (errorMessage != null) {
            accessor = MessageHeaderAccessor.getAccessor(errorMessage, StompHeaderAccessor.class);
            Assert.state(accessor != null, "No StompHeaderAccessor");
            payload = errorMessage.getPayload();
        }
    }
    sendToClient(session, accessor, payload);
}

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

private void sendToClient(WebSocketSession session, StompHeaderAccessor stompAccessor, byte[] payload) {
    StompCommand command = stompAccessor.getCommand();
    try {//from www .  j a va 2  s.c  o  m
        byte[] bytes = this.stompEncoder.encode(stompAccessor.getMessageHeaders(), payload);
        boolean useBinary = (payload.length > 0 && !(session instanceof SockJsSession)
                && MimeTypeUtils.APPLICATION_OCTET_STREAM.isCompatibleWith(stompAccessor.getContentType()));
        if (useBinary) {
            session.sendMessage(new BinaryMessage(bytes));
        } else {
            session.sendMessage(new TextMessage(bytes));
        }
    } catch (SessionLimitExceededException ex) {
        // Bad session, just get out
        throw ex;
    } catch (Throwable ex) {
        // Could be part of normal workflow (e.g. browser tab closed)
        if (logger.isDebugEnabled()) {
            logger.debug("Failed to send WebSocket message to client in session " + session.getId(), ex);
        }
        command = StompCommand.ERROR;
    } finally {
        if (StompCommand.ERROR.equals(command)) {
            try {
                session.close(CloseStatus.PROTOCOL_ERROR);
            } catch (IOException ex) {
                // Ignore
            }
        }
    }
}