• Home
• io.hekate
• hekate-core
• 3.10.0
• source code
• NettyServer.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

io.hekate.network.netty.NettyServer Maven / Gradle / Ivy

/*
 * Copyright 2020 The Hekate Project
 *
 * The Hekate 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.hekate.network.netty;

import io.hekate.codec.CodecFactory;
import io.hekate.core.internal.util.ArgAssert;
import io.hekate.core.internal.util.ConfigCheck;
import io.hekate.network.NetworkEndpoint;
import io.hekate.network.NetworkServer;
import io.hekate.network.NetworkServerCallback;
import io.hekate.network.NetworkServerFailure;
import io.hekate.network.NetworkServerFailure.Resolution;
import io.hekate.network.NetworkServerFuture;
import io.hekate.network.NetworkServerHandlerConfig;
import io.hekate.network.internal.NettyChannelSupport;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.PooledByteBufAllocator;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.epoll.EpollEventLoopGroup;
import io.netty.channel.epoll.EpollServerSocketChannel;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.ssl.SslContext;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import static io.hekate.network.NetworkServer.State.STARTED;
import static io.hekate.network.NetworkServer.State.STARTING;
import static io.hekate.network.NetworkServer.State.STOPPED;
import static io.hekate.network.NetworkServer.State.STOPPING;
import static java.util.Collections.emptyList;
import static java.util.Collections.synchronizedMap;

class NettyServer implements NetworkServer, NettyChannelSupport {
    private static final Logger log = LoggerFactory.getLogger(NettyServer.class);

    private static final boolean DEBUG = log.isDebugEnabled();

    private static final boolean TRACE = log.isTraceEnabled();

    private final Object mux = new Object();

    private final boolean autoAccept;

    private final int hbInterval;

    private final int hbLossThreshold;

    private final boolean hbDisabled;

    private final boolean tcpNoDelay;

    private final Integer soReceiveBufferSize;

    private final Integer soSendBuffer;

    private final Boolean soReuseAddress;

    private final Integer soBacklog;

    private final SslContext ssl;

    private final Map> codecs = synchronizedMap(new HashMap<>());

    private final Map handlers = new ConcurrentHashMap<>();

    private final Map clients = new IdentityHashMap<>();

    private final EventLoopGroup acceptors;

    private final EventLoopGroup workers;

    private final NettyMetricsFactory metrics;

    private Channel server;

    private NetworkServerCallback callback;

    private NetworkServerFuture startFuture;

    private NetworkServerFuture stopFuture;

    private boolean failoverInProgress;

    // Volatile since address is updated after server start (to reflect a real port)
    // and can be accessed in non-synchronized context.
    private volatile InetSocketAddress address;

    // Volatile since it can be accessed in non-synchronized context.
    private volatile State state = STOPPED;

    public NettyServer(NettyServerFactory factory) {
        ArgAssert.notNull(factory, "Factory");

        ConfigCheck check = ConfigCheck.get(NettyServerFactory.class);

        check.notNull(factory.getAcceptorEventLoop(), "acceptor event loop");
        check.notNull(factory.getWorkerEventLoop(), "worker event loop");

        autoAccept = factory.isAutoAccept();
        hbInterval = factory.getHeartbeatInterval();
        hbLossThreshold = factory.getHeartbeatLossThreshold();
        hbDisabled = factory.isDisableHeartbeats();
        tcpNoDelay = factory.isTcpNoDelay();
        soReceiveBufferSize = factory.getSoReceiveBufferSize();
        soSendBuffer = factory.getSoSendBufferSize();
        soReuseAddress = factory.getSoReuseAddress();
        soBacklog = factory.getSoBacklog();
        ssl = factory.getSsl();
        metrics = factory.getMetrics();

        acceptors = factory.getAcceptorEventLoop();
        workers = factory.getWorkerEventLoop();

        checkWorkerEventLoopType(check, workers);

        if (factory.getHandlers() != null) {
            factory.getHandlers().forEach(this::addHandler);
        }
    }

    @Override
    public InetSocketAddress address() {
        return address;
    }

    @Override
    public State state() {
        return state;
    }

    @Override
    public NetworkServerFuture start(InetSocketAddress bindAddress) {
        return start(bindAddress, null);
    }

    @Override
    public NetworkServerFuture start(InetSocketAddress address, NetworkServerCallback callback) {
        ArgAssert.notNull(address, "Address");

        synchronized (mux) {
            if (state != STOPPED) {
                throw new IllegalStateException("Server is in " + state + " state [address=" + this.address + ']');
            }

            if (DEBUG) {
                log.debug("Starting [address={}]", this.address);
            }

            this.state = STARTING;
            this.address = address;
            this.callback = callback;

            startFuture = new NetworkServerFuture();

            doStart(0);

            return startFuture;
        }
    }

    @Override
    public void startAccepting() {
        synchronized (mux) {
            if (server != null && !server.config().isAutoRead()) {
                if (DEBUG) {
                    log.debug("Start accepting [address={}]", address);
                }

                server.config().setAutoRead(true);
            }
        }
    }

    @Override
    public NetworkServerFuture stop() {
        return doStop(null);
    }

    @Override
    public void addHandler(NetworkServerHandlerConfig cfg) {
        @SuppressWarnings("unchecked")
        NetworkServerHandlerConfig