Add endpoint connection manager

spring-websocket/src/main/java/org/springframework/websocket/client/AbstractEndpointConnectionManager.java

@@ -0,0 +1,227 @@
+/*
+ * 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.websocket.client;
+
+import java.io.IOException;
+import java.net.URI;
+
+import javax.websocket.ContainerProvider;
+import javax.websocket.DeploymentException;
+import javax.websocket.Session;
+import javax.websocket.WebSocketContainer;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.springframework.beans.BeansException;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.ApplicationContextAware;
+import org.springframework.context.SmartLifecycle;
+import org.springframework.core.task.SimpleAsyncTaskExecutor;
+import org.springframework.core.task.TaskExecutor;
+import org.springframework.util.Assert;
+import org.springframework.web.util.UriComponentsBuilder;
+
+
+/**
+ *
+ * @author Rossen Stoyanchev
+ * @since 4.0
+ */
+public abstract class AbstractEndpointConnectionManager implements ApplicationContextAware, SmartLifecycle {
+
+	protected final Log logger = LogFactory.getLog(getClass());
+
+	private final Class<?> endpointClass;
+
+	private final Object endpointBean;
+
+	private final URI uri;
+
+	private boolean autoStartup = false;
+
+	private int phase = Integer.MAX_VALUE;
+
+	private final WebSocketContainer webSocketContainer = ContainerProvider.getWebSocketContainer();
+
+	private Session session;
+
+	private ApplicationContext applicationContext;
+
+	private TaskExecutor taskExecutor = new SimpleAsyncTaskExecutor("EndpointConnectionManager-");
+
+	private final Object lifecycleMonitor = new Object();
+
+
+	public AbstractEndpointConnectionManager(Class<?> endpointClass, String uriTemplate, Object... uriVariables) {
+		Assert.notNull(endpointClass, "endpointClass is required");
+		this.endpointClass = endpointClass;
+		this.endpointBean = null;
+		this.uri = initUri(uriTemplate, uriVariables);
+	}
+
+	public AbstractEndpointConnectionManager(Object endpointBean, String uriTemplate, Object... uriVariables) {
+		Assert.notNull(endpointBean, "endpointBean is required");
+		this.endpointClass = null;
+		this.endpointBean = endpointBean;
+		this.uri = initUri(uriTemplate, uriVariables);
+	}
+
+	private static URI initUri(String uri, Object... uriVariables) {
+		return UriComponentsBuilder.fromUriString(uri).buildAndExpand(uriVariables).encode().toUri();
+	}
+
+	public void setAsyncSendTimeout(long timeoutInMillis) {
+		this.webSocketContainer.setAsyncSendTimeout(timeoutInMillis);
+	}
+
+	public void setMaxSessionIdleTimeout(long timeoutInMillis) {
+		this.webSocketContainer.setDefaultMaxSessionIdleTimeout(timeoutInMillis);
+	}
+
+	public void setMaxTextMessageBufferSize(int bufferSize) {
+		this.webSocketContainer.setDefaultMaxTextMessageBufferSize(bufferSize);
+	}
+
+	public void setMaxBinaryMessageBufferSize(Integer bufferSize) {
+		this.webSocketContainer.setDefaultMaxBinaryMessageBufferSize(bufferSize);
+	}
+
+	/**
+	 * Set whether to auto-connect to the {@link #setDefaultUri(URI) default URI} after
+	 * this endpoint connection factory has been initialized and the Spring context has
+	 * been refreshed.
+	 * <p>Default is "false".
+	 */
+	public void setAutoStartup(boolean autoStartup) {
+		this.autoStartup = autoStartup;
+	}
+
+	/**
+	 * Return the value for the 'autoStartup' property. If "true", this endpoint
+	 * connection factory will connect to the {@link #setDefaultUri(URI) default URI} upon
+	 * a ContextRefreshedEvent.
+	 */
+	public boolean isAutoStartup() {
+		return this.autoStartup;
+	}
+
+	/**
+	 * Specify the phase in which this endpoint connection factory should be
+	 * auto-connected and closed. The startup order proceeds from lowest to highest, and
+	 * the shutdown order is the reverse of that. By default this value is
+	 * Integer.MAX_VALUE meaning that this endpoint connection factory connects as late as
+	 * possible and is closed as soon as possible.
+	 */
+	public void setPhase(int phase) {
+		this.phase = phase;
+	}
+
+	/**
+	 * Return the phase in which this endpoint connection factory will be auto-connected
+	 * and stopped.
+	 */
+	public int getPhase() {
+		return this.phase;
+	}
+
+	@Override
+	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+		this.applicationContext = applicationContext;
+	}
+
+	protected URI getUri() {
+		return this.uri;
+	}
+
+	protected WebSocketContainer getWebSocketContainer() {
+		return this.webSocketContainer;
+	}
+
+	protected Object getEndpoint() {
+		if (this.endpointClass != null) {
+			return this.applicationContext.getAutowireCapableBeanFactory().createBean(this.endpointClass);
+		}
+		else {
+			return this.endpointBean;
+		}
+	}
+
+	/**
+	 * Auto-connects to the configured {@link #setDefaultUri(URI) default URI}.
+	 */
+	public void start() {
+		synchronized (this.lifecycleMonitor) {
+			if (!isRunning()) {
+				this.taskExecutor.execute(new Runnable() {
+					@Override
+					public void run() {
+						synchronized (lifecycleMonitor) {
+							try {
+								logger.info("Connecting to endpoint at URI " + uri);
+								session = connect(getEndpoint());
+								logger.info("Successfully connected");
+							}
+							catch (Exception ex) {
+								logger.error("Failed to connect to endpoint at " + uri, ex);
+							}
+						}
+					}
+				});
+			}
+		}
+	}
+
+	protected abstract Session connect(Object endpoint) throws DeploymentException, IOException;
+
+	/**
+	 * Deactivates the configured message endpoint.
+	 */
+	public void stop() {
+		synchronized (this.lifecycleMonitor) {
+			if (isRunning()) {
+				try {
+					this.session.close();
+				}
+				catch (IOException e) {
+					// ignore
+				}
+			}
+			this.session = null;
+		}
+	}
+
+	public void stop(Runnable callback) {
+		synchronized (this.lifecycleMonitor) {
+			this.stop();
+			callback.run();
+		}
+	}
+
+	/**
+	 * Return whether the configured message endpoint is currently active.
+	 */
+	public boolean isRunning() {
+		synchronized (this.lifecycleMonitor) {
+			if ((this.session != null) && this.session.isOpen()) {
+				return true;
+			}
+			this.session = null;
+			return false;
+		}
+	}
+
+}

spring-websocket/src/main/java/org/springframework/websocket/client/AnnotatedEndpointConnectionManager.java

@@ -0,0 +1,46 @@
+/*
+ * 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.websocket.client;
+
+import java.io.IOException;
+
+import javax.websocket.DeploymentException;
+import javax.websocket.Session;
+
+
+/**
+ *
+ * @author Rossen Stoyanchev
+ * @since 4.0
+ */
+public class AnnotatedEndpointConnectionManager extends AbstractEndpointConnectionManager {
+
+
+	public AnnotatedEndpointConnectionManager(Class<?> endpointClass, String uriTemplate, Object... uriVariables) {
+		super(endpointClass, uriTemplate, uriVariables);
+	}
+
+	public AnnotatedEndpointConnectionManager(Object endpointBean, String uriTemplate, Object... uriVariables) {
+		super(endpointBean, uriTemplate, uriVariables);
+	}
+
+	@Override
+	protected Session connect(Object endpoint) throws DeploymentException, IOException {
+		return getWebSocketContainer().connectToServer(endpoint, getUri());
+	}
+
+}

spring-websocket/src/main/java/org/springframework/websocket/client/EndpointConnectionManager.java

@@ -0,0 +1,78 @@
+/*
+ * 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.websocket.client;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+
+import javax.websocket.ClientEndpointConfig;
+import javax.websocket.ClientEndpointConfig.Configurator;
+import javax.websocket.Decoder;
+import javax.websocket.DeploymentException;
+import javax.websocket.Encoder;
+import javax.websocket.Endpoint;
+import javax.websocket.Extension;
+import javax.websocket.Session;
+
+
+/**
+ *
+ * @author Rossen Stoyanchev
+ * @since 4.0
+ */
+public class EndpointConnectionManager extends AbstractEndpointConnectionManager {
+
+	private final ClientEndpointConfig.Builder configBuilder = ClientEndpointConfig.Builder.create();
+
+
+	public EndpointConnectionManager(Class<? extends Endpoint> endpointClass, String uriTemplate, Object... uriVariables) {
+		super(endpointClass, uriTemplate, uriVariables);
+	}
+
+	public EndpointConnectionManager(Endpoint endpointBean, String uriTemplate, Object... uriVariables) {
+		super(endpointBean, uriTemplate, uriVariables);
+	}
+
+	public void setSubProtocols(String... subprotocols) {
+		this.configBuilder.preferredSubprotocols(Arrays.asList(subprotocols));
+	}
+
+	public void setExtensions(Extension... extensions) {
+		this.configBuilder.extensions(Arrays.asList(extensions));
+	}
+
+	public void setEncoders(List<Class<? extends Encoder>> encoders) {
+		this.configBuilder.encoders(encoders);
+	}
+
+	public void setDecoders(List<Class<? extends Decoder>> decoders) {
+		this.configBuilder.decoders(decoders);
+	}
+
+	public void setConfigurator(Configurator configurator) {
+		this.configBuilder.configurator(configurator);
+	}
+
+	@Override
+	protected Session connect(Object endpoint) throws DeploymentException, IOException {
+		Endpoint typedEndpoint = (Endpoint) endpoint;
+		ClientEndpointConfig endpointConfig = this.configBuilder.build();
+		return getWebSocketContainer().connectToServer(typedEndpoint, endpointConfig, getUri());
+	}
+
+}

spring-websocket/src/main/java/org/springframework/websocket/server/endpoint/EndpointExporter.java

@@ -19,7 +19,6 @@ import java.util.Map;
 
 import javax.websocket.DeploymentException;
 import javax.websocket.server.ServerContainer;
-import javax.websocket.server.ServerContainerProvider;
 import javax.websocket.server.ServerEndpoint;
 import javax.websocket.server.ServerEndpointConfig;
 
@@ -44,7 +43,7 @@ import org.springframework.util.ObjectUtils;
  * @author Rossen Stoyanchev
  * @since 4.0
  */
-public class EndpointExporter implements InitializingBean, BeanPostProcessor, BeanFactoryAware {
+public abstract class EndpointExporter implements InitializingBean, BeanPostProcessor, BeanFactoryAware {
 
 	private static Log logger = LogFactory.getLog(EndpointExporter.class);
 
@@ -112,7 +111,7 @@ public class EndpointExporter implements InitializingBean, BeanPostProcessor, Be
 					if (logger.isInfoEnabled()) {
 						logger.info("Detected @ServerEndpoint bean '" + beanName + "', registering it as an endpoint by type");
 					}
-					ServerContainerProvider.getServerContainer().addEndpoint(beanType);
+					getServerContainer().addEndpoint(beanType);
 				}
 				catch (DeploymentException e) {
 					throw new IllegalStateException("Failed to register @ServerEndpoint bean type " + beanName, e);
@@ -121,10 +120,16 @@ public class EndpointExporter implements InitializingBean, BeanPostProcessor, Be
 		}
 	}
 
+	/**
+	 * Return the {@link ServerContainer} instance, a process which is undefined outside
+	 * of standalone containers (section 6.4 of the spec).
+	 */
+	protected abstract ServerContainer getServerContainer();
+
 	@Override
 	public void afterPropertiesSet() throws Exception {
 
-		ServerContainer serverContainer = ServerContainerProvider.getServerContainer();
+		ServerContainer serverContainer = getServerContainer();
 		Assert.notNull(serverContainer, "javax.websocket.server.ServerContainer not available");
 
 		if (this.maxSessionIdleTimeout != null) {
@@ -159,7 +164,7 @@ public class EndpointExporter implements InitializingBean, BeanPostProcessor, Be
 					logger.info("Registering bean '" + beanName
 							+ "' as javax.websocket.Endpoint under path " + sec.getPath());
 				}
-				ServerContainerProvider.getServerContainer().addEndpoint(sec);
+				getServerContainer().addEndpoint(sec);
 			}
 			catch (DeploymentException e) {
 				throw new IllegalStateException("Failed to deploy Endpoint bean " + bean, e);

spring-websocket/src/main/java/org/springframework/websocket/server/endpoint/EndpointRegistration.java

@@ -37,8 +37,6 @@ import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.web.context.ContextLoader;
 import org.springframework.web.context.WebApplicationContext;
-import org.springframework.websocket.WebSocketHandler;
-import org.springframework.websocket.endpoint.StandardWebSocketHandlerAdapter;
 
 
 /**
@@ -60,7 +58,7 @@ public class EndpointRegistration implements ServerEndpointConfig, BeanFactoryAw
 
 	private final Class<? extends Endpoint> endpointClass;
 
-	private final Object bean;
+	private final Object endpointBean;
 
 	private List<String> subprotocols = new ArrayList<String>();
 
@@ -97,9 +95,7 @@ public class EndpointRegistration implements ServerEndpointConfig, BeanFactoryAw
 		Assert.isTrue((endpointClass != null || bean != null), "Neither endpoint class nor endpoint bean provided");
 		this.path = path;
 		this.endpointClass = endpointClass;
-		this.bean = bean;
+		this.endpointBean = bean;
-		// this will fail if the bean is not a valid Endpoint type
-		getEndpointClass();
 	}
 
 	@Override
@@ -113,17 +109,14 @@ public class EndpointRegistration implements ServerEndpointConfig, BeanFactoryAw
 		if (this.endpointClass != null) {
 			return this.endpointClass;
 		}
-		Class<?> beanClass = this.bean.getClass();
+		Class<?> beanClass = this.endpointBean.getClass();
 		if (beanClass.equals(String.class)) {
-			beanClass = this.beanFactory.getType((String) this.bean);
+			beanClass = this.beanFactory.getType((String) this.endpointBean);
 		}
 		beanClass = ClassUtils.getUserClass(beanClass);
 		if (Endpoint.class.isAssignableFrom(beanClass)) {
 			return (Class<? extends Endpoint>) beanClass;
 		}
-		else if (WebSocketHandler.class.isAssignableFrom(beanClass)) {
-			return StandardWebSocketHandlerAdapter.class;
-		}
 		else {
 			throw new IllegalStateException("Invalid endpoint bean: must be of type ... TODO ");
 		}
@@ -138,16 +131,11 @@ public class EndpointRegistration implements ServerEndpointConfig, BeanFactoryAw
 			}
 			return wac.getAutowireCapableBeanFactory().createBean(this.endpointClass);
 		}
-		Object bean = this.bean;
+		Object bean = this.endpointBean;
-		if (this.bean instanceof String) {
+		if (this.endpointBean instanceof String) {
-			bean = this.beanFactory.getBean((String) this.bean);
+			bean = this.beanFactory.getBean((String) this.endpointBean);
-		}
-		if (bean instanceof WebSocketHandler) {
-			return new StandardWebSocketHandlerAdapter((WebSocketHandler) bean);
-		}
-		else {
-			return (Endpoint) bean;
 		}
+		return (Endpoint) bean;
 	}
 
 	@Override

spring-websocket/src/main/java/org/springframework/websocket/server/endpoint/ServletEndpointExporter.java

@@ -17,18 +17,25 @@
 package org.springframework.websocket.server.endpoint;
 
 import javax.servlet.ServletContext;
+import javax.websocket.server.ServerContainer;
+import javax.websocket.server.ServerContainerProvider;
 
-import org.apache.tomcat.websocket.server.WsServerContainer;
+import org.springframework.util.Assert;
 import org.springframework.web.context.ServletContextAware;
 
 
 /**
+ * A sub-class of {@link EndpointExporter} for use with a Servlet container runtime.
  *
  * @author Rossen Stoyanchev
  * @since 4.0
  */
 public class ServletEndpointExporter extends EndpointExporter implements ServletContextAware {
 
+	/**
+	 *
+	 */
+	private static final String SERVER_CONTAINER_ATTR_NAME = "javax.websocket.server.ServerContainer";
 	private ServletContext servletContext;
 
 
@@ -38,17 +45,18 @@ public class ServletEndpointExporter extends EndpointExporter implements Servlet
 	}
 
 	public ServletContext getServletContext() {
-		return servletContext;
+		return this.servletContext;
 	}
 
 	@Override
-	public void afterPropertiesSet() throws Exception {
+	protected ServerContainer getServerContainer() {
-
+		Assert.notNull(this.servletContext, "A ServletContext is needed to access the WebSocket ServerContainer");
-		// TODO: this is needed (see WsListener) but remove hard dependency
+		ServerContainer container = (ServerContainer) this.servletContext.getAttribute(SERVER_CONTAINER_ATTR_NAME);
-		WsServerContainer sc = WsServerContainer.getServerContainer();
+		if (container == null) {
-        sc.setServletContext(this.servletContext);
+			// Remove when Tomcat has caught up to http://java.net/jira/browse/WEBSOCKET_SPEC-165
-
+			return ServerContainerProvider.getServerContainer();
-        super.afterPropertiesSet();
+		}
+		return container;
 	}
 
 }

spring-websocket/src/main/java/org/springframework/websocket/server/endpoint/SpringConfigurator.java

@@ -21,6 +21,8 @@ import java.util.Map;
 import javax.websocket.server.ServerEndpoint;
 import javax.websocket.server.ServerEndpointConfig.Configurator;
 
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
 import org.springframework.web.context.ContextLoader;
 import org.springframework.web.context.WebApplicationContext;
 
@@ -35,27 +37,36 @@ import org.springframework.web.context.WebApplicationContext;
  */
 public class SpringConfigurator extends Configurator {
 
+	private static Log logger = LogFactory.getLog(SpringConfigurator.class);
+
 
 	@Override
 	public <T> T getEndpointInstance(Class<T> endpointClass) throws InstantiationException {
 
 		WebApplicationContext wac = ContextLoader.getCurrentWebApplicationContext();
 		if (wac == null) {
-			throw new IllegalStateException("Failed to find WebApplicationContext. "
+			String message = "Failed to find the root WebApplicationContext. Was ContextLoaderListener not used?";
-					+ "Was org.springframework.web.context.ContextLoader used to load the WebApplicationContext?");
+			logger.error(message);
+			throw new IllegalStateException(message);
 		}
 
 		Map<String, T> beans = wac.getBeansOfType(endpointClass);
 		if (beans.isEmpty()) {
-			// Initialize a new bean instance
+			if (logger.isTraceEnabled()) {
+				logger.trace("Creating new @ServerEndpoint instance of type " + endpointClass);
+			}
 			return wac.getAutowireCapableBeanFactory().createBean(endpointClass);
 		}
 		if (beans.size() == 1) {
-			// Return the matching bean instance
+			if (logger.isTraceEnabled()) {
+				logger.trace("Using @ServerEndpoint singleton " + beans.keySet().iterator().next());
+			}
 			return beans.values().iterator().next();
 		}
 		else {
-			// This should never happen (@ServerEndpoint has a single path mapping) ..
+			// This should never happen ..
+			String message = "Found more than one matching @ServerEndpoint beans of type " + endpointClass;
+			logger.error(message);
 			throw new IllegalStateException("Found more than one matching beans of type " + endpointClass);
 		}
 	}