package io.vertx.core.net.impl.transport;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFactory;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.ServerChannel;
import io.netty.channel.kqueue.*;
import io.netty.channel.socket.DatagramChannel;
import io.netty.channel.socket.InternetProtocolFamily;
import io.netty.channel.unix.DomainSocketAddress;
import io.vertx.core.datagram.DatagramSocketOptions;
import io.vertx.core.net.NetServerOptions;
import io.vertx.core.net.impl.SocketAddressImpl;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.util.concurrent.ThreadFactory;
class KQueueTransport extends Transport {
KQueueTransport() {
}
@Override
public SocketAddress convert(io.vertx.core.net.SocketAddress address, boolean resolved) {
if (address.path() != null) {
return new DomainSocketAddress(address.path());
} else {
if (resolved) {
return new InetSocketAddress(address.host(), address.port());
} else {
return InetSocketAddress.createUnresolved(address.host(), address.port());
}
}
}
@Override
public io.vertx.core.net.SocketAddress convert(SocketAddress address) {
if (address instanceof DomainSocketAddress) {
return new SocketAddressImpl(((DomainSocketAddress) address).path());
}
return super.convert(address);
}
@Override
public boolean isAvailable() {
return KQueue.isAvailable();
}
@Override
public Throwable unavailabilityCause() {
return KQueue.unavailabilityCause();
}
@Override
public EventLoopGroup eventLoopGroup(int type, int nThreads, ThreadFactory threadFactory, int ioRatio) {
KQueueEventLoopGroup eventLoopGroup = new KQueueEventLoopGroup(nThreads, threadFactory);
eventLoopGroup.setIoRatio(ioRatio);
return eventLoopGroup;
}
@Override
public DatagramChannel datagramChannel() {
return new KQueueDatagramChannel();
}
@Override
public DatagramChannel datagramChannel(InternetProtocolFamily family) {
return new KQueueDatagramChannel();
}
@Override
public ChannelFactory<? extends Channel> channelFactory(boolean domainSocket) {
if (domainSocket) {
return KQueueDomainSocketChannel::new;
} else {
return KQueueSocketChannel::new;
}
}
@Override
public ChannelFactory<? extends ServerChannel> serverChannelFactory(boolean domainSocket) {
if (domainSocket) {
return KQueueServerDomainSocketChannel::new;
} else {
return KQueueServerSocketChannel::new;
}
}
@Override
public void configure(NetServerOptions options, boolean domainSocket, ServerBootstrap bootstrap) {
if (!domainSocket) {
bootstrap.option(KQueueChannelOption.SO_REUSEPORT, options.isReusePort());
}
super.configure(options, domainSocket, bootstrap);
}
@Override
public void configure(DatagramChannel channel, DatagramSocketOptions options) {
channel.config().setOption(KQueueChannelOption.SO_REUSEPORT, options.isReusePort());
super.configure(channel, options);
}
}