rsmp 0.8.3 → 0.9.0

data/lib/rsmp/site.rb

@@ -9,12 +9,14 @@ 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
+
+      build_proxies
     end
 
     def site_id
@@ -62,25 +64,29 @@ module RSMP
       RSMP::Schemer::find_schema! sxl, version, lenient: true
     end
 
-    def reconnect
-      @sleep_condition.signal
+    def run
+      log "Starting site #{@site_settings["site_id"]}",
+          level: :info,
+          timestamp: @clock.now
+      @proxies.each { |proxy| proxy.start }
+      @proxies.each { |proxy| proxy.wait }
     end
 
-    def start_action
+    def build_proxies
       @site_settings["supervisors"].each do |supervisor_settings|
-        @task.async do |task|
-          task.annotate "site proxy"
-          connect_to_supervisor task, supervisor_settings
-        rescue StandardError => e
-          notify_error e, level: :internal
-        end
+        @proxies << SupervisorProxy.new({
+          site: self,
+          task: @task,
+          settings: @site_settings,
+          ip: supervisor_settings['ip'],
+          port: supervisor_settings['port'],
+          logger: @logger,
+          archive: @archive,
+          collect: @collect
+        })
       end
     end
 
-    def build_proxy settings
-      SupervisorProxy.new settings
-    end
-
     def aggregated_status_changed component, options={}
       @proxies.each do |proxy|
         proxy.send_aggregated_status component, options if proxy.ready?
@@ -91,7 +97,7 @@ module RSMP
       proxy = build_proxy({
         site: self,
         task: @task,
-        settings: @site_settings, 
+        settings: @site_settings,
         ip: supervisor_settings['ip'],
         port: supervisor_settings['port'],
         logger: @logger,
@@ -99,63 +105,20 @@ module RSMP
         collect: @collect
       })
       @proxies << proxy
+      proxy.start
       @proxies_condition.signal
-      run_site_proxy task, proxy
-    ensure
-      @proxies.delete proxy
-      @proxies_condition.signal
-    end
-
-    def run_site_proxy task, proxy
-      loop do
-        proxy.run       # run until disconnected
-      rescue IOError => e
-        log "Stream error: #{e}", level: :warning
-      rescue StandardError => e
-        notify_error e, level: :internal
-      ensure
-        begin
-          if @site_settings['intervals']['watchdog'] != :no
-            # sleep until waken by reconnect() or the reconnect interval passed
-            proxy.set_state :wait_for_reconnect
-            task.with_timeout(@site_settings['intervals']['watchdog']) do
-              @sleep_condition.wait
-            end
-          else
-            proxy.set_state :cannot_connect
-            break
-          end
-        rescue Async::TimeoutError
-          # ignore
-        end
-      end
     end
 
+    # stop
     def stop
       log "Stopping site #{@site_settings["site_id"]}", level: :info
-      @proxies.each do |proxy|
-        proxy.stop
-      end
-      @proxies.clear
       super
     end
- 
-    def starting
-      log "Starting site #{@site_settings["site_id"]}",
-          level: :info,
-          timestamp: @clock.now
-    end
-
-    def alarm
-      @proxies.each do |proxy|
-        proxy.stop
-      end
-    end
 
     def wait_for_supervisor ip, timeout
       supervisor = find_supervisor ip
       return supervisor if supervisor
-      wait_for(@proxy_condition,timeout) { find_supervisor ip }
+      wait_for_condition(@proxy_condition,timeout:timeout) { find_supervisor ip }
     rescue Async::TimeoutError
       raise RSMP::TimeoutError.new "Supervisor '#{ip}' did not connect within #{timeout}s"
     end

data/lib/rsmp/site_proxy.rb

@@ -1,6 +1,6 @@
 # Handles a supervisor connection to a remote client
 
-module RSMP  
+module RSMP
   class SiteProxy < Proxy
     include Components
 
@@ -14,33 +14,37 @@ module RSMP
       @site_id = options[:site_id]
     end
 
+    # handle communication
+    # when we're created, the socket is already open
+    def run
+      set_state :connected
+      start_reader
+      wait_for_reader   # run until disconnected
+    rescue RSMP::ConnectionError => e
+      log e, level: :error
+    rescue StandardError => e
+      notify_error e, level: :internal
+    ensure
+      close
+    end
+
     def revive options
       super options
       @supervisor = options[:supervisor]
       @settings = @supervisor.supervisor_settings.clone
     end
 
-
     def inspect
       "#<#{self.class.name}:#{self.object_id}, #{inspector(
         :@acknowledgements,:@settings,:@site_settings,:@components
         )}>"
     end
+
     def node
       supervisor
     end
 
-    def start
-      super
-      start_reader
-    end
-
-    def stop
-      log "Closing connection to site", level: :info
-      super
-    end
-
-    def connection_complete
+    def handshake_complete
       super
       sanitized_sxl_version = RSMP::Schemer.sanitize_version(@site_sxl_version)
       log "Connection to site #{@site_id} established, using core #{@rsmp_version}, #{@sxl} #{sanitized_sxl_version}", level: :info
@@ -68,7 +72,7 @@ module RSMP
         else
           super message
       end
-    rescue RSMP::RepeatedAlarmError, RSMP::RepeatedStatusError, TimestampError => e
+    rescue RSMP::RepeatedAlarmError, RSMP::RepeatedStatusError
       str = "Rejected #{message.type} message,"
       dont_acknowledge message, str, "#{e}"
       notify_error e.exception("#{str}#{e.message} #{message.json}")
@@ -101,13 +105,11 @@ module RSMP
           "cId" => component,
           "mId" => m_id
       })
-      send_and_optionally_collect message, options do |task|
-        collector = AggregatedStatusCollector.new(
+      send_and_optionally_collect message, options do |collect_options|
+        AggregatedStatusCollector.new(
           self,
-          options[:collect].merge(task:@task,m_id: m_id, num:1)
+          collect_options.merge(task:@task,m_id: m_id, num:1)
         )
-        collector.collect
-        collector
       end
     end
 
@@ -150,7 +152,7 @@ module RSMP
     end
 
     def version_acknowledged
-      connection_complete
+      handshake_complete
     end
 
     def process_watchdog message
@@ -179,14 +181,12 @@ module RSMP
           "sS" => request_list,
           "mId" => m_id
       })
-      send_and_optionally_collect message, options do |task|
-        collector = StatusCollector.new(
+      send_and_optionally_collect message, options do |collect_options|
+        StatusCollector.new(
           self,
           status_list,
-          options[:collect].merge(task:@task,m_id: m_id)
+          collect_options.merge(task:@task,m_id: m_id)
           )
-        collector.collect
-        collector
       end
     end
 
@@ -200,7 +200,7 @@ module RSMP
     def subscribe_to_status component_id, status_list, options={}
       validate_ready 'subscribe to status'
       m_id = options[:m_id] || RSMP::Message.make_m_id
-      
+
       # additional items can be used when verifying the response,
       # but must to remove from the subscribe message
       subscribe_list = status_list.map { |item| item.slice('sCI','n','uRt') }
@@ -215,14 +215,12 @@ module RSMP
           "sS" => subscribe_list,
           'mId' => m_id
       })
-      send_and_optionally_collect message, options do |task|
-        collector = StatusCollector.new(
+      send_and_optionally_collect message, options do |collect_options|
+        StatusCollector.new(
           self,
           status_list,
-          options[:collect].merge(task:@task,m_id: m_id)
+          collect_options.merge(task:@task,m_id: m_id)
         )
-        collector.collect
-        collector
       end
     end
 
@@ -267,14 +265,12 @@ module RSMP
           "arg" => command_list,
           "mId" => m_id
       })
-      send_and_optionally_collect message, options do |task|
-        collector = CommandResponseCollector.new(
+      send_and_optionally_collect message, options do |collect_options|
+        CommandResponseCollector.new(
           self,
           command_list,
-          options[:collect].merge(task:@task,m_id: m_id)
+          collect_options.merge(task:@task,m_id: m_id)
           )
-        collector.collect
-        collector
       end
     end
 
@@ -332,7 +328,7 @@ module RSMP
         log "Using site settings for guest", level: :debug
         return @settings['guest']
       end
-  
+
       nil
     end
 

data/lib/rsmp/supervisor.rb

@@ -58,26 +58,31 @@ module RSMP
       end
     end
 
-    def start_action
+    # listen for connections
+    # Async::IO::Endpoint#accept createa an async task that we will wait for
+    def run
+      log "Starting supervisor on port #{@supervisor_settings["port"]}",
+          level: :info,
+          timestamp: @clock.now
+
       @endpoint = Async::IO::Endpoint.tcp('0.0.0.0', @supervisor_settings["port"])
-      @endpoint.accept do |socket|  # creates async tasks
+      tasks = @endpoint.accept do |socket|  # creates async tasks
         handle_connection(socket)
       rescue StandardError => e
         notify_error e, level: :internal
       end
+      tasks.each { |task| task.wait }
     rescue StandardError => e
       notify_error e, level: :internal
     end
 
+    # stop
     def stop
       log "Stopping supervisor #{@supervisor_settings["site_id"]}", level: :info
-      @proxies.each { |proxy| proxy.stop }
-      @proxies.clear
       super
-      @tcp_server.close if @tcp_server
-      @tcp_server = nil
     end
 
+    # handle an incoming connction by either accepting of rejecting it
     def handle_connection socket
       remote_port = socket.remote_address.ip_port
       remote_hostname = socket.remote_address.ip_address
@@ -85,9 +90,9 @@ module RSMP
 
       info = {ip:remote_ip, port:remote_port, hostname:remote_hostname, now:Clock.now}
       if accept? socket, info
-        connect socket, info
+        accept_connection socket, info
       else
-        reject socket, info
+        reject_connection socket, info
       end
     rescue ConnectionError => e
       log "Rejected connection from #{remote_ip}:#{remote_port}, #{e.to_s}", level: :warning
@@ -99,12 +104,6 @@ module RSMP
       close socket, info
     end
 
-    def starting
-      log "Starting supervisor on port #{@supervisor_settings["port"]}", 
-          level: :info,
-          timestamp: @clock.now
-    end
-
     def accept? socket, info
       true
     end
@@ -143,7 +142,8 @@ module RSMP
       message.attribute('siteId').first['sId']
     end
 
-    def connect socket, info
+    # accept an incoming connecting by creating and starting a proxy
+    def accept_connection socket, info
       log "Site connected from #{format_ip_and_port(info)}",
           ip: info[:ip],
           port: info[:port],
@@ -182,7 +182,8 @@ module RSMP
         proxy = build_proxy settings.merge(site_id:id)    # keep the id learned by peeking above
         @proxies.push proxy
       end
-      proxy.run     # will run until the site disconnects
+      proxy.start     # will run until the site disconnects
+      proxy.wait
     ensure
       site_ids_changed
       stop if @supervisor_settings['one_shot']
@@ -192,7 +193,7 @@ module RSMP
       @site_id_condition.signal
     end
 
-    def reject socket, info
+    def reject_connection socket, info
       log "Site rejected", ip: info[:ip], level: :info
     end
 
@@ -224,10 +225,13 @@ module RSMP
       nil
     end
 
-    def wait_for_site site_id, timeout
+    def wait_for_site site_id, timeout:
       site = find_site site_id
       return site if site
-      wait_for(@site_id_condition,timeout) { find_site site_id }
+      wait_for_condition(@site_id_condition,timeout:timeout) do
+        find_site site_id
+      end
+
     rescue Async::TimeoutError
       if site_id == :any
         str = "No site connected"
@@ -237,8 +241,8 @@ module RSMP
       raise RSMP::TimeoutError.new "#{str} within #{timeout}s"
     end
 
-    def wait_for_site_disconnect site_id, timeout
-      wait_for(@site_id_condition,timeout) { true unless find_site site_id }
+    def wait_for_site_disconnect site_id, timeout:
+      wait_for_condition(@site_id_condition,timeout:timeout) { true unless find_site site_id }
     rescue Async::TimeoutError
       raise RSMP::TimeoutError.new "Site '#{site_id}' did not disconnect within #{timeout}s"
     end

data/lib/rsmp/supervisor_proxy.rb

@@ -2,7 +2,7 @@
 
 require 'digest'
 
-module RSMP  
+module RSMP
   class SupervisorProxy < Proxy
 
     attr_reader :supervisor_id, :site
@@ -22,44 +22,67 @@ module RSMP
       site
     end
 
-    def start
+    # handle communication
+    # if disconnected, then try to reconnect
+    def run
+      loop do
+        connect
+        start_reader
+        start_handshake
+        wait_for_reader   # run until disconnected
+        break if reconnect_delay == false
+      rescue Restart
+        @logger.mute @ip, @port
+        raise
+      rescue RSMP::ConnectionError => e
+        log e, level: :error
+        break if reconnect_delay == false
+      rescue StandardError => e
+        notify_error e, level: :internal
+        break if reconnect_delay == false
+      ensure
+        close
+        stop_subtasks
+      end
+    end
+
+    def start_handshake
+      send_version @site_settings['site_id'], @site_settings["rsmp_versions"]
+    end
+
+    # connect to the supervisor and initiate handshake supervisor
+    def connect
       log "Connecting to supervisor at #{@ip}:#{@port}", level: :info
-      super
-      connect
+      set_state :connecting
+      connect_tcp
       @logger.unmute @ip, @port
       log "Connected to supervisor at #{@ip}:#{@port}", level: :info
-      start_reader
-      send_version @site_settings['site_id'], @site_settings["rsmp_versions"]
     rescue SystemCallError => e
-      log "Could not connect to supervisor at #{@ip}:#{@port}: Errno #{e.errno} #{e}", level: :error
-      retry_notice
+      raise ConnectionError.new "Could not connect to supervisor at #{@ip}:#{@port}: Errno #{e.errno} #{e}"
     rescue StandardError => e
-      log "Error while connecting to supervisor at #{@ip}:#{@port}: #{e}", level: :error
-      retry_notice
-    end
-
-    def retry_notice
-      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
+      raise ConnectionError.new "Error while connecting to supervisor at #{@ip}:#{@port}: #{e}"
     end
 
-    def stop
-      log "Closing connection to supervisor", level: :info
+    def stop_task
       super
       @last_status_sent = nil
     end
 
-    def connect
-      return if @socket
+    def connect_tcp
       @endpoint = Async::IO::Endpoint.tcp(@ip, @port)
-      @socket = @endpoint.connect
+
+      # Async::IO::Endpoint#connect renames the current task. run in a subtask to avoid this
+      @task.async do |task|
+        task.annotate 'socket task'
+        @socket = @endpoint.connect
+      end.wait
+
       @stream = Async::IO::Stream.new(@socket)
       @protocol = Async::IO::Protocol::Line.new(@stream,WRAPPING_DELIMITER) # rsmp messages are json terminated with a form-feed
+      set_state :connected
     end
 
-    def connection_complete
+    def handshake_complete
       super
       sanitized_sxl_version = RSMP::Schemer.sanitize_version(sxl_version)
       log "Connection to supervisor established, using core #{@rsmp_version}, #{sxl} #{sanitized_sxl_version}", level: :info
@@ -114,16 +137,19 @@ module RSMP
     end
 
     def reconnect_delay
+      return false if @site_settings['intervals']['reconnect'] == :no
       interval = @site_settings['intervals']['reconnect']
-      log "Waiting #{interval} seconds before trying to reconnect", level: :info
+      log "Will try to reconnect again every #{interval} seconds...", level: :info
+      @logger.mute @ip, @port
       @task.sleep interval
+      true
     end
 
     def version_accepted message
       log "Received Version message, using RSMP #{@rsmp_version}", message: message, level: :log
       start_timer
       acknowledge message
-      connection_complete
+      handshake_complete
       @version_determined = true
     end
 
@@ -138,8 +164,8 @@ module RSMP
         "mId" => m_id,
       })
 
-      send_and_optionally_collect message, options do |task|
-        wait_for_acknowledgement task, options[:collect], m_id
+      send_and_optionally_collect message, options do |collect_options|
+        Collector.new self, collect_options.merge(task:@task, type: 'MessageAck')
       end
     end
 
@@ -234,7 +260,7 @@ module RSMP
       update_list = {}
       component = message.attributes["cId"]
       @status_subscriptions[component] ||= {}
-      update_list[component] ||= {} 
+      update_list[component] ||= {}
       now = Time.now  # internal timestamp
       subs = @status_subscriptions[component]
 
@@ -299,7 +325,7 @@ module RSMP
           by_name.each_pair do |name,subscription|
             current = nil
             should_send = false
-            if subscription[:interval] == 0 
+            if subscription[:interval] == 0
               # send as soon as the data changes
               if component_object
                 current, age = *(component_object.get_status code, name)

data/lib/rsmp/task.rb

@@ -0,0 +1,84 @@
+module RSMP
+  class Restart < StandardError
+  end
+
+  module Task
+    attr_reader :task
+
+    def initialize_task
+      @task = nil
+    end
+
+    # start our async tasks and return immediately
+    # run() will be called inside the task to perform actual long-running work
+    def start
+      return if @task
+      Async do |task|
+        task.annotate "#{self.class.name} main task"
+        @task = task
+        run
+        stop_subtasks
+        @task = nil
+      end
+      self
+    end
+
+    # initiate restart by raising a Restart exception
+    def restart
+      raise Restart.new "restart initiated by #{self.class.name}:#{object_id}"
+    end
+
+    # get the status of our task, or nil of no task
+    def status
+      @task.status if @task
+    end
+
+    # perform any long-running work
+    # the method will be called from an async task, and should not return
+    # if subtasks are needed, the method should call wait() on each of them
+    # once running, ready() must be called
+    def run
+      start_subtasks
+    end
+
+    # wait for our task to complete
+    def wait
+      @task.wait if @task
+    end
+
+    # stop our task
+    def stop
+      stop_subtasks
+      stop_task if @task
+    end
+
+    def stop_subtasks
+    end
+
+    # stop our task and any subtask
+    def stop_task
+      @task.stop
+      @task = nil
+    end
+
+    # wait for an async condition to signal, then yield to block
+    # if block returns true we're done. otherwise, wait again
+    def wait_for_condition condition, timeout:, task:Async::Task.current, &block
+      unless task
+        raise RuntimeError.new("Can't wait without a task")
+      end
+      task.with_timeout(timeout) do
+        while task.running?
+          value = condition.wait
+          return value unless block
+          result = yield value
+          return result if result
+        end
+        raise RuntimeError.new("Can't wait for condition because task #{task.object_id} #{task.annotation} is not running")
+      end
+    rescue Async::TimeoutError
+      raise RSMP::TimeoutError.new
+    end
+
+  end
+end

data/lib/rsmp/tlc/signal_group.rb

@@ -6,25 +6,35 @@ 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 = compute_state
+      end
+
+      def compute_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
+          return 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/signal_plan.rb

@@ -1,8 +1,8 @@
 module RSMP
   module TLC
     # A Traffic Light Controller Signal Plan.
-    # A signal plan is a description of how all signal groups should change 
-    # state over time. 
+    # A signal plan is a description of how all signal groups should change
+    # state over time.
     class SignalPlan
       attr_reader :nr, :states, :dynamic_bands
       def initialize nr:, states:, dynamic_bands: