private void bind(OioDatagramChannel channel, ChannelFuture future, SocketAddress localAddress) {
boolean bound = false;
boolean workerStarted = false;
try {
channel.socket.bind(localAddress);
bound = true;
// Fire events
future.setSuccess();
fireChannelBound(channel, channel.getLocalAddress());
// Start the business.
workerExecutor.execute(
new IoWorkerRunnable(
new ThreadRenamingRunnable(
new OioDatagramWorker(channel),
"Old I/O datagram worker (channelId: "
+ channel.getId()
+ ", "
+ channel.getLocalAddress()
+ ')')));
workerStarted = true;
} catch (Throwable t) {
future.setFailure(t);
fireExceptionCaught(channel, t);
} finally {
if (bound && !workerStarted) {
OioDatagramWorker.close(channel, future);
}
}
}
/**
* Will bind the DatagramSocket to the passed-in address. Every call bind will spawn a new thread
* using the that basically in turn
*/
private void bind(
final NioDatagramChannel channel,
final ChannelFuture future,
final InetSocketAddress address) {
boolean bound = false;
boolean started = false;
try {
// First bind the DatagramSocket the specified port.
channel.getDatagramChannel().socket().bind(address);
bound = true;
future.setSuccess();
fireChannelBound(channel, address);
channel.worker.register(channel, null);
started = true;
} catch (final Throwable t) {
future.setFailure(t);
fireExceptionCaught(channel, t);
} finally {
if (!started && bound) {
close(channel, future);
}
}
}
@Override
@SuppressWarnings("unchecked")
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
S serverChannel = (S) ctx.getAttachment();
T childChannel = createChildChannel(serverChannel, e.getChannel());
fireChannelOpen(childChannel);
ChannelAddress localAddress = serverChannel.getLocalAddress();
childChannel.setLocalAddress(localAddress);
childChannel.setBound();
fireChannelBound(childChannel, localAddress);
ctx.setAttachment(childChannel);
ctx.sendUpstream(e);
// TODO: fire CONNECTED_BARRIER event to next pipeline
// then fire CONNECTED event when future completes successfully
ChannelAddress remoteAddress = localAddress.newEphemeralAddress();
childChannel.setRemoteAddress(remoteAddress);
childChannel.setConnected();
fireChannelConnected(childChannel, remoteAddress);
}
private void connect(
OioDatagramChannel channel, ChannelFuture future, SocketAddress remoteAddress) {
boolean bound = channel.isBound();
boolean connected = false;
boolean workerStarted = false;
future.addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
// Clear the cached address so that the next getRemoteAddress() call
// updates the cache.
channel.remoteAddress = null;
try {
channel.socket.connect(remoteAddress);
connected = true;
// Fire events.
future.setSuccess();
if (!bound) {
fireChannelBound(channel, channel.getLocalAddress());
}
fireChannelConnected(channel, channel.getRemoteAddress());
String threadName =
"Old I/O datagram worker (channelId: "
+ channel.getId()
+ ", "
+ channel.getLocalAddress()
+ " => "
+ channel.getRemoteAddress()
+ ')';
if (!bound) {
// Start the business.
workerExecutor.execute(
new IoWorkerRunnable(
new ThreadRenamingRunnable(new OioDatagramWorker(channel), threadName)));
} else {
// Worker started by bind() - just rename.
Thread workerThread = channel.workerThread;
if (workerThread != null) {
try {
workerThread.setName(threadName);
} catch (SecurityException e) {
// Ignore.
}
}
}
workerStarted = true;
} catch (Throwable t) {
future.setFailure(t);
fireExceptionCaught(channel, t);
} finally {
if (connected && !workerStarted) {
OioDatagramWorker.close(channel, future);
}
}
}
@Test
public void testChannelBoundEventFromReal_replicatedOnVirtual() {
upstreamEvents.events.clear();
InetSocketAddress boundAddr = InetSocketAddress.createUnresolved("mycomputer", 12345);
Channels.fireChannelBound(realChannelFactory.createdChannel, boundAddr);
assertEquals(1, upstreamEvents.events.size());
checkIsUpstreamChannelStateEvent(
upstreamEvents.events.poll(), virtualChannel, ChannelState.BOUND, boundAddr);
}
public void run() {
SocketAddress localAddress = channel.getLocalAddress();
SocketAddress remoteAddress = channel.getRemoteAddress();
if (localAddress == null || remoteAddress == null) {
if (future != null) {
future.setFailure(new ClosedChannelException());
}
close(channel, succeededFuture(channel));
return;
}
try {
if (server) {
channel.channel.configureBlocking(false);
}
synchronized (channel.interestOpsLock) {
channel.channel.register(selector, channel.getRawInterestOps(), channel);
}
if (future != null) {
channel.setConnected();
future.setSuccess();
}
if (server || !((NioClientSocketChannel) channel).boundManually) {
fireChannelBound(channel, localAddress);
}
fireChannelConnected(channel, remoteAddress);
} catch (IOException e) {
if (future != null) {
future.setFailure(e);
}
close(channel, succeededFuture(channel));
if (!(e instanceof ClosedChannelException)) {
throw new ChannelException("Failed to register a socket to the selector.", e);
}
}
}
private void connect(
NioDatagramChannel channel, ChannelFuture future, SocketAddress remoteAddress) {
boolean bound = channel.isBound();
boolean connected = false;
boolean workerStarted = false;
future.addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
// Clear the cached address so that the next getRemoteAddress() call
// updates the cache.
channel.remoteAddress = null;
try {
channel.getDatagramChannel().connect(remoteAddress);
connected = true;
// Fire events.
future.setSuccess();
if (!bound) {
fireChannelBound(channel, channel.getLocalAddress());
}
fireChannelConnected(channel, channel.getRemoteAddress());
if (!bound) {
channel.worker.register(channel, future);
}
workerStarted = true;
} catch (Throwable t) {
future.setFailure(t);
fireExceptionCaught(channel, t);
} finally {
if (connected && !workerStarted) {
channel.worker.close(channel, future);
}
}
}
private void fireInitialEvents() {
// Fire the typical initial events.
fireChannelOpen(channel);
fireChannelBound(channel, channel.getLocalAddress());
fireChannelConnected(channel, channel.getRemoteAddress());
}
@Override
protected void httpMessageReceived(
ChannelHandlerContext ctx, MessageEvent e, HttpRequest httpRequest) throws Exception {
HttpVersion version = httpRequest.getProtocolVersion();
URI httpLocation = getEffectiveURI(httpRequest);
if (httpLocation == null) {
// see RFC-7230 section 5.4 Host
HttpResponse httpResponse = new DefaultHttpResponse(version, BAD_REQUEST);
ChannelFuture future = future(ctx.getChannel());
write(ctx, future, httpResponse);
return;
}
// channel's local address is resolved address so get the bind address from
// server channel's attachment
ChannelAddress transportCandidate =
(ChannelAddress) ctx.getChannel().getParent().getAttachment();
ChannelAddress candidate = new ChannelAddress(httpLocation, transportCandidate);
Entry<ChannelAddress, HttpServerChannel> httpBinding = httpBindings.floorEntry(candidate);
if (httpBinding == null) {
HttpResponse httpResponse = new DefaultHttpResponse(version, NOT_FOUND);
ChannelFuture future = future(ctx.getChannel());
write(ctx, future, httpResponse);
return;
}
HttpServerChannel parent = httpBinding.getValue();
ChannelFactory factory = parent.getFactory();
ChannelConfig config = parent.getConfig();
ChannelPipelineFactory pipelineFactory = config.getPipelineFactory();
ChannelPipeline pipeline = pipelineFactory.getPipeline();
ChannelAddress httpLocalAddress = parent.getLocalAddress();
Channel transport = ctx.getChannel();
ChannelAddress remoteAddress = remoteAddress(transport);
ChannelAddress httpRemoteAddress = new ChannelAddress(httpLocation, remoteAddress, true);
HttpChildChannelSink sink = new HttpChildChannelSink(transport);
HttpChildChannel httpChildChannel = new HttpChildChannel(parent, factory, pipeline, sink);
HttpChannelConfig httpChildConfig = httpChildChannel.getConfig();
httpChildConfig.setMethod(httpRequest.getMethod());
httpChildConfig.setVersion(version);
httpChildConfig.getReadHeaders().set(httpRequest.headers());
httpChildConfig.setReadQuery(new QueryStringDecoder(httpRequest.getUri()));
httpChildConfig.setWriteQuery(new QueryStringEncoder(httpRequest.getUri()));
httpChildConfig.setStatus(HttpResponseStatus.OK);
this.httpChildChannel = httpChildChannel;
ChannelBuffer content = httpRequest.getContent();
// update read state before firing channel events
if (isTransferEncodingChunked(httpRequest)) {
httpChildChannel.readState(HttpReadState.CONTENT_CHUNKED);
} else if (isContentLengthSet(httpRequest)) {
long contentLength = getContentLength(httpRequest);
contentLength -= content.readableBytes();
if (contentLength > 0) {
httpChildChannel.readState(HttpReadState.CONTENT_CHUNKED);
} else {
httpChildChannel.readState(HttpReadState.CONTENT_COMPLETE);
}
} else {
// see RFC-7230 section 3.3
// content indicated by presence of Content-Length or Transfer-Encoding
httpChildChannel.readState(HttpReadState.CONTENT_COMPLETE);
}
fireChannelOpen(httpChildChannel);
httpChildChannel.setLocalAddress(httpLocalAddress);
httpChildChannel.setBound();
fireChannelBound(httpChildChannel, httpLocalAddress);
httpChildChannel.setRemoteAddress(httpRemoteAddress);
httpChildChannel.setConnected();
fireChannelConnected(httpChildChannel, httpRemoteAddress);
if (content.readable()) {
fireMessageReceived(httpChildChannel, content);
}
// note: status may be set in reaction to one of the above events, such as CONNECTED
// so defer status code check until this point
if (httpChildConfig.getStatus().getCode() == SWITCHING_PROTOCOLS.getCode()) {
httpChildChannel.readState(HttpReadState.UPGRADED);
}
switch (httpChildChannel.readState()) {
case CONTENT_COMPLETE:
fireInputShutdown(httpChildChannel);
this.httpChildChannel = null;
if (httpChildChannel.setReadClosed()) {
fireChannelDisconnected(httpChildChannel);
fireChannelUnbound(httpChildChannel);
fireChannelClosed(httpChildChannel);
}
break;
default:
break;
}
}