cosmos 3.9.2 → 4.0.0

data/lib/cosmos/script/telemetry.rb

@@ -66,13 +66,53 @@ module Cosmos
     # Set the raw value of a telemetry point to a given value. Note this will
     # be over written in a live system by incoming new telemetry.
     # Usage:
-    #   set_tlm(target_name, packet_name, item_name, value)
+    #   set_tlm_raw(target_name, packet_name, item_name, value)
     # or
-    #   set_tlm("target_name packet_name item_name = value")
+    #   set_tlm_raw("target_name packet_name item_name = value")
     def set_tlm_raw(*args)
       return $cmd_tlm_server.set_tlm_raw(*args)
     end
 
+    # Injects a packet into the system as if it was received from an interface
+    #
+    # @param target_name[String] Target name of the packet
+    # @param packet_name[String] Packet name of the packet
+    # @param item_hash[Hash] Hash of item_name and value for each item you want to change from the current value table
+    # @param value_type[Symbol/String] Type of the values in the item_hash (RAW or CONVERTED)
+    # @param send_routers[Boolean] Whether or not to send to routers for the target's interface
+    # @param send_packet_log_writers[Boolean] Whether or not to send to the packet log writers for the target's interface
+    # @param create_new_logs[Boolean] Whether or not to create new log files before writing this packet to logs
+    def inject_tlm(target_name, packet_name, item_hash = nil, value_type = :CONVERTED, send_routers = true, send_packet_log_writers = true, create_new_logs = false)
+      return $cmd_tlm_server.inject_tlm(target_name, packet_name, item_hash, value_type, send_routers, send_packet_log_writers, create_new_logs)
+    end
+
+    # Permanently set the converted value of a telemetry point to a given value
+    # Usage:
+    #   override_tlm(target_name, packet_name, item_name, value)
+    # or
+    #   override_tlm("target_name packet_name item_name = value")
+    def override_tlm(*args)
+      return $cmd_tlm_server.override_tlm(*args)
+    end
+
+    # Permanently set the raw value of a telemetry point to a given value
+    # Usage:
+    #   override_tlm_raw(target_name, packet_name, item_name, value)
+    # or
+    #   override_tlm_raw("target_name packet_name item_name = value")
+    def override_tlm_raw(*args)
+      return $cmd_tlm_server.override_tlm_raw(*args)
+    end
+
+    # Clear an override of a telemetry point
+    # Usage:
+    #   normalize_tlm(target_name, packet_name, item_name)
+    # or
+    #   normalize_tlm("target_name packet_name item_name")
+    def normalize_tlm(*args)
+      return $cmd_tlm_server.normalize_tlm(*args)
+    end
+
     # Gets all the values from the given packet returned in a two dimensional
     # array containing the item_name, value, and limits state.
     # Usage:
@@ -125,7 +165,7 @@ module Cosmos
     # Returns the buffer from the telemetry packet.
     def get_tlm_buffer(target_name, packet_name)
       return $cmd_tlm_server.get_tlm_buffer(target_name, packet_name)
-    end    
+    end
 
     # Subscribe to one or more telemetry packets. The queue ID is returned for
     # use in get_packet_data and unsubscribe_packet_data.
@@ -149,31 +189,12 @@ module Cosmos
     def get_packet_data(id, non_block = false)
       results = $cmd_tlm_server.get_packet_data(id, non_block)
       if Array === results and results[3] and results[4]
-        results[3] = Time.at(results[3], results[4])
+        results[3] = Time.at(results[3], results[4]).sys
         results.delete_at(4)
       end
       results
     end
 
-    # Get a packet which was previously subscribed to by
-    # subscribe_packet_data. This method can block waiting for new packets or
-    # not based on the second parameter. It returns a single Cosmos::Packet instance
-    # and will return nil when no more packets are buffered (assuming non_block
-    # is false).
-    # Usage:
-    #   get_packet(id, <true or false to block>)
-    def get_packet(id, non_block = false)
-      packet = nil
-      buffer, target_name, packet_name, received_time, received_count = get_packet_data(id, non_block)
-      if buffer
-        packet = System.telemetry.packet(target_name, packet_name).clone
-        packet.buffer = buffer
-        packet.received_time = received_time
-        packet.received_count = received_count
-      end
-      packet
-    end
-
   end
 end
 

data/lib/cosmos/script/tools.rb

@@ -13,70 +13,6 @@ module Cosmos
   module Script
     private
 
-    #######################################
-    # Methods accessing tlm_viewer
-    #######################################
-
-    def display(display_name, x_pos = nil, y_pos = nil)
-      run_tlm_viewer("display", display_name) do |tlm_viewer|
-        tlm_viewer.display(display_name, x_pos, y_pos)
-      end
-    end
-
-    def clear(display_name)
-      run_tlm_viewer("clear", display_name) do |tlm_viewer|
-        tlm_viewer.clear(display_name)
-      end
-    end
-
-    def clear_all(target = nil)
-      run_tlm_viewer("clear_all") do |tlm_viewer|
-        tlm_viewer.clear_all(target)
-      end
-    end
-
-    def run_tlm_viewer(action, display_name = '')
-      tlm_viewer = JsonDRbObject.new "localhost", System.ports['TLMVIEWER_API']
-      begin
-        yield tlm_viewer
-        tlm_viewer.disconnect
-      rescue DRb::DRbConnError
-        # No Listening Tlm Viewer - So Start One
-        start_tlm_viewer
-        max_retries = 60
-        retry_count = 0
-        begin
-          yield tlm_viewer
-          tlm_viewer.disconnect
-        rescue DRb::DRbConnError
-          retry_count += 1
-          if retry_count < max_retries
-            canceled = cosmos_script_sleep(1)
-            retry unless canceled
-          end
-          raise "Unable to Successfully Start Listening Telemetry Viewer: Could not #{action} #{display_name}"
-        rescue Errno::ENOENT
-          raise "Display Screen File: #{display_name}.txt does not exist"
-        end
-      rescue Errno::ENOENT
-        raise "Display Screen File: #{display_name}.txt does not exist"
-      end
-    end
-
-    def start_tlm_viewer
-      system_file = File.basename(System.initial_filename)
-      mac_app = File.join(Cosmos::USERPATH, 'tools', 'mac', 'TlmViewer.app')
-
-      if Kernel.is_mac? && File.exist?(mac_app)
-        Cosmos.run_process("open '#{mac_app}' --args --system #{system_file}")
-      else
-        cmd = 'ruby'
-        cmd << 'w' if Kernel.is_windows? # Windows uses rubyw to avoid creating a DOS shell
-        Cosmos.run_process("#{cmd} '#{File.join(Cosmos::USERPATH, 'tools', 'TlmViewer')}' --system #{system_file}")
-      end
-      cosmos_script_sleep(1)
-    end
-
     #######################################
     # Methods accessing script runner
     #######################################
@@ -86,11 +22,15 @@ module Cosmos
     end
 
     def set_line_delay(delay)
-      _ensure_script_runner_frame { ScriptRunnerFrame.line_delay = delay if delay >= 0.0 }
+      if defined? ScriptRunnerFrame
+        ScriptRunnerFrame.line_delay = delay if delay >= 0.0
+      end
     end
 
     def get_line_delay
-      _ensure_script_runner_frame { ScriptRunnerFrame.line_delay }
+      if defined? ScriptRunnerFrame
+        ScriptRunnerFrame.line_delay
+      end
     end
 
     def get_scriptrunner_message_log_filename
@@ -135,15 +75,21 @@ module Cosmos
     end
 
     def step_mode
-      _ensure_script_runner_frame { ScriptRunnerFrame.step_mode = true }
+      if defined? ScriptRunnerFrame
+        ScriptRunnerFrame.step_mode = true
+      end
     end
 
     def run_mode
-      _ensure_script_runner_frame { ScriptRunnerFrame.step_mode = false }
+      if defined? ScriptRunnerFrame
+        ScriptRunnerFrame.step_mode = false
+      end
     end
 
     def show_backtrace(value = true)
-      _ensure_script_runner_frame { ScriptRunnerFrame.show_backtrace = value }
+      if defined? ScriptRunnerFrame
+        ScriptRunnerFrame.show_backtrace = value
+      end
     end
 
   end # module Script

data/lib/cosmos/streams/serial_stream.rb

@@ -9,16 +9,13 @@
 # attribution addendums as found in the LICENSE.txt
 
 require 'thread' # For Mutex
-require 'timeout' # For Timeout::Error
 require 'cosmos/streams/stream'
 require 'cosmos/config/config_parser'
 require 'cosmos/io/serial_driver'
 
 module Cosmos
-
   # Stream that reads and writes to serial ports by using {SerialDriver}.
   class SerialStream < Stream
-
     # @param write_port_name [String] The name of the serial port to write.
     #   Pass nil if the stream is to be read only. On Windows the port name
     #   is typically 'COMX' where X can be any port number. On UNIX the port
@@ -38,13 +35,15 @@ module Cosmos
     #   complete. Pass nil to create no timeout. The {SerialDriver} will
     #   continously try to read data until it has received data or an error
     #   occurs.
+    # @param flow_control [Symbol] Currently supported :NONE and :RTSCTS
     def initialize(write_port_name,
                    read_port_name,
                    baud_rate,
                    parity,
                    stop_bits,
                    write_timeout,
-                   read_timeout)
+                   read_timeout,
+                   flow_control = :NONE)
       super()
 
       # The SerialDriver class will validate the parameters
@@ -57,6 +56,7 @@ module Cosmos
       @write_timeout   = @write_timeout.to_f if @write_timeout
       @read_timeout    = ConfigParser.handle_nil(read_timeout)
       @read_timeout    = @read_timeout.to_f if @read_timeout
+      @flow_control = flow_control.to_s.intern
 
       if @write_port_name
         @write_serial_port = SerialDriver.new(@write_port_name,
@@ -64,7 +64,8 @@ module Cosmos
                                               @parity,
                                               @stop_bits,
                                               @write_timeout,
-                                              @read_timeout)
+                                              @read_timeout,
+                                              @flow_control)
       else
         @write_serial_port = nil
       end
@@ -77,7 +78,8 @@ module Cosmos
                                                @parity,
                                                @stop_bits,
                                                @write_timeout,
-                                               @read_timeout)
+                                               @read_timeout,
+                                               @flow_control)
         end
       else
         @read_serial_port = nil
@@ -97,21 +99,15 @@ module Cosmos
     # @return [String] Returns a binary string of data from the serial port
     def read
       raise "Attempt to read from write only stream" unless @read_serial_port
-      # No read mutex is needed because there is only one stream procesor
-      # reading
-      data = @read_serial_port.read
-      @raw_logger_pair.read_logger.write(data) if @raw_logger_pair
-      data
+      # No read mutex is needed because reads happen serially
+      @read_serial_port.read
     end
 
     # @return [String] Returns a binary string of data from the serial port without blocking
     def read_nonblock
       raise "Attempt to read from write only stream" unless @read_serial_port
-      # No read mutex is needed because there is only one stream procesor
-      # reading
-      data = @read_serial_port.read_nonblock
-      @raw_logger_pair.read_logger.write(data) if @raw_logger_pair
-      data
+      # No read mutex is needed because reads happen serially
+      @read_serial_port.read_nonblock
     end
 
     # @param data [String] A binary string of data to write to the serial port
@@ -119,7 +115,6 @@ module Cosmos
       raise "Attempt to write to read only stream" unless @write_serial_port
       @write_mutex.synchronize do
         @write_serial_port.write(data)
-        @raw_logger_pair.write_logger.write(data) if @raw_logger_pair
       end
     end
 
@@ -151,7 +146,5 @@ module Cosmos
         @connected = false
       end
     end
-
   end # class SerialStream
-
 end # module Cosmos

data/lib/cosmos/streams/stream.rb

@@ -8,20 +8,13 @@
 # as published by the Free Software Foundation; version 3 with
 # attribution addendums as found in the LICENSE.txt
 
-require 'timeout' # For Timeout::Error
-
 module Cosmos
-
   # Class that implments the following methods: read, write(data),
   # connect, connected? and disconnect. Streams are simply data sources which
-  # {StreamProtocol} classes read and write to. This separation of concerns
+  # {Protocol} classes read and write to. This separation of concerns
   # allows Streams to simply focus on getting and sending raw data while the
-  # higher level processing occurs in {StreamProtocol}.
+  # higher level processing occurs in {Protocol}.
   class Stream
-
-    # @return [RawLoggerPair] Raw logger pair associated with this stream
-    attr_accessor :raw_logger_pair
-
     # Expected to return any amount of data on success, or a blank string on
     # closed/EOF, and may raise Timeout::Error, or other errors
     def read
@@ -57,7 +50,5 @@ module Cosmos
     def disconnect
       raise "disconnect not defined by Stream"
     end
-
   end # class Stream
-
 end # module Cosmos

data/lib/cosmos/streams/tcpip_socket_stream.rb

@@ -49,8 +49,7 @@ module Cosmos
     def read
       raise "Attempt to read from write only stream" unless @read_socket
 
-      # No read mutex is needed because there is only one stream procesor
-      # reading
+      # No read mutex is needed because reads happen serially
       if FAST_READ
         begin
           while true # Loop until we get some data
@@ -77,7 +76,6 @@ module Cosmos
                 data = ''
               end
             end
-            @raw_logger_pair.read_logger.write(data) if @raw_logger_pair
             break
           end
         rescue Errno::ECONNRESET, Errno::ECONNABORTED, IOError, Errno::ENOTSOCK
@@ -86,7 +84,6 @@ module Cosmos
       else
         begin
           data = @read_socket.read_nonblock(65535)
-          @raw_logger_pair.read_logger.write(data) if @raw_logger_pair
         rescue IO::WaitReadable
           # Wait for the socket to be ready for reading or for the timeout
           begin
@@ -118,20 +115,14 @@ module Cosmos
 
     # @return [String] Returns a binary string of data from the socket. Always returns immediately
     def read_nonblock
-      # No read mutex is needed because there is only one stream procesor
-      # reading
+      # No read mutex is needed because reads happen serially
       begin
         if FAST_READ
           data = @read_socket.read_nonblock(65535, exception: false)
           raise EOFError, 'end of file reached' unless data
-          if data == :wait_readable
-            data = ''
-          else
-            @raw_logger_pair.read_logger.write(data) if @raw_logger_pair
-          end
+          data = '' if data == :wait_readable
         else
           data = @read_socket.read_nonblock(65535)
-          @raw_logger_pair.read_logger.write(data) if @raw_logger_pair
         end
       rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::ECONNRESET, Errno::ECONNABORTED, IOError
         data = ''
@@ -153,7 +144,6 @@ module Cosmos
         loop do
           begin
             bytes_sent = @write_socket.write_nonblock(data_to_send)
-            @raw_logger_pair.write_logger.write(data_to_send[0..(bytes_sent - 1)]) if @raw_logger_pair and bytes_sent > 0
           rescue Errno::EAGAIN, Errno::EWOULDBLOCK
             # Wait for the socket to be ready for writing or for the timeout
             result = IO.fast_select(nil, [@write_socket], nil, @write_timeout)

data/lib/cosmos/system/system.rb

@@ -20,7 +20,6 @@ require 'drb/acl'
 require 'bundler'
 
 module Cosmos
-
   # System is the primary entry point into the COSMOS framework. It captures
   # system wide configuration items such as the available ports and paths to
   # various files used by the system. The #commands, #telemetry, and #limits
@@ -32,14 +31,20 @@ module Cosmos
   class System
     # @return [Hash<String,Fixnum>] Hash of all the known ports and their values
     instance_attr_reader :ports
+    # @return [Hash<String,String>] Hash of host names or ip addresses for tools to listen on
+    instance_attr_reader :listen_hosts
+    # @return [Hash<String,String>] Hash of host names or ip addresses for tools to connect to
+    instance_attr_reader :connect_hosts
     # @return [Hash<String,String>] Hash of all the known paths and their values
     instance_attr_reader :paths
-    # @return [String] Arbitrary string containing the version
-    instance_attr_reader :cmd_tlm_version
     # @return [PacketLogWriter] Class used to create log files
     instance_attr_reader :default_packet_log_writer
+    # @return [Array<String>] Parameters to be used with the default log writer
+    instance_attr_reader :default_packet_log_writer_params
     # @return [PacketLogReader] Class used to read log files
     instance_attr_reader :default_packet_log_reader
+    # @return [Array<String>] Parameters to be used with the default log reader
+    instance_attr_reader :default_packet_log_reader_params
     # @return [Boolean] Whether to use sound for alerts
     instance_attr_reader :sound
     # @return [Boolean] Whether to use DNS to lookup IP addresses or not
@@ -58,11 +63,19 @@ module Cosmos
     instance_attr_reader :staleness_seconds
     # @return [Symbol] The current limits set
     instance_attr_reader :limits_set
+    # @return [Boolean] Whether to use UTC or local times
+    instance_attr_reader :use_utc
+    # @return [Array<String>] List of files that are to be included in the MD5
+    #   calculation in addition to the cmd/tlm definition files that are
+    #   automatically included
+    instance_attr_reader :additional_md5_files
 
     # Known COSMOS ports
     KNOWN_PORTS = ['CTS_API', 'TLMVIEWER_API', 'CTS_PREIDENTIFIED', 'CTS_CMD_ROUTER']
+    # Known COSMOS hosts
+    KNOWN_HOSTS = ['CTS_API', 'TLMVIEWER_API', 'CTS_PREIDENTIFIED', 'CTS_CMD_ROUTER']
     # Known COSMOS paths
-    KNOWN_PATHS = ['LOGS', 'TMP', 'SAVED_CONFIG', 'TABLES', 'HANDBOOKS', 'PROCEDURES']
+    KNOWN_PATHS = ['LOGS', 'TMP', 'SAVED_CONFIG', 'TABLES', 'HANDBOOKS', 'PROCEDURES', 'SEQUENCES']
 
     @@instance = nil
     @@instance_mutex = Mutex.new
@@ -81,14 +94,17 @@ module Cosmos
       @commands = nil
       @telemetry = nil
       @limits = nil
-      @cmd_tlm_version = nil
       @default_packet_log_writer = PacketLogWriter
+      @default_packet_log_writer_params = []
       @default_packet_log_reader = PacketLogReader
+      @default_packet_log_reader_params = []
       @sound = false
       @use_dns = false
       @acl = nil
       @staleness_seconds = 30
       @limits_set = :DEFAULT
+      @use_utc = false
+      @additional_md5_files = []
 
       @ports = {}
       @ports['CTS_API'] = 7777
@@ -96,6 +112,19 @@ module Cosmos
       @ports['CTS_PREIDENTIFIED'] = 7779
       @ports['CTS_CMD_ROUTER'] = 7780
 
+      @listen_hosts = {}
+      @listen_hosts['CTS_API'] = '127.0.0.1'
+      @listen_hosts['TLMVIEWER_API'] = '127.0.0.1'
+      # Localhost would be more secure but historically these are open to allow for chaining servers by default
+      @listen_hosts['CTS_PREIDENTIFIED'] = '0.0.0.0'
+      @listen_hosts['CTS_CMD_ROUTER'] = '0.0.0.0'
+
+      @connect_hosts = {}
+      @connect_hosts['CTS_API'] = '127.0.0.1'
+      @connect_hosts['TLMVIEWER_API'] = '127.0.0.1'
+      @connect_hosts['CTS_PREIDENTIFIED'] = '127.0.0.1'
+      @connect_hosts['CTS_CMD_ROUTER'] = '127.0.0.1'
+
       @paths = {}
       @paths['LOGS'] = File.join(USERPATH, 'outputs', 'logs')
       @paths['TMP'] = File.join(USERPATH, 'outputs', 'tmp')
@@ -103,6 +132,7 @@ module Cosmos
       @paths['TABLES'] = File.join(USERPATH, 'outputs', 'tables')
       @paths['HANDBOOKS'] = File.join(USERPATH, 'outputs', 'handbooks')
       @paths['PROCEDURES'] = [File.join(USERPATH, 'procedures')]
+      @paths['SEQUENCES'] = File.join(USERPATH, 'outputs', 'sequences')
 
       unless filename
         system_arg = false
@@ -120,6 +150,7 @@ module Cosmos
 
       @initial_filename = filename
       @initial_config = nil
+      @meta_init_filename = nil
       @@instance = self
     end
 
@@ -186,7 +217,7 @@ module Cosmos
         if @config.limits_sets.include?(new_limits_set)
           @limits_set = new_limits_set
           Logger.info("Limits Set Changed to: #{@limits_set}")
-          CmdTlmServer.instance.post_limits_event(:LIMITS_SET, System.limits_set) if defined? CmdTlmServer and CmdTlmServer.instance
+          CmdTlmServer.instance.post_limits_event(:LIMITS_SET, System.limits_set) if defined? CmdTlmServer && CmdTlmServer.instance
         else
           raise "Unknown limits set requested: #{new_limits_set}"
         end
@@ -218,12 +249,14 @@ module Cosmos
       @targets = {}
       # Set config to nil so things will lazy load later
       @config = nil
+      @use_utc = false
       acl_list = []
       all_allowed = false
       first_procedures_path = true
+      @additional_md5_files = []
 
       Cosmos.set_working_dir do
-        parser = ConfigParser.new
+        parser = ConfigParser.new("http://cosmosrb.com/docs/system")
 
         # First pass - Everything except targets
         parser.parse_file(filename) do |keyword, parameters|
@@ -238,6 +271,19 @@ module Cosmos
             @ports[port_name] = Integer(parameters[1])
             Logger.warn("Unknown port name given: #{port_name}") unless KNOWN_PORTS.include?(port_name)
 
+          when 'LISTEN_HOST', 'CONNECT_HOST'
+            usage = "#{keyword} <HOST NAME> <HOST VALUE>"
+            parser.verify_num_parameters(2, 2, usage)
+            host_name = parameters[0].to_s.upcase
+            host = parameters[1]
+            host = '127.0.0.1' if host.to_s.upcase == 'LOCALHOST'
+            if keyword == 'LISTEN_HOST'
+              @listen_hosts[host_name] = host
+            else
+              @connect_hosts[host_name] = host
+            end
+            Logger.warn("Unknown host name given: #{host_name}") unless KNOWN_HOSTS.include?(host_name)
+
           when 'PATH'
             usage = "#{keyword} <PATH NAME> <PATH>"
             parser.verify_num_parameters(2, 2, usage)
@@ -264,14 +310,16 @@ module Cosmos
             Logger.warn("Unknown path name given: #{path_name}") unless KNOWN_PATHS.include?(path_name)
 
           when 'DEFAULT_PACKET_LOG_WRITER'
-            usage = "#{keyword} <FILENAME>"
-            parser.verify_num_parameters(1, 1, usage)
+            usage = "#{keyword} <FILENAME> <Specific Parameters>"
+            parser.verify_num_parameters(1, nil, usage)
             @default_packet_log_writer = Cosmos.require_class(parameters[0])
+            @default_packet_log_writer_params = parameters[1..-1] if parameters.size > 1
 
           when 'DEFAULT_PACKET_LOG_READER'
-            usage = "#{keyword} <FILENAME>"
-            parser.verify_num_parameters(1, 1, usage)
+            usage = "#{keyword} <FILENAME> <Specific Parameters>"
+            parser.verify_num_parameters(1, nil, usage)
             @default_packet_log_reader = Cosmos.require_class(parameters[0])
+            @default_packet_log_reader_params = parameters[1..-1] if parameters.size > 1
 
           when 'ENABLE_SOUND'
             usage = "#{keyword}"
@@ -299,7 +347,7 @@ module Cosmos
 
               unless all_allowed
                 first_char = addr[0..0]
-                if !((first_char =~ /[1234567890]/) or (first_char == '*') or (addr.upcase == 'ALL'))
+                if !((first_char =~ /[1234567890]/) || (first_char == '*') || (addr.upcase == 'ALL'))
                   # Try to lookup IP Address
                   info = Socket.gethostbyname(addr)
                   addr = "#{info[3].getbyte(0)}.#{info[3].getbyte(1)}.#{info[3].getbyte(2)}.#{info[3].getbyte(3)}"
@@ -327,10 +375,23 @@ module Cosmos
             parser.verify_num_parameters(1, 1, "#{keyword} <Value in Seconds>")
             @staleness_seconds = Integer(parameters[0])
 
-          when 'CMD_TLM_VERSION'
-            usage = "#{keyword} <VERSION>"
-            parser.verify_num_parameters(1, 1, usage)
-            @cmd_tlm_version = parameters[0]
+          when 'META_INIT'
+            parser.verify_num_parameters(1, 1, "#{keyword} <Filename>")
+            @meta_init_filename = ConfigParser.handle_nil(parameters[0])
+
+          when 'TIME_ZONE_UTC'
+            parser.verify_num_parameters(0, 0, "#{keyword}")
+            @use_utc = true
+
+          when 'ADD_MD5_FILE'
+            parser.verify_num_parameters(1, 1, "#{keyword} <Filename>")
+            if File.file?(parameters[0])
+              @additional_md5_files << File.expand_path(parameters[0])
+            elsif File.file?(File.join(Cosmos::USERPATH, parameters[0]))
+              @additional_md5_files << File.expand_path(File.join(Cosmos::USERPATH, parameters[0]))
+            else
+              raise "Missing expected file: #{parameters[0]}"
+            end
 
           else
             # blank lines will have a nil keyword and should not raise an exception
@@ -340,6 +401,13 @@ module Cosmos
 
         @acl = ACL.new(acl_list, ACL::ALLOW_DENY) unless acl_list.empty?
 
+        # Explicitly set up time to use UTC or local
+        if @use_utc
+          Time.use_utc()
+        else
+          Time.use_local()
+        end
+
         # Second pass - Process targets
         process_targets(parser, filename, configuration_directory)
 
@@ -362,7 +430,6 @@ module Cosmos
           unless File.exist? path
             raise parser.error("#{path} must exist", usage)
           end
-          system_found = false
           dirs = []
           Dir.foreach(File.join(USERPATH, 'config', 'targets')) { |dir_filename| dirs << dir_filename }
           dirs.sort!
@@ -373,10 +440,7 @@ module Cosmos
                 # current directory then it must have been already processed by
                 # DECLARE_TARGET so we skip it.
                 next if @targets.select {|name, target| target.original_name == dir_filename }.length > 0
-                if dir_filename == 'SYSTEM'
-                  system_found = true
-                  next
-                end
+                next if dir_filename == 'SYSTEM'
                 target = Target.new(dir_filename)
                 @targets[target.name] = target
               else
@@ -387,10 +451,9 @@ module Cosmos
 
           auto_detect_gem_based_targets()
 
-          if system_found
-            target = Target.new('SYSTEM')
-            @targets[target.name] = target
-          end
+          # Make sure SYSTEM target is always present and added last
+          target = Target.new('SYSTEM')
+          @targets[target.name] = target
 
         when 'DECLARE_TARGET'
           usage = "#{keyword} <TARGET NAME> <SUBSTITUTE TARGET NAME (Optional)> <TARGET FILENAME (Optional - defaults to target.txt)>"
@@ -434,7 +497,7 @@ module Cosmos
     #   configuration. Pass nil to load the default configuration.
     # @return [String, Exception/nil] The actual configuration loaded
     def load_configuration(name = nil)
-      if name and @config
+      if name && @config
         # Make sure they're requesting something other than the current
         # configuration.
         if name != @config.name
@@ -481,7 +544,7 @@ module Cosmos
     def auto_detect_gem_based_targets
       Bundler.load.specs.each do |spec|
         spec_name_split = spec.name.split('-')
-        if spec_name_split.length > 1 and spec_name_split[0] == 'cosmos'
+        if spec_name_split.length > 1 && (spec_name_split[0] == 'cosmos')
           # Filter to just targets and not tools and other extensions
           if File.exist?(File.join(spec.gem_dir, 'cmd_tlm'))
             target_name = spec_name_split[1..-1].join('-').to_s.upcase
@@ -514,7 +577,7 @@ module Cosmos
       Cosmos.set_working_dir do
         Dir.foreach(@paths['SAVED_CONFIG']) do |filename|
           full_path = File.join(@paths['SAVED_CONFIG'], filename)
-          if Dir.exist?(full_path) and filename[-32..-1] == name
+          if Dir.exist?(full_path) && (filename[-32..-1] == name)
             return full_path
           end
         end
@@ -573,7 +636,7 @@ module Cosmos
         end
       end
 
-      md5 = Cosmos.md5_files(cmd_tlm_files, additional_data)
+      md5 = Cosmos.md5_files(cmd_tlm_files + @additional_md5_files, additional_data)
       md5_string = md5.hexdigest
 
       # Build filename for marshal file
@@ -612,13 +675,106 @@ module Cosmos
         else
           @config.name = md5_string
         end
+
         Cosmos.marshal_dump(marshal_filename, @config)
       end
+      setup_system_meta()
 
       @initial_config = @config unless @initial_config
       save_configuration()
     end
 
-  end # class System
+    def setup_system_meta
+      # Ensure SYSTEM META is defined and defined correctly
+      begin
+        tlm_meta = @telemetry.packet('SYSTEM', 'META')
+        cmd_meta = @commands.packet('SYSTEM', 'META')
+        item = tlm_meta.get_item('PKTID')
+        raise "PKTID Incorrect" unless (item.bit_size == 8) && (item.bit_offset == 0)
+        item = cmd_meta.get_item('PKTID')
+        raise "PKTID Incorrect" unless (item.bit_size == 8) && (item.bit_offset == 0)
+        item = tlm_meta.get_item('CONFIG')
+        raise "CONFIG Incorrect" unless (item.bit_size == 256) && (item.bit_offset == 8)
+        item = cmd_meta.get_item('CONFIG')
+        raise "CONFIG Incorrect" unless (item.bit_size == 256) && (item.bit_offset == 8)
+        item = tlm_meta.get_item('COSMOS_VERSION')
+        raise "CONFIG Incorrect" unless (item.bit_size == 240) && (item.bit_offset == 264)
+        item = cmd_meta.get_item('COSMOS_VERSION')
+        raise "CONFIG Incorrect" unless (item.bit_size == 240) && (item.bit_offset == 264)
+        item = tlm_meta.get_item('USER_VERSION')
+        raise "CONFIG Incorrect" unless (item.bit_size == 240) && (item.bit_offset == 504)
+        item = cmd_meta.get_item('USER_VERSION')
+        raise "CONFIG Incorrect" unless (item.bit_size == 240) && (item.bit_offset == 504)
+        item = tlm_meta.get_item('RUBY_VERSION')
+        raise "CONFIG Incorrect" unless (item.bit_size == 240) && (item.bit_offset == 744)
+        item = cmd_meta.get_item('RUBY_VERSION')
+        raise "CONFIG Incorrect" unless (item.bit_size == 240) && (item.bit_offset == 744)
+      rescue
+        Logger.error "SYSTEM META not defined or defined incorrectly - defaulting"
+
+        cmd_meta = Packet.new('SYSTEM', 'META', :BIG_ENDIAN)
+        item = cmd_meta.append_item('PKTID', 8, :UINT, nil, :BIG_ENDIAN, :ERROR, nil, nil, nil, 1)
+        item.range = 1..1
+        item.default = 1
+        item.description = 'Packet Id'
+        item = cmd_meta.append_item('CONFIG', 32 * 8, :STRING)
+        item.default = ''
+        item.description = 'Configuration Name'
+        item = cmd_meta.append_item('COSMOS_VERSION', 30 * 8, :STRING)
+        item.default = ''
+        item.description = 'COSMOS Version'
+        item = cmd_meta.append_item('USER_VERSION', 30 * 8, :STRING)
+        item.default = ''
+        item.description = 'User Project Version'
+        item = cmd_meta.append_item('RUBY_VERSION', 30 * 8, :STRING)
+        item.default = ''
+        item.description = 'Ruby Version'
+        @config.commands['SYSTEM'] ||= {}
+        @config.commands['SYSTEM']['META'] = cmd_meta
+
+        tlm_meta = Packet.new('SYSTEM', 'META', :BIG_ENDIAN)
+        item = tlm_meta.append_item('PKTID', 8, :UINT, nil, :BIG_ENDIAN, :ERROR, nil, nil, nil, 1)
+        item.description = 'Packet Id'
+        item = tlm_meta.append_item('CONFIG', 32 * 8, :STRING)
+        item.description = 'Configuration Name'
+        item = tlm_meta.append_item('COSMOS_VERSION', 30 * 8, :STRING)
+        item.description = 'COSMOS Version'
+        item = tlm_meta.append_item('USER_VERSION', 30 * 8, :STRING)
+        item.description = 'User Project Version'
+        item = tlm_meta.append_item('RUBY_VERSION', 30 * 8, :STRING)
+        item.description = 'Ruby Version'
+        @config.telemetry['SYSTEM'] ||= {}
+        @config.telemetry['SYSTEM']['META'] = tlm_meta
+      end
 
-end # module Cosmos
+      # Initialize the meta packet (if given init filename)
+      if @meta_init_filename
+        parser = ConfigParser.new("http://cosmosrb.com/docs/cmdtlm")
+        Cosmos.set_working_dir do
+          parser.parse_file(@meta_init_filename) do |keyword, params|
+            begin
+              item = tlm_meta.get_item(keyword)
+              if (item.data_type == :STRING) || (item.data_type == :BLOCK)
+                value = params[0]
+              else
+                value = params[0].convert_to_value
+              end
+              tlm_meta.write(keyword, value)
+            rescue => err
+              raise parser.error(err, "ITEM_NAME VALUE")
+            end
+          end
+        end
+      end
+
+      # Setup fixed part of SYSTEM META packet
+      tlm_meta.write('PKTID', 1)
+      tlm_meta.write('CONFIG', @config.name)
+      tlm_meta.write('COSMOS_VERSION', "#{COSMOS_VERSION}")
+      tlm_meta.write('USER_VERSION', USER_VERSION) if defined? USER_VERSION
+      tlm_meta.write('RUBY_VERSION', "#{RUBY_VERSION}p#{RUBY_PATCHLEVEL}")
+
+      cmd_meta.buffer = tlm_meta.buffer
+    end
+  end
+end