vizcore 0.1.0 → 1.1.0

data/lib/vizcore/server/websocket_handler.rb

@@ -9,6 +9,10 @@ module Vizcore
   module Server
     # Stateless WebSocket endpoint manager for frame broadcast transport.
     class WebSocketHandler
+      PROTOCOL_VERSION = "vizcore.frame.v1"
+      MAX_BUFFERED_FRAME_BYTES = 1_000_000
+      DROPPABLE_MESSAGE_TYPES = Set["audio_frame"].freeze
+
       class << self
         # Rack endpoint for WebSocket upgrade handling.
         #
@@ -36,15 +40,29 @@ module Vizcore
         def broadcast(type:, payload:)
           return false unless faye_websocket_class
 
-          message = JSON.generate(type: type, payload: payload)
+          message = JSON.generate(protocol: PROTOCOL_VERSION, type: type, payload: payload)
 
           each_socket do |socket|
-            send_message(socket, message)
+            send_message(socket, message, type: type)
           end
 
           true
         end
 
+        # Send one typed payload to a single websocket client.
+        #
+        # @param socket [#send]
+        # @param type [String]
+        # @param payload [Hash]
+        # @return [Boolean] false when websocket backend is unavailable
+        def send_to(socket, type:, payload:)
+          return false unless faye_websocket_class
+
+          message = JSON.generate(protocol: PROTOCOL_VERSION, type: type, payload: payload)
+          send_message(socket, message, type: type)
+          true
+        end
+
         # @return [Integer]
         def connection_count
           mutex.synchronize { sockets.size }
@@ -55,6 +73,11 @@ module Vizcore
           mutex.synchronize { @last_error }
         end
 
+        # @return [Integer]
+        def dropped_frame_count
+          mutex.synchronize { @dropped_frame_count || 0 }
+        end
+
         # Register one inbound message handler for client -> server control messages.
         #
         # @yieldparam message [Hash]
@@ -79,21 +102,44 @@ module Vizcore
           nil
         end
 
-        def send_message(socket, message)
+        def send_message(socket, message, type:)
+          return if drop_for_backpressure?(socket, type)
+
           if event_machine_reactor_running?
-            EventMachine.schedule { safe_send(socket, message) }
+            EventMachine.schedule { safe_send(socket, message, type: type) }
           else
-            safe_send(socket, message)
+            safe_send(socket, message, type: type)
           end
         end
 
-        def safe_send(socket, message)
+        def safe_send(socket, message, type:)
+          return if drop_for_backpressure?(socket, type)
+
           socket.send(message)
         rescue StandardError => e
           set_last_error(e)
           unregister(socket)
         end
 
+        def drop_for_backpressure?(socket, type)
+          return false unless DROPPABLE_MESSAGE_TYPES.include?(type.to_s)
+
+          buffered_amount = socket_buffered_amount(socket)
+          return false unless buffered_amount && buffered_amount > MAX_BUFFERED_FRAME_BYTES
+
+          increment_dropped_frame_count
+          true
+        end
+
+        def socket_buffered_amount(socket)
+          return socket.buffered_amount if socket.respond_to?(:buffered_amount)
+          return socket.bufferedAmount if socket.respond_to?(:bufferedAmount)
+
+          nil
+        rescue StandardError
+          nil
+        end
+
         def event_machine_reactor_running?
           require "eventmachine"
           EventMachine.reactor_running?
@@ -105,9 +151,9 @@ module Vizcore
           [500, json_headers, [JSON.generate(error: "Missing dependency: faye-websocket")]]
         end
 
-        def handle_message(_socket, raw_message)
+        def handle_message(socket, raw_message)
           message = JSON.parse(raw_message)
-          dispatch_message(message)
+          dispatch_message(message, socket)
           message
         rescue JSON::ParserError => e
           set_last_error(e)
@@ -139,12 +185,16 @@ module Vizcore
           mutex.synchronize { @last_error = error }
         end
 
-        def dispatch_message(message)
+        def increment_dropped_frame_count
+          mutex.synchronize { @dropped_frame_count = (@dropped_frame_count || 0) + 1 }
+        end
+
+        def dispatch_message(message, socket)
           handler = mutex.synchronize { @message_handler }
           return unless handler
           return unless message.is_a?(Hash)
 
-          handler.call(message)
+          handler.call(message, socket)
         rescue StandardError => e
           set_last_error(e)
           nil

data/lib/vizcore/server.rb

@@ -7,6 +7,10 @@ module Vizcore
 end
 
 require_relative "server/frame_broadcaster"
+require_relative "server/gallery_page"
+require_relative "server/gallery_app"
+require_relative "server/gallery_runner"
 require_relative "server/rack_app"
+require_relative "server/scene_dependency_watcher"
 require_relative "server/runner"
 require_relative "server/websocket_handler"