From 4bd774a6539656166ae815bdb147a6cff7b17910 Mon Sep 17 00:00:00 2001 From: Paul Speed Date: Thu, 28 May 2015 01:10:44 -0400 Subject: [PATCH] Created an abstract hosted connection service that has the autohost, start/stopHostingOnConnection support built into it. This is a very common things for connection based services and I got tired of cutting/pasting it all the time. RpcHostedService was modified to extend this base class instead of the more basic one. --- .../AbstractHostedConnectionService.java | 148 ++++++++++++++++++ .../network/service/rpc/RpcHostedService.java | 62 +------- 2 files changed, 153 insertions(+), 57 deletions(-) create mode 100644 jme3-networking/src/main/java/com/jme3/network/service/AbstractHostedConnectionService.java diff --git a/jme3-networking/src/main/java/com/jme3/network/service/AbstractHostedConnectionService.java b/jme3-networking/src/main/java/com/jme3/network/service/AbstractHostedConnectionService.java new file mode 100644 index 000000000..485712b95 --- /dev/null +++ b/jme3-networking/src/main/java/com/jme3/network/service/AbstractHostedConnectionService.java @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2015 jMonkeyEngine + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'jMonkeyEngine' nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +package com.jme3.network.service; + +import com.jme3.network.HostedConnection; +import com.jme3.network.Server; +import java.util.logging.Level; +import java.util.logging.Logger; + + +/** + * Convenient base class for HostedServices providing some default HostedService + * interface implementations as well as a few convenience methods + * such as getServiceManager() and getService(type). This implementation + * enhances the default capabilities provided by AbstractHostedService by + * adding automatic connection management. + * + *

Subclasses must at least override the onInitialize(), startHostingOnConnection(), and + * stopHostingOnConnection() methods to handle service and connection initialization.

+ * + *

An autoHost flag controls whether startHostingOnConnection() is called + * automatically when new connections are detected. If autoHohst is false then it + * is up to the implementation or appliction to specifically start hosting at + * some point.

+ * + * @author Paul Speed + */ +public abstract class AbstractHostedConnectionService extends AbstractHostedService { + + static final Logger log = Logger.getLogger(AbstractHostedConnectionService.class.getName()); + + private boolean autoHost; + + /** + * Creates a new HostedService that will autohost connections + * when detected. + */ + protected AbstractHostedConnectionService() { + this(true); + } + + /** + * Creates a new HostedService that will automatically host + * connections only if autoHost is true. + */ + protected AbstractHostedConnectionService( boolean autoHost ) { + this.autoHost = autoHost; + } + + /** + * When set to true, all new connections will automatically have + * hosting services attached to them by calling startHostingOnConnection(). + * If this is set to false then it is up to the application or other services + * to eventually call startHostingOnConnection(). + * + *

Reasons for doing this vary but usually would be because + * the client shouldn't be allowed to perform any service-related calls until + * it has provided more information... for example, logging in.

+ */ + public void setAutoHost( boolean b ) { + this.autoHost = b; + } + + /** + * Returns true if this service automatically attaches + * hosting capabilities to new connections. + */ + public boolean getAutoHost() { + return autoHost; + } + + + /** + * Performs implementation specific connection hosting setup. + * Generally this involves setting up some handlers or session + * attributes on the connection. If autoHost is true then this + * method is called automatically during connectionAdded() + * processing. + */ + public abstract void startHostingOnConnection( HostedConnection hc ); + + /** + * Performs implementation specific connection tear-down. + * This will be called automatically when the connectionRemoved() + * event occurs... whether the application has already called it + * or not. + */ + public abstract void stopHostingOnConnection( HostedConnection hc ); + + /** + * Called internally when a new connection is detected for + * the server. If the current autoHost property is true then + * startHostingOnConnection(hc) is called. + */ + @Override + public void connectionAdded(Server server, HostedConnection hc) { + if( log.isLoggable(Level.FINEST) ) { + log.log(Level.FINEST, "connectionAdded({0}, {1})", new Object[]{server, hc}); + } + if( autoHost ) { + startHostingOnConnection(hc); + } + } + + /** + * Called internally when an existing connection is leaving + * the server. This method always calls stopHostingOnConnection(hc). + * Implementations should be aware that if they stopHostingOnConnection() + * early that they will get a second call when the connection goes away. + */ + @Override + public void connectionRemoved(Server server, HostedConnection hc) { + if( log.isLoggable(Level.FINEST) ) { + log.log(Level.FINEST, "connectionRemoved({0}, {1})", new Object[]{server, hc}); + } + stopHostingOnConnection(hc); + } +} diff --git a/jme3-networking/src/main/java/com/jme3/network/service/rpc/RpcHostedService.java b/jme3-networking/src/main/java/com/jme3/network/service/rpc/RpcHostedService.java index 4a347b5a3..2d6f28593 100644 --- a/jme3-networking/src/main/java/com/jme3/network/service/rpc/RpcHostedService.java +++ b/jme3-networking/src/main/java/com/jme3/network/service/rpc/RpcHostedService.java @@ -35,8 +35,8 @@ package com.jme3.network.service.rpc; import com.jme3.network.HostedConnection; import com.jme3.network.Server; import com.jme3.network.serializing.Serializer; +import com.jme3.network.service.AbstractHostedConnectionService; import com.jme3.network.util.SessionDataDelegator; -import com.jme3.network.service.AbstractHostedService; import com.jme3.network.service.HostedServiceManager; import com.jme3.network.service.rpc.msg.RpcCallMessage; import com.jme3.network.service.rpc.msg.RpcResponseMessage; @@ -62,13 +62,12 @@ import java.util.logging.Logger; * * @author Paul Speed */ -public class RpcHostedService extends AbstractHostedService { +public class RpcHostedService extends AbstractHostedConnectionService { private static final String ATTRIBUTE_NAME = "rpcSession"; static final Logger log = Logger.getLogger(RpcHostedService.class.getName()); - private boolean autoHost; private SessionDataDelegator delegator; /** @@ -87,7 +86,7 @@ public class RpcHostedService extends AbstractHostedService { * on the specified 'autoHost' flag. */ public RpcHostedService( boolean autoHost ) { - this.autoHost = autoHost; + super(autoHost); // This works for me... has to be different in // the general case @@ -115,31 +114,6 @@ public class RpcHostedService extends AbstractHostedService { } } - /** - * When set to true, all new connections will automatically have - * RPC hosting services attached to them, meaning they can send - * and receive RPC calls. If this is set to false then it is up - * to other services to eventually call startHostingOnConnection(). - * - *

Reasons for doing this vary but usually would be because - * the client shouldn't be allowed to perform any RPC calls until - * it has provided more information. In general, this is unnecessary - * because the RpcHandler registries are not shared. Each client - * gets their own and RPC calls will fail until the appropriate - * objects have been registtered.

- */ - public void setAutoHost( boolean b ) { - this.autoHost = b; - } - - /** - * Returns true if this service automatically attaches RPC - * hosting capabilities to new connections. - */ - public boolean getAutoHost() { - return autoHost; - } - /** * Retrieves the RpcConnection for the specified HostedConnection * if that HostedConnection has had RPC services started using @@ -157,6 +131,7 @@ public class RpcHostedService extends AbstractHostedService { * This method is called automatically for all new connections if * autohost is set to true. */ + @Override public void startHostingOnConnection( HostedConnection hc ) { if( log.isLoggable(Level.FINEST) ) { log.log(Level.FINEST, "startHostingOnConnection:{0}", hc); @@ -173,6 +148,7 @@ public class RpcHostedService extends AbstractHostedService { * This method is called automatically for all leaving connections if * autohost is set to true. */ + @Override public void stopHostingOnConnection( HostedConnection hc ) { RpcConnection rpc = hc.getAttribute(ATTRIBUTE_NAME); if( rpc == null ) { @@ -195,33 +171,5 @@ public class RpcHostedService extends AbstractHostedService { server.removeMessageListener(delegator, delegator.getMessageTypes()); } - /** - * Called internally when a new connection is detected for - * the server. If the current autoHost property is true then - * startHostingOnConnection(hc) is called. - */ - @Override - public void connectionAdded(Server server, HostedConnection hc) { - if( log.isLoggable(Level.FINEST) ) { - log.log(Level.FINEST, "connectionAdded({0}, {1})", new Object[]{server, hc}); - } - if( autoHost ) { - startHostingOnConnection(hc); - } - } - - /** - * Called internally when an existing connection is leaving - * the server. If the current autoHost property is true then - * stopHostingOnConnection(hc) is called. - */ - @Override - public void connectionRemoved(Server server, HostedConnection hc) { - if( log.isLoggable(Level.FINEST) ) { - log.log(Level.FINEST, "connectionRemoved({0}, {1})", new Object[]{server, hc}); - } - stopHostingOnConnection(hc); - } - }