smart_message 0.0.10 → 0.0.12

data/examples/city_scenario/messages/emergency_resolved_message.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# examples/messages/emergency_resolved_message.rb
+#
+# Emergency resolution message broadcast when incidents are successfully resolved
+# Provides closure notification to all city services about completed emergency responses
+#
+require_relative '../../../lib/smart_message'
+
+
+module Messages
+  class EmergencyResolvedMessage < SmartMessage::Base
+    version 1
+
+    description 'Emergency incident closure notification message broadcast by emergency services when incidents are successfully resolved, providing completion status, response duration, outcome details, and unit deployment information to all city services for operational awareness and incident tracking'
+
+    transport  SmartMessage::Transport::RedisTransport.new
+    serializer SmartMessage::Serializer::Json.new
+
+    property :incident_id, required: true,
+                           description: 'Unique identifier of the emergency incident that was resolved'
+
+    property :incident_type, required: true,
+                             description: "Classification of the incident that was resolved (e.g., 'robbery', 'kitchen fire')"
+
+    property :location, required: true,
+                        description: 'Street address or location where the incident occurred and was resolved'
+
+    property :resolved_by, required: true,
+                           description: "Name of the city service that resolved the incident (e.g., 'police-department', 'fire-department')"
+
+    property :resolution_time, required: true,
+                               description: 'Exact time when the incident was fully resolved (YYYY-MM-DD HH:MM:SS format)'
+
+    property :duration_minutes, required: true,
+                                description: 'Total duration of the incident from start to resolution in minutes (decimal format)'
+
+    property :outcome,
+             description: 'Brief description of the final result or outcome of the emergency response'
+
+    property :units_involved,
+             description: 'Array of emergency response units that participated in resolving the incident'
+  end
+end

data/examples/city_scenario/messages/fire_dispatch_message.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+# examples/messages/fire_dispatch_message.rb
+#
+# Fire dispatch message sent by the Fire Department in response to fire emergencies
+# Contains fire engine assignments and specialized equipment details for fire suppression operations
+
+require_relative '../../../lib/smart_message'
+
+module Messages
+  class FireDispatchMessage < SmartMessage::Base
+    version 1
+
+    description 'Emergency fire suppression dispatch coordination message sent by the Fire Department in response to fire emergencies, containing fire engine assignments, specialized equipment deployment, and tactical response information for various fire types, rescue operations, and hazardous material incidents'
+
+    transport  SmartMessage::Transport::RedisTransport.new
+    serializer SmartMessage::Serializer::Json.new
+
+    property :dispatch_id, required: true,
+                           description: 'Unique hexadecimal identifier for this fire department dispatch operation'
+
+    property :engines_assigned, required: true,
+                                description: "Array of fire engine and apparatus call signs responding (e.g., ['Engine-1', 'Ladder-1', 'Rescue-1'])"
+
+    VALID_FIRE_TYPES = %w[fire kitchen electrical basement garage wildfire]
+
+    property :location, required: true,
+                        description: 'Street address or location where fire engines should respond to the emergency'
+
+    property :fire_type, required: true,
+                         validate: ->(v) { VALID_FIRE_TYPES.include?(v) },
+                         validation_message: "Fire type must be: #{VALID_FIRE_TYPES.join(', ')}",
+                         description: "Classification of the fire type requiring specific suppression methods. Valid values: #{VALID_FIRE_TYPES.join(', ')}"
+
+    property :equipment_needed,
+             description: 'Specialized firefighting equipment and tools required for this specific fire type'
+
+    property :estimated_arrival,
+             description: "Projected time for first fire engine arrival at the emergency scene (e.g., '6 minutes')"
+
+    property :timestamp, required: true,
+                         description: 'Exact time when the fire dispatch was initiated (YYYY-MM-DD HH:MM:SS format)'
+  end
+end

data/examples/city_scenario/messages/fire_emergency_message.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+# examples/messages/fire_emergency_message.rb
+#
+# Fire emergency message sent by houses to the Fire Department when fires are detected
+# Triggers immediate fire department response with engine dispatch based on fire severity and type
+#
+require_relative '../../../lib/smart_message'
+
+module Messages
+  class FireEmergencyMessage < SmartMessage::Base
+    version 1
+
+    description "Critical fire emergency alert message sent by residential monitoring systems to the Fire Department when smoke, heat, or fire is detected, triggering immediate emergency response with fire engine dispatch, specialized equipment deployment, and rescue operations based on fire type, severity, and occupant safety status"
+
+    transport SmartMessage::Transport::RedisTransport.new
+    serializer SmartMessage::Serializer::Json.new
+
+    VALID_FIRE_TYPES = %w[fire kitchen electrical basement garage wildfire]
+    VALID_SEVERITY = %w[small medium large out_of_control]
+    VALID_OCCUPANTS_STATUS = %w[safe evacuated trapped rescued]
+    VALID_SPREAD_RISK = %w[low medium high]
+
+    property :house_address, required: true,
+      description: "Full street address of the house where fire was detected"
+
+    property :fire_type, required: true,
+      validate: ->(v) { VALID_FIRE_TYPES.include?(v) },
+      validation_message: "Fire type must be: #{VALID_FIRE_TYPES.join(', ')}",
+      description: "Classification of fire origin and type. Valid values: #{VALID_FIRE_TYPES.join(', ')}"
+
+    property :severity, required: true,
+      validate: ->(v) { VALID_SEVERITY.include?(v) },
+      validation_message: "Severity must be: #{VALID_SEVERITY.join(', ')}",
+      description: "Current intensity and spread level of the fire. Valid values: #{VALID_SEVERITY.join(', ')}"
+
+    property :timestamp, required: true,
+      description: "Exact time when the fire was first detected (YYYY-MM-DD HH:MM:SS format)"
+
+    property :occupants_status,
+      description: "Current safety status of people in the house. Valid values: #{VALID_OCCUPANTS_STATUS.join(', ')}"
+
+    property :spread_risk,
+      description: "Assessment of fire's potential to spread to neighboring structures. Valid values: #{VALID_SPREAD_RISK.join(', ')}"
+  end
+end

data/examples/city_scenario/messages/health_check_message.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# messages/health_check_message.rb
+#
+# Health check message broadcast by the Health Department to monitor city services
+# Sent every 5 seconds to all services to verify operational status
+
+require_relative '../../../lib/smart_message'
+
+module Messages
+
+  class HealthCheckMessage < SmartMessage::Base
+    version 1
+
+    description "Health monitoring message broadcast by the Health Department every 5 seconds to verify operational status of all city services including police, fire, banks, and residential monitoring systems"
+
+    transport SmartMessage::Transport::RedisTransport.new
+    serializer SmartMessage::Serializer::Json.new
+
+    property :check_id, required: true,
+      description: "Unique identifier for this health check request (UUID format)"
+  end
+end

data/examples/city_scenario/messages/health_status_message.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+# messages/health_status_message.rb
+#
+# Health status response message sent by city services back to the Health Department
+# Contains operational status with color-coded display (green=healthy, yellow=warning, orange=critical, red=failed)
+
+require_relative '../../../lib/smart_message'
+
+module Messages
+
+  class HealthStatusMessage < SmartMessage::Base
+    version 1
+
+    description "Operational status response message sent by city services to the Health Department in response to health check requests, providing real-time service condition reporting with color-coded status levels for monitoring dashboard display"
+
+    VALID_STATUS = %w[healthy warning critical failed]
+
+    transport  SmartMessage::Transport::RedisTransport.new
+    serializer SmartMessage::Serializer::Json.new
+
+    property :service_name, required: true,
+      description: "Name of the city service reporting its status (e.g., 'police-department', 'fire-department')"
+
+    property :check_id, required: true,
+      description: "ID of the health check request this message responds to"
+
+    property :status, required: true,
+      validate: ->(v) { VALID_STATUS.include?(v) },
+      validation_message: "Status must be: #{VALID_STATUS.join(', ')}",
+      description: "Current operational status of the service. Valid values: #{VALID_STATUS.join(', ')}"
+
+    property :details,
+      description: "Additional status information describing current service conditions"
+  end
+end

data/examples/city_scenario/messages/police_dispatch_message.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# messages/police_dispatch_message.rb
+# Police dispatch message sent by the Police Department in response to emergency calls
+# Contains unit assignments and response details for security incidents and crimes
+
+require_relative '../../../lib/smart_message'
+
+module Messages
+  class PoliceDispatchMessage < SmartMessage::Base
+    version 1
+
+    description <<~DESC
+      Law enforcement dispatch coordination message sent by the Police Department in response to emergency calls
+      and security incidents,   containing unit assignments, response priorities, and tactical deployment information
+      for crimes, alarms, and public safety threats
+    DESC
+
+    transport  SmartMessage::Transport::RedisTransport.new
+    serializer SmartMessage::Serializer::Json.new
+
+    VALID_PRIORITY = %w[low medium high emergency]
+
+    property :dispatch_id, required: true,
+      description: "Unique hexadecimal identifier for this police dispatch operation"
+
+    property :units_assigned, required: true,
+      description: "Array of police unit call signs assigned to respond (e.g., ['Unit-101', 'Unit-102'])"
+
+    property :location, required: true,
+      description: "Street address or location where police units should respond"
+
+    property :incident_type, required: true,
+      description: "Classification of the incident requiring police response (e.g., 'robbery', 'suspicious_activity')"
+
+    property :priority, required: true,
+      validate: ->(v) { VALID_PRIORITY.include?(v) },
+      validation_message: "Priority must be: #{VALID_PRIORITY.join(', ')}",
+      description: "Response urgency level determining dispatch speed. Valid values: #{VALID_PRIORITY.join(', ')}"
+
+    property :estimated_arrival,
+      description: "Projected time for first unit arrival at the scene (e.g., '5 minutes')"
+
+    property :timestamp, required: true,
+      description: "Exact time when the dispatch was initiated (YYYY-MM-DD HH:MM:SS format)"
+  end
+end

data/examples/city_scenario/messages/silent_alarm_message.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# messages/silent_alarm_message.rb
+# Silent alarm message sent by banks to the Police Department during security incidents
+# Triggers immediate police response with unit dispatch based on severity level
+
+require_relative '../../../lib/smart_message'
+
+module Messages
+  class SilentAlarmMessage < SmartMessage::Base
+    version 1
+
+    description <<~DESC
+      An automatic emergency security alert message sent by banking institutions, stores or houses
+      with monitored secutity systems. This message is used to the Police Department when security breaches,
+      robberies, or suspicious activities are detected, triggering immediate law enforcement response with
+      automatic unit dispatch based on the threat severity level.
+    DESC
+
+    transport  SmartMessage::Transport::RedisTransport.new
+    serializer SmartMessage::Serializer::Json.new
+
+    VALID_ALARM_TYPES = %w[robbery vault_breach suspicious_activity]
+    VALID_SEVERITY = %w[low medium high critical]
+
+    property :bank_name, required: true, description: "Official name of the bank triggering the alarm (e.g., 'First National Bank')"
+    property :location, required: true, description: "Physical address of the bank location where alarm was triggered"
+    property :alarm_type, required: true,
+      validate: ->(v) { VALID_ALARM_TYPES.include?(v) },
+      validation_message: "Alarm type must be: #{VALID_ALARM_TYPES.join(', ')}",
+      description: "Type of security incident detected. Valid values: #{VALID_ALARM_TYPES.join(', ')}"
+    property :timestamp, required: true, description: "Exact time when the alarm was triggered (YYYY-MM-DD HH:MM:SS format)"
+    property :severity, required: true,
+      validate: ->(v) { VALID_SEVERITY.include?(v) },
+      validation_message: "Severity must be: #{VALID_SEVERITY.join(', ')}",
+      description: "Urgency level of the security threat. Valid values: #{VALID_SEVERITY.join(', ')}"
+    property :details, description: "Additional descriptive information about the security incident and current situation"
+  end
+end

data/examples/city_scenario/police_department.rb

@@ -0,0 +1,316 @@
+#!/usr/bin/env ruby
+# examples/multi_program_demo/police_department.rb
+
+require_relative '../../lib/smart_message'
+require_relative 'messages/health_check_message'
+require_relative 'messages/health_status_message'
+require_relative 'messages/silent_alarm_message'
+require_relative 'messages/police_dispatch_message'
+require_relative 'messages/emergency_resolved_message'
+require_relative 'messages/emergency_911_message'
+
+require_relative 'common/health_monitor'
+require_relative 'common/logger'
+
+class PoliceDepartment
+  include Common::HealthMonitor
+  include Common::Logger
+
+  def initialize
+    @service_name = 'police_department'
+    @status = 'healthy'
+    @start_time = Time.now
+    @active_incidents = {}
+    @available_units = ['Unit-101', 'Unit-102', 'Unit-103', 'Unit-104']
+
+    setup_messaging
+    setup_signal_handlers
+    setup_health_monitor
+  end
+
+
+  def setup_messaging
+    Messages::EmergencyResolvedMessage.from(@service_name)
+
+    # Subscribe to silent alarms from banks
+    Messages::SilentAlarmMessage.subscribe(to: @service_name) do |message|
+      puts "🚔 DEBUG: Received SilentAlarmMessage to: #{message._sm_header.to}"
+      handle_silent_alarm(message)
+    end
+
+    # Subscribe to 911 calls routed from dispatch
+    Messages::Emergency911Message.subscribe(to: [@service_name, /police/i]) do |message|
+      puts "🚔 DEBUG: Received Emergency911Message to: #{message._sm_header.to}"
+      handle_911_call(message)
+    end
+
+    puts "🚔 Police Department operational"
+    puts "   Available units: #{@available_units.join(', ')}"
+    puts "   Responding to health checks, silent alarms, and 911 calls"
+    puts "   Press Ctrl+C to stop\n\n"
+    logger.info("Police Department operational with units: #{@available_units.join(', ')}")
+  end
+
+  def setup_signal_handlers
+    %w[INT TERM].each do |signal|
+      Signal.trap(signal) do
+        puts "\n🚔 Police Department signing off..."
+        logger.info("Police Department signing off")
+        exit(0)
+      end
+    end
+  end
+
+
+  def start_service
+    loop do
+      check_incident_resolutions
+      sleep(2)
+    end
+  rescue => e
+    puts "🚔 Error in police service: #{e.message}"
+    logger.error("Error in police service: #{e.message}")
+    retry
+  end
+
+  private
+
+  def service_emoji
+    "🚔"
+  end
+
+  def get_status_details
+    # Determine status based on available units and active incidents
+    @status = if @available_units.empty?
+                'critical'
+              elsif @available_units.size <= 1
+                'warning'
+              elsif @active_incidents.size >= 3
+                'warning'
+              else
+                'healthy'
+              end
+
+    details = case @status
+             when 'healthy' then "All units operational, #{@active_incidents.size} active incidents"
+             when 'warning' then "High call volume, #{@active_incidents.size} active incidents"
+             when 'critical' then "Multiple emergencies, all units deployed"
+             when 'failed' then "System down, emergency protocols activated"
+             end
+
+    [@status, details]
+  end
+
+  def handle_silent_alarm(alarm)
+    # Process silent alarm message
+    puts "🚨 SILENT ALARM: #{alarm.bank_name} at #{alarm.location} - #{alarm.alarm_type.upcase} (#{alarm.severity} severity)"
+    puts "   Details: #{alarm.details}" if alarm.details
+    puts "   Time: #{alarm.timestamp}"
+    logger.warn("SILENT ALARM received: #{alarm.alarm_type} at #{alarm.location} (#{alarm.severity} severity)")
+
+    # Assign available units
+    units_needed = case alarm.severity
+                  when 'low' then 1
+                  when 'medium' then 2
+                  when 'high' then 3
+                  when 'critical' then 4
+                  else 2
+                  end
+
+    assigned_units = @available_units.take(units_needed)
+    @available_units = @available_units.drop(units_needed)
+
+    dispatch_id = SecureRandom.hex(4)
+    @active_incidents[dispatch_id] = {
+      location: alarm.location,
+      start_time: Time.now,
+      units: assigned_units,
+      type: alarm.alarm_type
+    }
+
+    # Send dispatch message
+    dispatch = Messages::PoliceDispatchMessage.new(
+      dispatch_id: dispatch_id,
+      units_assigned: assigned_units,
+      location: alarm.location,
+      incident_type: alarm.alarm_type,
+      priority: map_severity_to_priority(alarm.severity),
+      estimated_arrival: "#{rand(3..8)} minutes",
+      timestamp: Time.now.strftime('%Y-%m-%d %H:%M:%S'),
+    )
+    dispatch.publish
+
+    puts "🚔 Dispatched #{assigned_units.size} units to #{alarm.location}"
+    puts "   Available units: #{@available_units.size}"
+    logger.info("Dispatched units #{assigned_units.join(', ')} to #{alarm.location} (#{dispatch_id})")
+  rescue => e
+    puts "🚔 Error handling silent alarm: #{e.message}"
+    logger.error("Error handling silent alarm: #{e.message}")
+  end
+
+  def handle_911_call(call)
+    # Color code based on emergency type
+    type_color = case call.emergency_type
+                 when 'accident' then "\e[33m"  # Yellow
+                 when 'crime' then "\e[31m"     # Red
+                 else "\e[36m"                  # Cyan
+                 end
+
+    puts "\n#{type_color}🚔 911 CALL RECEIVED\e[0m from dispatch"
+    puts "   📍 Location: #{call.caller_location}"
+    puts "   🚨 Type: #{call.emergency_type.upcase}"
+    puts "   📝 Description: #{call.description}"
+    puts "   👤 Caller: #{call.caller_name || 'Unknown'}"
+
+    logger.warn("911 Call: #{call.emergency_type} at #{call.caller_location} - #{call.description}")
+
+    # Handle based on emergency type
+    case call.emergency_type
+    when 'accident'
+      handle_accident_call(call)
+    when 'crime'
+      handle_crime_call(call)
+    else
+      handle_general_911_call(call)
+    end
+  rescue => e
+    puts "🚔 Error handling 911 call: #{e.message}"
+    logger.error("Error handling 911 call: #{e.message}")
+  end
+
+  def handle_accident_call(call)
+    incident_id = "ACC-#{Time.now.strftime('%H%M%S')}"
+
+    # Determine units needed based on severity
+    units_needed = case call.severity
+                   when 'critical' then 3
+                   when 'high' then 2
+                   else 1
+                   end
+
+    units_needed = [units_needed, @available_units.size].min
+    assigned_units = @available_units.shift(units_needed)
+
+    if assigned_units.empty?
+      puts "🚔 ⚠️  No units available for accident response!"
+      logger.error("No units available for accident at #{call.caller_location}")
+      return
+    end
+
+    @active_incidents[incident_id] = {
+      type: 'accident',
+      location: call.caller_location,
+      units: assigned_units,
+      start_time: Time.now,
+      call: call
+    }
+
+    puts "🚔 Dispatched #{assigned_units.join(', ')} to accident at #{call.caller_location}"
+    puts "   Vehicles involved: #{call.vehicles_involved || 'Unknown'}"
+    puts "   Injuries: #{call.injuries_reported ? 'Yes' : 'No'}"
+    logger.info("Dispatched #{assigned_units.join(', ')} to accident #{incident_id}")
+  end
+
+  def handle_crime_call(call)
+    incident_id = "CRM-#{Time.now.strftime('%H%M%S')}"
+
+    # Determine units based on severity and weapons
+    units_needed = call.weapons_involved ? 3 : 2
+    units_needed = [units_needed, @available_units.size].min
+    assigned_units = @available_units.shift(units_needed)
+
+    if assigned_units.empty?
+      puts "🚔 ⚠️  No units available for crime response!"
+      logger.error("No units available for crime at #{call.caller_location}")
+      return
+    end
+
+    @active_incidents[incident_id] = {
+      type: 'crime',
+      location: call.caller_location,
+      units: assigned_units,
+      start_time: Time.now,
+      call: call
+    }
+
+    puts "🚔 Dispatched #{assigned_units.join(', ')} to crime scene at #{call.caller_location}"
+    puts "   Weapons involved: #{call.weapons_involved ? 'YES' : 'No'}"
+    puts "   Suspects on scene: #{call.suspects_on_scene ? 'YES' : 'Unknown'}"
+    logger.info("Dispatched #{assigned_units.join(', ')} to crime #{incident_id}")
+  end
+
+  def handle_general_911_call(call)
+    incident_id = "GEN-#{Time.now.strftime('%H%M%S')}"
+
+    assigned_units = @available_units.shift(1)
+
+    if assigned_units.empty?
+      puts "🚔 ⚠️  No units available for response!"
+      logger.error("No units available for call at #{call.caller_location}")
+      return
+    end
+
+    @active_incidents[incident_id] = {
+      type: call.emergency_type,
+      location: call.caller_location,
+      units: assigned_units,
+      start_time: Time.now,
+      call: call
+    }
+
+    puts "🚔 Dispatched #{assigned_units.join(', ')} to #{call.emergency_type} at #{call.caller_location}"
+    logger.info("Dispatched #{assigned_units.join(', ')} to #{call.emergency_type} #{incident_id}")
+  end
+
+  def check_incident_resolutions
+    @active_incidents.each do |incident_id, incident|
+      # Simulate incident resolution after 10-15 seconds
+      duration = (Time.now - incident[:start_time]).to_i
+      if duration > rand(10..15)
+        resolve_incident(incident_id, incident, duration)
+      end
+    end
+  end
+
+  def resolve_incident(incident_id, incident, duration_seconds)
+    # Return units to available pool
+    @available_units.concat(incident[:units])
+    @active_incidents.delete(incident_id)
+
+    outcomes = ['Suspects apprehended', 'False alarm - all clear', 'Incident resolved peacefully', 'Suspects fled scene']
+
+    resolution = Messages::EmergencyResolvedMessage.new(
+      incident_id: incident_id,
+      incident_type: incident[:type],
+      location: incident[:location],
+      resolved_by: @service_name,
+      resolution_time: Time.now.strftime('%Y-%m-%d %H:%M:%S'),
+      duration_minutes: (duration_seconds / 60.0).round(1),
+      outcome: outcomes.sample,
+      units_involved: incident[:units],
+    )
+    resolution.publish
+
+    puts "🚔 Incident #{incident_id} resolved after #{(duration_seconds / 60.0).round(1)} minutes"
+    puts "   Units #{incident[:units].join(', ')} now available"
+    logger.info("Incident #{incident_id} resolved: #{outcomes.last} after #{(duration_seconds / 60.0).round(1)} minutes")
+  rescue => e
+    puts "🚔 Error resolving incident: #{e.message}"
+    logger.error("Error resolving incident: #{e.message}")
+  end
+
+  def map_severity_to_priority(severity)
+    case severity
+    when 'low' then 'low'
+    when 'medium' then 'medium'
+    when 'high' then 'high'
+    when 'critical' then 'emergency'
+    else 'medium'
+    end
+  end
+end
+
+if __FILE__ == $0
+  police_dept = PoliceDepartment.new
+  police_dept.start_service
+end