rsmp 0.1.10 → 0.1.19

data/lib/rsmp/error.rb

@@ -23,7 +23,7 @@ module RSMP
 	class MissingWatchdog < Error
 	end
 
-	class MissingAcknowledgment < Error
+	class MessageRejected < Error
 	end
 
 	class MissingAttribute < InvalidMessage
@@ -43,4 +43,13 @@ module RSMP
 
 	class UnknownComponent < Error
 	end
+
+	class UnknownCommand < Error
+	end
+
+	class UnknownStatus < Error
+	end
+
+	class ConfigurationError < Error
+	end
 end

data/lib/rsmp/message.rb

@@ -27,6 +27,9 @@ module RSMP
 
     @@schemas = load_schemas
 
+    def self.make_m_id
+      SecureRandom.uuid()
+    end
 
     def self.parse_attributes json
       raise ArgumentError unless json
@@ -80,8 +83,12 @@ module RSMP
       @attributes["mId"]
     end
 
+    def self.shorten_m_id m_id, length=4
+      m_id[0..length-1]
+    end
+
     def m_id_short
-      @attributes["mId"][0..3]
+      Message.shorten_m_id @attributes["mId"]
     end
 
     def attribute key
@@ -126,7 +133,7 @@ module RSMP
 
     def ensure_message_id
       # if message id is empty, generate a new one
-      @attributes["mId"] ||= SecureRandom.uuid()
+      @attributes["mId"] ||= Message.make_m_id
     end
 
     def validate sxl=nil
@@ -197,6 +204,22 @@ module RSMP
     end
   end
 
+  class AlarmRequest < Message
+    def initialize attributes = {}
+      super({
+        "type" => "Alarm",
+      }.merge attributes)
+    end
+  end
+
+  class AlarmAcknowledged < Message
+    def initialize attributes = {}
+      super({
+        "type" => "Alarm",
+      }.merge attributes)
+    end
+  end
+
   class Watchdog < Message
     def initialize attributes = {}
       super({

data/lib/rsmp/node.rb

@@ -5,19 +5,46 @@
 
 module RSMP
   class Node < Base
-    attr_reader :archive, :logger, :task
+    include Wait
+
+    attr_reader :archive, :logger, :task, :deferred
 
     def initialize options
       super options
+      @task = options[:task]
+      @deferred = []
+    end
+
+    def defer item
+      @deferred << item
+    end
+
+    def process_deferred
+      cloned = @deferred.clone    # clone in case do_deferred restarts the current task
+      @deferred.clear
+      cloned.each do |item|
+        do_deferred item
+      end
+    end
+
+    def do_deferred item
+    end
+
+    def do_start task
+      task.annotate self.class.to_s
+      @task = task
+      start_action
+      idle
     end
 
     def start
       starting
-      Async do |task|
-        task.annotate self.class
-        @task = task
-        start_action
-        idle
+      if @task
+        do_start @task
+      else
+        Async do |task|
+          do_start task
+        end
       end
     rescue Errno::EADDRINUSE => e
       log "Cannot start: #{e.to_s}", level: :error

data/lib/rsmp/probe.rb

@@ -6,22 +6,6 @@ module RSMP
   class Probe
     attr_reader :condition, :items, :done
 
-    # block should send a message and return message just sent
-    def self.collect_response proxy, options={}, &block
-      from = proxy.archive.current_index
-      sent = yield
-      raise RuntimeError unless sent && sent[:message].is_a?(RSMP::Message)
-      item = proxy.archive.capture(options.merge(from: from+1, num: 1, with_message: true)) do |item|
-        ["CommandResponse","StatusResponse","MessageNotAck"].include?(item[:message].type)
-      end
-      if item
-        item[:message] 
-      else
-        nil
-      end
-    end
-
-
     def initialize archive
       raise ArgumentError.new("Archive expected") unless archive.is_a? Archive
       @archive = archive
@@ -30,6 +14,7 @@ module RSMP
     end
 
     def capture task, options={}, &block
+      raise ArgumentError.new("timeout option is missing") unless options[:timeout]
       @options = options
       @block = block
       @num = options[:num]
@@ -37,8 +22,6 @@ module RSMP
       if options[:earliest]
         from = find_timestamp_index options[:earliest]
         backscan from
-      elsif options[:from]
-        backscan options[:from]
       end
 
       # if backscan didn't find enough items, then
@@ -62,6 +45,7 @@ module RSMP
     end
 
     def find_timestamp_index earliest
+      return 0 if earliest == :start
       (0..@archive.items.size).bsearch do |i|        # use binary search to find item index
         @archive.items[i][:timestamp] >= earliest
       end
@@ -105,6 +89,9 @@ module RSMP
       end
       return if @options[:level] && item[:level] != @options[:level]
       return false if @options[:with_message] && !(item[:direction] && item[:message])
+      if @options[:component]
+        return false if item[:message].attributes['cId'] && item[:message].attributes['cId'] != @options[:component]
+      end
       if @block
         return false if @block.call(item) == false
       end

data/lib/rsmp/proxy.rb

@@ -2,7 +2,9 @@
 
 module RSMP  
   class Proxy < Base
-    attr_reader :state, :archive, :connection_info, :sxl
+    include Wait
+
+    attr_reader :state, :archive, :connection_info, :sxl, :task
 
     def initialize options
       super options
@@ -18,7 +20,7 @@ module RSMP
     def run
       start
       @reader.wait if @reader
-      stop
+      stop unless [:stopped, :stopping].include? @state
     end
 
     def ready?
@@ -115,26 +117,42 @@ module RSMP
       interval = @settings["timer_interval"] || 1
       log "Starting #{name} with interval #{interval} seconds", level: :debug
       @latest_watchdog_received = RSMP.now_object
+
       @timer = @task.async do |task|
         task.annotate "timer"
+        next_time = Time.now.to_f
         loop do
-          now = RSMP.now_object
-          break if timer(now) == false
-        rescue StandardError => e
-          log ["#{name} exception: #{e}",e.backtrace].flatten.join("\n"), level: :error
+          begin
+            now = RSMP.now_object
+            timer(now)
+          rescue EOFError => e
+            log "Timer: Connection closed: #{e}", level: :warning
+          rescue IOError => e
+            log "Timer: IOError", level: :warning
+          rescue Errno::ECONNRESET
+            log "Timer: Connection reset by peer", level: :warning
+          rescue Errno::EPIPE => e
+            log "Timer: Broken pipe", level: :warning
+          rescue StandardError => e
+            log "Error: #{e}", level: :debug
+          #rescue StandardError => e
+          #  log ["Timer error: #{e}",e.backtrace].flatten.join("\n"), level: :error
+          end
         ensure
-          task.sleep interval
+          next_time += interval
+          duration = next_time - Time.now.to_f
+          task.sleep duration
         end
       end
     end
 
     def timer now
-      check_watchdog_send_time now
-      return false if check_ack_timeout now
-      return false if check_watchdog_timeout now
+      watchdog_send_timer now
+      check_ack_timeout now
+      check_watchdog_timeout now
     end
 
-    def check_watchdog_send_time now
+    def watchdog_send_timer now
       return unless @watchdog_started  
       return if @settings["watchdog_interval"] == :never
       
@@ -148,8 +166,6 @@ module RSMP
           send_watchdog now
         end
       end
-    rescue StandardError => e
-      log ["Watchdog error: #{e}",e.backtrace].flatten.join("\n"), level: :error
     end
 
     def send_watchdog now=nil
@@ -167,24 +183,18 @@ module RSMP
         if now > latest
           log "No acknowledgements for #{message.type} #{message.m_id_short} within #{timeout} seconds", level: :error
           stop
-          return true
         end
       end
-      false
     end
 
     def check_watchdog_timeout now
-
       timeout = @settings["watchdog_timeout"]
       latest = @latest_watchdog_received + timeout
       left = latest - now
-      log "Check watchdog, time:#{timeout}, last:#{@latest_watchdog_received}, now: #{now}, latest:#{latest}, left #{left}, fail:#{left<0}", level: :debug
       if left < 0
-        log "No Watchdog within #{timeout} seconds, received at #{@latest_watchdog_received}, now is #{now}, diff #{now-latest}", level: :error
+        log "No Watchdog within #{timeout} seconds", level: :error
         stop
-        return true
       end
-      false
     end
 
     def stop_tasks
@@ -212,7 +222,7 @@ module RSMP
 
     def buffer_message message
       # TODO
-      log "Cannot send #{message.type} because the connection is closed.", message: message, level: :error
+      #log "Cannot send #{message.type} because the connection is closed.", message: message, level: :error
     end
 
     def log_send message, reason=nil
@@ -235,12 +245,13 @@ module RSMP
       message.validate sxl
       expect_version_message(message) unless @version_determined
       process_message message
+      process_deferred
       message
     rescue InvalidPacket => e
-      warning "Received invalid package, must be valid JSON but got #{json.size} bytes: #{e.message}"
+      log "Received invalid package, must be valid JSON but got #{json.size} bytes: #{e.message}", level: :warning
       nil
     rescue MalformedMessage => e
-      warning "Received malformed message, #{e.message}", Malformed.new(attributes)
+      log "Received malformed message, #{e.message}", message: Malformed.new(attributes), level: :warning
       # cannot send NotAcknowledged for a malformed message since we can't read it, just ignore it
       nil
     rescue SchemaError => e
@@ -331,7 +342,7 @@ module RSMP
     def wait_for_state state, timeout
       states = [state].flatten
       return if states.include?(@state)
-      RSMP::Wait.wait_for(@task,@state_condition,timeout) do |s|
+      wait_for(@state_condition,timeout) do |s|
         states.include?(@state)
       end
       @state
@@ -441,27 +452,16 @@ module RSMP
     def version_acknowledged
     end
 
-    def wait_for_acknowledgement original, timeout, options={}
+    def wait_for_acknowledgement original, timeout
       raise ArgumentError unless original
-      RSMP::Wait.wait_for(@task,@acknowledgement_condition,timeout) do |message|
-        message.is_a?(MessageAck) &&
-        message.attributes["oMId"] == original.m_id
-      end
-    end
-
-    def wait_for_not_acknowledged original, timeout
-      raise ArgumentError unless original
-      RSMP::Wait.wait_for(@task,@acknowledgement_condition,timeout) do |message|
-        message.is_a?(MessageNotAck) &&
-        message.attributes["oMId"] == original.m_id
-      end
-    end
-
-    def wait_for_acknowledgements timeout
-      return if @awaiting_acknowledgement.empty?
-      RSMP::Wait.wait_for(@task,@acknowledgement_condition,timeout) do |message|
-        @awaiting_acknowledgement.empty?
+      wait_for(@acknowledgement_condition,timeout) do |message|
+        if message.is_a?(MessageNotAck) && message.attributes["oMId"] == original.m_id
+          raise RSMP::MessageRejected.new(message.attributes['rea'])
+        end
+        message.is_a?(MessageAck) && message.attributes["oMId"] == original.m_id
       end
+    rescue Async::TimeoutError
+      raise RSMP::TimeoutError.new("Acknowledgement for #{original.type} #{original.m_id} not received within #{timeout}s")
     end
 
     def node

data/lib/rsmp/site.rb

@@ -27,6 +27,7 @@ module RSMP
           { 'ip' => '127.0.0.1', 'port' => 12111 }
         ],
         'rsmp_versions' => ['3.1.1','3.1.2','3.1.3','3.1.4'],
+        'sxl' => 'traffic_light_controller',
         'sxl_version' => '1.0.7',
         'timer_interval' => 0.1,
         'watchdog_interval' => 1,
@@ -69,7 +70,7 @@ module RSMP
       end
     end
 
-    def build_connector settings
+    def build_proxy settings
       SupervisorProxy.new settings
     end
 
@@ -80,7 +81,7 @@ module RSMP
     end
 
     def connect_to_supervisor task, supervisor_settings
-      proxy = build_connector({
+      proxy = build_proxy({
         site: self,
         task: @task,
         settings: @site_settings, 
@@ -109,7 +110,9 @@ module RSMP
           if @site_settings["reconnect_interval"] != :no
             # sleep until waken by reconnect() or the reconnect interval passed
             proxy.set_state :wait_for_reconnect
-            task.with_timeout(@site_settings["reconnect_interval"]) { @sleep_condition.wait }
+            task.with_timeout(@site_settings["reconnect_interval"]) do
+              @sleep_condition.wait
+            end
           else
             proxy.set_state :cannot_connect
             break
@@ -140,5 +143,6 @@ module RSMP
         proxy.stop
       end
     end
+
   end
 end

data/lib/rsmp/site_base.rb

@@ -13,8 +13,10 @@ module RSMP
 
     def setup_components settings
       return unless settings
-      settings.each_pair do |id,settings|
-        @components[id] = build_component(id,settings)
+      settings.each_pair do |type,components_by_type|
+        components_by_type.each_pair do |id,settings|
+          @components[id] = build_component(id:id, type:type, settings:settings)
+        end
       end
     end
 
@@ -22,8 +24,8 @@ module RSMP
       @components[component.c_id] = component
     end
 
-    def build_component id, settings={}
-      Component.new id: id, node: self, grouped: true
+    def build_component id:, type:, settings:{}
+      Component.new id:id, node: self, grouped: true
     end
 
     def find_component component_id

data/lib/rsmp/site_proxy.rb

@@ -23,6 +23,11 @@ module RSMP
       start_reader
     end
 
+    def stop
+      log "Closing connection to site", level: :info
+      super
+    end
+
     def connection_complete
       super
       log "Connection to site #{@site_id} established", level: :info
@@ -50,11 +55,15 @@ module RSMP
       end
     end
 
+    def process_deferred
+      supervisor.process_deferred
+    end
+
     def version_accepted message
       log "Received Version message for site #{@site_id} using RSMP #{@rsmp_version}", message: message, level: :log
       start_timer
       acknowledge message
-      send_version @site_id, @rsmp_version
+      send_version @site_id, @settings['rsmp_versions']
       @version_determined = true
 
       if @settings['sites']
@@ -81,7 +90,7 @@ module RSMP
       component = @components[c_id]
       if component == nil
         if @site_settings == nil || @site_settings['components'] == nil
-          component = build_component c_id
+          component = build_component(id:c_id, type:nil)
           @components[c_id] = component
           log "Adding component #{c_id} to site #{@site_id}", level: :info
         else
@@ -123,16 +132,38 @@ module RSMP
       @supervisor.site_ids_changed
     end
 
-    def request_status component, status_list, timeout=nil
-      raise NotReady unless @state == :ready
+    def fetch_status parent_task, options
+      wait_for_status_responses(parent_task,options) do |m_id|
+        request_status options.merge(m_id: m_id)
+      end
+    end
+
+    # Convert from a short ruby hash:
+    # {:S0001=>[:signalgroupstatus, :cyclecounter, :basecyclecounter, :stage]}
+    # to an rsmp-style list:
+    # [{"sCI"=>"S0001", "n"=>"signalgroupstatus"}, {"sCI"=>"S0001", "n"=>"cyclecounter"}, {"sCI"=>"S0001", "n"=>"basecyclecounter"}, {"sCI"=>"S0001", "n"=>"stage"}]
+    #
+    # If the input is already an array, just return it
+    def convert_status_list list
+      return list.clone if list.is_a? Array
+      list.map do |status_code_id,names|
+        names.map do |name|
+          { 'sCI' => status_code_id.to_s, 'n' => name.to_s }
+        end
+      end.flatten
+    end
+
+    def request_status options
+      raise NotReady unless ready?
       message = RSMP::StatusRequest.new({
           "ntsOId" => '',
           "xNId" => '',
-          "cId" => component,
-          "sS" => status_list
+          "cId" => options[:component],
+          "sS" => convert_status_list(options[:status_list]),
+          "mId" => options[:m_id]
       })
       send_message message
-      return message, wait_for_status_response(message: message, timeout: timeout)
+      message
     end
 
     def process_status_response message
@@ -140,41 +171,26 @@ module RSMP
       acknowledge message
     end
 
-    def wait_for_status_response options
-      raise ArgumentError unless options[:message]
-      item = @archive.capture(@task, options.merge(
-        type: ['StatusResponse','MessageNotAck'],
-        with_message: true,
-        num: 1
-      )) do |item|
-        if item[:message].type == 'MessageNotAck'
-          next item[:message].attribute('oMId') == options[:message].m_id
-        elsif item[:message].type == 'StatusResponse'
-          next item[:message].attribute('cId') == options[:message].attribute('cId')
-        end
-      end
-      item[:message] if item
-    end
-
-    def subscribe_to_status component, status_list, timeout
-      raise NotReady unless @state == :ready
+    def subscribe_to_status component, status_list, options={}
+      raise NotReady unless ready?
       message = RSMP::StatusSubscribe.new({
           "ntsOId" => '',
           "xNId" => '',
           "cId" => component,
-          "sS" => status_list
+          "sS" => convert_status_list(status_list),
+          'mId'=>options[:m_id]
       })
       send_message message
-      return message, wait_for_status_update(component: component, timeout: timeout)
+      return message
     end
 
     def unsubscribe_to_status component, status_list
-      raise NotReady unless @state == :ready
+      raise NotReady unless ready?
       message = RSMP::StatusUnsubscribe.new({
           "ntsOId" => '',
           "xNId" => '',
           "cId" => component,
-          "sS" => status_list
+          "sS" => convert_status_list(status_list)
       })
       send_message message
       message
@@ -185,50 +201,79 @@ module RSMP
       acknowledge message
     end
 
-    def wait_for_status_update options={}
-      raise ArgumentError unless options[:component]
-      item = @archive.capture(@task,options.merge(type: "StatusUpdate", with_message: true, num: 1)) do |item|
+    def status_match? query, item
+      return false if query[:sCI] && query[:sCI] != item['sCI']
+      return false if query[:n] && query[:n] != item['n']
+      return false if query[:q] && query[:q] != item['q']
+      if query[:s].is_a? Regexp
+        return false if query[:s] && item['s'] !~ query[:s]
+      else
+        return false if query[:s] && item['s'] != query[:s]
+      end
+      true
+    end
+
+    def wait_for_alarm options={}
+      raise ArgumentError.new("component argument is missing") unless options[:component]
+      matching_alarm = nil
+      item = @archive.capture(@task,options.merge(type: "Alarm", with_message: true, num: 1)) do |item|
         # TODO check components
-        found = false
-        sS = item[:message].attributes['sS']
-        sS.each do |status|
-          break if options[:sCI] && options[:sCI] != status['sCI']
-          break if options[:n] && options[:n] != status['n']
-          break if options[:q] && options[:q] != status['q']
-          break if options[:s] && options[:s] != status['s']
-          found = true
-          break
-        end
-        found
+        matching_alarm = nil
+        alarm = item[:message]
+        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")
+        matching_alarm = alarm
+        break
+      end
+      if item
+        { message: item[:message], status: matching_alarm }
       end
-      item[:message] if item
     end
 
-    def send_command component, args
-      raise NotReady unless @state == :ready
-      message = RSMP::CommandRequest.new({
+    def send_alarm_acknowledgement component, alarm_code
+      message = RSMP::AlarmAcknowledged.new({
           "ntsOId" => '',
           "xNId" => '',
           "cId" => component,
-          "arg" => args
+          "aCId" => alarm_code,
+          "xACId" => '',
+          "xNACId" => '',
+          "aSp" => 'Acknowledge'
       })
       send_message message
       message
     end
 
-    def process_command_response message
-      log "Received #{message.type}", message: message, level: :log
-      acknowledge message
-    end
-
-    def wait_for_command_response options
-      raise ArgumentError unless options[:component]
-      item = @archive.capture(@task,options.merge(num: 1, type: "CommandResponse", with_message: true)) do |item|
-         # check component
+    def wait_for_alarm_acknowledgement_response options
+      raise ArgumentError.new("component argument is missing") unless options[:component]
+      item = @archive.capture(@task,options.merge(
+        num: 1,
+        type: ['AlarmAcknowledgedResponse','MessageNotAck'],
+        with_message: true
+      )) do |item|
+        if item[:message].type == 'MessageNotAck'
+          next item[:message].attribute('oMId') == options[:message].m_id
+        elsif item[:message].type == 'AlarmAcknowledgedResponse'
+          next item[:message].attribute('cId') == options[:message].attribute('cId')
+        end
       end
       item[:message] if item
     end
 
+    def send_command component, args, options={}
+      raise NotReady unless ready?
+      message = RSMP::CommandRequest.new({
+          "ntsOId" => '',
+          "xNId" => '',
+          "cId" => component,
+          "arg" => args,
+          "mId" => options[:m_id]
+      })
+      send_message message
+      message
+    end
+
     def set_watchdog_interval interval
       @settings["watchdog_interval"] = interval
     end
@@ -261,6 +306,5 @@ module RSMP
       site_ids_changed
     end
 
-
   end
-end
+end