cosmos 4.2.4-java → 4.5.0-java

data/lib/cosmos/script/extract.rb

@@ -130,7 +130,7 @@ module Cosmos
       return [target_name, packet_name, item_name, comparison_to_eval] if split_string.length == 3
       raise "ERROR: Check improperly specified: #{text}" if split_string.length < 4
       split_string = text.split(/ /) # Split on regex spaces to preserve spaces in comparison
-      index = split_string.index(item_name)
+      index = split_string.rindex(item_name)
       comparison_to_eval = split_string[(index + 1)..(split_string.length - 1)].join(" ")
       raise "ERROR: Use '==' instead of '=': #{text}" if split_string[3] == '='
       return [target_name, packet_name, item_name, comparison_to_eval]

data/lib/cosmos/script/limits.rb

@@ -98,6 +98,10 @@ module Cosmos
         if result[0] == :LIMITS_CHANGE
           result[1][3] = result[1][3].to_s.intern if result[1][3]
           result[1][4] = result[1][4].to_s.intern if result[1][4]
+          if result[1][5] and result[1][6]
+            result[1][5] = Time.at(result[1][5], result[1][6]).sys
+            result[1].delete_at(6)
+          end
         elsif result[0] == :LIMITS_SETTINGS
           result[1][3] = result[1][3].to_s.intern if result[1][3]
         elsif result[0] == :STALE_PACKET

data/lib/cosmos/script/script.rb

@@ -21,16 +21,10 @@ require 'cosmos/script/tools'
 
 $cmd_tlm_server = nil
 $disconnected_targets = nil
+$disconnect_all_targets = false
 $cmd_tlm_replay_mode = false
 
 module Cosmos
-  # Error raised by the API when a check fails
-  class CheckError < RuntimeError; end
-  # Error raised when a Script should be stopped
-  class StopScript < StandardError; end
-  # Error raised when a TestCase should be skipped by TestRunner
-  class SkipTestCase < StandardError; end
-
   # Provides a proxy to both a disconnected CmdTlmServer instance and the real
   # JsonDRbObject which communicates with the real CmdTlmServer. If targets
   # are disconnected their method calls are forwarded to the disconnected
@@ -48,9 +42,9 @@ module Cosmos
       end
       # Start a Json connect to the real server
       if $cmd_tlm_replay_mode
-        @cmd_tlm_server = JsonDRbObject.new(System.connect_hosts['REPLAY_API'], System.ports['REPLAY_API'])
+        @cmd_tlm_server = JsonDRbObject.new(System.connect_hosts['REPLAY_API'], System.ports['REPLAY_API'], 1.0, Cosmos::System.x_csrf_token)
       else
-        @cmd_tlm_server = JsonDRbObject.new(System.connect_hosts['CTS_API'], System.ports['CTS_API'])
+        @cmd_tlm_server = JsonDRbObject.new(System.connect_hosts['CTS_API'], System.ports['CTS_API'], 1.0, Cosmos::System.x_csrf_token)
       end
     end
 
@@ -58,16 +52,6 @@ module Cosmos
     # us to proxy the methods to either the disconnected CmdTlmServer object
     # or to the real server through the JsonDRbObject.
     def method_missing(method_name, *method_params)
-      if $disconnected_targets && method_params[0].is_a?(String)
-        if method_params.length == 1
-          target = method_params[0].split(" ")[0]
-        else
-          target = method_params[0]
-        end
-        if $disconnected_targets.include?(target)
-          return @disconnected.send(method_name, *method_params)
-        end
-      end
       # Must call shutdown and disconnect on the JsonDrbObject itself
       # to avoid it being sent to the CmdTlmServer
       case method_name
@@ -77,6 +61,28 @@ module Cosmos
       when :disconnect
         @cmd_tlm_server.disconnect
       else
+        if $disconnect_all_targets
+          return @disconnected.send(method_name, *method_params)
+        elsif $disconnected_targets
+          name_string = nil
+          if method_params[0].is_a?(String)
+            name_string = method_params[0]
+          elsif method_params[0].is_a?(Array)
+            if method_params[0][0].is_a?(Array)
+              if method_params[0][0][0].is_a?(String)
+                name_string = method_params[0][0][0]
+              end
+            elsif method_params[0][0].is_a?(String)
+              name_string = method_params[0][0]
+            end
+          end
+          if name_string
+            target = name_string.split(" ")[0]
+            if $disconnected_targets.include?(target)
+              return @disconnected.send(method_name, *method_params)
+            end
+          end
+        end
         @cmd_tlm_server.method_missing(method_name, *method_params)
       end
     end
@@ -95,6 +101,7 @@ module Cosmos
     # Called when this module is mixed in using "include Cosmos::Script"
     def self.included(base)
       $disconnected_targets = nil
+      $disconnect_all_targets = false
       $cmd_tlm_replay_mode = false
       $cmd_tlm_server = nil
       initialize_script_module()
@@ -109,8 +116,9 @@ module Cosmos
       $cmd_tlm_server.shutdown if $cmd_tlm_server
     end
 
-    def set_disconnected_targets(targets, config_file = CmdTlmServer::DEFAULT_CONFIG_FILE)
+    def set_disconnected_targets(targets, all = false, config_file = CmdTlmServer::DEFAULT_CONFIG_FILE)
       $disconnected_targets = targets
+      $disconnect_all_targets = all
       initialize_script_module(config_file)
     end
 
@@ -120,6 +128,7 @@ module Cosmos
 
     def clear_disconnected_targets
       $disconnected_targets = nil
+      $disconnect_all_targets = false
     end
 
     def script_disconnect

data/lib/cosmos/script/scripting.rb

@@ -56,20 +56,20 @@ module Cosmos
       return value
     end
 
-    def prompt(string)
-      prompt_to_continue(string)
+    def prompt(string, **options)
+      prompt_to_continue(string, options)
     end
 
-    def message_box(string, *buttons)
-      prompt_message_box(string, buttons)
+    def message_box(string, *buttons, **options)
+      prompt_message_box(string, buttons, options)
     end
 
-    def vertical_message_box(string, *buttons)
-      prompt_vertical_message_box(string, buttons)
+    def vertical_message_box(string, *buttons, **options)
+      prompt_vertical_message_box(string, buttons, options)
     end
 
-    def combo_box(string, *options)
-      prompt_combo_box(string, options)
+    def combo_box(string, *items, **options)
+      prompt_combo_box(string, items, options)
     end
 
     def _file_dialog(message, directory, filter, select_files = true)
@@ -123,22 +123,24 @@ module Cosmos
       end
     end
 
-    def prompt_to_continue(string)
+    def prompt_to_continue(string, text_color: nil, background_color: nil, font_size: nil, font_family: nil, details: nil)
       print "#{string}: "
+      print "Details: #{details}\n" if details
       gets.chomp
     end
 
-    def prompt_message_box(string, buttons)
+    def prompt_message_box(string, buttons, text_color: nil, background_color: nil, font_size: nil, font_family: nil, details: nil)
       print "#{string} (#{buttons.join(", ")}): "
+      print "Details: #{details}\n" if details
       gets.chomp
     end
 
-    def prompt_vertical_message_box(string, options)
-      prompt_message_box(string, options)
+    def prompt_vertical_message_box(string, buttons, options)
+      prompt_message_box(string, buttons, options)
     end
 
-    def prompt_combo_box(string, options)
-      prompt_message_box(string, options)
+    def prompt_combo_box(string, items, options)
+      prompt_message_box(string, items, options)
     end
   end
 end

data/lib/cosmos/script/telemetry.rb

@@ -203,12 +203,14 @@ module Cosmos
       packet = nil
       # The get_packet_data above returns a Ruby time after the packet_name.
       # This is different from the API.s
-      buffer, target_name, packet_name, time, rx_count = get_packet_data(id, non_block)
+      buffer, target_name, packet_name, time, rx_count, stored, extra = get_packet_data(id, non_block)
       if buffer
         packet = System.telemetry.packet(target_name, packet_name).clone
         packet.buffer = buffer
         packet.received_time = time
         packet.received_count = rx_count
+        packet.stored = stored
+        packet.extra = extra
       end
       packet
     end

data/lib/cosmos/script/tools.rb

@@ -67,20 +67,20 @@ module Cosmos
     # Methods for debugging
     #######################################
 
-    def insert_return(*params)
-      _ensure_script_runner_frame do
-        ScriptRunnerFrame.instance.inline_return = true
-        ScriptRunnerFrame.instance.inline_return_params = params
-      end
-    end
-
     def step_mode
       if defined? ScriptRunnerFrame
+        # Ensure the Frame has toggled to debug so the user can see the Step button
+        _ensure_script_runner_frame do
+          Qt.execute_in_main_thread do
+            ScriptRunnerFrame.instance.toggle_debug(true)
+          end
+        end
         ScriptRunnerFrame.step_mode = true
       end
     end
 
     def run_mode
+      # Run mode simply disables step mode. Debug frame may or may not be displayed.
       if defined? ScriptRunnerFrame
         ScriptRunnerFrame.step_mode = false
       end
@@ -104,7 +104,17 @@ module Cosmos
     # Get a specific screen definition
     def get_screen_definition(screen_full_name, config_filename = nil, force_refresh = false)
       $cmd_tlm_server.get_screen_definition(screen_full_name, config_filename, force_refresh)
-    end  
+    end
+
+    # Show a local telemetry screen
+    def local_screen(title = 'Local Screen', screen_def = nil, x_pos = nil, y_pos = nil, &block)
+      # See script_module_gui.rb
+    end
+
+    # Close all local telemetry screens
+    def close_local_screens
+      # See script_module_gui.rb
+    end
 
   end # module Script
 

data/lib/cosmos/streams/serial_stream.rb

@@ -35,8 +35,10 @@ 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 (default :NONE)
+    # @param flow_control [Symbol] Currently supported :NONE, :RTSCTS (default :NONE)
     # @param data_bits [Integer] Number of data bits (default 8)
+    # @param struct [Array] Array of arrays of fields and values to set in the
+    #   Windows DCB or POSIX structure
     def initialize(write_port_name,
                    read_port_name,
                    baud_rate,
@@ -45,7 +47,8 @@ module Cosmos
                    write_timeout,
                    read_timeout,
                    flow_control = :NONE,
-                   data_bits = 8)
+                   data_bits = 8,
+                   struct = [])
       super()
 
       # The SerialDriver class will validate the parameters
@@ -69,7 +72,8 @@ module Cosmos
                                               @write_timeout,
                                               @read_timeout,
                                               @flow_control,
-                                              @data_bits)
+                                              @data_bits,
+                                              struct)
       else
         @write_serial_port = nil
       end
@@ -84,7 +88,8 @@ module Cosmos
                                                @write_timeout,
                                                @read_timeout,
                                                @flow_control,
-                                               @data_bits)
+                                               @data_bits,
+                                               struct)
         end
       else
         @read_serial_port = nil
@@ -151,5 +156,5 @@ module Cosmos
         @connected = false
       end
     end
-  end # class SerialStream
-end # module Cosmos
+  end
+end

data/lib/cosmos/system/system.rb

@@ -20,6 +20,7 @@ require 'drb/acl'
 require 'zip'
 require 'zip/filesystem'
 require 'bundler'
+require 'thread'
 
 module Cosmos
   # System is the primary entry point into the COSMOS framework. It captures
@@ -29,7 +30,7 @@ module Cosmos
   # #targets variable provides access to all the targets defined by the system.
   # Its primary responsibily is to load the system configuration file and
   # create all the Target instances. It also saves and restores configurations
-  # using a MD5 checksum over the entire configuration to detect changes.
+  # using a hashing checksum over the entire configuration to detect changes.
   class System
     # @return [Hash<String,Fixnum>] Hash of all the known ports and their values
     instance_attr_reader :ports
@@ -67,20 +68,36 @@ module Cosmos
     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
+    # @return [Array<String>] List of files that are to be included in the hashing
     #   calculation in addition to the cmd/tlm definition files that are
     #   automatically included
-    instance_attr_reader :additional_md5_files
+    instance_attr_reader :additional_hashing_files
+    # @return [Hash<String,String>] Hash of the text/color to use for the classificaiton banner
+    instance_attr_reader :classificiation_banner
+    # @return [String] Which hashing algorithm is in use
+    instance_attr_reader :hashing_algorithm
+    # @return [Boolean] Allow router commanding - defaults to false
+    instance_attr_reader :allow_router_commanding
+    # @return [String] API access secret using X-Csrf-Token - defaults to SuperSecret
+    instance_attr_reader :x_csrf_token
+    # @return [Array<String>] Allowed origins in http origin header - defaults to no origin header only
+    instance_attr_reader :allowed_origins
+    # @return [Array<String>] Allowed hosts in http host header - defaults to '127.0.0.1:7777' only
+    instance_attr_reader :allowed_hosts
 
     # Known COSMOS ports
-    KNOWN_PORTS = ['CTS_API', 'TLMVIEWER_API', 'CTS_PREIDENTIFIED', 'CTS_CMD_ROUTER', 'REPLAY_API', 'REPLAY_PREIDENTIFIED', 'REPLAY_CMD_ROUTER', 'DART_STREAM', 'DART_DECOM']
+    KNOWN_PORTS = ['CTS_API', 'TLMVIEWER_API', 'CTS_PREIDENTIFIED', 'CTS_CMD_ROUTER', 'REPLAY_API', 'REPLAY_PREIDENTIFIED', 'REPLAY_CMD_ROUTER', 'DART_STREAM', 'DART_DECOM', 'DART_MASTER']
+    API_PORTS = ['CTS_API', 'TLMVIEWER_API', 'REPLAY_API', 'DART_DECOM', 'DART_MASTER']
     # Known COSMOS hosts
-    KNOWN_HOSTS = ['CTS_API', 'TLMVIEWER_API', 'CTS_PREIDENTIFIED', 'CTS_CMD_ROUTER', 'REPLAY_API', 'REPLAY_PREIDENTIFIED', 'REPLAY_CMD_ROUTER', 'DART_STREAM', 'DART_DECOM']
+    KNOWN_HOSTS = ['CTS_API', 'TLMVIEWER_API', 'CTS_PREIDENTIFIED', 'CTS_CMD_ROUTER', 'REPLAY_API', 'REPLAY_PREIDENTIFIED', 'REPLAY_CMD_ROUTER', 'DART_STREAM', 'DART_DECOM', 'DART_MASTER']
     # Known COSMOS paths
     KNOWN_PATHS = ['LOGS', 'TMP', 'SAVED_CONFIG', 'TABLES', 'HANDBOOKS', 'PROCEDURES', 'SEQUENCES', 'DART_DATA', 'DART_LOGS']
+    # Supported hashing algorithms
+    SUPPORTED_HASHING_ALGORITHMS = ['MD5', 'RMD160', 'SHA1', 'SHA256', 'SHA384', 'SHA512']
 
     @@instance = nil
     @@instance_mutex = Mutex.new
+    @@instance_filename = nil
 
     # Create a new System object. Note, this should not be called directly but
     # you should instead use System.instance and treat this class as a
@@ -90,6 +107,7 @@ module Cosmos
     #   read. Be default this is <Cosmos::USERPATH>/config/system/system.txt
     def initialize(filename = nil)
       raise "Cosmos::System created twice" unless @@instance.nil?
+      @@instance_filename = filename
       reset_variables(filename)
       @@instance = self
     end
@@ -189,11 +207,12 @@ module Cosmos
       @targets = {}
       # Set config to nil so things will lazy load later
       @config = nil
+      @meta_init_filename = nil
       @use_utc = false
       acl_list = []
       all_allowed = false
       first_procedures_path = true
-      @additional_md5_files = []
+      @additional_hashing_files = []
 
       Cosmos.set_working_dir do
         parser = ConfigParser.new("http://cosmosrb.com/docs/system")
@@ -201,7 +220,7 @@ module Cosmos
         # First pass - Everything except targets
         parser.parse_file(filename) do |keyword, parameters|
           case keyword
-          when 'AUTO_DECLARE_TARGETS', 'DECLARE_TARGET', 'DECLARE_GEM_TARGET'
+          when 'AUTO_DECLARE_TARGETS', 'DECLARE_TARGET', 'DECLARE_GEM_TARGET', 'DECLARE_GEM_MULTI_TARGET'
             # Will be handled by second pass
 
           when 'PORT'
@@ -209,6 +228,7 @@ module Cosmos
             parser.verify_num_parameters(2, 2, usage)
             port_name = parameters[0].to_s.upcase
             @ports[port_name] = Integer(parameters[1])
+            @allowed_hosts << "127.0.0.1:#{parameters[1]}" if API_PORTS.include?(port_name)
             Logger.warn("Unknown port name given: #{port_name}") unless KNOWN_PORTS.include?(port_name)
 
           when 'LISTEN_HOST', 'CONNECT_HOST'
@@ -327,16 +347,60 @@ module Cosmos
             parser.verify_num_parameters(0, 0, "#{keyword}")
             @use_utc = true
 
-          when 'ADD_MD5_FILE'
+          when 'ADD_HASH_FILE', 'ADD_MD5_FILE' # MD5 is here for backwards compatibility
             parser.verify_num_parameters(1, 1, "#{keyword} <Filename>")
             if File.file?(parameters[0])
-              @additional_md5_files << File.expand_path(parameters[0])
+              @additional_hashing_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]))
+              @additional_hashing_files << File.expand_path(File.join(Cosmos::USERPATH, parameters[0]))
             else
               raise "Missing expected file: #{parameters[0]}"
             end
 
+          when 'HASHING_ALGORITHM'
+            parser.verify_num_parameters(1, 1, "#{keyword} <Hashing Algorithm>")
+            if SUPPORTED_HASHING_ALGORITHMS.include? parameters[0]
+              @hashing_algorithm = parameters[0]
+            else
+              Logger.error "Unrecognized hashing algorithm: #{parameters[0]}, using default algorithm MD5"
+              @hashing_algorithm = 'MD5'
+            end
+
+          when 'CLASSIFICATION'
+            parser.verify_num_parameters(2, 4, "#{keyword} <Display_Text> <Color Name|Red> <Green> <Blue>")
+            # Determine if the COSMOS color already exists, otherwise create a new one
+            if Cosmos.constants.include? parameters[1].upcase.to_sym
+              # We were given a named color that already exists in COSMOS
+              color = eval("Cosmos::#{parameters[1].upcase}")
+            else
+              if parameters.length < 4
+                # We were given a named color, but it didn't exist in COSMOS already
+                color = Cosmos::getColor(parameters[1].upcase)
+              else
+                # We were given RGB values
+                color = Cosmos::getColor(parameters[1], parameters[2], parameters[3])
+              end
+            end
+
+            @classificiation_banner = {'display_text' => parameters[0],
+                                       'color'        => color}
+
+          when 'ALLOW_ROUTER_COMMANDING'
+            parser.verify_num_parameters(0, 0, "#{keyword}")
+            @allow_router_commanding = true
+
+          when 'X_CSRF_TOKEN'
+            parser.verify_num_parameters(1, 1, "#{keyword} <Token>")
+            @x_csrf_token = ConfigParser.handle_nil(parameters[0])
+
+          when 'ALLOW_ORIGIN'
+            parser.verify_num_parameters(1, 1, "#{keyword} <Origin>")
+            @allowed_origins << parameters[0]
+
+          when 'ALLOW_HOST'
+            parser.verify_num_parameters(1, 1, "#{keyword} <Host:Port>")
+            @allowed_hosts << parameters[0]
+
           else
             # blank lines will have a nil keyword and should not raise an exception
             raise parser.error("Unknown keyword '#{keyword}'") if keyword
@@ -392,13 +456,8 @@ module Cosmos
               end
             end
           end
-
           auto_detect_gem_based_targets()
 
-          # 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)>"
           parser.verify_num_parameters(1, 3, usage)
@@ -429,60 +488,96 @@ module Cosmos
           target = Target.new(target_name, substitute_name, configuration_directory, ConfigParser.handle_nil(parameters[2]), gem_dir)
           @targets[target.name] = target
 
+        when 'DECLARE_GEM_MULTI_TARGET'
+          usage = "#{keyword} <GEM NAME> <TARGET NAME> <SUBSTITUTE TARGET NAME (Optional)> <TARGET FILENAME (Optional - defaults to target.txt)>"
+          parser.verify_num_parameters(2, 4, usage)
+
+          target_name = parameters[1].to_s.upcase
+          substitute_name = nil
+          substitute_name = ConfigParser.handle_nil(parameters[2])
+          substitute_name.to_s.upcase if substitute_name
+          gem_dir = Gem::Specification.find_by_name(parameters[0]).gem_dir
+          gem_dir = File.join(gem_dir, target_name)
+          target = Target.new(target_name, substitute_name, configuration_directory, ConfigParser.handle_nil(parameters[3]), gem_dir)
+          @targets[target.name] = target
+
         end # case keyword
       end # parser.parse_file
+
+      # Make sure SYSTEM target is always present and added last
+      unless @targets.key?('SYSTEM')
+        target = Target.new('SYSTEM')
+        @targets[target.name] = target
+      end
     end
 
     # Load the specified configuration by iterating through the SAVED_CONFIG
-    # directory looking for a matching MD5 sum. Updates the internal state so
+    # directory looking for a matching hashing sum. Updates the internal state so
     # subsequent commands and telemetry methods return the new configuration.
     #
-    # @param name [String] MD5 string which identifies the
+    # @param name [String] hash string which identifies the
     #   configuration. Pass nil to load the default configuration.
     # @return [String, Exception/nil] The actual configuration loaded
     def load_configuration(name = nil)
-      unless @config
-        # Ensure packets have been lazy loaded
-        System.commands
-      end
+      # Ensure packets have been lazy loaded
+      load_packets() unless @config
 
-      if name && @config
-        # Make sure they're requesting something other than the current
-        # configuration.
-        if name != @config.name
-          # If they want the initial configuration we can just swap out the
-          # current configuration without doing any file processing
-          if name == @initial_config.name
-            update_config(@initial_config)
-          else
-            # Look for the requested configuration in the saved configurations
-            configuration = find_configuration(name)
-            if configuration
-              # We found the configuration requested. Reprocess the system.txt
-              # and reload the packets
-              begin
-                unless File.directory?(configuration)
-                  # Zip file configuration so unzip and reset configuration path
-                  configuration = unzip(configuration)
+      @@instance_mutex.synchronize do
+        if @config_blacklist[name]
+          Logger.warn "Ignoring failed config #{name}"
+          update_config(@initial_config)
+          return @config.name, RuntimeError.new("Ignoring failed config #{name}")
+        end
+
+        if name && @config
+          # Make sure they're requesting something other than the current
+          # configuration.
+          if name != @config.name
+            # If they want the initial configuration we can just swap out the
+            # current configuration without doing any file processing
+            if name == @initial_config.name
+              Logger.info "Switching to initial configuration: #{name}"
+              update_config(@initial_config)
+            else
+              # Look for the requested configuration in the saved configurations
+              configuration = find_configuration(name)
+              if configuration
+                # We found the configuration requested. Reprocess the system.txt
+                # and reload the packets
+                begin
+                  unless File.directory?(configuration)
+                    # Zip file configuration so unzip and reset configuration path
+                    configuration = unzip(configuration)
+                  end
+
+                  Logger.info "Switching to configuration: #{name}"
+                  process_file(File.join(configuration, 'system.txt'), configuration)
+                  load_packets(name, false)
+                rescue Exception => error
+                  # Failed to load - Restore initial
+                  @config_blacklist[name] = true # Prevent wasting time trying to load the bad configuration again
+                  Logger.error "Problem loading configuration from #{configuration}: #{error.class}:#{error.message}\n#{error.backtrace.join("\n")}\n"
+                  Logger.info "Switching to initial configuration: #{@initial_config.name}"
+                  update_config(@initial_config)
+                  return @config.name, error
                 end
-                process_file(File.join(configuration, 'system.txt'), configuration)
-                load_packets(name)
-              rescue Exception => error
-                # Failed to load - Restore initial
+              else
+                # We couldn't find the configuration request. Reload the
+                # initial configuration
+                Logger.error "Unable to find configuration: #{name}"
+                Logger.info "Switching to initial configuration: #{@initial_config.name}"
                 update_config(@initial_config)
-                return @config.name, error
+                return @config.name, RuntimeError.new("Unable to find configuration: #{name}")
               end
-            else
-              # We couldn't find the configuration request. Reload the
-              # initial configuration
-              update_config(@initial_config)
             end
           end
+        else
+          Logger.info "Switching to initial configuration: #{@initial_config.name}"
+          update_config(@initial_config)
         end
-      else
-        update_config(@initial_config)
+
+        return @config.name, nil
       end
-      return @config.name, nil
     end
 
     # (see #load_configuration)
@@ -495,7 +590,6 @@ module Cosmos
     # @param filename [String] Path to system.txt config file to process. Defaults to config/system/system.txt
     def reset_variables(filename = nil)
       @targets = {}
-      @targets['UNKNOWN'] = Target.new('UNKNOWN')
       @config = nil
       @commands = nil
       @telemetry = nil
@@ -510,8 +604,9 @@ module Cosmos
       @staleness_seconds = 30
       @limits_set = :DEFAULT
       @use_utc = false
-      @additional_md5_files = []
+      @additional_hashing_files = []
       @meta_init_filename = nil
+      @hashing_algorithm = 'MD5'
 
       @ports = {}
       @ports['CTS_API'] = 7777
@@ -521,21 +616,22 @@ module Cosmos
       @ports['REPLAY_API'] = 7877
       @ports['REPLAY_PREIDENTIFIED'] = 7879
       @ports['REPLAY_CMD_ROUTER'] = 7880
-      @ports['DART_DECOM'] = 8777
-      @ports['DART_STREAM'] = 8779
+
+      @ports['DART_STREAM'] = 8777
+      @ports['DART_DECOM'] = 8779
+      @ports['DART_MASTER'] = 8780
 
       @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'
+      @listen_hosts['CTS_PREIDENTIFIED'] = '127.0.0.1'
+      @listen_hosts['CTS_CMD_ROUTER'] = '127.0.0.1'
       @listen_hosts['REPLAY_API'] = '127.0.0.1'
-      # Localhost would be more secure but historically these are open to allow for chaining servers by default
-      @listen_hosts['REPLAY_PREIDENTIFIED'] = '0.0.0.0'
-      @listen_hosts['REPLAY_CMD_ROUTER'] = '0.0.0.0'
-      @listen_hosts['DART_STREAM'] = '0.0.0.0'
-      @listen_hosts['DART_DECOM'] = '0.0.0.0'
+      @listen_hosts['REPLAY_PREIDENTIFIED'] = '127.0.0.1'
+      @listen_hosts['REPLAY_CMD_ROUTER'] = '127.0.0.1'
+      @listen_hosts['DART_STREAM'] = '127.0.0.1'
+      @listen_hosts['DART_DECOM'] = '127.0.0.1'
+      @listen_hosts['DART_MASTER'] = '127.0.0.1'
 
       @connect_hosts = {}
       @connect_hosts['CTS_API'] = '127.0.0.1'
@@ -547,6 +643,7 @@ module Cosmos
       @connect_hosts['REPLAY_CMD_ROUTER'] = '127.0.0.1'
       @connect_hosts['DART_STREAM'] = '127.0.0.1'
       @connect_hosts['DART_DECOM'] = '127.0.0.1'
+      @connect_hosts['DART_MASTER'] = '127.0.0.1'
 
       @paths = {}
       @paths['LOGS'] = File.join(USERPATH, 'outputs', 'logs')
@@ -559,6 +656,11 @@ module Cosmos
       @paths['DART_DATA'] = File.join(USERPATH, 'outputs', 'dart', 'data')
       @paths['DART_LOGS'] = File.join(USERPATH, 'outputs', 'dart', 'logs')
 
+      @allow_router_commanding = false
+      @x_csrf_token = 'SuperSecret'
+      @allowed_origins = []
+      @allowed_hosts = ['127.0.0.1:7777', '127.0.0.1:7778', '127.0.0.1:7877', '127.0.0.1:8779', '127.0.0.1:8780']
+
       unless filename
         system_arg = false
         ARGV.each do |arg|
@@ -575,10 +677,11 @@ module Cosmos
 
       @initial_filename = filename
       @initial_config = nil
+      @config_blacklist = {}
     end
 
     # Reset variables and load packets
-    def reset(filename = nil)
+    def reset(filename = @@instance_filename)
       reset_variables(filename)
       load_packets()
     end
@@ -653,11 +756,31 @@ module Cosmos
       Bundler.load.specs.each do |spec|
         spec_name_split = spec.name.split('-')
         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
-            target = Target.new(target_name, nil, nil, nil, spec.gem_dir)
-            @targets[target.name] = target
+          # search for multiple targets packaged in a single gem
+          dirs = []
+          Dir.foreach(spec.gem_dir) { |dir_filename| dirs << dir_filename }
+          dirs.sort!
+          dirs.each do |dir_filename|
+            if dir_filename == "."
+              # check the base directory
+              curr_dir = spec.gem_dir
+              target_name = spec_name_split[1..-1].join('-').to_s.upcase
+            else
+              #check for targets in other directories 1 level deep
+              next if dir_filename[0] == '.'               #skip dot directories and ".."
+              next if dir_filename != dir_filename.upcase  #skip non uppercase directories
+              curr_dir = File.join(spec.gem_dir, dir_filename)
+              target_name = dir_filename
+            end
+            # check for the cmd_tlm directory - if it has it, then we have found a target
+            if File.directory?(File.join(curr_dir,'cmd_tlm'))
+              # If any of the targets original directory name matches the
+              # 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 == target_name }.length > 0
+              target = Target.new(target_name,nil, nil, nil, spec.gem_dir)
+              @targets[target.name] = target
+           end
           end
         end
       end
@@ -686,9 +809,10 @@ module Cosmos
         configuration = find_configuration(@config.name)
         configuration = File.join(@paths['SAVED_CONFIG'], File.build_timestamped_filename([@config.name], '.zip')) unless configuration
         unless File.exist?(configuration)
+          configuration_tmp = File.join(@paths['SAVED_CONFIG'], File.build_timestamped_filename(['tmp_' + @config.name], '.zip.tmp'))
           begin
             Zip.continue_on_exists_proc = true
-            Zip::File.open(configuration, Zip::File::CREATE) do |zipfile|
+            Zip::File.open(configuration_tmp, Zip::File::CREATE) do |zipfile|
               zip_file_path = File.basename(configuration, ".zip")
               zipfile.mkdir zip_file_path
 
@@ -720,6 +844,7 @@ module Cosmos
                 end
               end
             end
+            File.rename(configuration_tmp, configuration)
             File.chmod(0444, configuration) # Mark readonly
           rescue Exception => error
             Logger.error "Problem saving configuration to #{configuration}: #{error.class}:#{error.message}\n#{error.backtrace.join("\n")}\n"
@@ -728,12 +853,13 @@ module Cosmos
       end
     end
 
-    def load_packets(configuration_name = nil)
-      # Determine MD5 over all targets cmd_tlm files
+    def load_packets_internal(configuration_name = nil)
+      # Determine hashing over all targets cmd_tlm files
       cmd_tlm_files = []
       additional_data = ''
       @targets.each do |target_name, target|
         cmd_tlm_files << target.filename if File.exist?(target.filename)
+        cmd_tlm_files.concat(target.requires)
         cmd_tlm_files.concat(target.cmd_tlm_files)
         if target.substitute
           additional_data << target.original_name
@@ -743,11 +869,13 @@ module Cosmos
         end
       end
 
-      md5 = Cosmos.md5_files(cmd_tlm_files + @additional_md5_files, additional_data)
-      md5_string = md5.hexdigest
+      hashing_result = Cosmos.hash_files(cmd_tlm_files + @additional_hashing_files, additional_data, @hashing_algorithm)
+      hash_string = hashing_result.hexdigest
+      # Only use at most, 32 characters of the hex
+      hash_string = hash_string[-32..-1] if hash_string.length >= 32
 
       # Build filename for marshal file
-      marshal_filename = File.join(@paths['TMP'], 'marshal_' << md5_string << '.bin')
+      marshal_filename = File.join(@paths['TMP'], 'marshal_' << hash_string << '.bin')
 
       # Attempt to load marshal file
       config = Cosmos.marshal_load(marshal_filename)
@@ -780,7 +908,7 @@ module Cosmos
         if configuration_name
           @config.name = configuration_name
         else
-          @config.name = md5_string
+          @config.name = hash_string
         end
 
         Cosmos.marshal_dump(marshal_filename, @config)
@@ -791,6 +919,16 @@ module Cosmos
       save_configuration()
     end
 
+    def load_packets(configuration_name = nil, take_mutex = true)
+      if take_mutex
+        @@instance_mutex.synchronize do
+          load_packets_internal(configuration_name)
+        end
+      else
+        load_packets_internal(configuration_name)
+      end
+    end
+
     def setup_system_meta
       # Ensure SYSTEM META is defined and defined correctly
       begin