private void initializeTransport()

in zuul-core/src/main/java/com/netflix/zuul/netty/server/Server.java [364:418]
50 lines of code
8 McCabe index (conditional complexity)

        private void initializeTransport() {
            // TODO - try our own impl of ChooserFactory that load-balances across the eventloops using leastconns algo?
            EventExecutorChooserFactory chooserFactory;
            if (USE_LEASTCONNS_FOR_EVENTLOOPS.get()) {
                chooserFactory = new LeastConnsEventLoopChooserFactory(eventLoopGroupMetrics);
            } else {
                chooserFactory = DefaultEventExecutorChooserFactory.INSTANCE;
            }

            ThreadFactory workerThreadFactory = new CategorizedThreadFactory(name + "-ClientToZuulWorker");
            Executor workerExecutor = new ThreadPerTaskExecutor(workerThreadFactory);

            Map<ChannelOption<?>, Object> extraOptions = new HashMap<>();
            boolean useNio = FORCE_NIO.get();
            boolean useIoUring = FORCE_IO_URING.get();
            if (useIoUring && ioUringIsAvailable()) {
                channelType = IOUringServerSocketChannel.class;
                defaultOutboundChannelType.set(IOUringSocketChannel.class);
                clientToProxyBossPool = new IOUringEventLoopGroup(
                        acceptorThreads, new CategorizedThreadFactory(name + "-ClientToZuulAcceptor"));
                clientToProxyWorkerPool = new IOUringEventLoopGroup(workerThreads, workerExecutor);
            } else if (!useNio && epollIsAvailable()) {
                channelType = EpollServerSocketChannel.class;
                defaultOutboundChannelType.set(EpollSocketChannel.class);
                extraOptions.put(EpollChannelOption.TCP_DEFER_ACCEPT, -1);
                clientToProxyBossPool = new EpollEventLoopGroup(
                        acceptorThreads, new CategorizedThreadFactory(name + "-ClientToZuulAcceptor"));
                clientToProxyWorkerPool = new EpollEventLoopGroup(
                        workerThreads, workerExecutor, chooserFactory, DefaultSelectStrategyFactory.INSTANCE);
            } else if (!useNio && kqueueIsAvailable()) {
                channelType = KQueueServerSocketChannel.class;
                defaultOutboundChannelType.set(KQueueSocketChannel.class);
                clientToProxyBossPool = new KQueueEventLoopGroup(
                        acceptorThreads, new CategorizedThreadFactory(name + "-ClientToZuulAcceptor"));
                clientToProxyWorkerPool = new KQueueEventLoopGroup(
                        workerThreads, workerExecutor, chooserFactory, DefaultSelectStrategyFactory.INSTANCE);
            } else {
                channelType = NioServerSocketChannel.class;
                defaultOutboundChannelType.set(NioSocketChannel.class);
                NioEventLoopGroup elg = new NioEventLoopGroup(
                        workerThreads,
                        workerExecutor,
                        chooserFactory,
                        SelectorProvider.provider(),
                        DefaultSelectStrategyFactory.INSTANCE);
                elg.setIoRatio(90);
                clientToProxyBossPool = new NioEventLoopGroup(
                        acceptorThreads, new CategorizedThreadFactory(name + "-ClientToZuulAcceptor"));
                clientToProxyWorkerPool = elg;
            }

            transportChannelOptions = Collections.unmodifiableMap(extraOptions);

            postEventLoopCreationHook(clientToProxyBossPool, clientToProxyWorkerPool);
        }