Java tutorial
/* * Copyright (C) 2012-2015 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 org.slf4j.Logger; import org.slf4j.LoggerFactory; import java.lang.reflect.Constructor; import java.util.Locale; import java.util.concurrent.ThreadFactory; /** * 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 SHADED; private static final boolean USE_EPOLL; private static final Constructor<? extends EventLoopGroup> EPOLL_EVENT_LOOP_GROUP_CONSTRUCTOR; private static final Class<? extends SocketChannel> EPOLL_CHANNEL_CLASS; private static final Class[] EVENT_GROUP_ARGUMENTS = { int.class, ThreadFactory.class }; static { boolean shaded; try { // prevent this string from being shaded Class.forName(String.format("%s.%s.channel.Channel", "io", "netty")); shaded = false; } catch (ClassNotFoundException e) { try { Class.forName("com.datastax.shaded.netty.channel.Channel"); shaded = true; } catch (ClassNotFoundException e1) { throw new AssertionError("Cannot locate Netty classes in the classpath:" + e1); } } SHADED = shaded; 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<? extends EventLoopGroup> constructor = null; Class<? extends SocketChannel> channelClass = null; if (USE_EPOLL) { try { channelClass = (Class<? extends SocketChannel>) Class .forName("io.netty.channel.epoll.EpollSocketChannel"); Class<?> epoolEventLoupGroupClass = Class.forName("io.netty.channel.epoll.EpollEventLoopGroup"); constructor = (Constructor<? extends EventLoopGroup>) 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}. * <p/> * 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. * <p/> * 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<? extends SocketChannel> channelClass() { if (isEpollAvailable()) { return EPOLL_CHANNEL_CLASS; } else { return NioSocketChannel.class; } } }