openc3 5.2.0 → 5.3.0

data/lib/openc3/interfaces/tcpip_server_interface.rb

@@ -58,8 +58,6 @@ module OpenC3
     attr_accessor :raw_logger_pair
     # @return [String] The ip address to bind to.  Default to ANY (0.0.0.0)
     attr_accessor :listen_address
-    # @return [boolean] Automatically send SYSTEM META on connect - Default false - Can be CMD/TLM
-    attr_accessor :auto_system_meta
 
     # @param write_port [Integer] The server write port. Clients should connect
     #   and expect to receive data from this port.
@@ -114,7 +112,6 @@ module OpenC3
       @raw_logging_enabled = false
       @connection_mutex = Mutex.new
       @listen_address = "0.0.0.0"
-      @auto_system_meta = false
 
       @read_allowed = false unless ConfigParser.handle_nil(read_port)
       @write_allowed = false unless ConfigParser.handle_nil(write_port)
@@ -282,15 +279,12 @@ module OpenC3
 
     # Supported Options
     # LISTEN_ADDRESS - Ip address of the interface to accept connections on - Default: 0.0.0.0
-    # AUTO_SYSTEM_META - Automatically send SYSTEM META on connect - Default false
     # (see Interface#set_option)
     def set_option(option_name, option_values)
       super(option_name, option_values)
       case option_name.upcase
       when 'LISTEN_ADDRESS'
         @listen_address = option_values[0]
-      when 'AUTO_SYSTEM_META'
-        @auto_system_meta = ConfigParser.handle_true_false(option_values[0])
       end
     end
 
@@ -411,11 +405,6 @@ module OpenC3
       interface.connect
 
       if listen_write
-        if @auto_system_meta
-          meta_packet = System.telemetry.packet('SYSTEM', 'META').clone
-          interface.write(meta_packet)
-        end
-
         @write_connection_callback.call(interface) if @write_connection_callback
         @connection_mutex.synchronize do
           @write_interface_infos << InterfaceInfo.new(interface, hostname, host_ip, port)

data/lib/openc3/interfaces.rb

@@ -17,11 +17,12 @@
 # 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.
 
 module OpenC3
   autoload(:Interface, 'openc3/interfaces/interface.rb')
+  autoload(:MqttInterface, 'openc3/interfaces/mqtt_interface.rb')
   autoload(:StreamInterface, 'openc3/interfaces/stream_interface.rb')
   autoload(:SerialInterface, 'openc3/interfaces/serial_interface.rb')
   autoload(:SimulatedTargetInterface, 'openc3/interfaces/simulated_target_interface.rb')
@@ -31,7 +32,6 @@ module OpenC3
   autoload(:LincInterface, 'openc3/interfaces/linc_interface.rb')
   autoload(:LincHandshakeCommand, 'openc3/interfaces/linc_interface.rb')
   autoload(:LincHandshake, 'openc3/interfaces/linc_interface.rb')
-  autoload(:DartStatusInterface, 'openc3/interfaces/dart_status_interface.rb')
 
   autoload(:Protocol, 'openc3/interfaces/protocols/protocol.rb')
   autoload(:BurstProtocol, 'openc3/interfaces/protocols/burst_protocol.rb')
@@ -41,7 +41,6 @@ module OpenC3
   autoload(:TemplateProtocol, 'openc3/interfaces/protocols/template_protocol.rb')
   autoload(:TerminatedProtocol, 'openc3/interfaces/protocols/terminated_protocol.rb')
 
-  autoload(:OverrideProtocol, 'openc3/interfaces/protocols/override_protocol.rb')
   autoload(:CrcProtocol, 'openc3/interfaces/protocols/crc_protocol.rb')
   autoload(:IgnorePacketProtocol, 'openc3/interfaces/protocols/ignore_packet_protocol.rb')
 end

data/lib/openc3/logs/buffered_packet_log_reader.rb

@@ -31,8 +31,8 @@ module OpenC3
       @buffer_depth = buffer_depth
     end
 
-    def next_packet_time
-      fill_buffer()
+    def next_packet_time(identify_and_define = true)
+      fill_buffer(identify_and_define)
       packet = @buffer[0]
       return packet.packet_time if packet
       return nil

data/lib/openc3/microservices/interface_microservice.rb

@@ -107,6 +107,28 @@ module OpenC3
               end
               next 'SUCCESS'
             end
+            if msg_hash.key?('interface_cmd')
+              params = JSON.parse(msg_hash['interface_cmd'], allow_nan: true, create_additions: true)
+              begin
+                @logger.info "#{@interface.name}: interface_cmd: #{params['cmd_name']} #{params['cmd_params'].join(' ')}"
+                @interface.interface_cmd(params['cmd_name'], params['cmd_params'])
+              rescue => e
+                @logger.error "#{@interface.name}: interface_cmd: #{e.formatted}"
+                next e.message
+              end
+              next 'SUCCESS'
+            end
+            if msg_hash.key?('protocol_cmd')
+              params = JSON.parse(msg_hash['protocol_cmd'], allow_nan: true, create_additions: true)
+              begin
+                @logger.info "#{@interface.name}: protocol_cmd: #{params['cmd_name']} #{params['cmd_params'].join(' ')} read_write: #{params['read_write']} index: #{params['index']}"
+                @interface.protocol_cmd(params['cmd_name'], params['cmd_params'], read_write: params['read_write'], index: params['index'])
+              rescue => e
+                @logger.error "#{@interface.name}: protocol_cmd: #{e.formatted}"
+                next e.message
+              end
+              next 'SUCCESS'
+            end
           end
 
           target_name = msg_hash['target_name']
@@ -234,6 +256,28 @@ module OpenC3
               @router.stop_raw_logging
             end
           end
+          if msg_hash.key?('router_cmd')
+            params = JSON.parse(msg_hash['router_cmd'], allow_nan: true, create_additions: true)
+            begin
+              @logger.info "#{@router.name}: router_cmd: #{params['cmd_name']} #{params['cmd_params'].join(' ')}"
+              @router.interface_cmd(params['cmd_name'], params['cmd_params'])
+            rescue => e
+              @logger.error "#{@router.name}: router_cmd: #{e.formatted}"
+              next e.message
+            end
+            next 'SUCCESS'
+          end
+          if msg_hash.key?('protocol_cmd')
+            params = JSON.parse(msg_hash['protocol_cmd'], allow_nan: true, create_additions: true)
+            begin
+              @logger.info "#{@router.name}: protocol_cmd: #{params['cmd_name']} #{params['cmd_params'].join(' ')} read_write: #{params['read_write']} index: #{params['index']}"
+              @router.protocol_cmd(params['cmd_name'], params['cmd_params'], read_write: params['read_write'], index: params['index'])
+            rescue => e
+              @logger.error "#{@router.name}: protoco_cmd: #{e.formatted}"
+              next e.message
+            end
+            next 'SUCCESS'
+          end
           next 'SUCCESS'
         end
 
@@ -264,6 +308,7 @@ module OpenC3
     UNKNOWN_BYTES_TO_PRINT = 16
 
     def initialize(name)
+      @mutex = Mutex.new
       super(name)
       @interface_or_router = self.class.name.to_s.split("Microservice")[0].upcase.split("::")[-1]
       @scope = name.split("__")[0]
@@ -307,7 +352,6 @@ module OpenC3
       @cancel_thread = false
       @connection_failed_messages = []
       @connection_lost_messages = []
-      @mutex = Mutex.new
       if @interface_or_router == 'INTERFACE'
         @handler_thread = InterfaceCmdHandlerThread.new(@interface, self, logger: @logger, scope: @scope)
       else
@@ -560,7 +604,7 @@ module OpenC3
 
     # Disconnect from the interface and stop the thread
     def stop
-      @logger.info "#{@interface.name}: stop requested"
+      @logger.info "#{@interface ? @interface.name : @name}: stop requested"
       @mutex.synchronize do
         # Need to make sure that @cancel_thread is set and the interface disconnected within
         # mutex to ensure that connect() is not called when we want to stop()
@@ -578,7 +622,7 @@ module OpenC3
     end
 
     def shutdown(sig = nil)
-      @logger.info "#{@interface.name}: shutdown requested"
+      @logger.info "#{@interface ? @interface.name : @name}: shutdown requested"
       stop()
       super()
     end

data/lib/openc3/microservices/microservice.rb

@@ -27,6 +27,7 @@ OpenC3.require_file 'fileutils'
 OpenC3.require_file 'openc3/utilities/zip'
 OpenC3.require_file 'openc3/utilities/store'
 OpenC3.require_file 'openc3/utilities/bucket'
+OpenC3.require_file 'openc3/utilities/secrets'
 OpenC3.require_file 'openc3/utilities/sleeper'
 OpenC3.require_file 'openc3/utilities/open_telemetry'
 OpenC3.require_file 'openc3/models/microservice_model'
@@ -43,6 +44,7 @@ module OpenC3
     attr_accessor :custom
     attr_accessor :scope
     attr_accessor :logger
+    attr_accessor :secrets
 
     def self.run(name = nil)
       name = ENV['OPENC3_MICROSERVICE_NAME'] unless name
@@ -93,6 +95,7 @@ module OpenC3
       @logger = Logger.new
       @logger.scope = @scope
       @logger.microservice_name = @name
+      @secrets = Secrets.getClient
 
       OpenC3.setup_open_telemetry(@name, false)
 
@@ -104,6 +107,9 @@ module OpenC3
       if @config
         @topics = @config['topics']
         @plugin = @config['plugin']
+        if @config['secrets']
+          @secrets.setup(@config['secrets'])
+        end
       else
         @config = {}
         @plugin = nil

data/lib/openc3/models/cvt_model.rb

@@ -25,30 +25,29 @@ require 'openc3/utilities/store'
 module OpenC3
   class CvtModel
     VALUE_TYPES = [:RAW, :CONVERTED, :FORMATTED, :WITH_UNITS]
-    # Stores telemetry item overrides which are returned on every request to get_item
-    @overrides = {}
-
     def self.build_json_from_packet(packet)
       packet.decom
     end
 
     # Delete the current value table for a target
-    def self.del(target_name:, packet_name:, scope:)
+    def self.del(target_name:, packet_name:, scope: $openc3_scope)
       Store.hdel("#{scope}__tlm__#{target_name}", packet_name)
     end
 
     # Set the current value table for a target, packet
-    def self.set(hash, target_name:, packet_name:, scope:)
+    def self.set(hash, target_name:, packet_name:, scope: $openc3_scope)
       Store.hset("#{scope}__tlm__#{target_name}", packet_name, JSON.generate(hash.as_json(:allow_nan => true)))
     end
 
     # Set an item in the current value table
-    def self.set_item(target_name, packet_name, item_name, value, type:, scope:)
+    def self.set_item(target_name, packet_name, item_name, value, type:, scope: $openc3_scope)
       case type
       when :WITH_UNITS
         field = "#{item_name}__U"
+        value = value.to_s # WITH_UNITS should always be a string
       when :FORMATTED
         field = "#{item_name}__F"
+        value = value.to_s # FORMATTED should always be a string
       when :CONVERTED
         field = "#{item_name}__C"
       when :RAW
@@ -62,27 +61,37 @@ module OpenC3
     end
 
     # Get an item from the current value table
-    def self.get_item(target_name, packet_name, item_name, type:, scope:)
-      if @overrides["#{target_name}__#{packet_name}__#{item_name}__#{type}"]
-        return @overrides["#{target_name}__#{packet_name}__#{item_name}__#{type}"]
-      end
-
+    def self.get_item(target_name, packet_name, item_name, type:, scope: $openc3_scope)
+      override_key = item_name
       types = []
       case type
       when :WITH_UNITS
         types = ["#{item_name}__U", "#{item_name}__F", "#{item_name}__C", item_name]
+        override_key = "#{item_name}__U"
       when :FORMATTED
         types = ["#{item_name}__F", "#{item_name}__C", item_name]
+        override_key = "#{item_name}__F"
       when :CONVERTED
         types = ["#{item_name}__C", item_name]
+        override_key = "#{item_name}__C"
       when :RAW
         types = [item_name]
       else
         raise "Unknown type '#{type}' for #{target_name} #{packet_name} #{item_name}"
       end
+      overrides = Store.hget("#{scope}__override__#{target_name}", packet_name)
+      if overrides
+        result = JSON.parse(overrides, :allow_nan => true, :create_additions => true)[override_key]
+        return result if result
+      end
       hash = JSON.parse(Store.hget("#{scope}__tlm__#{target_name}", packet_name), :allow_nan => true, :create_additions => true)
       hash.values_at(*types).each do |result|
-        return result if result
+        if result
+          if type == :FORMATTED or type == :WITH_UNITS
+            return result.to_s
+          end
+          return result
+        end
       end
       return nil
     end
@@ -97,10 +106,11 @@ module OpenC3
       results = []
       lookups = []
       packet_lookup = {}
+      overrides = {}
       # First generate a lookup hash of all the items represented so we can query the CVT
-      items.each { |item| _parse_item(lookups, item) }
+      items.each { |item| _parse_item(lookups, overrides, item, scope: scope) }
 
-      lookups.each do |target_packet_key, target_name, packet_name, packet_values|
+      lookups.each do |target_packet_key, target_name, packet_name, value_keys|
         unless packet_lookup[target_packet_key]
           packet = Store.hget("#{scope}__tlm__#{target_name}", packet_name)
           raise "Packet '#{target_name} #{packet_name}' does not exist" unless packet
@@ -108,23 +118,26 @@ module OpenC3
         end
         hash = packet_lookup[target_packet_key]
         item_result = []
-        packet_values.each do |value|
-          item_result[0] = hash[value]
-          break if item_result[0] # We want the first value
-        end
-        # If we were able to find a value, try to get the limits state
-        if item_result[0]
-          if now - hash['RECEIVED_TIMESECONDS'] > stale_time
-            item_result[1] = :STALE
+        if value_keys.is_a?(Hash) # Set in _parse_item to indicate override
+          item_result[0] = value_keys['value']
+        else
+          value_keys.each do |key|
+            item_result[0] = hash[key]
+            break if item_result[0] # We want the first value
+          end
+          # If we were able to find a value, try to get the limits state
+          if item_result[0]
+            if now - hash['RECEIVED_TIMESECONDS'] > stale_time
+              item_result[1] = :STALE
+            else
+              # The last key is simply the name (RAW) so we can append __L
+              # If there is no limits then it returns nil which is acceptable
+              item_result[1] = hash["#{value_keys[-1]}__L"]
+              item_result[1] = item_result[1].intern if item_result[1] # Convert to symbol
+            end
           else
-            # The last key is simply the name (RAW) so we can append __L
-            # If there is no limits then it returns nil which is acceptable
-            item_result[1] = hash["#{packet_values[-1]}__L"]
-            item_result[1] = item_result[1].intern if item_result[1] # Convert to symbol
+            raise "Item '#{target_name} #{packet_name} #{value_keys[-1]}' does not exist" unless hash.key?(value_keys[-1])
           end
-        else
-          raise "Item '#{target_name} #{packet_name} #{packet_values[-1]}' does not exist" unless hash.key?(packet_values[-1])
-          item_result[1] = nil
         end
         results << item_result
       end
@@ -133,35 +146,64 @@ module OpenC3
 
     # Override a current value table item such that it always returns the same value
     # for the given type
-    def self.override(target_name, packet_name, item_name, value, type:, scope: $openc3_scope)
-      if VALUE_TYPES.include?(type)
-        @overrides["#{target_name}__#{packet_name}__#{item_name}__#{type}"] = value
+    def self.override(target_name, packet_name, item_name, value, type: :ALL, scope: $openc3_scope)
+      hash = Store.hget("#{scope}__override__#{target_name}", packet_name)
+      hash = JSON.parse(hash, :allow_nan => true, :create_additions => true) if hash
+      hash ||= {} # In case the above didn't create anything
+      case type
+      when :ALL
+        hash[item_name] = value
+        hash["#{item_name}__C"] = value
+        hash["#{item_name}__F"] = value.to_s
+        hash["#{item_name}__U"] = value.to_s
+      when :RAW
+        hash[item_name] = value
+      when :CONVERTED
+        hash["#{item_name}__C"] = value
+      when :FORMATTED
+        hash["#{item_name}__F"] = value.to_s # Always a String
+      when :WITH_UNITS
+        hash["#{item_name}__U"] = value.to_s # Always a String
       else
         raise "Unknown type '#{type}' for #{target_name} #{packet_name} #{item_name}"
       end
+      Store.hset("#{scope}__override__#{target_name}", packet_name, JSON.generate(hash.as_json(:allow_nan => true)))
     end
 
     # Normalize a current value table item such that it returns the actual value
     def self.normalize(target_name, packet_name, item_name, type: :ALL, scope: $openc3_scope)
-      if type == :ALL
-        VALUE_TYPES.each do |type|
-          @overrides.delete("#{target_name}__#{packet_name}__#{item_name}__#{type}")
-        end
+      hash = Store.hget("#{scope}__override__#{target_name}", packet_name)
+      hash = JSON.parse(hash, :allow_nan => true, :create_additions => true) if hash
+      hash ||= {} # In case the above didn't create anything
+      case type
+      when :ALL
+        hash.delete(item_name)
+        hash.delete("#{item_name}__C")
+        hash.delete("#{item_name}__F")
+        hash.delete("#{item_name}__U")
+      when :RAW
+        hash.delete(item_name)
+      when :CONVERTED
+        hash.delete("#{item_name}__C")
+      when :FORMATTED
+        hash.delete("#{item_name}__F")
+      when :WITH_UNITS
+        hash.delete("#{item_name}__U")
       else
-        if VALUE_TYPES.include?(type)
-          @overrides.delete("#{target_name}__#{packet_name}__#{item_name}__#{type}")
-        else
-          raise "Unknown type '#{type}' for #{target_name} #{packet_name} #{item_name}"
-        end
+        raise "Unknown type '#{type}' for #{target_name} #{packet_name} #{item_name}"
+      end
+      if hash.empty?
+        Store.hdel("#{scope}__override__#{target_name}", packet_name)
+      else
+        Store.hset("#{scope}__override__#{target_name}", packet_name, JSON.generate(hash.as_json(:allow_nan => true)))
       end
     end
 
     # PRIVATE METHODS
 
-    def self._parse_item(lookups, item)
-      # parse item and update lookups with packet_name and target_name and keys
-      #
-      # return an ordered array of hash with keys
+    # parse item and update lookups with packet_name and target_name and keys
+    # 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?
 
@@ -177,9 +219,23 @@ module OpenC3
       when 'WITH_UNITS'
         keys = ["#{item_name}__U", "#{item_name}__F", "#{item_name}__C", item_name]
       else
-        raise "Unknown value type #{value_type}"
+        raise "Unknown value type '#{value_type}'"
+      end
+      tgt_pkt_key = "#{target_name}__#{packet_name}"
+      # Check the overrides cache for this target / packet
+      unless overrides[tgt_pkt_key]
+        override_data = Store.hget("#{scope}__override__#{target_name}", packet_name)
+        if override_data
+          overrides[tgt_pkt_key] = JSON.parse(override_data, :allow_nan => true, :create_additions => true)
+        else
+          overrides[tgt_pkt_key] = {}
+        end
+      end
+      if overrides[tgt_pkt_key][keys[0]]
+        # Set the result as a Hash to distingish it from the key array and from an overridden Array value
+        keys = {'value' => overrides[tgt_pkt_key][keys[0]]}
       end
-      lookups << ["#{target_name}__#{packet_name}", target_name, packet_name, keys]
+      lookups << [tgt_pkt_key, target_name, packet_name, keys]
     end
   end
 end

data/lib/openc3/models/interface_model.rb

@@ -38,11 +38,13 @@ module OpenC3
     attr_accessor :reconnect_delay
     attr_accessor :disable_disconnect
     attr_accessor :options
+    attr_accessor :secret_options
     attr_accessor :protocols
     attr_accessor :interfaces
     attr_accessor :log
     attr_accessor :log_raw
     attr_accessor :needs_dependencies
+    attr_accessor :secrets
 
     # NOTE: The following three class methods are used by the ModelController
     # and are reimplemented to enable various Model class methods to work
@@ -101,12 +103,14 @@ module OpenC3
       reconnect_delay: 5.0,
       disable_disconnect: false,
       options: [],
+      secret_options: [],
       protocols: [],
       log: true,
       log_raw: false,
       updated_at: nil,
       plugin: nil,
       needs_dependencies: false,
+      secrets: [],
       scope:
     )
       if self.class._get_type == 'INTERFACE'
@@ -123,10 +127,12 @@ module OpenC3
       @reconnect_delay = reconnect_delay
       @disable_disconnect = disable_disconnect
       @options = options
+      @secret_options = secret_options
       @protocols = protocols
       @log = log
       @log_raw = log_raw
       @needs_dependencies = needs_dependencies
+      @secrets = secrets
     end
 
     # Called by InterfaceMicroservice to instantiate the Interface defined
@@ -139,6 +145,7 @@ module OpenC3
       else
         interface_or_router = klass.new
       end
+      interface_or_router.secrets.setup(@secrets)
       interface_or_router.target_names = @target_names.dup
       interface_or_router.cmd_target_names = @cmd_target_names.dup
       interface_or_router.tlm_target_names = @tlm_target_names.dup
@@ -149,6 +156,11 @@ module OpenC3
       @options.each do |option|
         interface_or_router.set_option(option[0], option[1..-1])
       end
+      @secret_options.each do |option|
+        secret_name = option[1]
+        secret_value = interface_or_router.secrets.get(secret_name, scope: @scope)
+        interface_or_router.set_option(option[0], [secret_value])
+      end
       @protocols.each do |protocol|
         klass = OpenC3.require_class(protocol[1])
         interface_or_router.add_protocol(klass, protocol[2..-1], protocol[0].upcase.intern)
@@ -168,11 +180,13 @@ module OpenC3
         'reconnect_delay' => @reconnect_delay,
         'disable_disconnect' => @disable_disconnect,
         'options' => @options,
+        'secret_options' => @secret_options,
         'protocols' => @protocols,
         'log' => @log,
         'log_raw' => @log_raw,
         'plugin' => @plugin,
         'needs_dependencies' => @needs_dependencies,
+        'secrets' => @secrets.as_json(*a),
         'updated_at' => @updated_at
       }
     end
@@ -242,6 +256,14 @@ module OpenC3
         parser.verify_num_parameters(0, 0, "#{keyword}")
         @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)>")
+        @secrets << parameters[0..2]
+        if parameters[3]
+          # Option Name, Secret Name
+          @secret_options << [parameters[3], parameters[1]]
+        end
+
       else
         raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Interface/Router: #{keyword} #{parameters.join(" ")}")
 
@@ -261,6 +283,7 @@ module OpenC3
         target_names: @target_names,
         plugin: @plugin,
         needs_dependencies: @needs_dependencies,
+        secrets: @secrets,
         scope: @scope
       )
       unless validate_only

data/lib/openc3/models/microservice_model.rb

@@ -39,6 +39,7 @@ module OpenC3
     attr_accessor :work_dir
     attr_accessor :ports
     attr_accessor :parent
+    attr_accessor :secrets
 
     # NOTE: The following three class methods are used by the ModelController
     # and are reimplemented to enable various Model class methods to work
@@ -96,6 +97,7 @@ module OpenC3
       updated_at: nil,
       plugin: nil,
       needs_dependencies: false,
+      secrets: [],
       scope:
     )
       parts = name.split("__")
@@ -118,6 +120,7 @@ module OpenC3
       @parent = parent
       @container = container
       @needs_dependencies = needs_dependencies
+      @secrets = secrets
       @bucket = Bucket.getClient()
     end
 
@@ -137,6 +140,7 @@ module OpenC3
         'updated_at' => @updated_at,
         'plugin' => @plugin,
         'needs_dependencies' => @needs_dependencies,
+        'secrets' => @secrets.as_json(*a)
       }
     end
 
@@ -182,6 +186,9 @@ module OpenC3
       when 'CONTAINER'
         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
       else
         raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Microservice: #{keyword} #{parameters.join(" ")}")
       end

data/lib/openc3/models/model.rb

@@ -154,7 +154,7 @@ module OpenC3
         end
       end
       @updated_at = Time.now.to_nsec_from_epoch
-      self.class.store.hset(@primary_key, @name, JSON.generate(self.as_json(:allow_nan => true)))
+      self.class.store.hset(@primary_key, @name, JSON.generate(self.as_json(:allow_nan => true), :allow_nan => true))
     end
 
     # Alias for create(update: true)

data/lib/openc3/models/secret_model.rb

@@ -0,0 +1,53 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 OpenC3, Inc.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# This file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
+require 'openc3/models/model'
+
+module OpenC3
+  class SecretModel < Model
+    PRIMARY_KEY = 'openc3__secrets'
+
+    # NOTE: The following three class methods are used by the ModelController
+    # and are reimplemented to enable various Model class methods to work
+    def self.get(name:, scope:)
+      super("#{scope}__#{PRIMARY_KEY}", name: name)
+    end
+
+    def self.names(scope:)
+      super("#{scope}__#{PRIMARY_KEY}")
+    end
+
+    def self.all(scope:)
+      super("#{scope}__#{PRIMARY_KEY}")
+    end
+    # END NOTE
+
+    def initialize(name:, value:, scope:)
+      super("#{scope}__#{PRIMARY_KEY}", name: name, scope: scope)
+      @value = value
+    end
+
+    # @return [Hash] JSON encoding of this model
+    def as_json(*a)
+      {
+        'name' => @name,
+        'value' => @value.as_json(*a),
+      }
+    end
+  end
+end