De-duplicates a couple of methods (which I suspect are buggy and I expect it to be easier to fix the bugs if there is no duplication).

This commit is contained in:
Lyubomir Marinov 2016-03-04 22:22:04 -06:00
parent 91c7888085
commit 20f39c0037

View File

@ -22,6 +22,7 @@ import java.net.*;
import java.nio.*;
import java.nio.channels.*;
import java.util.*;
import java.util.function.*;
import org.ice4j.ice.harvest.*;
import org.ice4j.socket.*;
@ -301,31 +302,37 @@ class MuxingServerSocketChannel
*/
private static void runInAcceptThread()
{
do
{
Selector sel;
boolean select = false;
synchronized (muxingServerSocketChannels)
{
if (!Thread.currentThread().equals(acceptThread))
break;
sel = MuxingServerSocketChannel.acceptSelector;
if (!sel.isOpen())
break;
// Accept from all muxingServerSocketChannels.
for (Iterator<MuxingServerSocketChannel> i
= muxingServerSocketChannels.iterator();
i.hasNext();)
runInSelectorThread(
/* syncRoot */ muxingServerSocketChannels,
/* threadSupplier */ new Supplier<Thread>()
{
MuxingServerSocketChannel ch = i.next();
if (ch.isOpen())
@Override
public Thread get()
{
return MuxingServerSocketChannel.acceptThread;
}
},
/* selectorSupplier */ new Supplier<Selector>()
{
@Override
public Selector get()
{
return MuxingServerSocketChannel.acceptSelector;
}
},
/* selectionKeyOps */ SelectionKey.OP_ACCEPT,
/* channels */ muxingServerSocketChannels,
/* predicate */ new BiPredicate<MuxingServerSocketChannel, SelectionKey>()
{
@Override
public boolean test(
MuxingServerSocketChannel ch,
SelectionKey sk)
{
try
{
// The idea is that all muxingServerSocketChannels
// are non-blocking.
ch.accept();
}
catch (IOException ioe)
@ -336,54 +343,145 @@ class MuxingServerSocketChannel
// muxingServerSocketChannels.
}
// Make sure all muxingServerSocketChannels are
// registered with acceptSelector.
if (ch.isOpen() && ch.keyFor(sel) == null)
return false;
}
});
}
/**
* Continually tests a {@link Predicate} on a set of
* {@link SelectableChannel}s.
*
* @param syncRoot the {@code Object} to synchronize the access to
* {@code threadSupplier}, {@code selectorSupplier}, {@code channels}, and
* {@code predicate}. It should be notified whenever the values supplied by
* {@code threadSupplier}, {@code selectorSupplier}, and {@code channels}
* change.
* @param threadSupplier the {@link Supplier} which is to supply the
* {@code Thread} in which the method is supposed to be running. If the
* returned value differs from the {@code Thread} in which the method is
* actually running (i.e. {@link Thread#currentThread()}, the method
* returns. In other words, {@code threadSupplier} is one of the ways to
* break out of the loop implemented by the method. The
* {@code threadSupplier} is called on while {@code syncRoot} is acquired.
* @param selectorSupplier the {@code Supplier} which is to supply the
* {@code Selector} on which the method is to await changes in the states of
* {@code channels} in order to begin a subsequent loop iteration. If the
* returned {@code Selector} is not open, the method returns. In other
* words, {@code selectorSupplier} is another way to break out of the loop
* implemented by the method. The {@code selectorSupplier} is called on
* while {@code syncRoot} is acquired.
* @param selectionKeyOps the {@link SelectionKey} operation-set bits which
* identify the states of {@code channels} whose changes trigger new loop
* iterations
* @param channels the (set of) {@code SelectableChannel}s on each of which
* {@code predicate} is to be continually tested. A loop iteration is
* triggered when at least one of {@code channels} has a state identified by
* {@code selectionKeyOps} changes.
* @param predicate the {@code Predicate} which is to be continually tested
* on {@code channels}. A loop iteration is triggered when at least one of
* {@code channels} has a state identified by {@code selectionKeyOps}
* changes. {@link BiPredicate#test(Object, Object)} is supplied with an
* element of {@code channels} and its (automatically) associated
* {@code SelectionKey} in the {@code Selector} returned by
* {@code selectorSupplier}. The {@code SelectionKey} is provided in case,
* for example, the implementation of {@code predicate} chooses to associate
* additional state with the {@code SelectableChannel} (through
* {@link SelectionKey#attach(Object)}) available throughout the whole loop.
* @param <T> the element type of {@code channels}
*/
private static <T extends SelectableChannel> void runInSelectorThread(
Object syncRoot,
Supplier<Thread> threadSupplier,
Supplier<Selector> selectorSupplier,
int selectionKeyOps,
Iterable<T> channels,
BiPredicate<T, SelectionKey> predicate)
{
do
{
Selector sel;
boolean select = false;
synchronized (syncRoot)
{
if (!Thread.currentThread().equals(threadSupplier.get()))
break;
sel = selectorSupplier.get();
if (sel == null || !sel.isOpen())
break;
for (Iterator<T> i = channels.iterator(); i.hasNext();)
{
T ch = i.next();
boolean remove = false;
if (ch.isOpen())
{
SelectionKey sk = ch.keyFor(sel);
if (sk == null)
{
// Make sure that all (SelectableChannels in)
// channels are registered with (the Selector) sel.
try
{
ch.register(sel, SelectionKey.OP_ACCEPT);
sk = ch.register(sel, selectionKeyOps);
}
catch (ClosedChannelException cce)
{
// The cce will be handled at the end of the
// loop by removing ch from
// muxingServerSocketChannels.
// loop by removing ch from channels.
}
}
if (sk != null && sk.isValid())
{
remove = predicate.test(ch, sk);
if (remove)
sk.cancel();
}
}
if (ch.isOpen())
select = true;
else
if (remove || !ch.isOpen())
i.remove();
else
select = true;
}
// We've accepted from all muxingServerSocketChannels.
// We've invoked the predicate on all (SelectableChannels in)
// channels.
sel.selectedKeys().clear();
// If there are no muxingServerSocketChannels, we will wait
// If there are no SelectableChannels in channels, we will wait
// until there are.
if (!select)
{
// We're going to wait bellow and continue with the next
// iteration of the loop afterwards. Don't hold onto sel
// while waiting (because it's unnecessary).
sel = null;
try
{
muxingServerSocketChannels.wait();
syncRoot.wait();
}
catch (InterruptedException ie)
{
// I don't know that we care about the interrupted state
// of the current thread because that the method
// runInAcceptThread() is pretty much the whole
// execution of the current thread that could
// potentially care about the interrupted state and it
// doesn't.
// of the current thread because the method
// runInSelectorThread() is (or at least should be)
// pretty much the whole execution of the current thread
// that could potentially care about the interrupted
// state and it doesn't (or at least shouldn't).
}
continue;
}
}
// Wait for a new iteration of acceptance. (The value of the local
// variable select is guaranteed to be true.)
// Wait for a new change in the state(s) of at least one element of
// channels. (The value of the local variable select is guaranteed
// to be true here.)
try
{
sel.select();
@ -753,8 +851,7 @@ class MuxingServerSocketChannel
*
* @param channel the added <tt>MuxServerSocketChannel</tt>
*/
protected void muxServerSocketChannelAdded(
MuxServerSocketChannel channel)
protected void muxServerSocketChannelAdded(MuxServerSocketChannel channel)
{
}
@ -765,136 +862,34 @@ class MuxingServerSocketChannel
*/
protected void runInReadThread()
{
do
{
Selector sel;
boolean select = false;
synchronized (syncRoot)
{
if (!Thread.currentThread().equals(readThread))
break;
sel = this.readSelector;
if (!sel.isOpen())
break;
for (Iterator<SocketChannel> i = readQ.iterator();
i.hasNext();)
runInSelectorThread(
/* syncRoot */ syncRoot,
/* threadSupplier */ new Supplier<Thread>()
{
SocketChannel ch = i.next();
boolean remove = false;
if (ch.isOpen())
@Override
public Thread get()
{
SelectionKey sk = ch.keyFor(sel);
if (sk == null)
{
// Make sure that all SocketChannels in readQ are
// registered with readSelector.
try
{
sk = ch.register(sel, SelectionKey.OP_READ);
}
catch (ClosedChannelException cce)
{
// The cce will be handled at the end of the
// loop by removing ch from readQ.
}
}
if (sk != null && sk.isValid())
{
// Try to read from ch.
DatagramBuffer db
= (DatagramBuffer) sk.attachment();
if (db == null)
{
db
= new DatagramBuffer(
SOCKET_CHANNEL_READ_CAPACITY);
sk.attach(db);
}
int read = maybeRead(ch, db.getByteBuffer());
// Try to filter ch (into a MuxServerSocketChannel).
if (ch.isOpen())
{
// Maintain a record of when the SocketChannel
// last provided readable data in order to weed
// out abandoned ones.
long now = System.currentTimeMillis();
if (read > 0 || db.timestamp == -1)
db.timestamp = now;
DatagramPacket pkt = db.getDatagramPacket();
if (pkt.getLength() > 0
&& filterAccept(pkt, ch))
{
sk.cancel();
remove = true;
}
else if (read <= 0
&& now - db.timestamp
> SOCKET_CHANNEL_READ_TIMEOUT)
{
// The SocketChannel appears to have been
// abandoned by the client.
closeNoExceptions(ch);
}
}
}
return readThread;
}
if (remove || !ch.isOpen())
i.remove();
else
select = true;
}
// We've read from all SocketChannels in readQ.
sel.selectedKeys().clear();
// If there are no SocketChannels in readQ, we will wait until
// there are.
if (!select)
},
/* selectorSupplier */ new Supplier<Selector>()
{
try
@Override
public Selector get()
{
syncRoot.wait();
return readSelector;
}
catch (InterruptedException ie)
},
/* selectionKeyOps */ SelectionKey.OP_READ,
/* channels */ readQ,
/* predicate */ new BiPredicate<SocketChannel, SelectionKey>()
{
@Override
public boolean test(SocketChannel ch, SelectionKey sk)
{
// I don't know that we care about the interrupted state
// of the current thread because that the method
// runInReadThread() is pretty much the whole execution
// of the current thread that could potentially care
// about the interrupted state and it doesn't.
return testRunInReadThreadPredicate(ch, sk);
}
continue;
}
}
// Wait for a new iteration of acceptance. (The value of the local
// variable select is guaranteed to be true.)
try
{
sel.select();
}
catch (ClosedSelectorException cse)
{
break;
}
catch (IOException ioe)
{
// Well, we're selecting from multiple SelectableChannels so
// we're not sure what the IOException signals here.
}
}
while (true);
});
}
/**
@ -951,4 +946,64 @@ class MuxingServerSocketChannel
}
}
}
/**
* Implements {@link BiPredicate#test(Object, Object)} of the
* {@code BiPredicate} utilized by {@link #runInReadThread()}. The method is
* defined explicitly for the purposes of reducing excessive indentation and
* bettering readability. Reads from {@code ch} and attempts to
* classify/filter it into a {@link MuxServerSocketChannel} for acceptance.
* If {@code ch} has not provided readable data within
* {@link #SOCKET_CHANNEL_READ_TIMEOUT}, it is forcibly closed.
*
* @param ch the {@code SocketChannel} to read from and to classify/filter
* into a {@code MuxServerSocketChannel} for acceptance
* @param sk the {@code SelectionKey} associated with {@code ch} in the
* {@code Selector} which awaits changes in the state(s) of {@code ch}
* @return {@code true} if {@code ch} is to no longer be tested; otherwise,
* {@code false}
*/
private boolean testRunInReadThreadPredicate(
SocketChannel ch,
SelectionKey sk)
{
// Try to read from ch.
DatagramBuffer db = (DatagramBuffer) sk.attachment();
if (db == null)
{
db = new DatagramBuffer(SOCKET_CHANNEL_READ_CAPACITY);
sk.attach(db);
}
int read = maybeRead(ch, db.getByteBuffer());
boolean remove = false;
// Try to filter ch (into a MuxServerSocketChannel).
if (ch.isOpen())
{
// Maintain a record of when the SocketChannel last provided
// readable data in order to weed out abandoned ones.
long now = System.currentTimeMillis();
if (read > 0 || db.timestamp == -1)
db.timestamp = now;
DatagramPacket pkt = db.getDatagramPacket();
if (pkt.getLength() > 0 && filterAccept(pkt, ch))
{
remove = true;
}
else if (read <= 0
&& now - db.timestamp > SOCKET_CHANNEL_READ_TIMEOUT)
{
// The SocketChannel appears to have been abandoned by the
// client.
closeNoExceptions(ch);
}
}
return remove;
}
}