openc3 5.5.0.pre.beta0 → 5.5.1

data/lib/openc3/api/cmd_api.rb

@@ -99,6 +99,7 @@ module OpenC3
     # @param interface_name [String] The interface to send the raw binary
     # @param data [String] The raw binary data
     def send_raw(interface_name, data, scope: $openc3_scope, token: $openc3_token)
+      interface_name = interface_name.upcase
       authorize(permission: 'cmd_raw', interface_name: interface_name, scope: scope, token: token)
       get_interface(interface_name, scope: scope, token: token) # Check to make sure the interface exists
       InterfaceTopic.write_raw(interface_name, data, scope: scope)
@@ -110,6 +111,8 @@ module OpenC3
     # @param command_name [String] Packet name of the command
     # @return [Hash] command hash with last command buffer
     def get_cmd_buffer(target_name, command_name, scope: $openc3_scope, token: $openc3_token)
+      target_name = target_name.upcase
+      command_name = command_name.upcase
       authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
       TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       topic = "#{scope}__COMMAND__{#{target_name}}__#{command_name}"
@@ -127,6 +130,7 @@ module OpenC3
     # @param target_name [String] Name of the target
     # @return [Array<Hash>] Array of all commands as a hash
     def get_all_commands(target_name, scope: $openc3_scope, token: $openc3_token)
+      target_name = target_name.upcase
       authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
       TargetModel.packets(target_name, type: :CMD, scope: scope)
     end
@@ -137,6 +141,7 @@ module OpenC3
     # @param target_name [String] Name of the target
     # @return [Array<String>] Array of all command packet names
     def get_all_command_names(target_name, scope: $openc3_scope, token: $openc3_token)
+      target_name = target_name.upcase
       authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
       TargetModel.packet_names(target_name, type: :CMD, scope: scope)
     end
@@ -145,23 +150,28 @@ module OpenC3
     #
     # @since 5.0.0
     # @param target_name [String] Name of the target
-    # @param packet_name [String] Name of the packet
+    # @param command_name [String] Name of the packet
     # @return [Hash] Command as a hash
-    def get_command(target_name, packet_name, scope: $openc3_scope, token: $openc3_token)
+    def get_command(target_name, command_name, scope: $openc3_scope, token: $openc3_token)
+      target_name = target_name.upcase
+      command_name = command_name.upcase
       authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
-      TargetModel.packet(target_name, packet_name, type: :CMD, scope: scope)
+      TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
     end
 
     # Returns a hash of the given command parameter
     #
     # @since 5.0.0
     # @param target_name [String] Name of the target
-    # @param packet_name [String] Name of the packet
-    # @param param_name [String] Name of the parameter
+    # @param command_name [String] Name of the packet
+    # @param parameter_name [String] Name of the parameter
     # @return [Hash] Command parameter as a hash
-    def get_parameter(target_name, packet_name, param_name, scope: $openc3_scope, token: $openc3_token)
-      authorize(permission: 'cmd_info', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
-      TargetModel.packet_item(target_name, packet_name, param_name, type: :CMD, scope: scope)
+    def get_parameter(target_name, command_name, parameter_name, scope: $openc3_scope, token: $openc3_token)
+      target_name = target_name.upcase
+      command_name = command_name.upcase
+      parameter_name = parameter_name.upcase
+      authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
+      TargetModel.packet_item(target_name, command_name, parameter_name, type: :CMD, scope: scope)
     end
 
     # Returns whether the specified command is hazardous
@@ -176,35 +186,38 @@ module OpenC3
       extract_string_kwargs_to_args(args, kwargs)
       case args.length
       when 1
-        target_name, command_name, params = extract_fields_from_cmd_text(args[0], scope: scope)
+        target_name, command_name, parameters = extract_fields_from_cmd_text(args[0], scope: scope)
       when 2, 3
         target_name = args[0]
         command_name = args[1]
         if args.length == 2
-          params = {}
+          parameters = {}
         else
-          params = args[2]
+          parameters = args[2]
         end
       else
         # Invalid number of arguments
         raise "ERROR: Invalid number of arguments (#{args.length}) passed to get_cmd_hazardous()"
       end
+      target_name = target_name.upcase
+      command_name = command_name.upcase
+      parameters = parameters.transform_keys(&:upcase)
 
       authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
       packet = TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       return true if packet['hazardous']
 
       packet['items'].each do |item|
-        next unless params.keys.include?(item['name']) && item['states']
+        next unless parameters.keys.include?(item['name']) && item['states']
 
         # States are an array of the name followed by a hash of 'value' and sometimes 'hazardous'
         item['states'].each do |name, hash|
-          param_name = params[item['name']]
+          parameter_name = parameters[item['name']]
           # Remove quotes from string parameters
-          param_name = param_name.gsub('"', '').gsub("'", '') if param_name.is_a?(String)
+          parameter_name = parameter_name.gsub('"', '').gsub("'", '') if parameter_name.is_a?(String)
           # To be hazardous the state must be marked hazardous
           # Check if either the state name or value matches the param passed
-          if hash['hazardous'] && (name == param_name || hash['value'] == param_name)
+          if hash['hazardous'] && (name == parameter_name || hash['value'] == parameter_name)
             return true
           end
         end
@@ -222,6 +235,9 @@ module OpenC3
     #   one of {Packet::VALUE_TYPES}
     # @return [Varies] value
     def get_cmd_value(target_name, command_name, parameter_name, value_type = :CONVERTED, scope: $openc3_scope, token: $openc3_token)
+      target_name = target_name.upcase
+      command_name = command_name.upcase
+      parameter_name = parameter_name.upcase
       authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
       CommandDecomTopic.get_cmd_item(target_name, command_name, parameter_name, type: value_type, scope: scope)
     end
@@ -236,12 +252,15 @@ module OpenC3
     def get_cmd_time(target_name = nil, command_name = nil, scope: $openc3_scope, token: $openc3_token)
       authorize(permission: 'cmd_info', target_name: target_name, packet_name: command_name, scope: scope, token: token)
       if target_name and command_name
+        target_name = target_name.upcase
+        command_name = command_name.upcase
         time = CommandDecomTopic.get_cmd_item(target_name, command_name, 'RECEIVED_TIMESECONDS', type: :CONVERTED, scope: scope)
         [target_name, command_name, time.to_i, ((time.to_f - time.to_i) * 1_000_000).to_i]
       else
         if target_name.nil?
           targets = TargetModel.names(scope: scope)
         else
+          target_name = target_name.upcase
           targets = [target_name]
         end
         targets.each do |target_name|
@@ -268,6 +287,8 @@ module OpenC3
     # @param command_name [String] Packet name of the command
     # @return [Numeric] Transmit count for the command
     def get_cmd_cnt(target_name, command_name, scope: $openc3_scope, token: $openc3_token)
+      target_name = target_name.upcase
+      command_name = command_name.upcase
       authorize(permission: 'system', target_name: target_name, packet_name: command_name, scope: scope, token: token)
       TargetModel.packet(target_name, command_name, type: :CMD, scope: scope)
       Topic.get_cnt("#{scope}__COMMAND__{#{target_name}}__#{command_name}")
@@ -281,6 +302,8 @@ module OpenC3
       authorize(permission: 'system', scope: scope, token: token)
       counts = []
       target_commands.each do |target_name, command_name|
+        target_name = target_name.upcase
+        command_name = command_name.upcase
         counts << Topic.get_cnt("#{scope}__COMMAND__{#{target_name}}__#{command_name}")
       end
       counts
@@ -298,8 +321,8 @@ module OpenC3
       when 1
         target_name, cmd_name, cmd_params = extract_fields_from_cmd_text(args[0], scope: scope)
       when 2, 3
-        target_name = args[0]
-        cmd_name    = args[1]
+        target_name  = args[0]
+        cmd_name     = args[1]
         if args.length == 2
           cmd_params = {}
         else
@@ -309,6 +332,9 @@ module OpenC3
         # Invalid number of arguments
         raise "ERROR: Invalid number of arguments (#{args.length}) passed to #{method_name}()"
       end
+      target_name = target_name.upcase
+      cmd_name = cmd_name.upcase
+      cmd_params = cmd_params.transform_keys(&:upcase)
       authorize(permission: 'cmd', target_name: target_name, packet_name: cmd_name, scope: scope, token: token)
       packet = TargetModel.packet(target_name, cmd_name, type: :CMD, scope: scope)
 

data/lib/openc3/api/tlm_api.rb

@@ -120,11 +120,14 @@ module OpenC3
     def inject_tlm(target_name, packet_name, item_hash = nil, type: :CONVERTED, scope: $openc3_scope, token: $openc3_token)
       authorize(permission: 'tlm_set', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       type = type.to_s.intern
+      target_name = target_name.upcase
+      packet_name = packet_name.upcase
       unless CvtModel::VALUE_TYPES.include?(type)
         raise "Unknown type '#{type}' for #{target_name} #{packet_name}"
       end
 
       if item_hash
+        item_hash = item_hash.transform_keys(&:upcase)
         # Check that the items exist ... exceptions are raised if not
         TargetModel.packet_items(target_name, packet_name, item_hash.keys, scope: scope)
       else
@@ -201,6 +204,8 @@ module OpenC3
     # @param packet_name [String] Name of the packet
     # @return [Hash] telemetry hash with last telemetry buffer
     def get_tlm_buffer(target_name, packet_name, scope: $openc3_scope, token: $openc3_token)
+      target_name = target_name.upcase
+      packet_name = packet_name.upcase
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       TargetModel.packet(target_name, packet_name, scope: scope)
       topic = "#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}"
@@ -222,11 +227,13 @@ module OpenC3
     #   of [item name, item value, item limits state] where the item limits
     #   state can be one of {OpenC3::Limits::LIMITS_STATES}
     def get_tlm_packet(target_name, packet_name, stale_time: 30, type: :CONVERTED, scope: $openc3_scope, token: $openc3_token)
+      target_name = target_name.upcase
+      packet_name = packet_name.upcase
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       packet = TargetModel.packet(target_name, packet_name, scope: scope)
       t = _validate_tlm_type(type)
       raise ArgumentError, "Unknown type '#{type}' for #{target_name} #{packet_name}" if t.nil?
-      items = packet['items'].map { | item | item['name'] }
+      items = packet['items'].map { | item | item['name'].upcase }
       cvt_items = items.map { | item | "#{target_name}__#{packet_name}__#{item}__#{type}" }
       current_values = CvtModel.get_tlm_values(cvt_items, stale_time: stale_time, scope: scope)
       items.zip(current_values).map { | item , values | [item, values[0], values[1]]}
@@ -246,13 +253,18 @@ module OpenC3
       if !items.is_a?(Array) || !items[0].is_a?(String)
         raise ArgumentError, "items must be array of strings: ['TGT__PKT__ITEM__TYPE', ...]"
       end
-
       items.each_with_index do |item, index|
-        target_name, packet_name, item_name, item_type = item.split('__')
+        target_name, packet_name, item_name, value_type = item.split('__')
+        raise ArgumentError, "items must be formatted as TGT__PKT__ITEM__TYPE" if target_name.nil? || packet_name.nil? || item_name.nil? || value_type.nil?
+        target_name = target_name.upcase
+        packet_name = packet_name.upcase
+        item_name = item_name.upcase
+        value_type = value_type.upcase
         if packet_name == 'LATEST'
           _, packet_name, _ = tlm_process_args([target_name, packet_name, item_name], 'get_tlm_values', scope: scope) # Figure out which packet is LATEST
-          items[index] = "#{target_name}__#{packet_name}__#{item_name}__#{item_type}" # Replace LATEST with the real packet name
         end
+        # Change packet_name in case of LATEST and ensure upcase
+        items[index] = "#{target_name}__#{packet_name}__#{item_name}__#{value_type}"
         authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       end
       CvtModel.get_tlm_values(items, stale_time: stale_time, scope: scope)
@@ -264,6 +276,7 @@ module OpenC3
     # @param target_name [String] Name of the target
     # @return [Array<Hash>] Array of all telemetry packet hashes
     def get_all_telemetry(target_name, scope: $openc3_scope, token: $openc3_token)
+      target_name = target_name.upcase
       authorize(permission: 'tlm', target_name: target_name, scope: scope, token: token)
       TargetModel.packets(target_name, type: :TLM, scope: scope)
     end
@@ -274,6 +287,7 @@ module OpenC3
     # @param target_name [String] Name of the target
     # @return [Array<String>] Array of all telemetry packet names
     def get_all_telemetry_names(target_name, scope: $openc3_scope, token: $openc3_token)
+      target_name = target_name.upcase
       authorize(permission: 'cmd_info', target_name: target_name, scope: scope, token: token)
       TargetModel.packet_names(target_name, type: :TLM, scope: scope)
     end
@@ -285,6 +299,8 @@ module OpenC3
     # @param packet_name [String] Name of the packet
     # @return [Hash] Telemetry packet hash
     def get_telemetry(target_name, packet_name, scope: $openc3_scope, token: $openc3_token)
+      target_name = target_name.upcase
+      packet_name = packet_name.upcase
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       TargetModel.packet(target_name, packet_name, scope: scope)
     end
@@ -297,6 +313,9 @@ module OpenC3
     # @param item_name [String] Name of the packet
     # @return [Hash] Telemetry packet item hash
     def get_item(target_name, packet_name, item_name, scope: $openc3_scope, token: $openc3_token)
+      target_name = target_name.upcase
+      packet_name = packet_name.upcase
+      item_name = item_name.upcase
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       TargetModel.packet_item(target_name, packet_name, item_name, scope: scope)
     end
@@ -316,6 +335,8 @@ module OpenC3
 
       result = {}
       packets.each do |target_name, packet_name|
+        target_name = target_name.upcase
+        packet_name = packet_name.upcase
         authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
         topic = "#{scope}__DECOM__{#{target_name}}__#{packet_name}"
         id, _ = Topic.get_newest_message(topic)
@@ -356,6 +377,8 @@ module OpenC3
     # @param packet_name [String] Name of the packet
     # @return [Numeric] Receive count for the telemetry packet
     def get_tlm_cnt(target_name, packet_name, scope: $openc3_scope, token: $openc3_token)
+      target_name = target_name.upcase
+      packet_name = packet_name.upcase
       authorize(permission: 'system', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       TargetModel.packet(target_name, packet_name, scope: scope)
       Topic.get_cnt("#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}")
@@ -369,6 +392,8 @@ module OpenC3
       authorize(permission: 'system', scope: scope, token: token)
       counts = []
       target_packets.each do |target_name, packet_name|
+        target_name = target_name.upcase
+        packet_name = packet_name.upcase
         counts << Topic.get_cnt("#{scope}__TELEMETRY__{#{target_name}}__#{packet_name}")
       end
       counts
@@ -380,6 +405,8 @@ module OpenC3
     # @param packet_name [String] Packet name
     # @return [Array<String>] All of the ignored telemetry items for a packet.
     def get_packet_derived_items(target_name, packet_name, scope: $openc3_scope, token: $openc3_token)
+      target_name = target_name.upcase
+      packet_name = packet_name.upcase
       authorize(permission: 'tlm', target_name: target_name, packet_name: packet_name, scope: scope, token: token)
       packet = TargetModel.packet(target_name, packet_name, scope: scope)
       return packet['items'].select { |item| item['data_type'] == 'DERIVED' }.map { |item| item['name'] }
@@ -413,6 +440,9 @@ module OpenC3
         # Invalid number of arguments
         raise "ERROR: Invalid number of arguments (#{args.length}) passed to #{method_name}()"
       end
+      target_name = target_name.upcase
+      packet_name = packet_name.upcase
+      item_name = item_name.upcase
       if packet_name == 'LATEST'
         latest = -1
         TargetModel.packets(target_name, scope: scope).each do |packet|
@@ -449,6 +479,9 @@ module OpenC3
         # Invalid number of arguments
         raise "ERROR: Invalid number of arguments (#{args.length}) passed to #{method_name}()"
       end
+      target_name = target_name.upcase
+      packet_name = packet_name.upcase
+      item_name = item_name.upcase
       # Determine if this item exists, it will raise appropriate errors if not
       TargetModel.packet_item(target_name, packet_name, item_name, scope: scope)
 

data/lib/openc3/bridge/bridge.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'openc3'
@@ -27,8 +27,8 @@ require 'openc3/bridge/bridge_router_thread'
 
 module OpenC3
   class Bridge
-    def initialize(filename)
-      @config = BridgeConfig.new(filename)
+    def initialize(filename, existing_variables = {})
+      @config = BridgeConfig.new(filename, existing_variables)
       @threads = []
 
       # Start Interface Threads

data/lib/openc3/bridge/bridge_config.rb

@@ -17,7 +17,7 @@
 # All changes Copyright 2022, OpenC3, Inc.
 # All Rights Reserved
 #
-# This file may also be used under the terms of a commercial license 
+# This file may also be used under the terms of a commercial license
 # if purchased from OpenC3, Inc.
 
 require 'openc3/utilities/logger'
@@ -30,28 +30,55 @@ module OpenC3
     # @return [Hash<String, Interface>] Routers hash
     attr_accessor :routers
 
-    def initialize(filename)
+    def initialize(filename, existing_variables = {})
       @interfaces = {}
       @routers = {}
-      process_file(filename)
+      process_file(filename, existing_variables)
     end
 
     def self.generate_default(filename)
       default_config = <<~EOF
-                # Example Host Bridge Configuration for a Serial Port
-                #
-                # INTERFACE <Interface Name> <Interface File> <Interface Params...>
-                # INTERFACE <Interface Name> serial_interface.rb <Write Port> <Read Port> <Baud Rate> <Parity ODD/EVEN/NONE> <Stop Bits> <Write Timeout> <Read Timeout> <Protocol Name> <Protocol Params>
-                # INTERFACE <Interface Name> serial_interface.rb <Write Port> <Read Port> <Baud Rate> <Parity ODD/EVEN/NONE> <Stop Bits> <Write Timeout> <Read Timeout> BURST <Discard Leading Bytes> <Sync Pattern> <Add Sync On Write>
-                # INTERFACE SERIAL_INT serial_interface.rb /dev/ttyS1 /dev/ttyS1 38400 ODD 1 10.0 nil BURST 4 0xDEADBEEF
-                INTERFACE SERIAL_INT serial_interface.rb COM1 COM1 9600 NONE 1 10.0 nil BURST
+        # Write serial port name
+        VARIABLE write_port_name COM1
         #{'        '}
-                # ROUTER <Router Name> <Interface File> <Interface Params...>
-                # ROUTER SERIAL_ROUTER tcpip_server_interface.rb <Write Port> <Read Port> <Write Timeout> <Read Timeout> <Protocol Name> <Protocol Params>
-                # ROUTER SERIAL_ROUTER tcpip_server_interface.rb <Write Port> <Read Port> <Write Timeout> <Read Timeout> BURST <Discard Leading Bytes> <Sync Pattern> <Add Sync On Write>
-                ROUTER SERIAL_ROUTER tcpip_server_interface.rb 2950 2950 10.0 nil BURST
-                  # ROUTE <Interface Name>
-                  ROUTE SERIAL_INT
+        # Read serial port name
+        VARIABLE read_port_name COM1
+        #{'        '}
+        # Baud Rate
+        VARIABLE baud_rate 115200
+        #{'        '}
+        # Parity - NONE, ODD, or EVEN
+        VARIABLE parity NONE
+        #{'        '}
+        # Stop bits - 0, 1, or 2
+        VARIABLE stop_bits 1
+        #{'        '}
+        # Write Timeout
+        VARIABLE write_timeout 10.0
+        #{'        '}
+        # Read Timeout
+        VARIABLE read_timeout nil
+        #{'        '}
+        # Flow Control - NONE, or RTSCTS
+        VARIABLE flow_control NONE
+        #{'        '}
+        # Data bits per word - Typically 8
+        VARIABLE data_bits 8
+        #{'        '}
+        # Port to listen for connections from COSMOS - Plugin must match
+        VARIABLE router_port 2950
+        #{'        '}
+        # Port to listen on for connections from COSMOS. Defaults to localhost for security. Will need to be opened
+        # if COSMOS is on another machine.
+        VARIABLE router_listen_address 127.0.0.1
+        #{'        '}
+        INTERFACE SERIAL_INT serial_interface.rb <%= write_port_name %> <%= read_port_name %> <%= baud_rate %> <%= parity %> <%= stop_bits %> <%= write_timeout %> <%= read_timeout %>
+          OPTION FLOW_CONTROL <%= flow_control %>
+          OPTION DATA_BITS <%= data_bits %>
+        #{'        '}
+        ROUTER SERIAL_ROUTER tcpip_server_interface.rb <%= router_port %> <%= router_port %> 10.0 nil BURST
+          ROUTE SERIAL_INT
+          OPTION LISTEN_ADDRESS <%= router_listen_address %>
         #{'        '}
       EOF
 
@@ -66,18 +93,39 @@ module OpenC3
     # Processes a file and adds in the configuration defined in the file
     #
     # @param filename [String] The name of the configuration file to parse
-    # @param recursive [Boolean] Whether process_file is being called
-    #   recursively
-    def process_file(filename, recursive = false)
+    def process_file(filename, existing_variables = {})
       current_interface_or_router = nil
       current_type = nil
       current_interface_log_added = false
 
       Logger.info "Processing Bridge configuration in file: #{File.expand_path(filename)}"
 
+      variables = {}
       parser = ConfigParser.new
-      parser.parse_file(filename) do |keyword, params|
+      parser.parse_file(filename,
+                        false,
+                        true,
+                        false) do |keyword, params|
         case keyword
+        when 'VARIABLE'
+          usage = "#{keyword} <Variable Name> <Default Value>"
+          parser.verify_num_parameters(2, nil, usage)
+          variable_name = params[0]
+          value = params[1..-1].join(" ")
+          variables[variable_name] = value
+          if existing_variables && existing_variables.key?(variable_name)
+            variables[variable_name] = existing_variables[variable_name]
+          end
+          # Ignore everything else during phase 1
+        end
+      end
+
+      parser = ConfigParser.new
+      parser.parse_file(filename, false, true, true, variables) do |keyword, params|
+        case keyword
+
+        when 'VARIABLE'
+          # Ignore during this pass
 
         when 'INTERFACE'
           usage = "INTERFACE <Name> <Filename> <Specific Parameters>"

data/lib/openc3/interfaces/interface.rb

@@ -25,6 +25,11 @@ require 'openc3/io/raw_logger_pair'
 require 'openc3/utilities/secrets'
 
 module OpenC3
+  # Define a class to allow interfaces and protocols to reject commands without
+  # disconnecting the interface
+  class WriteRejectError < StandardError
+  end
+
   # Defines all the attributes and methods common to all interface classes
   # used by OpenC3.
   class Interface
@@ -330,6 +335,9 @@ module OpenC3
       else
         @write_mutex.synchronize { yield }
       end
+    rescue WriteRejectError => err
+      Logger.error("#{@name}: Write rejected by interface: #{err.message}")
+      raise err
     rescue Exception => err
       Logger.error("#{@name}: Error writing to interface")
       disconnect()

data/lib/openc3/microservices/decom_microservice.rb

@@ -95,7 +95,6 @@ module OpenC3
     # @param log_change [Boolean] Whether to log this limits change event
     def limits_change_callback(packet, item, old_limits_state, value, log_change)
       return if @cancel_thread
-      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       packet_time = packet.packet_time
       message = "#{packet.target_name} #{packet.packet_name} #{item.name} = #{value} is #{item.limits.state}"
       message << " (#{packet.packet_time.sys.formatted})" if packet_time
@@ -136,8 +135,6 @@ module OpenC3
           @logger.error e.formatted
         end
       end
-
-      diff = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start # seconds as a float
     end
   end
 end

data/lib/openc3/microservices/interface_microservice.rb

@@ -202,6 +202,8 @@ module OpenC3
               else
                 next "Interface not connected: #{@interface.name}"
               end
+            rescue WriteRejectError => e
+              next e.message
             rescue => e
               @logger.error "#{@interface.name}: #{e.formatted}"
               next e.message

data/lib/openc3/microservices/reaction_microservice.rb

@@ -264,7 +264,6 @@ module OpenC3
           when 'trigger'
             process_enabled_trigger(data: data)
           end
-          current_time = Time.now.to_i
         rescue StandardError => e
           @logger.error "ReactionWorker-#{@ident} failed to evaluate kind: #{kind} data: #{data}\n#{e.formatted}"
         end

data/lib/openc3/models/cvt_model.rb

@@ -240,11 +240,10 @@ module OpenC3
     # return an ordered array of hash with keys
     def self._parse_item(lookups, overrides, item, scope:)
       target_name, packet_name, item_name, value_type = item.split('__')
-      raise ArgumentError, "items must be formatted as TGT__PKT__ITEM__TYPE" if target_name.nil? || packet_name.nil? || item_name.nil? || value_type.nil?
 
       # We build lookup keys by including all the less formatted types to gracefully degrade lookups
       # This allows the user to specify WITH_UNITS and if there is no conversions it will simply return the RAW value
-      case value_type.upcase
+      case value_type
       when 'RAW'
         keys = [item_name]
       when 'CONVERTED'

data/lib/openc3/models/interface_model.rb

@@ -257,12 +257,15 @@ module OpenC3
         @log_raw = true
 
       when 'SECRET'
-        parser.verify_num_parameters(3, 4, "#{keyword} <Secret Type: ENV or FILE> <Secret Name> <Environment Variable Name or File Path> <Option Name (Optional)>")
+        parser.verify_num_parameters(3, 5, "#{keyword} <Secret Type: ENV or FILE> <Secret Name> <Environment Variable Name or File Path> <Option Name (Optional)> <Secret Store Name (Optional)>")
         @secrets << parameters[0..2]
-        if parameters[3]
+        if ConfigParser.handle_nil(parameters[3])
           # Option Name, Secret Name
           @secret_options << [parameters[3], parameters[1]]
         end
+        if ConfigParser.handle_nil(parameters[4])
+          @secrets[-1] << parameters[4]
+        end
 
       else
         raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Interface/Router: #{keyword} #{parameters.join(" ")}")

data/lib/openc3/models/metadata_model.rb

@@ -69,7 +69,7 @@ module OpenC3
       if @color.nil?
         @color = '#%06x' % (rand * 0xffffff)
       end
-      unless @color =~ /(#*)([0-9,a-f,A-F]{6})/
+      unless @color =~ /(#*)([0-9a-fA-F]{6})/
         raise SortedInputError.new "invalid color, must be in hex format, e.g. #FF0000"
       end
       @color = "##{@color}" unless @color.start_with?('#')

data/lib/openc3/models/microservice_model.rb

@@ -23,7 +23,6 @@
 require 'openc3/top_level'
 require 'openc3/models/model'
 require 'openc3/models/metric_model'
-require 'openc3/models/traefik_model'
 require 'openc3/utilities/bucket'
 
 module OpenC3
@@ -163,7 +162,7 @@ module OpenC3
         parser.verify_num_parameters(1, 2, usage)
         begin
           @ports << [Integer(parameters[0])]
-        rescue => err # In case Integer fails
+        rescue # In case Integer fails
           raise ConfigParser::Error.new(parser, "Port must be an integer: #{parameters[0]}", usage)
         end
         protocol = ConfigParser.handle_nil(parameters[1])
@@ -193,8 +192,12 @@ module OpenC3
         parser.verify_num_parameters(1, 1, "#{keyword} <Container Image Name>")
         @container = parameters[0]
       when 'SECRET'
-        parser.verify_num_parameters(3, 3, "#{keyword} <Secret Type: ENV or FILE> <Secret Name> <Environment Variable Name or File Path>")
-        @secrets << parameters.dup
+        parser.verify_num_parameters(3, 4, "#{keyword} <Secret Type: ENV or FILE> <Secret Name> <Environment Variable Name or File Path> <Secret Store Name (Optional)>")
+        if ConfigParser.handle_nil(parameters[3])
+          @secrets << parameters.dup
+        else
+          @secrets << parameters[0..2]
+        end
       when 'ROUTE_PREFIX'
         parser.verify_num_parameters(1, 1, "#{keyword} <Route Prefix>")
         @prefix = parameters[0]
@@ -225,7 +228,6 @@ module OpenC3
         end
       end
       unless validate_only
-        TraefikModel.register_route(microservice_name: @name, port: @ports[0][0], prefix: @prefix) if @ports[0] and ports[0][0] and @prefix
         ConfigTopic.write({ kind: 'created', type: 'microservice', name: @name, plugin: @plugin }, scope: @scope)
       end
     end
@@ -235,7 +237,6 @@ module OpenC3
       @bucket.list_objects(bucket: ENV['OPENC3_CONFIG_BUCKET'], prefix: prefix).each do |object|
         @bucket.delete_object(bucket: ENV['OPENC3_CONFIG_BUCKET'], key: object.key)
       end
-      TraefikModel.unregister_route(microservice_name: @name, port: @ports[0][0], prefix: @prefix) if @ports[0] and ports[0][0] and @prefix
       ConfigTopic.write({ kind: 'deleted', type: 'microservice', name: @name, plugin: @plugin }, scope: @scope)
     rescue Exception => error
       Logger.error("Error undeploying microservice model #{@name} in scope #{@scope} due to #{error}")

data/lib/openc3/models/note_model.rb

@@ -78,7 +78,7 @@ module OpenC3
       if @color.nil?
         @color = '#%06x' % (rand * 0xffffff)
       end
-      unless @color =~ /(#*)([0-9,a-f,A-F]{6})/
+      unless @color =~ /(#*)([0-9a-fA-F]{6})/
         raise SortedInputError.new "invalid color, must be in hex format, e.g. #FF0000"
       end
       @color = "##{@color}" unless @color.start_with?('#')