rsmp 0.1.17 → 0.1.30

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

@@ -17,47 +17,57 @@ module RSMP
       @supervisor_settings['site_id']
     end
 
-    def handle_supervisor_settings options
-      @supervisor_settings = {
+    def handle_supervisor_settings options={}
+      defaults = {
         'port' => 12111,
-        'rsmp_versions' => ['3.1.1','3.1.2','3.1.3','3.1.4'],
-        'timer_interval' => 0.1,
-        'watchdog_interval' => 1,
-        'watchdog_timeout' => 2,
-        'acknowledgement_timeout' => 2,
-        'command_response_timeout' => 1,
-        'status_response_timeout' => 1,
-        'status_update_timeout' => 1,
-        'site_connect_timeout' => 2,
-        'site_ready_timeout' => 1,
-        'stop_after_first_session' => false,
-        'sites' => {
-          :any => {}
+        'ips' => 'all',
+        'guest' => {
+          'rsmp_versions' => 'all',
+          'sxl' => 'tlc',
+          'intervals' => {
+            'timer' => 1,
+            'watchdog' => 1
+          },
+          'timeouts' => {
+            'watchdog' => 2,
+            'acknowledgement' => 2
+          }
         }
       }
-      
-      if options[:supervisor_settings]
-        converted = options[:supervisor_settings].map { |k,v| [k.to_s,v] }.to_h   #convert symbol keys to string keys
-        converted.compact!
-        @supervisor_settings.merge! converted
-      end
-
-      required = [:port, :rsmp_versions, :watchdog_interval, :watchdog_timeout,
-                  :acknowledgement_timeout, :command_response_timeout]
-      check_required_settings @supervisor_settings, required
 
+      # merge options into defaults
+      @supervisor_settings = defaults.deep_merge(options[:supervisor_settings] || {})
       @rsmp_versions = @supervisor_settings["rsmp_versions"]
+      check_site_sxl_types
+    end
+
+    def check_site_sxl_types
+      sites = @supervisor_settings['sites'].clone || {}
+      sites['guest'] = @supervisor_settings['guest']
+      sites.each do |site_id,settings|
+        unless settings
+          raise RSMP::ConfigurationError.new("Configuration for site '#{site_id}' 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 '#{site_id}': No SXL specified")
+        end
+        RSMP::Schemer.find_schemas! sxl if sxl
+      rescue RSMP::Schemer::UnknownSchemaError => e
+        raise RSMP::ConfigurationError.new("Configuration error for site '#{site_id}': #{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 +84,18 @@ 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}:#{remote_port}, #{e.to_s}", level: :warning
+      notify_error e
     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,7 +103,7 @@ 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
@@ -110,29 +122,49 @@ module RSMP
       end
     end
 
+    def authorize_ip ip
+      return if @supervisor_settings['ips'] == 'all'
+      return if @supervisor_settings['ips'].include? ip
+      raise ConnectionError.new('guest ip not allowed')
+    end
+
+    def check_max_sites
+      max = @supervisor_settings['max_sites']
+      if max
+        if @proxies.size >= max
+          raise ConnectionError.new("maximum of #{max} sites already connected")
+        end
+      end
+    end
+
     def connect socket, info
       log "Site connected from #{format_ip_and_port(info)}",
           ip: info[:ip],
           port: info[:port],
           level: :info,
-          timestamp: RSMP.now_object
+          timestamp: Clock.now
+
+      authorize_ip info[:ip]
+      check_max_sites
 
       proxy = build_proxy({
         supervisor: self,
+        ip: info[:ip],
+        port: info[:port],
         task: @task,
-        settings: @supervisor_settings[:sites],
+        settings: {'collect'=>@supervisor_settings['collect']},
         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
 
-      stop if @supervisor_settings['stop_after_first_session']
+      stop if @supervisor_settings['one_shot']
     end
 
     def site_ids_changed
@@ -145,9 +177,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,34 +199,38 @@ 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
       check_site_already_connected site_id
-      return find_allowed_site_setting site_id
+      return site_id_to_site_setting site_id
     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
+    def site_id_to_site_setting site_id
       return {} unless @supervisor_settings['sites']
       @supervisor_settings['sites'].each_pair do |id,settings|
-        if id == :any || id == site_id
+        if id == 'guest' || id == site_id
           return settings
         end
       end
-      raise FatalError.new "site id #{site_id} rejected"
+      raise FatalError.new "site id #{site_id} unknown"
+    end
+
+    def ip_to_site_settings ip
+      @supervisor_settings['sites'][ip] || @supervisor_settings['sites']['guest']
     end
 
     def aggregated_status_changed site_proxy, component

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,27 +27,34 @@ 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
       log "No connection to supervisor at #{@ip}:#{@port}", level: :error
-      unless @site.site_settings["reconnect_interval"] == :no
-        log "Will try to reconnect again every #{@site.site_settings["reconnect_interval"]} seconds..", level: :info
+      unless @site.site_settings['intervals']['reconnect'] == :no
+        log "Will try to reconnect again every #{@site.site_settings['intervals']['reconnect']} seconds..", level: :info
         @logger.mute @ip, @port
       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,14 +80,15 @@ module RSMP
         else
           super message
       end
-    rescue UnknownComponent => e
-      dont_acknowledge message, '', e.to_s
-    rescue UnknownCommand => e
-      dont_acknowledge message, '', e.to_s
-    rescue UnknownStatus => e
+    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
       # TODO
       # aggregateds status should only be send for later version of rsmp
@@ -101,7 +110,7 @@ module RSMP
     end
 
     def reconnect_delay
-      interval = @site_settings["reconnect_interval"]
+      interval = @site_settings['intervals']['watchdog']
       log "Waiting #{interval} seconds before trying to reconnect", level: :info
       @task.sleep interval
     end
@@ -116,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
       })
@@ -154,6 +163,14 @@ module RSMP
       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
       component_id = message.attributes["cId"]
@@ -170,14 +187,14 @@ module RSMP
       end
       response = CommandResponse.new({
         "cId"=>component_id,
-        "cTS"=>RSMP.now_string,
+        "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
@@ -187,8 +204,9 @@ module RSMP
       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
@@ -213,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
 
@@ -250,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
@@ -272,25 +313,27 @@ 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
+      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.map do |status_name|
-            value,quality = component.get_status code, status_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" => status_name,
                      "s" => value.to_s,
@@ -308,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