tcp-server 1.0.1-java

data/lib/client.rb

@@ -0,0 +1,578 @@
+#! /usr/bin/env jruby
+
+# 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 'java'
+require 'netty'
+
+require 'log'
+
+# The Client module
+module Client
+  VERSION = '1.0.1'.freeze unless defined?(VERSION)
+end
+
+# The Client module
+module Client
+  # The Config module
+  module Config
+    DEFAULTS = {
+      port: 8080,
+      host: 'localhost',
+      ssl: false,
+      quit_commands: %i[bye quit],
+      log_level: Logger::INFO
+    }.freeze
+  end
+end
+
+# The Client module
+module Client
+  java_import Java::io.netty.bootstrap.Bootstrap
+  java_import Java::io.netty.channel.ChannelOption
+  java_import Java::io.netty.channel.nio.NioEventLoopGroup
+  java_import Java::io.netty.handler.ssl.SslContextBuilder
+  java_import Java::io.netty.handler.ssl.util.InsecureTrustManagerFactory
+
+  # The InitializationMethods module
+  module InitializationMethods
+    def init(options)
+      @options = options
+      @host = @options[:host]
+      @port = @options[:port]
+      @queue = java.util.concurrent.LinkedBlockingQueue.new
+    end
+
+    def bootstrap
+      @bootstrap = Bootstrap.new
+      @bootstrap.group(client_group)
+      @bootstrap.channel(::TCP::CHANNEL_TYPE)
+      @bootstrap.option(ChannelOption::TCP_NODELAY, true)
+      @bootstrap.handler(logging_handler) if @options[:log_requests]
+      @bootstrap.handler(channel_initializer)
+    end
+
+    def client_group
+      @client_group ||= NioEventLoopGroup.new
+    end
+
+    def channel_initializer
+      @channel_initializer ||= ::Client::ChannelInitializer.new(@options)
+    end
+
+    def logging_handler
+      @logging_handler ||= LoggingHandler.new(LogLevel::INFO)
+    end
+
+    def configure_handlers(*handlers, &block)
+      ::Client::ChannelInitializer::DefaultHandler.add_listener(self)
+      listeners.addAll(handlers)
+      @user_app = block
+      @application_handler = lambda do |ctx, msg|
+        if @user_app.nil? || @user_app.arity == 1
+          @queue.add(msg.chomp)
+        else
+          @user_app.call(ctx, msg)
+        end
+      end
+    end
+  end
+  # module InitializationMethods
+end
+# module Client
+
+# The Client module
+module Client
+  java_import Java::io.netty.channel.AbstractChannel
+
+  # The InstanceMethods module
+  module InstanceMethods
+    def puts(msg)
+      sleep 0.1 until @channel.isActive()
+      msg.chomp!
+      log.trace "#puts msg: #{msg.inspect}"
+      raise 'Message is empty!' if msg.nil? || msg.empty?
+      @last_write_future = @channel.writeAndFlush("#{msg}\n")
+    end
+
+    def gets
+      log.debug 'Waiting for response from server'
+      @queue.take
+    rescue StandardError => e
+      warn "Unexpected error waiting for message: #{e.message}"
+      nil
+    end
+
+    def connect(host = @options[:host], port = @options[:port])
+      return unless @channel.nil?
+      # Start the connection attempt.
+      @channel = bootstrap.connect(host, port).sync().channel()
+    rescue AbstractChannel::AnnotatedConnectException => e
+      raise e.message
+    rescue StandardError => e
+      raise "Connection failure: #{e.message}"
+    end
+
+    def close(channel = @channel)
+      log.debug "Closing client channel: #{channel}"
+      channel.closeFuture().sync()
+      # Wait until all messages are flushed before closing the channel.
+      @last_write_future&.sync()
+    ensure
+      shutdown
+    end
+
+    def shutdown
+      log.debug 'Shutting down gracefully'
+      @client_group&.shutdownGracefully()
+    ensure
+      client_has_shut_down
+    end
+
+    def session
+      when_client_has_shut_down(@client_group) do |group|
+        log.debug "Channel group has shut down: #{group.inspect}"
+      end
+      @user_app.nil? ? read_user_commands : invoke_user_app
+    end
+
+    def invoke_user_app
+      @user_app&.call(self)
+    ensure
+      close
+    end
+
+    def shut_down_callbacks
+      @shut_down_callbacks ||= []
+    end
+
+    def when_client_has_shut_down(*args, &block)
+      shut_down_callbacks << {
+        block: block,
+        args: args
+      }
+      self
+    end
+
+    def client_has_shut_down
+      shut_down_callbacks.take_while do |callback|
+        callback[:block]&.call(*callback.fetch(:args, []))
+      end
+    rescue StandardError => e
+      log.error e.message
+    end
+
+    def channel_unregistered(ctx)
+      log.trace "##{__method__} channel: #{ctx.channel}"
+      shutdown
+    end
+
+    def message_received(ctx, message)
+      notify :message_received, ctx, message
+      if @application_handler.nil?
+        $stdout.puts message.chomp unless message.nil?
+      else
+        @application_handler.call(ctx, message)
+      end
+    end
+
+    def execute_command(str, client = self)
+      return if str.empty?
+      client.puts str
+      close if @options[:quit_commands].include?(str.downcase.to_sym)
+    end
+
+    def read_user_commands
+      log.trace 'Reading user commands'
+      loop do
+        input = $stdin.gets
+        raise 'Poll failure from stdin' if input.nil?
+        break unless @channel.active?
+        break if execute_command(input).is_a?(AbstractChannel::CloseFuture)
+      end
+    end
+
+    IdentiferTemplate = '#<%<class>s:0x%<id>s @options=%<opts>s>'.freeze
+
+    def to_s
+      format(IdentiferTemplate, class: self.class.name, id: object_id.to_s(16), opts: @options.to_s)
+    end
+  end
+  # module InstanceMethods
+end
+# module Client
+
+# The Client module
+module Client
+  # 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
+end
+
+# The Client module
+module Client
+  # java_import Java::io.netty.channel.ChannelInboundHandlerAdapter
+  java_import Java::io.netty.channel.SimpleChannelInboundHandler
+
+  # The ModularHandler class
+  # class ModularHandler < ChannelInboundHandlerAdapter
+  class ModularHandler < SimpleChannelInboundHandler
+    include ::Client::Listenable
+
+    def isSharable
+      true
+    end
+
+    def channelRegistered(ctx)
+      log.trace "##{__method__} channel: #{ctx.channel}"
+      notify :channel_registered, ctx
+      super(ctx)
+    end
+
+    def channelUnregistered(ctx)
+      log.trace "##{__method__} channel: #{ctx.channel}"
+      notify :channel_unregistered, ctx
+      super(ctx)
+    end
+
+    def channelActive(ctx)
+      ::Client.log.info "Channel active #{ctx.channel}"
+      notify :channel_active, ctx
+      super(ctx)
+    end
+
+    def channelInactive(ctx)
+      log.trace "##{__method__} channel: #{ctx.channel}"
+      notify :channel_inactive, ctx
+      super(ctx)
+    end
+
+    def messageReceived(ctx, msg)
+      log.trace "##{__method__} channel: #{ctx.channel}, message: #{msg.inspect}"
+      notify :message_received, ctx, msg
+    end
+
+    def channelRead(ctx, msg)
+      log.trace "##{__method__} channel: #{ctx.channel}, message: #{msg.inspect}"
+      notify :channel_read, ctx, msg
+      super(ctx, msg)
+    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 channelReadComplete(ctx)
+      log.trace "##{__method__} channel: #{ctx.channel}"
+      notify :channel_read_complete, ctx
+      super(ctx)
+    end
+
+    def channelWritabilityChanged(ctx)
+      log.trace "##{__method__} channel: #{ctx.channel}"
+      notify :channel_writability_changed, ctx
+      super(ctx)
+    end
+
+    def userEventTriggered(ctx, evt)
+      log.trace "##{__method__} channel: #{ctx.channel}, event: #{evt}"
+      notify :user_event_triggered, ctx, evt
+      super(ctx, evt)
+    end
+
+    def exceptionCaught(ctx, cause)
+      ::Client.log.warn "##{__method__} channel: #{ctx.channel}, cause: #{cause.message}"
+      listeners = notify :exception_caught, ctx, cause
+      super(ctx, cause) if listeners.empty?
+    end
+
+    IdentiferTemplate = '#<%<class>s:0x%<id>s>'.freeze
+
+    def to_s
+      format(IdentiferTemplate, class: self.class.name, id: object_id.to_s(16))
+    end
+    alias inspect to_s
+  end
+  # class ModularHandler
+end
+# module Client
+
+# The Client module
+module Client
+  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
+
+  # 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
+
+    def initialize(options = {})
+      super()
+      @options = options
+      @host = @options[:host]
+      @port = @options[:port]
+      @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(FrameDecoderBufferSize, 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'
+      builder = SslContextBuilder.forClient()
+      @ssl_ctx = builder.trustManager(InsecureTrustManagerFactory::INSTANCE).build()
+    end
+
+    def ssl_handler(channel, ssl_ctx = ssl_context)
+      return ssl_ctx.newHandler(channel.alloc(), @host, @port) 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_engine(ssl_ctx)
+      ssl_engine = ssl_ctx.createSSLEngine()
+      ssl_engine.setUseClientMode(true) # Client mode
+      ssl_engine.setNeedClientAuth(false)
+      ssl_engine
+    end
+  end
+  # class ChannelInitializer
+end
+# module Client
+
+# The TCP module
+module TCP
+  CHANNEL_TYPE = Java::io.netty.channel.socket.nio.NioSocketChannel.java_class
+
+  # The Client class
+  class Client
+    include ::Client::InitializationMethods
+    include ::Client::InstanceMethods
+    include ::Client::Listenable
+
+    def initialize(options = {}, *handlers, &block)
+      init(::Client::Config::DEFAULTS.merge(options))
+      configure_handlers(*handlers, &block)
+      connect
+      session
+    end
+
+    IdentiferTemplate = '#<%<class>s:0x%<id>s>'.freeze
+
+    def to_s
+      format(IdentiferTemplate, class: self.class.name, id: object_id.to_s(16))
+    end
+    alias inspect to_s
+  end
+end
+# module Client
+
+# The Client module
+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)
+      @parser = parser
+      @options = options
+      Flags.each { |method_name| method(method_name).call }
+    end
+
+    def banner
+      @parser.banner = "Usage: #{File.basename($PROGRAM_NAME)} [host] [port] [options]"
+      @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|
+        @options[:host] = v
+      end
+    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 = "Connect to server at this port; 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('--ssl', "Secure connection with TLSv1.3; default: #{@options[:ssl]}") do
+        @options[:ssl] = 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 "#{$PROGRAM_NAME} version #{Version}"
+        exit
+      end
+    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.options
+  rescue OptionParser::InvalidOption, OptionParser::AmbiguousOption => e
+    abort e.message
+  end
+  # rubocop: enable Metrics/AbcSize
+end
+# module Client
+
+# The Client module
+module Client
+  # The Monitor class
+  class Monitor
+    def exception_caught(ctx, cause)
+      log.warn "Unexpected exception from downstream channel #{ctx.channel}: #{cause.message}"
+    end
+
+    def channel_registered(ctx)
+      log.info "Channel registered: #{ctx.channel}"
+    end
+  end
+end
+# module Client
+
+# The Client module
+module Client
+  # The ConsoleHandler class
+  class ConsoleHandler
+    def message_received(ctx, message)
+      log.trace "##{__method__} channel: #{ctx.channel}, message: #{message}"
+      log.debug "Received message: #{message}"
+      puts message.chomp unless message.nil?
+    end
+  end
+end
+# module Client
+
+# The Client module
+module Client
+  InterruptTemplate = "\r%<class>s".freeze
+
+  # rubocop: disable Metrics/AbcSize
+  # 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)
+  rescue Interrupt => e
+    warn format(InterruptTemplate, class: e.class)
+    exit
+  rescue RuntimeError => e
+    ::Client.log.fatal e.message
+    exit 1
+  rescue StandardError => e
+    ::Client.log.fatal "Unexpected error: #{e.class}: #{e.message}"
+    e.backtrace.each { |t| log.debug t } if Logging.log_level == Logger::DEBUG
+    exit 1
+  end
+  # rubocop: enable Metrics/AbcSize
+  # rubocop: enable Metrics/MethodLength
+end
+# module Client
+
+Object.new.extend(Client).main if $PROGRAM_NAME == __FILE__