rsmp 0.1.21 → 0.1.32

data/lib/rsmp/collector.rb

@@ -1,21 +1,35 @@
-# A probe checks incoming messages and store matches
-# Once it has collected what it needs, it triggers a condition variable
-# and the client wakes up.
+# Collects matching ingoing and/or outgoing messages and
+# wakes up the client once the desired amount has been collected.
+# Can listen for ingoing and/or outgoing messages.
 
 module RSMP
   class Collector < Listener
-    attr_reader :condition, :items, :done
+
+    attr_reader :condition, :messages, :done
 
     def initialize proxy, options={}
-      #raise ArgumentError.new("timeout option is missing") unless options[:timeout]
       super proxy, options
-      @items = []
+      @ingoing = options[:ingoing] == nil ? true  : options[:ingoing]
+      @outgoing = options[:outgoing] == nil ? false : options[:outgoing]
+      @messages = []
       @condition = Async::Notification.new
       @done = false
       @options = options
       @num = options[:num]
     end
 
+    def inspect
+      "#<#{self.class.name}:#{self.object_id}, #{inspector(:@messages)}>"
+    end
+
+    def ingoing?
+      @ingoing == true
+    end
+
+    def outgoing?
+      @outgoing == true
+    end
+
     def wait
       @condition.wait
     end
@@ -31,33 +45,33 @@ module RSMP
       @options[:timeout] = options[:timeout] if options[:timeout]
       @block = block
 
-      siphon do
+      listen do
         task.with_timeout(@options[:timeout]) do
           @condition.wait
         end
       end
 
-      #if @num == 1
-      #  @items = @items.first       # if one item was requested, return item instead of array
-      #else
-      #  @items = @items.first @num  # return array, but ensure we never return more than requested
-      #end
-      #@items
+      if @num == 1
+        @messages = @messages.first       # if one message was requested, return it instead of array
+      else
+        @messages = @messages.first @num  # return array, but ensure we never return more than requested
+      end
+      @messages
     end
 
     def reset
-      @items.clear
+      @message.clear
       @done = false
     end
 
-    def notify item
-      raise ArgumentError unless item
+    def notify message
+      raise ArgumentError unless message
       return true if @done
-      return if item[:message].direction == :in && @ingoing == false
-      return if item[:message].direction == :out && @outgoing == false
-      if matches? item
-        @items << item
-        if @num && @items.size >= @num
+      return if message.direction == :in && @ingoing == false
+      return if message.direction == :out && @outgoing == false
+      if matches? message
+        @messages << message
+        if @num && @messages.size >= @num
           @done = true
           @proxy.remove_listener self
           @condition.signal
@@ -65,24 +79,22 @@ module RSMP
       end
     end
 
-    def matches? item
-      raise ArgumentError unless item
+    def matches? message
+      raise ArgumentError unless message
 
       if @options[:type]
-        return false if item[:message] == nil
+        return false if message == nil
         if @options[:type].is_a? Array
-          return false unless @options[:type].include? item[:message].type
+          return false unless @options[:type].include? message.type
         else
-          return false unless item[:message].type == @options[:type]
+          return false unless message.type == @options[:type]
         end
       end
-      return if @options[:level] && item[:level] != @options[:level]
-      return false if @options[:with_message] && !(item[:direction] && item[:message])
       if @options[:component]
-        return false if item[:message].attributes['cId'] && item[:message].attributes['cId'] != @options[:component]
+        return false if message.attributes['cId'] && message.attributes['cId'] != @options[:component]
       end
       if @block
-        return false if @block.call(item) == false
+        return false if @block.call(message) == false
       end
       true
     end

data/lib/rsmp/component.rb

@@ -1,5 +1,7 @@
 module RSMP
   class Component
+    include Inspect
+
     attr_reader :c_id, :node, :alarms, :statuses, :aggregated_status, :aggregated_status_bools, :grouped
 
     AGGREGATED_STATUS_KEYS = [ :local_control,

data/lib/rsmp/components.rb

@@ -25,7 +25,7 @@ module RSMP
     end
 
     def build_component id:, type:, settings:{}
-      Component.new id:id, node: self, grouped: true
+      Component.new id:id, node: self, grouped: type=='main'
     end
 
     def find_component component_id

data/lib/rsmp/convert/export/json_schema.rb

@@ -0,0 +1,204 @@
+# Import SXL from YAML format
+
+require 'yaml'
+require 'json'
+require 'fileutils'
+
+module RSMP
+  module Convert
+    module Export
+      module JSONSchema
+
+        @@json_options = {
+          array_nl: "\n",
+          object_nl: "\n",
+          indent: '  ',
+          space_before: ' ',
+          space: ' '
+        }
+
+        def self.output_json item
+          JSON.generate(item,@@json_options)
+        end
+
+        def self.build_value item
+          out = {}
+          
+          if item['description']
+            out["description"] = item['description']
+          end
+
+          if item['list']
+            case item['type']
+            when "boolean"
+              out["$ref"] = "../../core/definitions.json#/boolean_list"
+            when "integer", "ordinal", "unit", "scale", "long"
+              out["$ref"] = "../../core/definitions.json#/integer_list"
+            else
+              raise "Error: List of #{item['type']} is not supported: #{item.inspect}"
+            end
+
+            if item["values"]
+              value_list = item["values"].keys.join('|')
+              out['pattern'] = /(?-mix:^(#{value_list})(?:,(#{value_list}))*$)/
+            end
+
+            if item["pattern"]
+              puts "Warning: Pattern not support for lists: #{item.inspect}"
+            end
+          else
+            case item['type']
+            when "string", "base64"
+              out["type"] = "string"
+            when "boolean"
+              out["$ref"] = "../../core/definitions.json#/boolean"
+            when "timestamp"
+              out["$ref"] = "../../core/definitions.json#/timestamp"
+            when "integer", "ordinal", "unit", "scale", "long"
+              out["$ref"] = "../../core/definitions.json#/integer"
+            else
+              out["type"] = "string"
+            end
+
+            if item["values"]
+              out["enum"] = item["values"].keys.sort
+            end
+
+            if item["pattern"]
+              out["pattern"] = item["pattern"]
+            end
+          end
+
+
+          out
+        end
+
+        def self.build_item item, property_key: 'v'
+          json = { "allOf" => [ { "description" => item['description'] } ] }
+          if item['arguments']
+            json["allOf"].first["properties"] = { "n" => { "enum" => item['arguments'].keys.sort } }
+            item['arguments'].each_pair do |key,argument|
+              json["allOf"] << {
+                "if" => { "required" => ["n"], "properties" => { "n" => { "const" => key }}},
+                "then" => { "properties" => { property_key => build_value(argument) } }
+              }
+            end
+          end
+          json
+        end
+
+        def self.output_alarms out, items
+          list = items.keys.sort.map do |key|
+            {
+              "if" => { "required" => ["aCId"], "properties" => { "aCId" => { "const" => key }}},
+              "then" => { "$ref" => "#{key}.json" }
+            }
+          end
+          json = {
+            "properties" => { 
+              "aCId" => { "enum" => items.keys.sort },
+              "rvs" => { "items" => { "allOf" => list } }
+            }
+          }
+          out['alarms/alarms.json'] = output_json json
+          items.each_pair { |key,item| output_alarm out, key, item }
+        end
+
+        def self.output_alarm out, key, item
+          json = build_item item
+          out["alarms/#{key}.json"] = output_json json
+        end
+
+        def self.output_statuses out, items
+          list = [ { "properties" => { "sCI" => { "enum"=> items.keys.sort }}} ]
+          items.keys.sort.each do |key|
+            list << {
+              "if"=> { "required" => ["sCI"], "properties" => { "sCI"=> { "const"=> key }}},
+              "then" => { "$ref" => "#{key}.json" }
+            }
+          end
+          json = { "properties" => { "sS" => { "items" => { "allOf" => list }}}}
+          out['statuses/statuses.json'] = output_json json
+          items.each_pair { |key,item| output_status out, key, item }
+        end
+
+        def self.output_status out, key, item
+          json = build_item item, property_key:'s'
+          out["statuses/#{key}.json"] = output_json json
+        end
+
+        def self.output_commands out, items
+          list = [ { "properties" => { "cCI" => { "enum"=> items.keys.sort }}} ]
+          items.keys.sort.each do |key|
+            list << {
+              "if" => { "required" => ["cCI"], "properties" => { "cCI"=> { "const"=> key }}},
+              "then" => { "$ref" => "#{key}.json" }
+            }
+          end
+          json = { "items" => { "allOf" => list }}
+          out['commands/commands.json'] = output_json json
+
+          json = { "properties" => { "arg" => { "$ref" => "commands.json" }}}
+          out['commands/command_requests.json'] = output_json json
+
+          json = { "properties" => { "rvs" => { "$ref" => "commands.json" }}}
+          out['commands/command_responses.json'] = output_json json
+
+          items.each_pair { |key,item| output_command out, key, item }
+        end
+
+        def self.output_command out, key, item
+          json = build_item item
+          json["allOf"].first["properties"]['cO'] = { "const" => item['command'] }
+          out["commands/#{key}.json"] = output_json json
+        end
+
+        def self.output_root out
+          json = {
+            "description"=> "A schema validatating message against the RSMP SXL for Traffic Light Controllers",
+            "allOf" => [
+              {
+                "if" => { "required" => ["type"], "properties" => { "type" => { "const" => "CommandRequest" }}},
+                "then" => { "$ref" => "commands/command_requests.json" }
+              },
+              {
+                "if" => { "required" => ["type"], "properties" => { "type" => { "const" => "CommandResponse" }}},
+                "then" => { "$ref" => "commands/command_responses.json" }
+              },
+              {
+                "if" => { "required" => ["type"], "properties" => { "type" => { "enum" => ["StatusRequest","StatusResponse","StatusSubscribe","StatusUnsubscribe","StatusUpdate"] }}},
+                "then" => { "$ref" => "statuses/statuses.json" }
+              },
+              {
+                "if" => { "required" => ["type"], "properties" => { "type" => { "const" => "Alarm" }}},
+                "then" => { "$ref" => "alarms/alarms.json" }
+              }
+            ]
+          }
+          out["sxl.json"] = output_json json     
+        end
+
+        def self.generate sxl
+          out = {}
+          output_root out
+          output_alarms out, sxl[:alarms]
+          output_statuses out, sxl[:statuses]
+          output_commands out, sxl[:commands]
+          out
+        end
+
+        def self.write sxl, folder
+          out = generate sxl
+          out.each_pair do |relative_path,str|
+            path = File.join(folder, relative_path)
+            FileUtils.mkdir_p File.dirname(path)      # create folders if needed
+            file = File.open(path, 'w+')      # w+ means truncate or create new file 
+            file.puts str
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/rsmp/convert/import/yaml.rb

@@ -0,0 +1,38 @@
+# Import SXL from YAML format
+
+require 'yaml'
+require 'json'
+require 'fileutils'
+
+module RSMP
+  module Convert
+    module Import
+      module YAML
+
+        def self.read path
+          convert ::YAML.load_file(path)
+        end
+
+        def self.parse str
+          convert ::YAML.load(str)
+        end
+
+        def self.convert yaml
+          sxl = {
+            alarms: {},
+            statuses: {},
+            commands: {}
+          }
+
+          yaml['objects'].each_pair do |type,object|  
+            object["alarms"].each { |id,item| sxl[:alarms][id] = item }
+            object["statuses"].each { |id,item| sxl[:statuses][id] = item }
+            object["commands"].each { |id,item| sxl[:commands][id] = item }
+          end
+          sxl
+        end
+      end
+
+    end
+  end
+end

data/lib/rsmp/deep_merge.rb

@@ -0,0 +1,11 @@
+class Hash
+  def deep_merge(other_hash)
+    self.merge(other_hash) do |key, old, fresh|
+      if old.is_a?(Hash) && fresh.is_a?(Hash)
+        old.deep_merge(fresh)
+      else
+        fresh
+      end
+    end
+  end
+end

data/lib/rsmp/inspect.rb

@@ -0,0 +1,46 @@
+# Costume inspect, to reduce noise
+# 
+# Instance variables of classes starting with Async or RSMP are shown
+# with only their class name and object id, which reduces output,
+# especially for deep object structures.
+# Additionally, a list of variables to shown in short format can be passed.
+#
+# The short form is generated by using to_s() insted of inspect()
+#
+# Array#to_s and Hash#to_s usually show items, but here we show just number
+# of items, when the short form is requested.
+
+module RSMP
+  module Inspect
+
+    def inspector *short_items
+      instance_variables.map do |var_name|
+        var = instance_variable_get(var_name)
+        class_name = var.class.name
+
+        short = short_items.include?(var_name) ||
+                   class_name.start_with?('Async') ||
+                   class_name.start_with?('RSMP')
+
+        if short
+          if var.is_a? Array
+            "#{var_name}: #<#{class_name}:#{class_name.object_id}, #{var.size} items>"
+          elsif var.is_a? Hash
+            "#{var_name}: #<#{class_name}:#{class_name.object_id}, #{var.size} items>"
+          else
+            "#{var_name}: #{var.to_s}"
+          end
+        else
+          "#{var_name}: #{var.inspect}"
+        end
+      end.join(', ')
+    end
+
+    # override this if you want additional variable to be shown in the short format,
+    # or ottherwise change the inspect format
+    def inspect
+      "#<#{self.class.name}:#{self.object_id}, #{inspector}>"
+    end
+
+  end
+end

data/lib/rsmp/listener.rb

@@ -1,28 +1,18 @@
-# Receives messages from a Notifier, as long as it's
+# Receives items from a Notifier, as long as it's
 # installed as a listener.
-# Can listen for ingoing and/or outgoing messages.
 
 module RSMP
   class Listener
+    include Inspect
 
     def initialize proxy, options={}
       @proxy = proxy
-      @ingoing = options[:ingoing] == nil ? true  : options[:ingoing]
-      @outgoing = options[:outgoing] == nil ? false : options[:outgoing]
     end
 
-    def ingoing?
-      ingoing == true
+    def notify message
     end
 
-    def outgoing?
-      outgoing == true
-    end
-
-    def notify item
-    end
-
-    def siphon &block
+    def listen &block
       @proxy.add_listener self
       yield
     ensure