/** * Further initialize the StompHeaders, for example setting the heart-beat * header if necessary. * @param connectHeaders the headers to modify * @return the modified headers */ protected StompHeaders processConnectHeaders(@Nullable StompHeaders connectHeaders) { connectHeaders = (connectHeaders != null ? connectHeaders : new StompHeaders()); if (connectHeaders.getHeartbeat() == null) { connectHeaders.setHeartbeat(getDefaultHeartbeat()); } return connectHeaders; }
public DefaultSubscription(StompHeaders headers, StompFrameHandler handler) { super(headers.getReceipt()); Assert.notNull(headers.getDestination(), "Destination must not be null"); Assert.notNull(handler, "StompFrameHandler must not be null"); this.headers = headers; this.handler = handler; DefaultStompSession.this.subscriptions.put(headers.getId(), this); }
/** * Get the host header. */ @Nullable public String getHost() { return getFirst(HOST); }
@Override public Receiptable acknowledge(String messageId, boolean consumed) { StompHeaders headers = new StompHeaders(); if ("1.1".equals(this.version)) { headers.setMessageId(messageId); } else { headers.setId(messageId); } return acknowledge(headers, consumed); }
@Test // SPR-15131 public void unsubscribeWithCustomHeader() { this.session.afterConnected(this.connection); assertTrue(this.session.isConnected()); String headerName = "durable-subscription-name"; String headerValue = "123"; StompHeaders subscribeHeaders = new StompHeaders(); subscribeHeaders.setDestination("/topic/foo"); subscribeHeaders.set(headerName, headerValue); StompFrameHandler frameHandler = mock(StompFrameHandler.class); Subscription subscription = this.session.subscribe(subscribeHeaders, frameHandler); StompHeaders unsubscribeHeaders = new StompHeaders(); unsubscribeHeaders.set(headerName, subscription.getSubscriptionHeaders().getFirst(headerName)); subscription.unsubscribe(unsubscribeHeaders); Message<byte[]> message = this.messageCaptor.getValue(); StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class); assertEquals(StompCommand.UNSUBSCRIBE, accessor.getCommand()); StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders()); assertEquals(stompHeaders.toString(), 2, stompHeaders.size()); assertEquals(subscription.getSubscriptionId(), stompHeaders.getId()); assertEquals(headerValue, stompHeaders.getFirst(headerName)); }
@Test public void subscribeWithHeaders() { this.session.afterConnected(this.connection); assertTrue(this.session.isConnected()); String subscriptionId = "123"; String destination = "/topic/foo"; StompHeaders stompHeaders = new StompHeaders(); stompHeaders.setId(subscriptionId); stompHeaders.setDestination(destination); StompFrameHandler frameHandler = mock(StompFrameHandler.class); Subscription subscription = this.session.subscribe(stompHeaders, frameHandler); assertEquals(subscriptionId, subscription.getSubscriptionId()); Message<byte[]> message = this.messageCaptor.getValue(); StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class); assertEquals(StompCommand.SUBSCRIBE, accessor.getCommand()); stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders()); assertEquals(stompHeaders.toString(), 2, stompHeaders.size()); assertEquals(destination, stompHeaders.getDestination()); assertEquals(subscriptionId, stompHeaders.getId()); }
@Test public void subscribe() { this.session.afterConnected(this.connection); assertTrue(this.session.isConnected()); String destination = "/topic/foo"; StompFrameHandler frameHandler = mock(StompFrameHandler.class); Subscription subscription = this.session.subscribe(destination, frameHandler); Message<byte[]> message = this.messageCaptor.getValue(); StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class); assertEquals(StompCommand.SUBSCRIBE, accessor.getCommand()); StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders()); assertEquals(stompHeaders.toString(), 2, stompHeaders.size()); assertEquals(destination, stompHeaders.getDestination()); assertEquals(subscription.getSubscriptionId(), stompHeaders.getId()); }
@Test @SuppressWarnings({ "unchecked", "rawtypes" }) public void receiptNotReceived() { TaskScheduler taskScheduler = mock(TaskScheduler.class); this.session.afterConnected(this.connection); this.session.setTaskScheduler(taskScheduler); AtomicReference<Boolean> notReceived = new AtomicReference<>(); ScheduledFuture future = mock(ScheduledFuture.class); when(taskScheduler.schedule(any(Runnable.class), any(Date.class))).thenReturn(future); StompHeaders headers = new StompHeaders(); headers.setDestination("/topic/foo"); headers.setReceipt("my-receipt"); Receiptable receiptable = this.session.send(headers, "payload"); receiptable.addReceiptLostTask(() -> notReceived.set(true)); ArgumentCaptor<Runnable> taskCaptor = ArgumentCaptor.forClass(Runnable.class); verify(taskScheduler).schedule(taskCaptor.capture(), (Date) notNull()); Runnable scheduledTask = taskCaptor.getValue(); assertNotNull(scheduledTask); assertNull(notReceived.get()); scheduledTask.run(); assertTrue(notReceived.get()); verify(future).cancel(true); verifyNoMoreInteractions(future); }
@Override public Receiptable send(String destination, Object payload) { StompHeaders headers = new StompHeaders(); headers.setDestination(destination); return send(headers, payload); }
private void setStompHeader(StompHeaders target, String name, Object value) { if (StompHeaders.CONTENT_LENGTH.equals(name)) { if (value instanceof Number) { target.setContentLength(((Number) value).longValue()); target.setContentLength(Long.parseLong((String) value)); MimeType contentType = target.getContentType(); if (contentType == null || StompHeaders.CONTENT_TYPE.equals(name)) { if (value instanceof MediaType) { target.setContentType((MediaType) value); target.setContentType(MediaType.parseMediaType((String) value)); target.setDestination((String) value); target.setReceipt((String) value); target.set(name, (String) value);
@Override public Subscription subscribe(StompHeaders headers, StompFrameHandler handler) { Assert.hasText(headers.getDestination(), "Destination header is required"); Assert.notNull(handler, "StompFrameHandler must not be null"); String subscriptionId = headers.getId(); if (!StringUtils.hasText(subscriptionId)) { subscriptionId = String.valueOf(DefaultStompSession.this.subscriptionIndex.getAndIncrement()); headers.setId(subscriptionId); } checkOrAddReceipt(headers); Subscription subscription = new DefaultSubscription(headers, handler); StompHeaderAccessor accessor = createHeaderAccessor(StompCommand.SUBSCRIBE); accessor.addNativeHeaders(headers); Message<byte[]> message = createMessage(accessor, EMPTY_PAYLOAD); execute(message); return subscription; }
/** * Set the host header. * Applies to the CONNECT frame. */ public void setHost(@Nullable String host) { set(HOST, host); }
@Test @SuppressWarnings({"unchecked", "rawtypes"}) public void handleWebSocketMessageBinary() throws Exception { String text = "SEND\na:alpha\n\nMessage payload\0"; connect().handleMessage(this.webSocketSession, new BinaryMessage(text.getBytes(StandardCharsets.UTF_8))); ArgumentCaptor<Message> captor = ArgumentCaptor.forClass(Message.class); verify(this.stompSession).handleMessage(captor.capture()); Message<byte[]> message = captor.getValue(); assertNotNull(message); StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class); StompHeaders headers = StompHeaders.readOnlyStompHeaders(accessor.toNativeHeaderMap()); assertEquals(StompCommand.SEND, accessor.getCommand()); assertEquals("alpha", headers.getFirst("a")); assertEquals("Message payload", new String(message.getPayload(), StandardCharsets.UTF_8)); }
@Test public void send() { this.session.afterConnected(this.connection); assertTrue(this.session.isConnected()); String destination = "/topic/foo"; String payload = "sample payload"; this.session.send(destination, payload); Message<byte[]> message = this.messageCaptor.getValue(); StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class); assertEquals(StompCommand.SEND, accessor.getCommand()); StompHeaders stompHeaders = StompHeaders.readOnlyStompHeaders(accessor.getNativeHeaders()); assertEquals(stompHeaders.toString(), 2, stompHeaders.size()); assertEquals(destination, stompHeaders.getDestination()); assertEquals(new MimeType("text", "plain", StandardCharsets.UTF_8), stompHeaders.getContentType()); assertEquals(-1, stompHeaders.getContentLength()); // StompEncoder isn't involved assertEquals(payload, new String(message.getPayload(), StandardCharsets.UTF_8)); }
StompHeaders stompHeaders = new StompHeaders(); this.headerMapper.fromHeaders(message.getHeaders(), stompHeaders); if (stompHeaders.getDestination() == null) { Assert.state(this.destinationExpression != null, "One of 'destination' or 'destinationExpression' must " + "be" + " provided, if message header doesn't supply 'destination' STOMP header."); String destination = this.destinationExpression.getValue(this.evaluationContext, message, String.class); stompHeaders.setDestination(destination); final String destination = stompHeaders.getDestination(); final ApplicationEventPublisher eventPublisher = this.applicationEventPublisher; if (eventPublisher != null) {
@Nullable private String checkOrAddReceipt(StompHeaders headers) { String receiptId = headers.getReceipt(); if (isAutoReceiptEnabled() && receiptId == null) { receiptId = String.valueOf(DefaultStompSession.this.receiptIndex.getAndIncrement()); headers.setReceipt(receiptId); } return receiptId; }
/** * Whether heartbeats are enabled. Returns {@code false} if * {@link #setHeartbeat} is set to "0,0", and {@code true} otherwise. */ public boolean isHeartbeatEnabled() { long[] heartbeat = getHeartbeat(); return (heartbeat != null && heartbeat[0] != 0 && heartbeat[1] != 0); }
@Override public String toString() { return "Subscription [id=" + getSubscriptionId() + ", destination='" + this.headers.getDestination() + "', receiptId='" + getReceiptId() + "', handler=" + getHandler() + "]"; } }
@Test public void sendWithConversionException() { this.session.afterConnected(this.connection); assertTrue(this.session.isConnected()); StompHeaders stompHeaders = new StompHeaders(); stompHeaders.setDestination("/topic/foo"); stompHeaders.setContentType(MimeTypeUtils.APPLICATION_JSON); String payload = "{'foo':'bar'}"; this.expected.expect(MessageConversionException.class); this.session.send(stompHeaders, payload); verifyNoMoreInteractions(this.connection); }
@Bean public StompSessionManager stompSessionManager(WebSocketStompClient stompClient) { WebSocketStompSessionManager webSocketStompSessionManager = new WebSocketStompSessionManager(stompClient, server().getWsBaseUrl() + "/ws"); webSocketStompSessionManager.setAutoReceipt(true); webSocketStompSessionManager.setRecoveryInterval(1000); WebSocketHttpHeaders handshakeHeaders = new WebSocketHttpHeaders(); handshakeHeaders.setOrigin("http://foo.com"); webSocketStompSessionManager.setHandshakeHeaders(handshakeHeaders); StompHeaders stompHeaders = new StompHeaders(); stompHeaders.setHeartbeat(new long[] { 10000, 10000 }); webSocketStompSessionManager.setConnectHeaders(stompHeaders); return webSocketStompSessionManager; }