fractor 0.1.3 → 0.1.6

data/examples/continuous_chat_server/simulate.rb

@@ -0,0 +1,343 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "fileutils"
+require "optparse"
+require "json"
+
+module ContinuousChat
+  # Simulation controller that manages the server and clients
+  class Simulation
+    attr_reader :server_port, :log_dir
+
+    def initialize(server_port = 3000, duration = 10, log_dir = "logs")
+      @server_port = server_port
+      @duration = duration
+      @log_dir = log_dir
+      @server_pid = nil
+      @client_pids = {}
+      @running = false
+
+      # Create log directory if it doesn't exist
+      FileUtils.mkdir_p(@log_dir)
+    end
+
+    # Start the simulation
+    def start
+      puts "Starting chat simulation on port #{@server_port}"
+      puts "Logs will be saved to #{@log_dir}"
+
+      # Start the server
+      start_server
+
+      # Give the server time to initialize
+      puts "Waiting for server to initialize..."
+      sleep(2)
+
+      # Start the clients
+      start_clients
+
+      @running = true
+      puts "Chat simulation started"
+
+      # Wait for the specified duration
+      puts "Simulation will run for #{@duration} seconds"
+
+      # Give clients time to connect
+      sleep(2)
+      puts "Clients should be connecting now..."
+
+      # Wait for messages to be processed
+      remaining_time = @duration - 4
+      if remaining_time.positive?
+        puts "Waiting #{remaining_time} more seconds for processing..."
+        sleep(remaining_time)
+      end
+
+      puts "Simulation time complete, stopping..."
+
+      # Stop the simulation
+      stop
+
+      # Analyze the logs
+      analyze_logs
+
+      true
+    rescue StandardError => e
+      puts "Failed to start simulation: #{e.message}"
+      stop
+      false
+    end
+
+    # Stop the simulation
+    def stop
+      puts "Stopping chat simulation..."
+
+      # Stop all clients
+      stop_clients
+
+      # Stop the server
+      stop_server
+
+      @running = false
+      puts "Chat simulation stopped"
+    end
+
+    private
+
+    # Start the server process
+    def start_server
+      server_log_file = File.join(@log_dir, "server_messages.log")
+
+      # Get the directory where this script is located
+      script_dir = File.dirname(__FILE__)
+      server_script = File.join(script_dir, "chat_server.rb")
+
+      server_cmd = "ruby #{server_script} #{@server_port} #{server_log_file}"
+
+      puts "Starting server: #{server_cmd}"
+
+      # Start the server process as a fork
+      @server_pid = fork do
+        exec(server_cmd)
+      end
+
+      puts "Server started with PID #{@server_pid}"
+    end
+
+    # Stop the server process
+    def stop_server
+      return unless @server_pid
+
+      puts "Stopping server (PID #{@server_pid})..."
+
+      # Send SIGINT to the server process
+      begin
+        Process.kill("INT", @server_pid)
+        # Give it a moment to shut down gracefully
+        sleep(1)
+
+        # Force kill if still running
+        Process.kill("KILL", @server_pid) if process_running?(@server_pid)
+      rescue Errno::ESRCH
+        # Process already gone
+      end
+
+      @server_pid = nil
+      puts "Server stopped"
+    end
+
+    # Start client processes
+    def start_clients
+      # Define the client usernames and their messages
+      clients = {
+        "alice" => [
+          { content: "Hello everyone!", recipient: "all" },
+          { content: "I'm working on a Ruby project using sockets",
+            recipient: "all" },
+          { content: "It's a simple chat server and client", recipient: "all" },
+        ],
+        "bob" => [
+          { content: "Hi Alice!", recipient: "alice" },
+          { content: "That sounds interesting. What kind of project?",
+            recipient: "alice" },
+          { content: "Cool! I love Ruby's socket features",
+            recipient: "alice" },
+        ],
+        "charlie" => [
+          { content: "How's everyone doing today?", recipient: "all" },
+          { content: "Are you using any specific libraries?",
+            recipient: "alice" },
+          { content: "Non-blocking IO in chat clients is efficient",
+            recipient: "all" },
+        ],
+      }
+
+      puts "Starting #{clients.size} clients: #{clients.keys.join(', ')}"
+
+      # Start each client in a separate process
+      clients.each do |username, messages|
+        start_client(username, messages)
+      end
+    end
+
+    # Start a single client process
+    def start_client(username, messages)
+      client_log_file = File.join(@log_dir, "client_#{username}_messages.log")
+      messages_file = File.join(@log_dir,
+                                "client_#{username}_send_messages.json")
+
+      # Write the messages to a JSON file
+      File.write(messages_file, JSON.generate(messages))
+
+      # Get the directory where this script is located
+      script_dir = File.dirname(__FILE__)
+      client_script = File.join(script_dir, "chat_client.rb")
+
+      # Build the client command
+      client_cmd = "ruby #{client_script} #{username} #{@server_port} #{client_log_file}"
+
+      puts "Starting client #{username}"
+
+      # Start the client process as a fork
+      @client_pids[username] = fork do
+        exec(client_cmd)
+      end
+
+      puts "Client #{username} started with PID #{@client_pids[username]}"
+    end
+
+    # Stop all client processes
+    def stop_clients
+      return if @client_pids.empty?
+
+      puts "Stopping #{@client_pids.size} clients..."
+
+      @client_pids.each do |username, pid|
+        # Try to gracefully terminate the process
+        begin
+          Process.kill("INT", pid)
+          # Give it a moment to shut down
+          sleep(0.5)
+
+          # Force kill if still running
+          Process.kill("KILL", pid) if process_running?(pid)
+        rescue Errno::ESRCH
+          # Process already gone
+        end
+
+        puts "Client #{username} stopped"
+      rescue StandardError => e
+        puts "Error stopping client #{username}: #{e.message}"
+      end
+
+      @client_pids.clear
+    end
+
+    # Check if a process is still running
+    def process_running?(pid)
+      Process.getpgid(pid)
+      true
+    rescue Errno::ESRCH
+      false
+    end
+
+    # Analyze the log files after the simulation
+    def analyze_logs
+      puts "\nSimulation Results"
+      puts "================="
+
+      # Analyze server log
+      server_log_file = File.join(@log_dir, "server_messages.log")
+      if File.exist?(server_log_file)
+        server_log = File.readlines(server_log_file)
+        puts "Server processed #{server_log.size} log entries"
+
+        # Count message types
+        message_count = server_log.count do |line|
+          line.include?("Received from")
+        end
+        broadcast_count = server_log.count do |line|
+          line.include?('Broadcasting: {:type=>"broadcast"')
+        end
+        direct_count = server_log.count do |line|
+          line =~ /Received from \w+:.*"recipient":"(?!all)/
+        end
+
+        puts "  - #{message_count} messages received from clients"
+        puts "  - #{broadcast_count} broadcast messages sent"
+        puts "  - #{direct_count} direct messages sent"
+      else
+        puts "Server log file not found"
+      end
+
+      puts "\nClient Activity:"
+      # Analyze each client log
+      @client_pids.each_key do |username|
+        client_log_file = File.join(@log_dir, "client_#{username}_messages.log")
+        if File.exist?(client_log_file)
+          client_log = File.readlines(client_log_file)
+          sent_count = client_log.count { |line| line.include?("Sent message") }
+          received_count = client_log.count do |line|
+            line.include?("Received:")
+          end
+
+          puts "  #{username}: Sent #{sent_count} messages, Received #{received_count} messages"
+        else
+          puts "  #{username}: Log file not found"
+        end
+      end
+
+      puts "\nLog files are available in the #{@log_dir} directory for detailed analysis."
+    end
+  end
+end
+
+# When run directly, start the simulation
+if __FILE__ == $PROGRAM_NAME
+  options = {
+    port: 3000,
+    duration: 10,
+    log_dir: "logs",
+  }
+
+  # Parse command line options
+  OptionParser.new do |opts|
+    opts.banner = "Usage: ruby simulate.rb [options]"
+
+    opts.on("-p", "--port PORT", Integer,
+            "Server port (default: 3000)") do |port|
+      options[:port] = port
+    end
+
+    opts.on("-d", "--duration SECONDS", Integer,
+            "Simulation duration in seconds (default: 10)") do |duration|
+      options[:duration] = duration
+    end
+
+    opts.on("-l", "--log-dir DIR",
+            "Directory for log files (default: logs)") do |dir|
+      options[:log_dir] = dir
+    end
+
+    opts.on("-h", "--help", "Show this help message") do
+      puts opts
+      exit
+    end
+  end.parse!
+
+  puts "Starting Chat Simulation"
+  puts "======================"
+  puts "This simulation runs a chat server and multiple clients as separate processes"
+  puts "to demonstrate a basic chat application with socket communication."
+  puts
+
+  # Create and run the simulation
+  simulation = ContinuousChat::Simulation.new(
+    options[:port],
+    options[:duration],
+    options[:log_dir],
+  )
+
+  # Set up signal handlers to properly clean up child processes
+  Signal.trap("INT") do
+    puts "\nSimulation interrupted"
+    simulation.stop
+    exit
+  end
+
+  Signal.trap("TERM") do
+    puts "\nSimulation terminated"
+    simulation.stop
+    exit
+  end
+
+  begin
+    simulation.start
+  rescue Interrupt
+    puts "\nSimulation interrupted"
+    simulation.stop
+  end
+
+  puts "Simulation completed"
+end

data/examples/hierarchical_hasher/hierarchical_hasher.rb

@@ -10,7 +10,7 @@ module HierarchicalHasher
       super({
         data: data,
         start: start,
-        length: length || data.bytesize
+        length: length || data.bytesize,
       })
     end
 
@@ -46,15 +46,15 @@ module HierarchicalHasher
           result: {
             start: work.start,
             length: work.length,
-            hash: hash
+            hash: hash,
           },
-          work: work
+          work: work,
         )
       rescue StandardError => e
         # Return error result if something goes wrong
         Fractor::WorkResult.new(
           error: "Failed to hash chunk: #{e.message}",
-          work: work
+          work: work,
         )
       end
     end
@@ -74,8 +74,8 @@ module HierarchicalHasher
       # Create the supervisor with our worker class in a worker pool
       supervisor = Fractor::Supervisor.new(
         worker_pools: [
-          { worker_class: HashWorker, num_workers: @worker_count }
-        ]
+          { worker_class: HashWorker, num_workers: @worker_count },
+        ],
       )
 
       # Load the file and create work chunks
@@ -111,10 +111,14 @@ module HierarchicalHasher
       return nil if results_aggregator.results.empty?
 
       # Sort results by start position
-      sorted_results = results_aggregator.results.sort_by { |result| result.result[:start] }
+      sorted_results = results_aggregator.results.sort_by do |result|
+        result.result[:start]
+      end
 
       # Concatenate all hashes with newlines
-      combined_hash_string = sorted_results.map { |result| result.result[:hash] }.join("\n")
+      combined_hash_string = sorted_results.map do |result|
+        result.result[:hash]
+      end.join("\n")
 
       # Calculate final SHA-256 hash (instead of SHA3)
       Digest::SHA256.hexdigest(combined_hash_string)

data/examples/multi_work_type/multi_work_type.rb

@@ -45,7 +45,7 @@ module MultiWorkType
     end
 
     def to_s
-      "ImageWork: dimensions=#{dimensions.join("x")}, format=#{format}"
+      "ImageWork: dimensions=#{dimensions.join('x')}, format=#{format}"
     end
   end
 
@@ -62,7 +62,7 @@ module MultiWorkType
         error = TypeError.new("Unsupported work type: #{work.class}")
         Fractor::WorkResult.new(
           error: error,
-          work: work
+          work: work,
         )
       end
     end
@@ -74,7 +74,8 @@ module MultiWorkType
       sleep(rand(0.01..0.05)) # Simulate processing time
 
       processed_text = case work.format
-                       when :markdown then process_markdown(work.data, work.options)
+                       when :markdown then process_markdown(work.data,
+                                                            work.options)
                        when :html then process_html(work.data, work.options)
                        when :json then process_json(work.data, work.options)
                        else work.data.upcase # Simple transformation for plain text
@@ -87,10 +88,10 @@ module MultiWorkType
           transformed_data: processed_text,
           metadata: {
             word_count: processed_text.split(/\s+/).size,
-            char_count: processed_text.length
-          }
+            char_count: processed_text.length,
+          },
         },
-        work: work
+        work: work,
       )
     end
 
@@ -110,13 +111,13 @@ module MultiWorkType
         applied_filters: %i[sharpen contrast],
         processing_metadata: {
           original_size: input_size,
-          processed_size: (input_size * 0.8).to_i # Simulate compression
-        }
+          processed_size: (input_size * 0.8).to_i, # Simulate compression
+        },
       }
 
       Fractor::WorkResult.new(
         result: simulated_result,
-        work: work
+        work: work,
       )
     end
 
@@ -127,7 +128,7 @@ module MultiWorkType
       links = text.scan(/\[(.+?)\]\((.+?)\)/)
 
       "Processed Markdown: #{text.length} chars, #{headers.size} headers, #{links.size} links\n" \
-        "Headers: #{headers.join(", ")}\n" \
+        "Headers: #{headers.join(', ')}\n" \
         "#{text.gsub(/^#+\s+(.+)$/, '💫 \1 💫')}"
     end
 
@@ -136,7 +137,7 @@ module MultiWorkType
       tags = text.scan(/<(\w+)[^>]*>/).flatten
 
       "Processed HTML: #{text.length} chars, #{tags.size} tags\n" \
-        "Tags: #{tags.uniq.join(", ")}\n" \
+        "Tags: #{tags.uniq.join(', ')}\n" \
         "#{text.gsub(%r{<(\w+)[^>]*>(.+?)</\1>}, '✨\2✨')}"
     end
 
@@ -147,7 +148,7 @@ module MultiWorkType
       keys = data.keys
 
       "Processed JSON: #{keys.size} top-level keys\n" \
-        "Keys: #{keys.join(", ")}\n" \
+        "Keys: #{keys.join(', ')}\n" \
         "Pretty-printed: #{data}"
     rescue StandardError => e
       "Invalid JSON: #{e.message}"
@@ -162,14 +163,14 @@ module MultiWorkType
       # Create supervisor with a MultiFormatWorker pool
       @supervisor = Fractor::Supervisor.new(
         worker_pools: [
-          { worker_class: MultiFormatWorker, num_workers: worker_count }
-        ]
+          { worker_class: MultiFormatWorker, num_workers: worker_count },
+        ],
       )
 
       @results = {
         text: [],
         image: [],
-        errors: []
+        errors: [],
       }
     end
 
@@ -197,10 +198,10 @@ module MultiWorkType
         total_items: text_items.size + image_items.size,
         processed: {
           text: @results[:text].size,
-          image: @results[:image].size
+          image: @results[:image].size,
         },
         errors: @results[:errors].size,
-        results: @results
+        results: @results,
       }
     end
 
@@ -220,7 +221,7 @@ module MultiWorkType
       results_aggregator.errors.each do |error_result|
         @results[:errors] << {
           error: error_result.error,
-          work_type: error_result.work.class.name
+          work_type: error_result.work.class.name,
         }
       end
 
@@ -244,21 +245,21 @@ if __FILE__ == $PROGRAM_NAME
   text_items = [
     {
       data: "This is a plain text document. It has no special formatting.",
-      format: :plain
+      format: :plain,
     },
     {
       data: "# Markdown Document\n\nThis is a **bold** statement. Here's a [link](https://example.com).",
-      format: :markdown
+      format: :markdown,
     },
     {
       data: "<html><body><h1>HTML Document</h1><p>This is a paragraph.</p></body></html>",
-      format: :html
+      format: :html,
     },
     {
       data: "{name: 'Product', price: 29.99, tags: ['electronics', 'gadget']}",
       format: :json,
-      options: { pretty: true }
-    }
+      options: { pretty: true },
+    },
   ]
 
   # Sample image items (simulated)
@@ -266,18 +267,18 @@ if __FILE__ == $PROGRAM_NAME
     {
       data: "simulated_jpeg_data_1",
       dimensions: [800, 600],
-      format: :jpeg
+      format: :jpeg,
     },
     {
       data: "simulated_png_data_1",
       dimensions: [1024, 768],
-      format: :png
+      format: :png,
     },
     {
       data: "simulated_gif_data_1",
       dimensions: [320, 240],
-      format: :gif
-    }
+      format: :gif,
+    },
   ]
 
   worker_count = 4
@@ -309,8 +310,8 @@ if __FILE__ == $PROGRAM_NAME
   puts "Image Processing Results:"
   result[:results][:image].each_with_index do |image_result, index|
     puts "Image Item #{index + 1} (#{image_result[:format]}):"
-    puts "  Dimensions: #{image_result[:dimensions].join("x")}"
-    puts "  Applied filters: #{image_result[:applied_filters].join(", ")}"
+    puts "  Dimensions: #{image_result[:dimensions].join('x')}"
+    puts "  Applied filters: #{image_result[:applied_filters].join(', ')}"
     puts "  Compression: #{(1 - image_result[:processing_metadata][:processed_size].to_f / image_result[:processing_metadata][:original_size]).round(2) * 100}%"
     puts
   end

data/examples/pipeline_processing/pipeline_processing.rb

@@ -9,7 +9,7 @@ module PipelineProcessing
       super({
         data: data,
         stage: stage,
-        metadata: metadata
+        metadata: metadata,
       })
     end
 
@@ -29,7 +29,7 @@ module PipelineProcessing
       "MediaWork: stage=#{stage}, metadata=#{metadata}, data_size=#{begin
         data.bytesize
       rescue StandardError
-        "unknown"
+        'unknown'
       end}"
     end
   end
@@ -46,7 +46,7 @@ module PipelineProcessing
                else
                  return Fractor::WorkResult.new(
                    error: "Unknown stage: #{work.stage}",
-                   work: work
+                   work: work,
                  )
                end
 
@@ -58,7 +58,7 @@ module PipelineProcessing
       # Update metadata with processing information
       updated_metadata = work.metadata.merge(
         "#{work.stage}_completed" => true,
-        "#{work.stage}_time" => Time.now.to_s
+        "#{work.stage}_time" => Time.now.to_s,
       )
 
       # Return the result with next stage information
@@ -67,9 +67,9 @@ module PipelineProcessing
           processed_data: result,
           current_stage: work.stage,
           next_stage: next_stage,
-          metadata: updated_metadata
+          metadata: updated_metadata,
         },
-        work: work
+        work: work,
       )
     end
 
@@ -95,7 +95,7 @@ module PipelineProcessing
       sleep(rand(0.01..0.05)) # Simulate processing time
       tags = %w[landscape portrait nature urban abstract]
       selected_tags = tags.sample(rand(1..3))
-      "Tagged image: #{work.data} (tags: #{selected_tags.join(", ")})"
+      "Tagged image: #{work.data} (tags: #{selected_tags.join(', ')})"
     end
   end
 
@@ -106,8 +106,8 @@ module PipelineProcessing
     def initialize(worker_count = 4)
       @supervisor = Fractor::Supervisor.new(
         worker_pools: [
-          { worker_class: PipelineWorker, num_workers: worker_count }
-        ]
+          { worker_class: PipelineWorker, num_workers: worker_count },
+        ],
       )
 
       # Register callback to handle pipeline stage transitions
@@ -119,7 +119,7 @@ module PipelineProcessing
           new_work = MediaWork.new(
             result.result[:processed_data],
             next_stage,
-            result.result[:metadata]
+            result.result[:metadata],
           )
           @supervisor.add_work_item(new_work)
         end
@@ -127,7 +127,7 @@ module PipelineProcessing
 
       @results = {
         completed: [],
-        in_progress: []
+        in_progress: [],
       }
     end
 
@@ -137,7 +137,7 @@ module PipelineProcessing
         MediaWork.new(
           image,
           :resize,
-          { original_filename: image, started_at: Time.now.to_s }
+          { original_filename: image, started_at: Time.now.to_s },
         )
       end
 
@@ -159,7 +159,7 @@ module PipelineProcessing
         total_images: images.size,
         completed: @results[:completed].size,
         in_progress: @results[:in_progress].size,
-        results: @results[:completed]
+        results: @results[:completed],
       }
     end
   end
@@ -182,7 +182,7 @@ if __FILE__ == $PROGRAM_NAME
     "mountains.png",
     "beach.jpg",
     "city_skyline.jpg",
-    "forest.png"
+    "forest.png",
   ]
 
   worker_count = 4
@@ -205,7 +205,7 @@ if __FILE__ == $PROGRAM_NAME
     puts "Image #{index + 1}: #{image_result[:processed_data]}"
     puts "  Processing path:"
     image_result[:metadata].each do |key, value|
-      next unless key.to_s.end_with?("_completed") || key.to_s.end_with?("_time")
+      next unless key.to_s.end_with?("_completed", "_time")
 
       puts "    #{key}: #{value}"
     end