rsmp 0.1.0

data/lib/rsmp/component.rb

@@ -0,0 +1,65 @@
+module RSMP
+  class Component
+    attr_reader :c_id, :alarms, :statuses, :aggregated_status, :aggregated_status_bools, :grouped
+
+    AGGREGATED_STATUS_KEYS = [ :local_control,
+                               :communication_distruption,
+                               :high_priority_alarm,
+                               :medium_priority_alarm,
+                               :low_priority_alarm,
+                               :normal,
+                               :rest,
+                               :not_connected ]
+
+    def initialize node:, id:, grouped:
+      @c_id = id
+      @node = node
+      @grouped = grouped
+      @alarms = {}
+      @statuses = {}
+      clear_aggregated_status
+    end
+
+    def clear_aggregated_status
+      @aggregated_status = []
+      @aggregated_status_bools = Array.new(8,false)
+    end
+
+    def set_aggregated_status status
+      status = [status] if status.is_a? Symbol
+      raise InvalidArgument unless status.is_a? Array
+      input = status & AGGREGATED_STATUS_KEYS
+      if input != @aggregated_status
+        AGGREGATED_STATUS_KEYS.each_with_index do |key,index|
+          @aggregated_status_bools[index] = status.include?(key)
+        end
+        aggrated_status_changed
+      end
+    end
+
+    def set_aggregated_status_bools status
+      raise InvalidArgument unless status.is_a? Array
+      raise InvalidArgument unless status.size == 8
+      if status != @aggregated_status_bools
+        @aggregated_status = []
+        AGGREGATED_STATUS_KEYS.each_with_index do |key,index|
+          on = status[index] == true
+          @aggregated_status_bools[index] = on
+          @aggregated_status << key if on
+        end
+        aggrated_status_changed
+      end
+    end
+
+    def aggrated_status_changed
+      @node.aggrated_status_changed self
+    end
+ 
+    def alarm code:, status:
+    end
+
+    def status code:, value:
+    end
+
+  end
+end

data/lib/rsmp/error.rb

@@ -0,0 +1,44 @@
+module RSMP
+	class Error < StandardError
+	end
+
+	class InvalidPacket < Error
+	end
+
+	class MalformedMessage < Error
+	end
+
+	class SchemaError < Error
+	end
+
+	class InvalidMessage < Error
+	end
+
+	class UnknownMessage < Error
+	end
+
+	class MissingAcknowledgment < Error
+	end
+
+	class MissingWatchdog < Error
+	end
+
+	class MissingAcknowledgment < Error
+	end
+
+	class MissingAttribute < InvalidMessage
+	end
+
+	class FatalError < Error
+	end
+
+	class NotReady < Error
+	end
+
+	class TimeoutError < Error
+	end
+
+	class ConnectionError < Error
+	end
+
+end

data/lib/rsmp/logger.rb

@@ -0,0 +1,153 @@
+module RSMP
+  class Logger
+
+    def initialize settings
+      defaults = {
+        'active'=>false,
+        'author'=>false,
+        'color'=>true,
+        'site_id'=>true,
+        'component'=>false,
+        'level'=>false,
+        'ip'=>false,
+        'index'=>false,
+        'timestamp'=>true,
+        'json'=>false,
+        'debug'=>false,
+        'statistics'=>false
+      }
+      @settings = defaults.merge settings
+      @muted = {}
+    end
+
+    def mute ip, port
+      @muted["#{ip}:#{port}"] = true
+    end
+
+    def unmute ip, port
+      @muted.delete "#{ip}:#{port}"
+    end
+
+    def unmute_all
+      @muted = {}
+    end
+
+    def output? item, force=false
+      return false if item[:ip] && item[:port] && @muted["#{item[:ip]}:#{item[:port]}"]
+      return false if @settings["active"] == false && force != true
+      return false if @settings["info"] == false && item[:level] == :info
+      return false if @settings["debug"] != true && item[:level] == :debug
+      return false if @settings["statistics"] != true && item[:level] == :statistics
+
+      if item[:message]
+        type = item[:message].type
+        ack = type == "MessageAck" || type == "MessageNotAck"
+        if @settings["watchdogs"] == false
+          return false if type == "Watchdog"
+          if ack
+            return false if item[:message].original && item[:message].original.type == "Watchdog"
+          end
+        end
+        return false if ack && @settings["acknowledgements"] == false && 
+          [:not_acknowledged,:warning,:error].include?(item[:level]) == false
+      end
+      true
+    end
+
+    def output level, str
+      return if str.empty? || /^\s+$/.match(str)
+      streams = [$stdout]
+      #streams << $stderr if level == :error
+      str = colorize level, str
+      streams.each do |stream|
+        stream.puts str
+      end
+    end
+
+    def colorize level, str
+      #p String.color_samples
+      if @settings["color"] == false || @settings["color"] == nil
+        str
+      elsif @settings["color"] == true
+        case level
+        when  :error
+          str.colorize(:red)
+        when :warning
+          str.colorize(:light_yellow)
+        when :not_acknowledged
+          str.colorize(:cyan)
+        when :log
+          str.colorize(:light_blue)
+        when :statistics
+          str.colorize(:light_black)
+        else
+          str
+        end
+      else
+        if level == :nack || level == :warning || level == :error
+          str.colorize(@settings["color"]).bold
+        else
+          str.colorize @settings["color"]
+        end
+      end
+    end
+
+    def log item, force:false 
+      if output?(item, force)
+        output item[:level], build_output(item) 
+      end
+    end
+
+    def self.shorten_message_id m_id, length=4
+      if m_id
+        m_id[0..length-1].ljust(length)
+      else
+        ' '*length
+      end
+    end 
+
+    def dump archive, force:false
+      archive.items.each do |item|
+        log item, force:force
+      end
+    end
+
+    private
+    
+    def build_output item
+      parts = []
+      parts << item[:index].to_s.ljust(7) if @settings["index"] == true
+      parts << item[:author].to_s.ljust(13) if @settings["author"] == true
+      parts << item[:timestamp].to_s.ljust(24) unless @settings["timestamp"] == false
+      parts << item[:ip].to_s.ljust(22) unless @settings["ip"] == false
+      parts << item[:site_id].to_s.ljust(13) unless @settings["site_id"] == false
+      parts << item[:component_id].to_s.ljust(18) unless @settings["component"] == false
+      
+      directions = {in:"-->",out:"<--"}
+      parts << directions[item[:direction]].to_s.ljust(4) unless @settings["direction"] == false
+
+      parts << item[:level].to_s.capitalize.ljust(7) unless @settings["level"] == false
+
+      
+      unless @settings["id"] == false
+        length = 4
+        if item[:message]
+          parts << Logger.shorten_message_id(item[:message].m_id,length)+' '
+        else
+          parts << " "*(length+1)
+        end
+      end
+      parts << item[:str].to_s.strip unless @settings["text"] == false
+      parts << item[:message].json unless @settings["json"] == false || item[:message] == nil
+
+      if item[:exception]
+        parts << "#{item[:exception].class.to_s}\n"
+        parts << item[:exception].backtrace.join("\n")
+      end
+
+      out = parts.join(' ').chomp(' ')
+      out
+    end
+
+  end
+end

data/lib/rsmp/message.rb

@@ -0,0 +1,313 @@
+# rsmp messages
+module RSMP
+  class Message
+
+    attr_reader :now, :attributes, :out, :timestamp
+    attr_accessor :json, :direction
+
+    def self.load_schemas
+      # path to files in submodule folder
+      schema_path = File.join(File.dirname(__dir__),'rsmp_schema','schema')
+      @@schemas = {}
+
+      core_schema_path = File.join(schema_path,'core','rsmp.json')
+      @@schemas['core'] = JSONSchemer.schema( Pathname.new(core_schema_path) )
+
+      tlc_schema_path = File.join(schema_path,'tlc','sxl.json')
+      @@schemas['traffic_light_controller'] = JSONSchemer.schema( Pathname.new(tlc_schema_path) )
+  
+      @@schemas
+    end
+
+    def self.get_schema sxl = 'core'
+      schema = @@schemas[sxl]
+      raise SchemaError.new("Unknown schema #{sxl}") unless schema
+      schema
+    end
+
+    @@schemas = load_schemas
+
+
+    def self.parse_attributes packet
+      raise ArgumentError unless packet
+      JSON.parse packet
+    rescue JSON::ParserError
+      raise InvalidPacket, bin_to_chars(packet)
+    end
+
+    def self.build attributes, packet
+      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 "Watchdog"
+        message = Watchdog.new attributes
+      when "Alarm"
+        message = Alarm.new 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.json = packet
+      message.direction = :in
+      message
+    end
+
+    def type
+      @attributes["type"]
+    end
+
+    def m_id
+      @attributes["mId"]
+    end
+
+    def m_id_short
+      @attributes["mId"][0..3]
+    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
+      end
+      @attributes[key]
+    end
+
+    def self.bin_to_chars(s)
+      out = s.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]}"
+      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
+    end
+
+    def initialize attributes = {}
+      @timestamp = RSMP.now_object
+      @attributes = { "mType"=> "rSMsg" }.merge attributes
+
+      ensure_message_id
+    end
+
+    def ensure_message_id
+      # if message id is empty, generate a new one
+      @attributes["mId"] ||= SecureRandom.uuid()
+    end
+
+    def validate
+      unless Message.get_schema.valid? attributes
+        errors = Message.get_schema.validate attributes
+        error_string = errors.map do |item|
+          [item['data_pointer'],item['type'],item['details']].compact.join(' ')
+        end.join(", ")
+        raise SchemaError.new error_string
+      end
+    end
+
+    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
+    end
+
+    def valid?
+      true
+    end
+
+    def generate_json
+      @json = JSON.generate @attributes
+
+      # wrap json with a form feed to create an rsmp packet,
+      #as required by the rsmp specification
+      @out = "#{@json}"
+    end
+
+  end
+
+  class Malformed < Message
+    def initialize attributes = {}
+      # don't call super, just copy (potentially invalid) attributes
+      @attributes = {}
+      @invalid_attributes = attributes
+    end
+  end
+
+  class Version < Message
+    def initialize attributes = {}
+      super({
+        "type" => "Version",
+      }.merge attributes)
+    end
+
+    def validate
+      super &&
+      @attributes["RSMP"].is_a?(Array) && @attributes["RSMP"].size >= 1
+    end
+
+    def versions
+      attribute("RSMP").map{ |item| item["vers"] }
+    end
+  end
+
+  class Unknown < Message
+  end
+
+  class AggregatedStatus < Message 
+    def initialize attributes = {}
+      super({
+        "type" => "AggregatedStatus",
+      }.merge attributes)
+    end
+  end
+
+  class Alarm < Message
+    def initialize attributes = {}
+      super({
+        "type" => "Alarm",
+      }.merge attributes)
+    end
+  end
+
+  class Watchdog < Message
+    def initialize attributes = {}
+      super({
+        "type" => "Watchdog",
+      }.merge attributes)
+    end
+  end
+
+  class MessageAcking < Message
+    attr_reader :original
+
+    def self.build_from message
+      return new({
+        "oMId" => message.attributes["mId"]
+      })
+    end
+
+    def original= message
+      raise InvalidArgument unless message
+      @original = message
+    end
+
+    def validate_id
+      true
+    end
+  end
+
+  class MessageAck < MessageAcking
+    def initialize attributes = {}
+      super({
+        "type" => "MessageAck",
+      }.merge attributes)
+    end
+
+    def ensure_message_id
+      # Ack and NotAck does not have a mId
+    end
+  end
+
+  class MessageNotAck < MessageAcking
+    def initialize attributes = {}
+      super({
+        "type" => "MessageNotAck",
+        "rea" => "Unknown reason"
+      }.merge attributes)
+      @attributes.delete "mId"
+   end
+  end
+
+  class CommandRequest < Message
+    def initialize attributes = {}
+      super({
+        "type" => "CommandRequest",
+      }.merge attributes)
+    end
+  end
+
+  class CommandResponse < Message
+    def initialize attributes = {}
+      super({
+        "type" => "CommandResponse",
+      }.merge attributes)
+    end
+  end
+
+  class StatusRequest < Message
+    def initialize attributes = {}
+      super({
+        "type" => "StatusRequest",
+      }.merge attributes)
+    end
+  end
+
+  class StatusResponse < Message
+    def initialize attributes = {}
+      super({
+        "type" => "StatusResponse",
+      }.merge attributes)
+    end
+  end
+
+  class StatusSubscribe < Message
+    def initialize attributes = {}
+      super({
+        "type" => "StatusSubscribe",
+      }.merge attributes)
+    end
+  end
+
+  class StatusUnsubscribe < Message
+    def initialize attributes = {}
+      super({
+        "type" => "StatusUnsubscribe",
+      }.merge attributes)
+    end
+  end
+
+  class StatusUpdate < Message
+    def initialize attributes = {}
+      super({
+        "type" => "StatusUpdate",
+      }.merge attributes)
+    end
+  end
+
+end

data/lib/rsmp/node.rb

@@ -0,0 +1,53 @@
+# RSMP site
+#
+# Handles a single connection to a supervisor.
+# We connect to the supervisor.
+
+module RSMP
+  class Node < Base
+    attr_reader :archive, :logger, :task
+
+    def initialize options
+      super options
+    end
+
+    def start
+      starting
+      Async do |task|
+        task.annotate self.class
+        @task = task
+        start_action
+      end
+    rescue Errno::EADDRINUSE => e
+      log "Cannot start: #{e.to_s}", level: :error
+    rescue SystemExit, SignalException, Interrupt
+      @logger.unmute_all
+      exiting
+    end
+
+    def stop
+      @task.stop if @task
+    end
+
+    def restart
+      stop
+      start
+    end
+
+    def exiting
+      log "Exiting", level: :info
+    end
+
+    def check_required_settings settings, required
+      raise ArgumentError.new "Settings is empty" unless settings
+      required.each do |setting|
+        raise ArgumentError.new "Missing setting: #{setting}" unless settings.include? setting.to_s
+      end 
+    end
+
+    def author
+      site_id
+    end
+
+  end
+end