ruflet_server 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9ce7a082041b04a7208cf20bb1d541f6a4902361c5a31b1c188f509ebe321369
+  data.tar.gz: 4af18bd3e91a82bc38ce58f626005e20fb9e480bafe8ecefa768c81b77c9bf05
+SHA512:
+  metadata.gz: 9cdf0804b857072621d1a83156b13e7b1a9b799c3152182b50c91c1fb733e83e44965d6e197729ee1589519566c913ab2e4f0475c6faffc08e79749cbac119e8
+  data.tar.gz: b30664476e50b799ac372795314493f3f35c5f76643e0a8967e4ded5e7e934f49d1c808706bf7593fb15f71e2f71693fb3bad870c733470591dda3ba1e7012c5

data/README.md

@@ -0,0 +1,3 @@
+# ruflet_server
+
+Part of Ruflet monorepo.

data/lib/ruflet/server/web_socket_connection.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Ruflet
+  class WebSocketConnection
+    def initialize(socket)
+      @socket = socket
+      @write_mutex = Mutex.new
+    end
+
+    def session_key
+      @socket.object_id
+    end
+
+    def closed?
+      @socket.closed?
+    rescue IOError
+      true
+    end
+
+    def send_binary(payload)
+      send_frame(0x2, payload.to_s.b)
+    end
+
+    def send_text(payload)
+      send_frame(0x1, payload.to_s.b)
+    end
+
+    def read_message
+      frame = read_frame
+      return nil if frame.nil?
+
+      opcode = frame[:opcode]
+      payload = frame[:payload]
+
+      case opcode
+      when 0x8
+        close
+        nil
+      when 0x9
+        send_frame(0xA, payload)
+        read_message
+      when 0xA
+        read_message
+      when 0x1, 0x2
+        payload
+      else
+        read_message
+      end
+    end
+
+    def close
+      return if closed?
+
+      begin
+        @socket.close
+      rescue IOError
+        nil
+      end
+    end
+
+    private
+
+    def read_frame
+      header = read_exact(2)
+      return nil if header.nil?
+
+      b1 = header.getbyte(0)
+      b2 = header.getbyte(1)
+
+      masked = (b2 & 0x80) != 0
+      payload_len = b2 & 0x7f
+
+      payload_len = read_exact(2).unpack1("n") if payload_len == 126
+      payload_len = read_exact(8).unpack1("Q>") if payload_len == 127
+
+      masking_key = masked ? read_exact(4) : nil
+      payload = payload_len.zero? ? "".b : read_exact(payload_len)
+      return nil if payload.nil?
+
+      payload = unmask(payload, masking_key) if masked
+
+      { opcode: b1 & 0x0f, payload: payload }
+    end
+
+    def send_frame(opcode, payload)
+      bytes = payload.to_s.b
+      len = bytes.bytesize
+      header = [0x80 | (opcode & 0x0f)].pack("C")
+
+      header <<
+        if len <= 125
+          [len].pack("C")
+        elsif len <= 0xffff
+          [126].pack("C") + [len].pack("n")
+        else
+          [127].pack("C") + [len].pack("Q>")
+        end
+
+      @write_mutex.synchronize do
+        @socket.write(header)
+        @socket.write(bytes) unless bytes.empty?
+      end
+    end
+
+    def unmask(payload, mask)
+      out = +""
+      out.force_encoding(Encoding::BINARY)
+      payload.bytes.each_with_index do |byte, idx|
+        out << (byte ^ mask.getbyte(idx % 4))
+      end
+      out
+    end
+
+    def read_exact(length)
+      chunk = +""
+      chunk.force_encoding(Encoding::BINARY)
+
+      while chunk.bytesize < length
+        part = @socket.read(length - chunk.bytesize)
+        return nil if part.nil? || part.empty?
+
+        chunk << part
+      end
+
+      chunk
+    end
+  end
+end

data/lib/ruflet/server/wire_codec.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module Ruflet
+  class WireCodec
+    class << self
+      def pack(value)
+        case value
+        when NilClass
+          "\xc0".b
+        when TrueClass
+          "\xc3".b
+        when FalseClass
+          "\xc2".b
+        when Integer
+          pack_integer(value)
+        when Float
+          "\xcb".b + [value].pack("G")
+        when String
+          pack_string(value)
+        when Symbol
+          pack_string(value.to_s)
+        when Array
+          pack_array(value)
+        when Hash
+          pack_map(value)
+        else
+          pack_string(value.to_s)
+        end
+      end
+
+      def unpack(bytes)
+        reader = ByteReader.new(bytes)
+        read_value(reader)
+      end
+
+      private
+
+      def pack_integer(value)
+        if value >= 0
+          return [value].pack("C") if value <= 0x7f
+          return "\xcc".b + [value].pack("C") if value <= 0xff
+          return "\xcd".b + [value].pack("n") if value <= 0xffff
+          return "\xce".b + [value].pack("N") if value <= 0xffff_ffff
+
+          "\xcf".b + [value].pack("Q>")
+        else
+          return [value & 0xff].pack("C") if value >= -32
+          return "\xd0".b + [value].pack("c") if value >= -128
+          return "\xd1".b + [value].pack("s>") if value >= -32_768
+          return "\xd2".b + [value].pack("l>") if value >= -2_147_483_648
+
+          "\xd3".b + [value].pack("q>")
+        end
+      end
+
+      def pack_string(value)
+        str = value.to_s.dup.force_encoding("UTF-8")
+        bytes = str.b
+        len = bytes.bytesize
+
+        if len <= 31
+          [0xA0 | len].pack("C") + bytes
+        elsif len <= 0xff
+          "\xd9".b + [len].pack("C") + bytes
+        elsif len <= 0xffff
+          "\xda".b + [len].pack("n") + bytes
+        else
+          "\xdb".b + [len].pack("N") + bytes
+        end
+      end
+
+      def pack_array(value)
+        len = value.length
+        head =
+          if len <= 15
+            [0x90 | len].pack("C")
+          elsif len <= 0xffff
+            "\xdc".b + [len].pack("n")
+          else
+            "\xdd".b + [len].pack("N")
+          end
+
+        body = +"".b
+        value.each { |item| body << pack(item) }
+        head + body
+      end
+
+      def pack_map(value)
+        pairs = value.each_with_object({}) { |(k, v), out| out[k.to_s] = v }
+        len = pairs.length
+        head =
+          if len <= 15
+            [0x80 | len].pack("C")
+          elsif len <= 0xffff
+            "\xde".b + [len].pack("n")
+          else
+            "\xdf".b + [len].pack("N")
+          end
+
+        body = +"".b
+        pairs.each do |k, v|
+          body << pack(k)
+          body << pack(v)
+        end
+        head + body
+      end
+
+      def read_value(reader)
+        marker = reader.read_u8
+
+        return marker if marker <= 0x7f
+        return marker - 256 if marker >= 0xe0
+
+        case marker
+        when 0xc0 then nil
+        when 0xc2 then false
+        when 0xc3 then true
+        when 0xcc then reader.read_u8
+        when 0xcd then reader.read_u16
+        when 0xce then reader.read_u32
+        when 0xcf then reader.read_u64
+        when 0xd0 then reader.read_i8
+        when 0xd1 then reader.read_i16
+        when 0xd2 then reader.read_i32
+        when 0xd3 then reader.read_i64
+        when 0xca then reader.read_f32
+        when 0xcb then reader.read_f64
+        when 0xd9 then reader.read_string(reader.read_u8)
+        when 0xda then reader.read_string(reader.read_u16)
+        when 0xdb then reader.read_string(reader.read_u32)
+        when 0xdc then read_array(reader, reader.read_u16)
+        when 0xdd then read_array(reader, reader.read_u32)
+        when 0xde then read_map(reader, reader.read_u16)
+        when 0xdf then read_map(reader, reader.read_u32)
+        else
+          if (marker & 0xf0) == 0x90
+            read_array(reader, marker & 0x0f)
+          elsif (marker & 0xf0) == 0x80
+            read_map(reader, marker & 0x0f)
+          elsif (marker & 0xe0) == 0xa0
+            reader.read_string(marker & 0x1f)
+          else
+            raise "Unsupported MessagePack marker: 0x#{marker.to_s(16)}"
+          end
+        end
+      end
+
+      def read_array(reader, size)
+        Array.new(size) { read_value(reader) }
+      end
+
+      def read_map(reader, size)
+        out = {}
+        size.times do
+          key = read_value(reader)
+          out[key.to_s] = read_value(reader)
+        end
+        out
+      end
+    end
+
+    class ByteReader
+      def initialize(bytes)
+        @data = bytes.to_s.b
+        @offset = 0
+      end
+
+      def read_u8
+        value = @data.getbyte(@offset)
+        raise "Unexpected EOF" if value.nil?
+
+        @offset += 1
+        value
+      end
+
+      def read_exact(size)
+        chunk = @data.byteslice(@offset, size)
+        raise "Unexpected EOF" if chunk.nil? || chunk.bytesize != size
+
+        @offset += size
+        chunk
+      end
+
+      def read_u16
+        read_exact(2).unpack1("n")
+      end
+
+      def read_u32
+        read_exact(4).unpack1("N")
+      end
+
+      def read_u64
+        read_exact(8).unpack1("Q>")
+      end
+
+      def read_i8
+        read_exact(1).unpack1("c")
+      end
+
+      def read_i16
+        read_exact(2).unpack1("s>")
+      end
+
+      def read_i32
+        read_exact(4).unpack1("l>")
+      end
+
+      def read_i64
+        read_exact(8).unpack1("q>")
+      end
+
+      def read_f32
+        read_exact(4).unpack1("g")
+      end
+
+      def read_f64
+        read_exact(8).unpack1("G")
+      end
+
+      def read_string(size)
+        read_exact(size).force_encoding("UTF-8")
+      end
+    end
+  end
+end

data/lib/ruflet/server.rb

@@ -0,0 +1,407 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+require "socket"
+require "thread"
+
+require "ruflet"
+require_relative "server/wire_codec"
+require_relative "server/web_socket_connection"
+
+module Ruflet
+  class Server
+    attr_reader :port
+
+    WEBSOCKET_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
+    def initialize(host: "0.0.0.0", port: 8550, &app_block)
+      @host = host
+      @port = port
+      @app_block = app_block
+      @sessions = {}
+      @sessions_mutex = Mutex.new
+      @connections = {}
+      @connections_mutex = Mutex.new
+      @running = false
+      @server_socket = nil
+
+      at_exit do
+        begin
+          stop
+        rescue StandardError
+          nil
+        end
+      end
+    end
+
+    def start
+      previous_signals = trap_stop_signals
+      bind_server_socket!
+      @running = true
+      print_server_banner
+      accept_loop
+    rescue Interrupt
+      nil
+    ensure
+      stop
+      restore_stop_signals(previous_signals)
+    end
+
+    # For Rack-hosted mode: caller already performed the HTTP upgrade.
+    def handle_upgraded_socket(io)
+      ws = Ruflet::WebSocketConnection.new(io)
+      run_connection(ws)
+    end
+
+    def bind_server_socket!(max_attempts: 100)
+      requested = @port.to_i
+      candidate = requested
+
+      max_attempts.times do
+        begin
+          @server_socket = TCPServer.new(@host, candidate)
+          @port = candidate
+          warn "Requested port #{requested} is busy; bound to #{@port}" if @port != requested
+          return
+        rescue Errno::EADDRINUSE
+          candidate += 1
+        end
+      end
+
+      raise Errno::EADDRINUSE, "Unable to bind starting at #{requested} after #{max_attempts} attempts"
+    end
+
+    def stop
+      return unless @running || @server_socket
+
+      @running = false
+
+      server = @server_socket
+      @server_socket = nil
+      begin
+        server&.close
+      rescue IOError
+        nil
+      end
+
+      live_connections = @connections_mutex.synchronize { @connections.values.dup }
+      live_connections.each do |conn|
+        begin
+          conn.close
+        rescue StandardError
+          nil
+        end
+      end
+    end
+
+    private
+
+    def trap_stop_signals
+      {
+        "INT" => trap_signal("INT"),
+        "TERM" => trap_signal("TERM")
+      }
+    end
+
+    def trap_signal(signal_name)
+      Signal.trap(signal_name) do
+        stop
+        Thread.main.raise(Interrupt)
+      rescue StandardError
+        nil
+      end
+    end
+
+    def restore_stop_signals(previous_signals)
+      return unless previous_signals
+
+      previous_signals.each do |signal_name, handler|
+        Signal.trap(signal_name, handler) if handler
+      end
+    end
+
+    def print_server_banner
+      return if ENV["RUFLET_SUPPRESS_SERVER_BANNER"] == "1"
+
+      warn "Ruflet server listening on ws://#{@host}:#{@port}/ws"
+    end
+
+    def accept_loop
+      while @running
+        socket = accept_client_socket
+        break unless socket
+
+        start_client_thread(socket)
+      end
+    end
+
+    def accept_client_socket
+      accepted = @server_socket.accept
+      accepted.is_a?(Array) ? accepted.first : accepted
+    rescue IOError, Errno::EBADF
+      nil
+    rescue StandardError => e
+      warn "accept error: #{e.class}: #{e.message}"
+      warn e.backtrace.join("\n") if e.backtrace
+      nil
+    end
+
+    def start_client_thread(socket)
+      Thread.new(socket) do |client|
+        Thread.current.report_on_exception = false if Thread.current.respond_to?(:report_on_exception=)
+        handle_socket(client)
+      end
+    end
+
+    def handle_socket(socket)
+      ws = nil
+      begin
+        path, headers = read_http_upgrade_request(socket)
+        return unless websocket_upgrade_request?(path, headers)
+
+        send_handshake_response(socket, headers["sec-websocket-key"])
+        ws = Ruflet::WebSocketConnection.new(socket)
+        run_connection(ws)
+      rescue StandardError => e
+        warn "server error: #{e.class}: #{e.message}"
+        warn e.backtrace.join("\n") if e.backtrace
+        send_message(ws, Protocol::ACTIONS[:session_crashed], { "message" => e.message.to_s.dup.force_encoding("UTF-8") }) if ws
+      ensure
+        close_connection(ws)
+      end
+    end
+
+    def run_connection(ws)
+      register_connection(ws)
+
+      while (raw = ws.read_message)
+        handle_message(ws, raw)
+      end
+    rescue StandardError => e
+      warn "server error: #{e.class}: #{e.message}"
+      warn e.backtrace.join("\n") if e.backtrace
+      send_message(ws, Protocol::ACTIONS[:session_crashed], { "message" => e.message.to_s.dup.force_encoding("UTF-8") })
+    ensure
+      close_connection(ws)
+    end
+
+    def close_connection(ws)
+      remove_session(ws)
+      unregister_connection(ws)
+      ws&.close
+    end
+
+    def read_http_upgrade_request(socket)
+      request_line = socket.gets("\r\n")
+      raise "Invalid HTTP request" if request_line.nil?
+
+      method, path, _version = request_line.strip.split(" ", 3)
+      raise "Unsupported HTTP method: #{method}" unless method == "GET"
+
+      headers = {}
+      loop do
+        line = socket.gets("\r\n")
+        break if line.nil? || line == "\r\n"
+
+        key, value = line.split(":", 2)
+        next if key.nil? || value.nil?
+
+        headers[key.strip.downcase] = value.strip
+      end
+
+      [path, headers]
+    end
+
+    def websocket_upgrade_request?(path, headers)
+      return false unless path == "/ws"
+      return false unless headers["upgrade"]&.downcase == "websocket"
+      return false unless headers["connection"]&.downcase&.include?("upgrade")
+      return false if headers["sec-websocket-key"].to_s.empty?
+
+      true
+    end
+
+    def send_handshake_response(socket, key)
+      accept = [Digest::SHA1.digest("#{key}#{WEBSOCKET_GUID}")].pack("m0")
+
+      socket.write("HTTP/1.1 101 Switching Protocols\r\n")
+      socket.write("Upgrade: websocket\r\n")
+      socket.write("Connection: Upgrade\r\n")
+      socket.write("Sec-WebSocket-Accept: #{accept}\r\n")
+      socket.write("\r\n")
+    end
+
+    def remove_session(ws)
+      return unless ws
+
+      @sessions_mutex.synchronize do
+        @sessions.delete(ws.session_key)
+      end
+    end
+
+    def register_connection(ws)
+      return unless ws
+
+      @connections_mutex.synchronize do
+        @connections[ws.session_key] = ws
+      end
+    end
+
+    def unregister_connection(ws)
+      return unless ws
+
+      @connections_mutex.synchronize do
+        @connections.delete(ws.session_key)
+      end
+    end
+
+    def handle_message(ws, raw)
+      action, payload = decode_incoming(raw)
+      payload ||= {}
+
+      warn "incoming action=#{action.inspect}" if ENV["FLET_DEBUG"] == "1"
+
+      case action
+      when Protocol::ACTIONS[:register_client], Protocol::ACTIONS[:register_web_client]
+        on_register_client(ws, payload)
+      when Protocol::ACTIONS[:control_event], Protocol::ACTIONS[:page_event_from_web]
+        on_control_event(ws, payload)
+      when Protocol::ACTIONS[:update_control], Protocol::ACTIONS[:update_control_props]
+        on_update_control(ws, payload)
+      else
+        raise "Unknown action: #{action.inspect}"
+      end
+    end
+
+    def decode_incoming(raw)
+      parsed = normalize_incoming(Ruflet::WireCodec.unpack(raw.to_s.b))
+
+      if parsed.is_a?(Array) && parsed.length >= 2
+        return [parsed[0], parsed[1]]
+      end
+
+      if parsed.is_a?(Hash)
+        action = parsed["action"] || parsed[:action]
+        payload = parsed["payload"] || parsed[:payload]
+        return [action, payload] unless action.nil?
+
+        if (parsed.key?("target") || parsed.key?(:target)) && (parsed.key?("name") || parsed.key?(:name))
+          return [Protocol::ACTIONS[:control_event], parsed]
+        end
+      end
+
+      raise "Unsupported payload format"
+    end
+
+    def normalize_incoming(value)
+      case value
+      when String
+        value.dup.force_encoding("UTF-8")
+      when Integer, Float, TrueClass, FalseClass, NilClass
+        value
+      when Symbol
+        value.to_s
+      when Array
+        value.map { |v| normalize_incoming(v) }
+      when Hash
+        value.each_with_object({}) do |(k, v), out|
+          out[k.to_s] = normalize_incoming(v)
+        end
+      else
+        value.to_s
+      end
+    end
+
+    def on_register_client(ws, payload)
+      normalized = Protocol.normalize_register_payload(payload)
+      session_id = normalized["session_id"].to_s.empty? ? pseudo_uuid : normalized["session_id"]
+
+      page = Page.new(
+        session_id: session_id,
+        client_details: normalized,
+        sender: lambda do |action, msg_payload|
+          send_message(ws, action, msg_payload)
+        end
+      )
+
+      page.title = "Ruflet App"
+
+      @sessions_mutex.synchronize do
+        @sessions[ws.session_key] = page
+      end
+
+      initial_response = [
+        Protocol::ACTIONS[:register_client],
+        {
+          "session_id" => session_id,
+          "page_patch" => {},
+          "error" => nil
+        }
+      ]
+      ws.send_binary(Ruflet::WireCodec.pack(initial_response))
+
+      @app_block.call(page)
+      page.update
+    rescue StandardError => e
+      send_message(ws, Protocol::ACTIONS[:session_crashed], { "message" => e.message })
+      raise
+    end
+
+    def on_control_event(ws, payload)
+      event = Protocol.normalize_control_event_payload(payload)
+      page = fetch_page(ws)
+      return if event["target"].nil? || event["name"].to_s.empty?
+
+      page.dispatch_event(
+        target: event["target"],
+        name: event["name"],
+        data: normalize_event_data(event["data"])
+      )
+    end
+
+    def on_update_control(ws, payload)
+      update = Protocol.normalize_update_control_payload(payload)
+      page = fetch_page(ws)
+      return if update["id"].nil?
+
+      page.apply_client_update(update["id"], update["props"] || {})
+    end
+
+    def fetch_page(ws)
+      page = @sessions_mutex.synchronize { @sessions[ws.session_key] }
+      raise "Session not found" unless page
+
+      page
+    end
+
+    def normalize_event_data(value)
+      case value
+      when Hash
+        value.each_with_object({}) { |(k, v), out| out[k.to_sym] = normalize_event_data(v) }
+      when Array
+        value.map { |entry| normalize_event_data(entry) }
+      else
+        value
+      end
+    end
+
+    def send_message(ws, action, payload)
+      message = [action, payload]
+      ws.send_binary(Ruflet::WireCodec.pack(message))
+    rescue StandardError => e
+      warn "send error: #{e.class}: #{e.message}"
+    end
+
+    def pseudo_uuid
+      now = Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)
+      rnd = rand(0..0xffff_ffff)
+      "%08x-%04x-%04x-%04x-%012x" % [
+        rnd,
+        now & 0xffff,
+        (now >> 16) & 0xffff,
+        (now >> 32) & 0xffff,
+        (now >> 48) & 0xffff_ffff_ffff
+      ]
+    end
+  end
+end

data/lib/ruflet/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ruflet
+  VERSION = "0.0.1" unless const_defined?(:VERSION)
+end

data/lib/ruflet_server.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "ruflet"
+require_relative "ruflet/server"
+
+module Ruflet
+  module_function
+
+  def run(entrypoint = nil, host: "0.0.0.0", port: 8550, &block)
+    callback = entrypoint || block
+    raise ArgumentError, "Ruflet.run requires a callable entrypoint or block" unless callback.respond_to?(:call)
+
+    Server.new(host: host, port: port) do |page|
+      callback.call(page)
+    end.start
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: ruflet_server
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- AdamMusa
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruflet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+description: Ruflet WebSocket server runtime compatible with Flet protocol.
+email:
+- adammusa2222@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/ruflet/server.rb
+- lib/ruflet/server/web_socket_connection.rb
+- lib/ruflet/server/wire_codec.rb
+- lib/ruflet/version.rb
+- lib/ruflet_server.rb
+homepage: https://github.com/AdamMusa/Ruflet
+licenses: []
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.7.2
+specification_version: 4
+summary: Ruflet server package.
+test_files: []