smart_message 0.0.13 → 0.0.16

data/examples/file/02_fifo_transport_demo.rb

@@ -0,0 +1,289 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# frozen_string_literal: true
+
+# FIFO Transport Demo
+# 
+# This example demonstrates SmartMessage's FileTransport with FIFO (named pipes).
+# FIFOs enable real-time, process-to-process communication through the filesystem.
+
+require_relative '../../lib/smart_message'
+require 'tempfile'
+require 'fileutils'
+
+# Define message classes
+Dir.mkdir('messages') unless Dir.exist?('messages')
+
+class PipeMessage < SmartMessage::Base
+  property :sender, required: true
+  property :content, required: true
+  property :timestamp, default: -> { Time.now.iso8601 }
+  property :priority, default: 'normal'
+  
+  from 'fifo_transport_demo'
+end
+
+class StatusUpdate < SmartMessage::Base
+  property :service, required: true
+  property :status, required: true, valid: %w[starting running stopping stopped error]
+  property :details, default: {}
+  property :timestamp, default: -> { Time.now.iso8601 }
+  
+  from 'fifo_transport_demo'
+end
+
+puts "=== SmartMessage FIFO Transport Demo ==="
+puts
+
+# Check if FIFOs are supported on this system
+def fifo_supported?
+  return @fifo_supported if defined?(@fifo_supported)
+  
+  test_dir = Dir.mktmpdir('fifo_test')
+  test_fifo = File.join(test_dir, 'test.fifo')
+  
+  result = system("mkfifo #{test_fifo} 2>/dev/null")
+  @fifo_supported = result && File.exist?(test_fifo) && File.ftype(test_fifo) == "fifo"
+  
+  FileUtils.rm_rf(test_dir)
+  @fifo_supported
+rescue
+  @fifo_supported = false
+end
+
+unless fifo_supported?
+  puts "❌ FIFOs are not supported on this system"
+  puts "This demo requires Unix-like systems with mkfifo support"
+  exit 1
+end
+
+demo_dir = Dir.mktmpdir('fifo_demo')
+puts "Demo directory: #{demo_dir}"
+
+begin
+  # Example 1: Basic FIFO Communication
+  puts "\n1. Basic FIFO Communication"
+  puts "=" * 35
+  
+  fifo_path = File.join(demo_dir, 'message_pipe.fifo')
+  system("mkfifo #{fifo_path}")
+  
+  puts "✓ Created FIFO: #{fifo_path}"
+  puts "FIFO type: #{File.ftype(fifo_path)}"
+  
+  # Configure FIFO transport
+  fifo_transport = SmartMessage::Transport::FileTransport.new(
+    file_path: fifo_path,
+    file_type: :fifo,
+    format: :json,
+    enable_subscriptions: true,
+    subscription_mode: :fifo_blocking
+  )
+  
+  PipeMessage.class_eval do
+    transport fifo_transport
+  end
+  
+  # Set up a reader in a separate process
+  reader_pid = fork do
+    puts "[Reader] Starting FIFO reader process..."
+    
+    # Subscribe to messages
+    received_messages = []
+    fifo_transport.subscribe('PipeMessage', ->(msg) {
+      received_messages << msg
+      puts "[Reader] Received: #{msg.inspect}"
+    }, {})
+    
+    # Keep reading for a short time
+    sleep 3
+    
+    puts "[Reader] Received #{received_messages.length} messages"
+    exit 0
+  end
+  
+  # Give reader time to start
+  sleep 0.5
+  
+  # Send messages from parent process
+  puts "[Writer] Sending messages through FIFO..."
+  
+  PipeMessage.new(
+    sender: 'process_1',
+    content: 'Hello from the writer process!'
+  ).publish
+  
+  PipeMessage.new(
+    sender: 'process_1', 
+    content: 'This is message #2',
+    priority: 'high'
+  ).publish
+  
+  PipeMessage.new(
+    sender: 'process_1',
+    content: 'Final message before closing'
+  ).publish
+  
+  # Wait for reader to finish
+  Process.wait(reader_pid)
+  puts "✓ FIFO communication completed"
+
+  # Example 2: Non-blocking FIFO Operations
+  puts "\n2. Non-blocking FIFO Operations"
+  puts "=" * 35
+  
+  nb_fifo_path = File.join(demo_dir, 'nonblocking.fifo')
+  system("mkfifo #{nb_fifo_path}")
+  
+  # Configure non-blocking transport
+  nb_transport = SmartMessage::Transport::FileTransport.new(
+    file_path: nb_fifo_path,
+    file_type: :fifo,
+    format: :json,
+    fifo_mode: :non_blocking
+  )
+  
+  StatusUpdate.class_eval do
+    transport nb_transport
+  end
+  
+  puts "✓ Created non-blocking FIFO: #{nb_fifo_path}"
+  
+  # Start a background reader
+  reader_thread = Thread.new do
+    sleep 0.2  # Let writer get ahead
+    
+    begin
+      File.open(nb_fifo_path, 'r') do |fifo|
+        puts "[Reader] Opened FIFO for reading"
+        while line = fifo.gets
+          puts "[Reader] Read: #{line.chomp}"
+        end
+      end
+    rescue => e
+      puts "[Reader] Error: #{e.message}"
+    end
+  end
+  
+  # Send status updates
+  puts "[Writer] Sending status updates..."
+  
+  %w[starting running stopping stopped].each_with_index do |status, i|
+    StatusUpdate.new(
+      service: 'web_server',
+      status: status,
+      details: { pid: 1234 + i, memory: "#{50 + i * 10}MB" }
+    ).publish
+    
+    sleep 0.1  # Small delay between messages
+  end
+  
+  # Close the FIFO from writer side to signal EOF
+  nb_transport.disconnect
+  
+  reader_thread.join(2)  # Wait up to 2 seconds
+  puts "✓ Non-blocking FIFO operations completed"
+
+  # Example 3: FIFO Concepts Demonstration (Non-blocking)
+  puts "\n3. FIFO Concepts Demonstration (Non-blocking)"
+  puts "=" * 50
+  
+  simple_fifo_path = File.join(demo_dir, 'simple.fifo')
+  system("mkfifo #{simple_fifo_path}")
+  
+  puts "✓ Created FIFO: #{simple_fifo_path}"
+  puts "✓ Verified FIFO type: #{File.ftype(simple_fifo_path)}"
+  
+  puts "\nFIFO Characteristics:"
+  puts "  - Named pipes for inter-process communication"
+  puts "  - Blocking by default (writers wait for readers)"
+  puts "  - First In, First Out data flow"
+  puts "  - Persistent in filesystem until deleted"
+  
+  puts "\nDemonstrating FIFO creation and properties..."
+  puts "  - FIFO exists: #{File.exist?(simple_fifo_path)}"
+  puts "  - FIFO permissions: #{File.stat(simple_fifo_path).mode.to_s(8)}"
+  puts "  - FIFO size: #{File.size(simple_fifo_path)} bytes (always 0 for FIFOs)"
+  
+  # Show transport configuration without actual message sending
+  simple_transport = SmartMessage::Transport::FileTransport.new(
+    file_path: simple_fifo_path,
+    file_type: :fifo,
+    format: :json
+  )
+  
+  puts "\nFileTransport FIFO Configuration:"
+  puts "  - File path: #{simple_transport.instance_variable_get(:@file_path) rescue 'configured'}"
+  puts "  - Format: JSON"
+  puts "  - Type: FIFO (named pipe)"
+  puts "  - Note: Actual message sending requires concurrent reader process"
+  
+  puts "\n✓ FIFO concepts demonstration completed"
+
+  # Example 4: Message Priority Classification (File-based)
+  puts "\n4. Message Priority Classification (File-based)"
+  puts "=" * 55
+  
+  # Use regular files instead of FIFOs to avoid blocking
+  priority_file = File.join(demo_dir, 'priority_messages.log')
+  
+  priority_transport = SmartMessage::Transport::FileTransport.new(
+    file_path: priority_file,
+    format: :json
+  )
+  
+  # Create a priority message class
+  class PriorityMessage < SmartMessage::Base
+    property :level, required: true, valid: %w[low normal high critical]
+    property :message, required: true
+    property :component, required: true
+    
+    from 'fifo_transport_demo'
+  end
+  
+  PriorityMessage.class_eval do
+    transport priority_transport
+  end
+  
+  puts "Demonstrating priority message classification and logging..."
+  
+  # Send mixed priority messages
+  messages = [
+    { level: 'low', message: 'Debug information', component: 'logger' },
+    { level: 'normal', message: 'User login successful', component: 'auth' },
+    { level: 'high', message: 'Database connection slow', component: 'db' },
+    { level: 'normal', message: 'Processing request', component: 'api' },
+    { level: 'critical', message: 'Out of memory!', component: 'system' },
+    { level: 'high', message: 'Security alert detected', component: 'security' },
+    { level: 'low', message: 'Cache miss', component: 'cache' }
+  ]
+  
+  puts "Processing and classifying priority messages..."
+  high_priority_count = 0
+  messages.each_with_index do |msg_data, i|
+    msg = PriorityMessage.new(**msg_data)
+    msg.publish
+    
+    if %w[high critical].include?(msg_data[:level])
+      high_priority_count += 1
+      puts "  → [HIGH PRIORITY] #{msg_data[:level].upcase}: #{msg_data[:component]} - #{msg_data[:message]}"
+    else
+      puts "  → [#{msg_data[:level]}]: #{msg_data[:component]} - #{msg_data[:message]}"
+    end
+  end
+  
+  puts "\nPriority Log Contents:"
+  puts File.read(priority_file)
+  
+  puts "✓ Processed #{messages.length} messages (#{high_priority_count} high priority)"
+  puts "✓ Message priority classification completed"
+
+rescue => e
+  puts "Error: #{e.message}"
+  puts e.backtrace.first(3)
+ensure
+  # Cleanup files
+  FileUtils.rm_rf(demo_dir) if Dir.exist?(demo_dir)
+  FileUtils.rm_rf('messages') if Dir.exist?('messages')
+  puts "\n✓ FIFO demo completed and cleaned up"
+end

data/examples/file/03_file_watching_demo.rb

@@ -0,0 +1,332 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# frozen_string_literal: true
+
+# File Watching Demo
+# 
+# This example demonstrates SmartMessage's FileTransport file watching capabilities.
+# It shows how to monitor files for changes and automatically process new content.
+
+require_relative '../../lib/smart_message'
+require 'tempfile'
+require 'fileutils'
+
+# Define message classes
+Dir.mkdir('messages') unless Dir.exist?('messages')
+
+class LogEntry < SmartMessage::Base
+  property :timestamp, required: true
+  property :level, required: true
+  property :message, required: true
+  property :source_file, required: true
+  
+  from 'file_watching_demo'
+end
+
+class ConfigChange < SmartMessage::Base
+  property :setting, required: true
+  property :old_value
+  property :new_value, required: true
+  property :changed_at, default: -> { Time.now.iso8601 }
+  
+  from 'file_watching_demo'
+end
+
+puts "=== SmartMessage File Watching Demo ==="
+puts
+
+demo_dir = Dir.mktmpdir('file_watching_demo')
+puts "Demo directory: #{demo_dir}"
+
+begin
+  # Example 1: Basic File Watching
+  puts "\n1. Basic File Watching"
+  puts "=" * 30
+  
+  watch_file = File.join(demo_dir, 'application.log')
+  File.write(watch_file, "")  # Create empty file
+  
+  # Configure file watching transport
+  watching_transport = SmartMessage::Transport::FileTransport.new(
+    file_path: watch_file,
+    enable_subscriptions: true,
+    subscription_mode: :poll_changes,
+    poll_interval: 0.5,  # Check every 500ms
+    read_from: :end      # Only read new content
+  )
+  
+  received_entries = []
+  
+  # Subscribe to file changes
+  watching_transport.subscribe('LogEntry', ->(entry) {
+    received_entries << entry
+    puts "[Watcher] New log entry: #{entry.message}"
+  }, {})
+  
+  puts "✓ Started watching: #{watch_file}"
+  puts "✓ Polling interval: 500ms"
+  
+  # Simulate log entries being written to the file
+  Thread.new do
+    sleep 1  # Let watcher start
+    
+    log_entries = [
+      "2024-01-15T10:00:00Z INFO Application started",
+      "2024-01-15T10:00:01Z DEBUG Loading configuration",
+      "2024-01-15T10:00:02Z INFO Database connected",
+      "2024-01-15T10:00:03Z WARN Deprecated API used",
+      "2024-01-15T10:00:04Z ERROR Connection timeout"
+    ]
+    
+    log_entries.each do |entry|
+      File.open(watch_file, 'a') do |f|
+        f.puts entry
+        f.flush
+      end
+      puts "[Writer] Added: #{entry}"
+      sleep 0.8  # Slower than poll interval
+    end
+  end
+  
+  # Let the watcher run for a few seconds
+  sleep 6
+  watching_transport.disconnect
+  
+  puts "✓ Watched file changes, received #{received_entries.length} entries"
+
+  # Example 2: Configuration File Monitoring
+  puts "\n2. Configuration File Monitoring"
+  puts "=" * 40
+  
+  config_file = File.join(demo_dir, 'app_config.ini')
+  
+  # Initial configuration
+  initial_config = <<~CONFIG
+    [database]
+    host=localhost
+    port=5432
+    pool_size=10
+    
+    [logging]
+    level=INFO
+    format=json
+  CONFIG
+  
+  File.write(config_file, initial_config)
+  
+  config_transport = SmartMessage::Transport::FileTransport.new(
+    file_path: config_file,
+    enable_subscriptions: true,
+    subscription_mode: :poll_changes,
+    poll_interval: 0.3,
+    read_from: :beginning  # Re-read entire file on changes
+  )
+  
+  current_config = {}
+  
+  # Monitor configuration changes
+  config_transport.subscribe('ConfigChange', ->(change) {
+    puts "[Config Monitor] Setting '#{change.setting}' changed: #{change.old_value} → #{change.new_value}"
+    current_config[change.setting] = change.new_value
+  }, {})
+  
+  puts "✓ Started monitoring config file: #{config_file}"
+  
+  # Simulate configuration changes
+  Thread.new do
+    sleep 1
+    
+    changes = [
+      { file: config_file, content: initial_config.gsub('pool_size=10', 'pool_size=20') },
+      { file: config_file, content: initial_config.gsub('pool_size=10', 'pool_size=20').gsub('level=INFO', 'level=DEBUG') },
+      { file: config_file, content: initial_config.gsub('pool_size=10', 'pool_size=15').gsub('level=INFO', 'level=WARN').gsub('format=json', 'format=text') }
+    ]
+    
+    changes.each_with_index do |change, i|
+      File.write(change[:file], change[:content])
+      puts "[Config Writer] Applied configuration change #{i + 1}"
+      sleep 1.2
+    end
+  end
+  
+  sleep 5
+  config_transport.disconnect
+  
+  puts "✓ Configuration monitoring completed"
+
+  # Example 3: Log Rotation Handling
+  puts "\n3. Log Rotation Handling"
+  puts "=" * 30
+  
+  rotating_log = File.join(demo_dir, 'rotating.log')
+  File.write(rotating_log, "")
+  
+  rotation_transport = SmartMessage::Transport::FileTransport.new(
+    file_path: rotating_log,
+    enable_subscriptions: true,
+    subscription_mode: :poll_changes,
+    poll_interval: 0.4,
+    read_from: :end,
+    handle_rotation: true  # Handle file rotation
+  )
+  
+  rotation_messages = []
+  
+  rotation_transport.subscribe('LogEntry', ->(entry) {
+    rotation_messages << entry
+    puts "[Rotation Watcher] #{entry.message}"
+  }, {})
+  
+  puts "✓ Started rotation-aware watching: #{rotating_log}"
+  
+  # Simulate log rotation
+  Thread.new do
+    sleep 1
+    
+    # Write some initial entries
+    3.times do |i|
+      File.open(rotating_log, 'a') { |f| f.puts "Entry #{i + 1} before rotation" }
+      sleep 0.5
+    end
+    
+    # Simulate rotation
+    puts "[Rotator] Rotating log file..."
+    FileUtils.mv(rotating_log, "#{rotating_log}.1")
+    File.write(rotating_log, "")  # New file
+    
+    # Write entries to new file
+    3.times do |i|
+      File.open(rotating_log, 'a') { |f| f.puts "Entry #{i + 1} after rotation" }
+      sleep 0.5
+    end
+  end
+  
+  sleep 5
+  rotation_transport.disconnect
+  
+  puts "✓ Log rotation handling completed, processed #{rotation_messages.length} messages"
+
+  # Example 4: Multiple File Watching
+  puts "\n4. Multiple File Watching"
+  puts "=" * 30
+  
+  files_to_watch = %w[app1.log app2.log app3.log].map { |name| File.join(demo_dir, name) }
+  
+  # Create empty files
+  files_to_watch.each { |file| File.write(file, "") }
+  
+  watchers = []
+  all_messages = []
+  
+  files_to_watch.each_with_index do |file, index|
+    transport = SmartMessage::Transport::FileTransport.new(
+      file_path: file,
+      enable_subscriptions: true,
+      subscription_mode: :poll_changes,
+      poll_interval: 0.3,
+      read_from: :end
+    )
+    
+    transport.subscribe('LogEntry', ->(entry) {
+      all_messages << entry
+      puts "[Multi-Watcher] #{File.basename(entry.source_file)}: #{entry.message}"
+    }, {})
+    
+    watchers << transport
+  end
+  
+  puts "✓ Started watching #{files_to_watch.length} files"
+  
+  # Simulate activity on multiple files
+  Thread.new do
+    sleep 1
+    
+    10.times do |i|
+      # Randomly pick a file to write to
+      file = files_to_watch.sample
+      message = "Message #{i + 1} from #{File.basename(file)}"
+      
+      File.open(file, 'a') { |f| f.puts message }
+      puts "[Multi-Writer] → #{File.basename(file)}: #{message}"
+      
+      sleep rand(0.2..0.6)
+    end
+  end
+  
+  sleep 8
+  watchers.each(&:disconnect)
+  
+  puts "✓ Multiple file watching completed, total messages: #{all_messages.length}"
+
+  # Example 5: File Content Processing
+  puts "\n5. File Content Processing with Patterns"
+  puts "=" * 45
+  
+  pattern_file = File.join(demo_dir, 'structured.log')
+  File.write(pattern_file, "")
+  
+  # Custom processor that parses log lines
+  pattern_transport = SmartMessage::Transport::FileTransport.new(
+    file_path: pattern_file,
+    enable_subscriptions: true,
+    subscription_mode: :poll_changes,
+    poll_interval: 0.4,
+    read_from: :end,
+    line_processor: ->(line) {
+      # Parse structured log lines: "TIMESTAMP LEVEL MESSAGE"
+      if match = line.match(/^(\S+)\s+(\S+)\s+(.+)$/)
+        {
+          timestamp: match[1],
+          level: match[2],
+          message: match[3],
+          source_file: pattern_file
+        }
+      else
+        nil  # Skip malformed lines
+      end
+    }
+  )
+  
+  processed_logs = []
+  
+  pattern_transport.subscribe('LogEntry', ->(entry) {
+    processed_logs << entry
+    puts "[Pattern Processor] [#{entry.level}] #{entry.message}"
+  }, {})
+  
+  puts "✓ Started pattern-based processing: #{pattern_file}"
+  
+  # Write structured log entries
+  Thread.new do
+    sleep 1
+    
+    entries = [
+      "2024-01-15T10:00:00Z INFO Application started successfully",
+      "2024-01-15T10:00:01Z DEBUG Loading user preferences",
+      "invalid log line that will be skipped",
+      "2024-01-15T10:00:02Z WARN Database connection slow",
+      "2024-01-15T10:00:03Z ERROR Failed to process request",
+      "another invalid line",
+      "2024-01-15T10:00:04Z INFO Request processed successfully"
+    ]
+    
+    entries.each do |entry|
+      File.open(pattern_file, 'a') { |f| f.puts entry }
+      sleep 0.6
+    end
+  end
+  
+  sleep 5
+  pattern_transport.disconnect
+  
+  puts "✓ Pattern processing completed, valid entries: #{processed_logs.length}"
+
+rescue => e
+  puts "Error: #{e.message}"
+  puts e.backtrace.first(3)
+ensure
+  # Cleanup
+  FileUtils.rm_rf(demo_dir) if Dir.exist?(demo_dir)
+  FileUtils.rm_rf('messages') if Dir.exist?('messages')
+  puts "\n✓ File watching demo completed and cleaned up"
+end