fractor 0.1.0

data/tests/sample_working.rb.bak

@@ -0,0 +1,209 @@
+#!/usr/bin/env ruby
+
+
+class Worker
+  def process(work)
+    raise NotImplementedError, "This #{self.class} cannot respond to:"
+  end
+end
+
+class MyWorker < Worker
+  # This method is called by the Ractor to process the work
+  # It should return a WorkResult object
+  # If there is an error, it should raise an exception
+  # The Ractor will catch the exception and send it back to the main thread
+  def process(work)
+    puts "Working on '#{work.inspect}'"
+
+    if work.input == 5
+      return WorkResult.new(error: "Error processing work #{work.input}", work: work)
+    end
+
+    calculated = work.input * 2
+    WorkResult.new(result: calculated, work: work)
+  end
+end
+
+class Work
+  attr_reader :input
+  def initialize(input)
+    @input = input
+  end
+
+  def to_s
+    "Work: #{@input}"
+  end
+end
+
+class MyWork < Work
+  def initialize(input)
+    super
+  end
+
+  def to_s
+    "MyWork: #{@input}"
+  end
+end
+
+class WorkResult
+  attr_reader :result, :error, :work
+  def initialize(result: nil, error: nil, work: nil)
+    @result = result
+    @error = error
+    @work = work
+  end
+
+  def success?
+    !@error
+  end
+
+  def to_s
+    if success?
+      "Result: #{@result}"
+    else
+      "Error: #{@error}, Work: #{@work}"
+    end
+  end
+end
+
+
+class ResultAggregator
+  attr_reader :results, :errors
+
+  # This class is used to aggregate the results and errors from the Ractors
+  # It will store the results and errors in separate arrays
+  # It will also provide a method to print the results and errors
+  def initialize
+    @results = []
+    @errors = []
+  end
+
+  def add_result(result)
+    if result.success?
+      puts "Work completed successfully: #{result}"
+      @results << result
+    else
+      puts "Error processing work: #{result}"
+      @errors << result
+    end
+  end
+
+  def to_s
+    "Results: #{@results.each(&:to_s).join(", ")}, Errors: #{@errors.each(&:to_s).join(", ")}"
+  end
+
+  def inspect
+    {
+      results: @results.map(&:to_s),
+      errors: @errors.map(&:to_s)
+    }
+  end
+end
+
+class MyRactor
+  def initialize(name)
+    puts "Creating Ractor #{name}"
+    @name = name
+  end
+
+  def start
+    puts "Starting Ractor #{@name}"
+    @ractor = Ractor.new(@name) do |name|
+      puts "Ractor #{name} started"
+      Ractor.yield({ type: :initialize, processor: name })
+      worker = MyWorker.new
+
+      loop do
+        puts "Waiting for work in #{name}"
+        work = Ractor.receive
+        puts "Received work #{work} in #{name}"
+        begin
+          result = worker.process(work)
+          puts "Sending result #{result} from Ractor #{name}"
+          Ractor.yield({ type: :result, result: result })
+        rescue StandardError => e
+          puts "Error processing work #{work} in Ractor #{name}: #{e.message}"
+          Ractor.yield({ type: :error, error: e.message, processor: name, work: work })
+        end
+      end
+    end
+  end
+
+  def ractor
+    @ractor
+  end
+end
+
+# TODO: Create a class that contains the work queue and the results
+q = Queue.new
+(1..10).each do |i|
+  q << i
+end
+
+puts "Queue: #{q.inspect}"
+puts "Queue size: #{q.size}"
+
+# Create Ractors
+workers = (1..2).map do |i|
+  MyRactor.new("worker #{i}")
+end
+
+results = ResultAggregator.new
+result_number = q.size
+
+workers.each(&:start)
+puts "Ractors started"
+
+CR = Ractor.current
+
+Signal.trap("INT") do
+  puts "\nCtrl+C received. Requesting graceful shutdown..."
+  CR.send({ type: :shutdown })
+  puts "Shutdown request sent to Ractor #{CR}"
+  # exit(1)
+  # Do not exit here, let the main loop break
+end
+
+while !q.empty?
+  puts "Queue not empty, still contains #{q.size} items"
+
+  puts "Selecting Ractor"
+  ractor, completed_work = Ractor.select(*workers.map(&:ractor), CR)
+
+  puts "Selected Ractor returned: #{ractor}, completed work: #{completed_work}"
+
+  case completed_work[:type]
+  when :shutdown
+    puts "Shutdown request received in Ractor: #{completed_work[:processor]}"
+    break
+  when :initialize
+    puts "Initializing Ractor: #{completed_work[:processor]}"
+  when :result
+    puts "Completed work: #{completed_work[:result]} in Ractor: #{completed_work[:processor]}"
+    results.add_result(completed_work[:result])
+    puts "Results: #{results.inspect}"
+
+    # TODO: Instead of using a separate variable, we should rely on an object
+    # that contains both the work queue and their results
+    result_number -= 1
+    break if result_number == 0
+  when :error
+    # TODO: We have to put these on a "Failed Work" queue
+    puts "Error processing work #{completed_work[:work]} in Ractor: #{completed_work[:processor]}: #{completed_work[:error]}"
+    errors << { error: completed_work[:error], work: completed_work[:work] }
+    result_number -= 1
+    break if result_number == 0
+  else
+    puts "Unknown message type received: #{completed_work[:type]}"
+  end
+
+  puts "Sending work to Ractor"
+  puts "Queue: #{q.inspect}"
+  queued_work = q.pop
+  puts "Popped work: #{queued_work} from queue"
+  puts "Sending work to Ractor: #{ractor}"
+  ractor.send(MyWork.new(queued_work))
+  puts "Work sent to Ractor: #{ractor}"
+end
+
+puts "Results: #{results.inspect}"

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: fractor
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ronald Tse
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-05-05 00:00:00.000000000 Z
+dependencies: []
+description: Fractor is a lightweight Ruby framework designed to simplify the process
+  of distributing computational work across multiple Ractors.
+email:
+- ronald.tse@ribose.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CODE_OF_CONDUCT.md
+- README.adoc
+- Rakefile
+- examples/hierarchical_hasher.rb
+- examples/producer_subscriber.rb
+- lib/fractor.rb
+- lib/fractor/result_aggregator.rb
+- lib/fractor/supervisor.rb
+- lib/fractor/version.rb
+- lib/fractor/work.rb
+- lib/fractor/work_result.rb
+- lib/fractor/worker.rb
+- lib/fractor/wrapped_ractor.rb
+- sample.rb
+- sig/fractor.rbs
+- tests/sample.rb.bak
+- tests/sample_working.rb.bak
+homepage: https://github.com/ribose/fractor
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/ribose/fractor
+  source_code_uri: https://github.com/ribose/fractor
+  changelog_uri: https://github.com/ribose/fractor/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Function-driven Ractors framework for Ruby
+test_files: []