fractor 0.1.4 → 0.1.6

data/examples/continuous_chat_fractor/chat_common.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../continuous_chat_common/message_protocol'
+require_relative '../../lib/fractor'
+
+module ContinuousChatFractor
+  # ChatMessage represents a chat message as a unit of work for Fractor
+  class ChatMessage < Fractor::Work
+    def initialize(packet, client_socket = nil)
+      super({ packet: packet, client_socket: client_socket })
+    end
+
+    def packet
+      input[:packet]
+    end
+
+    def client_socket
+      input[:client_socket]
+    end
+
+    def to_s
+      "ChatMessage: #{packet.type} from #{packet.data}"
+    end
+  end
+
+  # ChatWorker processes chat messages using Fractor
+  class ChatWorker < Fractor::Worker
+    def process(work)
+      packet = work.packet
+      work.client_socket
+
+      # Process based on message type
+      result = case packet.type
+               when :broadcast
+                 # Broadcast message processing
+                 {
+                   action: :broadcast,
+                   from: packet.data[:from],
+                   content: packet.data[:content],
+                   timestamp: packet.timestamp
+                 }
+               when :direct_message
+                 # Direct message processing
+                 {
+                   action: :direct_message,
+                   from: packet.data[:from],
+                   to: packet.data[:to],
+                   content: packet.data[:content],
+                   timestamp: packet.timestamp
+                 }
+               when :server_message
+                 # Server message processing
+                 {
+                   action: :server_message,
+                   message: packet.data[:message],
+                   timestamp: packet.timestamp
+                 }
+               when :user_list
+                 # User list update
+                 {
+                   action: :user_list,
+                   users: packet.data[:users],
+                   timestamp: packet.timestamp
+                 }
+               else
+                 # Unknown message type
+                 {
+                   action: :error,
+                   message: "Unknown message type: #{packet.type}",
+                   timestamp: packet.timestamp
+                 }
+               end
+
+      Fractor::WorkResult.new(result: result, work: work)
+    rescue StandardError => e
+      Fractor::WorkResult.new(
+        error: "Error processing message: #{e.message}",
+        work: work
+      )
+    end
+  end
+end

data/examples/continuous_chat_fractor/chat_server.rb

@@ -0,0 +1,167 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'socket'
+require 'json'
+require 'time'
+require_relative 'chat_common'
+
+# Refactored Chat Server using new Fractor primitives
+puts 'Starting Fractor-based chat server (refactored)...'
+
+# Parse command line args
+port = ARGV[0]&.to_i || 3000
+log_file_path = ARGV[1] || 'logs/server_messages.log'
+
+# Thread-safe hash for client connections
+clients = {}
+clients_mutex = Mutex.new
+
+# Create server socket
+server = TCPServer.new('0.0.0.0', port)
+
+# Set up work queue and Fractor server
+work_queue = Fractor::WorkQueue.new
+
+fractor_server = Fractor::ContinuousServer.new(
+  worker_pools: [
+    { worker_class: ContinuousChatFractor::ChatWorker, num_workers: 2 }
+  ],
+  work_queue: work_queue,
+  log_file: log_file_path
+)
+
+# Handle results from Fractor workers
+fractor_server.on_result do |result|
+  action_data = result.result
+  case action_data[:action]
+  when :broadcast
+    puts "Broadcasting: #{action_data[:content]}"
+  when :direct_message
+    puts "DM from #{action_data[:from]} to #{action_data[:to]}"
+  when :server_message
+    puts "Server: #{action_data[:message]}"
+  end
+end
+
+fractor_server.on_error do |error|
+  puts "Error: #{error.error}"
+end
+
+# Start Fractor server in background
+Thread.new { fractor_server.run }
+sleep(0.2) # Give it time to start
+
+puts "Server started on port #{port}"
+puts "Server ready to accept connections"
+
+# Handle new client connections
+begin
+  sockets = [server]
+
+  loop do
+    readable, = IO.select(sockets, [], [], 0.1)
+    next unless readable
+
+    readable.each do |socket|
+      if socket == server
+        # New client connection
+        client = server.accept
+        sockets << client
+
+        # Read join message
+        line = client.gets&.chomp
+        if line
+          message = JSON.parse(line)
+          if message['type'] == 'join' && message['data']['username']
+            username = message['data']['username']
+            clients_mutex.synchronize { clients[username] = client }
+
+            packet = ContinuousChat::MessagePacket.new(
+              :server_message,
+              { message: "#{username} joined!" }
+            )
+            work_queue << ContinuousChatFractor::ChatMessage.new(packet)
+
+            client.puts(JSON.generate({
+              type: 'server_message',
+              data: { message: "Welcome #{username}!" },
+              timestamp: Time.now.to_i
+            }))
+          end
+        end
+      else
+        # Existing client sent data
+        line = socket.gets&.chomp
+        if line.nil?
+          # Client disconnected
+          username = clients_mutex.synchronize { clients.key(socket) }
+          if username
+            clients_mutex.synchronize { clients.delete(username) }
+            packet = ContinuousChat::MessagePacket.new(
+              :server_message,
+              { message: "#{username} left" }
+            )
+            work_queue << ContinuousChatFractor::ChatMessage.new(packet)
+          end
+          sockets.delete(socket)
+          socket.close rescue nil
+        else
+          # Process message
+          message = JSON.parse(line)
+          username = clients_mutex.synchronize { clients.key(socket) }
+
+          if message['type'] == 'message'
+            content = message['data']['content']
+            recipient = message['data']['recipient'] || 'all'
+
+            if recipient == 'all'
+              packet = ContinuousChat::MessagePacket.new(
+                :broadcast,
+                { from: username, content: content }
+              )
+              work_queue << ContinuousChatFractor::ChatMessage.new(packet)
+
+              # Broadcast to clients
+              broadcast_msg = {
+                type: 'broadcast',
+                data: { from: username, content: content },
+                timestamp: Time.now.to_i
+              }
+              clients_mutex.synchronize do
+                clients.each_value { |c| c.puts(JSON.generate(broadcast_msg)) rescue nil }
+              end
+            else
+              packet = ContinuousChat::MessagePacket.new(
+                :direct_message,
+                { from: username, to: recipient, content: content }
+              )
+              work_queue << ContinuousChatFractor::ChatMessage.new(packet)
+
+              # Send direct message
+              dm_msg = {
+                type: 'direct_message',
+                data: { from: username, content: content },
+                timestamp: Time.now.to_i
+              }
+              clients_mutex.synchronize do
+                recipient_socket = clients[recipient]
+                if recipient_socket
+                  recipient_socket.puts(JSON.generate(dm_msg)) rescue nil
+                  socket.puts(JSON.generate(dm_msg)) if username != recipient
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+rescue Interrupt
+  puts "\nServer interrupted, shutting down..."
+ensure
+  fractor_server.stop
+  clients_mutex.synchronize { clients.each_value { |c| c.close rescue nil } }
+  server&.close
+  puts 'Server stopped'
+end

data/examples/continuous_chat_fractor/simulate.rb

@@ -0,0 +1,345 @@
+#!/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?('Fractor: Broadcasting message from') ||
+            line.include?('Fractor processed: broadcast')
+        end
+        direct_count = server_log.count do |line|
+          line.include?('Fractor: Direct message from') ||
+            line.include?('Fractor processed: direct_message')
+        end
+
+        puts "  - #{message_count} messages received from clients"
+        puts "  - #{broadcast_count} broadcast messages processed by Fractor"
+        puts "  - #{direct_count} direct messages processed by Fractor"
+      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