c10ccc5dec
Motivation: At the moment it’s possible to have a Channel in Netty that is not registered / assigned to an EventLoop until register(...) is called. This is suboptimal as if the Channel is not registered it is also not possible to do anything useful with a ChannelFuture that belongs to the Channel. We should think about if we should have the EventLoop as a constructor argument of a Channel and have the register / deregister method only have the effect of add a Channel to KQueue/Epoll/... It is also currently possible to deregister a Channel from one EventLoop and register it with another EventLoop. This operation defeats the threading model assumptions that are wide spread in Netty, and requires careful user level coordination to pull off without any concurrency issues. It is not a commonly used feature in practice, may be better handled by other means (e.g. client side load balancing), and therefore we propose removing this feature. Modifications: - Change all Channel implementations to require an EventLoop for construction ( + an EventLoopGroup for all ServerChannel implementations) - Remove all register(...) methods from EventLoopGroup - Add ChannelOutboundInvoker.register(...) which now basically means we want to register on the EventLoop for IO. - Change ChannelUnsafe.register(...) to not take an EventLoop as parameter (as the EventLoop is supplied on custruction). - Change ChannelFactory to take an EventLoop to create new Channels and introduce ServerChannelFactory which takes an EventLoop and one EventLoopGroup to create new ServerChannel instances. - Add ServerChannel.childEventLoopGroup() - Ensure all operations on the accepted Channel is done in the EventLoop of the Channel in ServerBootstrap - Change unit tests for new behaviour Result: A Channel always has an EventLoop assigned which will never change during its life-time. This ensures we are always be able to call any operation on the Channel once constructed (unit the EventLoop is shutdown). This also simplifies the logic in DefaultChannelPipeline a lot as we can always call handlerAdded / handlerRemoved directly without the need to wait for register() to happen. Also note that its still possible to deregister a Channel and register it again. It's just not possible anymore to move from one EventLoop to another (which was not really safe anyway). Fixes https://github.com/netty/netty/issues/8513.
104 lines
3.6 KiB
Java
104 lines
3.6 KiB
Java
/*
|
|
* Copyright 2016 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.kqueue;
|
|
|
|
import io.netty.channel.Channel;
|
|
import io.netty.channel.EventLoop;
|
|
import io.netty.channel.EventLoopGroup;
|
|
import io.netty.channel.unix.DomainSocketAddress;
|
|
import io.netty.channel.unix.ServerDomainSocketChannel;
|
|
import io.netty.util.internal.UnstableApi;
|
|
import io.netty.util.internal.logging.InternalLogger;
|
|
import io.netty.util.internal.logging.InternalLoggerFactory;
|
|
|
|
import java.io.File;
|
|
import java.net.SocketAddress;
|
|
|
|
import static io.netty.channel.kqueue.BsdSocket.newSocketDomain;
|
|
|
|
@UnstableApi
|
|
public final class KQueueServerDomainSocketChannel extends AbstractKQueueServerChannel
|
|
implements ServerDomainSocketChannel {
|
|
private static final InternalLogger logger = InternalLoggerFactory.getInstance(
|
|
KQueueServerDomainSocketChannel.class);
|
|
|
|
private final KQueueServerChannelConfig config = new KQueueServerChannelConfig(this);
|
|
private volatile DomainSocketAddress local;
|
|
|
|
public KQueueServerDomainSocketChannel(EventLoop eventLoop, EventLoopGroup childEventLoopGroup) {
|
|
super(eventLoop, childEventLoopGroup, newSocketDomain(), false);
|
|
}
|
|
|
|
public KQueueServerDomainSocketChannel(EventLoop eventLoop, EventLoopGroup childEventLoopGroup, int fd) {
|
|
this(eventLoop, childEventLoopGroup, new BsdSocket(fd), false);
|
|
}
|
|
|
|
KQueueServerDomainSocketChannel(EventLoop eventLoop, EventLoopGroup childEventLoopGroup,
|
|
BsdSocket socket, boolean active) {
|
|
super(eventLoop, childEventLoopGroup, socket, active);
|
|
}
|
|
|
|
@Override
|
|
protected Channel newChildChannel(int fd, byte[] addr, int offset, int len) throws Exception {
|
|
return new KQueueDomainSocketChannel(this, childEventLoopGroup().next(), new BsdSocket(fd));
|
|
}
|
|
|
|
@Override
|
|
protected DomainSocketAddress localAddress0() {
|
|
return local;
|
|
}
|
|
|
|
@Override
|
|
protected void doBind(SocketAddress localAddress) throws Exception {
|
|
socket.bind(localAddress);
|
|
socket.listen(config.getBacklog());
|
|
local = (DomainSocketAddress) localAddress;
|
|
active = true;
|
|
}
|
|
|
|
@Override
|
|
protected void doClose() throws Exception {
|
|
try {
|
|
super.doClose();
|
|
} finally {
|
|
DomainSocketAddress local = this.local;
|
|
if (local != null) {
|
|
// Delete the socket file if possible.
|
|
File socketFile = new File(local.path());
|
|
boolean success = socketFile.delete();
|
|
if (!success && logger.isDebugEnabled()) {
|
|
logger.debug("Failed to delete a domain socket file: {}", local.path());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public KQueueServerChannelConfig config() {
|
|
return config;
|
|
}
|
|
|
|
@Override
|
|
public DomainSocketAddress remoteAddress() {
|
|
return (DomainSocketAddress) super.remoteAddress();
|
|
}
|
|
|
|
@Override
|
|
public DomainSocketAddress localAddress() {
|
|
return (DomainSocketAddress) super.localAddress();
|
|
}
|
|
}
|