/*
* KitchenSync-core Java Library Copyright (C) 2014 Burton Alexander
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option) any later
* version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program; if not, write to the Free Software Foundation, Inc., 51
* Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
*/
package com.github.mrstampy.kitchensync.netty;
import io.netty.bootstrap.AbstractBootstrap;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.epoll.EpollDatagramChannel;
import io.netty.channel.epoll.EpollEventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.oio.OioEventLoopGroup;
import io.netty.channel.socket.DatagramChannel;
import io.netty.channel.socket.nio.NioDatagramChannel;
import io.netty.channel.socket.oio.OioDatagramChannel;
import io.netty.util.concurrent.GenericFutureListener;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.NetworkInterface;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.github.mrstampy.kitchensync.netty.channel.AbstractKiSyMulticastChannel;
import com.github.mrstampy.kitchensync.util.KiSyUtils;
/**
* The Class Bootstrapper is the KitchenSync/<a href="http://netty.io">Netty</a>
* core class. It instantiates and keeps track of all Netty <a
* href="http://netty.io/4.0/api/io/netty/bootstrap/Bootstrap.html"
* >Bootstrap</a>s created and provides the ability to customize <a
* href="http://netty.io/4.0/api/io/netty/channel/ChannelOption.html"
* >options</a> on a per-bootstrap basis. This allows for easy creation of
* channels for separate tasks (ie. one for autonomous program state, one for
* sending and receiving broadcast messages, one for receiving broadcasted video
* etc.). The defaults chosen should be fine for small to medium numbers of
* channels with low to medium traffic. An understanding of Netty and Java
* Sockets is necessary to optimize the parameters for specific tasks.<br>
* <br>
*
* Bootstraps are either bound to a port (next available or specified) on the
* host machine or are bound to multicast addresses, both using the UDP protocol
* for communication. On startup the default InetAddress and default network
* interface are determined.
*/
public class Bootstrapper {
private static final Logger log = LoggerFactory.getLogger(Bootstrapper.class);
private static final int DEFAULT_BOOTSTRAP_KEY = -1;
/** The Constant INSTANCE. */
public static final Bootstrapper INSTANCE = new Bootstrapper();
/** The default interface. */
public final NetworkInterface DEFAULT_INTERFACE;
/** The default address. */
public final InetAddress DEFAULT_ADDRESS;
private static Map<Integer, Bootstrap> channelBootstraps = new ConcurrentHashMap<Integer, Bootstrap>();
private static Map<String, Bootstrap> multicastBootstraps = new ConcurrentHashMap<String, Bootstrap>();
/**
* The Constructor, use if subclassing, otherwise {@link #INSTANCE}.
*/
public Bootstrapper() {
try {
DEFAULT_ADDRESS = InetAddress.getLocalHost();
DEFAULT_INTERFACE = NetworkInterface.getByInetAddress(DEFAULT_ADDRESS);
} catch (Exception e) {
log.error("Could not determine network interface", e);
throw new RuntimeException(e);
}
}
/**
* Checks for default bootstrap.
*
* @return true, if checks for default bootstrap
*/
public boolean hasDefaultBootstrap() {
return containsBootstrap(DEFAULT_BOOTSTRAP_KEY);
}
/**
* Returns true if a bootstrap for the specified port is available.
*
* @param port
* the port
* @return true, if contains bootstrap
*/
public boolean containsBootstrap(int port) {
return channelBootstraps.containsKey(port);
}
/**
* Returns true if the bootstrap exists for the specified multicast address.
*
* @param multicast
* the multicast
* @return true, if contains multicast bootstrap
*/
public boolean containsMulticastBootstrap(InetSocketAddress multicast) {
String key = createMulticastKey(multicast);
return containsMulticastBootstrap(key);
}
/**
* Inits the default bootstrap. This bootstrap is used should no port-specific
* bootstrap exist when the {@link #bind()} or {@link #bind(int)} methods are
* called.<br>
* <br>
*
* The channel initializer allows the many Netty handlers to be specified as
* required for the bootstrap ie. one for SSL communication, one for message
* encryption/decryption etc etc. Refer to the <a
* href="http://netty.io">Netty</a> documentation for more information.
*
* @param <CHANNEL>
* the generic type
* @param initializer
* the initializer
* @param clazz
* the clazz
*/
public <CHANNEL extends DatagramChannel> void initDefaultBootstrap(ChannelInitializer<CHANNEL> initializer,
Class<? extends CHANNEL> clazz) {
initBootstrap(initializer, DEFAULT_BOOTSTRAP_KEY, clazz);
}
/**
* Inits the bootstrap for a specified port. This allows different bootstraps
* for different channels, all configured differently.<br>
* <br>
*
* The channel initializer allows the many Netty handlers to be specified as
* required for the bootstrap ie. one for SSL communication, one for message
* encryption/decryption etc etc. Refer to the <a
* href="http://netty.io">Netty</a> documentation for more information.
*
* @param <CHANNEL>
* the generic type
* @param initializer
* the initializer
* @param port
* the port
* @param clazz
* the clazz
*/
public <CHANNEL extends DatagramChannel> void initBootstrap(ChannelInitializer<CHANNEL> initializer, int port,
Class<? extends CHANNEL> clazz) {
if (containsBootstrap(port)) {
log.warn("Bootstrap for port {} already initialized", port);
return;
}
log.debug("Initializing bootstrap for port {}", port);
Bootstrap b = bootstrap(initializer, port, clazz);
channelBootstraps.put(port, b);
}
/**
* Inits the multicast bootstrap for the specified address.<br>
* <br>
*
* The channel initializer allows the many Netty handlers to be specified as
* required for the bootstrap ie. one for SSL communication, one for message
* encryption/decryption etc etc. Refer to the <a
* href="http://netty.io">Netty</a> documentation for more information.
*
* @param <CHANNEL>
* the generic type
* @param initializer
* the initializer
* @param multicast
* the multicast
* @param clazz
* the clazz
*/
public <CHANNEL extends DatagramChannel> void initMulticastBootstrap(ChannelInitializer<DatagramChannel> initializer,
InetSocketAddress multicast, Class<? extends CHANNEL> clazz) {
initMulticastBootstrap(initializer, multicast, DEFAULT_INTERFACE, clazz);
}
/**
* Inits the multicast bootstrap for the specified address.<br>
* <br>
*
* The channel initializer allows the many Netty handlers to be specified as
* required for the bootstrap ie. one for SSL communication, one for message
* encryption/decryption etc etc. Refer to the <a
* href="http://netty.io">Netty</a> documentation for more information.
*
* @param <CHANNEL>
* the generic type
* @param initializer
* the initializer
* @param multicast
* the multicast
* @param networkInterface
* the network interface
* @param clazz
* the clazz
*/
public <CHANNEL extends DatagramChannel> void initMulticastBootstrap(ChannelInitializer<DatagramChannel> initializer,
InetSocketAddress multicast, NetworkInterface networkInterface, Class<? extends CHANNEL> clazz) {
String key = createMulticastKey(multicast);
if (containsMulticastBootstrap(key)) {
log.warn("Multicast bootstrap for {} already initialized", multicast);
return;
}
log.debug("Initializing multicast bootstrap for {} using network interface {}", multicast, networkInterface);
Bootstrap b = multicastBootstrap(initializer, multicast, networkInterface, clazz);
multicastBootstraps.put(key, b);
}
private String createMulticastKey(InetSocketAddress multicast) {
return AbstractKiSyMulticastChannel.createMulticastKey(multicast);
}
/**
* Removes the bootstrap.
*
* @param port
* the port
* @return the bootstrap
*/
public Bootstrap removeBootstrap(int port) {
return channelBootstraps.remove(port);
}
/**
* Removes the multicast bootstrap.
*
* @param address
* the address
* @return the bootstrap
*/
public Bootstrap removeMulticastBootstrap(InetSocketAddress address) {
return removeMulticastBootstrap(createMulticastKey(address));
}
/**
* Removes the multicast bootstrap.
*
* @param key
* the key
* @return the bootstrap
*/
public Bootstrap removeMulticastBootstrap(String key) {
return multicastBootstraps.remove(key);
}
/**
* Gets the bootstrap keys.
*
* @return the bootstrap keys
*/
public Set<Integer> getBootstrapKeys() {
return channelBootstraps.keySet();
}
/**
* Gets the bootstraps.
*
* @return the bootstraps
*/
public Collection<Bootstrap> getBootstraps() {
return channelBootstraps.values();
}
/**
* Gets the multicast bootstrap keys.
*
* @return the multicast bootstrap keys
*/
public Set<String> getMulticastBootstrapKeys() {
return multicastBootstraps.keySet();
}
/**
* Gets the multicast bootstraps.
*
* @return the multicast bootstraps
*/
public Collection<Bootstrap> getMulticastBootstraps() {
return multicastBootstraps.values();
}
/**
* Gets the default bootstrap.
*
* @return the default bootstrap
*/
public Bootstrap getDefaultBootstrap() {
return getBootstrap(DEFAULT_BOOTSTRAP_KEY);
}
/**
* Gets the bootstrap.
*
* @param key
* the key
* @return the bootstrap
*/
public Bootstrap getBootstrap(int key) {
return channelBootstraps.get(key);
}
/**
* Gets the multicast bootstrap.
*
* @param address
* the address
* @return the multicast bootstrap
*/
public Bootstrap getMulticastBootstrap(InetSocketAddress address) {
String key = createMulticastKey(address);
return getMulticastBootstrap(key);
}
/**
* Gets the multicast bootstrap.
*
* @param key
* the key
* @return the multicast bootstrap
*/
public Bootstrap getMulticastBootstrap(String key) {
return multicastBootstraps.get(key);
}
/**
* Clear bootstraps.
*/
public void clearBootstraps() {
channelBootstraps.clear();
}
/**
* Clear multicast bootstraps.
*/
public void clearMulticastBootstraps() {
multicastBootstraps.clear();
}
/**
* Bind to the next available port on the host machine using the default
* bootstrap.
*
* @param <CHANNEL>
* the generic type
* @return the channel
*/
public <CHANNEL extends DatagramChannel> CHANNEL bind() {
return bind(0);
}
/**
* Returns a channel using the bootstrap for the specified port. Should none
* exist then the default bootstrap is used.
*
* @param <CHANNEL>
* the generic type
* @param port
* the port
* @return the channel
*/
@SuppressWarnings("unchecked")
public <CHANNEL extends DatagramChannel> CHANNEL bind(int port) {
boolean contains = containsBootstrap(port);
if (!contains && !hasDefaultBootstrap()) {
log.error("Bootstrap for port {} not initialized", port);
return null;
}
Bootstrap b = channelBootstraps.get(contains ? port : DEFAULT_BOOTSTRAP_KEY);
ChannelFuture cf = b.bind(port);
CountDownLatch latch = new CountDownLatch(1);
cf.addListener(getBindListener(port, latch));
await(latch, "Channel creation timed out");
return cf.isSuccess() ? (CHANNEL) cf.channel() : null;
}
/**
* Bind to the specified multicast address.
*
* @param <CHANNEL>
* the generic type
* @param multicast
* the multicast
* @return the channel
*/
@SuppressWarnings("unchecked")
public <CHANNEL extends DatagramChannel> CHANNEL multicastBind(InetSocketAddress multicast) {
String key = createMulticastKey(multicast);
if (!containsMulticastBootstrap(key)) {
log.error("Multicast bootstrap for {} not initialized", multicast);
return null;
}
Bootstrap b = multicastBootstraps.get(key);
ChannelFuture cf = b.bind();
CountDownLatch latch = new CountDownLatch(1);
cf.addListener(getMulticastBindListener(multicast, latch));
await(latch, "Multicast channel creation timed out");
return cf.isSuccess() ? (CHANNEL) cf.channel() : null;
}
private GenericFutureListener<ChannelFuture> getBindListener(final int port, final CountDownLatch latch) {
return new GenericFutureListener<ChannelFuture>() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
try {
if (future.isSuccess()) {
log.debug("Channel creation successful for {}", future.channel());
} else {
Throwable cause = future.cause();
if (cause == null) {
log.error("Could not create channel for {}", port);
} else {
log.error("Could not create channel for {}", port, cause);
}
}
} finally {
latch.countDown();
}
}
};
}
private GenericFutureListener<ChannelFuture> getMulticastBindListener(final InetSocketAddress multicast,
final CountDownLatch latch) {
return new GenericFutureListener<ChannelFuture>() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
try {
if (future.isSuccess()) {
log.debug("Multicast channel creation successful for {}", multicast);
} else {
Throwable cause = future.cause();
if (cause == null) {
log.error("Could not create multicast channel for {}", multicast);
} else {
log.error("Could not create multicast channel for {}", multicast, cause);
}
}
} finally {
latch.countDown();
}
}
};
}
private void await(CountDownLatch latch, String error) {
boolean ok = KiSyUtils.await(latch, 5, TimeUnit.SECONDS);
if (!ok) log.error(error);
}
/**
* Creates bootstrap for all purposes. Sets default options, event loop group
* and channel class. If the port > 0 (and it should be > 1024) then it
* is set in the bootstrap (localAddress).
*
* @param <CHANNEL>
* the generic type
* @param initializer
* the initializer
* @param port
* the port
* @param clazz
* the clazz
* @return the bootstrap
*/
protected <CHANNEL extends DatagramChannel> Bootstrap bootstrap(ChannelInitializer<CHANNEL> initializer, int port,
Class<? extends CHANNEL> clazz) {
Bootstrap b = new Bootstrap();
setDefaultBootstrapOptions(b, initializer);
if (port > 0) b.localAddress(port);
b.group(getEventLoopGroup(clazz));
b.channel(clazz);
return b;
}
/**
* Gets the event loop group based upon the class name. If the class is
* neither an <a href=
* "http://netty.io/4.0/api/io/netty/channel/socket/nio/NioDatagramChannel.html"
* >NioDatagramChannel</a> nor <a href=
* "http://netty.io/4.0/api/io/netty/channel/socket/oio/OioDatagramChannel.html"
* >OioDatagramChannel</a> (or on Linux, <a href=
* "http://netty.io/4.0/api/io/netty/channel/epoll/EpollDatagramChannel.html"
* >EpollDatagramChannel</a>) then an exception is thrown.
*
* @param <CHANNEL>
* the generic type
* @param clazz
* the clazz
* @return the event loop group
*/
protected <CHANNEL extends DatagramChannel> EventLoopGroup getEventLoopGroup(Class<? extends CHANNEL> clazz) {
if (NioDatagramChannel.class.equals(clazz)) return new NioEventLoopGroup();
if (OioDatagramChannel.class.equals(clazz)) return new OioEventLoopGroup();
// Linux only
if (EpollDatagramChannel.class.equals(clazz)) return new EpollEventLoopGroup();
throw new UnsupportedOperationException("No default event loop group defined for " + clazz.getName());
}
/**
* Sets the default bootstrap options (SO_BROADCAST=true, SO_REUSEADDR=true)
* and the initializer as the channel handler.
*
* @param b
* the b
* @param initializer
* the initializer
*/
protected void setDefaultBootstrapOptions(AbstractBootstrap<?, ?> b, ChannelInitializer<?> initializer) {
b.option(ChannelOption.SO_BROADCAST, true);
b.option(ChannelOption.SO_REUSEADDR, true);
b.handler(initializer);
}
/**
* Multicast bootstrap using the default network interface.
*
* @param <CHANNEL>
* the generic type
* @param initializer
* the initializer
* @param multicast
* the multicast
* @param clazz
* the clazz
* @return the bootstrap
*/
protected <CHANNEL extends DatagramChannel> Bootstrap multicastBootstrap(
ChannelInitializer<DatagramChannel> initializer, InetSocketAddress multicast, Class<? extends CHANNEL> clazz) {
return multicastBootstrap(initializer, multicast, DEFAULT_INTERFACE, clazz);
}
/**
* Multicast bootstrap, adding the IP_MULTICAST_IF=networkInterface option.
*
* @param <CHANNEL>
* the generic type
* @param initializer
* the initializer
* @param multicast
* the multicast
* @param networkInterface
* the network interface
* @param clazz
* the clazz
* @return the bootstrap
*/
protected <CHANNEL extends DatagramChannel> Bootstrap multicastBootstrap(
ChannelInitializer<DatagramChannel> initializer, InetSocketAddress multicast, NetworkInterface networkInterface,
Class<? extends CHANNEL> clazz) {
Bootstrap b = bootstrap(initializer, multicast.getPort(), clazz);
b.option(ChannelOption.IP_MULTICAST_IF, networkInterface);
return b;
}
private boolean containsMulticastBootstrap(String key) {
return multicastBootstraps.containsKey(key);
}
}