whoosh 1.3.2 → 1.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '058f9e32f51902477b54086f0b13891fb7dd4b3a33fbcef71387d2556af05ebe'
-  data.tar.gz: abdfab2e7f266bd8d32f7357d531a7847a7087c30a508d1de955edddd1564383
+  metadata.gz: 5baff744454d485e7f9788aca18285ece0c8901a5abea6f9c2f3fd4a22a7de75
+  data.tar.gz: 6c2062d73b6bec5e60c0adfd897e7e8aec5d10fa366439471592fc196bfe5bbd
 SHA512:
-  metadata.gz: 4e2f5bc134e5e2f32eb0c21258f240646abb0d140dfc8834e113d1f52a43d9919266ede8f36ba0750791ee98641d94d6059380d82274a171a8fb610ad9b0f963
-  data.tar.gz: 3e0ce60dd666d57c6aa84804a2f5a0cf5af34bd2a215faf3d31705d4d535489de8c01a979c03144d1784a61526af8ea3e3941cacd1fee623ef9aae0bf3e7d276
+  metadata.gz: 7ef32b36e7405fe117eefc60908baf71a9553d328ccd2fd7823c715b7e37d4f01aeedc29a7cb1709e865410d407a32bc511f49353b90339702a06bb7f9a31425
+  data.tar.gz: 75188ded90b9205cb7c779d18252ef842989ec84d76ad78e1167d4ca267e544918b39c5d2a3596abe0b2d6001620e98e4272a75bdd62491b4130127bba78487c

data/README.md

@@ -13,7 +13,7 @@
   <img src="https://img.shields.io/badge/ruby-%3E%3D%203.4.0-red" alt="Ruby">
   <img src="https://img.shields.io/badge/rack-3.0-blue" alt="Rack">
   <img src="https://img.shields.io/badge/license-MIT-green" alt="License">
-  <img src="https://img.shields.io/badge/tests-540%20passing-brightgreen" alt="Tests">
+  <img src="https://img.shields.io/badge/tests-542%20passing-brightgreen" alt="Tests">
   <img src="https://img.shields.io/badge/overhead-2.5%C2%B5s-orange" alt="Performance">
 </p>
 

data/lib/whoosh/streaming/websocket.rb

@@ -1,29 +1,25 @@
 # frozen_string_literal: true
 
 require "json"
-require "digest"
-require "base64"
 
 module Whoosh
   module Streaming
     class WebSocket
-      GUID = "258EAFA5-E914-47DA-95CA-5AB5DC65C3E5"
-
       attr_reader :env
 
       def initialize(env)
         @env = env
-        @io = nil
+        @ws = nil
         @closed = false
+        @on_open = nil
         @on_message = nil
         @on_close = nil
-        @on_open = nil
       end
 
       # Check if the request is a WebSocket upgrade
       def self.websocket?(env)
-        env["HTTP_UPGRADE"]&.downcase == "websocket" &&
-          env["HTTP_CONNECTION"]&.downcase&.include?("upgrade")
+        upgrade = env["HTTP_UPGRADE"]
+        upgrade && upgrade.downcase == "websocket"
       end
 
       # Register callbacks
@@ -41,154 +37,121 @@ module Whoosh
 
       # Send data to the client
       def send(data)
-        return if @closed
+        return if @closed || @ws.nil?
         formatted = data.is_a?(String) ? data : JSON.generate(data)
-        write_frame(formatted)
+        @ws.send(formatted)
       end
 
-      def close
+      def close(code = nil, reason = nil)
         return if @closed
         @closed = true
-        write_close_frame
-        @io&.close rescue nil
-        @on_close&.call
+        @ws&.close(code || 1000, reason || "")
+      rescue
+        # Already closed
       end
 
       def closed?
         @closed
       end
 
-      # Returns a Rack response that hijacks the connection
+      # Returns a Rack response — auto-detects Faye (Puma) or Async (Falcon)
       def rack_response
         unless self.class.websocket?(@env)
           return [400, { "content-type" => "text/plain" }, ["Not a WebSocket request"]]
         end
 
-        # WebSocket handshake
-        key = @env["HTTP_SEC_WEBSOCKET_KEY"]
-        accept = Base64.strict_encode64(Digest::SHA1.digest(key + GUID))
-
-        headers = {
-          "Upgrade" => "websocket",
-          "Connection" => "Upgrade",
-          "Sec-WebSocket-Accept" => accept
-        }
-
-        # Use rack.hijack to take over the connection
-        if @env["rack.hijack"]
-          @env["rack.hijack"].call
-          @io = @env["rack.hijack_io"]
-
-          # Send handshake response manually
-          @io.write("HTTP/1.1 101 Switching Protocols\r\n")
-          headers.each { |k, v| @io.write("#{k}: #{v}\r\n") }
-          @io.write("\r\n")
-          @io.flush
-
-          # Notify open
-          @on_open&.call
-
-          # Start reading frames in a thread
-          Thread.new { read_loop }
-
-          # Return a dummy response (connection is hijacked)
-          [-1, {}, []]
+        if async_websocket_available? && falcon_env?
+          rack_response_async
         else
-          # Fallback: return 101 and let the server handle hijack
-          [101, headers, []]
+          rack_response_faye
         end
       end
 
-      # For testing — simulate without real socket
+      # For testing without real socket
       def trigger_message(msg)
         @on_message&.call(msg)
       end
 
-      def trigger_close
-        @on_close&.call
+      def trigger_close(code = 1000, reason = "")
+        @on_close&.call(code, reason)
         @closed = true
       end
 
-      private
-
-      def read_loop
-        while !@closed && @io && !@io.closed?
-          frame = read_frame
-          break unless frame
-
-          case frame[:opcode]
-          when 0x1 # Text frame
-            @on_message&.call(frame[:data])
-          when 0x8 # Close frame
-            close
-            break
-          when 0x9 # Ping
-            write_pong(frame[:data])
-          end
-        end
-      rescue IOError, Errno::ECONNRESET, Errno::EPIPE
-        @closed = true
-        @on_close&.call
+      def trigger_open
+        @on_open&.call
       end
 
-      def read_frame
-        return nil unless @io && !@io.closed?
+      private
 
-        first_byte = @io.readbyte
-        fin = (first_byte & 0x80) != 0
-        opcode = first_byte & 0x0F
+      # Faye WebSocket — works with Puma (threads + EventMachine)
+      def rack_response_faye
+        require "faye/websocket"
 
-        second_byte = @io.readbyte
-        masked = (second_byte & 0x80) != 0
-        length = second_byte & 0x7F
+        @ws = Faye::WebSocket.new(@env)
 
-        if length == 126
-          length = @io.read(2).unpack1("n")
-        elsif length == 127
-          length = @io.read(8).unpack1("Q>")
+        @ws.on :open do |_event|
+          @on_open&.call
         end
 
-        mask_key = masked ? @io.read(4).bytes : nil
-        payload = @io.read(length)&.bytes || []
+        @ws.on :message do |event|
+          @on_message&.call(event.data)
+        end
 
-        if masked && mask_key
-          payload = payload.each_with_index.map { |b, i| b ^ mask_key[i % 4] }
+        @ws.on :close do |event|
+          @closed = true
+          @on_close&.call(event.code, event.reason)
+          @ws = nil
         end
 
-        { opcode: opcode, data: payload.pack("C*"), fin: fin }
-      rescue EOFError, IOError
-        nil
+        @ws.rack_response
       end
 
-      def write_frame(data, opcode: 0x1)
-        return unless @io && !@io.closed?
+      # Async WebSocket — works with Falcon (fibers + async)
+      def rack_response_async
+        require "async/websocket/adapters/rack"
 
-        bytes = data.encode("UTF-8").bytes
-        frame = [0x80 | opcode] # FIN + opcode
+        Async::WebSocket::Adapters::Rack.open(@env, protocols: ["ws"]) do |connection|
+          @ws = AsyncWSWrapper.new(connection)
+          @on_open&.call
 
-        if bytes.length < 126
-          frame << bytes.length
-        elsif bytes.length < 65536
-          frame << 126
-          frame += [bytes.length].pack("n").bytes
-        else
-          frame << 127
-          frame += [bytes.length].pack("Q>").bytes
+          while (message = connection.read)
+            @on_message&.call(message.to_str)
+          end
+        rescue EOFError, Protocol::WebSocket::ClosedError
+          # Client disconnected
+        ensure
+          @closed = true
+          @on_close&.call(1000, "")
+          @ws = nil
         end
+      end
 
-        frame += bytes
-        @io.write(frame.pack("C*"))
-        @io.flush
-      rescue IOError, Errno::EPIPE
-        @closed = true
+      def falcon_env?
+        # Falcon sets async.* keys in the env
+        @env.key?("async.reactor") || @env.key?("protocol.http.request")
       end
 
-      def write_close_frame
-        write_frame("", opcode: 0x8) rescue nil
+      def async_websocket_available?
+        require "async/websocket/adapters/rack"
+        true
+      rescue LoadError
+        false
       end
 
-      def write_pong(data)
-        write_frame(data, opcode: 0xA) rescue nil
+      # Wrapper to give async-websocket the same #send interface
+      class AsyncWSWrapper
+        def initialize(connection)
+          @connection = connection
+        end
+
+        def send(data)
+          @connection.write(Protocol::WebSocket::TextMessage.generate(data))
+          @connection.flush
+        end
+
+        def close(code = 1000, reason = "")
+          @connection.close
+        end
       end
     end
   end

data/lib/whoosh/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Whoosh
-  VERSION = "1.3.2"
+  VERSION = "1.4.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: whoosh
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.4.1
 platform: ruby
 authors:
 - Johannes Dwi Cahyo
@@ -107,6 +107,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: faye-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement