tcp-server 1.0.1-java

data/lib/log.rb

@@ -0,0 +1,207 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# =begin
+
+# Copyright Nels Nelson 2016-2019 but freely usable (see license)
+
+# =end
+
+require 'java'
+require 'logger'
+
+require 'log4j-2'
+
+# 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
+
+  # rubocop: disable Metrics/AbcSize
+  # rubocop: disable Metrics/MethodLength
+  def self.init_log4j(log_level = org.apache.logging.log4j.Level::INFO)
+    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)
+    config.setStatusLevel(log_level)
+    config.setConfigurationName('websocket')
+
+    # create a console appender
+    target = org.apache.logging.log4j.core.appender::ConsoleAppender::Target::SYSTEM_OUT
+    layout = config.newLayout('PatternLayout')
+    layout = layout.addAttribute('pattern', LoggerPatternTemplate)
+    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', ServerLogFile)
+    appender = appender.addAttribute('filePattern', RollingLogFilePath)
+    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 = org.apache.logging.log4j.core.config::Configurator.initialize(logging_configuration)
+    ctx.updateLoggers()
+  end
+  # rubocop: enable Metrics/AbcSize
+  # rubocop: enable Metrics/MethodLength
+  # def init_log4j
+end
+# module LogInitialization
+
+::LogInitialization.init_log4j if defined? Java
+
+# The Apache log4j Logger class
+# rubocop: disable Style/ClassAndModuleChildren
+class org.apache.logging.log4j.core::Logger
+  alias log4j_error error
+  def error(error_or_message, error = nil)
+    return extract_backtrace(error_or_message) if error.nil?
+    log4j_error(generate_message(error_or_message, error))
+    extract_backtrace(error)
+  end
+
+  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)
+    log4j_error(error)
+    if error.respond_to?(:backtrace)
+      error.backtrace.each { |trace| log4j_error(trace) unless trace.nil? }
+    elsif error.respond_to?(:getStackTrace)
+      error.getStackTrace().each { |trace| log4j_error(trace) unless trace.nil? }
+    else
+      default_result
+    end
+  end
+end
+# rubocop: enable Style/ClassAndModuleChildren
+
+# 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)
+    return init_java_logger(level, logger_name, caller[2]) if defined?(Java)
+    Logging.init_ruby_logger(level, logger_name)
+  end
+
+  def init_ruby_logger(level, logger_name = nil)
+    logger_instance = Logger.new(logger_name)
+    logger_instance.level = level
+    logger_instance
+  end
+
+  # rubocop: disable Metrics/AbcSize
+  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
+  end
+  # rubocop: enable Metrics/AbcSize
+
+  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 -2..-Float::INFINITY then :all
+    end
+  end
+  # rubocop: enable Metrics/CyclomaticComplexity
+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/argument_parser.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# =begin
+#
+# Copyright Nels Nelson 2016-2022 but freely usable (see license)
+#
+# =end
+
+require 'optparse'
+
+require_relative 'config'
+
+# The Server module
+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 }
+    end
+
+    def banner
+      @parser.banner = "Usage: #{File.basename($PROGRAM_NAME)} [port] [options]"
+      @parser.separator ''
+      @parser.separator 'Options:'
+    end
+
+    IntegerPattern = /^\d+$/.freeze
+
+    def validated_port(val)
+      raise "Invalid port: #{v}" unless IntegerPattern.match?(val.to_s) && val.positive? && val < 65_536
+      val
+    end
+
+    def port
+      description = "Port on which to listen for connections; default: #{@options[:port]}"
+      @parser.on('-p', '--port=<port>', Integer, description) do |v|
+        @options[:port] = validated_port(v).to_i
+      end
+    end
+
+    def ssl
+      @parser.on('-s', '--ssl', "Enable SSL socket server; default: #{@options[:ssl]}") do
+        @options[:ssl] = true
+      end
+    end
+
+    def idle_reading
+      @parser.on('--idle-reading=seconds', 'Amount of time channel can idle without incoming data') do |v|
+        @options[:idle_reading] = v.to_i
+      end
+    end
+
+    def idle_writing
+      @parser.on('--idle-writing=seconds', 'Amount of time channel can idle without outgoing data') do |v|
+        @options[:idle_writing] = v.to_i
+      end
+    end
+
+    def log_requests
+      @parser.on('-r', '--log-requests', 'Include individual request info in log output') do
+        @options[:log_requests] = true
+      end
+    end
+
+    def log_level
+      @parser.on_tail('-v', '--verbose', 'Increase verbosity') do
+        @options[:log_level] -= 1
+      end
+    end
+
+    def help
+      @parser.on_tail('-?', '--help', 'Show this message') do
+        puts @parser
+        exit
+      end
+    end
+
+    def version
+      @parser.on_tail('--version', 'Show version') do
+        puts "#{File.basename($PROGRAM_NAME)} version #{::Server::VERSION}"
+        exit
+      end
+    end
+  end
+  # class ArgumentsParser
+
+  def parse_arguments(arguments_parser = ::Server::ArgumentsParser.new)
+    arguments_parser.parser.parse!(ARGV)
+    arguments_parser.options
+  rescue OptionParser::InvalidOption, OptionParser::AmbiguousOption => e
+    abort e.message
+  end
+end
+# module Server

data/lib/server/channel_initializer.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# =begin
+#
+# Copyright Nels Nelson 2016-2022 but freely usable (see license)
+#
+# =end
+
+require 'java'
+require 'netty'
+
+require_relative 'message_handler'
+require_relative 'modular_handler'
+
+# The Server module
+module Server
+  java_import Java::io.netty.handler.codec.DelimiterBasedFrameDecoder
+  java_import Java::io.netty.handler.codec.Delimiters
+  java_import Java::io.netty.handler.codec.string.StringDecoder
+  java_import Java::io.netty.handler.codec.string.StringEncoder
+  java_import Java::io.netty.handler.ssl.SslContextBuilder
+  java_import Java::io.netty.handler.ssl.SslHandler
+  java_import Java::io.netty.handler.ssl.util.InsecureTrustManagerFactory
+  java_import Java::io.netty.handler.ssl.util.SelfSignedCertificate
+  java_import Java::io.netty.util.concurrent.FutureListener
+
+  # The ChannelInitializer class
+  class ChannelInitializer < Java::io.netty.channel.ChannelInitializer
+    DefaultHandler = ModularHandler.new
+    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 :handlers
+    attr_reader :options
+
+    def initialize(options = {})
+      super()
+      @options = options
+      @handlers = []
+    end
+
+    def <<(handler)
+      @handlers << handler
+    end
+
+    def initChannel(channel)
+      pipeline = channel.pipeline
+      pipeline.addLast(ssl_handler(channel)) if @options[:ssl]
+      pipeline.addLast(
+        DelimiterBasedFrameDecoder.new(FrameDecoderBufferBytesSize, Delimiters.lineDelimiter),
+        Decoder,
+        Encoder
+      )
+      add_user_handlers(pipeline)
+      pipeline.addLast(DefaultHandler)
+    end
+
+    protected
+
+    def add_user_handlers(pipeline)
+      @handlers.each do |handler|
+        case handler
+        when Class then pipeline.addLast(handler.new)
+        when Proc then pipeline.addLast(Server::MessageHandler.new(&handler))
+        else pipeline.addLast(handler)
+        end
+      end
+    end
+
+    private
+
+    def ssl_context
+      return @ssl_ctx unless @ssl_ctx.nil?
+      log.debug 'Initializing SSL context'
+      require 'bouncycastle'
+      ssc = SelfSignedCertificate.new
+      builder = SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey())
+      @ssl_ctx = builder.trustManager(InsecureTrustManagerFactory::INSTANCE).build()
+    end
+
+    def ssl_handler_instance(channel, ssl_ctx = ssl_context)
+      return ssl_ctx.newHandler(channel.alloc()) if ssl_ctx.respond_to?(:newHandler)
+      log.warn 'The SSL context did not provide a handler initializer'
+      log.warn 'Creating handler with SSL engine of the context'
+      SslHandler.new(ssl_engine(ssl_ctx))
+    end
+
+    def ssl_handler(channel)
+      handler = ssl_handler_instance(channel)
+      handler.handshake_future.addListener(SslHandshakeFutureListener.new)
+      handler
+    end
+
+    # The SslHandshakeFutureListener class
+    class SslHandshakeFutureListener
+      include FutureListener
+      # @Override
+      #
+      # public void operationComplete(Future<Channel> future) throws Exception
+      def operationComplete(future)
+        raise future.cause unless future.success?
+        session = future.now.pipeline.get('SslHandler#0')&.engine&.session
+        ::Server.log.info "Channel protocol: #{session.protocol}, cipher suite: #{session.cipher_suite}"
+      rescue StandardError => e
+        ::Server.log.warn e.message
+      end
+    end
+
+    def ssl_engine(ssl_ctx)
+      ssl_engine = ssl_ctx.createSSLEngine()
+      ssl_engine.setUseClientMode(false) # Server mode
+      ssl_engine.setNeedClientAuth(false)
+      ssl_engine
+    end
+  end
+  # class ChannelInitializer
+end
+# module Server

data/lib/server/config.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# =begin
+#
+# Copyright Nels Nelson 2016-2022 but freely usable (see license)
+#
+# =end
+
+require 'logger'
+
+# The Server module
+module Server
+  # The Config module
+  module Config
+    DEFAULTS = {
+      host: '0.0.0.0',
+      port: 8080,
+      ssl: false,
+      idle_reading: 5 * 60, # seconds
+      idle_writing: 30, # seconds
+      log_requests: false,
+      log_level: Logger::INFO,
+      quit_commands: %i[bye quit]
+    }.freeze
+  end
+end

data/lib/server/instance_methods.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# =begin
+#
+# Copyright Nels Nelson 2016-2022 but freely usable (see license)
+#
+# =end
+
+require 'java'
+require 'netty'
+
+require_relative 'channel_initializer'
+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.nio.NioEventLoopGroup
+  java_import Java::io.netty.handler.logging.LogLevel
+  java_import Java::io.netty.handler.logging.LoggingHandler
+
+  # The InstanceMethods module
+  module InstanceMethods
+    def configure_handlers(&block)
+      ::Server::ChannelInitializer::DefaultHandler.add_listener(self)
+      channel_initializer << block if block_given?
+    end
+
+    def bootstrap
+      @bootstrap = ServerBootstrap.new
+      @bootstrap.group(boss_group, worker_group)
+      @bootstrap.channel(::Server::CHANNEL_TYPE)
+      @bootstrap.option(ChannelOption::SO_BACKLOG, 100.to_java(java.lang.Integer))
+      @bootstrap.handler(logging_handler) if options[:log_requests]
+      @bootstrap.childHandler(channel_initializer)
+    end
+
+    def channel_initializer
+      @channel_initializer ||= ::Server::ChannelInitializer.new(@options)
+    end
+
+    def boss_group
+      @boss_group ||= NioEventLoopGroup.new(2)
+    end
+
+    def worker_group
+      @worker_group ||= NioEventLoopGroup.new
+    end
+
+    def logging_handler
+      @logging_handler ||= LoggingHandler.new(LogLevel::INFO)
+    end
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/MethodLength
+    def run(port = @options[:port])
+      channel = bootstrap.bind(port).sync().channel()
+      ::Server::Channels.add(channel)
+      ::Server::ShutdownHook.new(self)
+      log.info "Listening on #{channel.local_address}"
+      channel.closeFuture().sync()
+    rescue java.lang.IllegalArgumentException => e
+      raise "Invalid argument: #{e.message}"
+    rescue java.net.BindException => e
+      raise "Bind error: #{e.message}: #{options[:host]}:#{port}"
+    rescue java.net.SocketException => e
+      raise "Socket error: #{e.message}: #{options[:host]}:#{port}"
+    ensure
+      boss_group&.shutdownGracefully()
+      worker_group&.shutdownGracefully()
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/MethodLength
+
+    def shutdown
+      ::Server::Channels.disconnect().awaitUninterruptibly()
+      ::Server::Channels.close().awaitUninterruptibly()
+    end
+
+    def <<(handler)
+      channel_initializer << handler
+    end
+  end
+  # module ServerInstanceMethods
+end
+# module Server

data/lib/server/listenable.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# =begin
+#
+# Copyright Nels Nelson 2016-2022 but freely usable (see license)
+#
+# =end
+
+require 'java'
+
+# The Server module
+module Server
+  # The Listenable module
+  module Listenable
+    def listeners
+      @listeners ||= java.util.concurrent.CopyOnWriteArrayList.new
+    end
+
+    def add_listener(listener)
+      listeners << listener
+    end
+
+    def remove_listener(listener)
+      listeners.delete(listener)
+    end
+
+    def notify(message, *args)
+      return if listeners.empty?
+      log.trace "Notifying listeners (#{listeners}) of message: #{message}"
+      listeners.each do |listener|
+        listener.send(message.to_sym, *args) if listener.respond_to?(message.to_sym)
+      end
+    end
+  end
+  # module Listenable
+end
+# module Server

data/lib/server/message_handler.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+# frozen_string_literal: false
+
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+# =begin
+#
+# Copyright Nels Nelson 2016-2022 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
+
+  # The MessageHandler class
+  class MessageHandler < SimpleChannelInboundHandler
+    include ChannelHandler
+    include ChannelFutureListener
+
+    def initialize(&handler)
+      super()
+      @handler = handler
+    end
+
+    # Please keep in mind that this method will be renamed to
+    # messageReceived(ChannelHandlerContext, I) in 5.0.
+    #
+    # 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}"
+      messageReceived(ctx, msg)
+    end
+
+    def messageReceived(ctx, msg)
+      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
+      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}"
+      ctx.channel.writeAndFlush("#{response}\n")
+    end
+  end
+end