fractor 0.1.4 → 0.1.6

data/examples/continuous_chat_server/chat_server.rb

@@ -0,0 +1,359 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "socket"
+require "json"
+require "time"
+require "fileutils"
+require_relative "../continuous_chat_common/message_protocol"
+
+# Simple Chat Server using Ruby's standard socket library
+# Based on the approach from https://dev.to/aurelieverrot/create-a-chat-in-the-command-line-with-ruby-2po9
+# but modified to use JSON for message passing.
+puts "Starting chat server..."
+
+# Parse command line args
+port = ARGV[0]&.to_i || 3000
+log_file_path = ARGV[1] || "logs/server_messages.log"
+
+# Create logs directory if it doesn't exist
+FileUtils.mkdir_p(File.dirname(log_file_path))
+log_file = File.open(log_file_path, "w")
+
+def log_message(message, log_file)
+  timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S.%L")
+  log_entry = "[#{timestamp}] #{message}"
+
+  # Check if log file is still open before writing
+  if log_file && !log_file.closed?
+    log_file.puts(log_entry)
+    log_file.flush # Ensure it's written immediately
+  end
+
+  # Also print to console for debugging
+  puts log_entry
+end
+
+# Create the server socket
+server = TCPServer.new("0.0.0.0", port)
+log_message("Server started on port #{port}", log_file)
+puts "Server bound to port #{port}"
+
+# Array to store connected clients
+clients = {}
+
+# Broadcast a message to all clients
+def announce_to_everyone(clients, message, log_file)
+  log_message("Broadcasting: #{message}", log_file)
+
+  # Convert to JSON if it's not already a string
+  message_json = message.is_a?(String) ? message : JSON.generate(message)
+
+  # Create a copy of the clients hash to avoid modification during iteration
+  clients_copy = clients.dup
+
+  clients_copy.each do |username, client|
+    client.puts(message_json)
+  rescue StandardError => e
+    log_message("Error broadcasting to #{username}: #{e.message}", log_file)
+    # We don't disconnect here, that's handled in the client thread
+  end
+end
+
+# Handle a new client joining the chat
+def handle_new_client(clients, client, log_file)
+  line = client.gets&.chomp
+  return client.close unless line
+
+  log_message("Received join message: #{line}", log_file)
+
+  # Parse the join message
+  message = JSON.parse(line)
+
+  if message["type"] == "join" && message["data"] && message["data"]["username"]
+    username = message["data"]["username"]
+
+    # Store the client with username as key
+    clients[username] = client
+
+    # Send welcome message to the client
+    welcome_msg = {
+      type: "server_message",
+      data: {
+        message: "Hello #{username}! Connected clients: #{clients.count}",
+      },
+      timestamp: Time.now.to_i,
+    }
+    client.puts(JSON.generate(welcome_msg))
+
+    # Broadcast to all clients that a new user joined
+    join_msg = {
+      type: "server_message",
+      data: {
+        message: "#{username} joined the chat!",
+      },
+      timestamp: Time.now.to_i,
+    }
+    announce_to_everyone(clients, join_msg, log_file)
+
+    # Broadcast the updated user list
+    user_list_msg = {
+      type: "user_list",
+      data: {
+        users: clients.keys,
+      },
+      timestamp: Time.now.to_i,
+    }
+    announce_to_everyone(clients, user_list_msg, log_file)
+
+    true
+  else
+    # Invalid join message
+    error_msg = {
+      type: "error",
+      data: {
+        message: "First message must be a valid join command",
+      },
+      timestamp: Time.now.to_i,
+    }
+    client.puts(JSON.generate(error_msg))
+    client.close
+    false
+  end
+rescue JSON::ParserError => e
+  log_message("Error parsing initial join message: #{e.message}", log_file)
+  client.puts(JSON.generate({
+                              type: "error",
+                              data: {
+                                message: "Invalid JSON format in join message",
+                              },
+                              timestamp: Time.now.to_i,
+                            }))
+  client.close
+  false
+rescue StandardError => e
+  log_message("Error handling new client: #{e.message}", log_file)
+  client.close
+  false
+end
+
+# Process a message from an existing client
+def process_client_message(clients, client, username, log_file)
+  # Read a message from the client (non-blocking with timeout)
+  readable, = IO.select([client], nil, nil, 0)
+  return true unless readable # No data to read yet
+
+  line = client.gets&.chomp
+  return false unless line # Client disconnected
+
+  begin
+    message = JSON.parse(line)
+    log_message("Received from #{username}: #{line}", log_file)
+
+    case message["type"]
+    when "message"
+      content = message["data"]["content"]
+      recipient = message["data"]["recipient"] || "all"
+
+      if content.start_with?("/")
+        # Handle commands
+        case content
+        when "/list"
+          list_msg = {
+            type: "user_list",
+            data: {
+              users: clients.keys,
+            },
+            timestamp: Time.now.to_i,
+          }
+          client.puts(JSON.generate(list_msg))
+        else
+          # Unknown command
+          client.puts(JSON.generate({
+                                      type: "error",
+                                      data: {
+                                        message: "Unknown command: #{content}",
+                                      },
+                                      timestamp: Time.now.to_i,
+                                    }))
+        end
+      elsif recipient == "all"
+        # Broadcast message
+        broadcast_msg = {
+          type: "broadcast",
+          data: {
+            from: username,
+            content: content,
+          },
+          timestamp: Time.now.to_i,
+        }
+        announce_to_everyone(clients, broadcast_msg, log_file)
+      elsif clients[recipient]
+        # Direct message
+        dm_msg = {
+          type: "direct_message",
+          data: {
+            from: username,
+            content: content,
+          },
+          timestamp: Time.now.to_i,
+        }
+        clients[recipient].puts(JSON.generate(dm_msg))
+        # Also send to sender if not the same person
+        client.puts(JSON.generate(dm_msg)) if username != recipient
+      else
+        # Recipient not found
+        client.puts(JSON.generate({
+                                    type: "error",
+                                    data: {
+                                      message: "User #{recipient} not found",
+                                    },
+                                    timestamp: Time.now.to_i,
+                                  }))
+      end
+    when "leave"
+      # Client wants to leave
+      return false
+    end
+  rescue JSON::ParserError => e
+    log_message("Error parsing JSON from #{username}: #{e.message}", log_file)
+    client.puts(JSON.generate({
+                                type: "error",
+                                data: {
+                                  message: "Invalid JSON format",
+                                },
+                                timestamp: Time.now.to_i,
+                              }))
+  rescue StandardError => e
+    log_message("Error processing message from #{username}: #{e.message}",
+                log_file)
+    return false
+  end
+
+  true # Client still connected
+end
+
+# Handle client disconnection
+def handle_client_disconnect(clients, client, log_file)
+  username = clients.key(client)
+  return unless username
+
+  # Remove from clients list
+  clients.delete(username)
+  log_message("Client disconnected: #{username}", log_file)
+
+  # Notify everyone
+  leave_msg = {
+    type: "server_message",
+    data: {
+      message: "#{username} left the chat.",
+    },
+    timestamp: Time.now.to_i,
+  }
+  announce_to_everyone(clients, leave_msg, log_file)
+
+  # Update user list
+  user_list_msg = {
+    type: "user_list",
+    data: {
+      users: clients.keys,
+    },
+    timestamp: Time.now.to_i,
+  }
+  announce_to_everyone(clients, user_list_msg, log_file)
+
+  # Close the client socket
+  begin
+    client.close
+  rescue StandardError
+    nil
+  end
+end
+
+# Main server loop
+begin
+  log_message("Server ready to accept connections", log_file)
+
+  # Add the server socket to the list of sockets to monitor
+  sockets = [server]
+
+  # Main event loop
+  loop do
+    # Use IO.select to check which sockets have data to read
+    # This is non-blocking and allows us to handle multiple clients sequentially
+    readable, _, errored = IO.select(sockets, [], sockets, 0.1)
+
+    # Handle errors first
+    if errored && !errored.empty?
+      errored.each do |socket|
+        raise "Server socket error" if socket == server
+
+        # Server socket error - critical
+
+        # Client socket error
+        username = clients.key(socket)
+        log_message("Error on client socket: #{username || 'unknown'}",
+                    log_file)
+        handle_client_disconnect(clients, socket, log_file)
+        sockets.delete(socket)
+      end
+    end
+
+    # Nothing to process this iteration
+    next unless readable
+
+    # Process readable sockets
+    readable.each do |socket|
+      if socket == server
+        # New client connection
+        begin
+          client = server.accept
+          log_message(
+            "New client connection from #{client.peeraddr[2]}:#{client.peeraddr[1]}", log_file
+          )
+
+          # Add the client socket to our monitoring list
+          sockets << client
+
+          # We'll process the initial join message in the next iteration
+        rescue StandardError => e
+          log_message("Error accepting client: #{e.message}", log_file)
+        end
+      elsif clients.key(socket)
+        # Existing client sent data
+        username = clients.key(socket)
+
+        # Process message, remove client if it disconnected
+        unless process_client_message(clients, socket, username, log_file)
+          handle_client_disconnect(clients, socket, log_file)
+          sockets.delete(socket)
+        end
+      else
+        # This is a new client that needs to send their join message
+        unless handle_new_client(clients, socket, log_file)
+          # Join failed, remove from sockets
+          sockets.delete(socket)
+        end
+      end
+    end
+  end
+rescue Interrupt
+  log_message("Server interrupted, shutting down...", log_file)
+rescue StandardError => e
+  log_message("Server error: #{e.message}", log_file)
+ensure
+  # Close all client connections
+  clients.each_value do |client|
+    client.close
+  rescue StandardError
+    # Ignore errors when closing
+  end
+
+  # Close the server socket
+  server&.close
+
+  # Close the log file
+  log_file&.close
+
+  log_message("Server stopped", log_file)
+end

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