galaaz 0.5.0 → 2.0.0

data/new_bridge_specs/integration_phase5_3_callback_error_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Phase 5.3 callback error propagation on the R.bridge seam.
+# Run:
+# bin/run_rspec specs/new_bridge/integration_phase5_3_callback_error_spec.rb
+
+
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.3 integration callback error (R.bridge seam)' do
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+    R.bridge.eval_r('call_me <- function(f) { f() }')
+  end
+
+  it 'propagates Ruby callback failure through bridge call' do
+    expect do
+      R.call_me(proc { raise 'p53 callback boom' })
+    end.to raise_error(StandardError, /evaluation error|boom/)
+  end
+end
+

data/new_bridge_specs/integration_phase5_3_callback_timeout_spec.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Phase 5.3 callback timeout behavior on the R.bridge seam.
+# Run:
+# bin/run_rspec specs/new_bridge/integration_phase5_3_callback_timeout_spec.rb
+
+
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.3 integration callback timeout (R.bridge seam)' do
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+    R.bridge.eval_r('call_me <- function(f) { f() }')
+  end
+
+  it 'raises when callback execution exceeds callback wait (GALAAZ_CALLBACK_TIMEOUT_MS)' do
+    old = ENV['GALAAZ_CALLBACK_TIMEOUT_MS']
+    ENV['GALAAZ_CALLBACK_TIMEOUT_MS'] = '2000'
+    begin
+      expect do
+        R.call_me(proc { sleep 5; 999 })
+      end.to raise_error(StandardError, /timeout|evaluation error|no RET/i)
+    ensure
+      ENV['GALAAZ_CALLBACK_TIMEOUT_MS'] = old
+    end
+  end
+end
+

data/new_bridge_specs/integration_phase5_3_callbacks_smoke_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Phase 5.3 callback/proc stub smoke on the R.bridge seam.
+# Run:
+# bin/run_rspec specs/new_bridge/integration_phase5_3_callbacks_smoke_spec.rb
+
+
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.3 integration callbacks smoke (R.bridge seam)' do
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+  end
+
+  it 'invokes a Ruby Proc from R and returns a scalar result' do
+    R.bridge.eval_r('call_me <- function(f) { f() }')
+    result = R.call_me(proc { 42.0 })
+    expect(result).to be_a(R::Object)
+    expect(result.to_ruby).to eq(42.0)
+  end
+end
+

data/new_bridge_specs/integration_phase5_3_edge_cases_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Phase 5.3 callback edge cases on the R.bridge seam.
+# Run:
+# bin/run_rspec specs/new_bridge/integration_phase5_3_edge_cases_spec.rb
+
+
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.3 integration callback edge cases (R.bridge seam)' do
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+    R.bridge.eval_r('call_me <- function(f) { f() }')
+    R.bridge.eval_r('call_with_arg <- function(f, x) { f(x) }')
+  end
+
+  it 'supports callback proc with arity 2 receiving payload and call_id' do
+    result = R.call_with_arg(proc { |payload, call_id|
+      payload.to_i + (call_id.to_s.empty? ? 0 : 1)
+    }, 41)
+
+    expect(result).to be_a(R::Object)
+    expect(result.to_ruby).to eq(42.0)
+  end
+
+  it 'passes logical scalar argument through payload conversion' do
+    result = R.call_with_arg(proc { |x| x.to_ruby == true ? 7 : 0 }, true)
+    expect(result.to_ruby).to eq(7.0)
+  end
+
+  it 'keeps nested eval path available inside callback with arity 2' do
+    bridge = R.bridge
+    inner = nil
+
+    out = R.call_me(proc { |_payload, _call_id|
+      inner = bridge.eval_r_with_result('g2_v_p53_edge <- 55L')
+      9
+    })
+
+    expect(out).to be_a(R::Object)
+    expect(out.to_ruby).to eq(9.0)
+    expect(inner).not_to be_nil
+    expect(inner[:type]).to eq(:scalar_integer)
+    expect(inner[:value]).to eq(55)
+  end
+
+  it 'passes non-scalar callback arguments as a single R::Object' do
+    result = R.call_with_arg(proc { |x| x.to_s.empty? ? 1 : 0 }, R.c(1, 2, 3))
+    expect(result.to_ruby).to eq(0.0)
+  end
+end
+

data/new_bridge_specs/integration_phase5_3_nested_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Phase 5.3 nested callback integration on the R.bridge seam.
+# Run:
+# bin/run_rspec specs/new_bridge/integration_phase5_3_nested_spec.rb
+
+
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.3 integration nested callbacks (R.bridge seam)' do
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+  end
+
+  it 'supports nested eval_r_with_result from inside callback and returns correct values' do
+    bridge = R.bridge
+    inner_envelope = nil
+
+    result = R.lapply(R.c(1), proc do |_x|
+      inner_envelope = bridge.eval_r_with_result('g2_v_inner <- 200L')
+      33
+    end)
+
+    expect(inner_envelope).not_to be_nil
+    expect(inner_envelope[:type]).to eq(:scalar_integer)
+    expect(inner_envelope[:value]).to eq(200)
+    expect(result).to be_a(R::Object)
+  end
+end
+

data/new_bridge_specs/integration_phase5_4_concurrent_sessions_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Phase 5.4 concurrent session routing integration on the R.bridge seam.
+# Run:
+# bin/run_rspec specs/new_bridge/integration_phase5_4_concurrent_sessions_spec.rb
+
+
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.4 integration concurrent sessions (R.bridge seam)' do
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+  end
+
+  it 'isolates writes and reads per session under concurrency' do
+    bridge = R.bridge
+    expect(bridge).to respond_to(:with_session)
+
+    n_threads = 6
+    rounds = 8
+    values = Queue.new
+    errors = Queue.new
+
+    threads = n_threads.times.map do |tid|
+      Thread.new do
+        session = "sess-#{tid}"
+        rounds.times do |r|
+          expected = (tid * 100) + r
+          begin
+            got = bridge.with_session(session) do
+              bridge.eval_r_with_result("g2_v_slot <- #{expected}L")
+              bridge.eval_r_with_result('g2_v_read <- g2_v_slot')[:value]
+            end
+            values << [session, r, got, expected]
+          rescue => e
+            errors << [session, r, e.class.name, e.message]
+          end
+        end
+      end
+    end
+
+    threads.each(&:join)
+
+    expect(errors.size).to eq(0), "errors: #{errors.size}"
+    expect(values.size).to eq(n_threads * rounds)
+
+    until values.empty?
+      _session, _r, got, expected = values.pop(true) rescue break
+      expect(got).to eq(expected)
+    end
+  end
+end
+

data/new_bridge_specs/integration_phase5_4_nested_session_callbacks_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Phase 5.4 nested callback + session scoping integration.
+# Run:
+# bin/run_rspec specs/new_bridge/integration_phase5_4_nested_session_callbacks_spec.rb
+
+
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.4 integration nested callbacks with session scoping' do
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+  end
+
+  it 'keeps nested callback writes isolated to the active session' do
+    bridge = R.bridge
+    expect(bridge).to respond_to(:with_session)
+
+    out_a = bridge.with_session('nested-sess-a') do
+      bridge.eval_r('call_me <- function(f) { f() }')
+      R.call_me(proc do |_payload, _call_id|
+        bridge.eval_r_with_result('g2_v_ns <- 111L')
+        bridge.eval_r_with_result('g2_v_read <- g2_v_ns')[:value]
+      end)
+    end
+
+    out_b = bridge.with_session('nested-sess-b') do
+      bridge.eval_r('call_me <- function(f) { f() }')
+      R.call_me(proc do |_payload, _call_id|
+        bridge.eval_r_with_result('g2_v_ns <- 222L')
+        bridge.eval_r_with_result('g2_v_read <- g2_v_ns')[:value]
+      end)
+    end
+
+    read_a = bridge.with_session('nested-sess-a') do
+      bridge.eval_r_with_result('g2_v_read <- g2_v_ns')[:value]
+    end
+
+    read_b = bridge.with_session('nested-sess-b') do
+      bridge.eval_r_with_result('g2_v_read <- g2_v_ns')[:value]
+    end
+
+    expect(out_a).to be_a(R::Object)
+    expect(out_b).to be_a(R::Object)
+    expect(read_a).to eq(111)
+    expect(read_b).to eq(222)
+  end
+end
+

data/new_bridge_specs/integration_phase5_4_session_routing_spec.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Phase 5.4 session routing integration on the R.bridge seam.
+# Run:
+# bin/run_rspec specs/new_bridge/integration_phase5_4_session_routing_spec.rb
+
+
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.4 integration session routing (R.bridge seam)' do
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+  end
+
+  it 'keeps same handle name isolated across sessions' do
+    bridge = R.bridge
+    expect(bridge).to respond_to(:with_session)
+
+    a_value = bridge.with_session('sess-a') do
+      bridge.eval_r_with_result('g2_v_shared <- 10L')
+      bridge.eval_r_with_result('g2_v_read <- g2_v_shared')[:value]
+    end
+
+    b_value = bridge.with_session('sess-b') do
+      bridge.eval_r_with_result('g2_v_shared <- 20L')
+      bridge.eval_r_with_result('g2_v_read <- g2_v_shared')[:value]
+    end
+
+    again_a = bridge.with_session('sess-a') do
+      bridge.eval_r_with_result('g2_v_read <- g2_v_shared')[:value]
+    end
+
+    expect(a_value).to eq(10)
+    expect(b_value).to eq(20)
+    expect(again_a).to eq(10)
+  end
+end
+

data/new_bridge_specs/integration_phase5_5_stress_concurrency_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# Phase 5.5 stress-level concurrency integration on the R.bridge seam.
+# Run:
+# bin/run_rspec specs/new_bridge/integration_phase5_5_stress_concurrency_spec.rb
+
+
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.5 integration stress concurrency (R.bridge seam)' do
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+  end
+
+  it 'maintains session isolation under higher concurrent load' do
+    bridge = R.bridge
+    expect(bridge).to respond_to(:with_session)
+
+    n_threads = 12
+    rounds = 20
+    errors = Queue.new
+    ok_count = Queue.new
+
+    threads = n_threads.times.map do |tid|
+      Thread.new do
+        session = "stress-sess-#{tid}"
+        rounds.times do |r|
+          expected = (tid * 10_000) + r
+          begin
+            got = bridge.with_session(session) do
+              bridge.eval_r_with_result("g2_v_stress <- #{expected}L")
+              bridge.eval_r_with_result('g2_v_read <- g2_v_stress')[:value]
+            end
+            if got == expected
+              ok_count << true
+            else
+              errors << [session, r, :mismatch, got, expected]
+            end
+          rescue => e
+            errors << [session, r, e.class.name, e.message]
+          end
+        end
+      end
+    end
+
+    threads.each(&:join)
+
+    expect(errors.size).to eq(0), "errors=#{errors.size}"
+    expect(ok_count.size).to eq(n_threads * rounds)
+  end
+end
+

data/new_bridge_specs/integration_phase5_5_unbox_walk_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Phase 5.5 specialized unbox_walk traversal semantics.
+# Run:
+# bin/run_rspec specs/new_bridge/integration_phase5_5_unbox_walk_spec.rb
+
+
+require 'timeout'
+require_relative '../lib/R_interface/r'
+
+RSpec.describe 'Phase 5.5 integration unbox_walk (R.bridge seam)' do
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+  end
+
+  it 'reports depth_limit for deeply nested lists in one probe call' do
+    bridge = R.bridge
+    expect(bridge).to respond_to(:unbox_walk)
+
+    deep = R.list(1)
+    (R::Support::MAX_UNBOX_DEPTH + 10).times { deep = R.list(deep) }
+
+    result = Timeout.timeout(10) do
+      bridge.unbox_walk(deep.r_interop,
+                        max_depth: R::Support::MAX_UNBOX_DEPTH,
+                        max_nodes: 300_000)
+    end
+
+    expect(result[:status]).to eq(:depth_limit)
+    expect(result[:max_depth]).to be > R::Support::MAX_UNBOX_DEPTH
+  end
+
+  it 'materializes nested list/scalar trees in one call when supported' do
+    bridge = R.bridge
+    expect(bridge).to respond_to(:unbox_materialize)
+
+    tree = R.list(R.list(1, 2), R.list(3, 4))
+    result = bridge.unbox_materialize(tree.r_interop,
+                                      max_depth: R::Support::MAX_UNBOX_DEPTH,
+                                      max_nodes: 300_000)
+
+    expect(result[:status]).to eq(:ok)
+    expect(result[:value]).to eq([[1, 2], [3, 4]])
+  end
+end
+

data/new_bridge_specs/phase0_protocol_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+# Phase 0: envelope (MsgPack), framing, TCP echo, Rcpp load smoke test.
+# Run: bundle exec rspec specs/new_bridge/phase0_protocol_spec.rb
+
+require 'open3'
+require 'tempfile'
+
+root = File.expand_path('../..', __dir__)
+$LOAD_PATH.unshift(File.join(root, 'lib')) unless $LOAD_PATH.include?(File.join(root, 'lib'))
+
+require 'new_bridge'
+
+RSpec.describe 'NewBridge Phase 0' do
+  describe NewBridge::Envelope do
+    let(:sample) do
+      {
+        'call_id' => '550e8400-e29b-41d4-a716-446655440000',
+        'parent_id' => nil,
+        'type' => 'REQ',
+        'payload' => '1 + 1',
+        'status' => nil
+      }
+    end
+
+    it 'round-trips encode/decode' do
+      bytes = described_class.encode(sample)
+      out = described_class.decode(bytes)
+      expect(out['call_id']).to eq(sample['call_id'])
+      expect(out['type']).to eq('REQ')
+      expect(out['payload']).to eq('1 + 1')
+    end
+
+    it 'raises on invalid MsgPack' do
+      expect { described_class.decode("\xff\xff\xff") }.to raise_error(NewBridge::Envelope::Error, /invalid MsgPack/)
+    end
+
+    it 'raises on missing required keys' do
+      bad = MessagePack.pack('foo' => 'bar')
+      expect { described_class.decode(bad) }.to raise_error(NewBridge::Envelope::InvalidEnvelope, /missing keys/)
+    end
+  end
+
+  describe NewBridge::Framing do
+    it 'writes and reads one frame' do
+      io = StringIO.new(+'', 'r+')
+      payload = NewBridge::Envelope.encode(
+        'call_id' => 'a',
+        'type' => 'REQ',
+        'payload' => 'x'
+      )
+      described_class.write_frame(io, payload)
+      io.rewind
+      back = described_class.read_frame(io)
+      expect(back).to eq(payload)
+    end
+
+    it 'raises TruncatedFrame on short length prefix' do
+      io = StringIO.new("\x02\x00\x00\x00a", 'r') # length 2, only 1 byte body
+      expect { described_class.read_frame(io) }.to raise_error(NewBridge::Framing::TruncatedFrame)
+    end
+  end
+
+  describe NewBridge::TcpFramed do
+    it 'echoes one framed payload over TCP' do
+      payload = NewBridge::Envelope.encode('call_id' => 'b', 'type' => 'REQ', 'payload' => 'ok')
+      NewBridge::TcpFramed.with_echo_server do |port|
+        back = NewBridge::TcpFramed.send_receive('127.0.0.1', port, payload)
+        expect(back).to eq(payload)
+      end
+    end
+  end
+
+  describe 'Rcpp phase0 skeleton' do
+    cpp_path = File.expand_path('../ext/new_bridge/galaaz_gatekeeper_phase0.cpp', __dir__)
+
+    it 'loads via sourceCpp and runs galaaz_poll / galaaz_shutdown without hanging' do
+      skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+
+      cpp = cpp_path.gsub("'", "\\\\'")
+      r_script = <<~R
+        stopifnot(requireNamespace("Rcpp", quietly = TRUE))
+        library(Rcpp)
+        sourceCpp("#{cpp}")
+        p <- galaaz_poll()
+        stopifnot(length(p) == 0L)
+        galaaz_shutdown()
+        cat("PHASE0_RCPP_OK\\n")
+      R
+
+      stdout, stderr, status = Open3.capture3('R', '--slave', '--no-save', '-e', r_script)
+      expect(status.success?).to eq(true), "R failed:\nSTDOUT:\n#{stdout}\nSTDERR:\n#{stderr}"
+      expect(stdout).to include('PHASE0_RCPP_OK')
+    end
+  end
+end

data/new_bridge_specs/phase1_req_ret_spec.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# Phase 1: REQ/RET, per-session env, concurrency. Run: bundle exec rspec specs/new_bridge/phase1_req_ret_spec.rb
+
+root = File.expand_path('../..', __dir__)
+$LOAD_PATH.unshift(File.join(root, 'lib')) unless $LOAD_PATH.include?(File.join(root, 'lib'))
+
+require 'new_bridge'
+
+RSpec.describe 'NewBridge Phase 1 REQ/RET' do
+  let(:phase1_cpp) { File.expand_path('../ext/new_bridge/galaaz_gatekeeper_phase1.cpp', __dir__) }
+
+  before(:all) do
+    skip 'R not on PATH' unless system('command -v R >/dev/null 2>&1')
+    cpp = File.expand_path('../ext/new_bridge/galaaz_gatekeeper_phase1.cpp', __dir__)
+    @client = NewBridge::SessionClient.new(source_path: cpp)
+    @client.start
+  end
+
+  after(:all) do
+    @client&.stop
+  end
+
+  def with_client
+    yield @client
+  end
+
+  it 'evaluates 1+1 as integer 2' do
+    with_client do |c|
+      out = c.eval_r('1L + 1L')
+      expect(out['kind']).to eq('integer')
+      expect(out['value']).to eq(2)
+    end
+  end
+
+  it 'returns double scalar' do
+    with_client do |c|
+      out = c.eval_r('1.5 + 1')
+      expect(out['kind']).to eq('double')
+      expect(out['value']).to be_within(1e-9).of(2.5)
+    end
+  end
+
+  it 'isolates variables per session_id' do
+    with_client do |c|
+      c.eval_r('x <- 42L', session_id: 'sess-a')
+      c.eval_r('x <- 99L', session_id: 'sess-b')
+      expect(c.eval_r('x', session_id: 'sess-a')['value']).to eq(42)
+      expect(c.eval_r('x', session_id: 'sess-b')['value']).to eq(99)
+    end
+  end
+
+  it 'handles 10 concurrent Ruby threads with distinct sessions' do
+    with_client do |c|
+      threads = 10.times.map do |i|
+        Thread.new do
+          sid = "thr-#{i}"
+          c.eval_r("y <- #{i}L", session_id: sid)
+          c.eval_r('y', session_id: sid)['value']
+        end
+      end
+      values = threads.map(&:value)
+      expect(values.sort).to eq((0..9).to_a)
+    end
+  end
+end

data/new_bridge_specs/phase2_multi_instance_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# Phase 2: multi-instance correctness and isolation.
+# Run: bundle exec rspec specs/new_bridge/phase2_multi_instance_spec.rb
+
+root = File.expand_path('../..', __dir__)
+$LOAD_PATH.unshift(File.join(root, 'lib')) unless $LOAD_PATH.include?(File.join(root, 'lib'))
+
+require 'new_bridge'
+
+RSpec.describe 'NewBridge Phase 2 (REQ/RET Multi-instance)' do
+  before(:all) do
+    cpp_path = File.expand_path('../ext/new_bridge/galaaz_gatekeeper_phase1.cpp', __dir__)
+    @pool = NewBridge::InstancePoolClient.new(
+      source_path: cpp_path,
+      instances: ['instance-a', 'instance-b']
+    ).start
+  end
+
+  after(:all) do
+    @pool&.stop
+  end
+
+  it 'multi-instance correctness: same session_id on different instances stays isolated' do
+    @pool.eval_r('x <- 11L', session_id: 'shared-session', instance_id: 'instance-a')
+    @pool.eval_r('x <- 22L', session_id: 'shared-session', instance_id: 'instance-b')
+
+    a_val = @pool.eval_r('x', session_id: 'shared-session', instance_id: 'instance-a')
+    b_val = @pool.eval_r('x', session_id: 'shared-session', instance_id: 'instance-b')
+
+    expect(a_val['value']).to eq(11)
+    expect(b_val['value']).to eq(22)
+  end
+
+  it 'instance isolation under concurrency with distinct session_ids' do
+    threads = 20.times.map do |i|
+      Thread.new do
+        sid = "sess-#{i}"
+        inst = (i.even? ? 'instance-a' : 'instance-b')
+        @pool.eval_r("y <- #{i}L; y", session_id: sid, instance_id: inst)['value']
+      end
+    end
+
+    values = threads.map(&:value)
+    expect(values.sort).to eq((0..19).to_a)
+  end
+
+  it 'stress (light): many REQ calls across the pool' do
+    count = 100
+    threads = 10.times.map do |t|
+      Thread.new do
+        start_i = t * (count / 10)
+        end_i = start_i + (count / 10) - 1
+        inst = (t.even? ? 'instance-a' : 'instance-b')
+
+        (start_i..end_i).map do |i|
+          sid = "stress-sess-#{t}-#{i}"
+          @pool.eval_r("z <- #{i}L; z", session_id: sid, instance_id: inst)['value']
+        end
+      end
+    end
+
+    values = threads.flat_map(&:value)
+    expect(values.sort).to eq((0..(count - 1)).to_a)
+  end
+end
+