fractor 0.1.3 → 0.1.6

data/examples/continuous_chat_fractor/chat_client.rb

@@ -0,0 +1,303 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'socket'
+require 'json'
+require 'fileutils'
+
+module ContinuousChat
+  # Simple Chat Client using Ruby's standard socket library
+  class ChatClient
+    def initialize(username, server_host = 'localhost', server_port = 3000,
+                   log_file_path = nil)
+      @username = username
+      @server_host = server_host
+      @server_port = server_port
+      @running = true
+
+      # Set up logging
+      @log_file_path = log_file_path || "logs/client_#{username}_messages.log"
+      FileUtils.mkdir_p(File.dirname(@log_file_path))
+      @log_file = File.open(@log_file_path, 'w')
+
+      log_message("Client initialized for #{username}, connecting to #{server_host}:#{server_port}")
+    end
+
+    def connect
+      puts "Connecting to server at #{@server_host}:#{@server_port}..."
+      log_message("Connecting to server at #{@server_host}:#{@server_port}")
+
+      begin
+        @socket = TCPSocket.new(@server_host, @server_port)
+
+        # Send join message
+        join_data = {
+          type: 'join',
+          data: {
+            username: @username
+          },
+          timestamp: Time.now.to_i
+        }
+        @socket.puts(JSON.generate(join_data))
+        log_message("Sent join message: #{join_data}")
+
+        puts 'Connected to chat server!'
+        log_message('Connected to chat server')
+
+        true
+      rescue StandardError => e
+        puts "Failed to connect: #{e.message}"
+        log_message("Failed to connect: #{e.message}")
+        false
+      end
+    end
+
+    def start
+      return false unless @socket
+
+      # Main event loop that handles both sending and receiving messages
+      # without creating separate threads
+      main_event_loop
+
+      true
+    end
+
+    # Main event loop that handles both user input and server messages
+    def main_event_loop
+      log_message('Starting main event loop')
+
+      # Print initial prompt
+      print "(#{@username})> "
+      $stdout.flush
+
+      while @running
+        # Use IO.select to wait for input from either STDIN or the socket
+        # This is non-blocking and allows us to handle both in a single loop
+        readable, = IO.select([@socket, $stdin], nil, nil, 0.1)
+
+        next unless readable # Nothing to process this iteration
+
+        readable.each do |io|
+          if io == $stdin
+            # Handle user input
+            handle_user_input
+          elsif io == @socket
+            # Handle server message
+            handle_server_message
+          end
+        end
+      end
+    rescue Interrupt
+      log_message('Client interrupted')
+      @running = false
+    rescue StandardError => e
+      log_message("Error in main event loop: #{e.message}")
+      @running = false
+    ensure
+      disconnect
+    end
+
+    # Handle user input (non-blocking)
+    def handle_user_input
+      text = $stdin.gets&.chomp
+      return unless text
+
+      # Check if client wants to quit
+      if text == '/quit' || text.nil?
+        @running = false
+        return
+      end
+
+      # Create message packet
+      message_data = {
+        type: 'message',
+        data: {
+          content: text,
+          recipient: 'all' # Default to broadcast
+        },
+        timestamp: Time.now.to_i
+      }
+
+      # Send to server
+      @socket.puts(JSON.generate(message_data))
+      log_message("Sent message: #{text}")
+
+      # Print prompt for next input
+      print "(#{@username})> "
+      $stdout.flush
+    rescue StandardError => e
+      log_message("Error handling user input: #{e.message}")
+      @running = false
+    end
+
+    # Handle server message (non-blocking)
+    def handle_server_message
+      line = @socket.gets&.chomp
+
+      if line.nil?
+        # Server closed the connection
+        log_message('Connection to server lost')
+        @running = false
+        return
+      end
+
+      # Parse and handle the message
+      message = JSON.parse(line)
+      log_message("Received: #{line}")
+
+      # Display formatted message based on type
+      case message['type']
+      when 'broadcast'
+        puts "\r#{message['data']['from']}: #{message['data']['content']}"
+      when 'direct_message'
+        puts "\r[DM] #{message['data']['from']}: #{message['data']['content']}"
+      when 'server_message'
+        puts "\r[Server] #{message['data']['message']}"
+      when 'user_list'
+        puts "\r[Server] Users online: #{message['data']['users'].join(', ')}"
+      when 'error'
+        puts "\r[Error] #{message['data']['message']}"
+      end
+
+      # Reprint the prompt
+      print "(#{@username})> "
+      $stdout.flush
+    rescue StandardError => e
+      log_message("Error handling server message: #{e.message}")
+      # Don't immediately break for connection errors, may be temporary
+      # Just log and continue, IO.select will catch closed connections
+    end
+
+    def run_with_messages(messages, _delay_between_messages = 1)
+      return false unless @socket && @running
+
+      log_message("Running with #{messages.size} predefined messages")
+      puts "Sending #{messages.size} predefined messages"
+
+      # Send all messages in a non-blocking way
+      batch_send_messages(messages)
+
+      log_message('Finished sending all predefined messages')
+
+      # Start the event loop to receive responses
+      main_event_loop
+
+      true
+    end
+
+    # Helper to send a batch of messages without blocking
+    def batch_send_messages(messages)
+      messages.each_with_index do |msg, index|
+        content = msg[:content]
+        recipient = msg[:recipient] || 'all'
+
+        log_message("Sending message #{index + 1}: '#{content}' to #{recipient}")
+
+        message_data = {
+          type: 'message',
+          data: {
+            content: content,
+            recipient: recipient
+          },
+          timestamp: Time.now.to_i
+        }
+
+        @socket.puts(JSON.generate(message_data))
+        log_message("Sent message to #{recipient}: #{content}")
+
+        # Small delay between messages for stability
+        sleep(0.1)
+      end
+    end
+
+    def disconnect
+      return unless @running
+
+      @running = false
+      log_message('Disconnecting from server')
+
+      if @socket && !@socket.closed?
+        # Send leave message
+        leave_data = {
+          type: 'leave',
+          data: {
+            username: @username
+          },
+          timestamp: Time.now.to_i
+        }
+        @socket.puts(JSON.generate(leave_data))
+        log_message('Sent leave message')
+
+        @socket.close
+      end
+
+      @log_file&.close
+
+      puts 'Disconnected from server.'
+      true
+    end
+
+    private
+
+    def log_message(message)
+      timestamp = Time.now.strftime('%Y-%m-%d %H:%M:%S.%L')
+      log_entry = "[#{timestamp}] #{message}"
+
+      @log_file.puts(log_entry)
+      @log_file.flush # Ensure it's written immediately
+    end
+  end
+end
+
+# When run directly, start the client
+if __FILE__ == $PROGRAM_NAME
+  require 'fileutils'
+  require 'json'
+
+  puts 'Chat Client'
+  puts '==========='
+  puts 'This is the chat client that connects to the chat server.'
+  puts 'All messages are logged to a file for later analysis.'
+  puts
+
+  # Get username from command line or prompt
+  username = ARGV[0]
+
+  unless username
+    print 'Enter your username: '
+    username = gets.chomp
+  end
+
+  # Get port from command line or use default
+  port = ARGV[1]&.to_i || 3000
+  log_file = ARGV[2] || "logs/client_#{username}_messages.log"
+
+  # Check for messages file
+  messages_file = "logs/client_#{username}_send_messages.json"
+
+  # Create and run the client
+  client = ContinuousChat::ChatClient.new(username, 'localhost', port, log_file)
+
+  if client.connect
+    begin
+      # Load and send messages if the file exists
+      if File.exist?(messages_file)
+        puts "Loading messages from #{messages_file}"
+        messages = JSON.parse(File.read(messages_file), symbolize_names: true)
+        puts "Loaded #{messages.size} messages"
+
+        # Send the messages
+        client.run_with_messages(messages)
+      end
+
+      # Start the client
+      client.start
+    rescue Interrupt
+      puts "\nClient interrupted."
+    ensure
+      client.disconnect
+    end
+  end
+
+  puts 'Chat client exited.'
+end

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