rsmp 0.8.0 → 0.8.4

data/lib/rsmp/collect/query.rb

@@ -8,26 +8,36 @@ module RSMP
       @want = want
       @got = nil
       @message = nil
-      @done = false
     end
 
     # Are we done, i.e. did the last checked item match?
     def done?
-      @done
+      @got != nil
     end
 
     # Check an item and set @done to true if it matches
     # Store the item and corresponding message if there's a positive or negative match
-    def perform_match item, message
+    def perform_match item, message, block
       matched = match? item
       if matched != nil
-        @message = message
-        @got = item
-        @done = matched
+        if block
+          status = block.call(nil,item)
+          matched = status if status == true || status == false
+        end
       end
       matched
     end
 
+    def keep message, item
+      @message = message
+      @got = item
+    end
+
+    def forget
+      @message = nil
+      @got = nil
+    end
+
     def match? item
     end
   end

data/lib/rsmp/collect/{matcher.rb → state_collector.rb}

@@ -31,8 +31,7 @@ module RSMP
   #   {"cCI"=>"M0104", "cO"=>"setDate", "n"=>"month", "v"=>/\d+/} =>
   #     { <StatusResponse message>, {"cCI"=>"M0104", "cO"=>"setDate", "n"=>"month", "v"=>"9"} }
   # }
-
-  class Matcher < Collector
+  class StateCollector < Collector
     attr_reader :queries
 
     # Initialize with a list of wanted statuses
@@ -62,7 +61,7 @@ module RSMP
 
     # Get messages from results
     def messages
-      @queries.map { |query| query.message }.uniq
+      @queries.map { |query| query.message }.uniq.compact
     end
 
     # Return progress as completes queries vs. total number of queries
@@ -91,22 +90,33 @@ module RSMP
     # Check if a messages matches our criteria.
     # Match each query against each item in the message
     def perform_match message
-      return unless type_match?(message)
+      return false if super(message) == false
+      return unless collecting?
       @queries.each do |query|       # look through queries
         get_items(message).each do |item|  # look through items in message
-          matched = query.perform_match(item,message)
-          if matched == true
-            matched = @block.call(message,item) if @block
-          end
+          matched = query.perform_match(item,message,@block)
+          return unless collecting?
           if matched != nil
             type = {true=>'match',false=>'mismatch'}[matched]
             @notifier.log "#{@title.capitalize} #{message.m_id_short} collect #{type} #{query.want}, item #{item}", level: :debug
-            break
+            if matched == true
+              query.keep message, item
+            elsif matched == false
+              query.forget
+            end
           end
         end
       end
       complete if done?
       @notifier.log "#{@title.capitalize} collect reached #{summary}", level: :debug
     end
+
+    # don't collect anything. Query will collect them instead
+    def keep message
+    end
+
+    def describe
+      @queries.map {|q| q.want.to_s }
+    end
   end
 end

data/lib/rsmp/collect/status_collector.rb

@@ -0,0 +1,20 @@
+module RSMP
+  # Base class for waiting for status updates or responses
+  class StatusCollector < StateCollector
+    def initialize proxy, want, options={}
+      super proxy, want, options.merge(title: 'status response', type:['MessageNotAck'])
+
+      @options[:type] << 'StatusUpdate' unless options[:updates] == false
+      @options[:type] << 'StatusResponse' unless options[:reponses] == false
+    end
+
+    def build_query want
+      RSMP::StatusQuery.new want
+    end
+
+    # Get items, in our case status values
+    def get_items message
+      message.attributes['sS'] || []
+    end
+  end
+end

data/lib/rsmp/collect/{message_queries.rb → status_query.rb}

@@ -1,19 +1,4 @@
 module RSMP
-  # Match a specific command responses
-  class CommandQuery < Query
-    # Match a return value item against a query
-    def match? item
-      return nil if @want['cCI'] && @want['cCI'] != item['cCI']
-      return nil if @want['n'] && @want['n'] != item['n']
-      if @want['v'].is_a? Regexp
-        return false if @want['v'] && item['v'] !~ @want['v']
-      else
-        return false if @want['v'] && item['v'] != @want['v']
-      end
-      true
-    end
-  end
-
   # Match a specific status response or update
   class StatusQuery < Query
     # Match a status value against a query

data/lib/rsmp/node.rb

@@ -15,7 +15,6 @@ module RSMP
       @clock = Clock.new
       @error_queue = Async::Queue.new
       @ignore_errors = []
-      options[:collector]
       @collect = options[:collect]
     end
 

data/lib/rsmp/proxy.rb

@@ -52,12 +52,6 @@ module RSMP
       node.clock
     end
 
-    def collect task, options, &block
-      collector = RSMP::Collector.new self, options
-      collector.collect task, &block
-      collector
-    end
-
     def run
       start
       @reader.wait if @reader
@@ -579,25 +573,27 @@ module RSMP
     end
 
     def wait_for_acknowledgement parent_task, options={}, m_id
-      collect(parent_task,options.merge({
-        type: ['MessageAck','MessageNotAck'],
-        num: 1
-      })) do |message|
+      collector = Collector.new self, options.merge(task: parent_task, type: ['MessageAck','MessageNotAck'])
+      collector.collect do |message|
         if message.is_a?(MessageNotAck)
           if message.attribute('oMId') == m_id
-            # set result to an exception, but don't raise it.
-            # this will be returned by the task and stored as the task result
-            # when the parent task call wait() on the task, the exception
-            # will be raised in the parent task, and caught by rspec.
-            # rspec will then show the error and record the test as failed
             m_id_short = RSMP::Message.shorten_m_id m_id, 8
-            result = RSMP::MessageRejected.new "Aggregated status request #{m_id_short} was rejected with '#{message.attribute('rea')}'"
-            next true   # done, no more messages wanted
+            raise RSMP::MessageRejected.new "Aggregated status request #{m_id_short} was rejected with '#{message.attribute('rea')}'"
           end
         elsif message.is_a?(MessageAck)
-          next true if message.attribute('oMId') == m_id
+          collector.complete if message.attribute('oMId') == m_id
         end
-        false
+      end
+    end
+
+    def send_and_optionally_collect message, options, &block
+      if options[:collect]
+        task = @task.async { |task| yield task }
+        send_message message, validate: options[:validate]
+        { sent: message, collector: task.wait }
+      else
+        send_message message, validate: options[:validate]
+        return { sent: message }
       end
     end
   end

data/lib/rsmp/site.rb

@@ -9,9 +9,9 @@ module RSMP
     attr_reader :rsmp_versions, :site_settings, :logger, :proxies
 
     def initialize options={}
+      super options
       initialize_components
       handle_site_settings options
-      super options
       @proxies = []
       @sleep_condition = Async::Notification.new
       @proxies_condition = Async::Notification.new
@@ -95,7 +95,8 @@ module RSMP
         ip: supervisor_settings['ip'],
         port: supervisor_settings['port'],
         logger: @logger,
-        archive: @archive
+        archive: @archive,
+        collect: @collect
       })
       @proxies << proxy
       @proxies_condition.signal

data/lib/rsmp/site_proxy.rb

@@ -101,8 +101,13 @@ module RSMP
           "cId" => component,
           "mId" => m_id
       })
-      send_and_collect_if_needed message, options do |task|
-        collect_aggregated_status task, options[:collect].merge(m_id: m_id, num:1)
+      send_and_optionally_collect message, options do |task|
+        collector = AggregatedStatusCollector.new(
+          self,
+          options[:collect].merge(task:@task,m_id: m_id, num:1)
+        )
+        collector.collect
+        collector
       end
     end
 
@@ -174,8 +179,14 @@ module RSMP
           "sS" => request_list,
           "mId" => m_id
       })
-      send_and_collect_if_needed message, options do |task|
-        collect_status_responses task, status_list, options[:collect].merge(m_id: m_id)
+      send_and_optionally_collect message, options do |task|
+        collector = StatusCollector.new(
+          self,
+          status_list,
+          options[:collect].merge(task:@task,m_id: m_id)
+          )
+        collector.collect
+        collector
       end
     end
 
@@ -186,17 +197,6 @@ module RSMP
       acknowledge message
     end
 
-    def send_and_collect_if_needed message, options, &block
-      if options[:collect]
-        task = @task.async { |task| yield task }
-        send_message message, validate: options[:validate]
-        { sent: message, collector: task.wait }
-      else
-        send_message message, validate: options[:validate]
-        return { sent: message }
-      end
-    end
-
     def subscribe_to_status component_id, status_list, options={}
       validate_ready 'subscribe to status'
       m_id = options[:m_id] || RSMP::Message.make_m_id
@@ -215,8 +215,14 @@ module RSMP
           "sS" => subscribe_list,
           'mId' => m_id
       })
-      send_and_collect_if_needed message, options do |task|
-         collect_status_updates task, status_list, options[:collect].merge(m_id: m_id)
+      send_and_optionally_collect message, options do |task|
+        collector = StatusCollector.new(
+          self,
+          status_list,
+          options[:collect].merge(task:@task,m_id: m_id)
+        )
+        collector.collect
+        collector
       end
     end
 
@@ -261,8 +267,14 @@ module RSMP
           "arg" => command_list,
           "mId" => m_id
       })
-      send_and_collect_if_needed message, options do |task|
-        collect_command_responses task, command_list, options[:collect].merge(m_id: m_id)
+      send_and_optionally_collect message, options do |task|
+        collector = CommandResponseCollector.new(
+          self,
+          command_list,
+          options[:collect].merge(task:@task,m_id: m_id)
+          )
+        collector.collect
+        collector
       end
     end
 
@@ -339,37 +351,13 @@ module RSMP
       distribute_error e, options
     end
 
-    def collect_alarms parent_task, options={}
-      collect(parent_task,options.merge(type: "Alarm")) do |alarm|
+    def collect_alarms options={}
+      collect(@task,options.merge(type: "Alarm")) do |alarm|
         next if options[:aCId] && options[:aCId] != alarm.attribute("aCId")
         next if options[:aSp] && options[:aSp] != alarm.attribute("aSp")
         next if options[:aS] && options[:aS] != alarm.attribute("aS")
-        true
+        :keep
       end
     end
-
-    def collect_status_updates task, status_list, options
-      collector = StatusUpdateMatcher.new(self, status_list, options)
-      collector.collect task
-      collector
-    end
-
-    def collect_status_responses task, status_list, options
-      collector = StatusResponseMatcher.new(self, status_list, options)
-      collector.collect task
-      collector
-    end
-
-    def collect_command_responses task, command_list, options
-      collector = CommandResponseMatcher.new(self, command_list, options)
-      collector.collect task
-      collector
-    end
-
-    def collect_aggregated_status task, options
-      collector = AggregatedStatusMatcher.new(self, options)
-      collector.collect task
-      collector
-    end
   end
 end

data/lib/rsmp/supervisor_proxy.rb

@@ -138,16 +138,8 @@ module RSMP
         "mId" => m_id,
       })
 
-      if options[:collect]
-        result = nil
-        task = @task.async do |task|
-          wait_for_acknowledgement task, options[:collect], m_id
-        end
-        send_message message, validate: options[:validate]
-        return message, task.wait
-      else
-        send_message message, validate: options[:validate]
-        message
+      send_and_optionally_collect message, options do |task|
+        wait_for_acknowledgement task, options[:collect], m_id
       end
     end
 
@@ -282,7 +274,7 @@ module RSMP
     end
 
     def fetch_last_sent_status component, code, name
-      @last_status_sent.dig component, code, name
+      @last_status_sent.dig component, code, name if @last_status_sent
     end
 
     def store_last_sent_status message

data/lib/rsmp/tlc/signal_group.rb

@@ -6,25 +6,33 @@ module RSMP
       # plan is a string, with each character representing a signal phase at a particular second in the cycle
       def initialize node:, id:
         super node: node, id: id, grouped: false
-        move 0
       end
 
-      def get_state pos
+      def timer
+        @state = get_state
+      end
+
+      def get_state
+        return 'a' if node.main.dark_mode
+        return 'c' if node.main.yellow_flash
+
+        cycle_counter = node.main.cycle_counter
+
+        if node.main.startup_sequence_active
+          @state = node.main.startup_state || 'a'
+        end
+
         default = 'a'   # phase a means disabled/dark
         plan = node.main.current_plan
         return default unless plan
         return default unless plan.states
         states = plan.states[c_id]
         return default unless states
-        state =states[pos]
+        state = states[cycle_counter]
         return default unless state =~ /[a-hA-G0-9N-P]/  # valid signal group states
         state
       end
 
-      def move pos
-        @state = get_state pos
-      end
-
       def handle_command command_code, arg
         case command_code
         when 'M0010', 'M0011'

data/lib/rsmp/tlc/traffic_controller.rb

@@ -5,9 +5,12 @@ module RSMP
     # and keeps track of signal plans, detector logics, inputs, etc. which do
     # not have dedicated components.
     class TrafficController < Component
-      attr_reader :pos, :cycle_time, :plan
+      attr_reader :pos, :cycle_time, :plan, :cycle_counter,
+        :yellow_flash, :dark_mode,
+        :startup_sequence_active, :startup_sequence, :startup_sequence_pos
 
-      def initialize node:, id:, cycle_time: 10, signal_plans:
+      def initialize node:, id:, cycle_time: 10, signal_plans:,
+          startup_sequence:, live_output:nil
         super node: node, id: id, grouped: true
         @signal_groups = []
         @detector_logics = []
@@ -15,13 +18,15 @@ module RSMP
         @cycle_time = cycle_time
         @num_traffic_situations = 1
         @num_inputs = 8
+        @startup_sequence = startup_sequence
+        @live_output = live_output
         reset
       end
 
       def reset
-        @pos = 0
-        @plan = 0
-        @dark_mode = false
+        @cycle_counter = 0
+        @plan = 1
+        @dark_mode = true
         @yellow_flash = false
         @booting = false
         @control_mode = 'control'
@@ -40,6 +45,12 @@ module RSMP
         @inputs = '0'*@num_inputs
         @input_activations = '0'*@num_inputs
         @input_results = '0'*@num_inputs
+
+        @day_time_table = {}
+        @startup_sequence_active = false
+        @startup_sequence_initiated_at = nil
+        @startup_sequence_pos = 0
+        @time_int = nil
       end
 
       def clock
@@ -64,46 +75,83 @@ module RSMP
       end
 
       def timer now
-        # TODO
-        # We should use a monotone timer, to avoid jumps
-        # in case the user sets the system time
-        pos = Time.now.to_i % @cycle_time
-        if pos != @pos
-          @pos = pos
-          move pos
-        end
+        # TODO use monotone timer, to avoid jumps in case the user sets the system time
+        @signal_groups.each { |group| group.timer }
+        time = Time.now.to_i
+        return if time == @time_int
+        @time_int = time
+        move_cycle_counter
+        move_startup_sequence if @startup_sequence_active
+        output_states
+      end
+
+      def move_cycle_counter
+        counter = Time.now.to_i % @cycle_time
+        @cycle_counter = counter
+      end
+
+      def startup_state
+        return unless @startup_sequence_active
+        return unless @startup_sequence_pos
+        @startup_sequence[ @startup_sequence_pos ]
       end
 
-      def move pos
-        @signal_groups.each do |group|
-          group.move pos
+      def initiate_startup_sequence
+        log "Initiating startup sequence", level: :info
+        @startup_sequence_active = true
+        @startup_sequence_initiated_at = nil
+        @startup_sequence_pos = nil
+      end
+
+      def end_startup_sequence
+        @startup_sequence_active = false
+        @startup_sequence_initiated_at = nil
+        @startup_sequence_pos = nil
+
+        @yellow_flash = false
+        @dark_mode = false
+      end
+
+      def move_startup_sequence
+        was = @startup_sequence_pos
+        if @startup_sequence_initiated_at == nil
+          @startup_sequence_initiated_at = Time.now.to_i + 1
+          @startup_sequence_pos = 0
+        else
+          @startup_sequence_pos = Time.now.to_i - @startup_sequence_initiated_at
+        end
+        if @startup_sequence_pos >= @startup_sequence.size
+          end_startup_sequence
         end
-        #output_states
       end
 
       def output_states
+        return unless @live_output
         str = @signal_groups.map do |group|
           s = "#{group.c_id}:#{group.state}"
           if group.state =~ /^[1-9]$/
               s.colorize(:green)
           elsif group.state =~ /^[NOP]$/
             s.colorize(:yellow)
-          elsif group.state =~ /^[a]$/
-            s.colorize(color: :black)
+          elsif group.state =~ /^[ae]$/
+            s.colorize(:black)
+          elsif group.state =~ /^[f]$/
+            s.colorize(:yellow)
+          elsif group.state =~ /^[g]$/
+            s.colorize(:red)
           else
             s.colorize(:red)
           end
         end.join ' '
         plan = "P#{@plan}"
-        print "#{plan.rjust(4)} #{pos.to_s.rjust(4)} #{str}\r"
+
+        File.open @live_output, 'w' do |file|
+          file.puts "#{plan.rjust(4)} #{pos.to_s.rjust(4)} #{str}\r"
+        end
       end
 
       def format_signal_group_status
-        if @yellow_flash
-          'c' * @signal_groups.size
-        else
-          @signal_groups.map { |group| group.state }.join
-        end
+        @signal_groups.map { |group| group.state }.join
       end
 
       def handle_command command_code, arg
@@ -214,6 +262,18 @@ module RSMP
 
       def handle_m0017 arg
         @node.verify_security_code 2, arg['securityCode']
+        arg['status'].split(',').each do |item|
+          elems = item.split('-')
+          nr = elems[0].to_i
+          plan = elems[1].to_i
+          hour = elems[2].to_i
+          min = elems[3].to_i
+          if nr<0 || nr>12
+            raise InvalidMessage.new "time table id must be between 0 and 12, got #{nr}"
+          end
+          #p "nr: #{nr}, plan #{plan} at #{hour}:#{min}"
+          @day_time_table[nr] = {plan: plan, hour: hour, min:min}
+        end
       end
 
       def handle_m0018 arg
@@ -276,6 +336,7 @@ module RSMP
         log "Switching to mode #{mode}", level: :info
         case mode
         when 'NormalControl'
+          initiate_startup_sequence if @yellow_flash || @dark_mode
           @yellow_flash = false
           @dark_mode = false
         when 'YellowFlash'
@@ -308,9 +369,9 @@ module RSMP
         when 'signalgroupstatus'
           TrafficControllerSite.make_status format_signal_group_status
         when 'cyclecounter'
-          TrafficControllerSite.make_status @pos.to_s
+          TrafficControllerSite.make_status @cycle_counter.to_s
         when 'basecyclecounter'
-          TrafficControllerSite.make_status @pos.to_s
+          TrafficControllerSite.make_status @cycle_counter.to_s
         when 'stage'
           TrafficControllerSite.make_status 0.to_s
         end
@@ -511,7 +572,10 @@ module RSMP
       def handle_s0027 status_code, status_name=nil
         case status_name
         when 'status'
-          TrafficControllerSite.make_status '00-00-00-00'
+          status = @day_time_table.map do |i,item|
+            "#{i}-#{item[:plan]}-#{item[:hour]}-#{item[:min]}"
+          end.join(',')
+          TrafficControllerSite.make_status status
         end
       end
 

data/lib/rsmp/tlc/traffic_controller_site.rb

@@ -5,11 +5,16 @@ module RSMP
       attr_accessor :main, :signal_plans
 
       def initialize options={}
+        # setup options before calling super initializer,
+        # since build of components depend on options
         @sxl = 'traffic_light_controller'
         @security_codes = options[:site_settings]['security_codes']
         @interval = options[:site_settings].dig('intervals','timer') || 1
+        @startup_sequence = options[:site_settings]['startup_sequence'] || 'efg'
         build_plans options[:site_settings].dig('signal_plans')
+
         super options
+
         unless @main
           raise ConfigurationError.new "TLC must have a main component"
         end
@@ -37,7 +42,9 @@ module RSMP
         when 'main'
           @main = TrafficController.new node: self, id: id,
             cycle_time: settings['cycle_time'],
-            signal_plans: @signal_plans
+            startup_sequence: @startup_sequence,
+            signal_plans: @signal_plans,
+            live_output: @site_settings['live_output']
         when 'signal_group'
           group = SignalGroup.new node: self, id: id
           @main.add_signal_group group
@@ -52,6 +59,7 @@ module RSMP
       def start_action
         super
         start_timer
+        @main.initiate_startup_sequence
       end
 
       def start_timer
@@ -134,6 +142,7 @@ module RSMP
         when :restart
           log "Restarting TLC", level: :info
           restart
+          initiate_startup_sequence
         end
       end
     end

data/lib/rsmp/version.rb

@@ -1,3 +1,3 @@
 module RSMP
-  VERSION = "0.8.0"
+  VERSION = "0.8.4"
 end