fractor 0.1.4 → 0.1.6

data/examples/simple/sample.rb

@@ -32,7 +32,7 @@
 #
 # =============================================================================
 
-require_relative "../../lib/fractor"
+require_relative '../../lib/fractor'
 
 # Client-specific work item implementation inheriting from Fractor::Work
 class MyWork < Fractor::Work
@@ -72,14 +72,14 @@ class MyWorker < Fractor::Worker
   # It should return a Fractor::WorkResult object
   def process(work)
     # Only print debug information if FRACTOR_DEBUG is enabled
-    puts "Working on '#{work.inspect}'" if ENV["FRACTOR_DEBUG"]
+    puts "Working on '#{work.inspect}'" if ENV['FRACTOR_DEBUG']
 
     # Check work type and handle accordingly
     if work.is_a?(MyWork)
       if work.value == 5
         # Return a Fractor::WorkResult for errors
         # Store the error object, not just the string
-        error = StandardError.new("Cannot process value 5")
+        error = StandardError.new('Cannot process value 5')
         return Fractor::WorkResult.new(error: error, work: work)
       end
 
@@ -116,8 +116,8 @@ if __FILE__ == $PROGRAM_NAME
   # Run the supervisor to start processing work
   supervisor.run
 
-  puts "Processing complete."
-  puts "Final Aggregated Results:"
+  puts 'Processing complete.'
+  puts 'Final Aggregated Results:'
   # Access the results aggregator from the supervisor
   puts supervisor.results.inspect
 

data/examples/specialized_workers/specialized_workers.rb

@@ -9,7 +9,7 @@ module SpecializedWorkers
       super({
         data: data,
         operation: operation,
-        parameters: parameters
+        parameters: parameters,
       })
     end
 
@@ -32,12 +32,13 @@ module SpecializedWorkers
 
   # Second work type: Database operations
   class DatabaseWork < Fractor::Work
-    def initialize(data = "", query_type = :select, table = "unknown", conditions = {})
+    def initialize(data = "", query_type = :select, table = "unknown",
+conditions = {})
       super({
         data: data,
         query_type: query_type,
         table: table,
-        conditions: conditions
+        conditions: conditions,
       })
     end
 
@@ -74,14 +75,16 @@ module SpecializedWorkers
       unless work.is_a?(ComputeWork)
         return Fractor::WorkResult.new(
           error: "ComputeWorker can only process ComputeWork, got: #{work.class}",
-          work: work
+          work: work,
         )
       end
 
       # Process based on the requested operation
       result = case work.operation
-               when :matrix_multiply then matrix_multiply(work.data, work.parameters)
-               when :image_transform then image_transform(work.data, work.parameters)
+               when :matrix_multiply then matrix_multiply(work.data,
+                                                          work.parameters)
+               when :image_transform then image_transform(work.data,
+                                                          work.parameters)
                when :path_finding then path_finding(work.data, work.parameters)
                else default_computation(work.data, work.parameters)
                end
@@ -90,9 +93,9 @@ module SpecializedWorkers
         result: {
           operation: work.operation,
           computation_result: result,
-          resources_used: @compute_resources
+          resources_used: @compute_resources,
         },
-        work: work
+        work: work,
       )
     end
 
@@ -110,7 +113,7 @@ module SpecializedWorkers
       # Simulate image transformation
       sleep(rand(0.1..0.3))
       transforms = params[:transforms] || %i[rotate scale]
-      "Image transformation applied: #{transforms.join(", ")} with parameters #{params}"
+      "Image transformation applied: #{transforms.join(', ')} with parameters #{params}"
     end
 
     def path_finding(_data, params)
@@ -140,7 +143,7 @@ module SpecializedWorkers
       unless work.is_a?(DatabaseWork)
         return Fractor::WorkResult.new(
           error: "DatabaseWorker can only process DatabaseWork, got: #{work.class}",
-          work: work
+          work: work,
         )
       end
 
@@ -148,7 +151,8 @@ module SpecializedWorkers
       result = case work.query_type
                when :select then perform_select(work.table, work.conditions)
                when :insert then perform_insert(work.table, work.data)
-               when :update then perform_update(work.table, work.data, work.conditions)
+               when :update then perform_update(work.table, work.data,
+                                                work.conditions)
                when :delete then perform_delete(work.table, work.conditions)
                else default_query(work.query_type, work.table, work.conditions)
                end
@@ -159,9 +163,9 @@ module SpecializedWorkers
           table: work.table,
           rows_affected: result[:rows_affected],
           data: result[:data],
-          execution_time: result[:time]
+          execution_time: result[:time],
         },
-        work: work
+        work: work,
       )
     end
 
@@ -174,8 +178,10 @@ module SpecializedWorkers
       record_count = rand(0..20)
       {
         rows_affected: record_count,
-        data: record_count.times.map { |i| { id: i + 1, name: "Record #{i + 1}" } },
-        time: rand(0.01..0.05)
+        data: Array.new(record_count) do |i|
+          { id: i + 1, name: "Record #{i + 1}" }
+        end,
+        time: rand(0.01..0.05),
       }
     end
 
@@ -185,7 +191,7 @@ module SpecializedWorkers
       {
         rows_affected: 1,
         data: { id: rand(1000..9999) },
-        time: rand(0.01..0.03)
+        time: rand(0.01..0.03),
       }
     end
 
@@ -196,7 +202,7 @@ module SpecializedWorkers
       {
         rows_affected: affected,
         data: nil,
-        time: rand(0.01..0.05)
+        time: rand(0.01..0.05),
       }
     end
 
@@ -207,7 +213,7 @@ module SpecializedWorkers
       {
         rows_affected: affected,
         data: nil,
-        time: rand(0.01..0.03)
+        time: rand(0.01..0.03),
       }
     end
 
@@ -217,7 +223,7 @@ module SpecializedWorkers
       {
         rows_affected: 0,
         data: nil,
-        time: rand(0.005..0.01)
+        time: rand(0.005..0.01),
       }
     end
   end
@@ -230,14 +236,14 @@ module SpecializedWorkers
       # Create separate supervisors for each worker type
       @compute_supervisor = Fractor::Supervisor.new(
         worker_pools: [
-          { worker_class: ComputeWorker, num_workers: compute_workers }
-        ]
+          { worker_class: ComputeWorker, num_workers: compute_workers },
+        ],
       )
 
       @db_supervisor = Fractor::Supervisor.new(
         worker_pools: [
-          { worker_class: DatabaseWorker, num_workers: db_workers }
-        ]
+          { worker_class: DatabaseWorker, num_workers: db_workers },
+        ],
       )
 
       @compute_results = []
@@ -253,7 +259,8 @@ module SpecializedWorkers
 
       # Create and add database work items
       db_work_items = db_tasks.map do |task|
-        DatabaseWork.new(task[:data], task[:query_type], task[:table], task[:conditions])
+        DatabaseWork.new(task[:data], task[:query_type], task[:table],
+                         task[:conditions])
       end
       @db_supervisor.add_work_items(db_work_items)
 
@@ -277,13 +284,13 @@ module SpecializedWorkers
         computation: {
           tasks: compute_tasks.size,
           completed: @compute_results.size,
-          results: @compute_results
+          results: @compute_results,
         },
         database: {
           tasks: db_tasks.size,
           completed: @db_results.size,
-          results: @db_results
-        }
+          results: @db_results,
+        },
       }
     end
 
@@ -316,18 +323,18 @@ if __FILE__ == $PROGRAM_NAME
     {
       operation: :matrix_multiply,
       data: "Matrix data...",
-      parameters: { size: [10, 10] }
+      parameters: { size: [10, 10] },
     },
     {
       operation: :image_transform,
       data: "Image data...",
-      parameters: { transforms: %i[rotate scale blur], angle: 45, scale: 1.5 }
+      parameters: { transforms: %i[rotate scale blur], angle: 45, scale: 1.5 },
     },
     {
       operation: :path_finding,
       data: "Graph data...",
-      parameters: { algorithm: :dijkstra, nodes: 20, start: 1, end: 15 }
-    }
+      parameters: { algorithm: :dijkstra, nodes: 20, start: 1, end: 15 },
+    },
   ]
 
   # Prepare database tasks
@@ -335,24 +342,24 @@ if __FILE__ == $PROGRAM_NAME
     {
       query_type: :select,
       table: "users",
-      conditions: { active: true, role: "admin" }
+      conditions: { active: true, role: "admin" },
     },
     {
       query_type: :insert,
       table: "orders",
-      data: "Order data..."
+      data: "Order data...",
     },
     {
       query_type: :update,
       table: "products",
       data: "Product data...",
-      conditions: { category: "electronics" }
+      conditions: { category: "electronics" },
     },
     {
       query_type: :delete,
       table: "sessions",
-      conditions: { expired: true }
-    }
+      conditions: { expired: true },
+    },
   ]
 
   compute_workers = 2
@@ -363,7 +370,7 @@ if __FILE__ == $PROGRAM_NAME
   start_time = Time.now
   system = SpecializedWorkers::HybridSystem.new(
     compute_workers: compute_workers,
-    db_workers: db_workers
+    db_workers: db_workers,
   )
   result = system.process_mixed_workload(compute_tasks, db_tasks)
   end_time = Time.now

data/lib/fractor/continuous_server.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Fractor
+  # High-level wrapper for running Fractor in continuous mode.
+  # Handles threading, signal handling, and results processing automatically.
+  class ContinuousServer
+    attr_reader :supervisor, :work_queue
+
+    # Initialize a continuous server
+    # @param worker_pools [Array<Hash>] Worker pool configurations
+    # @param work_queue [WorkQueue, nil] Optional work queue to auto-register
+    # @param log_file [String, nil] Optional log file path
+    def initialize(worker_pools:, work_queue: nil, log_file: nil)
+      @worker_pools = worker_pools
+      @work_queue = work_queue
+      @log_file_path = log_file
+      @log_file = nil
+      @result_callbacks = []
+      @error_callbacks = []
+      @supervisor = nil
+      @supervisor_thread = nil
+      @results_thread = nil
+      @running = false
+    end
+
+    # Register a callback for successful results
+    # @yield [WorkResult] The successful result
+    def on_result(&block)
+      @result_callbacks << block
+    end
+
+    # Register a callback for errors
+    # @yield [WorkResult] The error result
+    def on_error(&block)
+      @error_callbacks << block
+    end
+
+    # Start the server and block until shutdown
+    # This method handles:
+    # - Opening log file if specified
+    # - Creating and starting supervisor
+    # - Starting results processing thread
+    # - Setting up signal handlers
+    # - Blocking until shutdown signal received
+    def run
+      setup_log_file
+      setup_supervisor
+      start_supervisor_thread
+      start_results_thread
+
+      log_message("Continuous server started")
+      log_message("Press Ctrl+C to stop")
+
+      begin
+        # Block until shutdown
+        @supervisor_thread&.join
+      rescue Interrupt
+        log_message("Interrupt received, shutting down...")
+      ensure
+        cleanup
+      end
+    end
+
+    # Stop the server programmatically
+    def stop
+      return unless @running
+
+      log_message("Stopping continuous server...")
+      @running = false
+
+      @supervisor&.stop
+
+      # Wait for threads to finish
+      [@supervisor_thread, @results_thread].compact.each do |thread|
+        thread.join(2) if thread.alive?
+      end
+
+      log_message("Continuous server stopped")
+    end
+
+    private
+
+    def setup_log_file
+      return unless @log_file_path
+
+      FileUtils.mkdir_p(File.dirname(@log_file_path))
+      @log_file = File.open(@log_file_path, "w")
+    end
+
+    def setup_supervisor
+      @supervisor = Supervisor.new(
+        worker_pools: @worker_pools,
+        continuous_mode: true,
+      )
+
+      # Auto-register work queue if provided
+      if @work_queue
+        @work_queue.register_with_supervisor(@supervisor)
+        log_message(
+          "Work queue registered with supervisor (batch size: 10)",
+        )
+      end
+    end
+
+    def start_supervisor_thread
+      @running = true
+      @supervisor_thread = Thread.new do
+        @supervisor.run
+      rescue StandardError => e
+        log_message("Supervisor error: #{e.message}")
+        log_message(e.backtrace.join("\n")) if ENV["FRACTOR_DEBUG"]
+      end
+
+      # Give supervisor time to start up
+      sleep(0.1)
+    end
+
+    def start_results_thread
+      @results_thread = Thread.new do
+        log_message("Results processing thread started")
+        process_results_loop
+      rescue StandardError => e
+        log_message("Results thread error: #{e.message}")
+        log_message(e.backtrace.join("\n")) if ENV["FRACTOR_DEBUG"]
+      end
+    end
+
+    def process_results_loop
+      while @running
+        sleep(0.05)
+
+        process_successful_results
+        process_error_results
+      end
+      log_message("Results processing thread stopped")
+    end
+
+    def process_successful_results
+      loop do
+        result = @supervisor.results.results.shift
+        break unless result
+
+        @result_callbacks.each do |callback|
+          callback.call(result)
+        rescue StandardError => e
+          log_message("Error in result callback: #{e.message}")
+        end
+      end
+    end
+
+    def process_error_results
+      loop do
+        error_result = @supervisor.results.errors.shift
+        break unless error_result
+
+        @error_callbacks.each do |callback|
+          callback.call(error_result)
+        rescue StandardError => e
+          log_message("Error in error callback: #{e.message}")
+        end
+      end
+    end
+
+    def cleanup
+      @running = false
+
+      # Close log file if open
+      if @log_file && !@log_file.closed?
+        @log_file.close
+        @log_file = nil
+      end
+    end
+
+    def log_message(message)
+      timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S.%L")
+      log_entry = "[#{timestamp}] #{message}"
+
+      if @log_file && !@log_file.closed?
+        @log_file.puts(log_entry)
+        @log_file.flush
+      end
+
+      puts log_entry
+    end
+  end
+end

data/lib/fractor/result_aggregator.rb

@@ -36,7 +36,7 @@ module Fractor
     def inspect
       {
         results: @results.map(&:inspect),
-        errors: @errors.map(&:inspect)
+        errors: @errors.map(&:inspect),
       }
     end
   end