下面列出了io.netty.channel.kqueue.KQueue#isAvailable ( ) 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
public NettyDomainSocketClient(ClientConfig config) {
super(config);
URI uri = config.baseUri();
Require.argument("URI scheme", uri.getScheme()).equalTo("unix");
if (Epoll.isAvailable()) {
this.eventLoopGroup = new EpollEventLoopGroup();
this.channelClazz = EpollDomainSocketChannel.class;
} else if (KQueue.isAvailable()) {
this.eventLoopGroup = new KQueueEventLoopGroup();
this.channelClazz = KQueueDomainSocketChannel.class;
} else {
throw new IllegalStateException("No native library for unix domain sockets is available");
}
this.path = uri.getPath();
}
private static NettyChannelBuilder newNettyChannelBuilder(String targetUrl, String proxy)
throws IOException {
if (Strings.isNullOrEmpty(proxy)) {
return NettyChannelBuilder.forTarget(targetUrl).defaultLoadBalancingPolicy("round_robin");
}
if (!proxy.startsWith("unix:")) {
throw new IOException("Remote proxy unsupported: " + proxy);
}
DomainSocketAddress address = new DomainSocketAddress(proxy.replaceFirst("^unix:", ""));
NettyChannelBuilder builder =
NettyChannelBuilder.forAddress(address).overrideAuthority(targetUrl);
if (KQueue.isAvailable()) {
return builder
.channelType(KQueueDomainSocketChannel.class)
.eventLoopGroup(new KQueueEventLoopGroup());
}
if (Epoll.isAvailable()) {
return builder
.channelType(EpollDomainSocketChannel.class)
.eventLoopGroup(new EpollEventLoopGroup());
}
throw new IOException("Unix domain sockets are unsupported on this platform");
}
private void setChannelInfo() {
if (Epoll.isAvailable()) {
this.group = new EpollEventLoopGroup();
this.channelType = EpollDomainSocketChannel.class;
LOGGER.info("Using epoll for Netty transport.");
} else {
if (!KQueue.isAvailable()) {
throw new RuntimeException("Unsupported OS '" + System.getProperty("os.name") + "', only Unix and Mac are supported");
}
this.group = new KQueueEventLoopGroup();
this.channelType = KQueueDomainSocketChannel.class;
LOGGER.info("Using KQueue for Netty transport.");
}
}
public static EventLoopGroup newEventLoopGroup(int threads) {
if (useNativeIo && Epoll.isAvailable()) {
return new EpollEventLoopGroup(threads);
} else if (useNativeIo && KQueue.isAvailable()) {
return new KQueueEventLoopGroup(threads);
}
NioEventLoopGroup eventLoopGroup = new NioEventLoopGroup(threads);
eventLoopGroup.setIoRatio(ConfigManager.getInstance().getIoRatio());
return eventLoopGroup;
}
public Class<? extends Channel> getClientChannel() {
if (useNativeIo && Epoll.isAvailable()) {
return uds ? EpollDomainSocketChannel.class : EpollSocketChannel.class;
} else if (useNativeIo && KQueue.isAvailable()) {
return uds ? KQueueDomainSocketChannel.class : KQueueSocketChannel.class;
}
return NioSocketChannel.class;
}
private void expectToFailIfNotOnLinux(Runnable call) {
// TODO(scott) Windows doesn't propagate the exception. Some times an unhandled exception in pipeline.
if (cChannel instanceof EpollSocketChannel || (!KQueue.isAvailable() && !Epoll.isAvailable())) {
call.run();
} else {
try {
call.run();
fail("Should fail");
} catch (ChannelException e) {
// Expected
}
}
}
public Class<? extends ServerChannel> getServerChannel() {
if (useNativeIo && Epoll.isAvailable()) {
return uds ? EpollServerDomainSocketChannel.class : EpollServerSocketChannel.class;
} else if (useNativeIo && KQueue.isAvailable()) {
return uds ? KQueueServerDomainSocketChannel.class : KQueueServerSocketChannel.class;
}
return NioServerSocketChannel.class;
}
public Class<? extends Channel> getClientChannel() {
if (useNativeIo && Epoll.isAvailable()) {
return uds ? EpollDomainSocketChannel.class : EpollSocketChannel.class;
} else if (useNativeIo && KQueue.isAvailable()) {
return uds ? KQueueDomainSocketChannel.class : KQueueSocketChannel.class;
}
return NioSocketChannel.class;
}
public static HttpBlobStore create(
DomainSocketAddress domainSocketAddress,
URI uri,
int timeoutMillis,
int remoteMaxConnections,
@Nullable final Credentials creds)
throws ConfigurationException, URISyntaxException, SSLException {
if (KQueue.isAvailable()) {
return new HttpBlobStore(
KQueueEventLoopGroup::new,
KQueueDomainSocketChannel.class,
uri,
timeoutMillis,
remoteMaxConnections,
creds,
domainSocketAddress);
} else if (Epoll.isAvailable()) {
return new HttpBlobStore(
EpollEventLoopGroup::new,
EpollDomainSocketChannel.class,
uri,
timeoutMillis,
remoteMaxConnections,
creds,
domainSocketAddress);
} else {
throw new ConfigurationException("Unix domain sockets are unsupported on this platform");
}
}
private static EventLoopGroup newEventLoopGroup() {
if (Epoll.isAvailable()) {
LOGGER.info("Using Netty epoll native transport.");
return new EpollEventLoopGroup(threadFactory);
}
if (KQueue.isAvailable()) {
LOGGER.info("Using Netty kqueue native transport.");
return new KQueueEventLoopGroup(threadFactory);
}
LOGGER.info("Using Netty NIO transport.");
return new NioEventLoopGroup(threadFactory);
}
public static final boolean isKQueueAvailable() {
try {
return Env.isMacOs() && KQueue.isAvailable();
} catch (NoClassDefFoundError noClassDefFoundError) {
ActiveMQClientLogger.LOGGER.unableToCheckKQueueAvailabilityNoClass();
return false;
} catch (Throwable e) {
ActiveMQClientLogger.LOGGER.unableToCheckKQueueAvailability(e);
return false;
}
}
public static boolean isAvailable(TransportOptions transportOptions) {
try {
return transportOptions.isUseKQueue() && KQueue.isAvailable();
} catch (NoClassDefFoundError ncdfe) {
LOG.debug("Unable to check for KQueue support due to missing class definition", ncdfe);
return false;
}
}
public Connector(int port) {
this(port, useNativeIo && (Epoll.isAvailable() || KQueue.isAvailable()));
}
@Before
public void setupUnixDomainSocketServer() throws IOException, URISyntaxException {
Class<? extends ServerDomainSocketChannel> channelType = null;
if (Epoll.isAvailable()) {
group = new EpollEventLoopGroup(2);
channelType = EpollServerDomainSocketChannel.class;
} else if (KQueue.isAvailable()) {
group = new KQueueEventLoopGroup(2);
channelType = KQueueServerDomainSocketChannel.class;
}
assumeThat(group).isNotNull();
assumeThat(channelType).isNotNull();
ServerBootstrap bootstrap = new ServerBootstrap()
.group(group)
.option(ChannelOption.SO_BACKLOG, 1024)
.childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT)
.channel(channelType)
.childHandler(new ChannelInitializer<DomainSocketChannel>() {
@Override
protected void initChannel(DomainSocketChannel ch) {
ch.pipeline()
.addLast("http-codec", new HttpServerCodec())
.addLast("http-keep-alive", new HttpServerKeepAliveHandler())
.addLast("http-aggregator", new HttpObjectAggregator(Integer.MAX_VALUE))
.addLast(new SimpleChannelInboundHandler<FullHttpRequest>() {
@Override
protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest req) {
byte[] bytes = responseText.get().getBytes(UTF_8);
ByteBuf text = Unpooled.wrappedBuffer(bytes);
FullHttpResponse res = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, text);
res.headers().set(CONTENT_TYPE, MediaType.PLAIN_TEXT_UTF_8.toString());
res.headers().set(CONTENT_LENGTH, bytes.length);
ctx.writeAndFlush(res);
}
});
}
});
Path temp = Files.createTempFile("domain-socket-test", "socket");
Files.deleteIfExists(temp);
SocketAddress address = new DomainSocketAddress(temp.toFile());
future = bootstrap.bind(address);
socket = new URI("unix", null, null, 0, temp.toString(), null, null);
}
public static Class<? extends SocketChannel> socketChannel() {
return EPOLL ? EpollSocketChannel.class : KQueue.isAvailable() ? KQueueSocketChannel.class : NioSocketChannel.class;
}
public static Class<? extends ServerSocketChannel> serverSocketChannel() {
return EPOLL ? EpollServerSocketChannel.class : KQueue.isAvailable() ? KQueueServerSocketChannel.class : NioServerSocketChannel.class;
}
public static EventLoopGroup eventLoopGroup(int threads, ThreadFactory threadFactory) {
return EPOLL ? new EpollEventLoopGroup(threads, threadFactory) : KQueue.isAvailable() ? new KQueueEventLoopGroup(threads,
threadFactory) : new NioEventLoopGroup(
threads,
threadFactory);
}
public Connector(int port) {
this(port, useNativeIo && (Epoll.isAvailable() || KQueue.isAvailable()));
}
/**
* The native socket transport for BSD systems such as MacOS using JNI.
*/
public static boolean isNativeKQueueAvailable() {
return KQueue.isAvailable();
}
/**
* Create a new {@link EventLoopGroup}.
*
* @param ioThreads number of threads
* @param threadFactory the {@link ThreadFactory} to use.
* @return The created {@link IoExecutor}
*/
public static EventLoopGroup createEventLoopGroup(int ioThreads, ThreadFactory threadFactory) {
validateIoThreads(ioThreads);
return Epoll.isAvailable() ? new EpollEventLoopGroup(ioThreads, threadFactory) :
KQueue.isAvailable() ? new KQueueEventLoopGroup(ioThreads, threadFactory) :
new NioEventLoopGroup(ioThreads, threadFactory);
}