com.datastax.driver.core.NettyUtil Maven / Gradle / Ivy
Show all versions of scylla-driver-core Show documentation
/*
* Copyright DataStax, Inc.
*
* Licensed 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 com.datastax.driver.core;
import com.google.common.base.Throwables;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import java.lang.reflect.Constructor;
import java.util.Locale;
import java.util.concurrent.ThreadFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/** A set of utilities related to the underlying Netty layer. */
@SuppressWarnings("unchecked")
class NettyUtil {
private static final boolean FORCE_NIO =
SystemProperties.getBoolean("com.datastax.driver.FORCE_NIO", false);
private static final Logger LOGGER = LoggerFactory.getLogger(NettyUtil.class);
private static final boolean USE_EPOLL;
private static final Constructor EPOLL_EVENT_LOOP_GROUP_CONSTRUCTOR;
private static final Class EPOLL_CHANNEL_CLASS;
private static final Class[] EVENT_GROUP_ARGUMENTS = {int.class, ThreadFactory.class};
private static final String SHADING_DETECTION_STRING =
"io.netty.shadingdetection.ShadingDetection";
private static final boolean SHADED =
!SHADING_DETECTION_STRING.equals(
String.format("%s.%s.shadingdetection.ShadingDetection", "io", "netty"));
static {
boolean useEpoll = false;
if (!SHADED) {
try {
Class epoll = Class.forName("io.netty.channel.epoll.Epoll");
if (FORCE_NIO) {
LOGGER.info(
"Found Netty's native epoll transport in the classpath, "
+ "but NIO was forced through the FORCE_NIO system property.");
} else if (!System.getProperty("os.name", "").toLowerCase(Locale.US).equals("linux")) {
LOGGER.warn(
"Found Netty's native epoll transport, but not running on linux-based operating "
+ "system. Using NIO instead.");
} else if (!(Boolean) epoll.getMethod("isAvailable").invoke(null)) {
LOGGER.warn(
"Found Netty's native epoll transport in the classpath, but epoll is not available. "
+ "Using NIO instead.",
(Throwable) epoll.getMethod("unavailabilityCause").invoke(null));
} else {
LOGGER.info("Found Netty's native epoll transport in the classpath, using it");
useEpoll = true;
}
} catch (ClassNotFoundException e) {
LOGGER.info(
"Did not find Netty's native epoll transport in the classpath, defaulting to NIO.");
} catch (Exception e) {
LOGGER.warn(
"Unexpected error trying to find Netty's native epoll transport in the classpath, defaulting to NIO.",
e);
}
} else {
LOGGER.info(
"Detected shaded Netty classes in the classpath; native epoll transport will not work properly, "
+ "defaulting to NIO.");
}
USE_EPOLL = useEpoll;
Constructor constructor = null;
Class channelClass = null;
if (USE_EPOLL) {
try {
channelClass =
(Class)
Class.forName("io.netty.channel.epoll.EpollSocketChannel");
Class epoolEventLoupGroupClass =
Class.forName("io.netty.channel.epoll.EpollEventLoopGroup");
constructor =
(Constructor)
epoolEventLoupGroupClass.getDeclaredConstructor(EVENT_GROUP_ARGUMENTS);
} catch (Exception e) {
throw new AssertionError(
"Netty's native epoll is in use but cannot locate Epoll classes, this should not happen: "
+ e);
}
}
EPOLL_EVENT_LOOP_GROUP_CONSTRUCTOR = constructor;
EPOLL_CHANNEL_CLASS = channelClass;
}
/** @return true if the current driver bundle is using shaded Netty classes, false otherwise. */
public static boolean isShaded() {
return SHADED;
}
/** @return true if native epoll transport is available in the classpath, false otherwise. */
public static boolean isEpollAvailable() {
return USE_EPOLL;
}
/**
* Return a new instance of {@link EventLoopGroup}.
*
* Returns an instance of {@link io.netty.channel.epoll.EpollEventLoopGroup} if {@link
* #isEpollAvailable() epoll is available}, or an instance of {@link NioEventLoopGroup} otherwise.
*
* @param factory the {@link ThreadFactory} instance to use to create the new instance of {@link
* EventLoopGroup}
* @return a new instance of {@link EventLoopGroup}
*/
public static EventLoopGroup newEventLoopGroupInstance(ThreadFactory factory) {
if (isEpollAvailable()) {
try {
return EPOLL_EVENT_LOOP_GROUP_CONSTRUCTOR.newInstance(0, factory);
} catch (Exception e) {
throw Throwables.propagate(e); // should not happen
}
} else {
return new NioEventLoopGroup(0, factory);
}
}
/**
* Return the SocketChannel class to use.
*
*
Returns an instance of {@link io.netty.channel.epoll.EpollSocketChannel} if {@link
* #isEpollAvailable() epoll is available}, or an instance of {@link NioSocketChannel} otherwise.
*
* @return the SocketChannel class to use.
*/
public static Class channelClass() {
if (isEpollAvailable()) {
return EPOLL_CHANNEL_CLASS;
} else {
return NioSocketChannel.class;
}
}
}