adding MessageBus

Mumfrey
1 parent 61965517
Showing 5 changed files with 507 additions and 7 deletions
java/client/com/mumfrey/liteloader/client/api/LiteLoaderCoreAPIClient.java
java/common/com/mumfrey/liteloader/core/LiteLoader.java
java/common/com/mumfrey/liteloader/messaging/Message.java
java/common/com/mumfrey/liteloader/messaging/MessageBus.java
java/common/com/mumfrey/liteloader/messaging/Messenger.java
@@ -14,6 +14,7 @@ import com.mumfrey.liteloader.client.LiteLoaderCoreProviderClient;
 import com.mumfrey.liteloader.core.LiteLoader;
 import com.mumfrey.liteloader.core.api.LiteLoaderCoreAPI;
 import com.mumfrey.liteloader.interfaces.ObjectFactory;
+import com.mumfrey.liteloader.messaging.MessageBus;
 /**
  * Client side of the core API
@@ -113,7 +114,8 @@ public class LiteLoaderCoreAPIClient extends LiteLoaderCoreAPI
 		(
 			objectFactory.getEventBroker(),
 			objectFactory.getClientPluginChannels(),
-			objectFactory.getServerPluginChannels()
+			objectFactory.getServerPluginChannels(),
+			MessageBus.getInstance()
 		);
 	}
@@ -125,7 +127,7 @@ public class LiteLoaderCoreAPIClient extends LiteLoaderCoreAPI
 	{
 		return ImmutableList.<Observer>of
 		(
-			this.getObjectFactory().getModPanelManager()
+			this.getObjectFactory().getPanelManager()
 		);
 	}
@@ -46,6 +46,7 @@ import com.mumfrey.liteloader.interfaces.PanelManager;
 import com.mumfrey.liteloader.interfaces.ObjectFactory;
 import com.mumfrey.liteloader.launch.LoaderEnvironment;
 import com.mumfrey.liteloader.launch.LoaderProperties;
+import com.mumfrey.liteloader.messaging.MessageBus;
 import com.mumfrey.liteloader.modconfig.ConfigManager;
 import com.mumfrey.liteloader.modconfig.Exposable;
 import com.mumfrey.liteloader.permissions.PermissionsManagerClient;
@@ -848,7 +849,7 @@ public final class LiteLoader
 		}
 		// Get the mod panel manager
-		this.panelManager = this.objectFactory.getModPanelManager();
+		this.panelManager = this.objectFactory.getPanelManager();
 		if (this.panelManager != null)
 		{
 			this.panelManager.init(this.mods, this.configManager);
@@ -905,15 +906,14 @@ public final class LiteLoader
 		// Set the loader branding in ClientBrandRetriever using reflection
 		LiteLoaderBootstrap.setBranding("LiteLoader");
-		for (CoreProvider coreProvider : this.coreProviders)
-		{
-			coreProvider.onStartupComplete();
-		}
+		this.coreProviders.all().onStartupComplete();
 		if (this.panelManager != null)
 		{
 			this.panelManager.onStartupComplete();
 		}
+		
+		MessageBus.getInstance().onStartupComplete();
 	}
 	/**
+package com.mumfrey.liteloader.messaging;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+import com.google.common.collect.ImmutableMap;
+
+/**
+ * Class used to encapsulate a MessageBus message
+ * 
+ * @author Adam Mummery-Smith
+ */
+public class Message
+{
+	/**
+	 * Regex for matching valid channels
+	 */
+	private static final Pattern channelPattern = Pattern.compile("^[a-z0-9]([a-z0-9_\\-]*[a-z0-9])?:[a-z0-9]([a-z0-9_\\-]*[a-z0-9])?$", Pattern.CASE_INSENSITIVE);
+	
+	private final String channel, replyChannel;
+	private final Messenger sender;
+	private final Map<String, ?> payload;
+	
+	Message(String channel, Object value, Messenger sender)
+	{
+		this(channel, value, sender, null);
+	}
+	
+	Message(String channel, Object value, Messenger sender, String replyChannel)
+	{
+		Message.validateChannel(channel);
+		
+		this.channel = channel;
+		this.payload = ImmutableMap.<String, Object>of("value", value);
+		this.sender = sender;
+		this.replyChannel = replyChannel;
+	}
+	
+	Message(String channel, Map<String, ?> payload, Messenger sender)
+	{
+		this(channel, payload, sender, null);
+	}
+	
+	Message(String channel, Map<String, ?> payload, Messenger sender, String replyChannel)
+	{
+		Message.validateChannel(channel);
+		
+		this.channel = channel;
+		this.payload = payload != null ? ImmutableMap.copyOf(payload) : ImmutableMap.<String, String>of();
+		this.sender = sender;
+		this.replyChannel = replyChannel;
+	}
+	
+	/**
+	 * Get the channel (fully qualified) that this message was sent on
+	 */
+	public String getChannel()
+	{
+		return this.channel;
+	}
+	
+	/**
+	 * Get the channel category for this message
+	 */
+	public String getCategory()
+	{
+		return this.channel.substring(0, this.channel.indexOf(':'));
+	}
+	
+	/**
+	 * Get the specified reply channel (if any) for this message - may return null
+	 */
+	public String getReplyChannel()
+	{
+		return this.replyChannel;
+	}
+	
+	/**
+	 * Get the message sender (if any) for this message - may return null
+	 */
+	public Messenger getSender()
+	{
+		return this.sender;
+	}
+	
+	/**
+	 * Get the message payload
+	 */
+	public Map<String, ?> getPayload()
+	{
+		return this.payload;
+	}
+	
+	/**
+	 * Check if this message is on the specified channel
+	 * 
+	 * @param channel Full name of the channel to check against (case sensitive)
+	 * @return
+	 */
+	public boolean isChannel(String channel)
+	{
+		return this.channel.equals(channel);
+	}
+	
+	/**
+	 * Check if this message has the specified category
+	 * 
+	 * @param category
+	 * @return
+	 */
+	public boolean isCategory(String category)
+	{
+		return this.getCategory().equals(category);
+	}
+	
+	/**
+	 * Get (and implicit cast) a value from this message's payload
+	 * 
+	 * @param key
+	 * @return
+	 */
+	@SuppressWarnings("unchecked")
+	public <T> T get(String key)
+	{
+		return (T)this.payload.get(key);
+	}
+	
+	@SuppressWarnings("unchecked")
+	public <T> T get(String key, T defaultValue)
+	{
+		Object value = this.payload.get(key);
+		if (value != null)
+		{
+			return (T)value;
+		}
+		return defaultValue;
+	}
+	
+	/**
+	 * Gets the payload with the key "value", which is used with messages constructed using a string-only payload 
+	 */
+	public <T> T getValue()
+	{
+		return this.get("value");
+	}
+	
+	public static void validateChannel(String channel) throws IllegalArgumentException
+	{
+		if (channel == null)
+		{
+			throw new IllegalArgumentException("Channel name cannot be null");
+		}
+		
+		if (!Message.isValidChannel(channel))
+		{
+			throw new IllegalArgumentException("'" + channel + "' is not a valid channel name");
+		}
+	}
+	
+	public static boolean isValidChannel(String channel)
+	{
+		return Message.channelPattern.matcher(channel).matches();
+	}
+	
+	/**
+	 * Build a KV map from interleaved keys and values, convenience function
+	 * 
+	 * @param args
+	 * @return
+	 */
+	public static Map<String, ?> buildMap(Object... args)
+	{
+		Map<String, Object> payload = new HashMap<String, Object>();
+		for (int i = 0; i < args.length - 1; i += 2)
+		{
+			if (args[i] instanceof String)
+			{
+				payload.put((String)args[i], args[i + 1]);
+			}
+		}
+		
+		return payload;
+	}
+}
+package com.mumfrey.liteloader.messaging;
+
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import com.mumfrey.liteloader.api.InterfaceProvider;
+import com.mumfrey.liteloader.api.Listener;
+import com.mumfrey.liteloader.core.InterfaceRegistrationDelegate;
+import com.mumfrey.liteloader.core.event.HandlerList;
+import com.mumfrey.liteloader.interfaces.FastIterable;
+import com.mumfrey.liteloader.util.log.LiteLoaderLogger;
+
+/**
+ * Intra-mod messaging bus, allows mods to send arbitrary notifications to each other without having to
+ * create an explicit dependency or resort to reflection
+ * 
+ * @author Adam Mummery-Smith
+ */
+public class MessageBus implements InterfaceProvider
+{
+	/**
+	 * Singleton
+	 */
+	private static MessageBus instance;
+	
+	/**
+	 * Messengers subscribed to each channel
+	 */
+	private final Map<String, FastIterable<Messenger>> messengers = new HashMap<String, FastIterable<Messenger>>();
+	
+	/**
+	 * Pending messages dispatched pre-startup
+	 */
+	private final Deque<Message> messageQueue = new LinkedList<Message>();
+	
+	private boolean enableMessaging = false;
+	
+	private MessageBus()
+	{
+	}
+	
+	/**
+	 * Get the singleton instance
+	 */
+	public static MessageBus getInstance()
+	{
+		if (MessageBus.instance == null)
+		{
+			MessageBus.instance = new MessageBus();
+		}
+		
+		return MessageBus.instance;
+	}
+
+	/* (non-Javadoc)
+	 * @see com.mumfrey.liteloader.api.InterfaceProvider#getListenerBaseType()
+	 */
+	@Override
+	public Class<? extends Listener> getListenerBaseType()
+	{
+		return Listener.class;
+	}
+
+	/* (non-Javadoc)
+	 * @see com.mumfrey.liteloader.api.InterfaceProvider#registerInterfaces(com.mumfrey.liteloader.core.InterfaceRegistrationDelegate)
+	 */
+	@Override
+	public void registerInterfaces(InterfaceRegistrationDelegate delegate)
+	{
+		delegate.registerInterface(Messenger.class);
+	}
+
+	/* (non-Javadoc)
+	 * @see com.mumfrey.liteloader.api.InterfaceProvider#initProvider()
+	 */
+	@Override
+	public void initProvider()
+	{
+	}
+
+	/**
+	 * 
+	 */
+	public void onStartupComplete()
+	{
+		this.enableMessaging = true;
+		
+		while (this.messageQueue.size() > 0)
+		{
+			Message msg = this.messageQueue.pop();
+			this.dispatchMessage(msg);
+		}
+	}
+	
+	public void registerMessenger(Messenger messenger)
+	{
+		List<String> messageChannels = messenger.getMessageChannels();
+		if (messageChannels == null)
+		{
+			LiteLoaderLogger.warning("Listener %s returned a null channel list for getMessageChannels(), this could indicate a problem with the listener", messenger.getName());
+			return;
+		}
+		
+		for (String channel : messageChannels)
+		{
+			if (channel != null && Message.isValidChannel(channel))
+			{
+				LiteLoaderLogger.info("Listener %s is registering MessageBus channel %s", messenger.getName(), channel);
+				this.getMessengerList(channel).add(messenger);
+			}
+			else
+			{
+				LiteLoaderLogger.warning("Listener %s tried to register invalid MessageBus channel %s", messenger.getName(), channel);
+			}
+		}	
+	}
+	
+	/**
+	 * @param message
+	 */
+	private void sendMessage(Message message)
+	{
+		if (this.enableMessaging)
+		{
+			this.dispatchMessage(message);
+			return;
+		}
+		
+		this.messageQueue.push(message);
+	}
+
+	/**
+	 * @param message
+	 */
+	private void dispatchMessage(Message message)
+	{
+		try
+		{
+			FastIterable<Messenger> messengerList = this.messengers.get(message.getChannel());
+			if (messengerList != null)
+			{
+				messengerList.all().receiveMessage(message);
+			}
+		}
+		catch (StackOverflowError err)
+		{
+			// A listener tried to reply on the same channel and ended up calling itself
+			throw new RuntimeException("Stack overflow encountered dispatching message on channel '" + message.getChannel() + "'. Did you reply to yourself?");
+		}
+	}
+	
+	/**
+	 * Get messengers for the specified channel
+	 * 
+	 * @param channel
+	 * @return
+	 */
+	private FastIterable<Messenger> getMessengerList(String channel)
+	{
+		FastIterable<Messenger> messengerList = this.messengers.get(channel);
+		if (messengerList == null)
+		{
+			messengerList = new HandlerList<Messenger>(Messenger.class);
+			this.messengers.put(channel, messengerList);
+		}
+		
+		return messengerList;
+	}
+	
+	/**
+	 * Send an empty message on the specified channel, this is useful for messages which are basically just notifications
+	 * 
+	 * @param channel
+	 */
+	public static void send(String channel)
+	{
+		Message message = new Message(channel, null, null);
+		MessageBus.getInstance().sendMessage(message);
+	}
+	
+	/**
+	 * Send a message with a value on the specified channel
+	 * 
+	 * @param channel
+	 * @param value
+	 */
+	public static void send(String channel, String value)
+	{
+		Message message = new Message(channel, value, null);
+		MessageBus.getInstance().sendMessage(message);
+	}
+	
+	/**
+	 * Send a message with a value on the specified channel from the specified sender
+	 * 
+	 * @param channel
+	 * @param value
+	 * @param sender
+	 */
+	public static void send(String channel, String value, Messenger sender)
+	{
+		Message message = new Message(channel, value, sender);
+		MessageBus.getInstance().sendMessage(message);
+	}
+	
+	/**
+	 * Send a message with a value on the specified channel from the specified sender
+	 * 
+	 * @param channel
+	 * @param value
+	 * @param sender
+	 * @param replyChannel
+	 */
+	public static void send(String channel, String value, Messenger sender, String replyChannel)
+	{
+		Message message = new Message(channel, value, sender, replyChannel);
+		MessageBus.getInstance().sendMessage(message);
+	}
+	
+	/**
+	 * Send a message with a supplied payload on the specified channel
+	 * 
+	 * @param channel
+	 * @param payload
+	 */
+	public static void send(String channel, Map<String, ?> payload)
+	{
+		Message message = new Message(channel, payload, null);
+		MessageBus.getInstance().sendMessage(message);
+	}
+	
+	/**
+	 * Send a message with a supplied payload on the specified channel from the specified sender
+	 * 
+	 * @param channel
+	 * @param payload
+	 * @param sender
+	 */
+	public static void send(String channel, Map<String, ?> payload, Messenger sender)
+	{
+		Message message = new Message(channel, payload, sender);
+		MessageBus.getInstance().sendMessage(message);
+	}
+	
+	/**
+	 * Send a message with a supplied payload on the specified channel from the specified sender
+	 * 
+	 * @param channel
+	 * @param payload
+	 * @param sender
+	 * @param replyChannel
+	 */
+	public static void send(String channel, Map<String, ?> payload, Messenger sender, String replyChannel)
+	{
+		Message message = new Message(channel, payload, sender, replyChannel);
+		MessageBus.getInstance().sendMessage(message);
+	}
+}
+package com.mumfrey.liteloader.messaging;
+
+import java.util.List;
+
+import com.mumfrey.liteloader.api.Listener;
+
+/**
+ * Interface for listeners that want to receive (or send) 
+ * 
+ * @author Adam Mummery-Smith
+ */
+public interface Messenger extends Listener
+{
+	/**
+	 * Get listening channels for this Messenger. Channel names must follow the format:
+	 * 
+	 *   {category}:{channel}
+	 *   
+	 * where both {category} and {channel} are alpha-numeric identifiers which can contain underscore or dash
+	 * but must begin and end with only alpha-numeric characters: for example the following channel names are
+	 * valid:
+	 * 
+	 *  * foo:bar
+	 *  * foo-bar:baz
+	 *  * foo-bar:baz_derp
+	 *  
+	 * The following are INVALID:
+	 * 
+	 *  * foo
+	 *  * foo_:bar
+	 *  * _foo:bar
+	 *  
+	 * In general, your listener should listen on channels all beginning with the same category, which may match
+	 * your mod id. Channel names and categories are case-sensitive.
+	 * 
+	 * @return List of channels to listen on
+	 */
+	public abstract List<String> getMessageChannels();
+	
+	/**
+	 * Called when a message matching a channel you have elected to listen on is dispatched by any agent.
+	 * WARNING: this method is called if you dispatch a message on a channel you are listening to, thus you should
+	 * AVOID replying on channels you are listening to UNLESS you specifically filter messages based on their sender:
+	 * 
+	 *   if (message.getSender() == this) return;
+	 *   
+	 * Messages may have a null sender or payload but will never have a null channel.
+	 * 
+	 * @param message
+	 */
+	public abstract void receiveMessage(Message message);
+}