tcp-server 1.2.1-java → 1.4.1-java

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

@@ -6,61 +6,65 @@
 
 # =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 'listenable'
+java_import 'io.netty.channel.SimpleChannelInboundHandler'
 
-# The Server module
-module Server
-  java_import Java::io.netty.channel.SimpleChannelInboundHandler
+require_relative 'listenable'
 
+# The TcpServer module
+module TcpServer
   # The ModularHandler class notifies listeners about events.
   class ModularHandler < SimpleChannelInboundHandler
-    include ::Server::Listenable
+    include TcpServer::Listenable
 
     def initialize(channel_group)
       super()
       @channel_group = channel_group
     end
 
+    # Overrides the Java::IoNettyChannel::SimpleChannelInboundHandler#isSharable
+    # method
+    # rubocop: disable Naming/PredicateMethod
     def isSharable
       true
     end
+    # rubocop: enable Naming/PredicateMethod
 
     def channelRegistered(ctx)
-      log.trace "##{__method__} channel: #{ctx.channel}"
+      log.trace "#channelRegistered channel: #{ctx.channel}"
       notify :channel_registered, ctx
-      super(ctx)
+      super
     end
 
     def channelUnregistered(ctx)
-      log.trace "##{__method__} channel: #{ctx.channel}"
+      log.trace "#channelUnregistered channel: #{ctx.channel}"
       notify :channel_unregistered, ctx
-      super(ctx)
+      super
     end
 
     def channelActive(ctx)
-      ::Server.log.debug "##{__method__} channel: #{ctx.channel}"
+      TcpServer.log.debug "#channelActive channel: #{ctx.channel}"
       @channel_group.add(ctx.channel)
       notify :channel_active, ctx
-      super(ctx)
+      super
     end
 
     def channelInactive(ctx)
-      log.trace "##{__method__} channel: #{ctx.channel}"
+      log.trace "#channelInactive channel: #{ctx.channel}"
       notify :channel_inactive, ctx
-      super(ctx)
+      super
     end
 
     def channelRead(ctx, msg)
-      log.trace "##{__method__} channel: #{ctx.channel}, message: #{msg.inspect}"
+      log.trace "#channelRead channel: #{ctx.channel}, message: #{msg.inspect}"
       notify :channel_read, ctx, msg
-      super(ctx, msg)
+      super
     end
 
     # Please keep in mind that this method will be renamed to
@@ -68,40 +72,41 @@ module Server
     #
     # java_signature 'protected abstract void channelRead0(ChannelHandlerContext ctx, I msg) throws Exception'
     def channelRead0(ctx, msg)
-      log.trace "##{__method__} channel: #{ctx.channel}, message: #{msg.inspect}"
+      log.trace "#channelRead0 channel: #{ctx.channel}, message: #{msg.inspect}"
       messageReceived(ctx, msg)
       # super(ctx, msg)
     end
 
     def messageReceived(ctx, msg)
-      log.trace "##{__method__} channel: #{ctx.channel}, message: #{msg.inspect}"
+      log.trace "#messageReceived channel: #{ctx.channel}, message: #{msg.inspect}"
       notify :message_received, ctx, msg
       # super(ctx, msg)
     end
 
     def channelReadComplete(ctx)
-      log.trace "##{__method__} channel: #{ctx.channel}"
+      log.trace "#channelReadComplete channel: #{ctx.channel}"
       notify :channel_read_complete, ctx
-      super(ctx)
+      super
     end
 
     def userEventTriggered(ctx, evt)
-      log.trace "##{__method__} channel: #{ctx.channel}, event: #{evt}"
+      log.trace "#userEventTriggered channel: #{ctx.channel}, event: #{evt}"
       notify :user_event_triggered, ctx, evt
-      super(ctx, evt)
+      super
     end
 
     def channelWritabilityChanged(ctx)
-      log.trace "##{__method__} channel: #{ctx.channel}"
+      log.trace "#channelWritabilityChanged channel: #{ctx.channel}"
       notify :channel_writability_changed, ctx
-      super(ctx)
+      super
     end
 
     def exceptionCaught(ctx, cause)
-      ::Server.log.warn "##{__method__} channel: #{ctx.channel}, cause: #{cause.message}"
-      cause.backtrace.each { |t| ::Server.log.error t }
+      TcpServer.log.warn "#exceptionCaught channel: #{ctx.channel}, " \
+        "cause: #{cause.message}"
+      cause.backtrace.each { |t| TcpServer.log.error t }
       listeners = notify :exception_caught, ctx, cause
-      super(ctx, cause) if listeners.nil? || listeners.empty?
+      super if listeners.nil? || listeners.empty?
     end
 
     IdentifierTemplate = '#<%<class>s:0x%<id>s>'.freeze
@@ -113,4 +118,4 @@ module Server
   end
   # class ModularHandler
 end
-# module Server
+# module TcpServer

data/lib/tcp_server/server.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# =begin
+#
+# Copyright Nels Nelson 2016-2026 but freely usable (see license)
+#
+# =end
+
+require 'java'
+require 'netty'
+
+require_relative 'arguments_parser'
+require_relative 'demo_listener'
+require_relative 'instance_methods'
+require_relative 'listenable'
+require_relative 'logging'
+
+java_import 'io.netty.channel.socket.nio.NioServerSocketChannel'
+
+# The Server module
+module TcpServer
+  # The Server class sets up the netty server.
+  class Server
+    CHANNEL_TYPE = NioServerSocketChannel.java_class
+    include TcpServer::InstanceMethods
+
+    attr_reader :options
+
+    def initialize(options = {}, *handlers, &block)
+      raise ArgumentError, 'Parameter may not be nil: options' if options.nil?
+      @options = TcpServer.server_config.merge(options)
+      configure_handlers(*(handlers.empty? && block.nil? ? [self] : handlers), &block)
+    ensure
+      listeners = channelizer.default_handler.listeners
+      log.trace "##{__method__} listeners: #{listeners}"
+    end
+  end
+  # class Server
+
+  def main(args = parse_arguments)
+    Logging.log_level = args[:log_level]
+    demo_handler = TcpServer::Demo.new(args)
+    TcpServer::Server.new(args, demo_handler).run
+  rescue Interrupt => e
+    warn format("\r%<class>s", class: e.class)
+    exit
+  rescue StandardError => e
+    TcpServer::Server.log.fatal(e)
+    e.backtrace.each { |t| TcpServer.log.fatal t }
+    exit 1
+  end
+end
+
+Object.new.extend(TcpServer).main if $PROGRAM_NAME == __FILE__

data/lib/tcp_server/version.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# =begin
+#
+# Copyright Nels Nelson 2016-2026 but freely usable (see license)
+#
+# =end
+
+# The TcpServer module
+module TcpServer
+  VERSION = '1.4.1'.freeze
+end

data/lib/tcp_server.rb

@@ -6,8 +6,9 @@
 
 # =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'
+require_relative 'tcp_server/client'
+require_relative 'tcp_server/server'

metadata

@@ -1,60 +1,70 @@
 --- !ruby/object:Gem::Specification
 name: tcp-server
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.4.1
 platform: java
 authors:
 - Nels Nelson
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-15 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
+  name: apache-log4j-2
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.17.1
-  name: apache-log4j-2
+        version: 2.25.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.17.1
-  force_ruby_platform: false
+        version: 2.25.3
 - !ruby/object:Gem::Dependency
+  name: bouncycastle
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.70.1
-  name: bouncycastle
+        version: '1.83'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.70.1
-  force_ruby_platform: false
+        version: '1.83'
 - !ruby/object:Gem::Dependency
+  name: logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.1.74
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
   name: netty-io
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.1.74
-  force_ruby_platform: false
+        version: 4.2.9
 description: TCP Server for JRuby is a tcp server which supports a demo echo server
   application.
 email: nels@nelsnelson.org
@@ -67,23 +77,20 @@ files:
 - README.md
 - Rakefile
 - exe/tcp_server
-- lib/client.rb
-- lib/demo_listener.rb
-- lib/logging.rb
-- lib/server.rb
-- lib/server/argument_parser.rb
-- lib/server/channel_initializer.rb
-- lib/server/config.rb
-- lib/server/default_handler.rb
-- lib/server/instance_methods.rb
-- lib/server/listenable.rb
-- lib/server/message_handler.rb
-- lib/server/modular_handler.rb
-- lib/server/server.rb
-- lib/server/shutdown_hook.rb
-- lib/server/version.rb
-- lib/tcp-server.rb
 - lib/tcp_server.rb
+- lib/tcp_server/arguments_parser.rb
+- lib/tcp_server/channelizer.rb
+- lib/tcp_server/client.rb
+- lib/tcp_server/config.rb
+- lib/tcp_server/default_handler.rb
+- lib/tcp_server/demo_listener.rb
+- lib/tcp_server/instance_methods.rb
+- lib/tcp_server/listenable.rb
+- lib/tcp_server/logging.rb
+- lib/tcp_server/message_handler.rb
+- lib/tcp_server/modular_handler.rb
+- lib/tcp_server/server.rb
+- lib/tcp_server/version.rb
 homepage: https://rubygems.org/gems/tcp-server-jruby
 licenses:
 - MIT
@@ -91,7 +98,6 @@ metadata:
   source_code_uri: https://gitlab.com/nelsnelson/tcp-server-jruby
   bug_tracker_uri: https://gitlab.com/nelsnelson/tcp-server-jruby/issues
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -106,8 +112,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: TCP Server for JRuby packaged as a gem.
 test_files: []

data/lib/logging.rb

@@ -1,253 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: false
-
-# -*- mode: ruby -*-
-# vi: set ft=ruby :
-
-# =begin
-
-# Copyright Nels Nelson 2016-2024 but freely usable (see license)
-
-# =end
-
-require 'java'
-require 'fileutils'
-require 'logger'
-
-require 'apache-log4j-2'
-
-# The Logging module
-module Logging
-  # rubocop: disable Metrics/MethodLength
-  def config
-    @config ||= begin
-      lib_dir_path = File.expand_path(__dir__)
-      project_dir_path = File.expand_path(File.dirname(lib_dir_path))
-      logs_dir_path = File.expand_path(File.join(project_dir_path, 'logs'))
-      FileUtils.mkdir_p(logs_dir_path)
-      log_file_path = File.expand_path(File.join(logs_dir_path, 'server.log'))
-      FileUtils.touch(log_file_path)
-      {
-        level: Logger::INFO,
-        name: 'websocket',
-        lib_dir_path: lib_dir_path,
-        project_dir_path: project_dir_path,
-        logs_dir_path: logs_dir_path,
-        log_file_path: log_file_path,
-        rolling_log_file_name_template: File.expand_path(
-          File.join(logs_dir_path, 'server-%d{yyyy-MM-dd}.log.gz')),
-        logging_pattern_template: {
-          java: '%d{ABSOLUTE} %-5p [%c{1}] %m%n',
-          ruby: "%<timestamp>s %-5<severity>s [%<progname>s] %<msg>s\n"
-        },
-        schedule: '0 0 0 * * ?',
-        size: '100M'
-      }
-    end
-  end
-  module_function :config
-  # rubocop: enable Metrics/MethodLength
-end
-
-# The Logging module
-module Logging
-  if defined?(Java)
-  java_import Java::org.apache.logging.log4j.core.appender::ConsoleAppender
-  java_import Java::org.apache.logging.log4j.core.config::Configurator
-  java_import Java::org.apache.logging.log4j.core.config.builder.api::ConfigurationBuilderFactory
-  end
-
-  # rubocop: disable Metrics/AbcSize
-  # rubocop: disable Metrics/MethodLength
-  def init_log4j(log_level = org.apache.logging.log4j.Level::INFO)
-    java.lang::System.setProperty('log4j.shutdownHookEnabled', java.lang::Boolean.toString(false))
-    config = ConfigurationBuilderFactory.newConfigurationBuilder()
-
-    log_level = org.apache.logging.log4j::Level.to_level(log_level.to_s.upcase) if log_level.is_a? Symbol
-    config.setStatusLevel(log_level)
-    config.setConfigurationName('websocket')
-
-    # create a console appender
-    target = ConsoleAppender::Target::SYSTEM_OUT
-    pattern = Logging.config[:logging_pattern_template][:java]
-    layout = config.newLayout('PatternLayout')
-    layout = layout.addAttribute('pattern', pattern)
-    appender = config.newAppender('stdout', 'CONSOLE')
-    appender = appender.addAttribute('target', target)
-    appender = appender.add(layout)
-    config.add(appender)
-
-    # create a root logger
-    root_logger = config.newRootLogger(log_level)
-    root_logger = root_logger.add(config.newAppenderRef('stdout'))
-
-    # create a rolling file appender
-    cron = config.newComponent('CronTriggeringPolicy')
-    cron = cron.addAttribute('schedule', '0 0 0 * * ?')
-
-    size = config.newComponent('SizeBasedTriggeringPolicy')
-    size = size.addAttribute('size', '100M')
-
-    policies = config.newComponent('Policies')
-    policies = policies.addComponent(cron)
-    policies = policies.addComponent(size)
-
-    appender = config.newAppender('rolling_file', 'RollingFile')
-    appender = appender.addAttribute('fileName', Logging.config[:log_file_path])
-    appender = appender.addAttribute('filePattern', Logging.config[:rolling_log_file_name_template])
-    appender = appender.add(layout)
-    appender = appender.addComponent(policies)
-    config.add(appender)
-
-    root_logger = root_logger.addAttribute('additivity', false)
-    root_logger = root_logger.add(config.newAppenderRef('rolling_file'))
-    config.add(root_logger)
-
-    logging_configuration = config.build()
-    ctx = Configurator.initialize(logging_configuration)
-    ctx.updateLoggers()
-  end
-  module_function :init_log4j
-  # rubocop: enable Metrics/AbcSize
-  # rubocop: enable Metrics/MethodLength
-  # def init_log4j
-
-  init_log4j if defined?(Java)
-end
-# module Logging
-
-# Namespace for methods to help with implicit backtrace printing
-module LoggerHelpers
-  def generate_message(error_or_message, error)
-    error_message = "#{error_or_message}: #{error.class.name}"
-    error_message << ": #{error.message}" if error.respond_to?(:message)
-    error_message
-  end
-
-  def extract_backtrace(error, default_result = nil)
-    if error.respond_to?(:backtrace)
-      error.backtrace.each { |trace| original_error(trace) unless trace.nil? }
-    elsif error.respond_to?(:getStackTrace)
-      error.getStackTrace().each { |trace| original_error(trace) unless trace.nil? }
-    else
-      default_result
-    end
-  end
-end
-
-# Monkey-patch the built-in Ruby Logger class to support
-# implicit backtrace printing
-# TODO: Figure out if this is actually useful.
-class Logger
-  include LoggerHelpers
-
-  alias original_error error
-  def error(error_or_message, error = nil)
-    return extract_backtrace(error_or_message) if error.nil?
-    original_error(generate_message(error_or_message, error))
-    extract_backtrace(original_error(error))
-  end
-end
-
-# The Logging module
-module Logging
-  if defined?(Java)
-  java_import Java::org.apache.logging.log4j.Level
-  java_import Java::org.apache.logging.log4j.LogManager
-  end
-
-  FORWARD_SLASH_PATTERN = %r{/} unless defined?(FORWARD_SLASH_PATTERN)
-
-  def init_logger(level = :info, logger_name = nil)
-    return init_java_logger(level, logger_name, caller[2]) if defined?(Java)
-    init_ruby_logger(level, logger_name, caller[2])
-  end
-
-  def ruby_log_formatter(severity_level, datetime, program_name, message)
-    format(
-      Logging.config[:logging_pattern_template][:ruby],
-      timestamp: datetime.strftime(Logging.config[:logging_timestamp_format]),
-      progname: program_name, severity: severity_level, msg: message)
-  end
-
-  def init_ruby_logger(level = nil, logger_name = nil, source_location = nil)
-    logger_name = get_formatted_logger_name(logger_name)
-    logger_name = source_location.split(FORWARD_SLASH_PATTERN).last if logger_name.empty?
-    log = Logger.new($stdout, progname: logger_name)
-    log.level = level.to_s unless level.nil?
-    log.formatter = method(:ruby_log_formatter)
-    log
-  end
-
-  def init_java_logger(level = nil, logger_name = nil, source_location = nil)
-    logger_name = get_formatted_logger_name(logger_name)
-    logger_name = source_location.split(FORWARD_SLASH_PATTERN).last if logger_name.empty?
-    log = LogManager.getLogger(logger_name)
-    log.level = Level.to_level(level.to_s.upcase) unless level.nil?
-    log
-  end
-
-  def get_formatted_logger_name(logger_name = nil)
-    return logger_name.to_s[/\w+$/] unless logger_name.nil?
-    return name[/\w+$/] if is_a?(Class) || is_a?(Module)
-    self.class.name[/\w+$/]
-  end
-
-  # rubocop: disable Metrics/CyclomaticComplexity
-  # OFF: 0
-  # FATAL: 100
-  # ERROR: 200
-  # WARN: 300
-  # INFO: 400
-  # DEBUG: 500
-  # TRACE: 600
-  # ALL: 2147483647
-  # See: https://logging.apache.org/log4j/2.x/log4j-api/apidocs/org/apache/logging/log4j/Level.html
-  def symbolize_numeric_log_level(level)
-    case level
-    when 5..Float::INFINITY then :off
-    when 4 then :fatal
-    when 3 then :error
-    when 2 then :warn
-    when 1 then :info
-    when 0 then :debug
-    when -1 then :trace
-    when -Float::INFINITY..-2 then :all
-    end
-  end
-  # rubocop: enable Metrics/CyclomaticComplexity
-
-  def log_level=(level)
-    Logging.config[:level] = symbolize_numeric_log_level(level)
-  end
-  module_function :log_level=
-
-  def log_level
-    Logging.config[:level]
-  end
-  module_function :log_level
-
-  def log(level = Logging.log_level, log_name = Logging.config[:app_name])
-    @log ||= init_logger(level, log_name)
-  end
-  alias logger log
-end
-# module Logging
-
-# The Module class
-class Module
-  # Universally include Logging
-  include ::Logging
-end
-
-# The Class class
-class Class
-  # Universally include Logging
-  include ::Logging
-end
-
-# The Object class
-class Object
-  # Universally include Logging
-  include ::Logging
-end

data/lib/server/server.rb

@@ -1,38 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: false
-
-# -*- mode: ruby -*-
-# vi: set ft=ruby :
-
-# =begin
-#
-# Copyright Nels Nelson 2016-2024 but freely usable (see license)
-#
-# =end
-
-require 'java'
-require 'netty'
-
-require_relative 'instance_methods'
-require_relative 'listenable'
-
-# The Server module
-module Server
-  # The Server class sets up the netty server.
-  class Server
-    CHANNEL_TYPE = Java::io.netty.channel.socket.nio.NioServerSocketChannel.java_class
-    include ::Server::InstanceMethods
-    attr_reader :options
-
-    def initialize(options = {}, *handlers, &block)
-      raise ArgumentError, 'Parameter may not be nil: options' if options.nil?
-      @options = ::Server.server_config.merge(options)
-      configure_handlers(*(handlers.empty? && block.nil? ? [self] : handlers), &block)
-    ensure
-      listeners = channel_initializer.default_handler.listeners
-      log.trace "##{__method__} listeners: #{listeners}"
-    end
-  end
-  # class Server
-end
-# module Server

data/lib/server/shutdown_hook.rb

@@ -1,35 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: false
-
-# -*- mode: ruby -*-
-# vi: set ft=ruby :
-
-# =begin
-#
-# Copyright Nels Nelson 2016-2024 but freely usable (see license)
-#
-# =end
-
-require 'java'
-
-# The Server module
-module Server
-  # The ShutdownHook class specifies a routine to be invoked when the
-  # java runtime is shutdown.
-  class ShutdownHook < java.lang.Thread
-    attr_reader :server
-
-    def initialize(server)
-      super()
-      @server = server
-      java.lang.Runtime.runtime.add_shutdown_hook(self)
-    end
-
-    def run
-      $stdout.write "\r\e[0K"
-      $stdout.flush
-      ::Server.log.info 'Shutting down'
-      server.shutdown if server.respond_to?(:shutdown)
-    end
-  end
-end