rsmp 0.40.0 → 0.41.0

data/config/supervisor.yaml

@@ -1,5 +1,5 @@
 port: 12111
-guest:
+default:
   sxl: tlc
   intervals:
     timer: 0.1

data/documentation/configuration.md

@@ -54,15 +54,81 @@ log:
 
 ```yaml
 port: 12111
-guest:
+default:
   sxl: tlc
   intervals:
     timer: 0.1
     watchdog: 0.1
 log:
   json: true
+sites:
+  TLC001:
+    sxl: tlc
+    sxl_version: "1.2.1"
+    intervals:
+      timer: 0.1
+      watchdog: 0.1
+    timeouts:
+      connect: 1
+      acknowledgement: 1
+    components:
+      main:
+        TC:
 ```
 
+Per-site configuration follows the supervisor-side site schema (`lib/rsmp/options/schemas/supervisor_site.json`). Each site entry must include an `sxl` value; if `sxl` is missing the supervisor will raise a `RSMP::ConfigurationError` on startup.
+
+## Supervisor settings
+
+The following lists the top-level supervisor settings and the keys available for per-site configuration under `sites`.
+
+Top-level supervisor settings
+
+- `port`: integer|string — TCP port the supervisor listens on (default: `12111`).
+- `ip`: string — address to bind to.
+- `ips`: string or array — `'all'` or a list of allowed IP addresses.
+- `site_id`: string — optional site identifier for the supervisor itself.
+- `max_sites`: integer — limit concurrent connected sites.
+- `default`: object — default settings applied to sites that don't have a specific `sites` entry. Contains keys:
+  - `sxl`: string — default SXL type for default sites (e.g. `tlc`).
+  - `sxl_version`, `core_version`: strings for version hints.
+  - `intervals`: object with `timer`, `watchdog` (numbers, seconds).
+  - `timeouts`: object with `watchdog`, `acknowledgement` (numbers, seconds).
+- `log`: object — log settings (see `log_settings` elsewhere in docs).
+- `sites`: mapping — per-site settings (see below).
+
+## Per-site settings (`sites` mapping)
+
+Each key under `sites` is a site id (for example `TLC001`) and the value is the supervisor-side configuration for that site. These settings tell the supervisor how to handle incoming connections from that specific site (which SXL/schema to use, per-site timeouts, component layout, etc.). Per-site configuration follows the supervisor-side schema at `lib/rsmp/options/schemas/supervisor_site.json`.
+
+If a connecting site's id is not present under `sites`, the supervisor will fall back to the `default` settings. The runtime configuration check will raise `RSMP::ConfigurationError` if a site entry is present but missing the required `sxl` key.
+
+
+Common per-site keys
+
+- `sxl` (string, required): the SXL type to use for this site (for example `tlc`). The supervisor will attempt to load the corresponding schemas for this SXL.
+- `sxl_version` (string): preferred SXL version (informational; runtime version comes from the site's Version message).
+- `type` (string): optional human-readable type identifier.
+- `site_id` (string): explicit site identifier (if different from the mapping key).
+- `supervisors` (array): list of supervisor endpoints (objects with `ip` and `port`). Useful for reverse mappings or local-site configs.
+- `components` (object): component definitions (same structure as site `components`), used by the supervisor-side proxies to set up component proxies.
+- `intervals` (object): per-site timer settings — `timer`, `watchdog`, `reconnect`, `after_connect` (numbers, seconds).
+- `timeouts` (object): per-site timeouts — `connect`, `watchdog`, `acknowledgement` (numbers, seconds).
+- `send_after_connect` (boolean): whether to send messages after connect without waiting for additional events.
+- `skip_validation` (array[string]): list of message types to skip JSON schema validation for this site.
+- `security_codes` (object): map of security code levels to secrets.
+
+### TLC-specific settings
+
+TLC-specific settings are used when a site uses the `tlc` SXL and include:
+
+- `startup_sequence` (string): expected startup sequence for the traffic controller.
+- `signal_plans` (object): signal plan definitions and timing information.
+- `inputs` (object): input definitions for the controller.
+- `live_output` (string|null): optional live output destination.
+
+See `lib/rsmp/options/schemas/traffic_controller_site.json` for the full schema and examples.
+
 ## Validation
 
 Invalid configurations raise `RSMP::ConfigurationError` with details about the failing path. The CLI prints these errors when loading config files.

data/lib/rsmp/cli.rb

@@ -163,8 +163,8 @@ module RSMP
     def apply_core_version_option(settings)
       return unless options[:core]
 
-      settings['guest'] ||= {}
-      settings['guest']['core_version'] = options[:core]
+      settings['default'] ||= {}
+      settings['default']['core_version'] = options[:core]
     end
 
     def apply_log_options(log_settings)

data/lib/rsmp/helpers/inspect.rb

@@ -11,7 +11,7 @@ module RSMP
   # Array#to_s and Hash#to_s usually show items, but here we show just number
   # of items, when the short form is requested.
   module Inspect
-    def inspector *short_items
+    def inspector(*short_items)
       instance_variables.map do |var_name|
         var = instance_variable_get(var_name)
         class_name = var.class.name

data/lib/rsmp/node/supervisor/modules/configuration.rb

@@ -6,13 +6,13 @@ module RSMP
         def handle_supervisor_settings(supervisor_settings)
           options = RSMP::Supervisor::Options.new(supervisor_settings || {})
           @supervisor_settings = options.to_h
-          @core_version = @supervisor_settings.dig('guest', 'core_version')
+          @core_version = @supervisor_settings.dig('default', 'core_version')
           check_site_sxl_types
         end
 
         def check_site_sxl_types
           sites = @supervisor_settings['sites'].clone || {}
-          sites['guest'] = @supervisor_settings['guest']
+          sites['default'] = @supervisor_settings['default']
           sites.each do |site_id, settings|
             raise RSMP::ConfigurationError, "Configuration for site '#{site_id}' is empty" unless settings
 
@@ -26,16 +26,18 @@ module RSMP
         end
 
         def site_id_to_site_setting(site_id)
-          return {} unless @supervisor_settings['sites']
+          base = @supervisor_settings['default'] || {}
 
-          @supervisor_settings['sites'].each_pair do |id, settings|
-            return settings if id == 'guest' || id == site_id
-          end
-          raise HandshakeError, "site id #{site_id} unknown"
+          return base unless @supervisor_settings['sites']
+
+          site_specific = @supervisor_settings['sites'][site_id] || @supervisor_settings['sites']['default']
+          return base unless site_specific
+
+          base.deep_merge(site_specific)
         end
 
         def ip_to_site_settings(ip)
-          @supervisor_settings['sites'][ip] || @supervisor_settings['sites']['guest']
+          @supervisor_settings['sites'][ip] || @supervisor_settings['sites']['default']
         end
       end
     end

data/lib/rsmp/node/supervisor/modules/connection.rb

@@ -40,7 +40,7 @@ module RSMP
           return if @supervisor_settings['ips'] == 'all'
           return if @supervisor_settings['ips'].include? ip
 
-          raise ConnectionError, 'guest ip not allowed'
+          raise ConnectionError, 'default ip not allowed'
         end
 
         def check_max_sites
@@ -60,6 +60,8 @@ module RSMP
         def build_proxy_settings(socket, info)
           stream = IO::Stream::Buffered.new(socket)
           protocol = RSMP::Protocol.new stream
+          site_id = retrieve_site_id(protocol)
+          site_settings = site_id_to_site_setting site_id
 
           {
             supervisor: self,
@@ -72,7 +74,9 @@ module RSMP
             protocol: protocol,
             info: info,
             logger: @logger,
-            archive: @archive
+            archive: @archive,
+            site_id: site_id,
+            site_settings: site_settings
           }
         end
 
@@ -83,12 +87,12 @@ module RSMP
 
         def setup_proxy(proxy, settings, id)
           if proxy
-            raise ConnectionError, "Site #{id} alredy connected from port #{proxy.port}" if proxy.connected?
+            raise ConnectionError, "Site #{id} already connected from port #{proxy.port}" if proxy.connected?
 
             proxy.revive settings
           else
             check_max_sites
-            proxy = build_proxy settings.merge(site_id: id)
+            proxy = build_proxy settings
             @proxies.push proxy
           end
           proxy
@@ -100,6 +104,9 @@ module RSMP
           log "Validating using core version #{proxy.core_version}", level: :debug
           proxy.start
           proxy.wait
+        ensure
+          proxy_type = proxy ? proxy.class.name.split('::').last : 'SiteProxy'
+          log "Created #{proxy_type} for site #{proxy&.site_id}", level: :debug
         end
 
         def accept_connection(socket, info)
@@ -112,7 +119,7 @@ module RSMP
           authorize_ip info[:ip]
 
           settings = build_proxy_settings(socket, info)
-          id = retrieve_site_id(settings[:protocol])
+          id = settings[:site_id]
           proxy = setup_proxy(find_site(id), settings, id)
 
           validate_and_start_proxy(proxy, settings[:protocol])
@@ -121,6 +128,8 @@ module RSMP
           stop if @supervisor_settings['one_shot']
         end
 
+        # Proxy type is now derived from `site_settings['sxl']` in Supervisor#build_proxy.
+
         def reject_connection(_socket, info)
           log 'Site rejected', ip: info[:ip], level: :info
         end

data/lib/rsmp/node/supervisor/supervisor.rb

@@ -59,6 +59,13 @@ module RSMP
     end
 
     def build_proxy(settings)
+      # Determine proxy type from site settings (SXL). Fall back to supervisor
+      # default settings when site-specific settings are not present.
+      site_settings = settings[:site_settings] || @supervisor_settings['default']
+      sxl_type = site_settings && site_settings['sxl']
+
+      return RSMP::TLC::TrafficControllerProxy.new(settings) if sxl_type == 'tlc'
+
       SiteProxy.new settings
     end
 

data/lib/rsmp/options/schemas/supervisor.json

@@ -12,7 +12,7 @@
     },
     "site_id": { "type": "string" },
     "max_sites": { "type": "integer" },
-    "guest": {
+    "default": {
       "type": "object",
       "properties": {
         "sxl": { "type": "string" },
@@ -37,7 +37,10 @@
       },
       "additionalProperties": true
     },
-    "sites": { "type": "object" }
+    "sites": {
+      "type": "object",
+      "additionalProperties": { "$ref": "supervisor_site.json" }
+    }
   },
   "additionalProperties": true
-}
+}

data/lib/rsmp/options/schemas/supervisor_site.json

@@ -0,0 +1,46 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "supervisor_site.json",
+  "type": "object",
+  "properties": {
+    "sxl": { "type": "string" },
+    "sxl_version": { "type": "string" },
+    "type": { "type": "string" },
+    "components": { "type": "object" },
+    "supervisors": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "ip": { "type": "string" },
+          "port": { "type": ["integer", "string"] }
+        },
+        "required": ["ip", "port"],
+        "additionalProperties": true
+      }
+    },
+    "intervals": {
+      "type": "object",
+      "properties": {
+        "timer": { "type": "number" },
+        "watchdog": { "type": "number" },
+        "reconnect": { "type": "number" },
+        "after_connect": { "type": "number" }
+      },
+      "additionalProperties": true
+    },
+    "timeouts": {
+      "type": "object",
+      "properties": {
+        "connect": { "type": "number" },
+        "watchdog": { "type": "number" },
+        "acknowledgement": { "type": "number" }
+      },
+      "additionalProperties": true
+    },
+    "send_after_connect": { "type": "boolean" },
+    "skip_validation": { "type": "array", "items": { "type": "string" } },
+    "security_codes": { "type": "object" }
+  },
+  "additionalProperties": true
+}

data/lib/rsmp/options/schemas/traffic_controller_site.json

@@ -10,9 +10,10 @@
         "startup_sequence": { "type": "string" },
         "signal_plans": { "type": "object" },
         "inputs": { "type": "object" },
-        "live_output": { "type": ["string", "null"] }
+        "live_output": { "type": ["string", "null"] },
+        "type": { "type": "string" }
       },
       "additionalProperties": true
     }
   ]
-}
+}

data/lib/rsmp/options/supervisor_options.rb

@@ -6,7 +6,7 @@ module RSMP
         {
           'port' => 12_111,
           'ips' => 'all',
-          'guest' => {
+          'default' => {
             'sxl' => 'tlc',
             'intervals' => {
               'timer' => 1,
@@ -14,7 +14,9 @@ module RSMP
             },
             'timeouts' => {
               'watchdog' => 2,
-              'acknowledgement' => 2
+              'acknowledgement' => 2,
+              'command' => 10,
+              'status_response' => 10
             }
           }
         }

data/lib/rsmp/proxy/proxy.rb

@@ -22,6 +22,7 @@ module RSMP
 
     def initialize(options)
       @node = options[:node]
+      options[:logger] = @node&.logger unless options[:logger] # default to node logger
       initialize_logging options
       initialize_distributor
       initialize_task

data/lib/rsmp/proxy/site/modules/alarms.rb

@@ -21,6 +21,64 @@ module RSMP
           send_message message, validate: options[:validate]
           message
         end
+
+        # Send an AlarmSuspend message and optionally collect the confirming response.
+        # When collect: true, returns [message, response]; when collect: false, returns message.
+        def suspend_alarm(task, c_id:, a_c_id:, collect: false)
+          message = RSMP::AlarmSuspend.new(
+            'mId' => RSMP::Message.make_m_id,
+            'cId' => c_id,
+            'aCId' => a_c_id
+          )
+          if collect
+            collect_task = task.async do
+              RSMP::AlarmCollector.new(self,
+                                       m_id: message.m_id,
+                                       num: 1,
+                                       matcher: {
+                                         'cId' => c_id,
+                                         'aCI' => a_c_id,
+                                         'aSp' => 'Suspend',
+                                         'sS' => /^Suspended/i
+                                       },
+                                       timeout: node.supervisor_settings.dig('default', 'timeouts', 'alarm')).collect!
+            end
+            send_message message
+            [message, collect_task.wait.first]
+          else
+            send_message message
+            message
+          end
+        end
+
+        # Send an AlarmResume message and optionally collect the confirming response.
+        # When collect: true, returns [message, response]; when collect: false, returns message.
+        def resume_alarm(task, c_id:, a_c_id:, collect: false)
+          message = RSMP::AlarmResume.new(
+            'mId' => RSMP::Message.make_m_id,
+            'cId' => c_id,
+            'aCId' => a_c_id
+          )
+          if collect
+            collect_task = task.async do
+              RSMP::AlarmCollector.new(self,
+                                       m_id: message.m_id,
+                                       num: 1,
+                                       matcher: {
+                                         'cId' => c_id,
+                                         'aCI' => a_c_id,
+                                         'aSp' => 'Suspend',
+                                         'sS' => /^notSuspended/i
+                                       },
+                                       timeout: node.supervisor_settings.dig('default', 'timeouts', 'alarm')).collect!
+            end
+            send_message message
+            [message, collect_task.wait.first]
+          else
+            send_message message
+            message
+          end
+        end
       end
     end
   end

data/lib/rsmp/proxy/site/modules/status.rb

@@ -97,6 +97,15 @@ module RSMP
           message
         end
 
+        # unsubscribes to all statuses (with all attributes) defined in the used SXL
+        def unsubscribe_from_all(component_id)
+          catalogue = RSMP::Schema.status_catalogue(@sxl, sxl_version)
+          status_list = catalogue.flat_map do |status_code_id, names|
+            names.map { |name| { 'sCI' => status_code_id.to_s, 'n' => name.to_s } }
+          end
+          unsubscribe_to_status component_id, status_list
+        end
+
         def process_status_update(message)
           component = find_component message.attribute('cId')
           component.check_repeat_values message, @status_subscriptions

data/lib/rsmp/proxy/site/site_proxy.rb

@@ -158,15 +158,20 @@ module RSMP
     end
 
     def find_site_settings(_site_id)
-      if @settings['sites'] && @settings['sites'][@site_id]
-        log "Using site settings for site id #{@site_id}", level: :debug
-        return @settings['sites'][@site_id]
+      base = @settings['default'] || {}
+
+      if @settings['sites']
+        site_specific = @settings['sites'][@site_id] || @settings['sites']['default']
+        if site_specific
+          label = @settings['sites'][@site_id] ? "site id #{@site_id}" : 'default'
+          log "Using #{label} site settings", level: :debug
+          return base.deep_merge(site_specific)
+        end
       end
 
-      @settings['guest']
-      if @settings['guest']
-        log 'Using site settings for guest', level: :debug
-        return @settings['guest']
+      unless base.empty?
+        log 'Using default site settings', level: :debug
+        return base
       end
 
       nil

data/lib/rsmp/tlc/modules/inputs.rb

@@ -7,7 +7,7 @@ module RSMP
         def setup_inputs(inputs)
           if inputs
             num_inputs = inputs['total']
-            @input_programming = inputs['programming']
+            @input_programming = normalize_input_programming(inputs['programming'])
           else
             @input_programming = nil
           end
@@ -167,6 +167,35 @@ module RSMP
             TrafficControllerSite.make_status @inputs.forced_string
           end
         end
+
+        private
+
+        def normalize_input_programming(programming)
+          return nil if programming.nil?
+          return programming if programming.is_a?(Array)
+          return programming unless programming.is_a?(Hash)
+
+          normalized = normalize_programming_keys(programming)
+          return normalized unless normalized.keys.all?(Integer)
+
+          programming_hash_to_array(normalized)
+        end
+
+        def normalize_programming_keys(programming)
+          programming.each_with_object({}) do |(key, value), memo|
+            int_key = key.is_a?(String) && key.match?(/^\d+$/) ? key.to_i : key
+            memo[int_key] = value
+          end
+        end
+
+        def programming_hash_to_array(normalized)
+          max_key = normalized.keys.max
+          program_array = Array.new(max_key + 1)
+          normalized.each do |index, value|
+            program_array[index] = value
+          end
+          program_array
+        end
       end
     end
   end

data/lib/rsmp/tlc/proxy/control.rb

@@ -0,0 +1,158 @@
+module RSMP
+  module TLC
+    module Proxy
+      # Command methods for operational control of a remote TLC.
+      # Covers functional position, emergency routes, I/O modes, signal group orders, and system settings.
+      module Control
+        # M0001 — Set functional position (NormalControl, YellowFlash, Dark).
+        def set_functional_position(status, timeout_minutes: 0, options: {})
+          validate_ready 'set functional position'
+          raise 'TLC main component not found' unless main
+
+          command_list = functional_position_command_list(status, timeout_minutes)
+          confirm_status = functional_position_confirm_status(status)
+          send_command_with_confirm main.c_id, command_list, options, "functional position #{status}", confirm_status
+        end
+
+        # M0005 — Set or clear an emergency route.
+        def set_emergency_route(route:, active:, options: {})
+          validate_ready 'set emergency route'
+          raise 'TLC main component not found' unless main
+
+          security_code = security_code_for(2)
+          active_str = active ? 'True' : 'False'
+
+          command_list = [{
+            'cCI' => 'M0005',
+            'cO' => 'setEmergency',
+            'n' => 'status',
+            'v' => active_str
+          }, {
+            'cCI' => 'M0005',
+            'cO' => 'setEmergency',
+            'n' => 'securityCode',
+            'v' => security_code.to_s
+          }, {
+            'cCI' => 'M0005',
+            'cO' => 'setEmergency',
+            'n' => 'emergencyroute',
+            'v' => route.to_s
+          }]
+
+          confirm_status = [{ 'sCI' => 'S0006', 'n' => 'status', 's' => active_str }]
+          send_command_with_confirm main.c_id, command_list, options,
+                                    "emergency route #{route} #{active ? 'active' : 'inactive'}", confirm_status
+        end
+
+        # M0007 — Enable or disable fixed-time control.
+        def set_fixed_time(status, options: {})
+          validate_ready 'set fixed time'
+          raise 'TLC main component not found' unless main
+
+          security_code = security_code_for(2)
+
+          command_list = [{
+            'cCI' => 'M0007',
+            'cO' => 'setFixedTime',
+            'n' => 'status',
+            'v' => status.to_s
+          }, {
+            'cCI' => 'M0007',
+            'cO' => 'setFixedTime',
+            'n' => 'securityCode',
+            'v' => security_code.to_s
+          }]
+
+          confirm_status = [{ 'sCI' => 'S0009', 'n' => 'status',
+                              's' => /^#{Regexp.escape(status.to_s)}(,#{Regexp.escape(status.to_s)})*$/ }]
+          send_command_with_confirm main.c_id, command_list, options, "fixed time #{status}", confirm_status
+        end
+
+        # M0003 — Set traffic situation (activate a specific situation number).
+        def set_traffic_situation(situation, options: {})
+          validate_ready 'set traffic situation'
+          raise 'TLC main component not found' unless main
+
+          security_code = security_code_for(2)
+
+          command_list = [{
+            'cCI' => 'M0003',
+            'cO' => 'setTrafficSituation',
+            'n' => 'status',
+            'v' => 'True'
+          }, {
+            'cCI' => 'M0003',
+            'cO' => 'setTrafficSituation',
+            'n' => 'securityCode',
+            'v' => security_code.to_s
+          }, {
+            'cCI' => 'M0003',
+            'cO' => 'setTrafficSituation',
+            'n' => 'traficsituation',
+            'v' => situation.to_s
+          }]
+
+          confirm_status = [{ 'sCI' => 'S0015', 'n' => 'status', 's' => situation.to_s }]
+          send_command_with_confirm main.c_id, command_list, options, "traffic situation #{situation}", confirm_status
+        end
+
+        # M0003 — Clear the active traffic situation.
+        def unset_traffic_situation(options: {})
+          validate_ready 'unset traffic situation'
+          raise 'TLC main component not found' unless main
+
+          security_code = security_code_for(2)
+
+          command_list = [{
+            'cCI' => 'M0003',
+            'cO' => 'setTrafficSituation',
+            'n' => 'status',
+            'v' => 'False'
+          }, {
+            'cCI' => 'M0003',
+            'cO' => 'setTrafficSituation',
+            'n' => 'securityCode',
+            'v' => security_code.to_s
+          }, {
+            'cCI' => 'M0003',
+            'cO' => 'setTrafficSituation',
+            'n' => 'traficsituation',
+            'v' => '1'
+          }]
+
+          confirm_status = [{ 'sCI' => 'S0015', 'n' => 'status', 's' => '1' }]
+          send_command_with_confirm main.c_id, command_list, options, 'traffic situation unset', confirm_status
+        end
+
+        private
+
+        def functional_position_command_list(status, timeout_minutes)
+          security_code = security_code_for(2)
+          [
+            { 'cCI' => 'M0001', 'cO' => 'setValue', 'n' => 'status', 'v' => status.to_s },
+            { 'cCI' => 'M0001', 'cO' => 'setValue', 'n' => 'securityCode', 'v' => security_code.to_s },
+            { 'cCI' => 'M0001', 'cO' => 'setValue', 'n' => 'timeout', 'v' => timeout_minutes.to_s },
+            { 'cCI' => 'M0001', 'cO' => 'setValue', 'n' => 'intersection', 'v' => '0' }
+          ]
+        end
+
+        def functional_position_confirm_status(status)
+          case status.to_s
+          when 'YellowFlash'
+            [{ 'sCI' => 'S0011', 'n' => 'status', 's' => /^True(,True)*$/ }]
+          when 'Dark'
+            [{ 'sCI' => 'S0007', 'n' => 'status', 's' => /^False(,False)*$/ }]
+          when 'NormalControl'
+            [
+              { 'sCI' => 'S0007', 'n' => 'status', 's' => /^True(,True)*$/ },
+              { 'sCI' => 'S0011', 'n' => 'status', 's' => /^False(,False)*$/ },
+              { 'sCI' => 'S0005', 'n' => 'status', 's' => 'False' }
+            ]
+          else
+            []
+          end
+        end
+      end
+    end
+  end
+end