rsmp 0.37.0 → 0.39.0

data/lib/rsmp/message.rb

@@ -2,72 +2,68 @@ require 'rsmp_schema'
 
 # rsmp messages
 module RSMP
+  # Base RSMP message class used to represent parsed and built messages.
   class Message
     include Inspect
 
-    attr_reader :now, :attributes, :out
-    attr_reader :timestamp # this is an internal timestamp recording when we receive/send
+    attr_reader :now, :attributes, :out, :timestamp # this is an internal timestamp recording when we receive/send
     attr_accessor :json, :direction
 
     def self.make_m_id
-      SecureRandom.uuid()
+      SecureRandom.uuid
     end
 
-    def self.parse_attributes json
+    def self.parse_attributes(json)
       raise ArgumentError unless json
+
       JSON.parse json
     rescue JSON::ParserError
       raise InvalidPacket, bin_to_chars(json)
     end
 
-    def self.build attributes, json
+    def self.build(attributes, json)
       validate_message_type attributes
-      case attributes["type"]
-      when "MessageAck"
-        message = MessageAck.new attributes
-      when "MessageNotAck"
-        message = MessageNotAck.new attributes
-      when "Version"
-        message = Version.new attributes
-      when "AggregatedStatus"
-        message = AggregatedStatus.new attributes
-      when "AggregatedStatusRequest"
-        message = AggregatedStatusRequest.new attributes
-      when "Watchdog"
-        message = Watchdog.new attributes
-      when "Alarm"
-        message = self.build_alarm attributes
-      when "CommandRequest"
-        message = CommandRequest.new attributes
-      when "CommandResponse"
-        message = CommandResponse.new attributes
-      when "StatusRequest"
-        message = StatusRequest.new attributes
-      when "StatusResponse"
-        message = StatusResponse.new attributes
-      when "StatusSubscribe"
-        message = StatusSubscribe.new attributes
-      when "StatusUnsubscribe"
-        message = StatusUnsubscribe.new attributes
-      when "StatusUpdate"
-        message = StatusUpdate.new attributes
-      else
-        message = Unknown.new attributes
-      end
+      message = create_message_instance(attributes)
       message.json = json
       message.direction = :in
       message
     end
 
-    def self.build_alarm attributes
-      case attributes["aSp"]
+    def self.message_types
+      {
+        'MessageAck' => MessageAck,
+        'MessageNotAck' => MessageNotAck,
+        'Version' => Version,
+        'AggregatedStatus' => AggregatedStatus,
+        'AggregatedStatusRequest' => AggregatedStatusRequest,
+        'Watchdog' => Watchdog,
+        'CommandRequest' => CommandRequest,
+        'CommandResponse' => CommandResponse,
+        'StatusRequest' => StatusRequest,
+        'StatusResponse' => StatusResponse,
+        'StatusSubscribe' => StatusSubscribe,
+        'StatusUnsubscribe' => StatusUnsubscribe,
+        'StatusUpdate' => StatusUpdate
+      }
+    end
+
+    def self.create_message_instance(attributes)
+      type = attributes['type']
+      return build_alarm(attributes) if type == 'Alarm'
+
+      klass = message_types[type] || Unknown
+      klass.new(attributes)
+    end
+
+    def self.build_alarm(attributes)
+      case attributes['aSp']
       when /^Issue$/i
         AlarmIssue.new attributes
       when /^Request$/i
         AlarmRequest.new attributes
       when /^Acknowledge$/i
         if attributes['ack'] =~ /^acknowledged$/i
-        AlarmAcknowledged.new attributes
+          AlarmAcknowledged.new attributes
         else
           AlarmAcknowledge.new attributes
         end
@@ -87,84 +83,97 @@ module RSMP
     end
 
     def type
-      @attributes["type"]
+      @attributes['type']
     end
 
     def m_id
-      @attributes["mId"]
+      @attributes['mId']
     end
 
-    def self.shorten_m_id m_id, length=4
-      m_id[0..length-1]
+    def self.shorten_m_id(m_id, length = 4)
+      m_id[0..(length - 1)]
     end
 
     def m_id_short
-      Message.shorten_m_id @attributes["mId"]
+      Message.shorten_m_id @attributes['mId']
     end
 
-    def attribute key
-      unless @attributes.key? key # note that this is not the same as @attributes[key] when
-        maybe = @attributes.find { |k,v| k.downcase == key.downcase }
-        if maybe
-          raise MissingAttribute.new "attribute '#{maybe.first}' should be named '#{key}'"
-        else
-          raise MissingAttribute.new "missing attribute '#{key}'"
-        end
+    def attribute(key)
+      unless @attributes.key? key # NOTE: that this is not the same as @attributes[key] when
+        maybe = @attributes.find { |k, _v| k.downcase == key.downcase }
+        raise MissingAttribute, "attribute '#{maybe.first}' should be named '#{key}'" if maybe
+
+        raise MissingAttribute, "missing attribute '#{key}'"
+
       end
       @attributes[key]
     end
 
-    def self.bin_to_chars(s)
-      out = s.gsub(/[^[:print:]]/i, '.')
+    def self.bin_to_chars(str)
+      out = str.gsub(/[^[:print:]]/i, '.')
       max = 120
       if out.size <= max
         out
       else
-        mid = " ... "
-        length = (max-mid.size)/2 - 1
-        "#{out[0..length]} ... #{out[-length-1..-1]}"
+        mid = ' ... '
+        length = ((max - mid.size) / 2) - 1
+        "#{out[0..length]} ... #{out[(-length - 1)..]}"
       end
     end
 
-    def self.validate_message_type attributes
-      raise MalformedMessage.new("JSON must be a Hash, got #{attributes.class} ") unless attributes.is_a?(Hash)
-      raise MalformedMessage.new("'mType' is missing") unless attributes["mType"]
-      raise MalformedMessage.new("'mType' must be a String, got #{attributes["mType"].class}") unless attributes["mType"].is_a? String
-      raise MalformedMessage.new("'mType' must be 'rSMsg', got '#{attributes["mType"]}'") unless attributes["mType"] == "rSMsg"
-      raise MalformedMessage.new("'type' is missing") unless attributes["type"]
-      raise MalformedMessage.new("'type' must be a String, got #{attributes["type"].class}") unless attributes["type"].is_a? String
+    def self.validate_message_type(attributes)
+      validate_attributes_structure(attributes)
+      validate_mtype_field(attributes)
+      validate_type_field(attributes)
     end
 
-    def initialize attributes = {}
-      @timestamp = Time.now   # this timestamp is for internal use, and does not use the clock
-                              # in the node, which can be set by an rsmp supervisor
+    def self.validate_attributes_structure(attributes)
+      raise MalformedMessage, "JSON must be a Hash, got #{attributes.class} " unless attributes.is_a?(Hash)
+    end
 
-      @attributes = { "mType"=> "rSMsg" }.merge attributes
+    def self.validate_mtype_field(attributes)
+      mtype = attributes['mType']
+      raise MalformedMessage, "'mType' is missing" unless mtype
+      raise MalformedMessage, "'mType' must be a String, got #{mtype.class}" unless mtype.is_a?(String)
+      raise MalformedMessage, "'mType' must be 'rSMsg', got '#{mtype}'" unless mtype == 'rSMsg'
+    end
+
+    def self.validate_type_field(attributes)
+      type = attributes['type']
+      raise MalformedMessage, "'type' is missing" unless type
+      raise MalformedMessage, "'type' must be a String, got #{type.class}" unless type.is_a?(String)
+    end
+
+    def initialize(attributes = {})
+      @timestamp = Time.now # this timestamp is for internal use, and does not use the clock
+      # in the node, which can be set by an rsmp supervisor
+
+      @attributes = { 'mType' => 'rSMsg' }.merge attributes
 
       ensure_message_id
     end
 
     def ensure_message_id
       # if message id is empty, generate a new one
-      @attributes["mId"] ||= Message.make_m_id
+      @attributes['mId'] ||= Message.make_m_id
     end
 
-    def validate schemas
+    def validate(schemas)
       errors = RSMP::Schema.validate attributes, schemas
-      if errors
-        error_string = errors.map {|item| item.reject {|e| e=='' } }.compact.join(', ').strip
-        err = SchemaError.new "#{error_string}"
-        err.schemas = schemas
-        raise err
-      end
+      return unless errors
+
+      error_string = errors.map { |item| item.reject { |e| e == '' } }.compact.join(', ').strip
+      err = SchemaError.new error_string.to_s
+      err.schemas = schemas
+      raise err
     end
 
-    def validate_type
-      @attributes["mType"] == "rSMsg"
+    def validate_type?
+      @attributes['mType'] == 'rSMsg'
     end
 
-    def validate_id
-       (@attributes["mId"] =~ /[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}/i) != nil
+    def validate_id?
+      !(@attributes['mId'] =~ /[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}/i).nil?
     end
 
     def valid?
@@ -181,165 +190,186 @@ module RSMP
       }
       @json = JSON.generate @attributes, options
     end
-
   end
 
+  # Represents a malformed message with invalid attributes.
   class Malformed < Message
-    def initialize attributes = {}
+    # rubocop:disable Lint/MissingSuper
+    def initialize(attributes = {})
       # don't call super, just copy (potentially invalid) attributes
       @attributes = {}
       @invalid_attributes = attributes
     end
+    # rubocop:enable Lint/MissingSuper
   end
 
+  # Version message, lists supported versions and SXL information.
   class Version < Message
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "type" => "Version",
+        'type' => 'Version'
       }.merge attributes)
     end
 
     def versions
-      attribute("RSMP").map{ |item| item["vers"] }
+      attribute('RSMP').map { |item| item['vers'] }
     end
   end
 
+  # Unknown message type wrapper.
   class Unknown < Message
   end
 
+  # AggregatedStatus message type.
   class AggregatedStatus < Message
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "type" => "AggregatedStatus",
+        'type' => 'AggregatedStatus'
       }.merge attributes)
     end
   end
 
+  # AggregatedStatusRequest message type.
   class AggregatedStatusRequest < Message
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "type" => "AggregatedStatusRequest",
+        'type' => 'AggregatedStatusRequest'
       }.merge attributes)
     end
   end
 
+  # Alarm base message type.
   class Alarm < Message
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "type" => "Alarm",
-        "ntsOId" => '',
-        "xNId" => '',
-        "xACId" => '',
-        "xNACId" => ''
+        'type' => 'Alarm',
+        'ntsOId' => '',
+        'xNId' => '',
+        'xACId' => '',
+        'xNACId' => ''
       }.merge attributes)
     end
 
-    def differ? from
-      %w{aSp aCId ack aS sS aTs cat pri}.each do |key|
+    def differ?(from)
+      %w[aSp aCId ack aS sS aTs cat pri].each do |key|
         return true if attribute(key).downcase != from.attribute(key).downcase
       end
       return true if attribute('rvs') != from.attribute('rvs')
+
       false
     end
   end
 
+  # Alarm issue specialization.
   class AlarmIssue < Alarm
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "aSp" => "Issue"
+        'aSp' => 'Issue'
       }.merge attributes)
     end
   end
 
+  # Alarm request specialization.
   class AlarmRequest < Alarm
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "aSp" => "Request",
+        'aSp' => 'Request'
       }.merge attributes)
     end
   end
 
+  # Alarm acknowledge message.
   class AlarmAcknowledge < Alarm
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "aSp" => "Acknowledge",
+        'aSp' => 'Acknowledge'
       }.merge attributes)
     end
   end
 
+  # Alarm acknowledged (acknowledged state) message.
   class AlarmAcknowledged < Alarm
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "aSp" => "Acknowledge",
-        "ack" => "acknowledged"
+        'aSp' => 'Acknowledge',
+        'ack' => 'acknowledged'
       }.merge attributes)
     end
   end
+
+  # Alarm suspend message.
   class AlarmSuspend < Alarm
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "aSp" => "Suspend",
+        'aSp' => 'Suspend'
       }.merge attributes)
     end
   end
 
+  # Alarm suspended (suspended state) message.
   class AlarmSuspended < Alarm
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "aSp" => "Suspend",
-        "sS" => "Suspended"
+        'aSp' => 'Suspend',
+        'sS' => 'Suspended'
       }.merge attributes)
     end
   end
 
+  # Alarm resume message.
   class AlarmResume < Alarm
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "aSp" => "Resume",
+        'aSp' => 'Resume'
       }.merge attributes)
     end
   end
 
+  # Alarm resumed (not suspended) message.
   class AlarmResumed < Alarm
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "aSp" => "Suspend",
-        "sS" => "notSuspended"
+        'aSp' => 'Suspend',
+        'sS' => 'notSuspended'
       }.merge attributes)
     end
   end
 
+  # Watchdog message type.
   class Watchdog < Message
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "type" => "Watchdog",
+        'type' => 'Watchdog'
       }.merge attributes)
     end
   end
 
+  # Base class for acking messages (MessageAck / MessageNotAck).
   class MessageAcking < Message
     attr_reader :original
 
-    def self.build_from message
-      return new({
-        "oMId" => message.attributes["mId"]
-      })
+    def self.build_from(message)
+      new({
+            'oMId' => message.attributes['mId']
+          })
     end
 
-    def original= message
+    def original=(message)
       raise InvalidArgument unless message
+
       @original = message
     end
 
-    def validate_id
+    def validate_id?
       true
     end
   end
 
+  # Acknowledgement for a received message.
   class MessageAck < MessageAcking
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "type" => "MessageAck",
+        'type' => 'MessageAck'
       }.merge attributes)
     end
 
@@ -348,70 +378,77 @@ module RSMP
     end
   end
 
+  # Negative acknowledgement for a received message.
   class MessageNotAck < MessageAcking
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "type" => "MessageNotAck",
-        "rea" => "Unknown reason"
+        'type' => 'MessageNotAck',
+        'rea' => 'Unknown reason'
       }.merge attributes)
-      @attributes.delete "mId"
-   end
+      @attributes.delete 'mId'
+    end
   end
 
+  # Command request message type.
   class CommandRequest < Message
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "type" => "CommandRequest",
+        'type' => 'CommandRequest'
       }.merge attributes)
     end
   end
 
+  # Command response message type.
   class CommandResponse < Message
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "type" => "CommandResponse",
+        'type' => 'CommandResponse'
       }.merge attributes)
     end
   end
 
+  # Status request message type.
   class StatusRequest < Message
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "type" => "StatusRequest",
+        'type' => 'StatusRequest'
       }.merge attributes)
     end
   end
 
+  # Status response message type.
   class StatusResponse < Message
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "type" => "StatusResponse",
+        'type' => 'StatusResponse'
       }.merge attributes)
     end
   end
 
+  # Status subscribe message type.
   class StatusSubscribe < Message
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "type" => "StatusSubscribe",
+        'type' => 'StatusSubscribe'
       }.merge attributes)
     end
   end
 
+  # Status unsubscribe message type.
   class StatusUnsubscribe < Message
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "type" => "StatusUnsubscribe",
+        'type' => 'StatusUnsubscribe'
       }.merge attributes)
     end
   end
 
+  # Status update message type.
   class StatusUpdate < Message
-    def initialize attributes = {}
+    def initialize(attributes = {})
       super({
-        "type" => "StatusUpdate",
+        'type' => 'StatusUpdate'
       }.merge attributes)
     end
   end
-
-end
+end

data/lib/rsmp/{node.rb → node/node.rb}

@@ -1,6 +1,5 @@
-# Base class for sites and supervisors
-
 module RSMP
+  # Base class for sites and supervisors.
   class Node
     include Logging
     include Inspect
@@ -8,7 +7,7 @@ module RSMP
 
     attr_reader :archive, :logger, :task, :deferred, :error_queue, :clock, :collector
 
-    def initialize options={}
+    def initialize(options = {})
       initialize_logging options
       initialize_task
       @deferred = []
@@ -24,55 +23,57 @@ module RSMP
 
     # stop proxies, then call super
     def stop_subtasks
-      @proxies.each { |proxy| proxy.stop }
+      @proxies.each(&:stop)
       @proxies.clear
       super
     end
 
-    def ignore_errors classes, &block
-      was, @ignore_errors = @ignore_errors, [classes].flatten
+    def ignore_errors(classes)
+      was = @ignore_errors
+      @ignore_errors = [classes].flatten
       yield
     ensure
       @ignore_errors = was
     end
 
-    def distribute_error e, options={}
-      return if @ignore_errors.find { |klass| e.is_a? klass }
+    def distribute_error(error, options = {})
+      return if @ignore_errors.find { |klass| error.is_a? klass }
+
       if options[:level] == :internal
-        log ["#{e.to_s} in task: #{Async::Task.current.to_s}",e.backtrace].flatten.join("\n"), level: :error
+        log ["#{error} in task: #{Async::Task.current}", error.backtrace].flatten.join("\n"),
+            level: :error
       end
-      @error_queue.enqueue e
+      @error_queue.enqueue error
     end
 
-    def defer key, item=nil
+    def defer(key, item = nil)
       @deferred << [key, item]
     end
 
     def process_deferred
-      cloned = @deferred.clone    # clone in case do_deferred restarts the current task
+      cloned = @deferred.clone # clone in case do_deferred restarts the current task
       @deferred.clear
       cloned.each do |pair|
         do_deferred pair.first, pair.last
       end
     end
 
-    def do_deferred key,item=nil
-    end
+    def do_deferred(key, item = nil); end
 
     def clear_deferred
       @deferred.clear
     end
 
-    def check_required_settings settings, required
-      raise ArgumentError.new "Settings is empty" unless settings
+    def check_required_settings(settings, required)
+      raise ArgumentError, 'Settings is empty' unless settings
+
       required.each do |setting|
-        raise ArgumentError.new "Missing setting: #{setting}" unless settings.include? setting.to_s
+        raise ArgumentError, "Missing setting: #{setting}" unless settings.include? setting.to_s
       end
     end
 
     def author
       site_id
     end
-
   end
-end
+end