KixmppEventEngine.java

package com.kixeye.kixmpp.handler;

/*
 * #%L
 * KIXMPP
 * %%
 * Copyright (C) 2014 KIXEYE, Inc
 * %%
 * 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.
 * #L%
 */

import io.netty.channel.Channel;

import java.util.Collections;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

import org.fusesource.hawtdispatch.Dispatch;
import org.fusesource.hawtdispatch.DispatchQueue;
import org.fusesource.hawtdispatch.Task;
import org.jdom2.Element;

import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.kixeye.kixmpp.KixmppJid;
import com.kixeye.kixmpp.KixmppStreamEnd;
import com.kixeye.kixmpp.KixmppStreamStart;
import com.kixeye.kixmpp.tuple.Tuple;

/**
 * An event engine that uses a {@link DispatchQueue}.
 * 
 * @author ebahtijaragic
 */
public class KixmppEventEngine {
	private static final String HANDLER_WILDCARD = "*";
	
	private final ConcurrentHashMap<Tuple, Set<KixmppStanzaHandler>> stanzaHandlers = new ConcurrentHashMap<>();
	private final Set<KixmppConnectionHandler> connectionHandlers = Collections.newSetFromMap(new ConcurrentHashMap<KixmppConnectionHandler, Boolean>());
	private final Set<KixmppStreamHandler> streamHandlers = Collections.newSetFromMap(new ConcurrentHashMap<KixmppStreamHandler, Boolean>());
	private final Set<KixmppSessionHandler> sessionHandlers = Collections.newSetFromMap(new ConcurrentHashMap<KixmppSessionHandler, Boolean>());

	private final LoadingCache<String, DispatchQueue> queues = CacheBuilder.newBuilder()
			.expireAfterAccess(30, TimeUnit.SECONDS)
			.build(new CacheLoader<String, DispatchQueue>() {
				public DispatchQueue load(String key) throws Exception {
					return Dispatch.createQueue(key);
				}
			});
	
	/**
	 * Publishes a stanza.
	 * 
	 * @param channel
	 * @param stanza
	 */
	public void publishStanza(Channel channel, Element stanza) {
		String to = stanza.getAttributeValue("to");
		
		DispatchQueue queue;
		
		try {
			if (to != null) {
				queue = queues.get("address:" + to);
			} else {
				queue = queues.get("channel:" + channel.hashCode());
			}
		} catch (ExecutionException e) {
			throw new RuntimeException(e);
		}
		
		if (to != null) {
			Set<KixmppStanzaHandler> recipientHandlers = stanzaHandlers.get(Tuple.from(stanza.getQualifiedName(), KixmppJid.fromRawJid(to)));
			
			if (recipientHandlers != null) {
				for (KixmppStanzaHandler handler : recipientHandlers) {
					queue.execute(new ExecuteStanzaHandler(handler, channel, stanza));
				}
			}
			
			recipientHandlers = stanzaHandlers.get(Tuple.from(HANDLER_WILDCARD, KixmppJid.fromRawJid(to)));
			
			if (recipientHandlers != null) {
				for (KixmppStanzaHandler handler : recipientHandlers) {
					queue.execute(new ExecuteStanzaHandler(handler, channel, stanza));
				}
			}
		}
		
		Set<KixmppStanzaHandler> globalHandlers = stanzaHandlers.get(Tuple.from(stanza.getQualifiedName()));
		
		if (globalHandlers != null) {
			for (KixmppStanzaHandler handler : globalHandlers) {
				queue.execute(new ExecuteStanzaHandler(handler, channel, stanza));
			}
		}
		
		globalHandlers = stanzaHandlers.get(Tuple.from(HANDLER_WILDCARD));
		
		if (globalHandlers != null) {
			for (KixmppStanzaHandler handler : globalHandlers) {
				queue.execute(new ExecuteStanzaHandler(handler, channel, stanza));
			}
		}
	}
	
	/**
	 * Published an arbitrary task for serial execution.
	 * 
	 * @param jid
	 * @param task
	 */
	public void publishTask(KixmppJid jid, Task task) {
		DispatchQueue queue;
		
		try {
            if (jid != null) {
                queue = queues.get("address:" + jid.getFullJid());
            } else {
                queue = queues.get("default");
            }
		} catch (ExecutionException e) {
			throw new RuntimeException(e);
		}
		
		queue.execute(task);
	}
	
	/**
	 * Published an arbitrary task for serial execution.
	 * 
	 * @param channel
	 * @param task
	 */
	public void publishTask(Channel channel, Task task) {
		DispatchQueue queue;
		
		try {
			queue = queues.get("channel:" + channel.hashCode());
		} catch (ExecutionException e) {
			throw new RuntimeException(e);
		}

		queue.execute(task);
	}
	
	/**
	 * Publishes that a channel has connected.
	 * 
	 * @param channel
	 */
	public void publishConnected(Channel channel) {
		DispatchQueue queue;
		
		try {
			queue = queues.get("channel:" + channel.hashCode());
		} catch (ExecutionException e) {
			throw new RuntimeException(e);
		}
		
		for (KixmppConnectionHandler handler : connectionHandlers) {
			queue.execute(new ExecuteConnectionConnectedHandler(handler, channel));
		}
	}
	
	/**
	 * Publishes that a channel has disconnected.
	 * 
	 * @param channel
	 */
	public void publishDisconnected(Channel channel) {
		DispatchQueue queue;
		
		try {
			queue = queues.get("channel:" + channel.hashCode());
		} catch (ExecutionException e) {
			throw new RuntimeException(e);
		}
		
		for (KixmppConnectionHandler handler : connectionHandlers) {
			queue.execute(new ExecuteConnectionDisconnectedHandler(handler, channel));
		}
	}
	
	/**
	 * Publishes a stream start event.
	 * 
	 * @param channel
	 * @param streamStart
	 */
	public void publishStreamStart(Channel channel, KixmppStreamStart streamStart) {
		DispatchQueue queue;
		
		try {
			queue = queues.get("channel:" + channel.hashCode());
		} catch (ExecutionException e) {
			throw new RuntimeException(e);
		}
		
		for (KixmppStreamHandler handler : streamHandlers) {
			queue.execute(new ExecuteStreamStartHandler(handler, channel, streamStart));
		}
	}
	
	/**
	 * Publishes a stream end event.
	 * 
	 * @param channel
	 * @param streamEnd
	 */
	public void publishStreamEnd(Channel channel, KixmppStreamEnd streamEnd) {
		DispatchQueue queue;
		
		try {
			queue = queues.get("channel:" + channel.hashCode());
		} catch (ExecutionException e) {
			throw new RuntimeException(e);
		}
		
		for (KixmppStreamHandler handler : streamHandlers) {
			queue.execute(new ExecuteStreamEndHandler(handler, channel, streamEnd));
		}
	}

	/**
	 * Publishes a session start event.
	 *
	 * @param channel
	 */
	public void publishSessionStart(Channel channel) {
		DispatchQueue queue;

		try {
			queue = queues.get("channel:" + channel.hashCode());
		} catch (ExecutionException e) {
			throw new RuntimeException(e);
		}

		for (KixmppSessionHandler handler : sessionHandlers) {
			queue.execute(new ExecuteSessionStartHandler(handler, channel));
		}
	}

	/**
	 * Registers a handler to listen to connection events.
	 * 
	 * @param handler
	 */
	public void registerConnectionHandler(KixmppConnectionHandler handler) {
		connectionHandlers.add(handler);
	}

	/**
	 * Unregisters a connection handler.
	 * 
	 * @param handler
	 */
	public void unregisterConnectionHandler(KixmppConnectionHandler handler) {
		connectionHandlers.remove(handler);
	}

	/**
	 * Registers a stream handler.
	 *
	 * @param handler
	 */
	public void registerStreamHandler(KixmppStreamHandler handler) {
		streamHandlers.add(handler);
	}

	/**
	 * Unregisters a stream handler.
	 *
	 * @param handler
	 */
	public void unregisterStreamHandler(KixmppStreamHandler handler) {
		streamHandlers.remove(handler);
	}

	/**
	 * Registers a session handler.
	 *
	 * @param handler
	 */
	public void registerSessionHandler(KixmppSessionHandler handler) {
		sessionHandlers.add(handler);
	}

	/**
	 * Unregisters a session handler.
	 *
	 * @param handler
	 */
	public void unregisterSessionHandler(KixmppSessionHandler handler) {
		sessionHandlers.remove(handler);
	}

	/**
	 * Registers a stanza handler.
	 * 
	 * @param qualifiedName
	 * @param jid
	 * @param handler
	 */
	public void registerStanzaHandler(KixmppJid jid, String qualifiedName, KixmppStanzaHandler handler) {
		Tuple key = Tuple.from(qualifiedName, jid);
		
		Set<KixmppStanzaHandler> handlers = stanzaHandlers.get(key);
		
		if (handlers == null) {
			Set<KixmppStanzaHandler> newHandlers = Collections.newSetFromMap(new ConcurrentHashMap<KixmppStanzaHandler, Boolean>());
			
			handlers = stanzaHandlers.putIfAbsent(key, newHandlers);
			
			if (handlers == null) {
				handlers = newHandlers;
			}
        }
		
		handlers.add(handler);
	}
	
	/**
	 * Registers a stanza handler.
	 * 
	 * @param jid
	 * @param handler
	 */
	public void registerStanzaHandler(KixmppJid jid, KixmppStanzaHandler handler) {
		registerStanzaHandler(jid, HANDLER_WILDCARD, handler);
	}
	
	/**
	 * Registers a stanza handler.
	 * 
	 * @param handler
	 */
	public void registerGlobalStanzaHandler(String qualifiedName, KixmppStanzaHandler handler) {
		Tuple key = Tuple.from(qualifiedName);
		
		Set<KixmppStanzaHandler> handlers = stanzaHandlers.get(key);
		
		if (handlers == null) {
			Set<KixmppStanzaHandler> newHandlers = Collections.newSetFromMap(new ConcurrentHashMap<KixmppStanzaHandler, Boolean>());
			
			handlers = stanzaHandlers.putIfAbsent(key, newHandlers);
			
			if (handlers == null) {
				handlers = newHandlers;
			}
        }
		
		handlers.add(handler);
	}
	
	/**
	 * Registers a stanza handler.
	 * 
	 * @param handler
	 */
	public void registerGlobalStanzaHandler(KixmppStanzaHandler handler) {
		registerGlobalStanzaHandler(HANDLER_WILDCARD, handler);
	}

	/**
	 * Unregisters a stanza handler.
	 * 
	 * @param jid
	 * @param qualifiedName
	 * @param handler
	 */
	public void unregisterStanzaHandler(KixmppJid jid, String qualifiedName, KixmppStanzaHandler handler) {
		Set<KixmppStanzaHandler> handlers = stanzaHandlers.get(Tuple.from(qualifiedName, jid));
		
		if (handlers != null) {
			handlers.remove(handler);
		}
	}
	
	/**
	 * Unregisters a stanza handler.
	 * 
	 * @param jid
	 * @param handler
	 */
	public void unregisterStanzaHandler(KixmppJid jid, KixmppStanzaHandler handler) {
		unregisterStanzaHandler(jid, HANDLER_WILDCARD, handler);
	}
	
	/**
	 * Unregisters a stanza handler.
	 * 
	 * @param qualifiedName
	 * @param handler
	 */
	public void unregisterGlobalStanzaHandler(String qualifiedName, KixmppStanzaHandler handler) {
		Set<KixmppStanzaHandler> handlers = stanzaHandlers.get(Tuple.from(qualifiedName));
		
		if (handlers != null) {
			handlers.remove(handler);
		}
	}
	
	/**
	 * Unregisters a stanza handler.
	 * 
	 * @param handler
	 */
	public void unregisterGlobalStanzaHandler(KixmppStanzaHandler handler) {
		unregisterGlobalStanzaHandler(HANDLER_WILDCARD, handler);
	}
	
	/**
	 * Unregisters all the handlers.
	 */
	public void unregisterAll() {
		stanzaHandlers.clear();
		connectionHandlers.clear();
		streamHandlers.clear();
		sessionHandlers.clear();
	}
	
	private static class ExecuteStanzaHandler extends Task {
		private final KixmppStanzaHandler handler;
		private final Channel channel;
		private final Element stanza;
		
		public ExecuteStanzaHandler(KixmppStanzaHandler handler, Channel channel, Element stanza) {
			this.handler = handler;
			this.channel = channel;
			this.stanza = stanza;
		}

		public void run() {
			handler.handle(channel, stanza);
		}
	}
	
	private static class ExecuteConnectionConnectedHandler extends Task {
		private final KixmppConnectionHandler handler;
		private final Channel channel;
		
		public ExecuteConnectionConnectedHandler(KixmppConnectionHandler handler, Channel channel) {
			this.handler = handler;
			this.channel = channel;
		}

		public void run() {
			handler.handleConnected(channel);
		}
	}
	
	private static class ExecuteConnectionDisconnectedHandler extends Task {
		private final KixmppConnectionHandler handler;
		private final Channel channel;
		
		public ExecuteConnectionDisconnectedHandler(KixmppConnectionHandler handler, Channel channel) {
			this.handler = handler;
			this.channel = channel;
		}

		public void run() {
			handler.handleDisconnected(channel);
		}
	}
	
	private static class ExecuteStreamStartHandler extends Task {
		private final KixmppStreamHandler handler;
		private final Channel channel;
		private final KixmppStreamStart start;
		
		public ExecuteStreamStartHandler(KixmppStreamHandler handler, Channel channel, KixmppStreamStart start) {
			this.handler = handler;
			this.channel = channel;
			this.start = start;
		}

		public void run() {
			handler.handleStreamStart(channel, start);
		}
	}
	
	private static class ExecuteStreamEndHandler extends Task {
		private final KixmppStreamHandler handler;
		private final Channel channel;
		private final KixmppStreamEnd end;
		
		public ExecuteStreamEndHandler(KixmppStreamHandler handler, Channel channel, KixmppStreamEnd end) {
			this.handler = handler;
			this.channel = channel;
			this.end = end;
		}

		public void run() {
			handler.handleStreamEnd(channel, end);
		}
	}

	private static class ExecuteSessionStartHandler extends Task {
		private final KixmppSessionHandler handler;
		private final Channel channel;

		public ExecuteSessionStartHandler(KixmppSessionHandler handler, Channel channel) {
			this.handler = handler;
			this.channel = channel;
		}

		public void run() {
			handler.handleSessionStart(channel);
		}
	}
}