tcp-server 1.2.0-java → 1.4.1-java

data/lib/{server → tcp_server}/config.rb

@@ -6,17 +6,19 @@
 
 # =begin
 #
-# Copyright Nels Nelson 2016-2024 but freely usable (see license)
+# Copyright Nels Nelson 2016-2026 but freely usable (see license)
 #
 # =end
 
 require 'java'
 require 'netty'
 
+java_import 'io.netty.handler.codec.Delimiters'
+
 require 'logger'
 
-# The Server module
-module Server
+# The TcpServer module
+module TcpServer
   DEFAULT_LOG_LEVEL = Logger::INFO
   DEFAULT_HOST = '0.0.0.0'.freeze
   DEFAULT_PORT = 8080
@@ -26,7 +28,7 @@ module Server
   DEFAULT_KEEP_ALIVE = false
   DEFAULT_MAX_QUEUED_INCOMING_CONNECTIONS = 100
   DEFAULT_MAX_FRAME_LENGTH = 8192
-  DEFAULT_DELIMITER = Java::io.netty.handler.codec.Delimiters.lineDelimiter
+  DEFAULT_DELIMITER = Delimiters.lineDelimiter
   DEFAULT_LOG_REQUESTS = false
   DEFAULT_QUIT_COMMANDS = %i[
     bye cease desist exit leave quit stop terminate
@@ -35,6 +37,7 @@ module Server
   # rubocop: disable Metrics/MethodLength
   def server_config
     @server_config ||= {
+      app_name: 'tcp_server',
       host: DEFAULT_HOST,
       port: DEFAULT_PORT,
       ssl: DEFAULT_SSL_ENABLED,
@@ -52,3 +55,4 @@ module Server
   module_function :server_config
   # rubocop: enable Metrics/MethodLength
 end
+# end TcpServer

data/lib/{server → tcp_server}/default_handler.rb

@@ -6,16 +6,16 @@
 
 # =begin
 #
-# Copyright Nels Nelson 2016-2024 but freely usable (see license)
+# Copyright Nels Nelson 2016-2026 but freely usable (see license)
 #
 # =end
 
-# The Server module
-module Server
+# The TcpServer module
+module TcpServer
   # The DefaultHandler module
   module DefaultHandler
     def channel_active(ctx)
-      ::Server.log.info "Channel active: #{ctx.channel}"
+      TcpServer.log.info "Channel active: #{ctx.channel}"
       response = 'Hello, world!'
       log.trace "Sending response: #{response.inspect}"
       ctx.channel.writeAndFlush("#{response}\n")
@@ -24,7 +24,7 @@ module Server
     # rubocop: disable Metrics/AbcSize
     def message_received(ctx, msg)
       return if msg.nil?
-      msg.chomp! if msg.respond_to?(:chomp!)
+      msg = msg.chomp if msg.respond_to?(:chomp)
       return if msg.respond_to?(:empty?) && msg.empty?
       log.trace "##{__method__} channel: #{ctx.channel}, message: #{msg.inspect}"
       return ctx.close() if @options[:quit_commands].include?(msg.downcase.to_sym)
@@ -35,9 +35,10 @@ module Server
     # rubocop: enable Metrics/AbcSize
 
     def exception_caught(_ctx, cause)
-      ::Server.log.error "Exception caught: #{cause}"
+      TcpServer.log.error "Exception caught: #{cause}"
       cause.backtrace.each { |t| ::Server.log.error t }
       ctx.close()
     end
   end
 end
+# end TcpServer

data/lib/{demo_listener.rb → tcp_server/demo_listener.rb}

@@ -6,17 +6,17 @@
 
 # =begin
 #
-# Copyright Nels Nelson 2016-2024 but freely usable (see license)
+# Copyright Nels Nelson 2016-2026 but freely usable (see license)
 #
 # =end
 
-require_relative 'server/default_handler'
+require_relative 'default_handler'
 
-# The Server module
-module Server
+# The TcpServer module
+module TcpServer
   # The Demo class
   class Demo
-    include Server::DefaultHandler
+    include TcpServer::DefaultHandler
 
     def initialize(options = {})
       @options = options

data/lib/{server → tcp_server}/instance_methods.rb

@@ -6,54 +6,61 @@
 
 # =begin
 #
-# Copyright Nels Nelson 2016-2024 but freely usable (see license)
+# Copyright Nels Nelson 2016-2026 but freely usable (see license)
 #
 # =end
 
 require 'java'
 require 'netty'
 
-require_relative 'channel_initializer'
+java_import 'io.netty.bootstrap.ServerBootstrap'
+java_import 'io.netty.channel.ChannelOption'
+java_import 'io.netty.channel.group.DefaultChannelGroup'
+java_import 'io.netty.channel.nio.NioEventLoopGroup'
+java_import 'io.netty.util.concurrent.GlobalEventExecutor'
+java_import 'io.netty.handler.logging.LoggingHandler'
+java_import 'io.netty.handler.logging.LogLevel'
+
+require_relative 'channelizer'
 require_relative 'default_handler'
-require_relative 'shutdown_hook'
-
-# The Server module
-module Server
-  java_import Java::io.netty.bootstrap.ServerBootstrap
-  java_import Java::io.netty.channel.ChannelOption
-  java_import Java::io.netty.channel.group.DefaultChannelGroup
-  java_import Java::io.netty.channel.nio.NioEventLoopGroup
-  java_import Java::io.netty.handler.logging.LogLevel
-  java_import Java::io.netty.handler.logging.LoggingHandler
-  java_import Java::io.netty.util.concurrent.GlobalEventExecutor
 
+# The TcpServer module
+module TcpServer
   # The InstanceMethods module
   module InstanceMethods
-    include ::Server::DefaultHandler
+    include TcpServer::DefaultHandler
 
     # rubocop: disable Metrics/AbcSize
     def bootstrap
       @bootstrap = ServerBootstrap.new
       @bootstrap.group(boss_group, worker_group)
       @bootstrap.channel(channel_type)
-      @bootstrap.option(ChannelOption::SO_BACKLOG, max_queued_incoming_connections)
-      @bootstrap.childOption(ChannelOption::SO_KEEPALIVE, keep_alive) if keep_alive
+      @bootstrap.option(backlog_option, max_queued_incoming_connections)
+      @bootstrap.childOption(keep_alive_option, keep_alive) if keep_alive
       @bootstrap.handler(logging_handler) if options.fetch(:log_requests, false)
-      @bootstrap.childHandler(channel_initializer)
+      @bootstrap.childHandler(channelizer)
     end
     # rubocop: enable Metrics/AbcSize
 
+    def backlog_option
+      ChannelOption::SO_BACKLOG
+    end
+
+    def keep_alive_option
+      ChannelOption::SO_KEEPALIVE
+    end
+
     def configure_handlers(*handlers, &block)
-      channel_initializer << block if block_given?
+      channelizer << block if block_given?
       add_listener(*handlers)
     end
 
     def channel_type
-      @channel_type ||= Server::CHANNEL_TYPE
+      @channel_type ||= TcpServer::Server::CHANNEL_TYPE
     end
 
-    def channel_initializer
-      @channel_initializer ||= ::Server::ChannelInitializer.new(channel_group, @options)
+    def channelizer
+      @channelizer ||= TcpServer::Channelizer.new(channel_group, @options)
     end
 
     def boss_group
@@ -65,21 +72,30 @@ module Server
     end
 
     def channel_group
-      @channel_group ||= DefaultChannelGroup.new('server_channels', GlobalEventExecutor::INSTANCE)
+      @channel_group ||= DefaultChannelGroup.new(
+        'server_channels', GlobalEventExecutor::INSTANCE)
     end
 
     def logging_handler
       @logging_handler ||= LoggingHandler.new(LogLevel::INFO)
     end
 
+    def server_channel(port = self.port)
+      @server_channel ||= bootstrap.bind(port).sync().channel()
+    end
+
     # rubocop: disable Metrics/AbcSize
     # rubocop: disable Metrics/MethodLength
     def run(port = self.port)
-      channel = bootstrap.bind(port).sync().channel()
+      channel = server_channel(port)
       channel_group.add(channel)
-      ::Server::ShutdownHook.new(self)
+      Signal.trap('INT') { handle_interrupt }
+      Signal.trap('TERM') { handle_interrupt }
       log.info "Listening on #{channel.local_address}"
       channel.closeFuture().sync()
+    rescue Interrupt => _e
+      $stdout.write "\r\e[0K"
+      $stdout.flush
     rescue java.lang.IllegalArgumentException => e
       raise "Invalid argument: #{e.message}"
     rescue java.net.BindException => e
@@ -96,26 +112,49 @@ module Server
       @port ||= (@options[:port] || DEFAULT_PORT).to_i
     end
 
+    def handle_interrupt
+      $stdout.write "\r\e[0K"
+      $stdout.flush
+      shutdown
+    end
+
     def shutdown
-      channel_group.disconnect().awaitUninterruptibly()
-      channel_group.close().awaitUninterruptibly()
+      logger.info 'Shutting down'
+      quietly do
+        server_channel&.close()
+        channel_group.disconnect().awaitUninterruptibly()
+        channel_group.close().awaitUninterruptibly()
+      end
+    rescue StandardError => e
+      warn e.message
+      $stderr.flush
+    end
+
+    def quietly(preserved_verbose = $VERBOSE)
+      $VERBOSE = nil
+      yield
+    ensure
+      $VERBOSE = preserved_verbose
     end
 
     def stop
       boss_group&.shutdownGracefully()
       worker_group&.shutdownGracefully()
+    rescue StandardError => e
+      warn e.message
+      $stderr.flush
     end
 
     def <<(handler)
-      channel_initializer << handler
+      channelizer << handler
     end
 
     def add_listener(*listener)
-      channel_initializer.add_listener(*listener)
+      channelizer.add_listener(*listener)
     end
 
     def replace_listeners(*listener)
-      channel_initializer.replace_listeners(*listener)
+      channelizer.replace_listeners(*listener)
     end
 
     def keep_alive
@@ -133,6 +172,6 @@ module Server
       end
     end
   end
-  # module ServerInstanceMethods
+  # module InstanceMethods
 end
-# module Server
+# module TcpServer

data/lib/{server → tcp_server}/listenable.rb

@@ -6,14 +6,14 @@
 
 # =begin
 #
-# Copyright Nels Nelson 2016-2024 but freely usable (see license)
+# Copyright Nels Nelson 2016-2026 but freely usable (see license)
 #
 # =end
 
 require 'java'
 
-# The Server module
-module Server
+# The TcpServer module
+module TcpServer
   # The Listenable module
   module Listenable
     def listeners
@@ -45,4 +45,4 @@ module Server
   end
   # module Listenable
 end
-# module Server
+# module TcpServer

data/lib/tcp_server/logging.rb

@@ -0,0 +1,310 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+def jruby?
+  defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby' && defined?(Java)
+end
+
+if jruby?
+  require 'java'
+  require 'apache-log4j-2'
+
+  java_import 'org.apache.logging.log4j.Level'
+  java_import 'org.apache.logging.log4j.core.appender.ConsoleAppender'
+  java_import 'org.apache.logging.log4j.core.config.builder.api.' \
+    'ConfigurationBuilderFactory'
+  java_import 'org.apache.logging.log4j.core.config.Configurator'
+  java_import 'org.apache.logging.log4j.core.config.LoggerConfig'
+  java_import 'org.apache.logging.log4j.core.LoggerContext'
+  java_import 'org.apache.logging.log4j.LogManager'
+  java_import 'org.apache.logging.log4j.ThreadContext'
+end
+
+require 'fileutils'
+require 'logger'
+
+# The Logging module
+module Logging
+  DEFAULT_TIME_FORMAT = '%Y-%m-%d %H:%M:%S'.freeze
+  DEFAULT_APP_NAME = 'app'.freeze
+  DEFAULT_LOG_PATTERN = '%d{ABSOLUTE} %-5p [%X{category}] %m%n'.freeze
+  DEFAULT_RUBY_LOG_FORMAT =
+    "%<timestamp>s %-5<severity>s %<category>s] %<msg>s\n".freeze
+  EMPTY_STRING = ''.freeze
+
+  module_function
+
+  def backend
+    @backend ||= init_backend
+  end
+
+  def init_backend
+    return init_log4j_backend if jruby?
+    init_logger_backend
+  end
+
+  def init_logger_backend
+    log = Logger.new($stdout)
+    log.formatter = method(:ruby_formatter)
+    @backend = log
+    apply_backend_level(log_level)
+    log
+  end
+
+  def init_log4j_backend
+    init_log4j2!
+    apply_backend_level(log_level)
+    LogManager.getLogger(app_logger_name)
+  end
+
+  def proxy
+    @proxy ||= Proxy.new
+  end
+
+  def app_name
+    DEFAULT_APP_NAME
+  end
+
+  def app_logger_name
+    DEFAULT_APP_NAME
+  end
+
+  def time_format
+    DEFAULT_TIME_FORMAT
+  end
+
+  def ruby_log_format
+    DEFAULT_RUBY_LOG_FORMAT
+  end
+
+  def java_log_pattern
+    DEFAULT_LOG_PATTERN
+  end
+
+  def ruby_formatter(severity, datetime, _progname, msg)
+    category = (Thread.current[:logging_category] || app_name).to_s
+    timestamp = datetime.strftime(time_format)
+    format(ruby_log_format, timestamp: timestamp, severity: severity,
+      category: category, msg: msg)
+  end
+
+  def init_log4j2!
+    return if @log4j2_initialized
+
+    Java::java.lang.System.setProperty(
+      'log4j.shutdownHookEnabled', Java::java.lang.Boolean.toString(false))
+
+    configure_log4j
+
+    @log4j2_initialized = true
+  end
+
+  def configure_log4j
+    @log4j2_context = Configurator.initialize(log4j_configuration.build)
+    @log4j2_context.updateLoggers
+  end
+
+  # rubocop: disable Metrics/AbcSize
+  # rubocop: disable Metrics/MethodLength
+  def log4j_configuration(
+      config = ConfigurationBuilderFactory.newConfigurationBuilder)
+    layout = config.newLayout('PatternLayout')
+      .addAttribute('pattern', java_log_pattern)
+    console = config.newAppender('stdout', 'CONSOLE')
+      .addAttribute('target', ConsoleAppender::Target::SYSTEM_OUT).add(layout)
+    config.add(console)
+    root = config.newRootLogger(Level::INFO)
+      .add(config.newAppenderRef('stdout'))
+    config.add(root)
+    app_logger = config.newLogger(app_logger_name, Level::INFO)
+      .add(config.newAppenderRef('stdout'))
+      .addAttribute('additivity', false)
+    config.add(app_logger)
+    config
+  end
+  # rubocop: enable Metrics/AbcSize
+  # rubocop: enable Metrics/MethodLength
+
+  def derive_category(receiver, callsite)
+    if receiver.is_a?(Module)
+      receiver.name.to_s
+    elsif receiver.respond_to?(:class) && receiver.class.respond_to?(:name)
+      receiver.class.name.to_s
+    else
+      EMPTY_STRING
+    end.tap do |cat|
+      return cat unless cat.empty?
+    end
+
+    File.basename(callsite.path.to_s)
+  end
+
+  def dispatch(level, *args, &block)
+    if jruby?
+      backend.public_send(level, *args, &block)
+    else
+      case level
+      when :fatal then backend.fatal(*args, &block)
+      when :warn then backend.warn(*args, &block)
+      else
+        backend.public_send(level, *args, &block)
+      end
+    end
+  end
+
+  # rubocop: disable Metrics/MethodLength
+  def with_category(category)
+    if jruby?
+      prev = ThreadContext.get('category')
+
+      begin
+        ThreadContext.put('category', category)
+        yield
+      ensure
+        if prev.nil?
+          ThreadContext.remove('category')
+        else
+          ThreadContext.put('category', prev)
+        end
+      end
+    else
+      prev = Thread.current[:logging_category]
+
+      begin
+        Thread.current[:logging_category] = category
+        yield
+      ensure
+        Thread.current[:logging_category] = prev
+      end
+    end
+  end
+  # rubocop: enable Metrics/MethodLength
+
+  NUMERIC_TO_SYMBOL = {
+    5 => :off,
+    4 => :fatal,
+    3 => :error,
+    2 => :warn,
+    1 => :info,
+    0 => :debug,
+    -1 => :trace
+  }.freeze
+
+  SYMBOL_TO_RUBY = {
+    off: Logger::FATAL,
+    fatal: Logger::FATAL,
+    error: Logger::ERROR,
+    warn: Logger::WARN,
+    info: Logger::INFO,
+    debug: Logger::DEBUG,
+    trace: Logger::DEBUG,
+    all: Logger::DEBUG
+  }.freeze
+
+  def log_level
+    @log_level ||= :info
+  end
+
+  def log_level=(level)
+    @log_level = case level
+    when Integer
+      int_to_symbol_level(level)
+    when Symbol, String
+      level.to_s.downcase.to_sym
+    else
+      :info
+    end
+
+    apply_backend_level(@log_level)
+  end
+
+  def apply_backend_level(sym)
+    if jruby?
+      ctx = @log4j2_context || LoggerContext.getContext(false)
+      app_cfg = app_config(ctx.getConfiguration, sym)
+      app_cfg.setLevel(symbol_to_java_level(sym))
+      ctx.updateLoggers
+    else
+      backend.level = SYMBOL_TO_RUBY.fetch(sym, Logger::INFO)
+    end
+
+    sym
+  end
+
+  def app_config(context_configuration, sym)
+    app_cfg = context_configuration.getLoggerConfig(app_logger_name)
+    return app_cfg if !app_cfg.nil? && app_cfg.getName == app_logger_name
+
+    init_app_logging_config(context_configuration, app_logger_name, sym)
+  end
+
+  def init_app_logging_config(context_configuration, app_logger_name, sym)
+    app_cfg = LoggerConfig.newBuilder.withConfig(context_configuration)
+      .withLoggerName(app_logger_name).withLevel(symbol_to_java_level(sym))
+      .withAdditivity(false).build
+    if (appender = context_configuration.getAppender('stdout')).nil?
+      app_cfg.setAdditive(true)
+    else
+      app_cfg.addAppender(appender, Level::INFO, nil)
+    end
+    context_configuration.addLogger(app_logger_name, app_cfg)
+    app_cfg
+  end
+
+  def int_to_symbol_level(level)
+    NUMERIC_TO_SYMBOL.fetch(level) do
+      level > 5 ? :off : :all
+    end
+  end
+
+  # rubocop: disable Metrics/CyclomaticComplexity
+  def symbol_to_java_level(sym)
+    case sym
+    when :off then Level::OFF
+    when :fatal then Level::FATAL
+    when :error then Level::ERROR
+    when :warn then Level::WARN
+    when :debug then Level::DEBUG
+    when :trace then Level::TRACE
+    when :all then Level::ALL
+    else Level::INFO
+    end
+  end
+  # rubocop: enable Metrics/CyclomaticComplexity
+end
+
+# The Logging class
+module Logging
+  # The Proxy class
+  class Proxy
+    SEVERITIES = %i[trace debug info warn error fatal].freeze
+
+    def method_missing(method_name, *args, &block)
+      return super unless SEVERITIES.include?(method_name)
+
+      receiver = Thread.current[:logging_receiver]
+      callsite = Thread.current[:logging_callsite] || caller_locations(2, 1).first
+      category = Logging.derive_category(receiver, callsite)
+
+      Logging.with_category(category) do
+        Logging.dispatch(method_name, *args, &block)
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      SEVERITIES.include?(method_name) || super
+    end
+  end
+end
+
+# Make `log` and `logger` available everywhere, capturing receiver + callsite.
+module LoggingInjection
+  def logger
+    Thread.current[:logging_receiver] = self
+    Thread.current[:logging_callsite] = caller_locations(1, 1).first
+    Logging.proxy
+  end
+  alias log logger
+end
+
+Object.include(LoggingInjection)

data/lib/{server → tcp_server}/message_handler.rb

@@ -6,19 +6,19 @@
 
 # =begin
 #
-# Copyright Nels Nelson 2016-2024 but freely usable (see license)
+# Copyright Nels Nelson 2016-2026 but freely usable (see license)
 #
 # =end
 
 require 'java'
 require 'netty'
 
-# The Server module
-module Server
-  java_import Java::io.netty.channel.ChannelFutureListener
-  java_import Java::io.netty.channel.ChannelHandler
-  java_import Java::io.netty.channel.SimpleChannelInboundHandler
+java_import 'io.netty.channel.ChannelHandler'
+java_import 'io.netty.channel.ChannelFutureListener'
+java_import 'io.netty.channel.SimpleChannelInboundHandler'
 
+# The TcpServer module
+module TcpServer
   # The MessageHandler class
   class MessageHandler < SimpleChannelInboundHandler
     include ChannelHandler
@@ -40,9 +40,9 @@ module Server
 
     def messageReceived(ctx, msg)
       log.trace "##{__method__} channel: #{ctx.channel}, message: #{msg.inspect}"
-      msg&.chomp!
+      msg = msg&.chomp
       log.info "Received message: #{msg}"
-      return super(ctx, msg) unless respond_to?(:handle_message) && @handler&.arity == 2
+      return super unless respond_to?(:handle_message) && @handler&.arity == 2
       handle_message(ctx, msg)
     end