rsmp 0.42.9 → 0.43.0

data/lib/rsmp/schema.rb

@@ -0,0 +1,210 @@
+require 'json_schemer'
+
+# RSMP (Road Side Message Protocol) schema validation library.
+module RSMP
+  # Provides JSON Schema validation for RSMP messages across core and SXL versions.
+  module Schema
+    @schemas = nil
+
+    def self.setup
+      @schemas = {}
+      schemas_path = File.expand_path(File.join(__dir__, '..', '..', 'schemas'))
+      Dir.glob("#{schemas_path}/*").select { |f| File.directory? f }.each do |type_path|
+        type = File.basename(type_path).to_sym
+        load_schema_type type, type_path
+      end
+    end
+
+    # load an schema from a folder. schemas are organized by version, and contain
+    # json schema files, with the entry point being rsmp.jspon, eg:
+    # tlc
+    #   1.0.7
+    #     rsmp.json
+    #     other jon schema files...
+    #   1.0.8
+    #   ...
+    #
+    #  an error is raised if the schema type already exists, and force is not set to true
+    def self.load_schema_type(type, type_path, force: false)
+      raise "Schema type #{type} already loaded" if @schemas[type] && force != true
+
+      @schemas[type] = {}
+      Dir.glob("#{type_path}/*").select { |f| File.directory? f }.each do |schema_path|
+        version = File.basename(schema_path)
+        file_path = File.join(schema_path, 'rsmp.json')
+        next unless File.exist? file_path
+
+        @schemas[type][version] = JSONSchemer.schema(
+          Pathname.new(File.join(schema_path, 'rsmp.json'))
+        )
+      end
+    end
+
+    # remove a schema type
+    def self.remove_schema_type(type)
+      schemas.delete type
+    end
+
+    # get schemas types
+    def self.schema_types
+      schemas.keys
+    end
+
+    # get all schemas, oganized by type and version
+    def self.schemas
+      raise 'No schemas available, perhaps Schema.setup was never called?' unless @schemas
+
+      @schemas
+    end
+
+    # get array of core schema versions
+    def self.core_versions
+      versions :core
+    end
+
+    # get earliest core schema version
+    def self.earliest_core_version
+      earliest_version :core
+    end
+
+    # get latesty core schema version
+    def self.latest_core_version
+      latest_version :core
+    end
+
+    # get array of  schema versions for a particular schema type
+    def self.versions(type)
+      schemas = find_schemas!(type).keys
+      sort_versions(schemas)
+    end
+
+    # get earliest schema version for a particular schema type
+    def self.earliest_version(type)
+      schemas = find_schemas!(type).keys
+      sort_versions(schemas).first
+    end
+
+    # get latest schema version for a particular schema type
+    def self.latest_version(type)
+      schemas = find_schemas!(type).keys
+      sort_versions(schemas).last
+    end
+
+    # validate an rsmp messages using a schema object
+    def self.validate_using_schema(message, schema)
+      raise ArgumentError, 'message missing' unless message
+      raise ArgumentError, 'schema missing' unless schema
+
+      if schema.valid? message
+        []
+      else
+        schema.validate(message).map do |item|
+          [item['data_pointer'], item['type'], item['details']]
+        end
+      end
+    end
+
+    # sort version strings
+    def self.sort_versions(versions)
+      versions.sort_by { |k| Gem::Version.new(k) }
+    end
+
+    # find schemas versions for particular schema type
+    # return nil if type not found
+    def self.find_schemas(type)
+      raise ArgumentError, 'type missing' unless type
+
+      @schemas[type.to_sym]
+    end
+
+    # find schemas versions for particular schema type
+    # raise error if not found
+    def self.find_schemas!(type)
+      schemas = find_schemas type
+      raise UnknownSchemaTypeError, "Unknown schema type #{type}" unless schemas
+
+      schemas
+    end
+
+    # find schema for a particular schema and version
+    # return nil if not found
+    def self.find_schema(type, version, options = {})
+      raise ArgumentError, 'version missing' unless version
+
+      version = sanitize_version version if options[:lenient]
+      if version
+        schemas = find_schemas type
+        return schemas[version] if schemas
+      end
+      nil
+    end
+
+    # get major.minor.patch part of a version string, where patch is optional
+    # ignore trailing characters, e.g.
+    #   3.1.3.32A => 3.1.3
+    #   3.1A3r3 >= 3.1
+    # return nil if string doesn't match
+    def self.sanitize_version(version)
+      # match normal semver z.y.z format
+      if (matched = /^\d+\.\d+\.\d+/.match(version))
+        matched.to_s
+      # match x.y format, and add patch version zero to get z.y.0
+      elsif (matched = /^\d+\.\d+/.match(version))
+        "#{matched}.0"
+      end
+    end
+
+    # find schema for a particular schema and version
+    # raise error if not found
+    def self.find_schema!(type, version, options = {})
+      schema = find_schema type, version, options
+      raise ArgumentError, 'version missing' unless version
+
+      version = sanitize_version version if options[:lenient]
+      if version
+        schemas = find_schemas! type
+        schema = schemas[version]
+        return schema if schema
+      end
+      raise UnknownSchemaVersionError, "Unknown schema version #{type} #{version}"
+    end
+
+    # true if a particular schema type and version found
+    def self.schema?(type, version, options = {})
+      find_schema(type, version, options) != nil
+    end
+
+    # return a catalogue of statuses for a particular schema type and version
+    # returns a hash of { status_code_id_sym => [arg_name_sym, ...] }
+    # raises an error if the schema type/version is not found, or has no sxl.yaml
+    def self.status_catalogue(type, version)
+      find_schema! type, version
+      schemas_path = File.expand_path(File.join(__dir__, '..', '..', 'schemas'))
+      yaml_path = File.join(schemas_path, type.to_s, version, 'sxl.yaml')
+      raise "No sxl.yaml for #{type} #{version}" unless File.exist?(yaml_path)
+
+      sxl = RSMP::Convert::Import::YAML.read(yaml_path)
+      sxl[:statuses].transform_keys(&:to_sym).transform_values do |status|
+        (status['arguments'] || {}).keys.map(&:to_sym)
+      end
+    end
+
+    # validate using a particular schema and version
+    # raises error if schema is not found
+    # return nil if validation succeds, otherwise returns an array of errors
+    def self.validate(message, schemas, options = {})
+      raise ArgumentError, 'message missing' unless message
+      raise ArgumentError, 'schemas missing' unless schemas
+      raise ArgumentError, 'schemas must be a Hash' unless schemas.is_a?(Hash)
+      raise ArgumentError, 'schemas cannot be empty' unless schemas.any?
+
+      errors = schemas.flat_map do |type, version|
+        schema = find_schema! type, version, options
+        validate_using_schema(message, schema)
+      end
+      return nil if errors.empty?
+
+      errors
+    end
+  end
+end

data/lib/rsmp/schema_error.rb

@@ -0,0 +1,19 @@
+module RSMP
+  module Schema
+    # Base error class for rsmp_schema.
+    class Error < StandardError
+    end
+
+    # Raised when an unknown schema type or version is requested.
+    class UnknownSchemaError < Error
+    end
+
+    # Raised when the requested schema type does not exist.
+    class UnknownSchemaTypeError < UnknownSchemaError
+    end
+
+    # Raised when the requested schema version does not exist.
+    class UnknownSchemaVersionError < UnknownSchemaError
+    end
+  end
+end

data/lib/rsmp/version.rb

@@ -1,3 +1,3 @@
 module RSMP
-  VERSION = '0.42.9'.freeze
+  VERSION = '0.43.0'.freeze
 end

data/lib/rsmp.rb

@@ -10,7 +10,10 @@ require 'json'
 require 'securerandom'
 require 'json_schemer'
 require 'async/queue'
-require 'rsmp_schema'
+require_relative 'rsmp/schema_error'
+require_relative 'rsmp/schema'
+require_relative 'rsmp/convert/import/yaml'
+require_relative 'rsmp/convert/export/json_schema'
 
 require_relative 'rsmp/status_list'
 require_relative 'rsmp/command_list'
@@ -98,9 +101,10 @@ require_relative 'rsmp/tlc/proxy/system'
 require_relative 'rsmp/tlc/traffic_controller_proxy'
 require_relative 'rsmp/tlc/traffic_controller'
 require_relative 'rsmp/tlc/detector_logic'
+
+RSMP::Schema.setup
 require_relative 'rsmp/tlc/signal_group'
 require_relative 'rsmp/tlc/signal_plan'
 require_relative 'rsmp/tlc/input_states'
 require_relative 'rsmp/tlc/signal_priority'
-require_relative 'rsmp/convert/import/yaml'
 require_relative 'rsmp/version'

data/rsmp.gemspec

@@ -35,7 +35,8 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'colorize', '~> 1.1'
   spec.add_dependency 'io-endpoint', '~> 0.15'
   spec.add_dependency 'io-stream', '~> 0.10'
+  spec.add_dependency 'json_schemer', '~> 2.5'
   spec.add_dependency 'logger', '~> 1.6'
   spec.add_dependency 'ostruct', '~> 0.6'
-  spec.add_dependency 'rsmp_schema', '~> 0.10'
+  spec.add_dependency 'thor', '~> 1.5'
 end

data/schemas/core/3.1.2/aggregated_status.json

@@ -0,0 +1,25 @@
+{
+  "title" :  "Aggregated Status",
+  "description" :  "Aggregated status message",
+  "properties" : {
+    "mId" : { "$ref": "definitions.json#/message_id" },
+    "aSTS" : { "$ref": "definitions.json#/timestamp" },
+    "fP" : {
+      "description" : "Functional position",
+      "type" : "string, null"
+    },
+    "fS" : {
+      "description" : "Functional position",
+      "type" : "string, null"
+    },
+    "se" : {
+      "type" : "array",
+      "minItems": 8,
+      "maxItems": 8,
+      "items" : {
+        "type" : "string"
+      }
+    }
+  },
+  "required" : [ "mId", "aSTS", "fP", "fS", "se" ]
+}

data/schemas/core/3.1.2/alarm.json

@@ -0,0 +1,67 @@
+{
+  "title" :  "Alarm",
+  "description" :  "Alarm messsage",
+  "properties" : {
+    "mId" : { "$ref": "definitions.json#/message_id" },
+    "cId" : { "$ref": "definitions.json#/component_id" },
+    "aCId" : { "$ref": "definitions.json#/alarm_code" },
+    "xACId" : { "description" : "External alarm code id", "type" : "string" },
+    "aSp" : {
+      "description" : "Alarm specialization",
+      "type" : "string",
+      "enum" : [ "Issue", "Acknowledge", "Suspend", "Resume",
+                 "issue", "acknowledge", "suspend", "resume" ]
+    }
+  },
+  "required" : [ "aSp"],
+  "allOf" : [
+    {
+      "if": {
+        "required" : [ "aSp" ],
+        "properties" : {
+          "aSp" : { "enum" : [ "Issue",
+                               "issue"] }
+        }
+      },
+      "then": { "$ref": "alarm_issue.json" }
+    },
+    {
+      "if": {
+        "allOf" : [
+          {
+            "required" : [ "aSp" ],
+            "properties" : {
+              "aSp" : { "enum" : [ "Suspend", "Resume",
+                                   "suspend", "resume"] }
+            }
+          },
+          {
+            "not": { "required" : [ "sS" ] }
+          }
+        ]
+      },
+      "then": { "$ref": "alarm_suspend_resume.json" }
+    },
+    {
+      "if": {
+        "required" : [ "aSp", "sS" ],
+        "properties" : {
+          "aSp" : { "enum" : [ "Suspend", "Resume",
+                               "suspend", "resume"] },
+          "sS" : { "enum" : [ "suspended", "notSuspended",
+                              "Suspended", "NotSuspended" ] }
+        }
+      },
+      "then": { "$ref": "alarm_suspended_resumed.json" }
+    },
+    {
+      "if": {
+        "required" : [ "aSp" ],
+        "properties" : {
+          "aSp" : { "enum" : [ "Acknowledge"] }
+        }
+      },
+      "then": { "$ref": "alarm_acknowledge.json" }
+    }
+  ]
+}

data/schemas/core/3.1.2/alarm_acknowledge.json

@@ -0,0 +1,12 @@
+{
+  "properties" : {
+    "ack" : {
+      "description" : "Acknowledgement",
+      "type" : "string",
+      "enum" : [ "Acknowledged", "notAcknowledged",
+                 "acknowledged", "NotAcknowledged" ]
+    },
+    "aTs" : { "$ref": "definitions.json#/timestamp" }
+  },
+  "required" : [ "mId", "cId", "aCId", "xACId", "aSp", "aTs" ]
+}

data/schemas/core/3.1.2/alarm_issue.json

@@ -0,0 +1,47 @@
+{
+  "properties" : {
+    "ack" : {
+      "description" : "Acknowledgement",
+      "type" : "string",
+      "enum" : [ "Acknowledged", "notAcknowledged",
+                 "acknowledged", "NotAcknowledged" ]
+    },
+    "aS" : {
+      "description" : "Active status",
+      "type" : "string",
+      "enum" : [ "inActive", "Active", "inactive",
+                 "InActive", "active" ]
+    },
+    "sS" : {
+      "description" : "Suspend status",
+      "type" : "string",
+      "enum" : [ "suspended", "notSuspended",
+                 "Suspended", "NotSuspended" ]
+    },
+    "aTs" : { "$ref": "definitions.json#/timestamp" },
+    "cat" : {
+      "description" : "Category",
+      "type" : "string",
+      "enum" : [ "T", "D" ]
+    },
+    "pri" : {
+      "description" : "Priority",
+      "type" : "string",
+      "enum" : [ "1", "2", "3" ]
+    },
+    "rvs" : {
+      "description" : "Return values",
+      "type" : "array",
+      "items" : {
+        "type" : "object",
+        "properties": {
+          "n" : { "description" : "Unique reference of the value", "type" : "string" },
+          "v" : { "description" : "Value", "type" : "string" }
+        },
+        "required" : [ "n", "v" ],
+        "additionalProperties": false
+      }
+    }
+  },
+  "required" : [ "mId", "cId", "aCId", "xACId", "aSp", "ack", "aS", "aTs", "sS", "cat", "pri", "rvs" ]
+}

data/schemas/core/3.1.2/alarm_suspend_resume.json

@@ -0,0 +1,3 @@
+{
+  "required" : [ "mId", "cId", "aCId", "xACId", "aSp" ]
+}

data/schemas/core/3.1.2/alarm_suspended_resumed.json

@@ -0,0 +1,47 @@
+{
+  "properties" : {
+    "ack" : {
+      "description" : "Acknowledgement",
+      "type" : "string",
+      "enum" : [ "Acknowledged", "notAcknowledged",
+                 "acknowledged", "NotAcknowledged" ]
+    },
+    "aS" : {
+      "description" : "Active status",
+      "type" : "string",
+      "enum" : [ "inActive", "Active", "inactive",
+                 "InActive", "active" ]
+    },
+    "sS" : {
+      "description" : "Suspend status",
+      "type" : "string",
+      "enum" : [ "suspended", "notSuspended",
+                 "Suspended", "NotSuspended" ]
+    },
+    "aTs" : { "$ref": "definitions.json#/timestamp" },
+    "cat" : {
+      "description" : "Category",
+      "type" : "string",
+      "enum" : [ "T", "D" ]
+    },
+    "pri" : {
+      "description" : "Priority",
+      "type" : "string",
+      "enum" : [ "1", "2", "3" ]
+    },
+    "rvs" : {
+      "description" : "Return values",
+      "type" : "array",
+      "items" : {
+        "type" : "object",
+        "properties": {
+          "n" : { "description" : "Unique reference of the value", "type" : "string" },
+          "v" : { "description" : "Value", "type" : "string" }
+        },
+        "required" : [ "n", "v" ],
+        "additionalProperties": false
+      }
+    }
+  },
+  "required" : [ "mId", "cId", "aCId", "xACId", "aSp", "ack", "aS", "aTs", "sS", "cat", "pri", "rvs" ]
+}

data/schemas/core/3.1.2/command_request.json

@@ -0,0 +1,24 @@
+{
+  "title" :  "CommandRequest",
+  "description" :  "Command request",
+  "properties" : {
+    "mId" : { "$ref": "definitions.json#/message_id" },
+    "cId" : { "$ref": "definitions.json#/component_id" },
+    "arg" : {
+      "description" : "Command arguments",
+      "type" : "array",
+      "minItems": 1,
+      "items" : {
+        "type" : "object",
+        "properties": {
+          "cCI" : { "$ref": "definitions.json#/command_code" },
+          "n" : { "description" : "Unique reference of the value", "type" : "string" },
+          "cO" : { "description" : "Command", "type" : "string" },
+          "v" : { "description" : "Value" }
+        },
+        "required" : [ "cCI", "n", "cO", "v" ]
+      }
+    }
+  },
+  "required" : [ "mId", "cId", "arg"]
+}

data/schemas/core/3.1.2/command_response.json

@@ -0,0 +1,34 @@
+{
+  "title" :  "CommandRequest",
+  "description" :  "Command request",
+  "properties" : {
+    "mId" : { "$ref": "definitions.json#/message_id" },
+    "cId" : { "$ref": "definitions.json#/component_id" },
+    "cTS" : { "$ref": "definitions.json#/timestamp" },
+    "rvs" : {
+      "description" : "Command arguments",
+      "type" : "array",
+      "items" : {
+        "type" : "object",
+        "properties": {
+          "cCI" : { "$ref": "definitions.json#/command_code" },
+          "n" : {
+            "description" : "Unique reference of the value",
+            "type" : "string"
+          },
+          "v" : {
+            "description" : "Value"
+          },
+          "age" : {
+            "description" : "Age of the value",
+            "type" : "string",
+            "enum" : [ "recent", "old", "undefined", "unknown" ]
+          }
+        },
+        "required" : [ "cCI", "n", "v", "age" ],
+        "additionalProperties": false
+      }
+    }
+  },
+  "required" : [ "mId", "cId", "cTS", "rvs" ]
+}

data/schemas/core/3.1.2/core.json

@@ -0,0 +1,38 @@
+{
+  "$schema" : "http://json-schema.org/draft-07/schema#",
+  "name" : "core",
+  "description" : "Core",
+  "version" : "3.1.2",
+  "type" :  "object",
+  "allOf" : [
+    {
+      "properties" : {
+        "mType" : {
+          "description" : "Supported RSMP versions",
+          "type" : "string",
+          "const" : "rSMsg"
+        },
+        "type" : {
+          "description" : "Type of RMSP message",
+          "type" : "string",
+          "enum" : [
+            "MessageAck",
+            "MessageNotAck",
+            "Version",
+            "AggregatedStatus",
+            "Watchdog",
+            "Alarm",
+            "CommandRequest",
+            "CommandResponse",
+            "StatusRequest",
+            "StatusResponse",
+            "StatusSubscribe",
+            "StatusUnsubscribe",
+            "StatusUpdate"
+          ]
+        }
+      },
+      "required" : [ "mType", "type" ]
+    }
+  ]
+}

data/schemas/core/3.1.2/definitions.json

@@ -0,0 +1,67 @@
+{
+  "message_id": {
+    "description" : "Message Id",
+    "type": "string",
+    "$comment" : "Example: 1.2.3 or 1.2",
+    "pattern": "^[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-4[a-fA-F0-9]{3}-[89abAB][a-fA-F0-9]{3}-[a-fA-F0-9]{12}$"
+  },
+  "timestamp" : {
+    "description" : "Timestamp",
+    "type": "string",
+    "$comment" : "Example: 2015-06-08T11:49:03.293Z",
+    "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}\\.[0-9]{3}Z$"
+  },
+  "integer" : {
+    "description" : "Integer as string",
+    "type": "string",
+    "$comment" : "Example: 123 or -123",
+    "pattern": "^\\-?[0-9]+$"
+  },
+  "version": {
+    "description" : "Version",
+    "type": "string",
+    "$comment" : "Example: 1.2.3 or 1.2",
+    "pattern" : "^[0-9]{1,2}\\.[0-9]{1,2}(\\.[0-9]{1,2})?"
+  },
+  "command_code": {
+    "description" : "Command code id",
+    "type" : "string",
+    "pattern" : "^M"
+  },
+  "status_code": {
+    "description" : "Status code id",
+    "type" : "string",
+    "pattern" : "^S"
+  },
+  "alarm_code": {
+    "description" : "Alarm code id",
+    "type" : "string",
+    "pattern" : "^A"
+  },
+  "component_id": {
+    "description" : "Compoment id",
+    "type" : "string"
+  },
+  "boolean": {
+    "description" : "Boolean as string",
+    "type" : "string",
+    "enum" : [ "True", "False" ]
+  },
+  "integer_list": {
+    "description" : "Comma-separated list of integers as strings",
+    "type" : "string",
+    "pattern" : "^(\\-?\\d+)(?:,(\\-?\\d+))*$"
+  },
+  "boolean_list": {
+    "description" : "Comma-separated list of booleans as strings",
+    "type" : "string",
+    "pattern" : "^(True|False)(?:,(True|False))*$"
+  },
+  "string_list": {
+    "description" : "Comma-separated list of strings",
+    "type" : "string"
+  }
+}
+
+
+

data/schemas/core/3.1.2/message_ack.json

@@ -0,0 +1,11 @@
+{
+  "title" :  "MessageAck",
+  "description" :  "Message acknowledged",
+  "properties" : {
+    "oMId" : {
+      "$ref": "definitions.json#/message_id",
+      "description" : "Old message id"
+    }
+  },
+  "required" : [ "oMId" ]
+}

data/schemas/core/3.1.2/message_not_ack.json

@@ -0,0 +1,15 @@
+{
+  "title" :  "MessageNotAck",
+  "description" :  "Message not acknowledgeded",
+  "properties" : {
+    "oMId" : {
+      "$ref": "definitions.json#/message_id",
+      "description" : "Old message id"
+    },
+    "rea" : {
+      "description" : "Reason / Error message",
+      "type" : "string"
+    }
+  },
+  "required" : [ "oMId" ]
+}