websocket-server 1.0.1-java

data/lib/websocket/idle_handler.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'
+require 'netty'
+
+require_relative 'idle_state_user_event_handler'
+
+# The WebSocket module
+module WebSocket
+  java_import Java::io.netty.handler.codec.http.websocketx.TextWebSocketFrame
+
+  # The IdleHandler class handles idle channels detected by the
+  # server pipeline.
+  class IdleHandler < WebSocket::IdleStateUserEventHandler
+    def initialize
+      super()
+    end
+
+    def handle_idle_channel(ctx, _evt)
+      klass = self.class.name
+      log.debug "#{klass} < IdleStateUserEventHandler ##{__method__}"
+      message = TextWebSocketFrame.new("\nDisconnecting idle session\n")
+      # TODO: Test
+      ctx.writeAndFlush(message).sync
+      ctx.close
+      # ctx.channel.writeAndFlush(message).sync
+      # ctx.channel.disconnect().awaitUninterruptibly()
+      # ctx.channel.close().awaitUninterruptibly()
+    end
+  end
+end

data/lib/websocket/idle_state_user_event_handler.rb

@@ -0,0 +1,47 @@
+# 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.ChannelDuplexHandler
+  java_import Java::io.netty.handler.codec.http.websocketx.PingWebSocketFrame
+  java_import Java::io.netty.handler.timeout.IdleState
+
+  # The PingMessage class is just a convenient alias
+  # for the PingWebSocketFrame class.
+  PingMessage = Class.new(PingWebSocketFrame)
+
+  # The IdleStateUserEventHandler class specifies methods implementing
+  # what to do when the pipeline detects an idle channel.
+  class IdleStateUserEventHandler < ChannelDuplexHandler
+    def initialize
+      super()
+    end
+
+    # java_signature 'public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception'
+    def userEventTriggered(ctx, evt)
+      return unless evt.respond_to?(:state)
+      case evt.state
+      when IdleState::READER_IDLE
+        return handle_idle_channel(ctx, evt) if respond_to?(:handle_idle_channel)
+        message = TextWebSocketFrame.new("\nDisconnecting idle session\n")
+        ctx.writeAndFlush(message).sync
+        ctx.close
+      when IdleState::WRITER_IDLE
+        ctx.writeAndFlush(PingMessage.new)
+      end
+    end
+  end
+end

data/lib/websocket/instance_methods.rb

@@ -0,0 +1,127 @@
+# 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 WebSocket module
+module WebSocket
+  java_import Java::io.netty.bootstrap.ServerBootstrap
+  java_import Java::io.netty.channel.group.DefaultChannelGroup
+  java_import Java::io.netty.channel.nio.NioEventLoopGroup
+  java_import Java::io.netty.handler.logging.LoggingHandler
+  java_import Java::io.netty.handler.logging.LogLevel
+  java_import Java::io.netty.util.concurrent.GlobalEventExecutor
+
+  # The InstanceMethods module
+  module InstanceMethods
+    def configure_handlers(&block)
+      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.handler(logging_handler) if @options[:log_requests]
+      @bootstrap.childHandler(channel_initializer)
+    end
+
+    def channel_initializer
+      @channel_initializer ||= ::WebSocket::ChannelInitializer.new(channel_group, @options)
+    end
+
+    def boss_group
+      @boss_group ||= NioEventLoopGroup.new(2)
+    end
+
+    def worker_group
+      @worker_group ||= NioEventLoopGroup.new
+    end
+
+    def channel_group
+      @channel_group ||= DefaultChannelGroup.new('server_channels', GlobalEventExecutor::INSTANCE)
+    end
+
+    def logging_handler
+      LoggingHandler.new(LogLevel::INFO)
+    end
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/MethodLength
+    def run(params = {})
+      options.merge!(params)
+      channel = bootstrap.bind(port).sync().channel()
+      channel_group.add(channel)
+      ::WebSocket::ShutdownHook.new(self)
+      log.info "Listening on #{channel.local_address}"
+      channel.closeFuture().sync()
+    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
+      stop
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/MethodLength
+
+    IntegerPattern = /^\d+$/.freeze
+
+    def valid_port?(val)
+      IntegerPattern.match?(val.to_s) && val.positive? && val < 65_536
+    end
+
+    def given_port
+      value = (options[:ssl] ? options[:ssl_port] : options[:port]).to_i
+      raise 'Given port parameter is invalid' unless valid_port?(value)
+      value
+    end
+
+    def port
+      @port ||= given_port
+    end
+
+    def shutdown
+      channel_group.disconnect().awaitUninterruptibly()
+      channel_group.close().awaitUninterruptibly()
+    end
+
+    def stop
+      boss_group&.shutdownGracefully()
+      worker_group&.shutdownGracefully()
+    end
+
+    def <<(handler)
+      channel_initializer.handlers << handler
+    end
+
+    def add_listener(listener)
+      channel_initializer.add_listener(listener)
+    end
+
+    # def all_exist?(*files)
+    #   files.all? { |f| File.exist?(f) }
+    # end
+
+    # def init_ssl_context(certificate, private_key)
+    #   return certificate_key_pair(certificate, private_key) if all_exist?(certificate, private_key)
+    #   options[:use_jdk_ssl_provider] ? jdk_ssl_provider : self_signed_certificate
+    # end
+  end
+  # module ServerInstanceMethods
+end
+# module WebSocket

data/lib/websocket/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 WebSocket module
+module WebSocket
+  # 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 WebSocket

data/lib/websocket/message_handler.rb

@@ -0,0 +1,47 @@
+# 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 'frame_handler'
+
+# The WebSocket module
+module WebSocket
+  java_import Java::io.netty.channel.ChannelHandler
+  java_import Java::io.netty.channel.ChannelFutureListener
+  java_import Java::io.netty.handler.codec.http.websocketx.TextWebSocketFrame
+
+  # The MessageHandler class provides a method for specifying code
+  # to handle incoming messages and respond with the results from
+  # the given code.
+  class MessageHandler < WebSocket::FrameHandler
+    include ChannelHandler
+    include ChannelFutureListener
+
+    def initialize(&handler)
+      super()
+      @handler = handler
+    end
+
+    def handle_message(ctx, message)
+      request = message&.to_s&.strip
+      return if request.nil?
+      response = @handler.call(ctx, request)
+      return if response.nil?
+      log.debug "#{self.class}#handle_message response: #{response.chomp}"
+      ctx.channel.writeAndFlush(TextWebSocketFrame.new(response))
+      response
+    end
+  end
+end
+# module WebSocket

data/lib/websocket/response_helpers.rb

@@ -0,0 +1,83 @@
+# 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 'encoding'
+
+# The WebSocket module
+module WebSocket
+  java_import Java::io.netty.channel.ChannelFutureListener
+  java_import Java::io.netty.buffer.Unpooled
+  java_import Java::io.netty.handler.codec.http.DefaultFullHttpResponse
+  java_import Java::io.netty.handler.codec.http.HttpHeaderNames
+  java_import Java::io.netty.handler.codec.http.HttpVersion
+  java_import Java::io.netty.util.CharsetUtil
+
+  # The ResponseHelpers helpers
+  module ResponseHelpers
+    NonSpacesBeforeEOLPattern = %r{([^\s]+)$}.freeze
+
+    def index_listing(path)
+      results = `ls -la #{path}`.strip.split("\n")
+      results.shift
+      index = results.collect do |s|
+        s.gsub(NonSpacesBeforeEOLPattern) do |resource_name|
+          %(<a href="#{resource_name}">#{resource_name}</a>)
+        end
+      end.join '<br />'
+      "<html><pre>#{index}</pre></html>"
+    end
+
+    def send_listing(ctx, path)
+      response = DefaultFullHttpResponse.new(HttpVersion::HTTP_1_1, HttpResponseStatus::OK)
+      response.headers().set(HttpHeaderNames::CONTENT_TYPE, WebSocket::HtmlContentType)
+
+      html = index_listing(path)
+
+      buffer = Unpooled.copiedBuffer(html, WebSocket::Encoding)
+      response.content().writeBytes(buffer)
+      buffer.release()
+
+      # Close the connection as soon as the error message is sent.
+      ctx.writeAndFlush(response).addListener(ChannelFutureListener::CLOSE)
+    end
+
+    def send_redirect(ctx, redirect_to_uri)
+      response = DefaultFullHttpResponse.new(HttpVersion::HTTP_1_1, HttpResponseStatus::FOUND)
+      response.headers().set(HttpHeaderNames::LOCATION, redirect_to_uri)
+
+      # Close the connection as soon as the error message is sent.
+      ctx.writeAndFlush(response).addListener(ChannelFutureListener::CLOSE)
+    end
+
+    def send_error(ctx, status)
+      message = Unpooled.copiedBuffer("#{status}\r\n", CharsetUtil::UTF_8)
+      response = DefaultFullHttpResponse.new(HttpVersion::HTTP_1_1, status, message)
+      response.headers().set(HttpHeaderNames::CONTENT_TYPE, WebSocket::HtmlContentType)
+
+      # Close the connection as soon as the error message is sent.
+      ctx.writeAndFlush(response).addListener(ChannelFutureListener::CLOSE)
+    end
+
+    def send_not_modified(ctx, date)
+      response = DefaultFullHttpResponse.new(HttpVersion::HTTP_1_1, HttpResponseStatus::NOT_MODIFIED)
+      date_header(response, date)
+
+      # Close the connection as soon as the error message is sent.
+      ctx.writeAndFlush(response).addListener(ChannelFutureListener::CLOSE)
+    end
+  end
+  # module ResponseHelpers
+end
+# module WebSocket

data/lib/websocket/server.rb

@@ -0,0 +1,26 @@
+# 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 'tcp-server'
+
+require_relative 'instance_methods'
+
+# The WebSocket module
+module WebSocket
+  # The Server class sets up the netty server
+  class Server < ::Server::Server
+    include ::WebSocket::InstanceMethods
+  end
+end
+# module WebSocket

data/lib/websocket/shutdown_hook.rb

@@ -0,0 +1,36 @@
+# 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
+  # 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
+      ::WebSocket::Server.log.info 'Shutting down'
+      server.shutdown if server.respond_to?(:shutdown)
+    end
+  end
+end

data/lib/websocket/ssl_cipher_inspector.rb

@@ -0,0 +1,44 @@
+# 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.SimpleChannelInboundHandler
+  java_import Java::io.netty.handler.ssl.SslHandler
+
+  # The SslCipherInspector class enables debugging the details around
+  # cipher configuration and pipeline handling of SSL handshakes.
+  class SslCipherInspector < SimpleChannelInboundHandler
+    def initialize
+      super()
+    end
+
+    def channelRead(ctx, msg)
+      cipher_suite = cipher_suite ctx
+      log.info "Server communications are secured by #{cipher_suite}"
+      ctx.fireChannelRead(msg)
+    end
+
+    private
+
+    def cipher_suite(ctx)
+      # Confirm the SSL context has been loaded into the channel pipeline
+      ssl_handler = ctx.pipeline.get(SslHandler.java_class)
+      ssl_engine = ssl_handler.engine()
+      ssl_session = ssl_engine.getSession()
+      ssl_session.getCipherSuite()
+    end
+  end
+end

data/lib/websocket/ssl_context_initialization.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 'java'
+require 'netty'
+
+# The WebSocket module
+module WebSocket
+  # This module implements methods responsible for the
+  # initialization of an SSL context
+  module SslContextInitializationMethods
+    java_import Java::io.netty.handler.ssl.SslContextBuilder
+    java_import Java::io.netty.handler.ssl.SslProvider
+    java_import Java::io.netty.handler.ssl.util.SelfSignedCertificate
+    java_import java.io.FileInputStream
+    java_import java.io.BufferedInputStream
+    java_import java.io.ByteArrayOutputStream
+    java_import java.security.KeyFactory
+    java_import java.security.cert.CertificateFactory
+    java_import java.security.spec.PKCS8EncodedKeySpec
+
+    DefaultCertificateType = 'X.509'.freeze
+
+    def init_ssl(channel_initializer)
+      return unless options[:ssl] && channel_initializer.respond_to?(:ssl_context)
+      context = ssl_context
+      channel_initializer.ssl_context = context unless context.nil?
+    end
+
+    def ssl_context
+      @ssl_context ||= init_ssl_context(options[:ssl_certificate_file_path], options[:ssl_private_key_file_path])
+    end
+
+    def certificate_key_pair(certificate, private_key)
+      log.info "Securing socket layer using #{certificate} and #{private_key}"
+      certificate = read_certificate(certificate)
+      private_key = read_private_key(private_key)
+      SslContextBuilder.forServer(private_key, certificate).build()
+    end
+
+    def jdk_ssl_provider
+      log.info 'Securing socket layer using JDK self-signed certificate'
+      ssc = SelfSignedCertificate.new
+      context_builder = SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey())
+      context_builder.sslProvider(SslProvider::JDK).build()
+    end
+
+    def self_signed_certificate
+      log.info 'Securing socket layer using self-signed certificate'
+      ssc = SelfSignedCertificate.new
+      SslContextBuilder.forServer(ssc.certificate(), ssc.privateKey()).build()
+    end
+
+    def read_certificate(file_path)
+      file_input_stream = FileInputStream.new(file_path)
+      buffered_input_stream = BufferedInputStream.new(file_input_stream)
+      CertificateFactory.getInstance(DefaultCertificateType).generateCertificate(buffered_input_stream)
+    end
+
+    def read_private_key(file_path)
+      file_input_stream = FileInputStream.new(file_path)
+      buffered_input_stream = BufferedInputStream.new(file_input_stream)
+      decode_private_key(stream_data(buffered_input_stream))
+    ensure
+      close_streams(buffered_input_stream, file_input_stream)
+    end
+
+    def stream_data(input_stream, output_stream = ByteArrayOutputStream.new)
+      buffer = Java::byte[1024 * 4].new
+      loop do
+        n = input_stream.read(buffer)
+        break if n == -1
+        output_stream.write(buffer, 0, n)
+      end
+      output_stream.toByteArray()
+    ensure
+      close_streams(output_stream)
+    end
+
+    def close_streams(*streams)
+      streams.each { |stream| safely_close_stream(stream) }
+    end
+
+    def safely_close_stream(stream)
+      stream.close()
+    rescue StandardError => e
+      log.warn "Failed to close stream: #{e.message}"
+    end
+
+    def decode_private_key(encoded_private_key)
+      private_key_spec = PKCS8EncodedKeySpec.new(encoded_private_key)
+      KeyFactory.getInstance('RSA').generatePrivate(private_key_spec)
+    end
+  end
+  # module SslContextInitializationMethods
+end
+# module WebSocket

data/lib/websocket/telnet_proxy.rb

@@ -0,0 +1,22 @@
+# 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 TelnetProxy class adds a handler to the server channel
+  # pipeline which will proxy incoming requests to a telnet server.
+  class TelnetProxy
+    def initialize(host, port)
+      pipeline << TelnetProxyFrontendHandler.new(host, port)
+    end
+  end
+end

data/lib/websocket/validation_helpers.rb

@@ -0,0 +1,51 @@
+# 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 'encoding'
+
+# The WebSocket module
+module WebSocket
+  # The ValidationHelpers module
+  module ValidationHelpers
+    FileSeparatorDotPattern = %r{#{File::SEPARATOR}\.}.freeze
+    DotFileSeparatorPattern = %r{\.#{File::SEPARATOR}}.freeze
+
+    # Simplistic dumb security check.
+    # Something more serious is required in a production environment.
+    def insecure_uri?(uri)
+      FileSeparatorDotPattern.match?(uri) ||
+        DotFileSeparatorPattern.match?(uri) ||
+        uri.start_with?('.') ||
+        uri.end_with?('.') ||
+        options[:insecure_uri_pattern].match?(uri)
+    end
+
+    QueryStringPattern = %r{\?.*}.freeze
+    ForwardSlashPattern = %r{/}.freeze
+
+    def sanitize_uri(uri)
+      # Decode the path.
+      uri = CGI.unescape(uri.gsub(QueryStringPattern, ''), WebSocket::Encoding.name)
+      return nil if uri.empty? || !uri.start_with?('/')
+      # Convert file separators.
+      uri = uri.gsub(ForwardSlashPattern, File::SEPARATOR)
+      return nil if insecure_uri?(uri)
+      # Convert to absolute path.
+      File.join(options[:web_root], uri)
+    end
+  end
+  # module ValidationHelpers
+end
+# module WebSocket

data/lib/websocket/version.rb

@@ -0,0 +1,16 @@
+# 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
+  VERSION = '1.0.1'.freeze
+end