rsmp 0.1.17 → 0.1.30

data/lib/rsmp/collector.rb

@@ -0,0 +1,102 @@
+# 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, :messages, :done
+
+    def initialize proxy, options={}
+      super proxy, options
+      @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
+
+    def collect_for task, duration
+      siphon do
+        task.sleep duration
+      end
+    end
+
+    def collect task, options={}, &block
+      @num = options[:num] if options[:num]
+      @options[:timeout] = options[:timeout] if options[:timeout]
+      @block = block
+
+      listen do
+        task.with_timeout(@options[:timeout]) do
+          @condition.wait
+        end
+      end
+
+      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
+      @message.clear
+      @done = false
+    end
+
+    def notify message
+      raise ArgumentError unless message
+      return true if @done
+      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
+        end
+      end
+    end
+
+    def matches? message
+      raise ArgumentError unless message
+
+      if @options[:type]
+        return false if message == nil
+        if @options[:type].is_a? Array
+          return false unless @options[:type].include? message.type
+        else
+          return false unless message.type == @options[:type]
+        end
+      end
+      if @options[:component]
+        return false if message.attributes['cId'] && message.attributes['cId'] != @options[:component]
+      end
+      if @block
+        return false if @block.call(message) == false
+      end
+      true
+    end
+  end
+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,
@@ -23,6 +25,7 @@ module RSMP
     def clear_aggregated_status
       @aggregated_status = []
       @aggregated_status_bools = Array.new(8,false)
+      @aggregated_status_bools[5] = true
     end
 
     def set_aggregated_status status

data/lib/rsmp/{site_base.rb → components.rb}

@@ -1,10 +1,10 @@
 # Things shared between sites and site proxies
 
 module RSMP
-  module SiteBase
+  module Components
     attr_reader :components
     
-    def initialize_site
+    def initialize_components
       @components = {}
     end
 
@@ -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/error.rb

@@ -23,7 +23,7 @@ module RSMP
 	class MissingWatchdog < Error
 	end
 
-	class MissingAcknowledgment < Error
+	class MessageRejected < Error
 	end
 
 	class MissingAttribute < InvalidMessage

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