private StompHeaderAccessor createHeaderAccessor(StompCommand command) { StompHeaderAccessor accessor = StompHeaderAccessor.create(command); accessor.setSessionId(this.sessionId); accessor.setLeaveMutable(true); return accessor; }
@Override @Nullable public Message<byte[]> handleClientMessageProcessingError(@Nullable Message<byte[]> clientMessage, Throwable ex) { StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.ERROR); accessor.setMessage(ex.getMessage()); accessor.setLeaveMutable(true); StompHeaderAccessor clientHeaderAccessor = null; if (clientMessage != null) { clientHeaderAccessor = MessageHeaderAccessor.getAccessor(clientMessage, StompHeaderAccessor.class); if (clientHeaderAccessor != null) { String receiptId = clientHeaderAccessor.getReceipt(); if (receiptId != null) { accessor.setReceiptId(receiptId); } } } return handleInternal(accessor, EMPTY_PAYLOAD, ex, clientHeaderAccessor); }
headerAccessor.setLeaveMutable(true); decodedMessage = MessageBuilder.createMessage(payload, headerAccessor.getMessageHeaders()); if (logger.isTraceEnabled()) { StompHeaderAccessor headerAccessor = StompHeaderAccessor.createForHeartbeat(); initHeaders(headerAccessor); headerAccessor.setLeaveMutable(true); decodedMessage = MessageBuilder.createMessage(HEARTBEAT_PAYLOAD, headerAccessor.getMessageHeaders()); if (logger.isTraceEnabled()) {
@Test public void heartbeatValues() { this.session.afterConnected(this.connection); assertTrue(this.session.isConnected()); this.connectHeaders.setHeartbeat(new long[] {10000, 10000}); StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.CONNECTED); accessor.setVersion("1.2"); accessor.setHeartbeat(20000, 20000); accessor.setLeaveMutable(true); this.session.handleMessage(MessageBuilder.createMessage(new byte[0], accessor.getMessageHeaders())); ArgumentCaptor<Long> writeInterval = ArgumentCaptor.forClass(Long.class); verify(this.connection).onWriteInactivity(any(Runnable.class), writeInterval.capture()); assertEquals(20000, (long) writeInterval.getValue()); ArgumentCaptor<Long> readInterval = ArgumentCaptor.forClass(Long.class); verify(this.connection).onReadInactivity(any(Runnable.class), readInterval.capture()); assertEquals(60000, (long) readInterval.getValue()); }
@Test public void heartbeatTasks() { this.session.afterConnected(this.connection); verify(this.connection).send(any()); this.connectHeaders.setHeartbeat(new long[] {10000, 10000}); StompHeaderAccessor connected = StompHeaderAccessor.create(StompCommand.CONNECTED); connected.setVersion("1.2"); connected.setHeartbeat(10000, 10000); connected.setLeaveMutable(true); this.session.handleMessage(MessageBuilder.createMessage(new byte[0], connected.getMessageHeaders())); ArgumentCaptor<Runnable> writeTaskCaptor = ArgumentCaptor.forClass(Runnable.class); ArgumentCaptor<Runnable> readTaskCaptor = ArgumentCaptor.forClass(Runnable.class); verify(this.connection).onWriteInactivity(writeTaskCaptor.capture(), any(Long.class)); verify(this.connection).onReadInactivity(readTaskCaptor.capture(), any(Long.class)); Runnable writeTask = writeTaskCaptor.getValue(); Runnable readTask = readTaskCaptor.getValue(); assertNotNull(writeTask); assertNotNull(readTask); writeTask.run(); StompHeaderAccessor accessor = StompHeaderAccessor.createForHeartbeat(); Message<byte[]> message = MessageBuilder.createMessage(new byte[] {'\n'}, accessor.getMessageHeaders()); verify(this.connection).send(eq(message)); verifyNoMoreInteractions(this.connection); reset(this.sessionHandler); readTask.run(); verify(this.sessionHandler).handleTransportError(same(this.session), any(IllegalStateException.class)); verifyNoMoreInteractions(this.sessionHandler); }
@Test public void handleErrorFrameWithConversionException() { StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.ERROR); accessor.setContentType(MimeTypeUtils.APPLICATION_JSON); accessor.addNativeHeader("foo", "bar"); accessor.setLeaveMutable(true); byte[] payload = "{'foo':'bar'}".getBytes(StandardCharsets.UTF_8); StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders()); when(this.sessionHandler.getPayloadType(stompHeaders)).thenReturn(Map.class); this.session.handleMessage(MessageBuilder.createMessage(payload, accessor.getMessageHeaders())); verify(this.sessionHandler).getPayloadType(stompHeaders); verify(this.sessionHandler).handleException(same(this.session), same(StompCommand.ERROR), eq(stompHeaders), same(payload), any(MessageConversionException.class)); verifyNoMoreInteractions(this.sessionHandler); }
@Test public void handleErrorFrame() { StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.ERROR); accessor.setContentType(new MimeType("text", "plain", StandardCharsets.UTF_8)); accessor.addNativeHeader("foo", "bar"); accessor.setLeaveMutable(true); String payload = "Oops"; StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders()); when(this.sessionHandler.getPayloadType(stompHeaders)).thenReturn(String.class); this.session.handleMessage(MessageBuilder.createMessage( payload.getBytes(StandardCharsets.UTF_8), accessor.getMessageHeaders())); verify(this.sessionHandler).getPayloadType(stompHeaders); verify(this.sessionHandler).handleFrame(stompHeaders, payload); verifyNoMoreInteractions(this.sessionHandler); }
@Test public void heartbeatNotSupportedByServer() { this.session.afterConnected(this.connection); verify(this.connection).send(any()); this.connectHeaders.setHeartbeat(new long[] {10000, 10000}); StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.CONNECTED); accessor.setVersion("1.2"); accessor.setHeartbeat(0, 0); accessor.setLeaveMutable(true); this.session.handleMessage(MessageBuilder.createMessage(new byte[0], accessor.getMessageHeaders())); verifyNoMoreInteractions(this.connection); }
@Test public void handleErrorFrameWithEmptyPayload() { StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.ERROR); accessor.addNativeHeader("foo", "bar"); accessor.setLeaveMutable(true); this.session.handleMessage(MessageBuilder.createMessage(new byte[0], accessor.getMessageHeaders())); StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders()); verify(this.sessionHandler).handleFrame(stompHeaders, null); verifyNoMoreInteractions(this.sessionHandler); }
@Test public void receiptReceivedBeforeTaskAdded() { this.session.afterConnected(this.connection); this.session.setTaskScheduler(mock(TaskScheduler.class)); AtomicReference<Boolean> received = new AtomicReference<>(); StompHeaders headers = new StompHeaders(); headers.setDestination("/topic/foo"); headers.setReceipt("my-receipt"); Subscription subscription = this.session.subscribe(headers, mock(StompFrameHandler.class)); StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.RECEIPT); accessor.setReceiptId("my-receipt"); accessor.setLeaveMutable(true); this.session.handleMessage(MessageBuilder.createMessage(new byte[0], accessor.getMessageHeaders())); subscription.addReceiptTask(() -> received.set(true)); assertNotNull(received.get()); assertTrue(received.get()); }
@Test public void receiptReceived() { this.session.afterConnected(this.connection); this.session.setTaskScheduler(mock(TaskScheduler.class)); AtomicReference<Boolean> received = new AtomicReference<>(); StompHeaders headers = new StompHeaders(); headers.setDestination("/topic/foo"); headers.setReceipt("my-receipt"); Subscription subscription = this.session.subscribe(headers, mock(StompFrameHandler.class)); subscription.addReceiptTask(() -> received.set(true)); assertNull(received.get()); StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.RECEIPT); accessor.setReceiptId("my-receipt"); accessor.setLeaveMutable(true); this.session.handleMessage(MessageBuilder.createMessage(new byte[0], accessor.getMessageHeaders())); assertNotNull(received.get()); assertTrue(received.get()); }
private void sendStompErrorFrameToClient(String errorText) { if (this.isRemoteClientSession) { StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.ERROR); if (getHeaderInitializer() != null) { getHeaderInitializer().initHeaders(accessor); } accessor.setSessionId(this.sessionId); Principal user = this.connectHeaders.getUser(); if (user != null) { accessor.setUser(user); } accessor.setMessage(errorText); accessor.setLeaveMutable(true); Message<?> errorMessage = MessageBuilder.createMessage(EMPTY_PAYLOAD, accessor.getMessageHeaders()); handleInboundMessage(errorMessage); } }
@Test public void handleMessageFrame() { this.session.afterConnected(this.connection); StompFrameHandler frameHandler = mock(StompFrameHandler.class); String destination = "/topic/foo"; Subscription subscription = this.session.subscribe(destination, frameHandler); StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.MESSAGE); accessor.setDestination(destination); accessor.setSubscriptionId(subscription.getSubscriptionId()); accessor.setContentType(MimeTypeUtils.TEXT_PLAIN); accessor.setMessageId("1"); accessor.setLeaveMutable(true); String payload = "sample payload"; StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders()); when(frameHandler.getPayloadType(stompHeaders)).thenReturn(String.class); this.session.handleMessage(MessageBuilder.createMessage(payload.getBytes(StandardCharsets.UTF_8), accessor.getMessageHeaders())); verify(frameHandler).getPayloadType(stompHeaders); verify(frameHandler).handleFrame(stompHeaders, payload); verifyNoMoreInteractions(frameHandler); }
@Test public void handleMessageFrameWithConversionException() { this.session.afterConnected(this.connection); assertTrue(this.session.isConnected()); StompFrameHandler frameHandler = mock(StompFrameHandler.class); String destination = "/topic/foo"; Subscription subscription = this.session.subscribe(destination, frameHandler); StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.MESSAGE); accessor.setDestination(destination); accessor.setSubscriptionId(subscription.getSubscriptionId()); accessor.setContentType(MimeTypeUtils.APPLICATION_JSON); accessor.setMessageId("1"); accessor.setLeaveMutable(true); byte[] payload = "{'foo':'bar'}".getBytes(StandardCharsets.UTF_8); StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders()); when(frameHandler.getPayloadType(stompHeaders)).thenReturn(Map.class); this.session.handleMessage(MessageBuilder.createMessage(payload, accessor.getMessageHeaders())); verify(frameHandler).getPayloadType(stompHeaders); verifyNoMoreInteractions(frameHandler); verify(this.sessionHandler).handleException(same(this.session), same(StompCommand.MESSAGE), eq(stompHeaders), same(payload), any(MessageConversionException.class)); verifyNoMoreInteractions(this.sessionHandler); }
private Message<byte[]> message(StompCommand command, String sessionId, String user, String destination) { StompHeaderAccessor accessor = StompHeaderAccessor.create(command); if (sessionId != null) { accessor.setSessionId(sessionId); } if (user != null) { accessor.setUser(new TestPrincipal(user)); } if (destination != null) { accessor.setDestination(destination); } accessor.setLeaveMutable(true); return MessageBuilder.createMessage(new byte[0], accessor.getMessageHeaders()); }
@Test public void systemSubscription() throws Exception { MessageHandler handler = mock(MessageHandler.class); this.brokerRelay.setSystemSubscriptions(Collections.singletonMap("/topic/foo", handler)); this.brokerRelay.start(); StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.CONNECTED); accessor.setLeaveMutable(true); MessageHeaders headers = accessor.getMessageHeaders(); this.tcpClient.handleMessage(MessageBuilder.createMessage(new byte[0], headers)); assertEquals(2, this.tcpClient.getSentMessages().size()); assertEquals(StompCommand.CONNECT, this.tcpClient.getSentHeaders(0).getCommand()); assertEquals(StompCommand.SUBSCRIBE, this.tcpClient.getSentHeaders(1).getCommand()); assertEquals("/topic/foo", this.tcpClient.getSentHeaders(1).getDestination()); Message<byte[]> message = message(StompCommand.MESSAGE, null, null, "/topic/foo"); this.tcpClient.handleMessage(message); ArgumentCaptor<Message> captor = ArgumentCaptor.forClass(Message.class); verify(handler).handleMessage(captor.capture()); assertSame(message, captor.getValue()); }
@Test public void handleMessageFromBrokerWithActiveSession() { TestSimpUser simpUser = new TestSimpUser("joe"); simpUser.addSessions(new TestSimpSession("123")); when(this.registry.getUser("joe")).thenReturn(simpUser); this.handler.setBroadcastDestination("/topic/unresolved"); given(this.brokerChannel.send(Mockito.any(Message.class))).willReturn(true); StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.MESSAGE); accessor.setSessionId("system123"); accessor.setDestination("/topic/unresolved"); accessor.setNativeHeader(ORIGINAL_DESTINATION, "/user/joe/queue/foo"); accessor.setNativeHeader("customHeader", "customHeaderValue"); accessor.setLeaveMutable(true); byte[] payload = "payload".getBytes(StandardCharsets.UTF_8); this.handler.handleMessage(MessageBuilder.createMessage(payload, accessor.getMessageHeaders())); ArgumentCaptor<Message> captor = ArgumentCaptor.forClass(Message.class); Mockito.verify(this.brokerChannel).send(captor.capture()); assertNotNull(captor.getValue()); SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.wrap(captor.getValue()); assertEquals("/queue/foo-user123", headers.getDestination()); assertEquals("/user/queue/foo", headers.getFirstNativeHeader(ORIGINAL_DESTINATION)); assertEquals("customHeaderValue", headers.getFirstNativeHeader("customHeader")); assertArrayEquals(payload, (byte[]) captor.getValue().getPayload()); }
@Test public void handleMessageFromBrokerWithoutActiveSession() { this.handler.setBroadcastDestination("/topic/unresolved"); given(this.brokerChannel.send(Mockito.any(Message.class))).willReturn(true); StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.MESSAGE); accessor.setSessionId("system123"); accessor.setDestination("/topic/unresolved"); accessor.setNativeHeader(ORIGINAL_DESTINATION, "/user/joe/queue/foo"); accessor.setLeaveMutable(true); byte[] payload = "payload".getBytes(StandardCharsets.UTF_8); this.handler.handleMessage(MessageBuilder.createMessage(payload, accessor.getMessageHeaders())); // No re-broadcast verifyNoMoreInteractions(this.brokerChannel); }
@Test public void handleConnectedFrame() { this.session.afterConnected(this.connection); assertTrue(this.session.isConnected()); this.connectHeaders.setHeartbeat(new long[] {10000, 10000}); StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.CONNECTED); accessor.setVersion("1.2"); accessor.setHeartbeat(10000, 10000); accessor.setLeaveMutable(true); this.session.handleMessage(MessageBuilder.createMessage(new byte[0], accessor.getMessageHeaders())); StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders()); verify(this.sessionHandler).afterConnected(this.session, stompHeaders); verifyNoMoreInteractions(this.sessionHandler); }
private StompHeaderAccessor createHeaderAccessor(StompCommand command) { StompHeaderAccessor accessor = StompHeaderAccessor.create(command); accessor.setSessionId(this.sessionId); accessor.setLeaveMutable(true); return accessor; }