julewire-ractor 1.0.1 → 1.1.0

data/lib/julewire/ractor/remote_payload.rb

@@ -3,13 +3,11 @@
 module Julewire
   module Ractor
     module RemotePayload
-      MISSING = Object.new.freeze
-      private_constant :MISSING
-
       class << self
         def extract(payload)
+          validate_hash!(payload)
           {
-            input: input_value(payload),
+            input: hash_value(payload, :input),
             context: hash_value(payload, :context),
             neutral: hash_value(payload, :neutral),
             attributes: hash_value(payload, :attributes),
@@ -18,14 +16,6 @@ module Julewire
           }
         end
 
-        def input_value(payload)
-          value = Core::Integration::Values::Read.hash_value(payload, :input, default: MISSING)
-          return {} if value.equal?(MISSING)
-          return Core::Fields::FieldSet.deep_symbolize_owned_keys(value) if value.is_a?(Hash)
-
-          value
-        end
-
         def scope_snapshot(scope_payload)
           Core::Execution::ScopeSnapshot.new(
             execution: hash_value(scope_payload, :execution),
@@ -37,8 +27,13 @@ module Julewire
         end
 
         def hash_value(hash, key)
-          value = Core::Integration::Values::Read.hash_value(hash, key)
-          value.is_a?(Hash) ? Core::Fields::FieldSet.deep_symbolize_owned_keys(value) : {}
+          validate_hash!(hash.fetch(key))
+        end
+
+        private
+
+        def validate_hash!(value)
+          Core::Integration::Protocol.validate_symbol_hash(value)
         end
       end
     end

data/lib/julewire/ractor/remote_runtime.rb

@@ -47,11 +47,22 @@ module Julewire
         remote_emit(:emit_without_level, record, fields, &)
       end
 
+      def emit_integration(record, enforce_level:)
+        command = enforce_level ? :emit : :emit_without_level
+        input = Core::Records::BuildInput.validate_owned(record)
+        notify(command, payload: remote_emit_payload(input))
+      rescue StandardError => e
+        @child_stats.message_dropped(e)
+      end
+
       def remote_emit(command, record, fields, &)
         record = Core.emit_input(record, fields)
         record = Core::Records::LazyEmitInput.call(record, &) if block_given?
-        record = record.to_h if Core::Records::LazyEmitInput.input?(record)
-        notify(command, payload: remote_emit_payload(record))
+        input = Core::Records::BuildInput.normalize_public(record)
+        input = Core::Fields::FieldSet.deep_symbolize_keys(input)
+        notify(command, payload: remote_emit_payload(input))
+      rescue StandardError => e
+        @child_stats.message_dropped(e)
       end
       private :remote_emit
 
@@ -81,22 +92,22 @@ module Julewire
         Core::ContextStore.reset_current!
       end
 
+      def reset_facade! = reset!
+
       def emit_summary_record(scope)
-        notify(:emit_record, payload: Core::Serialization::Serializer.call(summary_record_input(scope)))
+        notify(:emit_record, payload: serialize_remote(summary_record_input(scope)))
+      rescue StandardError => e
+        @child_stats.message_dropped(e)
       end
 
       private
 
       def emit_non_standard_exception_summaries? = @emit_non_standard_exception_summaries
 
-      def summary_finalizer_failure
-        @summary_finalizer_failure ||= ->(_error) {}
-      end
-
       def build_execution_boundary
         Core::Execution::Boundary.new(
           emit_summary_record: ->(scope) { emit_summary_record(scope) },
-          summary_finalizer_failure: summary_finalizer_failure,
+          summary_finalizer_failure: nil,
           emit_non_standard_exception_summaries: -> { emit_non_standard_exception_summaries? }
         )
       end
@@ -108,19 +119,23 @@ module Julewire
       end
 
       def remote_emit_payload(record)
-        {
-          input: Core::Serialization::Serializer.call(record),
-          context: Core::Serialization::Serializer.call(Core::ContextStore.current.context_hash),
-          neutral: Core::Serialization::Serializer.call(Core::ContextStore.current.neutral_hash),
-          attributes: Core::Serialization::Serializer.call(Core::ContextStore.current.attributes_hash),
-          carry: Core::Serialization::Serializer.call(Core::ContextStore.current.carry_hash),
-          scope: Core::Serialization::Serializer.call(scope_payload)
-        }
+        serialize_remote(
+          input: record,
+          context: Core::ContextStore.current.context_hash,
+          neutral: Core::ContextStore.current.neutral_hash,
+          attributes: Core::ContextStore.current.attributes_hash,
+          carry: Core::ContextStore.current.carry_hash,
+          scope: scope_payload
+        )
+      end
+
+      def serialize_remote(value)
+        RemoteSerializer.call(value)
       end
 
       def scope_payload
         scope = Core::ContextStore.current.current_scope_or_snapshot
-        return {} unless scope
+        return empty_scope_payload unless scope
 
         {
           execution: scope.execution_hash,
@@ -131,31 +146,28 @@ module Julewire
         }
       end
 
+      def empty_scope_payload
+        { execution: {}, neutral: {}, attributes: {}, carry: {}, labels: {} }
+      end
+
       def notify(command, payload:)
         @request_mutex.synchronize do
           @port.send({ command: command, payload: payload })
         end
         @child_stats.message_sent
-        nil
-      rescue StandardError => e
-        @child_stats.message_dropped(e)
-        nil
       end
 
       def request(command, timeout:)
         reply = ::Ractor::Port.new
-        waiting_for_reply = false
         @request_mutex.synchronize do
           @port.send({ command: command, payload: { timeout: timeout }, reply: reply })
         end
         @child_stats.request_sent
-        waiting_for_reply = true
         wait_for_reply(reply, timeout)
       rescue StandardError => e
         @child_stats.request_failed(e)
-        nil
       ensure
-        close_reply(reply) if reply && !waiting_for_reply
+        close_reply(reply)
       end
 
       def effective_timeout(timeout)
@@ -163,20 +175,17 @@ module Julewire
       end
 
       def wait_for_reply(reply, timeout)
-        timeout_token = @timeout_scheduler.schedule(reply, timeout: timeout) if timeout
-        response = reply.receive
+        response = if timeout.nil?
+                     reply.receive
+                   else
+                     @timeout_scheduler.with_timeout(reply, timeout: timeout) { reply.receive }
+                   end
 
         if response.equal?(REQUEST_TIMEOUT)
           @child_stats.request_timed_out
-          nil
         else
           response
         end
-      rescue StandardError
-        nil
-      ensure
-        @timeout_scheduler.cancel(timeout_token)
-        close_reply(reply)
       end
 
       def close_reply(reply)

data/lib/julewire/ractor/remote_serializer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Ractor
+    # Serializes cross-ractor values without changing the internal Symbol-key
+    # protocol into a JSON-shaped String-key protocol.
+    class RemoteSerializer < Core::Serialization::Serializer
+      def serialize(value)
+        Core::Integration::Protocol.validate_symbol_keys(value)
+        super
+      end
+
+      private
+
+      def initialize(**)
+        super
+        @truncation_key = TRUNCATION_METADATA_KEY.to_sym
+      end
+
+      def key_value(key) = super.to_sym
+
+      def truncation_metadata(fields) = super(fields, key_style: :symbol)
+    end
+
+    private_constant :RemoteSerializer
+  end
+end

data/lib/julewire/ractor/remote_summary_record.rb

@@ -8,7 +8,7 @@ module Julewire
       end
 
       def owned_summary_record_input
-        @owned_summary_record_input ||= Core::Fields::FieldSet.deep_symbolize_owned_keys(@record)
+        @owned_summary_record_input ||= Core::Integration::Protocol.validate_symbol_keys(@record)
       end
     end
   end

data/lib/julewire/ractor/reply_timeout_scheduler.rb

@@ -5,32 +5,35 @@ module Julewire
     class ReplyTimeoutScheduler
       THREAD_NAME = "julewire-ractor-reply-timeout"
 
-      # This stays stdlib-only because RemoteRuntime creates it inside a Ractor.
-      # Concurrent::ScheduledTask currently touches non-shareable concurrent-ruby
-      # constants from worker ractors.
-
       def initialize(timeout_value:)
         @timeout_value = timeout_value
-        @scheduler = Core::Scheduling::DeadlineScheduler.new(thread_name: THREAD_NAME, idle: :exit)
       end
 
       def schedule(reply, timeout:)
-        @scheduler.schedule(timeout) { send_timeout(reply) }
+        Thread.new(Float(timeout)) do |delay|
+          Thread.current.name = THREAD_NAME
+          sleep(delay)
+          send_timeout(reply)
+        end
       end
 
-      def cancel(token)
-        return unless token
-
-        @scheduler.cancel(token)
-      rescue StandardError
+      def cancel(thread)
+        thread&.kill
+        thread&.join
         nil
       end
 
+      def with_timeout(reply, timeout:)
+        token = schedule(reply, timeout: timeout)
+        yield
+      ensure
+        cancel(token)
+      end
+
       private
 
       def send_timeout(reply)
         reply.send(@timeout_value)
-        nil
       rescue StandardError
         nil
       end

data/lib/julewire/ractor/version.rb

@@ -2,6 +2,6 @@
 
 module Julewire
   module Ractor
-    VERSION = "1.0.1"
+    VERSION = "1.1.0"
   end
 end

data/lib/julewire/ractor/worker_handshake.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Ractor
+    class WorkerHandshake
+      DEFAULT_TIMEOUT = 1
+
+      class << self
+        def receive(setup_port:, worker:, scheduler:, timeout: DEFAULT_TIMEOUT)
+          PortLifecycle.with_port do |timeout_port|
+            scheduler.with_timeout(timeout_port, timeout: timeout) do
+              selected, value = ::Ractor.select(setup_port, worker, timeout_port)
+
+              if selected.equal?(timeout_port)
+                raise Core::Error, "ractor destination worker did not start within #{timeout} seconds"
+              end
+              return value if selected.equal?(setup_port) && value.is_a?(::Ractor::Port)
+
+              raise ArgumentError, "ractor destination worker did not start"
+            end
+          end
+        end
+      end
+    end
+
+    private_constant :WorkerHandshake
+  end
+end

data/lib/julewire/ractor.rb

@@ -7,7 +7,7 @@ module Julewire
   module Ractor
     class << self
       def health
-        bridge_health
+        Bridge.health
       end
 
       def child_stats
@@ -24,15 +24,10 @@ module Julewire
 
       def enable_default_destination_workers!
         Core::Destinations.register(:default) { |name:, **options| Destination.new(name: name, **options) }
-        nil
       end
 
       private
 
-      def bridge_health
-        Bridge.health
-      end
-
       def child_runtime
         runtime = Core::RuntimeLocator.current
         runtime if runtime.respond_to?(:child_stats)
@@ -53,7 +48,7 @@ module Julewire
     def ractor(*args, name: nil, &block)
       raise ArgumentError, "block required" unless block
 
-      Ractor::Bridge.spawn(args: args, name: name, runtime: Core::RuntimeLocator.current, &block)
+      Ractor::Bridge.start(args: args, name: name, runtime: Core::RuntimeLocator.current, &block)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: julewire-ractor
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Alexander Grebennik
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -65,9 +65,11 @@ files:
 - lib/julewire/ractor/port_lifecycle.rb
 - lib/julewire/ractor/remote_payload.rb
 - lib/julewire/ractor/remote_runtime.rb
+- lib/julewire/ractor/remote_serializer.rb
 - lib/julewire/ractor/remote_summary_record.rb
 - lib/julewire/ractor/reply_timeout_scheduler.rb
 - lib/julewire/ractor/version.rb
+- lib/julewire/ractor/worker_handshake.rb
 homepage: https://github.com/slbug/julewire
 licenses:
 - MIT
@@ -90,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.14
+rubygems_version: 4.0.16
 specification_version: 4
 summary: Experimental Ractor bridge for julewire-core.
 test_files: []