rsmp 0.1.12 → 0.1.27

data/lib/rsmp/site_proxy_wait.rb

@@ -0,0 +1,206 @@
+# waiting for various types of messages and reponses from remote sites
+module RSMP
+  module SiteProxyWait
+
+    def wait_for_status_updates parent_task, options={}, &send_block
+      send_while_collecting parent_task, send_block do |task, m_id|
+        collect_status_updates_or_responses task, 'StatusUpdate', options, m_id
+      end
+    end
+
+    def wait_for_status_responses parent_task, options={}, &send_block
+      send_while_collecting parent_task, send_block do |task, m_id|
+        collect_status_updates_or_responses task, 'StatusResponse', options, m_id
+      end
+    end
+
+    def wait_for_command_responses parent_task, options={}, &send_block
+      send_while_collecting parent_task, send_block do |task, m_id|
+        collect_command_responses task, options, m_id
+      end
+    end
+
+    def wait_for_alarm parent_task, options={}
+      matching_alarm = nil
+      message = collect(parent_task,options.merge(type: "Alarm", with_message: true, num: 1)) do |message|
+        # TODO check components
+        matching_alarm = nil
+        alarm = 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: message, status: matching_alarm }
+      end
+    end
+
+    def collect_status_updates task, options, m_id
+      collect_status_updates_or_responses task, 'StatusUpdate', options, m_id
+    end
+
+    def collect_status_responses task, options, m_id
+      collect_status_updates_or_responses task, 'StatusResponse', options, m_id
+    end
+
+    def collect_command_responses parent_task, options, m_id
+      task.annotate "wait for command response"
+      want = options[:command_list].clone
+      result = {}
+      messages = []
+      collect(parent_task,options.merge({
+        type: ['CommandResponse','MessageNotAck'],
+        num: 1
+      })) 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 "Command request #{m_id_short} was rejected: #{message.attribute('rea')}"
+            next true   # done, no more messages wanted
+          else
+            false
+          end
+        else
+          add = false
+          # look through querues
+          want.each_with_index do |query,i|
+            # look through items in message
+            message.attributes['rvs'].each do |input|
+              matching = command_match? query, input
+              if matching == true
+                result[query] = input
+                add = true
+              elsif matching == false
+                result.delete query
+              end
+            end
+          end
+          messages << message if add
+          result.size == want.size # any queries left to match?
+        end
+      end
+      return result, messages
+    rescue Async::TimeoutError
+      raise RSMP::TimeoutError.new "Did not receive correct command response to #{m_id} within #{options[:timeout]}s"
+    end
+
+    def collect_status_updates_or_responses task, type, options, m_id
+      want = options[:status_list].clone
+      result = {}
+      messages = []
+      # wait for a status update
+      collect(task,options.merge({
+        type: [type,'MessageNotAck'],
+        num: 1
+      })) 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 "Status request #{m_id_short} was rejected: #{message.attribute('rea')}"
+            next true   # done, no more messages wanted
+          end
+          false
+        else
+          found = []
+          add = false
+          # look through querues
+          want.each_with_index do |query,i|
+            # look through status items in message
+            message.attributes['sS'].each do |input|
+              matching = status_match? query, input
+              if matching == true
+                result[query] = input
+                add = true
+              elsif matching == false
+                result.delete query
+              end
+            end
+          end
+          messages << message if add
+          result.size == want.size # any queries left to match?
+        end
+      end
+      return result, messages
+    rescue Async::TimeoutError
+      type_str = {'StatusUpdate'=>'update', 'StatusResponse'=>'response'}[type]
+      raise RSMP::TimeoutError.new "Did not received correct status #{type_str} in reply to #{m_id} within #{options[:timeout]}s"
+    end
+
+    def status_match? query, item
+      return nil if query['sCI'] && query['sCI'] != item['sCI']
+      return nil 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 command_match? query, item
+      return nil if query['cCI'] && query['cCI'] != item['cCI']
+      return nil if query['n'] && query['n'] != item['n']
+      if query['v'].is_a? Regexp
+        return false if query['v'] && item['v'] !~ query['v']
+      else
+        return false if query['v'] && item['v'] != query['v']
+      end
+      true
+    end
+
+    def send_while_collecting parent_task, send_block, &collect_block
+      m_id = RSMP::Message.make_m_id    # make message id so we can start waiting for it
+
+      # wait for command responses in an async task
+      task = parent_task.async do |task|
+        collect_block.call task, m_id
+      rescue StandardError => e
+        notify_error e, level: :internal
+      end
+
+       # call block, it should send command request using the given m_id
+      send_block.call m_id
+
+      # wait for the response and return it, raise exception if NotAck received, it it timed out
+      task.wait
+    end
+
+    def wait_for_aggregated_status parent_task, options={}
+      collect(parent_task,options.merge({
+        type: ['AggregatedStatus','MessageNotAck'],
+        num: 1
+      })) 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: #{message.attribute('rea')}"
+            next true   # done, no more messages wanted
+          else
+            false
+          end
+        else
+          true
+        end
+      end
+    end
+
+  end
+end

data/lib/rsmp/supervisor.rb

@@ -20,7 +20,7 @@ module RSMP
     def handle_supervisor_settings options
       @supervisor_settings = {
         'port' => 12111,
-        'rsmp_versions' => ['3.1.1','3.1.2','3.1.3','3.1.4'],
+        'rsmp_versions' => ['3.1.1','3.1.2','3.1.3','3.1.4','3.1.5'],
         'timer_interval' => 0.1,
         'watchdog_interval' => 1,
         'watchdog_timeout' => 2,
@@ -32,7 +32,9 @@ module RSMP
         'site_ready_timeout' => 1,
         'stop_after_first_session' => false,
         'sites' => {
-          :any => {}
+          :any => {
+            'sxl' => 'tlc'
+          }
         }
       }
       
@@ -47,17 +49,35 @@ module RSMP
       check_required_settings @supervisor_settings, required
 
       @rsmp_versions = @supervisor_settings["rsmp_versions"]
+
+      check_site_sxl_types
+    end
+
+    def check_site_sxl_types
+      @supervisor_settings['sites'].each do |ip,settings|
+        unless settings
+          raise RSMP::ConfigurationError.new("Configuration for site '#{ip}' is empty")
+        end
+        sxl = settings['sxl']
+        sxl = 'tlc' unless sxl    # temporary fix until configs are updated
+        unless sxl
+          raise RSMP::ConfigurationError.new("Configuration error for site '#{ip}': No SXL specified")
+        end
+        RSMP::Schemer.find_schemas! sxl if sxl
+      rescue RSMP::Schemer::UnknownSchemaError => e
+        raise RSMP::ConfigurationError.new("Configuration error for site '#{ip}': #{e}")
+      end
     end
 
     def start_action
       @endpoint = Async::IO::Endpoint.tcp('0.0.0.0', @supervisor_settings["port"])
-      @endpoint.accept do |socket|
+      @endpoint.accept do |socket|  # creates async tasks
         handle_connection(socket)
+      rescue StandardError => e
+        notify_error e, level: :internal
       end
-    rescue SystemCallError => e # all ERRNO errors
-      log "Exception: #{e.to_s}", level: :error
     rescue StandardError => e
-      log ["Exception: #{e.inspect}",e.backtrace].flatten.join("\n"), level: :error
+      notify_error e, level: :internal
     end
 
     def stop
@@ -74,16 +94,17 @@ module RSMP
       remote_hostname = socket.remote_address.ip_address
       remote_ip = socket.remote_address.ip_address
 
-      info = {ip:remote_ip, port:remote_port, hostname:remote_hostname, now:RSMP.now_string()}
+      info = {ip:remote_ip, port:remote_port, hostname:remote_hostname, now:Clock.now}
       if accept? socket, info
         connect socket, info
       else
         reject socket, info
       end
-    rescue SystemCallError => e # all ERRNO errors
-      log "Exception: #{e.to_s}", level: :error
+    rescue ConnectionError => e
+      log "Rejected connection from #{remote_ip}, #{e.to_s}", level: :info
     rescue StandardError => e
-      log "Exception: #{e}", exception: e, level: :error
+      log "Connection: #{e.to_s}", exception: e, level: :error
+      notify_error e, level: :internal
     ensure
       close socket, info
     end
@@ -91,14 +112,14 @@ module RSMP
     def starting
       log "Starting supervisor on port #{@supervisor_settings["port"]}", 
           level: :info,
-          timestamp: RSMP.now_object
+          timestamp: @clock.now
     end
 
     def accept? socket, info
       true
     end
 
-    def build_connector settings
+    def build_proxy settings
       SiteProxy.new settings
     end
 
@@ -115,20 +136,25 @@ module RSMP
           ip: info[:ip],
           port: info[:port],
           level: :info,
-          timestamp: RSMP.now_object
+          timestamp: Clock.now
 
-      proxy = build_connector({
+      settings = ip_to_site_settings info[:ip]
+      raise ConnectionError.new('unknown ip not allowed') unless settings
+
+      proxy = build_proxy({
         supervisor: self,
+        ip: info[:ip],
+        port: info[:port],
         task: @task,
-        settings: @supervisor_settings[:sites],
+        settings: settings,
         socket: socket,
         info: info,
         logger: @logger,
         archive: @archive
       })
       @proxies.push proxy
-      
       proxy.run     # will run until the site disconnects
+    ensure
       @proxies.delete proxy
       site_ids_changed
 
@@ -145,9 +171,9 @@ module RSMP
 
     def close socket, info
       if info
-        log "Connection to #{format_ip_and_port(info)} closed", ip: info[:ip], level: :info, timestamp: RSMP.now_object
+        log "Connection to #{format_ip_and_port(info)} closed", ip: info[:ip], level: :info, timestamp: Clock.now
       else
-        log "Connection closed", level: :info, timestamp: RSMP.now_object
+        log "Connection closed", level: :info, timestamp: Clock.now
       end
 
       socket.close
@@ -167,15 +193,15 @@ module RSMP
     def wait_for_site site_id, timeout
       site = find_site site_id
       return site if site
-      RSMP::Wait.wait_for(@task,@site_id_condition,timeout) { find_site site_id }
+      wait_for(@site_id_condition,timeout) { find_site site_id }
     rescue Async::TimeoutError
-      nil
+      raise RSMP::TimeoutError.new "Site '#{site_id}'' did not connect within #{timeout}s"
     end
 
     def wait_for_site_disconnect site_id, timeout
-      RSMP::Wait.wait_for(@task,@site_id_condition,timeout) { true unless find_site site_id }
+      wait_for(@site_id_condition,timeout) { true unless find_site site_id }
     rescue Async::TimeoutError
-      false
+      raise RSMP::TimeoutError.new "Site '#{site_id}'' did not disconnect within #{timeout}s"
     end
 
     def check_site_id site_id
@@ -184,7 +210,7 @@ module RSMP
     end
 
     def check_site_already_connected site_id
-      raise FatalError.new "Site #{site_id} already connected" if find_site(site_id)
+      raise FatalError.new "Site '#{site_id}'' already connected" if find_site(site_id)
     end
 
     def find_allowed_site_setting site_id
@@ -197,6 +223,10 @@ module RSMP
       raise FatalError.new "site id #{site_id} rejected"
     end
 
+    def ip_to_site_settings ip
+      @supervisor_settings['sites'][ip] || @supervisor_settings['sites'][:any]
+    end
+
     def aggregated_status_changed site_proxy, component
     end
 

data/lib/rsmp/supervisor_proxy.rb

@@ -14,7 +14,6 @@ module RSMP
       @ip = options[:ip]
       @port = options[:port]
       @status_subscriptions = {}
-      @status_subscriptions_mutex = Mutex.new
       @sxl = @site_settings['sxl']
       @synthetic_id = Supervisor.build_id_from_ip_port @ip, @port
     end
@@ -28,6 +27,7 @@ module RSMP
       super
       connect
       @logger.unmute @ip, @port
+      log "Connected to superviser at #{@ip}:#{@port}", level: :info
       start_reader
       send_version @site_settings['site_id'], @site_settings["rsmp_versions"]
     rescue Errno::ECONNREFUSED
@@ -38,17 +38,23 @@ module RSMP
       end
     end
 
+    def stop
+      log "Closing connection to supervisor", level: :info
+      super
+      @last_status_sent = nil
+    end
+
     def connect
       return if @socket
       @endpoint = Async::IO::Endpoint.tcp(@ip, @port)
       @socket = @endpoint.connect
       @stream = Async::IO::Stream.new(@socket)
-      @protocol = Async::IO::Protocol::Line.new(@stream,RSMP::WRAPPING_DELIMITER) # rsmp messages are json terminated with a form-feed
+      @protocol = Async::IO::Protocol::Line.new(@stream,WRAPPING_DELIMITER) # rsmp messages are json terminated with a form-feed
     end
 
     def connection_complete
       super
-      log "Connection to supervisor established", level: :info
+      log "Connection to supervisor established, using core #{@rsmp_version}, #{sxl} #{sxl_version}", level: :info
       start_watchdog
     end
 
@@ -59,6 +65,8 @@ module RSMP
         when StatusUpdate
         when AggregatedStatus
           will_not_handle message
+        when AggregatedStatusRequest
+          process_aggregated_status_request message
         when CommandRequest
           process_command_request message
         when CommandResponse
@@ -72,6 +80,13 @@ module RSMP
         else
           super message
       end
+    rescue UnknownComponent, UnknownCommand, UnknownStatus,
+           MessageRejected, MissingAttribute => e
+      dont_acknowledge message, '', e.to_s
+    end
+
+    def process_deferred
+      site.process_deferred
     end
 
     def acknowledged_first_ingoing message
@@ -110,9 +125,9 @@ module RSMP
 
     def send_aggregated_status component
       message = AggregatedStatus.new({
-        "aSTS" => RSMP.now_string,
+        "aSTS" => clock.to_s,
         "cId" =>  component.c_id,
-        "fP" => nil,
+        "fP" => 'NormalControl',
         "fS" => nil,
         "se" => component.aggregated_status_bools
       })
@@ -135,48 +150,66 @@ module RSMP
       acknowledge message
     end
 
+    # reorganize rmsp command request arg attribute:
+    # [{"cCI":"M0002","cO":"setPlan","n":"status","v":"True"},{"cCI":"M0002","cO":"setPlan","n":"securityCode","v":"5678"},{"cCI":"M0002","cO":"setPlan","n":"timeplan","v":"3"}]
+    # into the simpler, but equivalent:
+    # {"M0002"=>{"status"=>"True", "securityCode"=>"5678", "timeplan"=>"3"}}
+    def simplify_command_requests arg
+      sorted = {}
+      arg.each do |item|
+        sorted[item['cCI']] ||= {}
+        sorted[item['cCI']][item['n']] = item['v']
+      end
+      sorted
+    end
+
+    def process_aggregated_status_request message
+      log "Received #{message.type}", message: message, level: :log
+      component_id = message.attributes["cId"]
+      component = @site.find_component component_id
+      acknowledge message
+      send_aggregated_status component
+    end
+
     def process_command_request message
       log "Received #{message.type}", message: message, level: :log
-      rvs = []
-      message.attributes["arg"].each do |arg|
-        unless arg['cCI'] && arg['n'] && arg['v']
-          dont_acknowledge message, '', 'bad arguments'
-          return
-        end 
-        rvs << { "cCI" => arg["cCI"],
-                 "n" => arg["n"],
-                 "v" => arg["v"],
-                 "age" => "recent" }
+      component_id = message.attributes["cId"]
+      component = @site.find_component component_id
+      commands = simplify_command_requests message.attributes["arg"]
+      commands.each_pair do |command_code,arg|
+        component.handle_command command_code,arg
       end
 
+      rvs = message.attributes["arg"].map do |item|
+        item = item.dup.merge('age'=>'recent')
+        item.delete 'cO'
+        item
+      end
       response = CommandResponse.new({
-        "cId"=>message.attributes["cId"],
-        "cTS"=>RSMP.now_string,
+        "cId"=>component_id,
+        "cTS"=>clock.to_s,
         "rvs"=>rvs
       })
       acknowledge message
       send_message response
     end
 
-    def process_status_request message
+    def process_status_request message, options={}
       component_id = message.attributes["cId"]
       component = @site.find_component component_id
-
       log "Received #{message.type}", message: message, level: :log
-      sS = message.attributes["sS"].clone.map do |request|
-        request["s"] = rand(100).to_s
-        request["q"] = "recent"
-        request
+      sS = message.attributes["sS"].map do |arg|
+        value, quality =  component.get_status arg['sCI'], arg['n']
+        { "s" => value.to_s, "q" => quality.to_s }.merge arg
       end
       response = StatusResponse.new({
         "cId"=>component_id,
-        "sTs"=>RSMP.now_string,
-        "sS"=>sS
+        "sTs"=>clock.to_s,
+        "sS"=>sS,
+        "mId" => options[:m_id]
       })
       acknowledge message
       send_message response
-    rescue UnknownComponent => e
-      dont_acknowledge message, '', e.to_s
     end
 
     def process_status_subcribe message
@@ -198,10 +231,11 @@ module RSMP
       update_list[component] ||= {} 
 
       subs = @status_subscriptions[component]
+      now = Time.now  # internal timestamp
 
       message.attributes["sS"].each do |arg|
         sCI = arg["sCI"]
-        subcription = {interval: arg["uRt"].to_i, last_sent_at: nil}
+        subcription = {interval: arg["uRt"].to_i, last_sent_at: now}
         subs[sCI] ||= {}
         subs[sCI][arg["n"]] = subcription
 
@@ -235,18 +269,40 @@ module RSMP
       status_update_timer now if ready?
     end
 
+    def fetch_last_sent_status component, code, name
+      if @last_status_sent && @last_status_sent[component] && @last_status_sent[component][code]
+        @last_status_sent[component][code][name]
+      else
+        nil
+      end
+    end
+
+    def store_last_sent_status component, code, name, value
+      @last_status_sent ||= {}
+      @last_status_sent[component] ||= {}
+      @last_status_sent[component][code] ||= {}
+      @last_status_sent[component][code][name] = value
+    end
+
     def status_update_timer now
       update_list = {}
       # go through subscriptons and build a similarly organized list,
       # that only contains what should be send
 
       @status_subscriptions.each_pair do |component,by_code|
+        component_object = @site.find_component component
         by_code.each_pair do |code,by_name|
           by_name.each_pair do |name,subscription|
+            current = nil
             if subscription[:interval] == 0 
               # send as soon as the data changes
-              if rand(100) >= 90
+              if component_object
+                current, age = *(component_object.get_status code, name)
+              end
+              last_sent = fetch_last_sent_status component, code, name
+              if current != last_sent
                 should_send = true
+                store_last_sent_status component, code, name, current
               end
             else
               # send at regular intervals
@@ -257,31 +313,35 @@ module RSMP
             if should_send
               subscription[:last_sent_at] = now
               update_list[component] ||= {}
-              update_list[component][code] ||= []
-              update_list[component][code] << name
+              update_list[component][code] ||= {}
+              update_list[component][code][name] = current
            end
           end
         end
       end
       send_status_updates update_list
-    rescue StandardError => e
-      log ["Status update exception: #{e}",e.backtrace].flatten.join("\n"), level: :error
     end
 
     def send_status_updates update_list
-      now = RSMP.now_string
-      update_list.each_pair do |component,by_code|
+      now = clock.to_s
+      update_list.each_pair do |component_id,by_code|
+        component = @site.find_component component_id
         sS = []
         by_code.each_pair do |code,names|
-          names.each do |name|
+          names.map do |status_name,value|
+            if value
+              quality = 'recent'
+            else
+              value,quality = component.get_status code, status_name
+            end
             sS << { "sCI" => code,
-                     "n" => name,
-                     "s" => rand(100).to_s,
-                     "q" => "recent" }
+                     "n" => status_name,
+                     "s" => value.to_s,
+                     "q" => quality }
           end
         end
         update = StatusUpdate.new({
-          "cId"=>component,
+          "cId"=>component_id,
           "sTs"=>now,
           "sS"=>sS
         })
@@ -291,7 +351,7 @@ module RSMP
 
     def send_alarm
       message = Alarm.new({
-        "aSTS"=>RSMP.now_string,
+        "aSTS"=>clock.to_s,
         "fP"=>nil,
         "fS"=>nil,
         "se"=>@site.aggregated_status_bools