websocket-server 1.0.1-java

data/lib/websocket/arguments_parser.rb

@@ -0,0 +1,142 @@
+# 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 WebSocket module
+module WebSocket
+  # The ArgumentsParser class
+  class ArgumentsParser
+    Flags = %i[
+      banner port telnet_proxy_host telnet_proxy_port
+      ssl ssl_certificate ssl_private_key use_jdk_ssl_provider
+      inspect_ssl idle_reading idle_writing log_requests web_root
+      verbose help version
+    ].freeze
+    attr_reader :parser, :options
+
+    def initialize(option_parser = OptionParser.new)
+      @parser = option_parser
+      @options = ::WebSocket.server_config.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
+
+    def port
+      @parser.on_head('-p', '--port=port', 'Listen on this port for incoming connections') do |v|
+        @options[:port] = v.to_i
+      end
+    end
+
+    def telnet_proxy_host
+      @parser.on('--telnet-proxy-host=host', 'Remote telnet proxy host') do |v|
+        @options[:telnet_proxy_host] = v
+      end
+    end
+
+    def telnet_proxy_port
+      @parser.on('--telnet-proxy-port=port', 'Remote telnet proxy port') do |v|
+        @options[:telnet_proxy_port] = v.to_i
+      end
+    end
+
+    def ssl
+      @parser.on('-s', '--ssl', 'Use TLS/SSL') do |v|
+        @options[:ssl] = v
+      end
+    end
+
+    def ssl_certificate
+      @parser.on('-c', '--ssl-certificate=file', 'Path to ssl certificate file') do |v|
+        @options[:ssl_certificate_file_path] = v
+      end
+    end
+
+    def ssl_private_key
+      @parser.on('-k', '--ssl-private-key=file', 'Path to private key file') do |v|
+        @options[:ssl_private_key_file_path] = v
+      end
+    end
+
+    def use_jdk_ssl_provider
+      @parser.on('--use-jdk-ssl-provider', 'Use the JDK SSL provider') do
+        @options[:use_jdk_ssl_provider] = true
+      end
+    end
+
+    def inspect_ssl
+      @parser.on('--inspect-ssl', 'Verbosely log SSL messages for encryption confirmation') do
+        @options[:inspect_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 |v|
+        @options[:log_requests] = v
+      end
+    end
+
+    def web_root
+      @parser.on('-w', '--web-root=path', 'Set the web root to a specific path') do |v|
+        @options[:web_root] = v
+      end
+    end
+
+    def verbose
+      @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 #{WebSocket.version}"
+        exit
+      end
+    end
+  end
+  # class ArgumentsParser
+
+  def parse_arguments(arguments_parser = WebSocket::ArgumentsParser.new)
+    arguments_parser.parser.parse!(ARGV)
+    arguments_parser.options
+  rescue OptionParser::InvalidOption, OptionParser::AmbiguousOption => e
+    abort e.message
+  end
+end
+# module WebSocket

data/lib/websocket/channel_initializer.rb

@@ -0,0 +1,73 @@
+# 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 'http_static_file_server_handler'
+require_relative 'idle_handler'
+require_relative 'message_handler'
+
+# The WebSocket module
+module WebSocket
+  java_import Java::io.netty.handler.codec.http.HttpObjectAggregator
+  java_import Java::io.netty.handler.codec.http.HttpServerCodec
+  java_import Java::io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler
+  java_import Java::io.netty.handler.codec.http.websocketx.extensions.compression.WebSocketServerCompressionHandler
+  java_import Java::io.netty.handler.stream.ChunkedWriteHandler
+  java_import Java::io.netty.handler.timeout.IdleStateHandler
+
+  # The ChannelInitializer class programmatically specifies the
+  # configuration for the channel pipeline that will handle requests of
+  # the server.
+  class ChannelInitializer < ::Server::ChannelInitializer
+    HttpObjectAggregatorBufferBytesSize = 65_536
+
+    def initialize(channel_group, options = {})
+      super(channel_group, options)
+    end
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/MethodLength
+    def initChannel(channel)
+      pipeline = channel.pipeline
+      pipeline.addLast(ssl_handler(channel)) if @options[:ssl]
+      pipeline.addLast(HttpServerCodec.new)
+      pipeline.addLast(HttpObjectAggregator.new(HttpObjectAggregatorBufferBytesSize))
+      pipeline.addLast(ChunkedWriteHandler.new)
+      pipeline.addLast(IdleStateHandler.new(@options[:idle_reading], @options[:idle_writing], 0))
+      pipeline.addLast(WebSocket::IdleHandler.new)
+      pipeline.addLast(WebSocketServerCompressionHandler.new)
+      pipeline.addLast(WebSocketServerProtocolHandler.new(@options[:web_socket_path], nil, true))
+      pipeline.addLast(SslCipherInspector.new) if !ssl_context.nil? && @options[:inspect_ssl]
+      pipeline.addLast(HttpStaticFileServerHandler.new(@options))
+      add_user_handlers(pipeline)
+      pipeline.addLast(default_handler)
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/MethodLength
+
+    protected
+
+    def add_user_handlers(pipeline)
+      @user_handlers.each do |handler|
+        case handler
+        when Class then pipeline.addLast(handler.new)
+        when Proc then pipeline.addLast(::WebSocket::MessageHandler.new(&handler))
+        else pipeline.addLast(handler)
+        end
+      end
+    end
+  end
+  # class ServerInitializer
+end
+# module WebSocket

data/lib/websocket/config.rb

@@ -0,0 +1,59 @@
+# 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 WebSocket module
+module WebSocket
+  # rubocop: disable Metrics/MethodLength
+  def server_config
+    @server_config ||= begin
+      server_submodule_dir_path = File.expand_path(__dir__)
+      lib_dir_path = File.expand_path(File.dirname(server_submodule_dir_path))
+      project_dir_path = File.expand_path(File.dirname(lib_dir_path))
+      {
+        log_level: Logger::INFO,
+        host: '0.0.0.0',
+        port: 4000,
+        ssl_port: 443,
+        telnet_proxy_host: nil,
+        telnet_proxy_port: 21,
+        ssl: false,
+        ssl_certificate_file_path: File.join(project_dir_path, 'fullchain.pem'),
+        # openssl pkcs8 -topk8 -nocrypt -in websocket.key -out websocket_pcks8
+        #
+        # The privkey.key file here should be generated using the following
+        # openssl command:
+        #
+        #    openssl pkcs8 -topk8 -inform PEM -outform DER -in privkey.pem -nocrypt > privkey.key
+        #
+        ssl_private_key_file_path: File.join(project_dir_path, 'privkey.key'),
+        use_jdk_ssl_provider: false,
+        inspect_ssl: false,
+        idle_reading: 5 * 60, # seconds
+        idle_writing: 30, # seconds
+        index_page: 'index.html',
+        web_root: File.join(project_dir_path, 'web'),
+        web_socket_path: '/websocket',
+        ping_message: "ping\n",
+        http_date_format: '%a, %d %b %Y %H:%M:%S %Z', # EEE, dd MMM yyyy HH:mm:ss zzz
+        http_date_gmt_timezone: 'GMT',
+        http_cache_seconds: 60,
+        insecure_uri_pattern: /.*[<>&"].*/,
+        allowed_file_name: /[A-Za-z0-9][-_A-Za-z0-9\\.]*/,
+        log_requests: false
+      }
+    end
+  end
+  module_function :server_config
+  # rubocop: enable Metrics/MethodLength
+end

data/lib/websocket/encoding.rb

@@ -0,0 +1,21 @@
+# 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 WebSocket module
+module WebSocket
+  java_import Java::io.netty.util.CharsetUtil
+  Encoding = CharsetUtil::UTF_8
+  HtmlContentType = "text/html; charset=#{Encoding.name}".freeze
+end

data/lib/websocket/file_server_channel_progressive_future_listener.rb

@@ -0,0 +1,32 @@
+# 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
+
+# The WebSocket module
+module WebSocket
+  # The FileServerChannelProgressiveFutureListener class implements
+  # handler methods invoked within the server pipeline during a file
+  # transfer over a channel.
+  class FileServerChannelProgressiveFutureListener
+    def operationProgressed(future, progress, total)
+      if total.positive?
+        log.info "#{future.channel} Transfer progress: #{progress} / #{total}"
+      else # total unknown
+        log.info "#{future.channel} Transfer progress: #{progress}"
+      end
+    end
+
+    def operationComplete(future)
+      log.debug "#{future.channel} Transfer complete"
+    end
+  end
+end
+# module WebSocket

data/lib/websocket/frame_handler.rb

@@ -0,0 +1,71 @@
+# 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 WebSocket module
+module WebSocket
+  java_import Java::io.netty.channel.ChannelFutureListener
+  java_import Java::io.netty.channel.ChannelHandler
+  java_import Java::io.netty.handler.codec.http.FullHttpRequest
+  java_import Java::io.netty.handler.codec.http.websocketx.WebSocketFrame
+  java_import Java::io.netty.handler.codec.http.websocketx.TextWebSocketFrame
+
+  # The FrameHandler class implements a handler for incoming
+  # WebSocket request messages.  This handler invokes a #handle_message
+  # method which should be implemented by a user provided subclass.  The
+  # MessageHandler class is an example of one such subclass.
+  class FrameHandler < SimpleChannelInboundHandler
+    include ChannelHandler
+    include ChannelFutureListener
+    UnsupportedFrameTypeErrorTemplate =
+      '%<handler>s encountered unsupported frame type: %<frame>s'.freeze
+
+    def initialize
+      super(WebSocketFrame.java_class)
+    end
+
+    # Please keep in mind that this method will be renamed to
+    # messageReceived(ChannelHandlerContext, I) in 5.0.
+    #
+    # java_signature 'protected void channelRead0(ChannelHandlerContext ctx, WebSocketFrame frame) throws Exception'
+    def channelRead0(ctx, frame)
+      messageReceived(ctx, frame)
+    end
+
+    def handle_message(ctx, msg)
+      # Send the uppercase string back.
+      ctx.channel.writeAndFlush(TextWebSocketFrame.new(msg.to_s.strip.upcase))
+    end
+
+    def unsupported_frame(frame, handler)
+      raise java.lang.UnsupportedOperationException, format(
+        UnsupportedFrameTypeErrorTemplate, handler: handler.class, frame: frame.class
+      )
+    end
+
+    def messageReceived(ctx, frame)
+      # ping and pong frames already handled
+      case frame
+      when TextWebSocketFrame
+        unsupported_frame(frame, self) unless frame.respond_to?(:text)
+        handle_message(ctx, frame.text)
+      when FullHttpRequest
+        # Let another handler handle it.
+      else unsupported_frame(frame, self)
+      end
+    end
+  end
+  # class WebSocketFrameHandler
+end
+# module WebSocket

data/lib/websocket/header_helpers.rb

@@ -0,0 +1,70 @@
+# 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 '../server/mime_types'
+
+# The WebSocket module
+module WebSocket
+  java_import Java::io.netty.handler.codec.http.HttpHeaderValues
+
+  # The HeaderHelpers module
+  module HeaderHelpers
+    def keep_alive_header(response)
+      response.headers().set(HttpHeaderNames::CONNECTION, HttpHeaderValues::KEEP_ALIVE)
+    end
+
+    def date_header(response, date)
+      response.headers().set(HttpHeaderNames::DATE, date)
+    end
+
+    def expires_header(response, expires)
+      response.headers().set(HttpHeaderNames::EXPIRES, expires)
+    end
+
+    def cache_control_header(response, cache_control)
+      response.headers().set(HttpHeaderNames::CACHE_CONTROL, cache_control)
+    end
+
+    def last_modified_header(response, last_modified)
+      response.headers().set(HttpHeaderNames::LAST_MODIFIED, last_modified)
+    end
+
+    PrivateMaxAgeTempalte = 'private, max-age=%<max_age>s'.freeze
+
+    # rubocop: disable Metrics/AbcSize
+    def date_and_cache_headers(response, path, timestamp = Time.now)
+      maximum_age = options[:http_cache_seconds]
+      date_format = options[:http_date_format]
+      date_header(response, timestamp.strftime(date_format))
+      expires_header(response, Time.at(timestamp.to_i + maximum_age).strftime(date_format))
+      cache_control_header(response, format(PrivateMaxAgeTempalte, max_age: maximum_age.to_s))
+      last_modified_header(response, File.mtime(path).strftime(date_format))
+    end
+    # rubocop: enable Metrics/AbcSize
+
+    def content_type_header(response, content_type)
+      response.headers().set(HttpHeaderNames::CONTENT_TYPE, content_type)
+    end
+
+    def guess_content_type(path, _charset = nil)
+      i = path.rindex(/\./)
+      return nil if i == -1
+      extension = path[(i + 1)..].downcase.to_sym
+      ::Server::MimeTypes.fetch(extension, ::Server::MimeTypes[:txt])
+    end
+  end
+  # module HeaderHelpers
+end
+# module WebSocket

data/lib/websocket/http_static_file_server_handler.rb

@@ -0,0 +1,50 @@
+# 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 'http_static_file_server_handler_instance_methods'
+require_relative 'header_helpers'
+require_relative 'response_helpers'
+require_relative 'validation_helpers'
+
+# The WebSocket module
+module WebSocket
+  java_import Java::io.netty.channel.SimpleChannelInboundHandler
+  java_import Java::io.netty.handler.codec.http.FullHttpRequest
+
+  # The HttpStaticFileServerHandler class supports classical
+  # file server semantics.
+  class HttpStaticFileServerHandler < SimpleChannelInboundHandler
+    include WebSocket::HttpStaticFileServerHandlerInstanceMethods
+    include WebSocket::HeaderHelpers
+    include WebSocket::ResponseHelpers
+    include WebSocket::ValidationHelpers
+    attr_reader :options
+
+    def initialize(options = nil)
+      super(FullHttpRequest.java_class)
+      @options = options
+    end
+
+    # Please keep in mind that this method will be renamed to
+    # messageReceived(ChannelHandlerContext, I) in 5.0.
+    #
+    # protected abstract void channelRead0(ChannelHandlerContext ctx, I msg) throws Exception
+    def channelRead0(ctx, message)
+      messageReceived(ctx, message)
+    end
+  end
+  # class HttpStaticFileServerHandler
+end
+# module WebSocket

data/lib/websocket/http_static_file_server_handler_instance_methods.rb

@@ -0,0 +1,160 @@
+# 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 'cgi'
+require 'date'
+
+require 'java'
+require 'netty'
+
+require_relative 'file_server_channel_progressive_future_listener'
+
+# The WebSocket module
+module WebSocket
+  java_import Java::io.netty.channel.ChannelFutureListener
+  java_import Java::io.netty.channel.DefaultFileRegion
+  java_import Java::io.netty.handler.codec.http.DefaultHttpResponse
+  java_import Java::io.netty.handler.codec.http.HttpChunkedInput
+  java_import Java::io.netty.handler.codec.http.HttpResponseStatus
+  java_import Java::io.netty.handler.codec.http.HttpHeaderNames
+  java_import Java::io.netty.handler.codec.http.HttpMethod
+  java_import Java::io.netty.handler.codec.http.HttpVersion
+  java_import Java::io.netty.handler.codec.http.HttpUtil
+  java_import Java::io.netty.handler.codec.http.LastHttpContent
+  java_import Java::io.netty.handler.ssl.SslHandler
+  java_import Java::io.netty.handler.stream.ChunkedFile
+  java_import java.io.RandomAccessFile
+
+  # The HttpStaticFileServerHandlerInstanceMethods module
+  module HttpStaticFileServerHandlerInstanceMethods
+    ForwardSlashBeforeEOLPattern = %r{/$}.freeze
+    URIForwardSlashTemplate = '%<uri>s/'.freeze
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/CyclomaticComplexity
+    # rubocop: disable Metrics/MethodLength
+    # rubocop: disable Metrics/PerceivedComplexity
+    def messageReceived(ctx, request)
+      return if %r{^#{options[:web_socket_path]}$}.match?(request.uri)
+
+      unless request.decoderResult().isSuccess()
+        send_error(ctx, HttpResponseStatus::BAD_REQUEST)
+        return
+      end
+
+      unless request.method() == HttpMethod::GET
+        send_error(ctx, HttpResponseStatus::METHOD_NOT_ALLOWED)
+        return
+      end
+
+      uri = request.uri
+      path = sanitize_uri(uri)
+      if path.nil?
+        send_error(ctx, HttpResponseStatus::FORBIDDEN)
+        return
+      end
+
+      unless File.exist? path
+        send_error(ctx, HttpResponseStatus::NOT_FOUND)
+        return
+      end
+
+      if File.directory? path
+        if ForwardSlashBeforeEOLPattern.match?(uri)
+          send_listing(ctx, path)
+        else
+          send_redirect(ctx, format(URIForwardSlashTemplate, uri: uri))
+        end
+        return
+      end
+
+      unless File.exist? path
+        send_error(ctx, HttpResponseStatus::FORBIDDEN)
+        return
+      end
+
+      # Cache Validation
+      modified_since = request.headers().get(HttpHeaderNames::IF_MODIFIED_SINCE)
+      if !modified_since.nil? && !modified_since.empty?
+        file_last_modified = File.mtime(path).to_s
+        # Only compare up to the second because the format of the timestamp
+        # sent to the client does not include milliseconds
+        modified_since_seconds = DateTime.parse(modified_since).to_time.to_i
+        file_last_modified_seconds = DateTime.parse(file_last_modified).to_time.to_i
+
+        if modified_since_seconds == file_last_modified_seconds
+          send_not_modified(ctx, file_last_modified_seconds)
+          return
+        end
+      end
+
+      raf = nil
+      begin
+        raf = RandomAccessFile.new(path, 'r')
+      rescue StandardError => _e
+        send_error(ctx, HttpResponseStatus::NOT_FOUND)
+        return
+      end
+      file_length = raf.length
+
+      response = DefaultHttpResponse.new(HttpVersion::HTTP_1_1, HttpResponseStatus::OK)
+      HttpUtil.setContentLength(response, file_length)
+      content_type_header(response, guess_content_type(path))
+      date_and_cache_headers(response, path)
+      keep_alive_header(response) if HttpUtil.isKeepAlive(request)
+
+      # Write the initial line and the header.
+      ctx.write(response)
+
+      send_file_future = nil
+      last_content_future = nil
+      progressive_promise = ctx.newProgressivePromise()
+
+      # Write the content.
+      if ctx.pipeline().get(SslHandler.java_class)
+        # SSL enabled - cannot use zero-copy file transfer.
+        chunked_file = ChunkedFile.new(raf, 0, file_length, 8192)
+        chunked_input = HttpChunkedInput.new(chunked_file)
+        send_file_future = ctx.writeAndFlush(chunked_input, progressive_promise)
+        # HttpChunkedInput will write the end marker (LastHttpContent) for us.
+        last_content_future = send_file_future
+      else
+        # SSL not enabled - can use zero-copy file transfer.
+        file_region = DefaultFileRegion.new(raf.channel, 0, file_length)
+        send_file_future = ctx.write(file_region, progressive_promise)
+        # Write the end marker.
+        last_content_future = ctx.writeAndFlush(LastHttpContent::EMPTY_LAST_CONTENT)
+      end
+
+      send_file_future.addListener(FileServerChannelProgressiveFutureListener.new)
+
+      # Decide whether to close the connection or not.
+      return if HttpUtil.isKeepAlive(request)
+
+      # Close the connection when the whole content is written out.
+      last_content_future.addListener(ChannelFutureListener::CLOSE)
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/CyclomaticComplexity
+    # rubocop: enable Metrics/MethodLength
+    # rubocop: enable Metrics/PerceivedComplexity
+
+    def exceptionCaught(ctx, cause)
+      log.info "##{__method__} wtf2"
+      cause.printStackTrace()
+      return unless ctx.channel().isActive()
+      send_error(ctx, HttpResponseStatus::INTERNAL_SERVER_ERROR)
+    end
+  end
+  # module HttpStaticFileServerHandlerInstanceMethods
+end
+# module WebSocket