From 12a4ef19a0fb5d5daac3946e4841f57c4cee8f15 Mon Sep 17 00:00:00 2001
From: Boris Grozev
Date: Mon, 7 Nov 2016 14:49:00 -0600
Subject: [PATCH] feat: Adds MergingDatagramSocket.
---
.../ice4j/socket/MergingDatagramSocket.java | 809 ++++++++++++++++++
1 file changed, 809 insertions(+)
create mode 100644 src/main/java/org/ice4j/socket/MergingDatagramSocket.java
diff --git a/src/main/java/org/ice4j/socket/MergingDatagramSocket.java b/src/main/java/org/ice4j/socket/MergingDatagramSocket.java
new file mode 100644
index 0000000..59f99b9
--- /dev/null
+++ b/src/main/java/org/ice4j/socket/MergingDatagramSocket.java
@@ -0,0 +1,809 @@
+/*
+ * ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
+ *
+ * Copyright @ 2015-2016 Atlassian Pty Ltd
+ *
+ * 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.ice4j.socket;
+
+import java.io.*;
+import java.net.*;
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.logging.*;
+
+/**
+ * A {@link DatagramSocket} implementation which merges a set of sockets.
+ *
+ * It maintains a thread reading from each of the underlying sockets. Thus
+ * received datagrams are provided via the {@link #receive(DatagramPacket)}
+ * API, in the order in which they were originally received (or close to it,
+ * since the implementation is only based on timestamps).
+ *
+ * One of the underlying sockets is used as a delegate, and handles sending
+ * via {@link #send(DatagramPacket)} and calls to
+ * {@link #getLocalPort()}, {@link #getLocalAddress()} and
+ * {@link #getLocalSocketAddress()}.
+ *
+ * Currently the delegate is just the first socket, but the intention is to
+ * allow it to change dynamically.
+ *
+ * @author Boris Grozev
+ */
+public class MergingDatagramSocket
+ extends DatagramSocket
+{
+ /**
+ * The {@link Logger} used by the {@link MergingDatagramSocket} class and
+ * its instances for logging output.
+ */
+ private static final Logger logger
+ = Logger.getLogger(MergingDatagramSocket.class.getName());
+
+ /**
+ * Used to control access to {@link #socketContainers}.
+ */
+ private final Object socketContainersSyncRoot = new Object();
+
+ /**
+ * Stores the underlying sockets. Copy on write.
+ */
+ private SocketContainer[] socketContainers = new SocketContainer[0];
+
+ /**
+ * Calls to {@link #receive(java.net.DatagramPacket)} will wait on this
+ * object in case no packet is available for reading.
+ */
+ private final Object receiveLock = new Object();
+
+ /**
+ * If non-zero, {@link #receive(java.net.DatagramPacket)} will attempt to
+ * return within this many milliseconds, and will throw a
+ * {@link SocketTimeoutException} if no packet has been read.
+ */
+ private int soTimeout = 0;
+
+ /**
+ * Initializes a new {@link MergingDatagramSocket} instance.
+ * @throws SocketException
+ */
+ public MergingDatagramSocket()
+ throws SocketException
+ {}
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public void setSoTimeout(int soTimeout)
+ {
+ this.soTimeout = soTimeout;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int getSoTimeout()
+ {
+ return soTimeout;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * The current implementation delegates to the first container, but this is
+ * subject to change.
+ *
+ * @param pkt the datagram to send.
+ * @throws IOException
+ */
+ @Override
+ public void send(DatagramPacket pkt)
+ throws IOException
+ {
+ SocketContainer[] socketContainers = this.socketContainers;
+ if (socketContainers != null && socketContainers.length > 0
+ && socketContainers[0] != null)
+ {
+ socketContainers[0].send(pkt);
+ }
+ else
+ {
+ throw new IOException("No sockets.");
+ }
+
+ }
+
+ /**
+ * Adds a {@link DelegatingSocket} instance to this merging socket. Note
+ * that this will start a thread reading from the added socket.
+ * @param socket the socket to add.
+ */
+ public void add(DelegatingSocket socket)
+ {
+ Objects.requireNonNull(socket, "socket");
+ if (logger.isLoggable(Level.FINE))
+ {
+ logger.fine("Adding a DelegatingSocket instance: "
+ + socket.getLocalAddress());
+ }
+ doAdd(socket);
+ }
+
+ /**
+ * Adds a {@link DatagramSocket} instance to this merging socket. Note
+ * that this will start a thread reading from the added socket.
+ * @param socket the socket to add.
+ */
+ public void add(DatagramSocket socket)
+ {
+ Objects.requireNonNull(socket, "socket");
+ if (logger.isLoggable(Level.FINE))
+ {
+ logger.fine("Adding a DatagramSocket instance: "
+ + socket.getLocalAddress());
+ }
+ doAdd(socket);
+ }
+
+ /**
+ * Adds a socket (either a {@link DatagramSocket} or a
+ * {@link DelegatingSocket}) to the list of underlying sockets merged by
+ * this {@link MergingDatagramSocket}.
+ * @param socket the socket to add.
+ */
+ private void doAdd(Object socket)
+ {
+ if (!(socket instanceof DelegatingSocket) &&
+ !(socket instanceof DatagramSocket))
+ {
+ logger.severe("Unsupported class: "
+ + (socket == null ? "null" : socket.getClass()));
+ return;
+ }
+
+ synchronized (socketContainersSyncRoot)
+ {
+ if (indexOf(socketContainers, socket) != -1)
+ {
+ logger.warning("Socket already added.");
+ return;
+ }
+
+ SocketContainer socketContainer;
+ if (socket instanceof DelegatingSocket)
+ {
+ socketContainer = new SocketContainer((DelegatingSocket) socket);
+ }
+ else
+ {
+ socketContainer = new SocketContainer((DatagramSocket) socket);
+ }
+
+ SocketContainer[] newSocketContainers
+ = new SocketContainer[socketContainers.length + 1];
+ System.arraycopy(socketContainers, 0,
+ newSocketContainers, 0,
+ socketContainers.length);
+ newSocketContainers[socketContainers.length] = socketContainer;
+
+ socketContainers = newSocketContainers;
+ }
+ }
+
+ /**
+ * Removes a specific {@link DatagramSocket} from the list of sockets
+ * merged by this {@link MergingDatagramSocket}.
+ * @param socket the {@link DatagramSocket} to remove.
+ */
+ public void remove(DatagramSocket socket)
+ {
+ doRemove(socket);
+ }
+
+ /**
+ * Removes a specific {@link DelegatingSocket} from the list of sockets
+ * merged by this {@link MergingDatagramSocket}.
+ * @param socket the {@link DelegatingSocket} to remove.
+ */
+ public void remove(DelegatingSocket socket)
+ {
+ doRemove(socket);
+ }
+
+ /**
+ * Removes a socket from the list of sockets merged by this
+ * {@link MergingDatagramSocket}.
+ * @param socket the socket to remove.
+ */
+ private void doRemove(Object socket)
+ {
+ SocketContainer socketContainer = null;
+
+ synchronized (socketContainersSyncRoot)
+ {
+ int i = indexOf(socketContainers, socket);
+ if (i > 0)
+ {
+ socketContainer = socketContainers[i];
+
+ SocketContainer[] newSockets
+ = new SocketContainer[socketContainers.length - 1];
+ if (i > 0)
+ {
+ System.arraycopy(socketContainers, 0,
+ newSockets, 0,
+ i);
+ }
+ if (i < socketContainers.length - 1)
+ {
+ System.arraycopy(socketContainers, i + 1,
+ newSockets, i,
+ socketContainers.length - i - 1);
+ }
+
+ socketContainers = newSockets;
+ }
+ else
+ {
+ logger.severe("Cannot find socket to remove.");
+ }
+ }
+
+ if (logger.isLoggable(Level.FINE))
+ {
+ logger.fine("Removed: " + socketContainer);
+ }
+ if (socketContainer != null)
+ {
+ // Stop the reading thread.
+ // TODO: do we want to interrupt the thread here? This will not
+ // help unless we set a soTimeout > 0
+ socketContainer.closed = true;
+ }
+ }
+
+ /**
+ * Returns the index in {@link #socketContainers} of the
+ * {@link SocketContainer} with socket equal to {@code socket}, or -1 if
+ * such a {@link SocketContainer} doesn't exist.
+ *
+ * @param socket the {@link DatagramSocket} to get the index of.
+ * @return the index in {@link #socketContainers} of the
+ * {@link SocketContainer} with socket equal to {@code socket}, or -1 if
+ * such a {@link SocketContainer} doesn't exist.
+ */
+ private int indexOf(SocketContainer[] socketContainers, Object socket)
+ {
+ for (int i = 0; i < socketContainers.length; i++)
+ {
+ if (socketContainers[i].datagramSocket == socket ||
+ socketContainers[i].delegatingSocket == socket)
+ {
+ return i;
+ }
+ }
+ return -1;
+ }
+
+ /**
+ * TODO
+ */
+ private SocketContainer getActiveSocket()
+ {
+ //TODO switch dynamically.
+ SocketContainer[] socketContainers = this.socketContainers;
+ if (socketContainers != null && socketContainers.length > 0)
+ {
+ return socketContainers[0];
+ }
+ return null;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * Delegates to the "active" socket, if one exists. Else returns
+ * {@code null}.
+ */
+ @Override
+ public InetAddress getLocalAddress()
+ {
+ SocketContainer activeSocket = getActiveSocket();
+ return activeSocket == null ? null : activeSocket.getLocalAddress();
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * Delegates to the "active" socket, if one exists. Else returns
+ * {@code 0}.
+ * TODO: should we return 0 (unbound) or -1 (closed) if there are no
+ * sockets?
+ */
+ @Override
+ public int getLocalPort()
+ {
+ SocketContainer activeSocket = getActiveSocket();
+ return activeSocket == null ? 0 : activeSocket.getLocalPort();
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * Delegates to the "active" socket, if one exists. Else returns
+ * {@code null}.
+ */
+ @Override
+ public SocketAddress getLocalSocketAddress()
+ {
+ SocketContainer activeSocket = getActiveSocket();
+ return
+ activeSocket == null ? null : activeSocket.getLocalSocketAddress();
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * Copies into {@code p} a packet already received from one of the
+ * underlying sockets. The socket is chosen on the base of the timestamp
+ * of the reception of the first packet in its queue (so that earlier
+ * packets are received first).
+ */
+ @Override
+ public void receive(DatagramPacket p)
+ throws SocketTimeoutException
+ {
+ long start = System.currentTimeMillis();
+ int soTimeout = this.soTimeout;
+
+ // We need to hold the lock while checking for an available packet,
+ // otherwise we might end up wait()-ing if a packet becomes available
+ // after our check.
+ // We keep the loop inside the lock, because this prevents us from
+ // having to re-obtain the lock after wait() returns. All operations
+ // inside the block are non-blocking, except for wait(), so we run no
+ // risk of causing a deadlock by doing so.
+ synchronized (receiveLock)
+ {
+ do
+ {
+ // Find the input socket with the oldest packet
+ SocketContainer[] socketContainers = this.socketContainers;
+ SocketContainer socketToReceiveFrom = null;
+ long firstTime = -1;
+ for (SocketContainer socketContainer : socketContainers)
+ {
+ long f = socketContainer.getFirstReceivedTime();
+ if (f > 0)
+ {
+ if (firstTime == -1 || firstTime > f)
+ {
+ firstTime = f;
+ socketToReceiveFrom = socketContainer;
+ }
+ }
+ }
+
+ // If a packet is available read it
+ if (socketToReceiveFrom != null)
+ {
+ socketToReceiveFrom.receive(p);
+ return;
+ }
+ // Otherwise wait on receiveLock.
+ else
+ {
+ try
+ {
+ if (soTimeout > 0)
+ {
+ long remaining
+ = start + soTimeout
+ - System.currentTimeMillis();
+ if (remaining <= 0)
+ throw new SocketTimeoutException();
+
+ receiveLock.wait(remaining);
+ }
+ else
+ {
+ receiveLock.wait();
+ }
+ }
+ catch (InterruptedException ie)
+ {
+ Thread.currentThread().interrupt();
+ // We haven't received a packet, but what else can we
+ // do?
+ return;
+ }
+ }
+ }
+ while (true);
+ }
+ }
+
+ /**
+ * Contains one of the sockets which this {@link MergingDatagramSocket}
+ * merges, and objects associated with the socket, including a thread
+ * which loops reading from it.
+ *
+ * The socket is either a {@link DatagramSocket} or a
+ * {@link DelegatingSocket} instance, stored in {@link #datagramSocket} or
+ * {@link #delegatingSocket} respectively. Exactly one of these fields must
+ * be null.
+ */
+ private class SocketContainer
+ {
+ /**
+ * Either the socket represented by this instance, if it is a {@link
+ * DatagramSocket} instance, or {@code null} if it is not.
+ */
+ private final DatagramSocket datagramSocket;
+
+ /**
+ * Either the socket represented by this instance, if it is a {@link
+ * DelegatingSocket} instance, or {@code null}if it is not.
+ */
+ private final DelegatingSocket delegatingSocket;
+
+ /**
+ * The queue to which packets received from this instance's socket are
+ * added.
+ */
+ private final ArrayBlockingQueue queue
+ = new ArrayBlockingQueue<>(100);
+
+ /**
+ * A pool of unused {@link Buffer} instances.
+ */
+ private final ArrayBlockingQueue pool
+ = new ArrayBlockingQueue<>(10);
+
+ /**
+ * A flag used to signal to {@link #thread} to finish.
+ */
+ private boolean closed = false;
+
+ /**
+ * The remote address of the last received packet.
+ */
+ private SocketAddress remoteAddress = null;
+
+ /**
+ * The thread which reads packets from this instance's socket and adds
+ * them to {@link #queue}. If the queue is filled up, it will stop
+ * receiving packets and will block waiting for the queue accept.
+ */
+ private Thread thread;
+
+ /**
+ * Initializes a {@link SocketContainer} instance using a {@link
+ * DatagramSocket} as its socket.
+ *
+ * @param socket the socket.
+ */
+ SocketContainer(DelegatingSocket socket)
+ {
+ this.datagramSocket = null;
+ this.delegatingSocket = Objects.requireNonNull(socket, "socket");
+ init();
+ }
+
+ /**
+ * Initializes a {@link SocketContainer} instance using a {@link
+ * DatagramSocket} as its socket.
+ *
+ * @param socket the socket.
+ */
+ SocketContainer(DatagramSocket socket)
+ {
+ this.datagramSocket = Objects.requireNonNull(socket, "socket");
+ this.delegatingSocket = null;
+ init();
+ }
+
+ /**
+ * Initializes and starts the thread of this instance.
+ */
+ private void init()
+ {
+ thread = new Thread()
+ {
+ @Override
+ public void run()
+ {
+ runInReaderThread();
+ }
+ };
+ thread.setDaemon(true);
+ thread.setName("MergingDatagramSocket reader thread for: "
+ + getLocalSocketAddress() + " -> "
+ + getRemoteSocketAddress());
+
+ if (logger.isLoggable(Level.FINE))
+ {
+ logger.fine("Starting the thread for socket "
+ + getLocalSocketAddress() + " -> "
+ + getRemoteSocketAddress());
+ }
+ thread.start();
+ }
+
+ /**
+ * @return an unused {@link Buffer} instance.
+ */
+ private Buffer getFreeBuffer()
+ {
+ Buffer buffer = pool.poll();
+ if (buffer == null)
+ buffer = new Buffer();
+ buffer.reset();
+ return buffer;
+ }
+
+ /**
+ * Reads from the underlying socket and adds the read packets to {@link
+ * #queue}. Blocks if {@link #queue} is full.
+ */
+ private void runInReaderThread()
+ {
+ while (true)
+ {
+ if (closed || Thread.currentThread().isInterrupted())
+ break;
+
+ // Read from the underlying socket
+ Buffer buffer = getFreeBuffer();
+ try
+ {
+ if (!doReceive(buffer))
+ {
+ continue;
+ }
+ }
+ catch (IOException ioe)
+ {
+ logger.severe("Failed to receive: " + ioe);
+ break;
+ }
+
+ if (closed || Thread.currentThread().isInterrupted())
+ break;
+
+ try
+ {
+ queue.put(buffer);
+ synchronized (receiveLock)
+ {
+ receiveLock.notifyAll();
+ }
+ }
+ catch (InterruptedException ie)
+ {
+ Thread.currentThread().interrupt();
+ }
+ }
+
+ if (logger.isLoggable(Level.FINE))
+ {
+ logger.fine("Finished: " + toString());
+ }
+ }
+
+ /**
+ * Tries to receive a packet from the underlying socket into {@code
+ * buffer}.
+ *
+ * @param buffer the buffer into which to receive.
+ * @return {@code true} if the method succeeded, or {@code false} if the
+ * thread was interrupted or this {@link SocketContainer} was closed.
+ * @throws IOException if receiving failed due to an I/O error from the
+ * underlying socket.
+ */
+ private boolean doReceive(Buffer buffer)
+ throws IOException
+ {
+ while (true)
+ {
+ if (closed || Thread.currentThread().isInterrupted())
+ break;
+ try
+ {
+ if (datagramSocket != null)
+ {
+ datagramSocket.receive(buffer.pkt);
+ }
+ else
+ {
+ delegatingSocket.receive(buffer.pkt);
+ }
+
+ buffer.receivedTime = System.currentTimeMillis();
+ remoteAddress = buffer.pkt.getSocketAddress();
+ return true;
+ }
+ catch (SocketTimeoutException ste)
+ {
+ // Ignore timeouts and loop.
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Copies a packet from this {@link SocketContainer}'s queue into
+ * {@code p}. Does not block.
+ *
+ * @param p the {@link DatagramPacket} to receive into.
+ */
+ private void receive(DatagramPacket p)
+ {
+ Buffer buffer = queue.poll();
+ if (buffer == null)
+ {
+ throw new IllegalStateException("Queue empty.");
+ }
+
+ byte[] dest = p.getData();
+ int destOffset = p.getOffset();
+ int len
+ = Math.min(
+ dest.length - destOffset,
+ buffer.pkt.getLength());
+
+ System.arraycopy(buffer.pkt.getData(), buffer.pkt.getOffset(),
+ dest, destOffset,
+ len);
+ p.setLength(len);
+ p.setSocketAddress(buffer.pkt.getSocketAddress());
+
+ pool.offer(buffer);
+ }
+
+ /**
+ * @return the time of reception of the first packet in the queue, or
+ * {@code -1} if the queue is empty.
+ */
+ private long getFirstReceivedTime()
+ {
+ Buffer nextBuffer = queue.peek();
+ if (nextBuffer != null)
+ {
+ return nextBuffer.receivedTime;
+ }
+ return -1;
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * Delegates to the underlying socket (either {@link #datagramSocket} or
+ * {@link #delegatingSocket}).
+ */
+ private InetAddress getLocalAddress()
+ {
+ return datagramSocket != null
+ ? datagramSocket.getLocalAddress()
+ : delegatingSocket.getLocalAddress();
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * Delegates to the underlying socket (either {@link #datagramSocket} or
+ * {@link #delegatingSocket}).
+ */
+ private int getLocalPort()
+ {
+ return datagramSocket != null
+ ? datagramSocket.getLocalPort()
+ : delegatingSocket.getLocalPort();
+ }
+
+ /**
+ * {@inheritDoc}
+ *
+ * Delegates to the underlying socket (either {@link #datagramSocket} or
+ * {@link #delegatingSocket}).
+ */
+ public SocketAddress getLocalSocketAddress()
+ {
+ return datagramSocket != null
+ ? datagramSocket.getLocalSocketAddress()
+ : delegatingSocket.getLocalSocketAddress();
+
+ }
+
+ /**
+ * Returns a {@link String} representation of this {@link
+ * SocketContainer}.
+ */
+ public String toString()
+ {
+ if (datagramSocket != null)
+ {
+ return datagramSocket.getLocalSocketAddress()
+ + " -> " + remoteAddress;
+ }
+ else
+ {
+ return delegatingSocket.getLocalSocketAddress()
+ + " -> " + remoteAddress;
+ }
+ }
+
+ /**
+ * Sends a {@link DatagramPacket} through the underlying socket (either
+ * {@link #datagramSocket} or {@link #delegatingSocket}).
+ *
+ * @param pkt the packet to send.
+ */
+ private void send(DatagramPacket pkt)
+ throws IOException
+ {
+ if (datagramSocket != null)
+ {
+ datagramSocket.send(pkt);
+ }
+ else
+ {
+ delegatingSocket.send(pkt);
+ }
+ }
+
+ /**
+ * Represents a {@link DatagramPacket} for the purposes of {@link
+ * SocketContainer}.
+ */
+ private class Buffer
+ {
+ /**
+ * The size of the buffer to allocate.
+ */
+ private static final int MAX_PACKET_SIZE = 1500;
+
+ /**
+ * The time at which this buffer was filled.
+ */
+ long receivedTime = -1;
+
+ /**
+ * The {@link DatagramPacket} wrapped by this {@link Buffer}.
+ */
+ DatagramPacket pkt
+ = new DatagramPacket(
+ new byte[MAX_PACKET_SIZE],
+ 0,
+ MAX_PACKET_SIZE);
+
+ /**
+ * Prepares this {@link Buffer} for reuse.
+ */
+ private void reset()
+ {
+ receivedTime = -1;
+
+ // We are going to receive from a socket into this packet. If
+ // the length is insufficient it is going to truncate the data.
+ // So reset it to what we know is the underlying byte[]'s
+ // length.
+ pkt.setLength(MAX_PACKET_SIZE);
+ }
+ }
+ }
+}