ruflet_server 0.0.14 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68ae173b9c0aa89989e40d996aed245db4c434b96e084b2bc83642c89f244208
-  data.tar.gz: 9aea810e84df29511565821252e06f7c0a73cc989b5df86df683393a496d8793
+  metadata.gz: b2720e5cd2f2bbe7ea1f8c6470c420fcb2b84bb8c6c3bab83ca12b5ea64633d5
+  data.tar.gz: 410a06961fed394deb2b0bdc194cccede9c407de205b5a8e977da1c165290e68
 SHA512:
-  metadata.gz: de44b6b80acfdc2ce0bca54a3460e027b053d16244cf8d1e44d81b6446d036795008cba9510d37ccec622734205b9bb41cecb8401456bbeb0fa349d8a51ad13e
-  data.tar.gz: 5a7e6e9e7623eebc5635ac8e200e13d8e62ba68335d5fe15533d6260b88a83fe5f5d3c279819c3f89d8f2465a5fac5014e399d1c4b9d67a52a15c0a3f3a76f91
+  metadata.gz: e9d1f379990a194e710220e0cc872501c3ce9da07e7e9149b5eaf4377ab669f5d74cc814bb6c8cf37dec3f647ea767074c1aa5c49daab87a584da3f9909d9846
+  data.tar.gz: c59c37531ebbd43796a7117d843208680562f18e09d939aeb63ab05b5560faa79fe7fbc5014de7fd4dc413f2be80d949f4cb1a4d802aa421ed4e41aa1ca325fb

data/README.md

@@ -1,3 +1,17 @@
 # ruflet_server
 
-Part of Ruflet monorepo.
+`ruflet_server` runs server-driven Ruflet applications and connects their Ruby
+UI code to Ruflet clients.
+
+It is installed automatically in projects created with `ruflet new`. Start an
+application through the Ruflet CLI:
+
+```bash
+bundle exec ruflet run
+bundle exec ruflet run --web
+bundle exec ruflet run --desktop
+```
+
+Application code uses the public `Ruflet.run` API supplied by `ruflet_core`.
+Rails applications should use `ruflet_rails` instead of starting this server
+directly.

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
@@ -63,8 +63,9 @@ module Ruflet
           @server_socket = TCPServer.new(@host, candidate)
           @port = candidate
           if @port != requested && ENV["RUFLET_SUPPRESS_SERVER_BANNER"] != "1"
-            warn "Requested port #{requested} is busy; bound to #{@port}"
+            warn "Port #{requested} is busy; using #{@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"),
@@ -207,30 +233,22 @@ module Ruflet
         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)
+        if ws
+          close_connection(ws)
+        else
+          # Plain HTTP request: we answer with `Connection: close`, so we must
+          # actually close the socket. Leaving it open exhausts the browser's
+          # per-host connection pool and the later /ws upgrade never opens —
+          # the app then hangs on its "connecting" screen.
+          close_http_socket(socket)
+        end
       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
+    def close_http_socket(socket)
+      socket.close if socket && !socket.closed?
+    rescue StandardError
+      nil
     end
 
     def read_http_upgrade_request(socket)
@@ -257,7 +275,7 @@ module Ruflet
     end
 
     def websocket_upgrade_request?(path, headers)
-      return false unless path == "/ws"
+      return false unless path.to_s.split("?", 2).first == "/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?
@@ -266,21 +284,95 @@ module Ruflet
     end
 
     def handle_http_request(socket, path)
-      case path
-      when "/health"
-        write_http_response(socket, 200, "text/plain", "ok")
+      clean = path.to_s.split("?", 2).first.split("#", 2).first
+      return write_http_response(socket, 200, "text/plain", "ok") if clean == "/health"
+
+      # In web mode the standalone backend also serves the Flutter web client,
+      # so the browser loads the app and opens its websocket on this same
+      # origin/port — no separate static server or proxy is needed.
+      return serve_web_client(socket, clean) if web_client_root
+
+      case clean
       when "/"
         write_http_response(socket, 200, "text/plain", "ruflet server")
       else
-        if path.start_with?("/assets/")
-          serve_asset(socket, path)
+        if clean.start_with?("/assets/")
+          serve_asset(socket, clean)
         else
           write_http_response(socket, 404, "text/plain", "not found")
         end
       end
     rescue StandardError => e
+      # The browser routinely cancels in-flight asset requests (preloads,
+      # duplicate connections); writing to a reset socket raises EPIPE/ECONNRESET
+      # and is expected, not an error.
+      return if disconnect_error?(e)
+
       warn "http error: #{e.class}: #{e.message}"
-      write_http_response(socket, 500, "text/plain", "server error")
+      begin
+        write_http_response(socket, 500, "text/plain", "server error")
+      rescue StandardError
+        nil
+      end
+    end
+
+    def web_client_root
+      dir = ENV["RUFLET_WEB_CLIENT_DIR"].to_s
+      return nil if dir.empty?
+
+      full = File.expand_path(dir)
+      File.directory?(full) ? full : nil
+    end
+
+    def serve_web_client(socket, path)
+      root = web_client_root
+
+      # Neutralize the Flutter service worker: when this dev server hops between
+      # localhost ports a cached worker would otherwise keep a stale client
+      # alive that reconnects to the wrong backend. This unregisters it and
+      # clears caches so the browser always loads the current client.
+      if path == "/flutter_service_worker.js"
+        return write_http_response(socket, 200, "text/javascript", service_worker_reset_js, cache: false)
+      end
+
+      relative = path == "/" ? "index.html" : path.sub(%r{\A/}, "")
+      full = File.expand_path(File.join(root, relative))
+      if (full == root || full.start_with?(root + File::SEPARATOR)) && File.file?(full)
+        return write_http_response(socket, 200, content_type_for(full), File.binread(full), binary: true, cache: false)
+      end
+
+      # App runtime assets (images referenced by the app) fall back to the
+      # configured assets directory when not part of the client bundle.
+      if path.start_with?("/assets/") && (asset = resolve_asset_path(path))
+        return write_http_response(socket, 200, content_type_for(asset), File.binread(asset), binary: true, cache: false)
+      end
+
+      # SPA fallback: serve index.html for extension-less route paths.
+      index = File.join(root, "index.html")
+      if File.extname(path).empty? && File.file?(index)
+        return write_http_response(socket, 200, "text/html", File.binread(index), binary: true, cache: false)
+      end
+
+      write_http_response(socket, 404, "text/plain", "not found")
+    end
+
+    # A no-op service worker: it registers cleanly (so Flutter's loader, which
+    # awaits navigator.serviceWorker.ready, never hangs), wipes any caches a
+    # previous run left behind, claims the page, and installs NO fetch handler —
+    # so every request (including the app shell) goes straight to the network and
+    # the client always loads fresh and connects to the current origin/port.
+    # (Self-unregistering here can leave serviceWorker.ready unresolved.)
+    def service_worker_reset_js
+      <<~JS
+        self.addEventListener('install', function (e) { self.skipWaiting(); });
+        self.addEventListener('activate', function (e) {
+          e.waitUntil((async function () {
+            var keys = await caches.keys();
+            await Promise.all(keys.map(function (k) { return caches.delete(k); }));
+            await self.clients.claim();
+          })());
+        });
+      JS
     end
 
     def serve_asset(socket, path)
@@ -311,28 +403,39 @@ module Ruflet
       root = ENV["RUFLET_ASSETS_DIR"].to_s
       return root unless root.empty?
 
+      embedded_root = defined?($__ruflet_app_root) ? $__ruflet_app_root.to_s : ""
+      unless embedded_root.empty?
+        embedded_assets = File.join(embedded_root, "assets")
+        return embedded_assets if File.directory?(embedded_assets)
+      end
+
       default_root = File.join(Dir.pwd, "assets")
       File.directory?(default_root) ? default_root : nil
     end
 
     def content_type_for(path)
       case File.extname(path).downcase
-      when ".png"
-        "image/png"
-      when ".jpg", ".jpeg"
-        "image/jpeg"
-      when ".gif"
-        "image/gif"
-      when ".webp"
-        "image/webp"
-      when ".svg"
-        "image/svg+xml"
-      else
-        "application/octet-stream"
+      when ".html", ".htm" then "text/html; charset=utf-8"
+      when ".js", ".mjs" then "text/javascript; charset=utf-8"
+      when ".json", ".map" then "application/json; charset=utf-8"
+      when ".css" then "text/css; charset=utf-8"
+      when ".wasm" then "application/wasm"
+      when ".png" then "image/png"
+      when ".jpg", ".jpeg" then "image/jpeg"
+      when ".gif" then "image/gif"
+      when ".webp" then "image/webp"
+      when ".svg" then "image/svg+xml"
+      when ".ico" then "image/x-icon"
+      when ".ttf" then "font/ttf"
+      when ".otf" then "font/otf"
+      when ".woff" then "font/woff"
+      when ".woff2" then "font/woff2"
+      when ".txt" then "text/plain; charset=utf-8"
+      else "application/octet-stream"
       end
     end
 
-    def write_http_response(socket, status, content_type, body, binary: false)
+    def write_http_response(socket, status, content_type, body, binary: false, cache: true)
       reason = {
         200 => "OK",
         404 => "Not Found",
@@ -345,6 +448,10 @@ module Ruflet
       socket.write("HTTP/1.1 #{status} #{reason}\r\n")
       socket.write("Content-Type: #{content_type}\r\n")
       socket.write("Content-Length: #{length}\r\n")
+      unless cache
+        socket.write("Cache-Control: no-store, no-cache, must-revalidate, max-age=0\r\n")
+        socket.write("Pragma: no-cache\r\n")
+      end
       socket.write("Connection: close\r\n")
       socket.write("\r\n")
       socket.write(body_str)
@@ -360,15 +467,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 +476,7 @@ module Ruflet
       end
     end
 
-    def unregister_connection(ws)
+    def connection_closed(ws)
       return unless ws
 
       @connections_mutex.synchronize do
@@ -384,180 +484,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.16" unless const_defined?(:VERSION)
 end

data/lib/ruflet_server.rb

@@ -6,7 +6,8 @@ require_relative "ruflet/server"
 module Ruflet
   module_function
 
-  def run(entrypoint = nil, host: "0.0.0.0", port: 8550, &block)
+  def run(entrypoint = nil, host: "0.0.0.0", port: nil, &block)
+    port = normalize_run_port(port || ENV["RUFLET_PORT"] || 8550)
     callback = entrypoint || block
     raise ArgumentError, "Ruflet.run requires a callable entrypoint or block" unless callback.respond_to?(:call)
 
@@ -27,5 +28,13 @@ module Ruflet
 
     @run_interceptors_mutex.synchronize { @run_interceptors.last }
   end
-  private_class_method :run_interceptor
+
+  def normalize_run_port(value)
+    Integer(value)
+  rescue ArgumentError, TypeError
+    8550
+  end
+  class << self
+    private :run_interceptor, :normalize_run_port
+  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.16
 platform: ruby
 authors:
 - AdamMusa
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.14
+        version: 0.0.16
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.14
+        version: 0.0.16
 description: Ruflet WebSocket server runtime compatible with Flet protocol.
 email:
 - adammusa2222@gmail.com
@@ -32,12 +32,14 @@ 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
 - lib/ruflet_server.rb
 homepage: https://github.com/AdamMusa/Ruflet
-licenses: []
+licenses:
+- MIT
 metadata: {}
 rdoc_options: []
 require_paths: