tcp-server 1.0.6-java → 1.0.9-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: adb40677b97f1b1ce0fb1fad9308d527d3086c927044f5e71d1e378c5e0d8e25
-  data.tar.gz: 7e489022262138faae081772672bb99ca5eef415f943ff2b9cf96120390cb984
+  metadata.gz: c707938b3d92a5bd20d128d6f09bfcbbc50ff56f0d4c34006c40b27815b299c3
+  data.tar.gz: 01bb7897ee596c304ff32bf6dbb2ac5b380bc9f45cad86d0f39479515a4f07b5
 SHA512:
-  metadata.gz: 1d8afb5280d5a8bfe5dd234dcb5f0dfb26558543074b917de3c39bd08cd5331319a32bd764400d7183fa8814d8b978a57532306dfb2b7464c28cc58aacc5c732
-  data.tar.gz: 8a6c94c3ee130ea33a8c4e95009b75414d9622916b4277a38664f3f08d3f238d787941c9c0e7ed5c566a2c3efd2b2d064dda83f0cdce513fd95036c08c959e09
+  metadata.gz: 8cff7fdc5fbae7e1e7521bda5cd6b335a3c7f7822e1362b5a284d62a5a81b71f466dd52519c2c6f12389eb425fa262fc066ec0b756bf502391ae04841b581e37
+  data.tar.gz: bc42f07bfe23e91f9626de066f233ace69987e624950ed81d7724ee2ec8e5095d2475446f58a7a5b8d35c123b9201c98abf5a7a8d11fb6cb01636313c0584532

data/README.md

@@ -18,7 +18,9 @@ You may run the websocket server in a container. The [`colima`](https://github.c
 
 ```sh
 colima start
-docker-compose up
+docker-compose up --detach
+nc localhost 4000
+docker-compose down
 ```
 
 Building the image or running the container:
@@ -57,8 +59,7 @@ Download and install the latest version of [JRuby].
 
 ```sh
 asdf plugin add ruby
-pushd "${HOME}/.asdf/plugins/ruby/ruby-build"; git fetch origin; git pull origin master; popd
-# ~/.asdf/plugins/ruby/bin/list-all
+asdf plugin update --all
 asdf list all ruby
 asdf install ruby jruby-9.3.4.0
 ```
@@ -123,7 +124,7 @@ Here is a bird's-eye view of the project layout.
 
 ```sh
 # date && tree -I "logs|vendor|tmp"
-Thu Jun 16 00:03:23 CDT 2022
+Wed Jul 20 13:18:23 CDT 2022
 .
 ├── Dockerfile
 ├── Gemfile
@@ -157,14 +158,14 @@ Thu Jun 16 00:03:23 CDT 2022
 │   ├── test_spec.rb
 │   └── verify
 │       └── verify_spec.rb
-├── tcp-server-1.0.2-java.gem
 ├── tcp-server-jruby.gemspec
 ├── tcp_server.png
 └── tcp_server.rb
 
-5 directories, 31 files
+5 directories, 30 files
 ```
 
+
 ## CI linting
 
 Use the GitLab CI Linting API to validate the syntax of a CI definition file.
@@ -173,12 +174,13 @@ Use the GitLab CI Linting API to validate the syntax of a CI definition file.
 jq --null-input --arg yaml "$(<.gitlab/ci/gem.gitlab-ci.yml)" '.content=$yaml' | curl --silent --location https://gitlab.com/api/v4/ci/lint --header "PRIVATE-TOKEN: ${GITLAB_COM_API_PRIVATE_TOKEN}" --header "Content-Type: application/json" --data @- | jq --raw-output '.errors[0]'
 ```
 
+
 ## CI configuration
 
 Generate a deploy key.
 
 ```sh
-ssh-keygen -t ed25519 -C deploy_key
+ssh-keygen -t ed25519 -P '' -C deploy_key -f deploy_key_ed25519
 ```
 
 Use the GitLab Project-level Variables API to add the deploy key as a ssh private key variable.
@@ -186,18 +188,21 @@ Use the GitLab Project-level Variables API to add the deploy key as a ssh privat
 ```sh
 project_path="nelsnelson/$(basename $(pwd))"
 
+# Test auth token validity
+curl --silent --show-error --location "https://gitlab.com/api/v4/projects" --header "PRIVATE-TOKEN: ${GITLAB_COM_API_PRIVATE_TOKEN}" | jq '.[0]["id"]'
+
 project=$(curl --silent --show-error --location "https://gitlab.com/api/v4/search?scope=projects&search=${project_path}" --header "PRIVATE-TOKEN: ${GITLAB_COM_API_PRIVATE_TOKEN}" | jq --arg project_path "${project_path}" '.[] | select(.path_with_namespace == $project_path)')
 
 project_id=$(curl --silent --show-error --location "https://gitlab.com/api/v4/search?scope=projects&search=${project_path}" --header "PRIVATE-TOKEN: ${GITLAB_COM_API_PRIVATE_TOKEN}" | jq --arg project_path "${project_path}" '.[] | select(.path_with_namespace == $project_path) | .id')
 
 # Add the deploy_token as a CI variable:
-curl --silent --show-error --location --request POST "https://gitlab.com/api/v4/projects/${project_id}/variables" --header "PRIVATE-TOKEN: ${GITLAB_COM_API_PRIVATE_TOKEN}" --form "key=SSH_PRIVATE_KEY" --form "value=$(cat ./deploy_token)" --form "protected=true" | jq
+curl --silent --show-error --location --request POST "https://gitlab.com/api/v4/projects/${project_id}/variables" --header "PRIVATE-TOKEN: ${GITLAB_COM_API_PRIVATE_TOKEN}" --form "key=SSH_PRIVATE_KEY" --form "value=$(cat ./deploy_key_ed25519)" --form "protected=true" | jq
 ```
 
 Use the Deploy keys API to add a the public deploy key as a deploy key for the project.
 
 ```sh
-curl --silent --show-error --location --request POST "https://gitlab.com/api/v4/projects/${project_id}/deploy_keys" --header "PRIVATE-TOKEN: ${GITLAB_COM_API_PRIVATE_TOKEN}" --data '{"title": "deploy_key", "key": "$(cat ./deploy_token.pub)", "can_push": "true"}' | jq
+curl --silent --show-error --location --request POST "https://gitlab.com/api/v4/projects/${project_id}/deploy_keys" --header "PRIVATE-TOKEN: ${GITLAB_COM_API_PRIVATE_TOKEN}" --form "title=deploy_key"  --form "key=$(cat ./deploy_key_ed25519.pub)" --form "can_push=true" | jq
 ```
 
 [license]: https://gitlab.com/nelsnelson/tcp-server-jruby/blob/master/LICENSE

data/lib/client.rb

@@ -12,11 +12,12 @@
 #
 # =end
 
-require 'optparse'
-
 require 'java'
 require 'netty'
 
+require 'logger'
+require 'optparse'
+
 require 'log'
 
 # The Client module
@@ -26,16 +27,18 @@ end
 
 # The Client module
 module Client
-  # The Config module
-  module Config
-    DEFAULTS = {
+  def client_config
+    @client_config ||= {
+      host: '0.0.0.0',
       port: 8080,
-      host: 'localhost',
       ssl: false,
-      quit_commands: %i[bye quit],
-      log_level: Logger::INFO
+      log_level: Logger::INFO,
+      quit_commands: %i[bye cease desist exit leave quit stop terminate],
+      max_frame_length: 8192,
+      delimiter: Java::io.netty.handler.codec.Delimiters.lineDelimiter
     }.freeze
   end
+  module_function :client_config
 end
 
 # The Client module
@@ -77,8 +80,8 @@ module Client
     end
 
     def configure_handlers(*handlers, &block)
-      ::Client::ChannelInitializer::DefaultHandler.add_listener(self)
-      listeners.addAll(handlers)
+      channel_initializer.default_handler.add_listener(self)
+      channel_initializer.default_handler.listeners.addAll(handlers)
       @user_app = block
       @application_handler = lambda do |ctx, msg|
         if @user_app.nil? || @user_app.arity == 1
@@ -100,7 +103,7 @@ module Client
   # The InstanceMethods module
   module InstanceMethods
     def puts(msg)
-      sleep 0.1 until @channel.isActive()
+      wait_until_channel_is_active
       msg.chomp!
       log.trace "#puts msg: #{msg.inspect}"
       raise 'Message is empty!' if msg.nil? || msg.empty?
@@ -115,6 +118,10 @@ module Client
       nil
     end
 
+    def wait_until_channel_is_active(timeout = 5, give_up = Time.now + timeout)
+      sleep 0.1 until @channel.active? || Time.now > give_up
+    end
+
     def connect(host = @options[:host], port = @options[:port])
       return unless @channel.nil?
       # Start the connection attempt.
@@ -143,7 +150,7 @@ module Client
 
     def session
       when_client_has_shut_down(@client_group) do |group|
-        log.debug "Channel group has shut down: #{group.inspect}"
+        log.debug "Channel group has shut down: #{group}"
       end
       @user_app.nil? ? read_user_commands : invoke_user_app
     end
@@ -176,13 +183,13 @@ module Client
 
     def channel_unregistered(ctx)
       log.trace "##{__method__} channel: #{ctx.channel}"
-      shutdown
+      # shutdown
     end
 
     def message_received(ctx, message)
       notify :message_received, ctx, message
       if @application_handler.nil?
-        $stdout.puts message.chomp unless message.nil?
+        $stdout.print message.chomp unless message.nil?
       else
         @application_handler.call(ctx, message)
       end
@@ -197,10 +204,11 @@ module Client
     def read_user_commands
       log.trace 'Reading user commands'
       loop do
+        log.debug 'Waiting for user input...'
         input = $stdin.gets
         raise 'Poll failure from stdin' if input.nil?
         break unless @channel.active?
-        break if execute_command(input).is_a?(AbstractChannel::CloseFuture)
+        break unless execute_command(input).nil?
       end
     end
 
@@ -222,23 +230,32 @@ module Client
       @listeners ||= java.util.concurrent.CopyOnWriteArrayList.new
     end
 
-    def add_listener(listener)
-      listeners << listener
+    def add_listener(*listener)
+      listeners.addAll(listener)
+    ensure
+      log.trace "Listeners: #{listeners}"
     end
 
-    def remove_listener(listener)
-      listeners.delete(listener)
+    def remove_listener(*listener)
+      listeners.removeAll(listener)
     end
 
-    def notify(message, *args)
-      return if listeners.empty?
-      log.trace "Notifying listeners (#{listeners}) of message: #{message}"
+    def replace_listeners(*listener)
+      listeners.clear
+      add_listener(*listener)
+    end
+
+    def notify(event, *args)
       listeners.each do |listener|
-        listener.send(message.to_sym, *args) if listener.respond_to?(message.to_sym)
+        next unless listener.respond_to?(event.to_sym)
+        log.trace "Notifying listener #{listener} of event: #{event}"
+        listener.send(event.to_sym, *args)
       end
     end
   end
+  # module Listenable
 end
+# module Client
 
 # The Client module
 module Client
@@ -342,13 +359,7 @@ module Client
 
   # The ChannelInitializer class
   class ChannelInitializer < Java::io.netty.channel.ChannelInitializer
-    DefaultHandler = ::Client::ModularHandler.new
-    FrameDecoderBufferSize = 8192 # bytes
-    # The encoder and decoder are sharable. If they were not, then
-    # constant definitions could not be used.
-    Decoder = StringDecoder.new
-    Encoder = StringEncoder.new
-    attr_accessor :handlers
+    attr_accessor :decoder, :encoder, :handlers
 
     def initialize(options = {})
       super()
@@ -356,6 +367,8 @@ module Client
       @host = @options[:host]
       @port = @options[:port]
       @handlers = []
+      @decoder = StringDecoder.new
+      @encoder = StringEncoder.new
     end
 
     def <<(handler)
@@ -365,13 +378,19 @@ module Client
     def initChannel(channel)
       pipeline = channel.pipeline
       pipeline.addLast(ssl_handler(channel)) if @options[:ssl]
-      pipeline.addLast(
-        DelimiterBasedFrameDecoder.new(FrameDecoderBufferSize, Delimiters.lineDelimiter()),
-        Decoder,
-        Encoder
-      )
+      # pipeline.addLast(frame_decoder)
+      pipeline.addLast(decoder)
+      pipeline.addLast(encoder)
       add_user_handlers(pipeline)
-      pipeline.addLast(DefaultHandler)
+      pipeline.addLast(default_handler)
+    end
+
+    def frame_decoder
+      DelimiterBasedFrameDecoder.new(@options[:max_frame_length], @options[:delimiter])
+    end
+
+    def default_handler
+      @default_handler ||= ::Client::ModularHandler.new
     end
 
     protected
@@ -424,7 +443,7 @@ module TCP
     include ::Client::Listenable
 
     def initialize(options = {}, *handlers, &block)
-      init(::Client::Config::DEFAULTS.merge(options))
+      init(::Client.client_config.merge(options))
       configure_handlers(*handlers, &block)
       connect
       session
@@ -444,32 +463,32 @@ end
 module Client
   # The ArgumentsParser class
   class ArgumentsParser
-    Flags = %i[banner port ssl log_level help version].freeze
     attr_reader :parser, :options
 
-    def initialize(parser = OptionParser.new, options = ::Client::Config::DEFAULTS.dup)
+    def initialize(parser = OptionParser.new, options = ::Client.client_config.dup)
       @parser = parser
       @options = options
-      Flags.each { |method_name| method(method_name).call }
+      @flags = %i[banner port ssl log_level help version]
+      @flags.each { |method_name| method(method_name)&.call if respond_to?(method_name) }
     end
 
     def banner
-      @parser.banner = "Usage: #{File.basename($PROGRAM_NAME)} [host] [port] [options]"
+      @parser.banner = "Usage: #{File.basename($PROGRAM_NAME)} [options] <hostname> [port]"
       @parser.separator ''
       @parser.separator 'Options:'
     end
 
     def host
       description = "Connect to server at this host; default: #{@options[:host]}"
-      @parser.on('-h', '--host=<host>s', description) do |v|
+      @parser.on('-h', '--hostname=<hostname>', description) do |v|
         @options[:host] = v
       end
     end
 
-    IntegerPattern = /^\d+$/.freeze
+    def validated_port(val, integer_pattern = /^\d+$/)
+      raise OptionParser::InvalidArgument, "Invalid port: #{val}" unless \
+        integer_pattern.match?(val.to_s) && val.positive? && val < 65_536
 
-    def validated_port(val)
-      raise "Invalid port: #{v}" unless IntegerPattern.match?(val.to_s) && val.positive? && val < 65_536
       val
     end
 
@@ -488,6 +507,7 @@ module Client
 
     def log_level
       @parser.on_tail('-v', '--verbose', 'Increase verbosity') do
+        @options[:log_level] ||= 0
         @options[:log_level] -= 1
       end
     end
@@ -505,19 +525,28 @@ module Client
         exit
       end
     end
+
+    def parse_positional_arguments!
+      @options[:host] = ARGV.shift or raise OptionParser::MissingArgument, 'hostname'
+      return if (given_port = ARGV.shift&.to_i).nil?
+
+      @options[:port] = validated_port(given_port).to_i
+    end
   end
   # class ArgumentsParser
 
-  # rubocop: disable Metrics/AbcSize
   def parse_arguments(arguments_parser = ArgumentsParser.new)
     arguments_parser.parser.parse!(ARGV)
-    arguments_parser.options[:host] = v.to_s unless (v = ARGV.shift).nil?
-    arguments_parser.options[:port] = validated_port(v).to_i unless (v = ARGV.shift).nil?
+    arguments_parser.parse_positional_arguments!
     arguments_parser.options
-  rescue OptionParser::InvalidOption, OptionParser::AmbiguousOption => e
+  rescue OptionParser::InvalidArgument, OptionParser::InvalidOption,
+         OptionParser::MissingArgument, OptionParser::NeedlessArgument => e
+    puts e.message
+    puts parser
+    exit
+  rescue OptionParser::AmbiguousOption => e
     abort e.message
   end
-  # rubocop: enable Metrics/AbcSize
 end
 # module Client
 
@@ -538,12 +567,12 @@ end
 
 # The Client module
 module Client
-  # The ConsoleHandler class
-  class ConsoleHandler
+  # The Console class
+  class Console
     def message_received(ctx, message)
       log.trace "##{__method__} channel: #{ctx.channel}, message: #{message}"
       log.debug "Received message: #{message}"
-      puts message.chomp unless message.nil?
+      $stdout.print message unless message.nil?
     end
   end
 end
@@ -557,8 +586,7 @@ module Client
   # rubocop: disable Metrics/MethodLength
   def main(args = parse_arguments)
     Logging.log_level = args[:log_level]
-    handlers = [::Client::Monitor.new, ::Client::ConsoleHandler.new]
-    ::TCP::Client.new(args, *handlers)
+    ::TCP::Client.new(args, ::Client::Console.new, ::Client::Monitor.new)
   rescue Interrupt => e
     warn format(InterruptTemplate, class: e.class)
     exit

data/lib/log.rb

@@ -12,56 +12,98 @@ require 'logger'
 
 require 'log4j-2'
 
+require 'fileutils'
+
+# 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'))
+      server_log_file = File.expand_path(File.join(logs_dir_path, 'server.log'))
+      {
+        level: :info,
+        name: 'tcp-server',
+        lib_dir_path: lib_dir_path,
+        project_dir_path: project_dir_path,
+        logs_dir_path: logs_dir_path,
+        server_log_file: server_log_file,
+        rolling_log_file_name_template: 'server-%d{yyyy-MM-dd}.log.gz',
+        logger_pattern_template: '%d{ABSOLUTE} %-5p [%c{1}] %m%n',
+        schedule: '0 0 0 * * ?',
+        size: '100M'
+      }
+    end
+  end
+  module_function :config
+  # rubocop: enable Metrics/MethodLength
+end
+
 # The LogInitialization module
 module LogInitialization
-  LibDirPath = File.expand_path(__dir__) unless defined?(LibDirPath)
-  ProjectDirPath = File.expand_path(File.dirname(LibDirPath)) unless defined?(ProjectDirPath)
-  LogsDirPath = File.expand_path(File.join(ProjectDirPath, 'logs'))
-  Dir.mkdir(LogsDirPath) unless File.exist?(LogsDirPath)
-  ServerLogFile = File.join(LogsDirPath, 'server.log')
-  RollLogFileNameTemplate = 'server-%d{yyyy-MM-dd}.log.gz'.freeze
-  RollingLogFilePath = File.join(LogsDirPath, RollLogFileNameTemplate)
-  File.write(ServerLogFile, '') unless File.file? ServerLogFile
-  LoggerPatternTemplate = '%d{ABSOLUTE} %-5p [%c{1}] %m%n'.freeze
+  def init
+    init_log_file
+    init_log4j if defined? Java
+  end
+  module_function :init
+
+  def init_log_file
+    FileUtils.mkdir_p(Logging.config[:logs_dir_path])
+    return if File.file?(Logging.config[:server_log_file])
+
+    File.write(Logging.config[:server_log_file], '')
+  end
+  module_function :init_log_file
 
   # rubocop: disable Metrics/AbcSize
   # rubocop: disable Metrics/MethodLength
-  def self.init_log4j(log_level = org.apache.logging.log4j.Level::INFO)
+  def init_log4j(log_level = org.apache.logging.log4j.Level::INFO)
+    server_log_file = Logging.config[:server_log_file]
+    logs_dir_path = Logging.config[:logs_dir_path]
+    rolling_log_file_name_template = Logging.config[:rolling_log_file_name_template]
+    rolling_log_file_path = File.join(logs_dir_path, rolling_log_file_name_template)
+
     java.lang::System.setProperty('log4j.shutdownHookEnabled', java.lang::Boolean.toString(false))
     factory = org.apache.logging.log4j.core.config.builder.api::ConfigurationBuilderFactory
     config = factory.newConfigurationBuilder()
 
-    log_level = org.apache.logging.log4j.Level.to_level(log_level.to_s.upcase) if log_level.is_a?(Symbol)
+    if log_level.is_a?(Symbol)
+      log_level = org.apache.logging.log4j.Level.to_level(
+        log_level.to_s.upcase
+      )
+    end
     config.setStatusLevel(log_level)
-    config.setConfigurationName('websocket')
+    config.setConfigurationName(Logging.config['name'])
 
-    # create a console appender
+    # Create a console appender
     target = org.apache.logging.log4j.core.appender::ConsoleAppender::Target::SYSTEM_OUT
     layout = config.newLayout('PatternLayout')
-    layout = layout.addAttribute('pattern', LoggerPatternTemplate)
+    layout = layout.addAttribute('pattern', Logging.config[:logger_pattern_template])
     appender = config.newAppender('stdout', 'CONSOLE')
     appender = appender.addAttribute('target', target)
     appender = appender.add(layout)
     config.add(appender)
 
-    # create a root logger
+    # Create a root logger
     root_logger = config.newRootLogger(log_level)
     root_logger = root_logger.add(config.newAppenderRef('stdout'))
 
-    # create a rolling file appender
+    # Create a rolling file appender
     cron = config.newComponent('CronTriggeringPolicy')
-    cron = cron.addAttribute('schedule', '0 0 0 * * ?')
+    cron = cron.addAttribute('schedule', Logging.config[:schedule])
 
     size = config.newComponent('SizeBasedTriggeringPolicy')
-    size = size.addAttribute('size', '100M')
+    size = size.addAttribute('size', Logging.config[:size])
 
     policies = config.newComponent('Policies')
     policies = policies.addComponent(cron)
     policies = policies.addComponent(size)
 
     appender = config.newAppender('rolling_file', 'RollingFile')
-    appender = appender.addAttribute('fileName', ServerLogFile)
-    appender = appender.addAttribute('filePattern', RollingLogFilePath)
+    appender = appender.addAttribute('fileName', server_log_file)
+    appender = appender.addAttribute('filePattern', rolling_log_file_path)
     appender = appender.add(layout)
     appender = appender.addComponent(policies)
     config.add(appender)
@@ -77,10 +119,11 @@ module LogInitialization
   # rubocop: enable Metrics/AbcSize
   # rubocop: enable Metrics/MethodLength
   # def init_log4j
+  module_function :init_log4j
 end
 # module LogInitialization
 
-::LogInitialization.init_log4j if defined? Java
+::LogInitialization.init
 
 # The Apache log4j Logger class
 # rubocop: disable Style/ClassAndModuleChildren
@@ -113,35 +156,14 @@ end
 
 # The Logging module
 module Logging
-  # rubocop: disable Style/MutableConstant
-  Configuration = {
-    level: Logger::INFO
-  }
-  # rubocop: enable Style/MutableConstant
-
-  def self.log_level=(log_level)
-    Logging::Configuration[:level] = log_level
-  end
-
-  def self.log_level
-    Logging::Configuration[:level]
-  end
-
-  def log(level = Logging.log_level, log_name = nil)
-    @log ||= init_logger(level, log_name)
-  end
-  alias logger log
-
-  protected
-
-  def init_logger(level = Logging.log_level, logger_name = nil)
+  def init_logger(level = :all, logger_name = nil)
     return init_java_logger(level, logger_name, caller[2]) if defined?(Java)
-    Logging.init_ruby_logger(level, logger_name)
+    init_ruby_logger(level)
   end
 
-  def init_ruby_logger(level, logger_name = nil)
-    logger_instance = Logger.new(logger_name)
-    logger_instance.level = level
+  def init_ruby_logger(level)
+    logger_instance = Logger.new
+    logger_instance.level = Logging::Level.to_level(level.to_s.upcase)
     logger_instance
   end
 
@@ -149,9 +171,8 @@ module Logging
   def init_java_logger(level, logger_name = nil, source_location = nil)
     logger_name = get_formatted_logger_name(logger_name)
     logger_name = source_location.split(/\//).last if logger_name.empty?
-    level_name = symbolize_numeric_log_level(level).to_s.upcase
     logger_instance = org.apache.logging.log4j.LogManager.getLogger(logger_name)
-    logger_instance.level = org.apache.logging.log4j.Level.to_level(level_name)
+    logger_instance.level = org.apache.logging.log4j.Level.to_level(level.to_s.upcase)
     logger_instance
   end
   # rubocop: enable Metrics/AbcSize
@@ -185,6 +206,22 @@ module Logging
     end
   end
   # rubocop: enable Metrics/CyclomaticComplexity
+  module_function :symbolize_numeric_log_level
+
+  def log_level=(log_level)
+    Logging.config[:level] = symbolize_numeric_log_level(log_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 = nil)
+    @log ||= init_logger(level, log_name)
+  end
+  alias logger log
 end
 # module Logging
 

data/lib/server/argument_parser.rb

@@ -18,16 +18,13 @@ require_relative 'config'
 module Server
   # The ArgumentsParser class
   class ArgumentsParser
-    Flags = %i[
-      banner port ssl idle_reading idle_writing log_requests log_level help
-      version
-    ].freeze
     attr_reader :parser, :options
 
     def initialize(option_parser = OptionParser.new)
       @parser = option_parser
-      @options = ::Server::Config::DEFAULTS.dup
-      Flags.each { |method_name| method(method_name).call }
+      @options = ::Server.server_config.dup
+      @flags = %i[banner port ssl idle_reading idle_writing log_requests log_level help version]
+      @flags.each { |method_name| method(method_name).call }
     end
 
     def banner
@@ -36,10 +33,10 @@ module Server
       @parser.separator 'Options:'
     end
 
-    IntegerPattern = /^\d+$/.freeze
+    def validated_port(val, integer_pattern = /^\d+$/)
+      raise OptionParser::InvalidArgument, "Invalid port: #{v}" unless \
+        integer_pattern.match?(val.to_s) && val.positive? && val < 65_536
 
-    def validated_port(val)
-      raise "Invalid port: #{v}" unless IntegerPattern.match?(val.to_s) && val.positive? && val < 65_536
       val
     end
 
@@ -76,7 +73,8 @@ module Server
 
     def log_level
       @parser.on_tail('-v', '--verbose', 'Increase verbosity') do
-        @options[:log_level] -= 1
+        current_level = @options.fetch(:log_level, 0)
+        @options[:log_level] = current_level - 1
       end
     end
 

data/lib/server/channel_initializer.rb

@@ -30,19 +30,16 @@ module Server
 
   # The ChannelInitializer class
   class ChannelInitializer < Java::io.netty.channel.ChannelInitializer
-    FrameDecoderBufferBytesSize = 8192
-    # The encoder and decoder are sharable. If they were not, then
-    # constant definitions could not be used.
-    Decoder = StringDecoder.new
-    Encoder = StringEncoder.new
-    attr_accessor :user_handlers
+    attr_accessor :decoder, :encoder, :user_handlers
     attr_reader :options
 
     def initialize(channel_group, options = {})
       super()
       @channel_group = channel_group
       @options = options
-      @user_handlers = []
+      @user_handlers = @options.fetch(:handlers, [])
+      @decoder = StringDecoder.new
+      @encoder = StringEncoder.new
     end
 
     def <<(handler)
@@ -52,21 +49,25 @@ module Server
     def initChannel(channel)
       pipeline = channel.pipeline
       pipeline.addLast(ssl_handler(channel)) if @options[:ssl]
-      pipeline.addLast(
-        DelimiterBasedFrameDecoder.new(FrameDecoderBufferBytesSize, Delimiters.lineDelimiter),
-        Decoder,
-        Encoder
-      )
+      pipeline.addLast(frame_decoder, @decoder, @encoder)
       add_user_handlers(pipeline)
       pipeline.addLast(default_handler)
     end
 
+    def frame_decoder
+      DelimiterBasedFrameDecoder.new(@options[:max_frame_length], @options[:delimiter])
+    end
+
     def default_handler
       @default_handler ||= ::Server::ModularHandler.new(@channel_group)
     end
 
-    def add_listener(listener)
-      default_handler.add_listener(listener)
+    def add_listener(*listeners)
+      default_handler.add_listener(*listeners)
+    end
+
+    def replace_listeners(*listeners)
+      default_handler.replace_listener(*listeners)
     end
 
     protected

data/lib/server/config.rb

@@ -10,13 +10,15 @@
 #
 # =end
 
+require 'netty'
+
 require 'logger'
 
 # The Server module
 module Server
-  # The Config module
-  module Config
-    DEFAULTS = {
+  # rubocop: disable Metrics/MethodLength
+  def server_config
+    @server_config ||= {
       host: '0.0.0.0',
       port: 8080,
       ssl: false,
@@ -24,7 +26,11 @@ module Server
       idle_writing: 30, # seconds
       log_requests: false,
       log_level: Logger::INFO,
-      quit_commands: %i[bye quit]
+      quit_commands: %i[bye cease desist exit leave quit stop terminate],
+      max_frame_length: 8192,
+      delimiter: Java::io.netty.handler.codec.Delimiters.lineDelimiter
     }.freeze
   end
+  module_function :server_config
+  # rubocop: enable Metrics/MethodLength
 end

data/lib/server/instance_methods.rb

@@ -96,8 +96,12 @@ module Server
       channel_initializer << handler
     end
 
-    def add_listener(listener)
-      channel_initializer.add_listener(listener)
+    def add_listener(*listeners)
+      channel_initializer.add_listener(*listeners)
+    end
+
+    def replace_listeners(*listeners)
+      channel_initializer.replace_listener(*listeners)
     end
   end
   # module ServerInstanceMethods

data/lib/server/listenable.rb

@@ -20,19 +20,26 @@ module Server
       @listeners ||= java.util.concurrent.CopyOnWriteArrayList.new
     end
 
-    def add_listener(listener)
-      listeners << listener
+    def add_listener(*listener)
+      listeners.addAll(listener)
+    ensure
+      log.trace "Listeners: #{listeners}"
     end
 
-    def remove_listener(listener)
-      listeners.delete(listener)
+    def remove_listener(*listener)
+      listeners.removeAll(listener)
     end
 
-    def notify(message, *args)
-      return if listeners.empty?
-      log.trace "Notifying listeners (#{listeners}) of message: #{message}"
+    def replace_listeners(*listener)
+      listeners.clear
+      add_listener(*listener)
+    end
+
+    def notify(event, *args)
       listeners.each do |listener|
-        listener.send(message.to_sym, *args) if listener.respond_to?(message.to_sym)
+        next unless listener.respond_to?(event.to_sym)
+        log.trace "Notifying listener #{listener} of event: #{event}"
+        listener.send(event.to_sym, *args)
       end
     end
   end

data/lib/server/message_handler.rb

@@ -39,17 +39,17 @@ module Server
     end
 
     def messageReceived(ctx, msg)
-      log.trace "##{__method} channel: #{ctx.channel}, message: #{msg.inspect}"
+      log.trace "##{__method__} channel: #{ctx.channel}, message: #{msg.inspect}"
       msg&.chomp!
       log.info "Received message: #{msg}"
-      return super(ctx, msg) unless respond_to?(:handle_message) && @handler.arity == 2
+      return super(ctx, msg) unless respond_to?(:handle_message) && @handler&.arity == 2
       handle_message(ctx, msg)
     end
 
     def handle_message(ctx, message)
       request = message.to_s.strip
       response = @handler.call(ctx.channel, request).to_s.chomp
-      log.debug "response: #{response}"
+      log.debug "##{__method__} response: #{response}"
       ctx.channel.writeAndFlush("#{response}\n")
     end
   end

data/lib/server/modular_handler.rb

@@ -45,7 +45,7 @@ module Server
     end
 
     def channelActive(ctx)
-      log.trace "##{__method__} channel: #{ctx.channel}"
+      log.info "##{__method__} channel: #{ctx.channel}"
       @channel_group.add(ctx.channel)
       notify :channel_active, ctx
       super(ctx)

data/lib/server/server.rb

@@ -25,7 +25,7 @@ module Server
     attr_reader :options
 
     def initialize(params = {}, &block)
-      @options = ::Server::Config::DEFAULTS.merge(params.fetch(:options, {}))
+      @options = ::Server.server_config.merge(params.fetch(:options, {}))
       configure_handlers(&block)
     end
 

data/lib/server/version.rb

@@ -12,5 +12,5 @@
 
 # The Server module
 module Server
-  VERSION = '1.0.6'.freeze
+  VERSION = '1.0.9'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tcp-server
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.9
 platform: java
 authors:
 - Nels Nelson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-06-22 00:00:00.000000000 Z
+date: 2022-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement