rsmp 0.35.2 → 0.38.0

data/lib/rsmp/cli.rb

@@ -1,186 +1,208 @@
 require 'thor'
-require 'rsmp'
+require_relative '../rsmp'
 
 module RSMP
   class CLI < Thor
-    desc "version", "Show version"
+    desc 'version', 'Show version'
     def version
       puts RSMP::VERSION
     end
 
-    desc "site", "Run RSMP site"
-    method_option :config, :type => :string, :aliases => "-c", banner: 'Path to .yaml config file'
-    method_option :id, :type => :string, :aliases => "-i", banner: 'RSMP site id'
-    method_option :supervisors, :type => :string, :aliases => "-s", banner: 'ip:port,... list of supervisor to connect to'
-    method_option :core, :string => :string, banner: "Core version: [#{RSMP::Schema.core_versions.join(' ')}]", enum: RSMP::Schema.core_versions
-    method_option :type, :type => :string, :aliases => "-t", banner: 'Type of site: [tlc]', enum: ['tlc'], default: 'tlc'
-    method_option :log, :type => :string, :aliases => "-l", banner: 'Path to log file'
-    method_option :json, :type => :boolean, :aliases => "-j", banner: 'Show JSON messages in log'
+    desc 'site', 'Run RSMP site'
+    method_option :config, type: :string, aliases: '-c', banner: 'Path to .yaml config file'
+    method_option :id, type: :string, aliases: '-i', banner: 'RSMP site id'
+    method_option :supervisors, type: :string, aliases: '-s',
+                                banner: 'ip:port,... list of supervisor to connect to'
+    method_option :core, type: :string, banner: "Core version: [#{RSMP::Schema.core_versions.join(' ')}]", enum: RSMP::Schema.core_versions
+    method_option :type, type: :string, aliases: '-t', banner: 'Type of site: [tlc]', enum: ['tlc'],
+                         default: 'tlc'
+    method_option :log, type: :string, aliases: '-l', banner: 'Path to log file'
+    method_option :json, type: :boolean, aliases: '-j', banner: 'Show JSON messages in log'
     def site
-      settings = {}
-      log_settings = { 'active' => true }
+      settings, log_settings = load_site_configuration
+      apply_site_options(settings, log_settings)
+      site_class = determine_site_class(settings)
+      run_site(site_class, settings, log_settings)
+    rescue Interrupt
+      # ctrl-c
+    rescue StandardError => e
+      puts "Uncaught error: #{e}"
+      puts caller.join("\n")
+    end
+
+    desc 'supervisor', 'Run RSMP supervisor'
+    method_option :config, type: :string, aliases: '-c', banner: 'Path to .yaml config file'
+    method_option :id, type: :string, aliases: '-i', banner: 'RSMP site id'
+    method_option :ip, type: :string, banner: 'IP address to listen on'
+    method_option :port, type: :string, aliases: '-p', banner: 'Port to listen on'
+    method_option :core, type: :string, banner: "Core version: [#{RSMP::Schema.core_versions.join(' ')}]", enum: RSMP::Schema.core_versions
+    method_option :log, type: :string, aliases: '-l', banner: 'Path to log file'
+    method_option :json, type: :boolean, aliases: '-j', banner: 'Show JSON messages in log'
+    def supervisor
+      settings, log_settings = load_supervisor_configuration
+      apply_supervisor_options(settings, log_settings)
+      run_supervisor(settings, log_settings)
+    rescue Interrupt
+      # ctrl-c
+    end
+
+    desc 'convert', 'Convert SXL from YAML to JSON Schema'
+    method_option :in, type: :string, aliases: '-i', banner: 'Path to YAML input file'
+    method_option :out, type: :string, aliases: '-o', banner: 'Path to JSON Schema output file'
+    def convert
+      validate_convert_options
+      validate_input_file_exists
+      perform_conversion
+    end
+
+    no_commands do
+      def load_site_configuration
+        settings = {}
+        log_settings = { 'active' => true }
+
+        return [settings, log_settings] unless options[:config]
 
-      if options[:config]
         if File.exist? options[:config]
           settings = YAML.load_file options[:config]
-          log_settings = settings.delete('log') || {}
+          log_settings = settings.delete('log') || log_settings
         else
           puts "Error: Config #{options[:config]} not found"
           exit
         end
-      end
 
-      if options[:id]
-        settings['site_id'] = options[:id]
+        [settings, log_settings]
       end
+    end
 
-      if options[:supervisors]
-        settings['supervisors'] = []
-        options[:supervisors].split(',').each do |supervisor|
-          ip, port = supervisor.split ':'
-          ip = '127.0.0.1' if ip.empty?
-          port = '12111' if port.empty?
-          settings['supervisors'] << {"ip"=>ip, "port"=>port}
-        end
-      end
+    private
 
-      if options[:core]
-        settings['core_version'] = options[:core]
-      end
+    def apply_site_options(settings, log_settings)
+      apply_basic_site_options(settings)
+      parse_supervisors(settings) if options[:supervisors]
+      apply_log_options(log_settings)
+    end
 
-      site_class = RSMP::Site
-      site_type = options[:type] || settings['type']
-      case site_type
-        when 'tlc'
-          site_class = RSMP::TLC::TrafficControllerSite
-        else
-          puts "Error: Unknown site type #{site_type}"
-          exit
-      end
+    def apply_basic_site_options(settings)
+      settings['site_id'] = options[:id] if options[:id]
+      settings['core_version'] = options[:core] if options[:core]
+    end
 
-      if options[:log]
-        log_settings['path'] = options[:log]
+    def parse_supervisors(settings)
+      settings['supervisors'] = []
+      options[:supervisors].split(',').each do |supervisor|
+        ip, port = supervisor.split ':'
+        ip = '127.0.0.1' if ip.empty?
+        port = '12111' if port.empty?
+        settings['supervisors'] << { 'ip' => ip, 'port' => port }
       end
+    end
 
-      if options[:json]
-        log_settings['json'] = options[:json]
+    def determine_site_class(settings)
+      site_type = options[:type] || settings['type']
+      case site_type
+      when 'tlc'
+        RSMP::TLC::TrafficControllerSite
+      else
+        puts "Error: Unknown site type #{site_type}"
+        exit
       end
+    end
 
+    def run_site(site_class, settings, log_settings)
       Async do |task|
         task.annotate 'cli'
         loop do
-          begin
-            site = site_class.new(site_settings: settings, log_settings: log_settings)
-            site.start
-            site.wait
-          rescue Psych::SyntaxError => e
-            puts "Cannot read config file #{e}"
-            break
-          rescue RSMP::Schema::UnknownSchemaTypeError => e
-            puts "Cannot start site: #{e}"
-            break
-          rescue RSMP::Schema::UnknownSchemaVersionError => e
-            puts "Cannot start site: #{e}"
-            break
-          rescue RSMP::ConfigurationError => e
-            puts "Cannot start site: #{e}"
-            break
-          rescue RSMP::Restart
-            site.stop
-          end
+          site = site_class.new(site_settings: settings, log_settings: log_settings)
+          site.start
+          site.wait
+        rescue Psych::SyntaxError => e
+          puts "Cannot read config file #{e}"
+          break
+        rescue RSMP::Schema::UnknownSchemaTypeError, RSMP::Schema::UnknownSchemaVersionError,
+               RSMP::ConfigurationError => e
+          puts "Cannot start site: #{e}"
+          break
+        rescue RSMP::Restart
+          site.stop
         end
       end
-    rescue Interrupt
-      # cntr-c
-    rescue Exception => e
-      puts "Uncaught error: #{e}"
-      puts caller.join("\n")
     end
 
-    desc "supervisor", "Run RSMP supervisor"
-    method_option :config, :type => :string, :aliases => "-c", banner: 'Path to .yaml config file'
-    method_option :id, :type => :string, :aliases => "-i", banner: 'RSMP site id'
-    method_option :ip, :type => :numeric, banner: 'IP address to listen on'
-    method_option :port, :type => :string, :aliases => "-p", banner: 'Port to listen on'
-    method_option :core, :string => :string, banner: "Core version: [#{RSMP::Schema.core_versions.join(' ')}]", enum: RSMP::Schema.core_versions
-    method_option :log, :type => :string, :aliases => "-l", banner: 'Path to log file'
-    method_option :json, :type => :boolean, :aliases => "-j", banner: 'Show JSON messages in log'
-    def supervisor
+    def load_supervisor_configuration
       settings = {}
       log_settings = { 'active' => true }
 
-      if options[:config]
-        if File.exist? options[:config]
-          settings = YAML.load_file options[:config]
-          log_settings = settings.delete 'log'
-        else
-          puts "Error: Config #{options[:config]} not found"
-          exit
-        end
-      end
+      return [settings, log_settings] unless options[:config]
 
-      if options[:id]
-        settings['site_id'] = options[:id]
+      if File.exist? options[:config]
+        settings = YAML.load_file options[:config]
+        log_settings = settings.delete('log') || log_settings
+      else
+        puts "Error: Config #{options[:config]} not found"
+        exit
       end
 
-      if options[:ip]
-        settings['ip'] = options[:ip]
-      end
+      [settings, log_settings]
+    end
 
-      if options[:port]
-        settings['port'] = options[:port]
-      end
+    def apply_supervisor_options(settings, log_settings)
+      apply_basic_supervisor_options(settings)
+      apply_core_version_option(settings)
+      apply_log_options(log_settings)
+    end
 
-      if options[:core]
-        settings['guest'] = {}
-        settings['guest']['core_version'] = options[:core]
-      end
+    def apply_basic_supervisor_options(settings)
+      settings['site_id'] = options[:id] if options[:id]
+      settings['ip'] = options[:ip] if options[:ip]
+      settings['port'] = options[:port] if options[:port]
+    end
 
-      if options[:log]
-        log_settings['path'] = options[:log]
-      end
+    def apply_core_version_option(settings)
+      return unless options[:core]
 
-      if options[:json]
-        log_settings['json'] = options[:json]
-      end
+      settings['guest'] ||= {}
+      settings['guest']['core_version'] = options[:core]
+    end
 
+    def apply_log_options(log_settings)
+      log_settings['path'] = options[:log] if options[:log]
+      log_settings['json'] = options[:json] if options[:json]
+    end
+
+    def run_supervisor(settings, log_settings)
       Async do |task|
         task.annotate 'cli'
-        supervisor = RSMP::Supervisor.new(supervisor_settings:settings,log_settings:log_settings)
+        supervisor = RSMP::Supervisor.new(supervisor_settings: settings, log_settings: log_settings)
         supervisor.start
         supervisor.wait
       rescue Psych::SyntaxError => e
         puts "Cannot read config file #{e}"
-      rescue RSMP::Schema::UnknownSchemaTypeError => e
-        puts "Cannot start supervisor: #{e}"
-      rescue RSMP::Schema::UnknownSchemaVersionError => e
-        puts "Cannot start supervisor: #{e}"
-      rescue RSMP::ConfigurationError => e
+      rescue RSMP::Schema::UnknownSchemaTypeError, RSMP::Schema::UnknownSchemaVersionError,
+             RSMP::ConfigurationError => e
         puts "Cannot start supervisor: #{e}"
       end
-    rescue Interrupt
-      # ctrl-c
     end
 
-    desc "convert", "Convert SXL from YAML to JSON Schema"
-    method_option :in, :type => :string, :aliases => "-i", banner: 'Path to YAML input file'
-    method_option :out, :type => :string, :aliases => "-o", banner: 'Path to JSON Schema output file'
-    def convert
+    def validate_convert_options
       unless options[:in]
-        puts "Error: Input option missing"
+        puts 'Error: Input option missing'
         exit
       end
 
-      unless options[:out]
-        puts "Error: Output option missing"
-        exit
-      end
+      return if options[:out]
 
-      unless File.exist? options[:in]
-        puts "Error: Input path file #{options[:in]} not found"
-        exit
-      end
+      puts 'Error: Output option missing'
+      exit
+    end
+
+    def validate_input_file_exists
+      return if File.exist? options[:in]
+
+      puts "Error: Input path file #{options[:in]} not found"
+      exit
+    end
 
+    def perform_conversion
       sxl = RSMP::Convert::Import::YAML.read options[:in]
       RSMP::Convert::Export::JSONSchema.write sxl, options[:out]
     end
@@ -190,5 +212,6 @@ module RSMP
     def self.exit_on_failure?
       true
     end
+    private_class_method :exit_on_failure?
   end
-end
+end

data/lib/rsmp/collect/ack_collector.rb

@@ -1,18 +1,19 @@
 module RSMP
   # Class for waiting for a message acknowledgement
   class AckCollector < Collector
-    def initialize proxy, options={}
-      raise ArgumentError.new("m_id must be provided") unless options[:m_id]
-      super proxy, options.merge(
+    def initialize(proxy, options = {})
+      raise ArgumentError, 'm_id must be provided' unless options[:m_id]
+
+      super(proxy, options.merge(
         filter: RSMP::Filter.new(ingoing: true, outgoing: false, type: 'MessageAck'),
         num: 1,
         title: 'message acknowledgement'
-      )
+      ))
     end
 
     # Check if we the MessageAck related to initiating request, identified by @m_id.
-    def acceptable? message
-      super(message) && message.attribute('oMId') == @m_id
+    def acceptable?(message)
+      super && message.attribute('oMId') == @m_id
     end
   end
-end
+end

data/lib/rsmp/collect/aggregated_status_collector.rb

@@ -1,11 +1,11 @@
 module RSMP
   # Class for waiting for an aggregated status response
   class AggregatedStatusCollector < Collector
-    def initialize proxy, options={}
-      super proxy, options.merge(
+    def initialize(proxy, options = {})
+      super(proxy, options.merge(
         filter: RSMP::Filter.new(ingoing: true, outgoing: false, type: 'AggregatedStatus'),
         title: 'aggregated status'
-      )
+      ))
     end
   end
-end
+end

data/lib/rsmp/collect/alarm_collector.rb

@@ -1,20 +1,26 @@
 module RSMP
   # Class for waiting for specific command responses
   class AlarmCollector < Collector
-    def initialize proxy,options={}
+    def initialize(proxy, options = {})
       @matcher = options[:matcher] || {}
-      super proxy, options.merge(
+      super(proxy, options.merge(
         filter: RSMP::Filter.new(ingoing: true, outgoing: false, type: 'Alarm'),
-        title:'alarm'
-      )
+        title: 'alarm'
+      ))
     end
 
-    # match alarm attributes
-    def acceptable? message
-      return false if super(message) == false
+    def acceptable?(message)
+      return false if super == false
+      return false unless fixed_attributes_match?(message)
+      return false unless rvs_attributes_match?(message)
 
-      # match fixed attributes
-      %w{cId aCId aSp ack aS sS cat pri}.each do |key|
+      true
+    end
+
+    private
+
+    def fixed_attributes_match?(message)
+      %w[cId aCId aSp ack aS sS cat pri].each do |key|
         want = @matcher[key]
         got = message.attribute(key)
         case want
@@ -24,26 +30,28 @@ module RSMP
           return false if got != want
         end
       end
+      true
+    end
 
-      # match rvs items
-      if @matcher['rvs']
-        matcher_rvs = @matcher['rvs']
-        message_rvs = message.attributes['rvs']
-        return false unless message_rvs
-        return false unless matcher_rvs.all? do |matcher_item|
-          return false unless message_rvs.any? do |message_item|
-            next message_item['n'] == matcher_item['n'] && message_item['v'] == matcher_item['v']
-          end
-          next true
+    def rvs_attributes_match?(message)
+      return true unless @matcher['rvs']
+
+      matcher_rvs = @matcher['rvs']
+      message_rvs = message.attributes['rvs']
+      return false unless message_rvs
+
+      matcher_rvs.all? do |matcher_item|
+        message_rvs.any? do |message_item|
+          message_item['n'] == matcher_item['n'] && message_item['v'] == matcher_item['v']
         end
       end
-      true
     end
 
+    public
+
     # return a string that describes what we're collecting
     def describe_matcher
-      "#{describe_num_and_type} #{ {component: @options[:component]}.merge(@matcher).compact }"
+      "#{describe_num_and_type} #{{ component: @options[:component] }.merge(@matcher).compact}"
     end
-
   end
-end
+end

data/lib/rsmp/collect/alarm_matcher.rb

@@ -1,9 +1,9 @@
 module RSMP
   # Match a specific alarm
   class AlarmMatcher < Matcher
-    # Match an alarm value against a matcher
-    def match? item
+    def match?(item)
       return false if @want['n'] && @want['n'] != item['n']
+
       if @want['v'].is_a? Regexp
         return false if item['v'] !~ @want['v']
       elsif @want['v']
@@ -12,4 +12,4 @@ module RSMP
       true
     end
   end
-end
+end

data/lib/rsmp/collect/collector/logging.rb

@@ -0,0 +1,17 @@
+module RSMP
+  class Collector
+    module Logging
+      def log_start
+        @distributor.log "#{identifier}: Waiting for #{describe_matcher}".strip, level: :collect
+      end
+
+      def log_incomplete
+        @distributor.log "#{identifier}: #{describe_progress}", level: :collect
+      end
+
+      def log_complete
+        @distributor.log "#{identifier}: Done", level: :collect
+      end
+    end
+  end
+end

data/lib/rsmp/collect/collector/reporting.rb

@@ -0,0 +1,44 @@
+module RSMP
+  class Collector
+    # Progress reporting and description methods for collectors
+    module Reporting
+      # return a string describing the types of messages we're collecting
+      def describe_types
+        [@filter&.type].flatten.join('/')
+      end
+
+      # return a string that describes whe number of messages, and type of message we're collecting
+      def describe_num_and_type
+        if @num && @num > 1
+          "#{@num} #{describe_types}s"
+        else
+          describe_types
+        end
+      end
+
+      # return a string that describes the attributes that we're looking for
+      def describe_matcher
+        h = { component: @filter&.component }.compact
+        if h.empty?
+          describe_num_and_type
+        else
+          "#{describe_num_and_type} #{h}"
+        end
+      end
+
+      # Build a string describing how far progress reached before timeout
+      def describe_progress
+        str = "#{@title.capitalize} #{identifier} "
+        str << "in response to #{@m_id} " if @m_id
+        str << "timed out after #{@timeout}s, "
+        str << "reaching #{@messages.size}/#{@num}"
+        str
+      end
+
+      # get a short id in hex format, identifying ourself
+      def identifier
+        "Collect #{object_id.to_s(16)}"
+      end
+    end
+  end
+end

data/lib/rsmp/collect/collector/status.rb

@@ -0,0 +1,34 @@
+module RSMP
+  class Collector
+    # Status predicate methods for collectors
+    module Status
+      def collecting?
+        @status == :collecting
+      end
+
+      def ok?
+        @status == :ok
+      end
+
+      def timeout?
+        @status == :timeout
+      end
+
+      def ready?
+        @status == :ready
+      end
+
+      def cancelled?
+        @status == :cancelled
+      end
+
+      def ingoing?
+        @ingoing == true
+      end
+
+      def outgoing?
+        @outgoing == true
+      end
+    end
+  end
+end