root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 8 Packages Projects Releases Wiki Activity

Publish events about broker's availability 

Components that are using a StompBrokerRelayMessageHandler may want
to know whether or not the broker's unavailable. If they're sending
messages to the relay via an asynchronous channel there's currently
no way for them to find this out.

This commit enhances StompBrokerRelayMessageHandler to publish
application events when the broker's availability changes:
BrokerBecameAvailableEvent and BrokerBecameUnavailableEvent.
Irrespective of the number of relay sessions only a single event is
published for each change in the broker's availability.
This commit is contained in:
Andy Wilkinson 2013-08-08 16:07:01 +01:00 committed by Rossen Stoyanchev
parent be6dbe54a3
commit 8b48d8f445
7 changed files with 268 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
build.gradle
View File

@ -323,6 +323,7 @@ project("spring-messaging") {
optional("com.lmax:disruptor:3.1.1")
testCompile("commons-dbcp:commons-dbcp:1.2.2")
testCompile("javax.inject:javax.inject-tck:1")
testCompile(project(":spring-test"))
}
repositories {

33
spring-messaging/src/main/java/org/springframework/messaging/simp/stomp/BrokerAvailabilityEvent.java Normal file
View File

@ -0,0 +1,33 @@
/*
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.messaging.simp.stomp;
import org.springframework.context.ApplicationEvent;
/**
* Base class for application events relating to broker availability.
*
* @author Andy Wilkinson
*/
public abstract class BrokerAvailabilityEvent extends ApplicationEvent {
protected BrokerAvailabilityEvent(Object source) {
super(source);
}
}

38
spring-messaging/src/main/java/org/springframework/messaging/simp/stomp/BrokerBecameAvailableEvent.java Normal file
View File

@ -0,0 +1,38 @@
/*
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.messaging.simp.stomp;
/**
* Event raised when the broker being used by a {@link
* StompBrokerRelayMessageHandler} becomes available
*
* @author Andy Wilkinson
*/
public class BrokerBecameAvailableEvent extends BrokerAvailabilityEvent {
/**
* Creates a new BrokerBecameAvailableEvent
*
* @param source the {@code StompBrokerRelayMessageHandler} that is acting
* as a relay for the broker that has become available. Must not be {@code
* null}.
*/
public BrokerBecameAvailableEvent(StompBrokerRelayMessageHandler source) {
super(source);
}
}

39
spring-messaging/src/main/java/org/springframework/messaging/simp/stomp/BrokerBecameUnavailableEvent.java Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.messaging.simp.stomp;
/**
* Event raised when the broker being used by a {@link
* StompBrokerRelayMessageHandler} becomes unavailable
*
* @author Andy Wilkinson
*/
public class BrokerBecameUnavailableEvent extends BrokerAvailabilityEvent {
/**
* Creates a new BrokerBecameUnavailableEvent
*
* @param source the {@code StompBrokerRelayMessageHandler} that is acting
* as a relay for the broker that has become unavailable. Must not be {@code
* null}.
*/
public BrokerBecameUnavailableEvent(StompBrokerRelayMessageHandler source) {
super(source);
}
}

34
spring-messaging/src/main/java/org/springframework/messaging/simp/stomp/StompBrokerRelayMessageHandler.java
View File

@ -24,9 +24,13 @@ import java.util.Map;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicBoolean;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.context.SmartLifecycle;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
@ -51,9 +55,11 @@ import reactor.tcp.spec.TcpClientSpec;
/**
* @author Rossen Stoyanchev
* @author Andy Wilkinson
*
* @since 4.0
*/
public class StompBrokerRelayMessageHandler implements MessageHandler, SmartLifecycle {
public class StompBrokerRelayMessageHandler implements MessageHandler, SmartLifecycle, ApplicationEventPublisherAware {
private static final Log logger = LogFactory.getLog(StompBrokerRelayMessageHandler.class);
@ -63,6 +69,8 @@ public class StompBrokerRelayMessageHandler implements MessageHandler, SmartLife
private final String[] destinationPrefixes;
private ApplicationEventPublisher applicationEventPublisher;
private String relayHost = "127.0.0.1";
private int relayPort = 61613;
@ -83,6 +91,7 @@ public class StompBrokerRelayMessageHandler implements MessageHandler, SmartLife
private boolean running = false;
private AtomicBoolean brokerAvailable = new AtomicBoolean(false);
/**
* @param messageChannel the channel to send messages from the STOMP broker to
@ -197,6 +206,12 @@ public class StompBrokerRelayMessageHandler implements MessageHandler, SmartLife
}
}
@Override
public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher)
throws BeansException {
this.applicationEventPublisher = applicationEventPublisher;
}
/**
* Open a "system" session for sending messages from parts of the application
* not associated with a client STOMP session.
@ -342,6 +357,18 @@ public class StompBrokerRelayMessageHandler implements MessageHandler, SmartLife
return false;
}
private void brokerAvailable() {
if (this.brokerAvailable.compareAndSet(false, true)) {
this.applicationEventPublisher.publishEvent(new BrokerBecameAvailableEvent(this));
}
}
private void brokerUnavailable() {
if (this.brokerAvailable.compareAndSet(true, false)) {
this.applicationEventPublisher.publishEvent(new BrokerBecameUnavailableEvent(this));
}
}
private class RelaySession {
@ -356,7 +383,7 @@ public class StompBrokerRelayMessageHandler implements MessageHandler, SmartLife
private final Object monitor = new Object();
public RelaySession(String sessionId) {
private RelaySession(String sessionId) {
Assert.notNull(sessionId, "sessionId is required");
this.sessionId = sessionId;
}
@ -404,6 +431,7 @@ public class StompBrokerRelayMessageHandler implements MessageHandler, SmartLife
if (StompCommand.CONNECTED == headers.getCommand()) {
synchronized(this.monitor) {
this.isConnected = true;
brokerAvailable();
flushMessages(this.promise.get());
}
return;
@ -419,6 +447,8 @@ public class StompBrokerRelayMessageHandler implements MessageHandler, SmartLife
}
private void sendError(String sessionId, String errorText) {
brokerUnavailable();
StompHeaderAccessor headers = StompHeaderAccessor.create(StompCommand.ERROR);
headers.setSessionId(sessionId);
headers.setMessage(errorText);

114
spring-messaging/src/test/java/org/springframework/messaging/simp/stomp/StompBrokerRelayMessageHandlerIntegrationTests.java
View File

@ -17,20 +17,34 @@
package org.springframework.messaging.simp.stomp;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.Message;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.MessageHandler;
import org.springframework.messaging.MessagingException;
import org.springframework.messaging.SubscribableChannel;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.messaging.support.channel.ExecutorSubscribableChannel;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.annotation.DirtiesContext.ClassMode;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.util.SocketUtils;
import static org.junit.Assert.*;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
/**
@ -38,20 +52,29 @@ import static org.junit.Assert.*;
*
* @author Andy Wilkinson
*/
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {StompBrokerRelayMessageHandlerIntegrationTests.TestConfiguration.class})
@DirtiesContext(classMode=ClassMode.AFTER_EACH_TEST_METHOD)
public class StompBrokerRelayMessageHandlerIntegrationTests {
private final SubscribableChannel messageChannel = new ExecutorSubscribableChannel();
@Autowired
private SubscribableChannel messageChannel;
private final StompBrokerRelayMessageHandler relay =
new StompBrokerRelayMessageHandler(messageChannel, Arrays.asList("/queue/", "/topic/"));
@Autowired
private StompBrokerRelayMessageHandler relay;
@Autowired
private TestStompBroker stompBroker;
@Autowired
private ApplicationContext applicationContext;
@Autowired
private BrokerAvailabilityListener brokerAvailabilityListener;
@Test
public void basicPublishAndSubscribe() throws IOException, InterruptedException {
int port = SocketUtils.findAvailableTcpPort();
TestStompBroker stompBroker = new TestStompBroker(port);
stompBroker.start();
String client1SessionId = "abc123";
String client2SessionId = "def456";
@ -70,9 +93,6 @@ public class StompBrokerRelayMessageHandlerIntegrationTests {
});
relay.setRelayPort(port);
relay.start();
relay.handleMessage(createConnectMessage(client1SessionId));
relay.handleMessage(createConnectMessage(client2SessionId));
relay.handleMessage(createSubscribeMessage(client1SessionId, "/topic/test"));
@ -83,17 +103,13 @@ public class StompBrokerRelayMessageHandlerIntegrationTests {
assertTrue(messageLatch.await(30, TimeUnit.SECONDS));
this.relay.stop();
stompBroker.stop();
assertEquals(1, brokerAvailabilityListener.availabilityEvents.size());
assertTrue(brokerAvailabilityListener.availabilityEvents.get(0) instanceof BrokerBecameAvailableEvent);
}
@Test
public void whenConnectFailsDueToTheBrokerBeingUnavailableAnErrorFrameIsSentToTheClient()
throws IOException, InterruptedException {
int port = SocketUtils.findAvailableTcpPort();
TestStompBroker stompBroker = new TestStompBroker(port);
stompBroker.start();
String sessionId = "abc123";
@ -111,25 +127,25 @@ public class StompBrokerRelayMessageHandlerIntegrationTests {
});
relay.setRelayPort(port);
relay.start();
stompBroker.awaitMessages(1);
assertEquals(1, brokerAvailabilityListener.availabilityEvents.size());
assertTrue(brokerAvailabilityListener.availabilityEvents.get(0) instanceof BrokerBecameAvailableEvent);
stompBroker.stop();
relay.handleMessage(createConnectMessage(sessionId));
errorLatch.await(30, TimeUnit.SECONDS);
assertEquals(2, brokerAvailabilityListener.availabilityEvents.size());
assertTrue(brokerAvailabilityListener.availabilityEvents.get(0) instanceof BrokerBecameAvailableEvent);
assertTrue(brokerAvailabilityListener.availabilityEvents.get(1) instanceof BrokerBecameUnavailableEvent);
}
@Test
public void whenSendFailsDueToTheBrokerBeingUnavailableAnErrorFrameIsSentToTheClient()
throws IOException, InterruptedException {
int port = SocketUtils.findAvailableTcpPort();
TestStompBroker stompBroker = new TestStompBroker(port);
stompBroker.start();
String sessionId = "abc123";
@ -147,18 +163,22 @@ public class StompBrokerRelayMessageHandlerIntegrationTests {
});
relay.setRelayPort(port);
relay.start();
relay.handleMessage(createConnectMessage(sessionId));
stompBroker.awaitMessages(2);
assertEquals(1, brokerAvailabilityListener.availabilityEvents.size());
assertTrue(brokerAvailabilityListener.availabilityEvents.get(0) instanceof BrokerBecameAvailableEvent);
stompBroker.stop();
relay.handleMessage(createSubscribeMessage(sessionId, "/topic/test/"));
errorLatch.await(30, TimeUnit.SECONDS);
assertEquals(2, brokerAvailabilityListener.availabilityEvents.size());
assertTrue(brokerAvailabilityListener.availabilityEvents.get(0) instanceof BrokerBecameAvailableEvent);
assertTrue(brokerAvailabilityListener.availabilityEvents.get(1) instanceof BrokerBecameUnavailableEvent);
}
private Message<?> createConnectMessage(String sessionId) {
@ -183,4 +203,44 @@ public class StompBrokerRelayMessageHandlerIntegrationTests {
return MessageBuilder.withPayloadAndHeaders(payload.getBytes(), headers).build();
}
@Configuration
public static class TestConfiguration {
@Bean
public MessageChannel messageChannel() {
return new ExecutorSubscribableChannel();
}
@Bean
public StompBrokerRelayMessageHandler relay() {
StompBrokerRelayMessageHandler relay =
new StompBrokerRelayMessageHandler(messageChannel(), Arrays.asList("/queue/", "/topic/"));
relay.setRelayPort(SocketUtils.findAvailableTcpPort());
return relay;
}
@Bean
public TestStompBroker broker() throws IOException {
TestStompBroker broker = new TestStompBroker(relay().getRelayPort());
return broker;
}
@Bean
public BrokerAvailabilityListener availabilityListener() {
return new BrokerAvailabilityListener();
}
}
private static class BrokerAvailabilityListener implements ApplicationListener<BrokerAvailabilityEvent> {
private final List<BrokerAvailabilityEvent> availabilityEvents = new ArrayList<BrokerAvailabilityEvent>();
@Override
public void onApplicationEvent(BrokerAvailabilityEvent event) {
this.availabilityEvents.add(event);
}
}
}

43
spring-messaging/src/test/java/org/springframework/messaging/simp/stomp/TestStompBroker.java
View File

@ -25,8 +25,10 @@ import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicLong;
import org.springframework.context.SmartLifecycle;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.util.StringUtils;
import reactor.core.Environment;
import reactor.function.Consumer;
@ -40,7 +42,7 @@ import reactor.tcp.spec.TcpServerSpec;
/**
* @author Andy Wilkinson
*/
class TestStompBroker {
class TestStompBroker implements SmartLifecycle {
private final StompMessageConverter messageConverter = new StompMessageConverter();
@ -60,11 +62,13 @@ class TestStompBroker {
private volatile TcpServer tcpServer;
private volatile boolean running;
TestStompBroker(int port) {
this.port = port;
}
public void start() throws IOException {
public void start() {
this.environment = new Environment();
this.tcpServer = new TcpServerSpec<String, String>(NettyTcpServer.class)
@ -78,7 +82,9 @@ class TestStompBroker {
connection.consume(new Consumer<String>() {
@Override
public void accept(String stompFrame) {
handleMessage(messageConverter.toMessage(stompFrame), connection);
if (!StringUtils.isEmpty(stompFrame)) {
handleMessage(messageConverter.toMessage(stompFrame), connection);
}
}
});
}
@ -86,10 +92,16 @@ class TestStompBroker {
.get();
this.tcpServer.start();
this.running = true;
}
public void stop() throws IOException, InterruptedException {
this.tcpServer.shutdown().await();
public void stop() {
try {
this.tcpServer.shutdown().await();
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
}
this.running = false;
}
private void handleMessage(Message<?> message, TcpConnection<String, String> connection) {
@ -158,4 +170,25 @@ class TestStompBroker {
}
}
@Override
public boolean isRunning() {
return this.running;
}
@Override
public int getPhase() {
return Integer.MIN_VALUE;
}
@Override
public boolean isAutoStartup() {
return true;
}
@Override
public void stop(Runnable callback) {
this.stop();
callback.run();
}
}