rsmp 0.1.13 → 0.1.29

data/lib/rsmp/cli.rb

@@ -2,106 +2,137 @@ require 'thor'
 require 'rsmp'
 
 module RSMP
-	class CLI < Thor
-
-		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 :log, :type => :string, :aliases => "-l", banner: 'Path to log file'
-		method_option :json, :type => :boolean, :aliases => "-j", banner: 'Show JSON messages in log'
-		method_option :type, :type => :string, :aliases => "-t", banner: 'Type of site: [tlc]'
-		def site
-			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
-
-			if options[:id]
-				settings['site_id'] = options[:id]
-			end
-
-		if options[:supervisors]
-			options[:supervisors].split(',').each do |supervisor|
-				settings[:supervisors] ||= []
-					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[:log]
-				log_settings['path'] = options[:log]
-			end
-
-			if options[:json]
-				log_settings['json'] = options[:json]
-			end
-
-			site_class = RSMP::Site
-			if options[:type]
-				case options[:type]
-					when 'tlc'
-						site_class = RSMP::Tlc
-					else
-						site_class = RSMP::Site
-				end
-			end
-			site_class.new(site_settings:settings, log_settings: log_settings).start
-		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 :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 = { '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
-
-			if options[:id]
-				settings['site_id'] = options[:id]
-			end
-
-			if options[:ip]
-				settings['ip'] = options[:ip]
-			end
-
-			if options[:port]
-				settings['port'] = options[:port]
-			end
-
-			if options[:log]
-				log_settings['path'] = options[:log]
-			end
-
-			if options[:json]
-				log_settings['json'] = options[:json]
-			end
-
-			RSMP::Supervisor.new(supervisor_settings:settings,log_settings:log_settings).start
-		end
-
-	end
+  class CLI < Thor
+
+    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 :log, :type => :string, :aliases => "-l", banner: 'Path to log file'
+    method_option :json, :type => :boolean, :aliases => "-j", banner: 'Show JSON messages in log'
+    method_option :type, :type => :string, :aliases => "-t", banner: 'Type of site: [tlc]'
+    def site
+      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
+
+      if options[:id]
+        settings['site_id'] = options[:id]
+      end
+
+      if options[:supervisors]
+        options[:supervisors].split(',').each do |supervisor|
+          settings['supervisors'] ||= []
+          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[:log]
+        log_settings['path'] = options[:log]
+      end
+
+      if options[:json]
+        log_settings['json'] = options[:json]
+      end
+
+      site_class = RSMP::Site
+      if options[:type]
+        case options[:type]
+          when 'tlc'
+            site_class = RSMP::Tlc
+          else
+            site_class = RSMP::Site
+        end
+      end
+      site_class.new(site_settings:settings, log_settings: log_settings).start
+    rescue RSMP::Schemer::UnknownSchemaTypeError => e
+      puts "Cannot start site: #{e}"
+    rescue RSMP::Schemer::UnknownSchemaVersionError => e
+      puts "Cannot start site: #{e}"
+    rescue Psych::SyntaxError => e
+      puts "Cannot read config file #{e}"
+    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 :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 = { '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
+
+      if options[:id]
+        settings['site_id'] = options[:id]
+      end
+
+      if options[:ip]
+        settings['ip'] = options[:ip]
+      end
+
+      if options[:port]
+        settings['port'] = options[:port]
+      end
+
+      if options[:log]
+        log_settings['path'] = options[:log]
+      end
+
+      if options[:json]
+        log_settings['json'] = options[:json]
+      end
+
+      RSMP::Supervisor.new(supervisor_settings:settings,log_settings:log_settings).start
+    rescue RSMP::ConfigurationError => e
+      puts "Cannot start supervisor: #{e}"
+    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
+      unless options[:in]
+        puts "Error: Input option missing"
+        exit
+      end
+
+      unless options[:out]
+        puts "Error: Output option missing"
+        exit
+      end
+
+      unless File.exist? options[:in]
+        puts "Error: Input path file #{options[:in]} not found"
+        exit
+      end
+
+      sxl = RSMP::Convert::Import::YAML.read options[:in]
+      RSMP::Convert::Export::JSONSchema.write sxl, options[:out]
+    end
+
+  end
 end

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,6 +1,8 @@
 module RSMP
   class Component
-    attr_reader :c_id, :alarms, :statuses, :aggregated_status, :aggregated_status_bools, :grouped
+    include Inspect
+
+    attr_reader :c_id, :node, :alarms, :statuses, :aggregated_status, :aggregated_status_bools, :grouped
 
     AGGREGATED_STATUS_KEYS = [ :local_control,
                                :communication_distruption,
@@ -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
@@ -58,11 +61,17 @@ module RSMP
     def alarm code:, status:
     end
 
-    def status code:, value:
-    end
-
     def log str, options
       @node.log str, options
     end
+
+    def handle_command command_code, arg
+      raise UnknownCommand.new "Command #{command_code} not implemented by #{self.class}"
+    end
+
+    def get_status status_code, status_name=nil
+      raise UnknownStatus.new "Status #{status_code}/#{status_name} not implemented by #{self.class}"
+    end
+
   end
 end

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
 
@@ -13,8 +13,10 @@ module RSMP
 
     def setup_components settings
       return unless settings
-      settings.each_pair do |id,settings|
-        @components[id] = build_component(id,settings)
+      settings.each_pair do |type,components_by_type|
+        components_by_type.each_pair do |id,settings|
+          @components[id] = build_component(id:id, type:type, settings:settings)
+        end
       end
     end
 
@@ -22,8 +24,8 @@ module RSMP
       @components[component.c_id] = component
     end
 
-    def build_component id, settings={}
-      Component.new id: id, node: self, grouped: true
+    def build_component id:, type:, settings:{}
+      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