Optimize DefaultChannelPipeline in terms of memory usage and initialization time
Motivation: Each of DefaultChannelPipeline instance creates an head and tail that wraps a handler. These are used to chain together other DefaultChannelHandlerContext that are created once a new ChannelHandler is added. There are a few things here that can be improved in terms of memory usage and initialization time. Modification: - Only generate the name for the tail and head one time as it will never change anyway - Rename DefaultChannelHandlerContext to AbstractChannelHandlerContext and make it abstract - Create a new DefaultChannelHandlerContext that is used when a ChannelHandler is added to the DefaultChannelPipeline - Rename TailHandler to TailContext and HeadHandler to HeadContext and let them extend AbstractChannelHandlerContext. This way we can save 2 object creations per DefaultChannelPipeline Result: - Less memory usage because we have 2 less objects per DefaultChannelPipeline - Faster creation of DefaultChannelPipeline as we not need to generate the name for the head and tail
This commit is contained in:
Norman Maurer
parent
e3c76ec106
commit
8180f7922f
|
|
@ -0,0 +1,379 @@
|
|||
/*
|
||||
* Copyright 2012 The Netty Project
|
||||
*
|
||||
* The Netty Project licenses this file to you 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 io.netty.channel;
|
||||
|
||||
import io.netty.buffer.ByteBufAllocator;
|
||||
import io.netty.util.Attribute;
|
||||
import io.netty.util.AttributeKey;
|
||||
import io.netty.util.ReferenceCountUtil;
|
||||
import io.netty.util.ResourceLeakHint;
|
||||
import io.netty.util.concurrent.EventExecutor;
|
||||
import io.netty.util.internal.StringUtil;
|
||||
|
||||
import java.net.SocketAddress;
|
||||
|
||||
abstract class AbstractChannelHandlerContext implements ChannelHandlerContext, ResourceLeakHint {
|
||||
|
||||
volatile AbstractChannelHandlerContext next;
|
||||
volatile AbstractChannelHandlerContext prev;
|
||||
|
||||
private final boolean inbound;
|
||||
private final boolean outbound;
|
||||
private final AbstractChannel channel;
|
||||
private final DefaultChannelPipeline pipeline;
|
||||
private final String name;
|
||||
private boolean removed;
|
||||
|
||||
final ChannelHandlerInvoker invoker;
|
||||
private ChannelFuture succeededFuture;
|
||||
|
||||
// Lazily instantiated tasks used to trigger events to a handler with different executor.
|
||||
// These needs to be volatile as otherwise an other Thread may see an half initialized instance.
|
||||
// See the JMM for more details
|
||||
volatile Runnable invokeChannelReadCompleteTask;
|
||||
volatile Runnable invokeReadTask;
|
||||
volatile Runnable invokeChannelWritableStateChangedTask;
|
||||
volatile Runnable invokeFlushTask;
|
||||
|
||||
AbstractChannelHandlerContext(
|
||||
DefaultChannelPipeline pipeline, ChannelHandlerInvoker invoker,
|
||||
String name, boolean inbound, boolean outbound) {
|
||||
|
||||
if (name == null) {
|
||||
throw new NullPointerException("name");
|
||||
}
|
||||
|
||||
channel = pipeline.channel;
|
||||
this.pipeline = pipeline;
|
||||
this.name = name;
|
||||
this.invoker = invoker;
|
||||
|
||||
this.inbound = inbound;
|
||||
this.outbound = outbound;
|
||||
}
|
||||
|
||||
/** Invocation initiated by {@link DefaultChannelPipeline#teardownAll()}}. */
|
||||
void teardown() {
|
||||
EventExecutor executor = executor();
|
||||
if (executor.inEventLoop()) {
|
||||
teardown0();
|
||||
} else {
|
||||
executor.execute(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
teardown0();
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
private void teardown0() {
|
||||
AbstractChannelHandlerContext prev = this.prev;
|
||||
if (prev != null) {
|
||||
synchronized (pipeline) {
|
||||
pipeline.remove0(this);
|
||||
}
|
||||
prev.teardown();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public Channel channel() {
|
||||
return channel;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelPipeline pipeline() {
|
||||
return pipeline;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ByteBufAllocator alloc() {
|
||||
return channel().config().getAllocator();
|
||||
}
|
||||
|
||||
@Override
|
||||
public EventExecutor executor() {
|
||||
return invoker().executor();
|
||||
}
|
||||
|
||||
public ChannelHandlerInvoker invoker() {
|
||||
if (invoker == null) {
|
||||
return channel.unsafe().invoker();
|
||||
} else {
|
||||
return invoker;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String name() {
|
||||
return name;
|
||||
}
|
||||
|
||||
@Override
|
||||
public <T> Attribute<T> attr(AttributeKey<T> key) {
|
||||
return channel.attr(key);
|
||||
}
|
||||
|
||||
@Override
|
||||
public <T> boolean hasAttr(AttributeKey<T> key) {
|
||||
return channel.hasAttr(key);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireChannelRegistered() {
|
||||
AbstractChannelHandlerContext next = findContextInbound();
|
||||
next.invoker().invokeChannelRegistered(next);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireChannelUnregistered() {
|
||||
AbstractChannelHandlerContext next = findContextInbound();
|
||||
next.invoker().invokeChannelUnregistered(next);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireChannelActive() {
|
||||
AbstractChannelHandlerContext next = findContextInbound();
|
||||
next.invoker().invokeChannelActive(next);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireChannelInactive() {
|
||||
AbstractChannelHandlerContext next = findContextInbound();
|
||||
next.invoker().invokeChannelInactive(next);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireExceptionCaught(Throwable cause) {
|
||||
AbstractChannelHandlerContext next = this.next;
|
||||
next.invoker().invokeExceptionCaught(next, cause);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireUserEventTriggered(Object event) {
|
||||
AbstractChannelHandlerContext next = findContextInbound();
|
||||
next.invoker().invokeUserEventTriggered(next, event);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireChannelRead(Object msg) {
|
||||
AbstractChannelHandlerContext next = findContextInbound();
|
||||
ReferenceCountUtil.touch(msg, next);
|
||||
next.invoker().invokeChannelRead(next, msg);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireChannelReadComplete() {
|
||||
AbstractChannelHandlerContext next = findContextInbound();
|
||||
next.invoker().invokeChannelReadComplete(next);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireChannelWritabilityChanged() {
|
||||
AbstractChannelHandlerContext next = findContextInbound();
|
||||
next.invoker().invokeChannelWritabilityChanged(next);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture bind(SocketAddress localAddress) {
|
||||
return bind(localAddress, newPromise());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture connect(SocketAddress remoteAddress) {
|
||||
return connect(remoteAddress, newPromise());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress) {
|
||||
return connect(remoteAddress, localAddress, newPromise());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture disconnect() {
|
||||
return disconnect(newPromise());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture close() {
|
||||
return close(newPromise());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture deregister() {
|
||||
return deregister(newPromise());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture bind(final SocketAddress localAddress, final ChannelPromise promise) {
|
||||
AbstractChannelHandlerContext next = findContextOutbound();
|
||||
next.invoker().invokeBind(next, localAddress, promise);
|
||||
return promise;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture connect(SocketAddress remoteAddress, ChannelPromise promise) {
|
||||
return connect(remoteAddress, null, promise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise) {
|
||||
AbstractChannelHandlerContext next = findContextOutbound();
|
||||
next.invoker().invokeConnect(next, remoteAddress, localAddress, promise);
|
||||
return promise;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture disconnect(ChannelPromise promise) {
|
||||
if (!channel().metadata().hasDisconnect()) {
|
||||
return close(promise);
|
||||
}
|
||||
|
||||
AbstractChannelHandlerContext next = findContextOutbound();
|
||||
next.invoker().invokeDisconnect(next, promise);
|
||||
return promise;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture close(ChannelPromise promise) {
|
||||
AbstractChannelHandlerContext next = findContextOutbound();
|
||||
next.invoker().invokeClose(next, promise);
|
||||
return promise;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture deregister(ChannelPromise promise) {
|
||||
AbstractChannelHandlerContext next = findContextOutbound();
|
||||
next.invoker().invokeDeregister(next, promise);
|
||||
return promise;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext read() {
|
||||
AbstractChannelHandlerContext next = findContextOutbound();
|
||||
next.invoker().invokeRead(next);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture write(Object msg) {
|
||||
return write(msg, newPromise());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture write(Object msg, ChannelPromise promise) {
|
||||
AbstractChannelHandlerContext next = findContextOutbound();
|
||||
ReferenceCountUtil.touch(msg, next);
|
||||
next.invoker().invokeWrite(next, msg, promise);
|
||||
return promise;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext flush() {
|
||||
AbstractChannelHandlerContext next = findContextOutbound();
|
||||
next.invoker().invokeFlush(next);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture writeAndFlush(Object msg, ChannelPromise promise) {
|
||||
AbstractChannelHandlerContext next = findContextOutbound();
|
||||
ReferenceCountUtil.touch(msg, next);
|
||||
ChannelHandlerInvoker invoker = next.invoker();
|
||||
invoker.invokeWrite(next, msg, promise);
|
||||
invoker.invokeFlush(next);
|
||||
return promise;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture writeAndFlush(Object msg) {
|
||||
return writeAndFlush(msg, newPromise());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelPromise newPromise() {
|
||||
return new DefaultChannelPromise(channel(), executor());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelProgressivePromise newProgressivePromise() {
|
||||
return new DefaultChannelProgressivePromise(channel(), executor());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture newSucceededFuture() {
|
||||
ChannelFuture succeededFuture = this.succeededFuture;
|
||||
if (succeededFuture == null) {
|
||||
this.succeededFuture = succeededFuture = new SucceededChannelFuture(channel(), executor());
|
||||
}
|
||||
return succeededFuture;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture newFailedFuture(Throwable cause) {
|
||||
return new FailedChannelFuture(channel(), executor(), cause);
|
||||
}
|
||||
|
||||
private AbstractChannelHandlerContext findContextInbound() {
|
||||
AbstractChannelHandlerContext ctx = this;
|
||||
do {
|
||||
ctx = ctx.next;
|
||||
} while (!ctx.inbound);
|
||||
return ctx;
|
||||
}
|
||||
|
||||
private AbstractChannelHandlerContext findContextOutbound() {
|
||||
AbstractChannelHandlerContext ctx = this;
|
||||
do {
|
||||
ctx = ctx.prev;
|
||||
} while (!ctx.outbound);
|
||||
return ctx;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelPromise voidPromise() {
|
||||
return channel.voidPromise();
|
||||
}
|
||||
|
||||
void setRemoved() {
|
||||
removed = true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isRemoved() {
|
||||
return removed;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toHintString() {
|
||||
return '\'' + name + "' will handle the message from this point.";
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return StringUtil.simpleClassName(ChannelHandlerContext.class) + '(' + name + ", " + channel + ')';
|
||||
}
|
||||
}
|
||||
|
|
@ -181,7 +181,7 @@ public class ChannelHandlerAppender extends ChannelInboundHandlerAdapter {
|
|||
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
|
||||
added = true;
|
||||
|
||||
DefaultChannelHandlerContext dctx = (DefaultChannelHandlerContext) ctx;
|
||||
AbstractChannelHandlerContext dctx = (AbstractChannelHandlerContext) ctx;
|
||||
DefaultChannelPipeline pipeline = (DefaultChannelPipeline) dctx.pipeline();
|
||||
String name = dctx.name();
|
||||
try {
|
||||
|
|
|
|||
|
|
@ -1,125 +1,31 @@
|
|||
/*
|
||||
* Copyright 2012 The Netty Project
|
||||
*
|
||||
* The Netty Project licenses this file to you 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.
|
||||
*/
|
||||
* Copyright 2014 The Netty Project
|
||||
*
|
||||
* The Netty Project licenses this file to you 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 io.netty.channel;
|
||||
|
||||
import io.netty.buffer.ByteBufAllocator;
|
||||
import io.netty.util.Attribute;
|
||||
import io.netty.util.AttributeKey;
|
||||
import io.netty.util.ReferenceCountUtil;
|
||||
import io.netty.util.ResourceLeakHint;
|
||||
import io.netty.util.concurrent.EventExecutor;
|
||||
import io.netty.util.internal.StringUtil;
|
||||
final class DefaultChannelHandlerContext extends AbstractChannelHandlerContext {
|
||||
|
||||
import java.net.SocketAddress;
|
||||
|
||||
final class DefaultChannelHandlerContext implements ChannelHandlerContext, ResourceLeakHint {
|
||||
|
||||
volatile DefaultChannelHandlerContext next;
|
||||
volatile DefaultChannelHandlerContext prev;
|
||||
|
||||
private final boolean inbound;
|
||||
private final boolean outbound;
|
||||
private final AbstractChannel channel;
|
||||
private final DefaultChannelPipeline pipeline;
|
||||
private final String name;
|
||||
private final ChannelHandler handler;
|
||||
private boolean removed;
|
||||
|
||||
final ChannelHandlerInvoker invoker;
|
||||
private ChannelFuture succeededFuture;
|
||||
|
||||
// Lazily instantiated tasks used to trigger events to a handler with different executor.
|
||||
// These needs to be volatile as otherwise an other Thread may see an half initialized instance.
|
||||
// See the JMM for more details
|
||||
volatile Runnable invokeChannelReadCompleteTask;
|
||||
volatile Runnable invokeReadTask;
|
||||
volatile Runnable invokeChannelWritableStateChangedTask;
|
||||
volatile Runnable invokeFlushTask;
|
||||
|
||||
DefaultChannelHandlerContext(
|
||||
DefaultChannelPipeline pipeline, ChannelHandlerInvoker invoker, String name, ChannelHandler handler) {
|
||||
|
||||
if (name == null) {
|
||||
throw new NullPointerException("name");
|
||||
}
|
||||
super(pipeline, invoker, name, isInbound(handler), isOutbound(handler));
|
||||
if (handler == null) {
|
||||
throw new NullPointerException("handler");
|
||||
}
|
||||
|
||||
channel = pipeline.channel;
|
||||
this.pipeline = pipeline;
|
||||
this.name = name;
|
||||
this.handler = handler;
|
||||
this.invoker = invoker;
|
||||
|
||||
inbound = handler instanceof ChannelInboundHandler;
|
||||
outbound = handler instanceof ChannelOutboundHandler;
|
||||
}
|
||||
|
||||
/** Invocation initiated by {@link DefaultChannelPipeline#teardownAll()}}. */
|
||||
void teardown() {
|
||||
EventExecutor executor = executor();
|
||||
if (executor.inEventLoop()) {
|
||||
teardown0();
|
||||
} else {
|
||||
executor.execute(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
teardown0();
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
private void teardown0() {
|
||||
DefaultChannelHandlerContext prev = this.prev;
|
||||
if (prev != null) {
|
||||
synchronized (pipeline) {
|
||||
pipeline.remove0(this);
|
||||
}
|
||||
prev.teardown();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public Channel channel() {
|
||||
return channel;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelPipeline pipeline() {
|
||||
return pipeline;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ByteBufAllocator alloc() {
|
||||
return channel().config().getAllocator();
|
||||
}
|
||||
|
||||
@Override
|
||||
public EventExecutor executor() {
|
||||
return invoker().executor();
|
||||
}
|
||||
|
||||
public ChannelHandlerInvoker invoker() {
|
||||
if (invoker == null) {
|
||||
return channel.unsafe().invoker();
|
||||
} else {
|
||||
return invoker;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
@ -127,262 +33,11 @@ final class DefaultChannelHandlerContext implements ChannelHandlerContext, Resou
|
|||
return handler;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String name() {
|
||||
return name;
|
||||
private static boolean isInbound(ChannelHandler handler) {
|
||||
return handler instanceof ChannelInboundHandler;
|
||||
}
|
||||
|
||||
@Override
|
||||
public <T> Attribute<T> attr(AttributeKey<T> key) {
|
||||
return channel.attr(key);
|
||||
}
|
||||
|
||||
@Override
|
||||
public <T> boolean hasAttr(AttributeKey<T> key) {
|
||||
return channel.hasAttr(key);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireChannelRegistered() {
|
||||
DefaultChannelHandlerContext next = findContextInbound();
|
||||
next.invoker().invokeChannelRegistered(next);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireChannelUnregistered() {
|
||||
DefaultChannelHandlerContext next = findContextInbound();
|
||||
next.invoker().invokeChannelUnregistered(next);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireChannelActive() {
|
||||
DefaultChannelHandlerContext next = findContextInbound();
|
||||
next.invoker().invokeChannelActive(next);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireChannelInactive() {
|
||||
DefaultChannelHandlerContext next = findContextInbound();
|
||||
next.invoker().invokeChannelInactive(next);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireExceptionCaught(Throwable cause) {
|
||||
DefaultChannelHandlerContext next = this.next;
|
||||
next.invoker().invokeExceptionCaught(next, cause);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireUserEventTriggered(Object event) {
|
||||
DefaultChannelHandlerContext next = findContextInbound();
|
||||
next.invoker().invokeUserEventTriggered(next, event);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireChannelRead(Object msg) {
|
||||
DefaultChannelHandlerContext next = findContextInbound();
|
||||
ReferenceCountUtil.touch(msg, next);
|
||||
next.invoker().invokeChannelRead(next, msg);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireChannelReadComplete() {
|
||||
DefaultChannelHandlerContext next = findContextInbound();
|
||||
next.invoker().invokeChannelReadComplete(next);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext fireChannelWritabilityChanged() {
|
||||
DefaultChannelHandlerContext next = findContextInbound();
|
||||
next.invoker().invokeChannelWritabilityChanged(next);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture bind(SocketAddress localAddress) {
|
||||
return bind(localAddress, newPromise());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture connect(SocketAddress remoteAddress) {
|
||||
return connect(remoteAddress, newPromise());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress) {
|
||||
return connect(remoteAddress, localAddress, newPromise());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture disconnect() {
|
||||
return disconnect(newPromise());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture close() {
|
||||
return close(newPromise());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture deregister() {
|
||||
return deregister(newPromise());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture bind(final SocketAddress localAddress, final ChannelPromise promise) {
|
||||
DefaultChannelHandlerContext next = findContextOutbound();
|
||||
next.invoker().invokeBind(next, localAddress, promise);
|
||||
return promise;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture connect(SocketAddress remoteAddress, ChannelPromise promise) {
|
||||
return connect(remoteAddress, null, promise);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture connect(SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise) {
|
||||
DefaultChannelHandlerContext next = findContextOutbound();
|
||||
next.invoker().invokeConnect(next, remoteAddress, localAddress, promise);
|
||||
return promise;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture disconnect(ChannelPromise promise) {
|
||||
if (!channel().metadata().hasDisconnect()) {
|
||||
return close(promise);
|
||||
}
|
||||
|
||||
DefaultChannelHandlerContext next = findContextOutbound();
|
||||
next.invoker().invokeDisconnect(next, promise);
|
||||
return promise;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture close(ChannelPromise promise) {
|
||||
DefaultChannelHandlerContext next = findContextOutbound();
|
||||
next.invoker().invokeClose(next, promise);
|
||||
return promise;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture deregister(ChannelPromise promise) {
|
||||
DefaultChannelHandlerContext next = findContextOutbound();
|
||||
next.invoker().invokeDeregister(next, promise);
|
||||
return promise;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext read() {
|
||||
DefaultChannelHandlerContext next = findContextOutbound();
|
||||
next.invoker().invokeRead(next);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture write(Object msg) {
|
||||
return write(msg, newPromise());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture write(Object msg, ChannelPromise promise) {
|
||||
DefaultChannelHandlerContext next = findContextOutbound();
|
||||
ReferenceCountUtil.touch(msg, next);
|
||||
next.invoker().invokeWrite(next, msg, promise);
|
||||
return promise;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandlerContext flush() {
|
||||
DefaultChannelHandlerContext next = findContextOutbound();
|
||||
next.invoker().invokeFlush(next);
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture writeAndFlush(Object msg, ChannelPromise promise) {
|
||||
DefaultChannelHandlerContext next = findContextOutbound();
|
||||
ReferenceCountUtil.touch(msg, next);
|
||||
ChannelHandlerInvoker invoker = next.invoker();
|
||||
invoker.invokeWrite(next, msg, promise);
|
||||
invoker.invokeFlush(next);
|
||||
return promise;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture writeAndFlush(Object msg) {
|
||||
return writeAndFlush(msg, newPromise());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelPromise newPromise() {
|
||||
return new DefaultChannelPromise(channel(), executor());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelProgressivePromise newProgressivePromise() {
|
||||
return new DefaultChannelProgressivePromise(channel(), executor());
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture newSucceededFuture() {
|
||||
ChannelFuture succeededFuture = this.succeededFuture;
|
||||
if (succeededFuture == null) {
|
||||
this.succeededFuture = succeededFuture = new SucceededChannelFuture(channel(), executor());
|
||||
}
|
||||
return succeededFuture;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelFuture newFailedFuture(Throwable cause) {
|
||||
return new FailedChannelFuture(channel(), executor(), cause);
|
||||
}
|
||||
|
||||
private DefaultChannelHandlerContext findContextInbound() {
|
||||
DefaultChannelHandlerContext ctx = this;
|
||||
do {
|
||||
ctx = ctx.next;
|
||||
} while (!ctx.inbound);
|
||||
return ctx;
|
||||
}
|
||||
|
||||
private DefaultChannelHandlerContext findContextOutbound() {
|
||||
DefaultChannelHandlerContext ctx = this;
|
||||
do {
|
||||
ctx = ctx.prev;
|
||||
} while (!ctx.outbound);
|
||||
return ctx;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelPromise voidPromise() {
|
||||
return channel.voidPromise();
|
||||
}
|
||||
|
||||
void setRemoved() {
|
||||
removed = true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isRemoved() {
|
||||
return removed;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toHintString() {
|
||||
return '\'' + name + "' will handle the message from this point.";
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return StringUtil.simpleClassName(ChannelHandlerContext.class) + '(' + name + ", " + channel + ')';
|
||||
private static boolean isOutbound(ChannelHandler handler) {
|
||||
return handler instanceof ChannelOutboundHandler;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -165,7 +165,7 @@ public class DefaultChannelHandlerInvoker implements ChannelHandlerInvoker {
|
|||
if (executor.inEventLoop()) {
|
||||
invokeChannelReadCompleteNow(ctx);
|
||||
} else {
|
||||
DefaultChannelHandlerContext dctx = (DefaultChannelHandlerContext) ctx;
|
||||
AbstractChannelHandlerContext dctx = (AbstractChannelHandlerContext) ctx;
|
||||
Runnable task = dctx.invokeChannelReadCompleteTask;
|
||||
if (task == null) {
|
||||
dctx.invokeChannelReadCompleteTask = task = new Runnable() {
|
||||
|
|
@ -184,7 +184,7 @@ public class DefaultChannelHandlerInvoker implements ChannelHandlerInvoker {
|
|||
if (executor.inEventLoop()) {
|
||||
invokeChannelWritabilityChangedNow(ctx);
|
||||
} else {
|
||||
DefaultChannelHandlerContext dctx = (DefaultChannelHandlerContext) ctx;
|
||||
AbstractChannelHandlerContext dctx = (AbstractChannelHandlerContext) ctx;
|
||||
Runnable task = dctx.invokeChannelWritableStateChangedTask;
|
||||
if (task == null) {
|
||||
dctx.invokeChannelWritableStateChangedTask = task = new Runnable() {
|
||||
|
|
@ -307,7 +307,7 @@ public class DefaultChannelHandlerInvoker implements ChannelHandlerInvoker {
|
|||
if (executor.inEventLoop()) {
|
||||
invokeReadNow(ctx);
|
||||
} else {
|
||||
DefaultChannelHandlerContext dctx = (DefaultChannelHandlerContext) ctx;
|
||||
AbstractChannelHandlerContext dctx = (AbstractChannelHandlerContext) ctx;
|
||||
Runnable task = dctx.invokeReadTask;
|
||||
if (task == null) {
|
||||
dctx.invokeReadTask = task = new Runnable() {
|
||||
|
|
@ -353,7 +353,7 @@ public class DefaultChannelHandlerInvoker implements ChannelHandlerInvoker {
|
|||
if (executor.inEventLoop()) {
|
||||
invokeFlushNow(ctx);
|
||||
} else {
|
||||
DefaultChannelHandlerContext dctx = (DefaultChannelHandlerContext) ctx;
|
||||
AbstractChannelHandlerContext dctx = (AbstractChannelHandlerContext) ctx;
|
||||
Runnable task = dctx.invokeFlushTask;
|
||||
if (task == null) {
|
||||
dctx.invokeFlushTask = task = new Runnable() {
|
||||
|
|
|
|||
|
|
@ -57,11 +57,11 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
|
||||
final AbstractChannel channel;
|
||||
|
||||
final DefaultChannelHandlerContext head;
|
||||
final DefaultChannelHandlerContext tail;
|
||||
final AbstractChannelHandlerContext head;
|
||||
final AbstractChannelHandlerContext tail;
|
||||
|
||||
private final Map<String, DefaultChannelHandlerContext> name2ctx =
|
||||
new HashMap<String, DefaultChannelHandlerContext>(4);
|
||||
private final Map<String, AbstractChannelHandlerContext> name2ctx =
|
||||
new HashMap<String, AbstractChannelHandlerContext>(4);
|
||||
|
||||
/**
|
||||
* @see #findInvoker(EventExecutorGroup)
|
||||
|
|
@ -74,11 +74,8 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
}
|
||||
this.channel = channel;
|
||||
|
||||
TailHandler tailHandler = new TailHandler();
|
||||
tail = new DefaultChannelHandlerContext(this, null, generateName(tailHandler), tailHandler);
|
||||
|
||||
HeadHandler headHandler = new HeadHandler(channel.unsafe());
|
||||
head = new DefaultChannelHandlerContext(this, null, generateName(headHandler), headHandler);
|
||||
tail = new TailContext(this);
|
||||
head = new HeadContext(this);
|
||||
|
||||
head.next = tail;
|
||||
tail.prev = head;
|
||||
|
|
@ -112,10 +109,10 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
return this;
|
||||
}
|
||||
|
||||
private void addFirst0(String name, DefaultChannelHandlerContext newCtx) {
|
||||
private void addFirst0(String name, AbstractChannelHandlerContext newCtx) {
|
||||
checkMultiplicity(newCtx);
|
||||
|
||||
DefaultChannelHandlerContext nextCtx = head.next;
|
||||
AbstractChannelHandlerContext nextCtx = head.next;
|
||||
newCtx.prev = head;
|
||||
newCtx.next = nextCtx;
|
||||
head.next = newCtx;
|
||||
|
|
@ -149,10 +146,10 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
return this;
|
||||
}
|
||||
|
||||
private void addLast0(final String name, DefaultChannelHandlerContext newCtx) {
|
||||
private void addLast0(final String name, AbstractChannelHandlerContext newCtx) {
|
||||
checkMultiplicity(newCtx);
|
||||
|
||||
DefaultChannelHandlerContext prev = tail.prev;
|
||||
AbstractChannelHandlerContext prev = tail.prev;
|
||||
newCtx.prev = prev;
|
||||
newCtx.next = tail;
|
||||
prev.next = newCtx;
|
||||
|
|
@ -171,7 +168,7 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
@Override
|
||||
public ChannelPipeline addBefore(EventExecutorGroup group, String baseName, String name, ChannelHandler handler) {
|
||||
synchronized (this) {
|
||||
DefaultChannelHandlerContext ctx = getContextOrDie(baseName);
|
||||
AbstractChannelHandlerContext ctx = getContextOrDie(baseName);
|
||||
checkDuplicateName(name);
|
||||
addBefore0(name, ctx, new DefaultChannelHandlerContext(this, findInvoker(group), name, handler));
|
||||
}
|
||||
|
|
@ -182,14 +179,15 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
public ChannelPipeline addBefore(
|
||||
ChannelHandlerInvoker invoker, String baseName, final String name, ChannelHandler handler) {
|
||||
synchronized (this) {
|
||||
DefaultChannelHandlerContext ctx = getContextOrDie(baseName);
|
||||
AbstractChannelHandlerContext ctx = getContextOrDie(baseName);
|
||||
checkDuplicateName(name);
|
||||
addBefore0(name, ctx, new DefaultChannelHandlerContext(this, invoker, name, handler));
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
private void addBefore0(final String name, DefaultChannelHandlerContext ctx, DefaultChannelHandlerContext newCtx) {
|
||||
private void addBefore0(
|
||||
final String name, AbstractChannelHandlerContext ctx, AbstractChannelHandlerContext newCtx) {
|
||||
checkMultiplicity(newCtx);
|
||||
|
||||
newCtx.prev = ctx.prev;
|
||||
|
|
@ -210,7 +208,7 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
@Override
|
||||
public ChannelPipeline addAfter(EventExecutorGroup group, String baseName, String name, ChannelHandler handler) {
|
||||
synchronized (this) {
|
||||
DefaultChannelHandlerContext ctx = getContextOrDie(baseName);
|
||||
AbstractChannelHandlerContext ctx = getContextOrDie(baseName);
|
||||
checkDuplicateName(name);
|
||||
addAfter0(name, ctx, new DefaultChannelHandlerContext(this, findInvoker(group), name, handler));
|
||||
}
|
||||
|
|
@ -221,14 +219,14 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
public ChannelPipeline addAfter(
|
||||
ChannelHandlerInvoker invoker, String baseName, final String name, ChannelHandler handler) {
|
||||
synchronized (this) {
|
||||
DefaultChannelHandlerContext ctx = getContextOrDie(baseName);
|
||||
AbstractChannelHandlerContext ctx = getContextOrDie(baseName);
|
||||
checkDuplicateName(name);
|
||||
addAfter0(name, ctx, new DefaultChannelHandlerContext(this, invoker, name, handler));
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
private void addAfter0(final String name, DefaultChannelHandlerContext ctx, DefaultChannelHandlerContext newCtx) {
|
||||
private void addAfter0(final String name, AbstractChannelHandlerContext ctx, AbstractChannelHandlerContext newCtx) {
|
||||
checkDuplicateName(name);
|
||||
checkMultiplicity(newCtx);
|
||||
|
||||
|
|
@ -367,7 +365,7 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
synchronized (cache) {
|
||||
name = cache.get(handlerType);
|
||||
if (name == null) {
|
||||
name = StringUtil.simpleClassName(handlerType) + "#0";
|
||||
name = generateName0(handlerType);
|
||||
cache.put(handlerType, name);
|
||||
}
|
||||
}
|
||||
|
|
@ -390,6 +388,10 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
return name;
|
||||
}
|
||||
|
||||
private static String generateName0(Class<?> handlerType) {
|
||||
return StringUtil.simpleClassName(handlerType) + "#0";
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelPipeline remove(ChannelHandler handler) {
|
||||
remove(getContextOrDie(handler));
|
||||
|
|
@ -407,10 +409,10 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
return (T) remove(getContextOrDie(handlerType)).handler();
|
||||
}
|
||||
|
||||
private DefaultChannelHandlerContext remove(final DefaultChannelHandlerContext ctx) {
|
||||
private AbstractChannelHandlerContext remove(final AbstractChannelHandlerContext ctx) {
|
||||
assert ctx != head && ctx != tail;
|
||||
|
||||
DefaultChannelHandlerContext context;
|
||||
AbstractChannelHandlerContext context;
|
||||
Future<?> future;
|
||||
|
||||
synchronized (this) {
|
||||
|
|
@ -438,9 +440,9 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
return context;
|
||||
}
|
||||
|
||||
void remove0(DefaultChannelHandlerContext ctx) {
|
||||
DefaultChannelHandlerContext prev = ctx.prev;
|
||||
DefaultChannelHandlerContext next = ctx.next;
|
||||
void remove0(AbstractChannelHandlerContext ctx) {
|
||||
AbstractChannelHandlerContext prev = ctx.prev;
|
||||
AbstractChannelHandlerContext next = ctx.next;
|
||||
prev.next = next;
|
||||
next.prev = prev;
|
||||
name2ctx.remove(ctx.name());
|
||||
|
|
@ -482,7 +484,7 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
}
|
||||
|
||||
private ChannelHandler replace(
|
||||
final DefaultChannelHandlerContext ctx, final String newName,
|
||||
final AbstractChannelHandlerContext ctx, final String newName,
|
||||
ChannelHandler newHandler) {
|
||||
|
||||
assert ctx != head && ctx != tail;
|
||||
|
|
@ -494,7 +496,7 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
checkDuplicateName(newName);
|
||||
}
|
||||
|
||||
final DefaultChannelHandlerContext newCtx =
|
||||
final AbstractChannelHandlerContext newCtx =
|
||||
new DefaultChannelHandlerContext(this, ctx.invoker, newName, newHandler);
|
||||
|
||||
if (!newCtx.channel().isRegistered() || newCtx.executor().inEventLoop()) {
|
||||
|
|
@ -520,12 +522,12 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
return ctx.handler();
|
||||
}
|
||||
|
||||
private void replace0(DefaultChannelHandlerContext oldCtx, String newName,
|
||||
DefaultChannelHandlerContext newCtx) {
|
||||
private void replace0(AbstractChannelHandlerContext oldCtx, String newName,
|
||||
AbstractChannelHandlerContext newCtx) {
|
||||
checkMultiplicity(newCtx);
|
||||
|
||||
DefaultChannelHandlerContext prev = oldCtx.prev;
|
||||
DefaultChannelHandlerContext next = oldCtx.next;
|
||||
AbstractChannelHandlerContext prev = oldCtx.prev;
|
||||
AbstractChannelHandlerContext next = oldCtx.next;
|
||||
newCtx.prev = prev;
|
||||
newCtx.next = next;
|
||||
|
||||
|
|
@ -565,7 +567,7 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
}
|
||||
}
|
||||
|
||||
private void callHandlerAdded(final DefaultChannelHandlerContext ctx) {
|
||||
private void callHandlerAdded(final AbstractChannelHandlerContext ctx) {
|
||||
if (ctx.channel().isRegistered() && !ctx.executor().inEventLoop()) {
|
||||
ctx.executor().execute(new Runnable() {
|
||||
@Override
|
||||
|
|
@ -578,7 +580,7 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
callHandlerAdded0(ctx);
|
||||
}
|
||||
|
||||
private void callHandlerAdded0(final DefaultChannelHandlerContext ctx) {
|
||||
private void callHandlerAdded0(final AbstractChannelHandlerContext ctx) {
|
||||
try {
|
||||
ctx.handler().handlerAdded(ctx);
|
||||
} catch (Throwable t) {
|
||||
|
|
@ -604,7 +606,7 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
}
|
||||
}
|
||||
|
||||
private void callHandlerRemoved(final DefaultChannelHandlerContext ctx) {
|
||||
private void callHandlerRemoved(final AbstractChannelHandlerContext ctx) {
|
||||
if (ctx.channel().isRegistered() && !ctx.executor().inEventLoop()) {
|
||||
ctx.executor().execute(new Runnable() {
|
||||
@Override
|
||||
|
|
@ -617,7 +619,7 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
callHandlerRemoved0(ctx);
|
||||
}
|
||||
|
||||
private void callHandlerRemoved0(final DefaultChannelHandlerContext ctx) {
|
||||
private void callHandlerRemoved0(final AbstractChannelHandlerContext ctx) {
|
||||
// Notify the complete removal.
|
||||
try {
|
||||
ctx.handler().handlerRemoved(ctx);
|
||||
|
|
@ -666,7 +668,7 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
|
||||
@Override
|
||||
public ChannelHandlerContext firstContext() {
|
||||
DefaultChannelHandlerContext first = head.next;
|
||||
AbstractChannelHandlerContext first = head.next;
|
||||
if (first == tail) {
|
||||
return null;
|
||||
}
|
||||
|
|
@ -675,7 +677,7 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
|
||||
@Override
|
||||
public ChannelHandler last() {
|
||||
DefaultChannelHandlerContext last = tail.prev;
|
||||
AbstractChannelHandlerContext last = tail.prev;
|
||||
if (last == head) {
|
||||
return null;
|
||||
}
|
||||
|
|
@ -684,7 +686,7 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
|
||||
@Override
|
||||
public ChannelHandlerContext lastContext() {
|
||||
DefaultChannelHandlerContext last = tail.prev;
|
||||
AbstractChannelHandlerContext last = tail.prev;
|
||||
if (last == head) {
|
||||
return null;
|
||||
}
|
||||
|
|
@ -729,7 +731,7 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
throw new NullPointerException("handler");
|
||||
}
|
||||
|
||||
DefaultChannelHandlerContext ctx = head.next;
|
||||
AbstractChannelHandlerContext ctx = head.next;
|
||||
for (;;) {
|
||||
|
||||
if (ctx == null) {
|
||||
|
|
@ -750,7 +752,7 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
throw new NullPointerException("handlerType");
|
||||
}
|
||||
|
||||
DefaultChannelHandlerContext ctx = head.next;
|
||||
AbstractChannelHandlerContext ctx = head.next;
|
||||
for (;;) {
|
||||
if (ctx == null) {
|
||||
return null;
|
||||
|
|
@ -765,7 +767,7 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
@Override
|
||||
public List<String> names() {
|
||||
List<String> list = new ArrayList<String>();
|
||||
DefaultChannelHandlerContext ctx = head.next;
|
||||
AbstractChannelHandlerContext ctx = head.next;
|
||||
for (;;) {
|
||||
if (ctx == null) {
|
||||
return list;
|
||||
|
|
@ -778,7 +780,7 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
@Override
|
||||
public Map<String, ChannelHandler> toMap() {
|
||||
Map<String, ChannelHandler> map = new LinkedHashMap<String, ChannelHandler>();
|
||||
DefaultChannelHandlerContext ctx = head.next;
|
||||
AbstractChannelHandlerContext ctx = head.next;
|
||||
for (;;) {
|
||||
if (ctx == tail) {
|
||||
return map;
|
||||
|
|
@ -801,7 +803,7 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
StringBuilder buf = new StringBuilder();
|
||||
buf.append(StringUtil.simpleClassName(this));
|
||||
buf.append('{');
|
||||
DefaultChannelHandlerContext ctx = head.next;
|
||||
AbstractChannelHandlerContext ctx = head.next;
|
||||
for (;;) {
|
||||
if (ctx == tail) {
|
||||
break;
|
||||
|
|
@ -998,8 +1000,8 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
}
|
||||
}
|
||||
|
||||
private DefaultChannelHandlerContext getContextOrDie(String name) {
|
||||
DefaultChannelHandlerContext ctx = (DefaultChannelHandlerContext) context(name);
|
||||
private AbstractChannelHandlerContext getContextOrDie(String name) {
|
||||
AbstractChannelHandlerContext ctx = (AbstractChannelHandlerContext) context(name);
|
||||
if (ctx == null) {
|
||||
throw new NoSuchElementException(name);
|
||||
} else {
|
||||
|
|
@ -1007,8 +1009,8 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
}
|
||||
}
|
||||
|
||||
private DefaultChannelHandlerContext getContextOrDie(ChannelHandler handler) {
|
||||
DefaultChannelHandlerContext ctx = (DefaultChannelHandlerContext) context(handler);
|
||||
private AbstractChannelHandlerContext getContextOrDie(ChannelHandler handler) {
|
||||
AbstractChannelHandlerContext ctx = (AbstractChannelHandlerContext) context(handler);
|
||||
if (ctx == null) {
|
||||
throw new NoSuchElementException(handler.getClass().getName());
|
||||
} else {
|
||||
|
|
@ -1016,8 +1018,8 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
}
|
||||
}
|
||||
|
||||
private DefaultChannelHandlerContext getContextOrDie(Class<? extends ChannelHandler> handlerType) {
|
||||
DefaultChannelHandlerContext ctx = (DefaultChannelHandlerContext) context(handlerType);
|
||||
private AbstractChannelHandlerContext getContextOrDie(Class<? extends ChannelHandler> handlerType) {
|
||||
AbstractChannelHandlerContext ctx = (AbstractChannelHandlerContext) context(handlerType);
|
||||
if (ctx == null) {
|
||||
throw new NoSuchElementException(handlerType.getName());
|
||||
} else {
|
||||
|
|
@ -1026,7 +1028,18 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
}
|
||||
|
||||
// A special catch-all handler that handles both bytes and messages.
|
||||
static final class TailHandler implements ChannelInboundHandler {
|
||||
static final class TailContext extends AbstractChannelHandlerContext implements ChannelInboundHandler {
|
||||
|
||||
private static final String TAIL_NAME = generateName0(TailContext.class);
|
||||
|
||||
TailContext(DefaultChannelPipeline pipeline) {
|
||||
super(pipeline, null, TAIL_NAME, true, false);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandler handler() {
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void channelRegistered(ChannelHandlerContext ctx) throws Exception { }
|
||||
|
|
@ -1074,12 +1087,31 @@ final class DefaultChannelPipeline implements ChannelPipeline {
|
|||
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception { }
|
||||
}
|
||||
|
||||
static final class HeadHandler extends ChannelOutboundHandlerAdapter {
|
||||
static final class HeadContext extends AbstractChannelHandlerContext implements ChannelOutboundHandler {
|
||||
|
||||
private static final String HEAD_NAME = generateName0(HeadContext.class);
|
||||
|
||||
private final Unsafe unsafe;
|
||||
|
||||
HeadHandler(Unsafe unsafe) {
|
||||
this.unsafe = unsafe;
|
||||
HeadContext(DefaultChannelPipeline pipeline) {
|
||||
super(pipeline, null, HEAD_NAME, false, true);
|
||||
unsafe = pipeline.channel().unsafe();
|
||||
}
|
||||
|
||||
@Override
|
||||
public ChannelHandler handler() {
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void handlerAdded(ChannelHandlerContext ctx) throws Exception { }
|
||||
|
||||
@Override
|
||||
public void handlerRemoved(ChannelHandlerContext ctx) throws Exception { }
|
||||
|
||||
@Override
|
||||
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
|
||||
ctx.fireExceptionCaught(cause);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
|
|
|||
|
|
@ -259,7 +259,7 @@ public class DefaultChannelPipelineTest {
|
|||
pipeline.addBefore("1", "0", newHandler());
|
||||
pipeline.addAfter("10", "11", newHandler());
|
||||
|
||||
DefaultChannelHandlerContext ctx = (DefaultChannelHandlerContext) pipeline.firstContext();
|
||||
AbstractChannelHandlerContext ctx = (AbstractChannelHandlerContext) pipeline.firstContext();
|
||||
assertNotNull(ctx);
|
||||
while (ctx != null) {
|
||||
int i = toInt(ctx.name());
|
||||
|
|
@ -548,8 +548,8 @@ public class DefaultChannelPipelineTest {
|
|||
assertNull(pipeline.last());
|
||||
}
|
||||
|
||||
private static int next(DefaultChannelHandlerContext ctx) {
|
||||
DefaultChannelHandlerContext next = ctx.next;
|
||||
private static int next(AbstractChannelHandlerContext ctx) {
|
||||
AbstractChannelHandlerContext next = ctx.next;
|
||||
if (next == null) {
|
||||
return Integer.MAX_VALUE;
|
||||
}
|
||||
|
|
@ -566,7 +566,7 @@ public class DefaultChannelPipelineTest {
|
|||
}
|
||||
|
||||
private static void verifyContextNumber(ChannelPipeline pipeline, int expectedNumber) {
|
||||
DefaultChannelHandlerContext ctx = (DefaultChannelHandlerContext) pipeline.firstContext();
|
||||
AbstractChannelHandlerContext ctx = (AbstractChannelHandlerContext) pipeline.firstContext();
|
||||
int handlerNumber = 0;
|
||||
while (ctx != ((DefaultChannelPipeline) pipeline).tail) {
|
||||
handlerNumber++;
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user