rsmp 0.1.0

data/lib/rsmp/site.rb

@@ -0,0 +1,165 @@
+# RSMP site
+# The site initializes the connection to the supervisor.
+# Connections to supervisors are handles via supervisor proxies.
+
+module RSMP
+  class Site < Node
+    include SiteBase
+
+    attr_reader :rsmp_versions, :site_settings, :logger, :proxies
+
+    def initialize options={}
+      initialize_site
+      handle_site_settings options
+      super options.merge log_settings: @site_settings["log"]
+      @proxies = []
+      @sleep_condition = Async::Notification.new
+    end
+
+    def site_id
+      @site_settings['site_id']
+    end
+
+    def handle_site_settings options
+      @site_settings = {
+        'site_id' => 'RN+SI0001',
+        'supervisors' => [
+          { 'ip' => '127.0.0.1', '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,
+        'reconnect_interval' => 0.1,
+        'send_after_connect' => true,
+        'components' => {
+          'C1' => {}
+        },
+        'log' => {
+          'active' => true,
+          'color' => true,
+          'ip' => false,
+          'timestamp' => true,
+          'site_id' => true,
+          'level' => false,
+          'acknowledgements' => false,
+          'watchdogs' => false,
+          'json' => false,
+          'statistics' => false
+        }
+      }
+      if options[:site_settings_path]
+        if File.exist? options[:site_settings_path]
+          @site_settings.merge! YAML.load_file(options[:site_settings_path])
+        else
+          puts "Error: Config #{options[:site_settings_path]} not found, pwd"
+          exit
+        end
+      end
+
+      if options[:site_settings]
+        converted = options[:site_settings].map { |k,v| [k.to_s,v] }.to_h   #convert symbol keys to string keys
+        converted.compact!
+        @site_settings.merge! converted
+      end
+
+      required = [:supervisors,:rsmp_versions,:site_id,:watchdog_interval,:watchdog_timeout,
+                  :acknowledgement_timeout,:command_response_timeout,:log]
+      check_required_settings @site_settings, required
+
+      setup_components @site_settings['components']
+    end
+
+    def reconnect
+      @sleep_condition.signal
+    end
+
+    def start_action
+      @site_settings["supervisors"].each do |supervisor_settings|
+        @task.async do |task|
+          task.annotate "site_proxy"
+          connect_to_supervisor task, supervisor_settings
+        end
+      end
+    end
+
+    def build_connector settings
+      SupervisorProxy.new settings
+    end
+
+    def aggrated_status_changed component
+      @proxies.each do |proxy|
+        proxy.send_aggregated_status component
+      end
+    end
+
+    def connect_to_supervisor task, supervisor_settings
+      proxy = build_connector({
+        site: self,
+        task: @task,
+        settings: @site_settings, 
+        ip: supervisor_settings['ip'],
+        port: supervisor_settings['port'],
+        logger: @logger,
+        archive: @archive
+      })
+      @proxies << proxy
+      run_site_proxy task, proxy
+    ensure
+      @proxies.delete proxy
+    end
+
+    def run_site_proxy task, proxy
+      loop do
+        proxy.run       # run until disconnected
+      rescue IOError => e
+        log "Stream error: #{e}", level: :warning
+      rescue SystemCallError => e # all ERRNO errors
+        log "Reader exception: #{e.to_s}", level: :error
+      rescue StandardError => e
+        log ["Reader exception: #{e}",e.backtrace].flatten.join("\n"), level: :error
+      ensure
+        begin
+          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 }
+          else
+            proxy.set_state :cannot_connect
+            break
+          end
+        rescue Async::TimeoutError
+          # ignore
+        end
+      end
+    end
+
+    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: RSMP.now_object
+    end
+
+    def alarm
+      @proxies.each do |proxy|
+        proxy.stop
+      end
+    end
+
+  end
+end

data/lib/rsmp/site_base.rb

@@ -0,0 +1,26 @@
+# Things shared between sites and site proxies
+
+module RSMP
+  module SiteBase
+    attr_reader :components
+    
+    def initialize_site
+      @components = {}
+    end
+
+    def aggrated_status_changed component
+    end
+
+    def setup_components settings
+      return unless settings
+      settings.each_pair do |id,settings|
+        @components[id] = build_component(id,settings)
+      end
+    end
+
+    def build_component id, settings={}
+      Component.new id: id, node: self, grouped: true
+    end
+
+  end
+end

data/lib/rsmp/site_proxy.rb

@@ -0,0 +1,220 @@
+# Handles a supervisor connection to a remote client
+
+module RSMP  
+  class SiteProxy < Proxy
+    include SiteBase
+
+    attr_reader :supervisor
+
+    def initialize options
+      super options
+      initialize_site
+      @supervisor = options[:supervisor]
+      @settings = @supervisor.supervisor_settings.clone
+    end
+
+    def node
+      supervisor
+    end
+
+    def start
+      super
+      start_reader
+    end
+
+    def connection_complete
+      super
+      log "Connection to site #{@site_ids.first} established", level: :info
+    end
+
+    def process_message message
+      case message
+        when CommandRequest
+        when StatusRequest
+        when StatusSubscribe
+        when StatusUnsubscribe
+          will_not_handle message
+        when AggregatedStatus
+          process_aggregated_status message
+        when Alarm
+          process_alarm message
+        when CommandResponse
+          process_command_response message
+        when StatusResponse
+          process_status_response message
+        when StatusUpdate
+          process_status_update message
+        else
+          super message
+      end
+    end
+
+    def version_accepted message, rsmp_version
+      log "Received Version message for sites [#{@site_ids.join(',')}] using RSMP #{rsmp_version}", message: message, level: :log
+      start_timer
+      acknowledge message
+      send_version rsmp_version
+      @version_determined = true
+
+      site_id = @site_ids.first
+      if @settings['sites']
+        @site_settings = @settings['sites'][site_id]
+        if @site_settings
+          setup_components @site_settings['components']
+        end
+      end
+    end
+
+    def validate_aggregated_status  message, se
+      unless se && se.is_a?(Array) && se.size == 8
+        reason = "invalid AggregatedStatus, 'se' must be an Array of size 8"
+        dont_acknowledge message, "Received", reaons
+        raise InvalidMessage
+      end
+    end
+
+    def process_aggregated_status message
+      se = message.attribute("se")
+      validate_aggregated_status(message,se) == false
+      c_id = message.attributes["cId"]
+      component = @components[c_id]
+      if component == nil
+        if @site_settings == nil || @site_settings['components'] == nil
+          component = build_component c_id
+          log "Adding component #{c_id} to site #{site_id}", level: :info
+        else
+          reason = "component #{c_id} not found"
+          dont_acknowledge message, "Ignoring #{message.type}:", reason
+          return
+        end
+      end
+
+      component.set_aggregated_status_bools se
+      log "Received #{message.type} status for component #{c_id} [#{component.aggregated_status.join(', ')}]", message: message
+      acknowledge message
+    end
+
+    def aggrated_status_changed component
+      @supervisor.aggregated_status_changed self, component
+    end
+
+    def process_alarm message
+      alarm_code = message.attribute("aCId")
+      asp = message.attribute("aSp")
+      status = ["ack","aS","sS"].map { |key| message.attribute(key) }.join(',')
+      log "Received #{message.type}, #{alarm_code} #{asp} [#{status}]", message: message, level: :log
+      acknowledge message
+    end
+
+    def version_acknowledged
+      connection_complete
+    end
+
+    def process_watchdog message
+      super
+      if @watchdog_started == false
+        start_watchdog
+      end
+    end
+
+    def site_ids_changed
+      @supervisor.site_ids_changed
+    end
+
+    def check_site_id site_id
+      @site_settings = @supervisor.check_site_id site_id
+    end
+
+    def request_status component, status_list, timeout=nil
+      raise NotReady unless @state == :ready
+      message = RSMP::StatusRequest.new({
+          "ntsOId" => '',
+          "xNId" => '',
+          "cId" => component,
+          "sS" => status_list
+      })
+      send_message message
+      return message, wait_for_status_response(component: component, timeout: timeout)
+    end
+
+    def process_status_response message
+      log "Received #{message.type}", message: message, level: :log
+      acknowledge message
+    end
+
+    def wait_for_status_response options
+      raise ArgumentError unless options[:component]
+      item = @archive.capture(@task, options.merge(type: "StatusResponse", with_message: true, num: 1)) do |item|
+        # check component
+      end
+      item[:message] if item
+    end
+
+    def subscribe_to_status component, status_list
+      raise NotReady unless @state == :ready
+      message = RSMP::StatusSubscribe.new({
+          "ntsOId" => '',
+          "xNId" => '',
+          "cId" => component,
+          "sS" => status_list
+      })
+      send_message message
+      message
+    end
+
+    def unsubscribe_to_status component, status_list
+      raise NotReady unless @state == :ready
+      message = RSMP::StatusUnsubscribe.new({
+          "ntsOId" => '',
+          "xNId" => '',
+          "cId" => component,
+          "sS" => status_list
+      })
+      send_message message
+      message
+    end
+
+    def process_status_update message
+      log "Received #{message.type}", message: message, level: :log
+      acknowledge message
+    end
+
+    def wait_for_status_update options={}
+      raise ArgumentError unless options[:component]
+      item = @archive.capture(options.merge(type: "StatusUpdate", with_message: true, num: 1)) do |item|
+        # check component
+      end
+      item[:message] if item
+    end
+
+    def send_command component, args
+      raise NotReady unless @state == :ready
+      message = RSMP::CommandRequest.new({
+          "ntsOId" => '',
+          "xNId" => '',
+          "cId" => component,
+          "arg" => args
+      })
+      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
+      end
+      item[:message] if item
+    end
+
+    def set_watchdog_interval interval
+      @settings["watchdog_interval"] = interval
+    end
+
+  end
+end

data/lib/rsmp/supervisor.rb

@@ -0,0 +1,220 @@
+# RSMP supervisor (server)
+# The supervisor waits for sites to connect.
+# Connections to sites are handles via site proxies.
+
+module RSMP
+  class Supervisor < Node
+    attr_reader :rsmp_versions, :site_id, :supervisor_settings, :proxies, :logger
+
+    def initialize options={}
+      handle_supervisor_settings options
+      super options.merge log_settings: @supervisor_settings["log"]
+      @proxies = []
+      @site_id_condition = Async::Notification.new
+    end
+
+    def site_id
+      @supervisor_settings['site_id']
+    end
+
+    def handle_supervisor_settings options
+      @supervisor_settings = {
+        'site_id' => 'RN+SU0001',
+        '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,
+        'log' => {
+          'active' => true,
+          'color' => true,
+          'ip' => false,
+          'timestamp' => true,
+          'site_id' => true,
+          'level' => false,
+          'acknowledgements' => false,
+          'watchdogs' => false,
+          'json' => false
+        }
+      }
+
+      if options[:supervisor_settings_path]
+        if File.exist? options[:supervisor_settings_path]
+          @supervisor_settings.merge! YAML.load_file(options[:supervisor_settings_path])
+        else
+          puts "Error: Site settings #{options[:supervisor_settings_path]} not found"
+          exit
+        end
+
+      end
+      
+      if options[:supervisor_settings]
+        converted = options[:supervisor_settings].map { |k,v| [k.to_s,v] }.to_h   #convert symbol keys to string keys
+        @supervisor_settings.merge! converted
+      end
+
+      required = [:port, :rsmp_versions, :site_id, :watchdog_interval, :watchdog_timeout,
+                  :acknowledgement_timeout, :command_response_timeout, :log]
+      check_required_settings @supervisor_settings, required
+
+      @rsmp_versions = @supervisor_settings["rsmp_versions"]
+      
+      # randomize site id
+      #@supervisor_settings["site_id"] = "RN+SU#{rand(9999).to_i}"
+
+      # randomize port
+      #@supervisor_settings["port"] = @supervisor_settings["port"] + rand(10).to_i
+    end
+
+    def start_action
+      @endpoint = Async::IO::Endpoint.tcp('0.0.0.0', @supervisor_settings["port"])
+      @endpoint.accept do |socket|
+        handle_connection(socket)
+      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
+    end
+
+    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
+
+    def handle_connection socket
+      remote_port = socket.remote_address.ip_port
+      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()}
+      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 StandardError => e
+      log "Exception: #{e}", exception: e, level: :error
+    ensure
+      close socket, info
+    end
+
+    def starting
+      log "Starting supervisor #{@supervisor_settings["site_id"]} on port #{@supervisor_settings["port"]}", 
+          level: :info,
+          timestamp: RSMP.now_object
+    end
+
+    def accept? socket, info
+      true
+    end
+
+    def build_connector settings
+      SiteProxy.new settings
+    end
+
+    def connect socket, info
+      if @supervisor_settings['log']['hide_ip_and_port']
+        port_and_port = '********'
+      else
+        port_and_port = "#{info[:ip]}:#{info[:port]}"
+      end
+
+      log "Site connected from #{port_and_port}", 
+          ip: port_and_port,
+          level: :info,
+          timestamp: RSMP.now_object
+
+      proxy = build_connector({
+        supervisor: self,
+        task: @task,
+        settings: @supervisor_settings[:sites],
+        socket: socket,
+        info: info,
+        logger: @logger,
+        archive: @archive
+      })
+      @proxies.push proxy
+      
+      proxy.run     # will run until the site disconnects
+      @proxies.delete proxy
+      site_ids_changed
+    end
+
+    def site_ids_changed
+      @site_id_condition.signal
+    end
+
+    def reject socket, info
+      log "Site rejected", ip: info[:ip], level: :info
+    end
+
+    def close socket, info
+      if info
+        log "Connection to #{info[:ip]}:#{info[:port]} closed", ip: info[:ip], level: :info, timestamp: RSMP.now_object
+      else
+        log "Connection closed", level: :info, timestamp: RSMP.now_object
+      end
+
+      socket.close
+    end
+
+    def site_connected? site_id
+      return find_site(site_id) != nil
+    end
+
+    def find_site site_id
+      @proxies.each do |site|
+        return site if site_id == :any || site.site_ids.include?(site_id)
+      end
+      nil
+    end
+
+    def wait_for_site site_id, timeout
+      RSMP::Wait.wait_for(@task,@site_id_condition,timeout) { find_site site_id }
+    rescue Async::TimeoutError
+      nil
+    end
+
+    def wait_for_site_disconnect site_id, timeout
+      RSMP::Wait.wait_for(@task,@site_id_condition,timeout) { true unless find_site site_id }
+    rescue Async::TimeoutError
+      false
+    end   
+
+    def check_site_id site_id
+      check_site_already_connected site_id
+      return find_allowed_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)
+    end
+
+    def find_allowed_site_setting site_id
+      return {} unless @supervisor_settings['sites']
+      @supervisor_settings['sites'].each_pair do |id,settings|
+        if id == site_id
+          return settings
+        end
+      end
+      raise FatalError.new "site id #{site_id} rejected"
+    end
+
+    def aggregated_status_changed site_proxy, component
+    end
+
+  end
+end

data/lib/rsmp/supervisor_base.rb

@@ -0,0 +1,10 @@
+# Things shared between sites and site proxies
+
+module RSMP
+  module SupervisorBase
+
+    def initialize_supervisor
+    end
+
+  end
+end