Splits a file into multiple files (for the purposes of readability).
This commit is contained in:
parent
9fb7d02869
commit
902321c4e1
92
src/main/java/org/ice4j/socket/jdk8/DatagramBuffer.java
Normal file
92
src/main/java/org/ice4j/socket/jdk8/DatagramBuffer.java
Normal file
@ -0,0 +1,92 @@
|
|||||||
|
/*
|
||||||
|
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
|
||||||
|
*
|
||||||
|
* Copyright @ 2015 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.jdk8;
|
||||||
|
|
||||||
|
import java.net.*;
|
||||||
|
import java.nio.*;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Associates a {@link ByteBuffer} with a {@link DatagramPacket} so that the
|
||||||
|
* {@code ByteBuffer} may be used for writing into a {@code byte} array and the
|
||||||
|
* {@code DatagramPacket} may be used for reader from the same {@code byte}
|
||||||
|
* array.
|
||||||
|
*
|
||||||
|
* @author Lyubomir Marinov
|
||||||
|
*/
|
||||||
|
class DatagramBuffer
|
||||||
|
{
|
||||||
|
/**
|
||||||
|
* The {@code ByteBuffer} which is associated with {@link #datagramPacket}
|
||||||
|
* and shares its backing {@code array} with.
|
||||||
|
*/
|
||||||
|
private final ByteBuffer byteBuffer;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The {@code DatagramPacket} which is associated with {@link #byteBuffer}
|
||||||
|
* and shares its {@code data} with.
|
||||||
|
*/
|
||||||
|
private final DatagramPacket datagramPacket;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The latest/last time in milliseconds at which {@code byte}s were written
|
||||||
|
* into this {@code DatagramBuffer}.
|
||||||
|
*/
|
||||||
|
long timestamp = -1;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializes a new {@code DatagramBuffer} instance with a specific
|
||||||
|
* capacity of {@code byte}s shared between a {@code ByteBuffer} and a
|
||||||
|
* {@code DatagramPacket}.
|
||||||
|
*
|
||||||
|
* @param capacity the maximum number of {@code byte}s to be written into
|
||||||
|
* and read from the new instance
|
||||||
|
*/
|
||||||
|
public DatagramBuffer(int capacity)
|
||||||
|
{
|
||||||
|
byteBuffer = ByteBuffer.allocate(capacity);
|
||||||
|
datagramPacket
|
||||||
|
= new DatagramPacket(
|
||||||
|
byteBuffer.array(),
|
||||||
|
/* offset */ 0,
|
||||||
|
/* length */ 0);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the {@code ByteBuffer} (view) of this instance.
|
||||||
|
*
|
||||||
|
* @return the {@code ByteBuffer} (view) of this instance
|
||||||
|
*/
|
||||||
|
public ByteBuffer getByteBuffer()
|
||||||
|
{
|
||||||
|
return byteBuffer;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Gets the {@code DatagramPacket} (view) of this instance. The
|
||||||
|
* {@code length} of the {@code DatagramPacket} equals the {@code position}
|
||||||
|
* of the {@code ByteBuffer} so that the {@code byte}s written into the
|
||||||
|
* {@code ByteBuffer} may be read from the {@code DatagramPacket}.
|
||||||
|
*
|
||||||
|
* @return the {@code DatagramPacket} (view) of this instance
|
||||||
|
*/
|
||||||
|
public DatagramPacket getDatagramPacket()
|
||||||
|
{
|
||||||
|
datagramPacket.setLength(byteBuffer.position());
|
||||||
|
return datagramPacket;
|
||||||
|
}
|
||||||
|
}
|
||||||
54
src/main/java/org/ice4j/socket/jdk8/MuxServerSocket.java
Normal file
54
src/main/java/org/ice4j/socket/jdk8/MuxServerSocket.java
Normal file
@ -0,0 +1,54 @@
|
|||||||
|
/*
|
||||||
|
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
|
||||||
|
*
|
||||||
|
* Copyright @ 2015 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.jdk8;
|
||||||
|
|
||||||
|
import java.io.*;
|
||||||
|
import java.net.*;
|
||||||
|
import org.ice4j.socket.*;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Represents a {@link ServerSocket} associated with a
|
||||||
|
* {@code MuxServerSocketChannel}.
|
||||||
|
*
|
||||||
|
* @author Lyubomir Marinov
|
||||||
|
*/
|
||||||
|
class MuxServerSocket
|
||||||
|
extends DelegatingServerSocket
|
||||||
|
{
|
||||||
|
/**
|
||||||
|
* Initializes a new {@code MuxServerSocket} instance which delegates (its
|
||||||
|
* method calls) to a specific {@code MuxingServerSocket} and is associated
|
||||||
|
* with a specific {@code MuxServerSocketChannel}.
|
||||||
|
*
|
||||||
|
* @param delegate the {@code MuxingServerSocket} the new instance is to
|
||||||
|
* delegate (its method calls) to. Technically, it is the {@code socket} of
|
||||||
|
* the {@code delegate} of {@code channel}.
|
||||||
|
* @param channel the {@code MuxServerSocketChannel} associated with the new
|
||||||
|
* instance
|
||||||
|
* @throws IOException if an I/O error occurs
|
||||||
|
*/
|
||||||
|
public MuxServerSocket(
|
||||||
|
MuxingServerSocket delegate,
|
||||||
|
MuxServerSocketChannel channel)
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
super(
|
||||||
|
MuxServerSocketChannel.assertIsNotNull(delegate, "delegate"),
|
||||||
|
MuxServerSocketChannel.assertIsNotNull(channel, "channel"));
|
||||||
|
}
|
||||||
|
}
|
||||||
File diff suppressed because it is too large
Load Diff
54
src/main/java/org/ice4j/socket/jdk8/MuxingServerSocket.java
Normal file
54
src/main/java/org/ice4j/socket/jdk8/MuxingServerSocket.java
Normal file
@ -0,0 +1,54 @@
|
|||||||
|
/*
|
||||||
|
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
|
||||||
|
*
|
||||||
|
* Copyright @ 2015 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.jdk8;
|
||||||
|
|
||||||
|
import java.io.*;
|
||||||
|
import java.net.*;
|
||||||
|
import org.ice4j.socket.*;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Represents a {@link ServerSocket} associated with a
|
||||||
|
* {@code MuxingServerSocketChannel}.
|
||||||
|
*
|
||||||
|
* @author Lyubomir Marinov
|
||||||
|
*/
|
||||||
|
class MuxingServerSocket
|
||||||
|
extends DelegatingServerSocket
|
||||||
|
{
|
||||||
|
/**
|
||||||
|
* Initializes a new {@code MuxingServerSocket} instance which delegates
|
||||||
|
* (its method calls) to a specific {@code ServerSocket} and is associated
|
||||||
|
* with a specific {@code MuxingServerSocketChannel}.
|
||||||
|
*
|
||||||
|
* @param delegate the {@code ServerSocket} the new instance is to delegate
|
||||||
|
* (its method calls) to. Technically, it is the {@code socket} of the
|
||||||
|
* {@code delegate} of {@code channel}.
|
||||||
|
* @param channel the {@code MuxingServerSocketChannel} associated with the
|
||||||
|
* new instance
|
||||||
|
* @throws IOException if an I/O error occurs
|
||||||
|
*/
|
||||||
|
public MuxingServerSocket(
|
||||||
|
ServerSocket delegate,
|
||||||
|
MuxingServerSocketChannel channel)
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
super(
|
||||||
|
MuxServerSocketChannel.assertIsNotNull(delegate, "delegate"),
|
||||||
|
MuxServerSocketChannel.assertIsNotNull(channel, "channel"));
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,945 @@
|
|||||||
|
/*
|
||||||
|
* ice4j, the OpenSource Java Solution for NAT and Firewall Traversal.
|
||||||
|
*
|
||||||
|
* Copyright @ 2015 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.jdk8;
|
||||||
|
|
||||||
|
import java.io.*;
|
||||||
|
import java.net.*;
|
||||||
|
import java.nio.*;
|
||||||
|
import java.nio.channels.*;
|
||||||
|
import java.util.*;
|
||||||
|
import org.ice4j.ice.harvest.*;
|
||||||
|
import org.ice4j.socket.*;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Shares a listening endpoint (i.e. an open and bound
|
||||||
|
* {@link ServerSocketChannel}) among multiple {@code MuxServerSocketChannel}s.
|
||||||
|
* Accepted {@link SocketChannel}s are demultiplexed based on
|
||||||
|
* {@link DatagramPacketFilter}s and dispatched for acceptance through matching
|
||||||
|
* {@code MuxServerSocketChannel}s.
|
||||||
|
*
|
||||||
|
* @author Lyubomir Marinov
|
||||||
|
*/
|
||||||
|
class MuxingServerSocketChannel
|
||||||
|
extends DelegatingServerSocketChannel<ServerSocketChannel>
|
||||||
|
{
|
||||||
|
/**
|
||||||
|
* Reference to 0.0.0.0 IPv4 or 0::0 IPv6 address for "wildcard" matching
|
||||||
|
* purposes.
|
||||||
|
*/
|
||||||
|
private static final InetAddress ANY_LOCAL_ADDRESS;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The {@code Selector} which waits for incoming network connections on all
|
||||||
|
* {@link #muxingServerSocketChannels}.
|
||||||
|
*/
|
||||||
|
private static Selector acceptSelector;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The {@code Thread} which waits for and accepts incoming network
|
||||||
|
* connections on all {@link #muxingServerSocketChannels}.
|
||||||
|
*/
|
||||||
|
private static Thread acceptThread;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The (global) list of existing <tt>MixingServerSocketChannel</tt>s.
|
||||||
|
*/
|
||||||
|
private static final List<MuxingServerSocketChannel>
|
||||||
|
muxingServerSocketChannels
|
||||||
|
= new LinkedList<MuxingServerSocketChannel>();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The maximum number of milliseconds to wait for an accepted
|
||||||
|
* {@code SocketChannel} to provide incoming/readable data before it is
|
||||||
|
* considered abandoned by the client.
|
||||||
|
*/
|
||||||
|
private static final int SOCKET_CHANNEL_READ_TIMEOUT
|
||||||
|
= MuxServerSocketChannelFactory.SOCKET_CHANNEL_READ_TIMEOUT;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The maximum number of {@code byte}s to be read from
|
||||||
|
* {@link SocketChannel}s accepted by {@link MuxingServerSocketChannel}s in
|
||||||
|
* order to demultiplex (i.e. filter) them into
|
||||||
|
* {@code MuxServerSocketChannel}s.
|
||||||
|
*/
|
||||||
|
private static final int SOCKET_CHANNEL_READ_CAPACITY
|
||||||
|
= Math.max(
|
||||||
|
GoogleTurnSSLCandidateHarvester.SSL_CLIENT_HANDSHAKE.length,
|
||||||
|
Math.max(
|
||||||
|
HttpDemuxFilter.REQUEST_METHOD_MAX_LENGTH + 1 /* SP */,
|
||||||
|
HttpDemuxFilter.TLS_MIN_LENGTH));
|
||||||
|
|
||||||
|
static
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
ANY_LOCAL_ADDRESS = InetAddress.getByName("::");
|
||||||
|
}
|
||||||
|
catch (UnknownHostException e)
|
||||||
|
{
|
||||||
|
throw new RuntimeException(e);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Adds a specific {@code MuxingServerSocketChannel} to the (global) list of
|
||||||
|
* existing {@code MuxingServerSocketChannel}s and schedules acceptance of
|
||||||
|
* incoming network connections on it.
|
||||||
|
*
|
||||||
|
* @param channel the {@code MuxingServerSocketChannel} to add to the
|
||||||
|
* (global) list of existing {@code MuxingServerSocketChannel}s and to
|
||||||
|
* schedule for acceptance of incoming network connections
|
||||||
|
* @throws IOException if an I/O error occurs
|
||||||
|
*/
|
||||||
|
private static void addMuxingServerSocketChannel(
|
||||||
|
MuxingServerSocketChannel channel)
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
synchronized (muxingServerSocketChannels)
|
||||||
|
{
|
||||||
|
muxingServerSocketChannels.add(channel);
|
||||||
|
muxingServerSocketChannels.notifyAll();
|
||||||
|
|
||||||
|
scheduleAccept(channel);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Closes a {@code Channel} and swallows any {@link IOException}.
|
||||||
|
*
|
||||||
|
* @param channel the {@code Channel} to close
|
||||||
|
*/
|
||||||
|
public static void closeNoExceptions(Channel channel)
|
||||||
|
{
|
||||||
|
MuxServerSocketChannelFactory.closeNoExceptions(channel);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Finds the first open {@code MuxingServerSocketChannel} in the (global)
|
||||||
|
* list of existing {@code MuxingServerSocketChannel}s which is bound to a
|
||||||
|
* specific local {@link SocketAddress}.
|
||||||
|
*
|
||||||
|
* @param localAddr the local {@code SocketAddress} on which the bound
|
||||||
|
* {@code MuxingServerSocketChannel} is to be found
|
||||||
|
* @return the first open {@code MuxingServerSocketChannel} in the (global)
|
||||||
|
* list of existing {@code MuxingServerSocketChannel}s which is bound to the
|
||||||
|
* specified {@code localAddr} or {@code null}
|
||||||
|
*/
|
||||||
|
private static MuxingServerSocketChannel findMuxingServerSocketChannel(
|
||||||
|
SocketAddress localAddr)
|
||||||
|
{
|
||||||
|
MuxingServerSocketChannel channel = null;
|
||||||
|
|
||||||
|
synchronized (muxingServerSocketChannels)
|
||||||
|
{
|
||||||
|
Iterator<MuxingServerSocketChannel> i
|
||||||
|
= muxingServerSocketChannels.iterator();
|
||||||
|
|
||||||
|
while (i.hasNext())
|
||||||
|
{
|
||||||
|
MuxingServerSocketChannel aChannel = i.next();
|
||||||
|
|
||||||
|
if (aChannel.isOpen())
|
||||||
|
{
|
||||||
|
SocketAddress aLocalAddr;
|
||||||
|
|
||||||
|
try
|
||||||
|
{
|
||||||
|
aLocalAddr = aChannel.getLocalAddress();
|
||||||
|
}
|
||||||
|
catch (ClosedChannelException cce)
|
||||||
|
{
|
||||||
|
i.remove();
|
||||||
|
aLocalAddr = null;
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{
|
||||||
|
aLocalAddr = null;
|
||||||
|
}
|
||||||
|
|
||||||
|
boolean matches
|
||||||
|
= aLocalAddr != null && aLocalAddr.equals(localAddr);
|
||||||
|
|
||||||
|
// If not the same address, let's see if the cached one is
|
||||||
|
// an "anyLocalAddress" and if so let's consider it a match.
|
||||||
|
if (!matches
|
||||||
|
&& aLocalAddr instanceof InetSocketAddress
|
||||||
|
&& localAddr instanceof InetSocketAddress)
|
||||||
|
{
|
||||||
|
InetSocketAddress aLocalInetAddr
|
||||||
|
= (InetSocketAddress) aLocalAddr;
|
||||||
|
InetSocketAddress localInetAddr
|
||||||
|
= (InetSocketAddress) localAddr;
|
||||||
|
|
||||||
|
matches
|
||||||
|
= aLocalInetAddr.getAddress()
|
||||||
|
.equals(ANY_LOCAL_ADDRESS)
|
||||||
|
&& aLocalInetAddr.getPort()
|
||||||
|
== localInetAddr.getPort();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (matches)
|
||||||
|
{
|
||||||
|
channel = aChannel;
|
||||||
|
// The whole idea of using (1) a List for
|
||||||
|
// muxingServerSocketChannels instead of a Map and (2)
|
||||||
|
// an Iterator to loop over muxingServerSocketChannels
|
||||||
|
// is to aggressively clean up. Anyway, break as soon as
|
||||||
|
// possible in order to improve the execution speed and
|
||||||
|
// because there is an attempt to clean
|
||||||
|
// muxingServerSocketChannels up upon closing.
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
i.remove();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return channel;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* If {@link #acceptSelector} exists and is open, try to close it and do not
|
||||||
|
* throw an <tt>IOException</tt>.
|
||||||
|
*/
|
||||||
|
private static void maybeCloseAcceptSelector()
|
||||||
|
{
|
||||||
|
if (acceptSelector != null)
|
||||||
|
{
|
||||||
|
if (acceptSelector.isOpen())
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
acceptSelector.close();
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
}
|
||||||
|
acceptSelector = null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Opens and binds a new {@code MuxServerSocketChannel} instance. If there
|
||||||
|
* are other (existing) {@code MuxServerSocketChannel} open and bound on the
|
||||||
|
* specified listening {@code endpoint}, the new instance will share it with
|
||||||
|
* them.
|
||||||
|
*
|
||||||
|
* @param properties a {@code Map} of the values to be assigned to
|
||||||
|
* properties of the underlying {@link ServerSocketChannel} which is to
|
||||||
|
* actually listen on the specified {@code endpoint}. If the new instance is
|
||||||
|
* not the first to open and bind the specified {@code endpoint}, the
|
||||||
|
* {@code properties} and their respective values may not be used.
|
||||||
|
* @param endpoint the IP and port the new instance is to bind to
|
||||||
|
* @param backlog the requested maximum number of pending incoming
|
||||||
|
* connections to be queued. If the new instance is not the first to open
|
||||||
|
* and bind the specified {@code endpoint}, the value may not be used.
|
||||||
|
* @param filter the {@code DatagramPacketFilter} to demultiplex (i.e.
|
||||||
|
* recognize) the content meant for the new instance
|
||||||
|
* @return a new {@code MuxServerSocketChannel} instance open and bound on
|
||||||
|
* the specified listening {@code endpoint}
|
||||||
|
* @throws IOException if an I/O error occurs
|
||||||
|
*/
|
||||||
|
public static MuxServerSocketChannel openAndBind(
|
||||||
|
Map<String,Object> properties,
|
||||||
|
SocketAddress endpoint,
|
||||||
|
int backlog,
|
||||||
|
DatagramPacketFilter filter)
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
// The restriction(s) on filter are imposed by MuxingServerSocketChannel
|
||||||
|
// and MuxServerSocketChannel. Assert that they are satisfied as early
|
||||||
|
// as possible though because it does not make sense to bind a
|
||||||
|
// ServerSocketChannel and initialize a new MuxingServerSocketChannel
|
||||||
|
// instance otherwise.
|
||||||
|
MuxServerSocketChannel.assertIsNotNull(filter, "filter");
|
||||||
|
|
||||||
|
MuxingServerSocketChannel muxingChannel;
|
||||||
|
|
||||||
|
synchronized (muxingServerSocketChannels)
|
||||||
|
{
|
||||||
|
muxingChannel = findMuxingServerSocketChannel(endpoint);
|
||||||
|
if (muxingChannel == null)
|
||||||
|
{
|
||||||
|
ServerSocketChannel channel
|
||||||
|
= MuxServerSocketChannelFactory
|
||||||
|
.openAndBindServerSocketChannel(
|
||||||
|
properties,
|
||||||
|
endpoint,
|
||||||
|
backlog);
|
||||||
|
|
||||||
|
muxingChannel = new MuxingServerSocketChannel(channel);
|
||||||
|
addMuxingServerSocketChannel(muxingChannel);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return muxingChannel.createMuxServerSocketChannel(filter);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Runs in {@link #acceptThread} and waits for and accepts incoming network
|
||||||
|
* connections on all {@link #muxingServerSocketChannels}.
|
||||||
|
*/
|
||||||
|
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();)
|
||||||
|
{
|
||||||
|
MuxingServerSocketChannel ch = i.next();
|
||||||
|
|
||||||
|
if (ch.isOpen())
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
ch.accept();
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{
|
||||||
|
// If ioe is a ClosedChannelException signalling
|
||||||
|
// that ch is closed, it will be handled at the end
|
||||||
|
// of the loop by removing ch from
|
||||||
|
// muxingServerSocketChannels.
|
||||||
|
}
|
||||||
|
|
||||||
|
// Make sure all muxingServerSocketChannels are
|
||||||
|
// registered with acceptSelector.
|
||||||
|
if (ch.isOpen() && ch.keyFor(sel) == null)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
ch.register(sel, SelectionKey.OP_ACCEPT);
|
||||||
|
}
|
||||||
|
catch (ClosedChannelException cce)
|
||||||
|
{
|
||||||
|
// The cce will be handled at the end of the
|
||||||
|
// loop by removing ch from
|
||||||
|
// muxingServerSocketChannels.
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (ch.isOpen())
|
||||||
|
select = true;
|
||||||
|
else
|
||||||
|
i.remove();
|
||||||
|
}
|
||||||
|
// We've accepted from all muxingServerSocketChannels.
|
||||||
|
sel.selectedKeys().clear();
|
||||||
|
|
||||||
|
// If there are no muxingServerSocketChannels, we will wait
|
||||||
|
// until there are.
|
||||||
|
if (!select)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
muxingServerSocketChannels.wait();
|
||||||
|
}
|
||||||
|
catch (InterruptedException ie)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Wait for a new iteration of acceptance.
|
||||||
|
if (select)
|
||||||
|
{
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Schedules a specific {@code MuxingServerSocketChannel} for acceptance of
|
||||||
|
* incoming network connections in {@link #acceptThread}.
|
||||||
|
*
|
||||||
|
* @param channel the {@code MuxingServerSocketChannel} to schedule for
|
||||||
|
* acceptance of incoming network connections in {@code acceptThread}
|
||||||
|
* @throws IOException if an I/O error occurs
|
||||||
|
*/
|
||||||
|
private static void scheduleAccept(MuxingServerSocketChannel channel)
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
synchronized (muxingServerSocketChannels)
|
||||||
|
{
|
||||||
|
if (acceptThread == null)
|
||||||
|
{
|
||||||
|
// acceptSelector
|
||||||
|
maybeCloseAcceptSelector();
|
||||||
|
try
|
||||||
|
{
|
||||||
|
acceptSelector = channel.provider().openSelector();
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{
|
||||||
|
acceptSelector = Selector.open();
|
||||||
|
}
|
||||||
|
|
||||||
|
// acceptThread
|
||||||
|
acceptThread
|
||||||
|
= new Thread()
|
||||||
|
{
|
||||||
|
@Override
|
||||||
|
public void run()
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
runInAcceptThread();
|
||||||
|
}
|
||||||
|
finally
|
||||||
|
{
|
||||||
|
synchronized (muxingServerSocketChannels)
|
||||||
|
{
|
||||||
|
if (Thread.currentThread().equals(
|
||||||
|
acceptThread))
|
||||||
|
{
|
||||||
|
// acceptThread
|
||||||
|
acceptThread = null;
|
||||||
|
// acceptSelector
|
||||||
|
maybeCloseAcceptSelector();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
acceptThread.setDaemon(true);
|
||||||
|
acceptThread.setName(
|
||||||
|
MuxingServerSocketChannel.class.getName()
|
||||||
|
+ ".acceptThread");
|
||||||
|
acceptThread.start();
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
// Notify acceptThread that a new MuxingServerSocketChannel
|
||||||
|
// (e.g. channel) may have been added.
|
||||||
|
Selector sel = MuxingServerSocketChannel.acceptSelector;
|
||||||
|
|
||||||
|
if (sel != null)
|
||||||
|
sel.wakeup();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// We might as well expedite the acceptance from
|
||||||
|
// muxingServerSocketChannel i.e. not wait for acceptThread and
|
||||||
|
// explicitly cause an accept iteration.
|
||||||
|
channel.accept();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The list of <tt>MuxServerSocketChannel</tt>s created by and delegating to
|
||||||
|
* this instance.
|
||||||
|
*/
|
||||||
|
private final List<MuxServerSocketChannel> muxServerSocketChannels
|
||||||
|
= new ArrayList<MuxServerSocketChannel>();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The list of {@code SocketChannel}s which have been accepted by this
|
||||||
|
* {@code MuxingServerSocketChannel}, are being read from, and have not been
|
||||||
|
* accepted by the {@link DatagramPacketFilter} of any
|
||||||
|
* {@link MuxServerSocketChannel} yet.
|
||||||
|
*/
|
||||||
|
private final Queue<SocketChannel> readQ = new LinkedList<SocketChannel>();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The {@code Selector} which waits for incoming packets on all
|
||||||
|
* {@code SocketChannel}s in {@link #readQ}.
|
||||||
|
*/
|
||||||
|
private final Selector readSelector;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The {@code Thread} which waits for incoming packets on and reads them
|
||||||
|
* from all {@code SocketChannel}s in {@link #readQ}.
|
||||||
|
*/
|
||||||
|
private Thread readThread;
|
||||||
|
|
||||||
|
/**
|
||||||
|
* The <tt>Object</tt> which synchronizes the access to the state of this
|
||||||
|
* <tt>MuxingServerSocketChannel</tt> such as
|
||||||
|
* {@link #muxServerSocketChannels} and {@link #readQ}.
|
||||||
|
*/
|
||||||
|
private final Object syncRoot = new Object();
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializes a new {@code MuxingServerSocketChannel} instance which is to
|
||||||
|
* share the listening endpoint of a specific {@link ServerSocketChannel}
|
||||||
|
* among multiple {@code MuxServerSocketChannel}s.
|
||||||
|
*
|
||||||
|
* @param delegate the {@code ServerSocketChannel} for which the new
|
||||||
|
* instance is to provide listening endpoint sharing
|
||||||
|
* @throws IOException if an I/O error occurs
|
||||||
|
*/
|
||||||
|
public MuxingServerSocketChannel(ServerSocketChannel delegate)
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
super(MuxServerSocketChannel.assertIsNotNull(delegate, "delegate"));
|
||||||
|
|
||||||
|
// If at least one MuxServerSocketChannel is configured as non-blocking,
|
||||||
|
// then MuxingServerSocketChannel (i.e. delegate) has to be configured
|
||||||
|
// as non-blocking as well.
|
||||||
|
configureBlocking(false);
|
||||||
|
|
||||||
|
readSelector = provider().openSelector();
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Adds a specific {@code MuxServerSocketChannel} to the list of
|
||||||
|
* {@code MuxServerSocketChannel}s created by and delegating to this
|
||||||
|
* instance.
|
||||||
|
*
|
||||||
|
* @param channel the {@code MuxServerSocketChannel} to add
|
||||||
|
*/
|
||||||
|
protected void addMuxServerSocketChannel(MuxServerSocketChannel channel)
|
||||||
|
{
|
||||||
|
synchronized (syncRoot)
|
||||||
|
{
|
||||||
|
muxServerSocketChannels.add(channel);
|
||||||
|
syncRoot.notifyAll();
|
||||||
|
|
||||||
|
// Wake readThread up in case a SocketChannel from readQ is accepted
|
||||||
|
// by the filter of the newly-added MuxServerSocketChannel.
|
||||||
|
scheduleRead(/* channel */ null);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Initializes a new {@code MuxServerSocketChannel} instance which is to
|
||||||
|
* delegate to this instance and is to demultiplex incoming network
|
||||||
|
* connections and packets using a specific {@link DatagramPacketFilter}.
|
||||||
|
*
|
||||||
|
* @param filter the {@code DatagramPacketFilter} to be used by the new
|
||||||
|
* {@code MuxServerSocketChannel} instance to demultiplex incoming network
|
||||||
|
* connections and packets
|
||||||
|
* @return a new {@code MuxServerSocketChannel} instance which delegates to
|
||||||
|
* this instance and demultiplexes incoming network connections and packets
|
||||||
|
* using the specified {@code filter}
|
||||||
|
*/
|
||||||
|
protected MuxServerSocketChannel createMuxServerSocketChannel(
|
||||||
|
DatagramPacketFilter filter)
|
||||||
|
{
|
||||||
|
// A MuxServerSocketChannel with no filter does not make sense. It
|
||||||
|
// cannot be a fallback because DatagramPacketFilters (i.e.
|
||||||
|
// MuxServerSocketChannels) have no priorities. It cannot be a catch all
|
||||||
|
// because a SocketChannel (i.e. Socket) may be accepted by a single
|
||||||
|
// MuxServerSocketChannel only.
|
||||||
|
MuxServerSocketChannel.assertIsNotNull(filter, "filter");
|
||||||
|
|
||||||
|
MuxServerSocketChannel channel;
|
||||||
|
|
||||||
|
synchronized (syncRoot)
|
||||||
|
{
|
||||||
|
Iterator<MuxServerSocketChannel> i
|
||||||
|
= muxServerSocketChannels.iterator();
|
||||||
|
|
||||||
|
while (i.hasNext())
|
||||||
|
{
|
||||||
|
MuxServerSocketChannel aChannel = i.next();
|
||||||
|
|
||||||
|
if (aChannel.isOpen())
|
||||||
|
{
|
||||||
|
DatagramPacketFilter aFilter = aChannel.filter;
|
||||||
|
|
||||||
|
// The implementations of Object#equals(Object) should be
|
||||||
|
// symmetric but they are written by humans so there is room
|
||||||
|
// for errors.
|
||||||
|
if (filter.equals(aFilter) || aFilter.equals(filter))
|
||||||
|
{
|
||||||
|
// A SocketChannel (i.e. Socket) may be accepted by a
|
||||||
|
// single MuxServerSocketChannel only.
|
||||||
|
throw new IllegalArgumentException("filter");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
i.remove();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
channel = new MuxServerSocketChannel(this, filter);
|
||||||
|
addMuxServerSocketChannel(channel);
|
||||||
|
}
|
||||||
|
|
||||||
|
muxServerSocketChannelAdded(channel);
|
||||||
|
|
||||||
|
return channel;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Determines whether any of the {@code MuxServerSocketChannel}s created by
|
||||||
|
* and delegating to this instance demultiplexes (i.e. recognizes) a
|
||||||
|
* specific {@link SocketChannel} based on a specific {@link DatagramPacket}
|
||||||
|
* read from it and will make it available for acceptance.
|
||||||
|
*
|
||||||
|
* @param p the {@code DatagramPacket} read from {@code channel} which is to
|
||||||
|
* be analyzed by the {@code MuxServerSocketChannel}s created by and
|
||||||
|
* delegating to this instance
|
||||||
|
* @param channel the {@code SocketChannel} from which {@code p} was read
|
||||||
|
* and which is to possibly be demultiplexed into a
|
||||||
|
* {@code MuxServerSocketChannel}
|
||||||
|
* @return {@code true} if one of the {@code MuxServerSocketChannel}s
|
||||||
|
* created by and delegating to this instance demultiplexed the specified
|
||||||
|
* {@code channel}; otherwise, {@code false}
|
||||||
|
*/
|
||||||
|
private boolean filterAccept(DatagramPacket p, SocketChannel channel)
|
||||||
|
{
|
||||||
|
boolean b = false;
|
||||||
|
|
||||||
|
for (Iterator<MuxServerSocketChannel> i
|
||||||
|
= muxServerSocketChannels.iterator();
|
||||||
|
i.hasNext();)
|
||||||
|
{
|
||||||
|
MuxServerSocketChannel muxChannel = i.next();
|
||||||
|
|
||||||
|
if (muxChannel.isOpen())
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
b = muxChannel.filterAccept(p, channel);
|
||||||
|
if (b)
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
catch (Throwable t)
|
||||||
|
{
|
||||||
|
// The implementation of DatagramPacketFilter is external to
|
||||||
|
// MuxingServerSocketChannel and we do not want the failure
|
||||||
|
// of one DatagramPacketFilter to kill the whole
|
||||||
|
// MuxingServerSocketChannel.
|
||||||
|
if (t instanceof InterruptedException)
|
||||||
|
Thread.currentThread().interrupt();
|
||||||
|
else if (t instanceof ThreadDeath)
|
||||||
|
throw (ThreadDeath) t;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
i.remove();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
return b;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* {@inheritDoc}
|
||||||
|
*
|
||||||
|
* Queues a {@link SocketChannel} accepted by this instance for reading so
|
||||||
|
* that it may later on be demultiplexed into a
|
||||||
|
* {@code MuxServerSocketChannel}.
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
protected SocketChannel implAccept(SocketChannel accepted)
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
synchronized (syncRoot)
|
||||||
|
{
|
||||||
|
if (accepted != null && accepted.isOpen())
|
||||||
|
{
|
||||||
|
accepted.configureBlocking(false);
|
||||||
|
|
||||||
|
readQ.add(accepted);
|
||||||
|
syncRoot.notifyAll();
|
||||||
|
|
||||||
|
scheduleRead(accepted);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return accepted;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* {@inheritDoc}
|
||||||
|
*
|
||||||
|
* Associates a {@link MuxingServerSocket} with this
|
||||||
|
* {@code MuxingServerSocketChannel}.
|
||||||
|
*/
|
||||||
|
@Override
|
||||||
|
protected MuxingServerSocket implSocket(ServerSocket socket)
|
||||||
|
throws IOException
|
||||||
|
{
|
||||||
|
return new MuxingServerSocket(socket, this);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Attempts to read from a specific {@link SocketChannel} into a specific
|
||||||
|
* {@link ByteBuffer} without throwing an {@link IOException} if the reading
|
||||||
|
* from the {@code channel} fails or there is insufficient room in
|
||||||
|
* {@code buf} to write into.
|
||||||
|
*
|
||||||
|
* @param channel the {@code SocketChannel} to read from
|
||||||
|
* @param buf the {@code ByteBuffer} to write into
|
||||||
|
* @return the number of {@code byte}s read from {@code channel} and written
|
||||||
|
* into {@code buf} or {@code -1} if {@code channel} has reached the end of
|
||||||
|
* its stream
|
||||||
|
*/
|
||||||
|
protected int maybeRead(SocketChannel channel, ByteBuffer buf)
|
||||||
|
{
|
||||||
|
int read;
|
||||||
|
|
||||||
|
if (buf.remaining() > 0)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
read = channel.read(buf);
|
||||||
|
}
|
||||||
|
catch (IOException ioe)
|
||||||
|
{
|
||||||
|
// If ioe is a ClosedChannelException signalling that the
|
||||||
|
// specified channel is closed, it will be handled by the method
|
||||||
|
// caller (by removing channel from readQ).
|
||||||
|
read = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
read = 0;
|
||||||
|
}
|
||||||
|
return read;
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Notifies this <tt>MixingServerSocketChannel</tt> that a specific
|
||||||
|
* <tt>MuxServerSocketChannel</tt> was added to
|
||||||
|
* {@link #muxServerSocketChannels}.
|
||||||
|
*
|
||||||
|
* @param channel the added <tt>MuxServerSocketChannel</tt>
|
||||||
|
*/
|
||||||
|
protected void muxServerSocketChannelAdded(
|
||||||
|
MuxServerSocketChannel channel)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Runs in {@link #readThread} and reads from all {@link SocketChannel}s in
|
||||||
|
* {@link #readQ} and serves them for demultiplexing to
|
||||||
|
* {@link #muxServerSocketChannels}.
|
||||||
|
*/
|
||||||
|
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();)
|
||||||
|
{
|
||||||
|
SocketChannel ch = i.next();
|
||||||
|
boolean remove = false;
|
||||||
|
|
||||||
|
if (ch.isOpen())
|
||||||
|
{
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
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)
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
syncRoot.wait();
|
||||||
|
}
|
||||||
|
catch (InterruptedException ie)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Wait for a new iteration of acceptance.
|
||||||
|
if (select)
|
||||||
|
{
|
||||||
|
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);
|
||||||
|
}
|
||||||
|
|
||||||
|
/**
|
||||||
|
* Queues a specific {@link SocketChannel} to be read and demultiplexed into
|
||||||
|
* a {@code MuxServerSocketChannel}.
|
||||||
|
*
|
||||||
|
* @param channel the {@code SocketChannel} to queue for reading and
|
||||||
|
* demultiplexing
|
||||||
|
*/
|
||||||
|
protected void scheduleRead(SocketChannel channel)
|
||||||
|
{
|
||||||
|
synchronized (syncRoot)
|
||||||
|
{
|
||||||
|
if (readThread == null)
|
||||||
|
{
|
||||||
|
// readThread
|
||||||
|
readThread
|
||||||
|
= new Thread()
|
||||||
|
{
|
||||||
|
@Override
|
||||||
|
public void run()
|
||||||
|
{
|
||||||
|
try
|
||||||
|
{
|
||||||
|
runInReadThread();
|
||||||
|
}
|
||||||
|
finally
|
||||||
|
{
|
||||||
|
synchronized (syncRoot)
|
||||||
|
{
|
||||||
|
if (Thread.currentThread().equals(
|
||||||
|
readThread))
|
||||||
|
{
|
||||||
|
readThread = null;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
readThread.setDaemon(true);
|
||||||
|
readThread.setName(
|
||||||
|
MuxingServerSocketChannel.class.getName()
|
||||||
|
+ ".readThread");
|
||||||
|
readThread.start();
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
// Notify readThread that a new SocketChannel (e.g. channel) may
|
||||||
|
// have been added.
|
||||||
|
Selector sel = this.readSelector;
|
||||||
|
|
||||||
|
if (sel != null)
|
||||||
|
sel.wakeup();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
x
Reference in New Issue
Block a user