cosmos 3.0.0

data/lib/cosmos/io/json_rpc.rb

@@ -0,0 +1,365 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Lesser General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'json'
+
+class Object
+  def as_json(options = nil) #:nodoc:
+    if respond_to?(:to_hash)
+      to_hash
+    else
+      instance_variables
+    end
+  end
+end
+
+class Struct #:nodoc:
+  def as_json(options = nil)
+    pairs = []
+    self.each_pair { |k, v| pairs << k.to_s; pairs << v.as_json(options) }
+    Hash[*pairs]
+  end
+end
+
+class TrueClass
+  def as_json(options = nil) self end #:nodoc:
+end
+
+class FalseClass
+  def as_json(options = nil) self end #:nodoc:
+end
+
+class NilClass
+  def as_json(options = nil) self end #:nodoc:
+end
+
+class String
+  NON_ASCII_PRINTABLE = /[^\x21-\x7e\s]/
+
+  def as_json(options = nil)
+    if self =~ NON_ASCII_PRINTABLE
+      self.to_json_raw_object
+    else
+      self
+    end
+  end #:nodoc:
+end
+
+class Symbol
+  def as_json(options = nil) to_s end #:nodoc:
+end
+
+class Numeric
+  def as_json(options = nil) self end #:nodoc:
+end
+
+class Regexp
+  def as_json(options = nil) to_s end #:nodoc:
+end
+
+module Enumerable
+  def as_json(options = nil) #:nodoc:
+    to_a.as_json(options)
+  end
+end
+
+class Array
+  def as_json(options = nil) #:nodoc:
+    map { |v| v.as_json(options) }
+  end
+end
+
+class Hash
+  def as_json(options = nil) #:nodoc:
+    pairs = []
+    self.each { |k, v| pairs << k.to_s; pairs << v.as_json(options) }
+    Hash[*pairs]
+  end
+end
+
+class Time
+  def as_json(options = nil) #:nodoc:
+    to_json(options).remove_quotes
+  end
+end
+
+class Date
+  def as_json(options = nil) #:nodoc:
+    to_json(options).remove_quotes
+  end
+end
+
+class DateTime
+  def as_json(options = nil) #:nodoc:
+    to_json(options).remove_quotes
+  end
+end
+
+class Exception
+  def as_json(*a)
+    hash = {}
+    hash['class'] = self.class.name
+    hash['message'] = self.message
+    hash['backtrace'] = self.backtrace
+    instance_vars = {}
+    self.instance_variables.each do |instance_var_name|
+      instance_vars[instance_var_name.to_s] = self.instance_variable_get(instance_var_name.to_s.intern)
+    end
+    hash['instance_variables'] = instance_vars
+    hash.as_json(*a)
+  end
+
+  def to_json(*a)
+    as_json(*a).to_json(*a)
+  end
+
+  def self.from_hash(hash)
+    begin
+      # Get Error class handling namespaced constants
+      split_error_class_name = hash['class'].split("::")
+      error_class = Object
+      split_error_class_name.each do |name|
+        error_class = error_class.const_get(name)
+      end
+    rescue
+      error = Cosmos::JsonDRbUnknownError.new(hash['message'])
+      error.set_backtrace(hash['backtrace'].concat(caller()))
+      raise error
+    end
+    error = error_class.new(hash['message'])
+    error.set_backtrace(hash['backtrace'].concat(caller())) if hash['backtrace']
+    hash['instance_variables'].each do |name, value|
+      error.instance_variable_set(name.intern, value)
+    end
+    error
+  end
+end
+
+module Cosmos
+  # An unknown JSON DRb error which can be re-raised by Exception
+  class JsonDRbUnknownError < StandardError; end
+
+  # Base class for all JSON Remote Procedure Calls. Provides basic
+  # comparison and Hash to JSON conversions.
+  class JsonRpc
+    include Comparable
+
+    def initialize
+      @hash = {}
+    end
+
+    # @param other [JsonRpc] Another JsonRpc to compare hash values with
+    def <=>(other)
+      self.as_json <=> other.as_json
+    end
+
+    # @param a [Array] Array of options
+    # @return [Hash] Hash representing the object
+    def as_json(*a)
+      @hash.as_json(*a)
+    end
+
+    # @param a [Array] Array of options
+    # @return [String] The JSON encoded String
+    def to_json(*a)
+      as_json(*a).to_json(*a)
+    end
+  end
+
+  # Represents a JSON Remote Procedure Call Request
+  class JsonRpcRequest < JsonRpc
+    DANGEROUS_METHODS = ['__send__', 'send', 'instance_eval', 'instance_exec']
+
+    # @param method_name [String] The name of the method to call
+    # @param method_params [Array<String>] Array of strings which represent the
+    #   parameters to send to the method
+    # @param id [Integer] The identifier which will be matched to the response
+    def initialize(method_name, method_params, id)
+      super()
+      @hash['jsonrpc'] = "2.0"
+      @hash['method'] = method_name.to_s
+      if method_params and method_params.length != 0
+        @hash['params'] = method_params
+      end
+      @hash['id'] = id.to_i
+    end
+
+    # @return [String] The method to call
+    def method
+      @hash['method']
+    end
+
+    # @return [Array<String>] Array of strings which represent the
+    #   parameters to send to the method
+    def params
+      @hash['params'] || []
+    end
+
+    # @return [Integer] The request identifier
+    def id
+      @hash['id']
+    end
+
+    # Creates a JsonRpcRequest object from a JSON encoded String. The version
+    # must be 2.0 and the JSON must include the method and id members.
+    #
+    # @param request_data [String] JSON encoded string representing the request
+    # @return [JsonRpcRequest]
+    def self.from_json(request_data)
+      begin
+        hash = JSON.parse(request_data, :allow_nan => true, :create_additions => true)
+        # Verify the jsonrpc version is correct and there is a method and id
+        raise unless (hash['jsonrpc'] == "2.0" && hash['method'] && hash['id'])
+        self.from_hash(hash)
+      rescue
+        raise "Invalid JSON-RPC 2.0 Request"
+      end
+    end
+
+    # Creates a JsonRpcRequest object from a Hash
+    #
+    # @param hash [Hash] Hash containing the following keys: method, params,
+    #   and id
+    # @return [JsonRpcRequest]
+    def self.from_hash(hash)
+      self.new(hash['method'], hash['params'], hash['id'])
+    end
+  end
+
+  # Represents a JSON Remote Procedure Call Response
+  class JsonRpcResponse < JsonRpc
+
+    # @param id [Integer] The identifier which will be matched to the request
+    def initialize(id)
+      super()
+      @hash['jsonrpc'] = "2.0"
+      @hash['id'] = id
+    end
+
+    # Creates a JsonRpcResponse object from a JSON encoded String. The version
+    # must be 2.0 and the JSON must include the id members. It must also
+    # include either result for success or error for failure but never both.
+    #
+    # @param response_data [String] JSON encoded string representing the response
+    # @return [JsonRpcResponse]
+    def self.from_json(response_data)
+      msg = "Invalid JSON-RPC 2.0 Response"
+      begin
+        hash = JSON.parse(response_data, :allow_nan => true, :create_additions => true)
+      rescue
+        raise msg
+      end
+
+      # Verify the jsonrpc version is correct and there is an ID
+      raise msg unless hash['jsonrpc'] == "2.0" and hash.key?('id')
+      # If there is a result this is probably a good response
+      if hash.key?('result')
+        # Can't have an error key in a good response
+        raise msg if hash.key?('error')
+        JsonRpcSuccessResponse.from_hash(hash)
+      elsif hash.key?('error')
+        # There was an error key so create an error response
+        JsonRpcErrorResponse.from_hash(hash)
+      else
+        # Neither a result or error key so raise exception
+        raise msg
+      end
+    end
+  end
+
+  # Represents a JSON Remote Procedure Call Success Response
+  class JsonRpcSuccessResponse < JsonRpcResponse
+
+    # @param id [Integer] The identifier which will be matched to the request
+    def initialize(result, id)
+      super(id)
+      @hash['result'] = result
+    end
+
+    # @return [Object] The result of the method request
+    def result
+      @hash['result']
+    end
+
+    # Creates a JsonRpcSuccessResponse object from a Hash
+    #
+    # @param hash [Hash] Hash containing the following keys: result and id
+    # @return [JsonRpcSuccessResponse]
+    def self.from_hash(hash)
+      self.new(hash['result'], hash['id'])
+    end
+  end
+
+  # Represents a JSON Remote Procedure Call Error Response
+  class JsonRpcErrorResponse < JsonRpcResponse
+
+    # @param error [JsonRpcError] The error object
+    # @param id [Integer] The identifier which will be matched to the request
+    def initialize(error, id)
+      super(id)
+      @hash['error'] = error
+    end
+
+    # @return [JsonRpcError] The error object
+    def error
+      @hash['error']
+    end
+
+    # Creates a JsonRpcErrorResponse object from a Hash
+    #
+    # @param hash [Hash] Hash containing the following keys: error and id
+    # @return [JsonRpcErrorResponse]
+    def self.from_hash(hash)
+      self.new(JsonRpcError.from_hash(hash['error']), hash['id'])
+    end
+  end
+
+  # Represents a JSON Remote Procedure Call Error
+  class JsonRpcError < JsonRpc
+
+    # @param code [Integer] The error type that occurred
+    # @param message [String] A short description of the error
+    # @param data [Hash] Additional information about the error
+    def initialize(code, message, data = nil)
+      super()
+      @hash['code'] = code
+      @hash['message'] = message
+      @hash['data'] = data
+    end
+
+    # @return [Integer] The error type that occurred
+    def code
+      @hash['code']
+    end
+
+    # @return [String] A short description of the error
+    def message
+      @hash['message']
+    end
+
+    # @return [Hash] Additional information about the error
+    def data
+      @hash['data']
+    end
+
+    # Creates a JsonRpcError object from a Hash
+    #
+    # @param hash [Hash] Hash containing the following keys: code, message, and
+    #   optionally data
+    # @return [JsonRpcError]
+    def self.from_hash(hash)
+      if hash['code'] and (hash['code'].to_i == hash['code']) and hash['message']
+        self.new(hash['code'], hash['message'], hash['data'])
+      else
+        raise "Invalid JSON-RPC 2.0 Error"
+      end
+    end
+  end
+end

data/lib/cosmos/io/posix_serial_driver.rb

@@ -0,0 +1,145 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'fcntl'
+require 'termios' # Requires ruby-termios gem
+require 'timeout' # For Timeout::Error
+
+module Cosmos
+
+  # Serial driver for use on Posix serial ports found on UNIX based systems
+  class PosixSerialDriver
+
+    # (see SerialDriver#initialize)
+    def initialize(port_name = '/dev/ttyS0',
+                   baud_rate = 9600,
+                   parity = :NONE,
+                   stop_bits = 1,
+                   write_timeout = 10.0,
+                   read_timeout = nil)
+
+      # Convert Baud Rate into Termios constant
+      begin
+        baud_rate = Object.const_get("Termios::B#{baud_rate}")
+      rescue NameError
+        raise(ArgumentError, "Invalid Baud Rate, Not Defined by Termios: #{baud_rate}")
+      end
+
+      # Verify Parameters
+      raise(ArgumentError, "Invalid parity: #{parity}") if parity and !SerialDriver::VALID_PARITY.include?(parity)
+      raise(ArgumentError, "Invalid Stop Bits: #{stop_bits}") unless [1,2].include?(stop_bits)
+      @write_timeout = write_timeout
+      @read_timeout = read_timeout
+
+      parity = nil if parity == :NONE
+
+      # Open the serial Port
+      @handle = Kernel.open(port_name, File::RDWR | File::NONBLOCK)
+      flags = @handle.fcntl(Fcntl::F_GETFL, 0)
+      @handle.fcntl(Fcntl::F_SETFL, flags & ~File::NONBLOCK)
+      @handle.extend Termios
+
+      # Configure the serial Port
+      tio = Termios::new_termios()
+      iflags = 0
+      iflags |= Termios::IGNPAR unless parity
+      cflags = 0
+      cflags |= Termios::CREAD # Enable receiver
+      cflags |= Termios::CS8 # 8-bit bytes
+      cflags |= Termios::CLOCAL # Ignore Modem Control Lines
+      cflags |= Termios::CSTOPB if stop_bits == 2
+      cflags |= Termios::PARENB if parity
+      cflags |= Termios::PADODD if parity == :ODD
+      tio.iflag = iflags
+      tio.oflag = 0
+      tio.cflag = cflags
+      tio.lflag = 0
+      tio.cc[Termios::VTIME] = 0
+      tio.cc[Termios::VMIN] = 1
+      tio.ispeed = baud_rate
+      tio.ospeed = baud_rate
+      @handle.tcflush(Termios::TCIOFLUSH)
+      @handle.tcsetattr(Termios::TCSANOW, tio)
+    end
+
+    # (see SerialDriver#close)
+    def close
+      if @handle
+        # Close the serial Port
+        @handle.close
+        @handle = nil
+      end
+    end
+
+    # (see SerialDriver#closed?)
+    def closed?
+      if @handle
+        false
+      else
+        true
+      end
+    end
+
+    # (see SerialDriver#write)
+    def write(data)
+      num_bytes_to_send = data.length
+      total_bytes_sent = 0
+      bytes_sent = 0
+      data_to_send = data
+
+      loop do
+        begin
+          bytes_sent = @handle.write_nonblock(data_to_send)
+        rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+          result = IO.fast_select(nil, [@handle], nil, @write_timeout)
+          if result
+            retry
+          else
+            raise Timeout::Error, "Write Timeout"
+          end
+        end
+        total_bytes_sent += bytes_sent
+        break if total_bytes_sent >= num_bytes_to_send
+        data_to_send = data[total_bytes_sent..-1]
+      end
+    end
+
+    # (see SerialDriver#read)
+    def read
+      begin
+        data = @handle.read_nonblock(65535)
+      rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+        result = IO.fast_select([@handle], nil, nil, @read_timeout)
+        if result
+          retry
+        else
+          raise Timeout::Error, "Read Timeout"
+        end
+      end
+
+      data
+    end
+
+    # (see SerialDriver#read_nonblock)
+    def read_nonblock
+      data = ''
+
+      begin
+        data = @handle.read_nonblock(65535)
+      rescue Errno::EAGAIN, Errno::EWOULDBLOCK
+        # Do Nothing
+      end
+
+      data
+    end
+
+  end # class PosixSerialDriver
+
+end # module Cosmos

data/lib/cosmos/io/raw_logger.rb

@@ -0,0 +1,174 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'thread'
+require 'socket' # For gethostname
+require 'cosmos/config/config_parser'
+
+module Cosmos
+
+  # Creates a log file of raw data for either reads or writes. Can automatically
+  # cycle the log based on when the log file reaches a predefined size.
+  class RawLogger
+
+    # @return [String] The filename of the log
+    attr_reader :filename
+
+    # @return [Queue] Queue for asynchronous logging
+    attr_reader :queue
+
+    # @return [Boolean] Is logging enabled?
+    attr_reader :logging_enabled
+
+    # @retuen [String] Original name passed to raw logger
+    attr_reader :orig_name
+
+    # The allowable log types
+    LOG_TYPES = [:READ, :WRITE]
+
+    # The cycle time interval. Cycle times are only checked at this level of
+    # granularity.
+    CYCLE_TIME_INTERVAL = 60
+
+    # @param log_name [String] The name of the raw logger.  Typically matches the
+    #    name of the corresponding interface
+    # @param log_type [Symbol] The type of log to create. Must be :READ
+    #   or :WRITE.
+    # @param cycle_time [Integer] The amount of time in seconds before creating
+    #   a new log file. This can be combined with cycle_size but is better used
+    #   independently.
+    # @param cycle_size [Integer] The size in bytes before creating a new log
+    #   file. This can be combined with cycle_time but is better used
+    #   independently.
+    # @param log_directory [String] The directory to store the log files.
+    #   Passing nil will use the system default 'LOGS' directory.
+    def initialize(
+      log_name,
+      log_type,
+      logging_enabled = false,
+      cycle_size = 2000000000,
+      log_directory = nil
+    )
+      raise "log_type must be :READ or :WRITE" unless LOG_TYPES.include? log_type
+      @log_type = log_type
+      @orig_name = log_name
+      @log_name = (log_name.to_s.downcase + '_raw_' + @log_type.to_s.downcase + '_' + self.object_id.to_s).freeze
+      @cycle_size = ConfigParser.handle_nil(cycle_size)
+      @cycle_size = Integer(@cycle_size) if @cycle_size
+      if ConfigParser.handle_nil(log_directory)
+        @log_directory = log_directory
+      else
+        @log_directory = nil
+      end
+      @mutex = Mutex.new
+      @file = nil
+      @filename = nil
+      @start_time = Time.now
+      @logging_enabled = ConfigParser.handle_true_false(logging_enabled)
+    end
+
+    # Set the raw logger name
+    # @param name [String] new name
+    def name=(log_name)
+      @orig_name = log_name
+      @log_name = (log_name.to_s.downcase + '_raw_' + @log_type.to_s.downcase + '_' + self.object_id.to_s).freeze
+    end
+
+    # Write data to the log file.
+    #
+    # If no log file currently exists in the filesystem, a new file will be
+    # created.
+    #
+    # Writing a log file is a critical operation so the entire method is
+    # wrapped with a rescue and handled with handle_critical_exception
+    #
+    # @param data [String] The data to write to the log file
+    def write(data)
+      if @logging_enabled
+        return if !data or data.length <= 0
+        need_new_file = false
+        @mutex.synchronize do
+          if !@file or (@cycle_size and (@file.stat.size + data.length) > @cycle_size)
+            need_new_file = true
+          end
+        end
+        start_new_file() if need_new_file
+        @mutex.synchronize { @file.write(data) if @file }
+      end
+    rescue => err
+      Logger.instance.error "Error writing #{@filename} : #{err.formatted}"
+      Cosmos.handle_critical_exception(err)
+    end
+
+    # Starts a new log file by closing the existing log file. New log files are
+    # not created until data is written by {#write} so this does not
+    # immediately create a log file on the filesystem.
+    def start
+      close_file() unless ((Time.now - @start_time) < 1.0) # Prevent close/open too fast
+      @mutex.synchronize { @logging_enabled = true }
+    end
+
+    # Stops all logging and closes the current log file.
+    def stop
+      @mutex.synchronize { @logging_enabled = false }
+      close_file()
+    end
+
+    # Create a clone of this object with a new name
+    def clone
+      raw_logger = super()
+      raw_logger.name = raw_logger.orig_name
+      raw_logger
+    end
+
+    protected
+
+    # Starting a new log file is a critical operation so the entire method is
+    # wrapped with a rescue and handled with handle_critical_exception
+    def start_new_file
+      @log_directory ||= System.instance.paths['LOGS']
+      close_file()
+      @mutex.synchronize do
+        Cosmos.set_working_dir do
+          @filename = File.join(@log_directory, File.build_timestamped_filename([@log_name], '.bin'))
+          @file = File.new(@filename, 'wb')
+        end
+        @start_time = Time.now
+        Logger.instance.info "Raw Log File Opened : #{@filename}"
+      end
+    rescue => err
+      Logger.instance.error "Error opening #{@filename} : #{err.formatted}"
+      @logging_enabled = false
+      Cosmos.handle_critical_exception(err)
+    end
+
+    # Closing a log file isn't critical so we just log an error
+    def close_file
+      @mutex.synchronize do
+        if @file
+          begin
+            @file.close unless @file.closed?
+            Cosmos.set_working_dir do
+              File.chmod(0444, @file.path) # Make file read only
+            end
+            Logger.instance.info "Raw Log File Closed : #{@filename}"
+          rescue => err
+            Logger.instance.error "Error closing #{@filename} : #{err.formatted}"
+          end
+
+          @file = nil
+          @filename = nil
+        end
+      end
+    end
+
+  end # class RawLogger
+
+end # module Cosmos