ruflet_server 0.0.14 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68ae173b9c0aa89989e40d996aed245db4c434b96e084b2bc83642c89f244208
-  data.tar.gz: 9aea810e84df29511565821252e06f7c0a73cc989b5df86df683393a496d8793
+  metadata.gz: 2681e7067d0b0bd1d3d998e352b89a926cc6c8d1c129a632bb325fb5d2dde8c6
+  data.tar.gz: d4562b20a7f17a82c29cca1020b1956cc18c22ff8aa8531a7c5ebd5230db6704
 SHA512:
-  metadata.gz: de44b6b80acfdc2ce0bca54a3460e027b053d16244cf8d1e44d81b6446d036795008cba9510d37ccec622734205b9bb41cecb8401456bbeb0fa349d8a51ad13e
-  data.tar.gz: 5a7e6e9e7623eebc5635ac8e200e13d8e62ba68335d5fe15533d6260b88a83fe5f5d3c279819c3f89d8f2465a5fac5014e399d1c4b9d67a52a15c0a3f3a76f91
+  metadata.gz: a249874ec8efe3f1ac1c683ee69043077e73051c97eb7cfaa45b491e68df57b7cd22636f665918e33cfeac87913bca791a45ccacb36d16a815f8044ccb219717
+  data.tar.gz: 8b5aca6dde6daf9e51d8700de9609879873110b7793db145153140c813095bd294b9683a2b0a29ffdfd111f7ad43373ce830e9c0103cd3ec86b7d098e5474ff0

data/lib/ruflet/server/connection_protocol.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+module Ruflet
+  # Transport-agnostic implementation of the Ruflet wire protocol: one
+  # connection loop shared by every server that speaks to Flutter clients.
+  #
+  # The standalone TCP server (Ruflet::Server) and host-server adapters such
+  # as ruflet_rails' Rack-hijack endpoint include this module and provide
+  # only their transport plus the integration hooks below — the protocol
+  # itself is never reimplemented.
+  #
+  # Includers must initialize:
+  #   @app_block       — proc invoked with the Page on first registration
+  #   @sessions        — Hash mapping connection key => Page
+  #   @sessions_mutex  — Mutex guarding @sessions
+  module ConnectionProtocol
+    # ------------------------------------------------------------------
+    # Integration hooks (override in the including server as needed).
+    # ------------------------------------------------------------------
+
+    # Called when a connection enters the protocol loop.
+    def connection_opened(ws); end
+
+    # Called when a connection leaves the protocol loop.
+    def connection_closed(ws); end
+
+    # Return an existing Page to resume for this session id, or nil to
+    # create a fresh one (hosts with a session registry override this).
+    def resume_session(_session_id)
+      nil
+    end
+
+    # Called after a Page is stored for a connection.
+    def session_stored(page, ws); end
+
+    # Called after a Page is removed for a connection.
+    def session_removed(page, ws); end
+
+    # Called before a control event is dispatched to the Page.
+    def before_dispatch_event(ws, event); end
+
+    def log_connection_error(error)
+      warn "server error: #{error.class}: #{error.message}"
+      warn error.backtrace.join("\n") if error.backtrace
+    end
+
+    # ------------------------------------------------------------------
+    # Transport entry points.
+    # ------------------------------------------------------------------
+
+    # For hosts that already performed the HTTP upgrade (Rack hijack, the
+    # embedded runtime, tests with socket pairs).
+    def handle_upgraded_socket(io)
+      run_connection(Ruflet::WebSocketConnection.new(io))
+    end
+
+    def run_connection(ws)
+      connection_opened(ws)
+
+      while (raw = ws.read_message)
+        handle_message(ws, raw)
+      end
+    rescue StandardError => e
+      return if disconnect_error?(e)
+
+      log_connection_error(e)
+      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)
+      return unless ws
+
+      remove_session(ws)
+      connection_closed(ws)
+      ws.close
+    end
+
+    # ------------------------------------------------------------------
+    # Protocol core.
+    # ------------------------------------------------------------------
+
+    def handle_message(ws, raw)
+      action, payload = decode_incoming(raw)
+      payload ||= {}
+
+      warn "incoming action=#{action.inspect}" if ENV["RUFLET_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)
+      when Protocol::ACTIONS[:invoke_control_method]
+        on_invoke_control_method(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 = resume_session(session_id)
+      first_registration = page.nil?
+
+      if page
+        attach_sender(page, ws)
+        reset_mount_state(page)
+      else
+        page = Page.new(
+          session_id: session_id,
+          client_details: normalized,
+          sender: sender_for(ws)
+        )
+        page.title = "Ruflet App"
+      end
+
+      @sessions_mutex.synchronize { @sessions[ws.session_key] = page }
+      session_stored(page, ws)
+
+      initial_response = [
+        Protocol::ACTIONS[:register_client],
+        Protocol.register_response(session_id: session_id)
+      ]
+      ws.send_binary(Ruflet::WireCodec.pack(initial_response))
+
+      @app_block.call(page) if first_registration
+      page.update
+    rescue StandardError => e
+      send_message(ws, Protocol::ACTIONS[:session_crashed], { "message" => e.message.to_s })
+      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?
+
+      attach_sender(page, ws)
+      before_dispatch_event(ws, event)
+      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?
+
+      attach_sender(page, ws)
+      page.apply_client_update(update["id"], update["props"] || {})
+    end
+
+    def on_invoke_control_method(ws, payload)
+      page = fetch_page(ws)
+      attach_sender(page, ws)
+      page.handle_invoke_method_result(Protocol.normalize_invoke_method_result_payload(payload))
+    end
+
+    def fetch_page(ws)
+      page = @sessions_mutex.synchronize { @sessions[ws.session_key] }
+      raise "Session not found" unless page
+
+      page
+    end
+
+    def remove_session(ws)
+      return unless ws
+
+      page = @sessions_mutex.synchronize { @sessions.delete(ws.session_key) }
+      session_removed(page, ws) if 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)
+      return if ws.nil? || ws.closed?
+
+      ws.send_binary(Ruflet::WireCodec.pack([action, payload]))
+    rescue StandardError => e
+      log_connection_error(e) unless disconnect_error?(e)
+      remove_session(ws)
+      connection_closed(ws)
+      nil
+    end
+
+    def sender_for(ws)
+      lambda do |action, msg_payload|
+        send_message(ws, action, msg_payload)
+      end
+    end
+
+    def attach_sender(page, ws)
+      page.instance_variable_set(:@sender, sender_for(ws))
+    end
+
+    def reset_mount_state(page)
+      page.instance_variable_set(:@overlay_container_mounted, false)
+      page.instance_variable_set(:@dialogs_container_mounted, false)
+      page.instance_variable_set(:@services_container_mounted, false)
+    end
+
+    def disconnect_error?(error)
+      return true if error.is_a?(IOError)
+      return true if error.is_a?(Errno::EPIPE)
+      return true if error.is_a?(Errno::ECONNRESET)
+      return true if error.is_a?(Errno::ECONNABORTED)
+      return true if error.is_a?(Errno::ENOTCONN)
+      return true if error.is_a?(Errno::ESHUTDOWN)
+      return true if error.is_a?(Errno::EBADF)
+      return true if error.is_a?(Errno::EINVAL)
+
+      false
+    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/server.rb

@@ -7,9 +7,15 @@ require "thread"
 require "ruflet_core"
 require_relative "server/wire_codec"
 require_relative "server/web_socket_connection"
+require_relative "server/connection_protocol"
 
 module Ruflet
+  # Standalone TCP transport for the Ruflet protocol. The protocol itself
+  # lives in Ruflet::ConnectionProtocol and is shared with host-server
+  # adapters (e.g. ruflet_rails runs it on the Rails server's own socket).
   class Server
+    include ConnectionProtocol
+
     attr_reader :port
 
     WEBSOCKET_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
@@ -47,12 +53,6 @@ module Ruflet
       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
@@ -65,6 +65,7 @@ module Ruflet
           if @port != requested && ENV["RUFLET_SUPPRESS_SERVER_BANNER"] != "1"
             warn "Requested port #{requested} is busy; bound to #{@port}"
           end
+          publish_bound_port!
           return
         rescue Errno::EADDRINUSE
           candidate += 1
@@ -80,6 +81,7 @@ module Ruflet
       return unless @running || @server_socket
 
       @running = false
+      remove_port_file!
 
       server = @server_socket
       @server_socket = nil
@@ -128,6 +130,30 @@ module Ruflet
 
     private
 
+    # Lets embedding hosts (e.g. the ruby_runtime Flutter plugins) discover
+    # which port the server actually bound when the requested one was busy.
+    def publish_bound_port!
+      path = ENV["RUFLET_PORT_FILE"].to_s
+      return if path.empty?
+
+      begin
+        File.write(path, @port.to_s)
+      rescue StandardError
+        nil
+      end
+    end
+
+    def remove_port_file!
+      path = ENV["RUFLET_PORT_FILE"].to_s
+      return if path.empty?
+
+      begin
+        File.delete(path)
+      rescue StandardError
+        nil
+      end
+    end
+
     def trap_stop_signals
       {
         "INT" => trap_signal("INT"),
@@ -211,28 +237,6 @@ module Ruflet
       end
     end
 
-    def run_connection(ws)
-      register_connection(ws)
-
-      while (raw = ws.read_message)
-        handle_message(ws, raw)
-      end
-    rescue StandardError => e
-      return if disconnect_error?(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")
       return [nil, {}] if request_line.nil?
@@ -360,15 +364,8 @@ module Ruflet
       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)
+    # ConnectionProtocol hooks: track live sockets so #stop can close them.
+    def connection_opened(ws)
       return unless ws
 
       @connections_mutex.synchronize do
@@ -376,7 +373,7 @@ module Ruflet
       end
     end
 
-    def unregister_connection(ws)
+    def connection_closed(ws)
       return unless ws
 
       @connections_mutex.synchronize do
@@ -384,180 +381,5 @@ module Ruflet
       end
     end
 
-    def handle_message(ws, raw)
-      action, payload = decode_incoming(raw)
-      payload ||= {}
-
-      warn "incoming action=#{action.inspect}" if ENV["RUFLET_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)
-      when Protocol::ACTIONS[:invoke_control_method]
-        on_invoke_control_method(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_invoke_control_method(ws, payload)
-      page = fetch_page(ws)
-      page.handle_invoke_method_result(Protocol.normalize_invoke_method_result_payload(payload))
-    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)
-      return if ws.nil? || ws.closed?
-
-      message = [action, payload]
-      ws.send_binary(Ruflet::WireCodec.pack(message))
-    rescue StandardError => e
-      unless disconnect_error?(e)
-        warn "send error: #{e.class}: #{e.message}"
-      end
-      remove_session(ws)
-      unregister_connection(ws)
-      ws&.close
-    end
-
-    def disconnect_error?(error)
-      return true if error.is_a?(IOError)
-      return true if error.is_a?(Errno::EPIPE)
-      return true if error.is_a?(Errno::ECONNRESET)
-      return true if error.is_a?(Errno::ECONNABORTED)
-      return true if error.is_a?(Errno::ENOTCONN)
-      return true if error.is_a?(Errno::ESHUTDOWN)
-      return true if error.is_a?(Errno::EBADF)
-      return true if error.is_a?(Errno::EINVAL)
-
-      false
-    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

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

data/lib/ruflet_server.rb

@@ -27,5 +27,7 @@ module Ruflet
 
     @run_interceptors_mutex.synchronize { @run_interceptors.last }
   end
-  private_class_method :run_interceptor
+  class << self
+    private :run_interceptor
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruflet_server
 version: !ruby/object:Gem::Version
-  version: 0.0.14
+  version: 0.0.15
 platform: ruby
 authors:
 - AdamMusa
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.14
+        version: 0.0.15
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.14
+        version: 0.0.15
 description: Ruflet WebSocket server runtime compatible with Flet protocol.
 email:
 - adammusa2222@gmail.com
@@ -32,6 +32,7 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/ruflet/server.rb
+- lib/ruflet/server/connection_protocol.rb
 - lib/ruflet/server/web_socket_connection.rb
 - lib/ruflet/server/wire_codec.rb
 - lib/ruflet/version.rb