openc3 7.2.1 → 7.4.0

data/lib/openc3/models/gem_model.rb

@@ -22,6 +22,7 @@ require 'rubygems'
 require 'rubygems/uninstaller'
 require 'tempfile'
 require 'openc3/utilities/process_manager'
+require 'openc3/utilities/rubygems_url'
 require 'openc3/api/api'
 require 'pathname'
 
@@ -34,8 +35,8 @@ module OpenC3
     extend Api
 
     def self.names
-      if Dir.exist?("#{ENV['GEM_HOME']}/gems")
-        result = Pathname.new("#{ENV['GEM_HOME']}/gems").children.select { |c| c.directory? }.collect { |p| File.basename(p) + '.gem' }
+      if Dir.exist?("#{ENV.fetch('GEM_HOME', nil)}/gems")
+        result = Pathname.new("#{ENV.fetch('GEM_HOME', nil)}/gems").children.select { |c| c.directory? }.collect { |p| File.basename(p) + '.gem' }
       else
         result = []
       end
@@ -43,19 +44,19 @@ module OpenC3
     end
 
     def self.get(name)
-      path = "#{ENV['GEM_HOME']}/cosmoscache/#{name}"
+      path = "#{ENV.fetch('GEM_HOME', nil)}/cosmoscache/#{name}"
       return path if File.exist?(path)
-      path = "#{ENV['GEM_HOME']}/cache/#{name}"
+      path = "#{ENV.fetch('GEM_HOME', nil)}/cache/#{name}"
       return path if File.exist?(path)
-      raise "Gem #{name} not found"
+      raise "Gem '#{name}' not found"
     end
 
     def self.put(gem_file_path, gem_install: true, scope:)
       if File.file?(gem_file_path)
         gem_filename = File.basename(gem_file_path)
         # Put into cosmoscache folder that we control
-        FileUtils.mkdir_p("#{ENV['GEM_HOME']}/cosmoscache") unless Dir.exist?("#{ENV['GEM_HOME']}/cosmoscache")
-        FileUtils.cp(gem_file_path, "#{ENV['GEM_HOME']}/cosmoscache/#{File.basename(gem_file_path)}")
+        FileUtils.mkdir_p("#{ENV.fetch('GEM_HOME', nil)}/cosmoscache") unless Dir.exist?("#{ENV.fetch('GEM_HOME', nil)}/cosmoscache")
+        FileUtils.cp(gem_file_path, "#{ENV.fetch('GEM_HOME', nil)}/cosmoscache/#{File.basename(gem_file_path)}")
         if gem_install
           Logger.info "Installing gem: #{gem_filename}"
           result = OpenC3::ProcessManager.instance.spawn(["ruby", "/openc3/bin/openc3cli", "geminstall", gem_filename, scope], "package_install", gem_filename, Time.now + 3600.0, scope: scope)
@@ -79,9 +80,11 @@ module OpenC3
         rubygems_url = get_setting('rubygems_url', scope: scope)
       rescue
         # If Redis isn't running try the ENV, then simply rubygems.org
-        rubygems_url = ENV['RUBYGEMS_URL']
-        rubygems_url ||= 'https://rubygems.org'
+        rubygems_url = ENV.fetch('RUBYGEMS_URL', RubygemsUrl::DEFAULT)
       end
+      # The url comes from a user-writable setting or ENV so validate it before
+      # using it as a Gem source
+      rubygems_url = RubygemsUrl.validate(rubygems_url) if rubygems_url
       Gem.sources = [rubygems_url] if rubygems_url
       Gem.done_installing_hooks.clear
       begin
@@ -92,7 +95,7 @@ module OpenC3
         Gem.install(gem_file_path, "> 0.pre", build_args: ['--no-document, --without development,test'], prerelease: true, domain: :both)
       end
     rescue => e
-      message = "Gem file #{gem_file_path} error installing to #{ENV['GEM_HOME']}\n#{e.formatted}"
+      message = "Gem file #{gem_file_path} error installing to #{ENV.fetch('GEM_HOME', nil)}\n#{e.formatted}"
       Logger.error message
       raise e
     end

data/lib/openc3/models/host_interface_microservice_model.rb

@@ -0,0 +1,114 @@
+# encoding: ascii-8bit
+
+# Copyright 2026 OpenC3, Inc.
+# All Rights Reserved.
+#
+# 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 LICENSE.md 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
+  # Captures the information openc3-app needs to spawn a COSMOS interface on the
+  # host computer (outside Docker) so it can reach hardware such as serial ports
+  # that aren't available inside a container. A host microservice performs raw
+  # data transfer and basic functionality only; complex processing (protocols,
+  # target definitions) stays on the Docker side of COSMOS. The host side speaks
+  # Iroh back to openc3-app which forwards the data into COSMOS through the named
+  # bridge_microservice relay.
+  #
+  # This model is written by InterfaceModel#deploy for bridged interfaces (those
+  # configured with the BRIDGE keyword) and read by openc3-app. It is deliberately
+  # kept separate from MicroserviceModel so it is NOT run by the normal COSMOS
+  # microservice operator.
+  class HostInterfaceMicroserviceModel < Model
+    PRIMARY_KEY = 'openc3_host_interface_microservices'
+
+    # The real interface class and its parameters, e.g. ['serial_interface.py', ...]
+    attr_accessor :config_params
+    attr_accessor :work_dir
+    attr_accessor :env
+    attr_accessor :options
+    attr_accessor :secret_options
+    attr_accessor :protocols
+    attr_accessor :secrets
+    attr_accessor :container
+    attr_accessor :needs_dependencies
+    # The bridge (bridge_microservice relay) this host interface routes through.
+    attr_accessor :bridge_name
+    # The Iroh ALPN stream name (the interface name) used to route data back to
+    # openc3-app and on to the matching COSMOS bridge_interface.
+    attr_accessor :stream
+
+    # NOTE: The following three class methods are reimplemented (like other
+    # scoped models) so the ModelController and Model class methods 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:,
+      bridge_name:,
+      stream:,
+      config_params: [],
+      work_dir: '.',
+      env: {},
+      options: [],
+      secret_options: [],
+      protocols: [],
+      secrets: [],
+      container: nil,
+      needs_dependencies: false,
+      updated_at: nil,
+      plugin: nil,
+      scope:
+    )
+      super("#{scope}__#{PRIMARY_KEY}", name: name, updated_at: updated_at, plugin: plugin, scope: scope)
+      @bridge_name = bridge_name
+      @stream = stream
+      @config_params = config_params
+      @work_dir = work_dir
+      @env = env
+      @options = options
+      @secret_options = secret_options
+      @protocols = protocols
+      @secrets = secrets
+      @container = container
+      @needs_dependencies = needs_dependencies
+    end
+
+    def as_json(*a)
+      {
+        'name' => @name,
+        'scope' => @scope,
+        'bridge_name' => @bridge_name,
+        'stream' => @stream,
+        'config_params' => @config_params,
+        'work_dir' => @work_dir,
+        'env' => @env,
+        'options' => @options,
+        'secret_options' => @secret_options,
+        'protocols' => @protocols,
+        'secrets' => @secrets.as_json(*a),
+        'container' => @container,
+        'needs_dependencies' => @needs_dependencies,
+        'plugin' => @plugin,
+        'updated_at' => @updated_at
+      }
+    end
+  end
+end

data/lib/openc3/models/interface_model.rb

@@ -16,11 +16,16 @@
 # if purchased from OpenC3, Inc.
 
 require 'openc3/models/model'
+require 'openc3/models/config_keyword_model'
 require 'openc3/models/microservice_model'
+require 'openc3/models/bridge_model'
+require 'openc3/models/host_interface_microservice_model'
 require 'openc3/models/target_model'
 
 module OpenC3
   class InterfaceModel < Model
+    include ConfigKeywordModel
+
     INTERFACES_PRIMARY_KEY = 'openc3_interfaces'
     ROUTERS_PRIMARY_KEY = 'openc3_routers'
 
@@ -36,7 +41,10 @@ module OpenC3
     attr_accessor :disable_disconnect
     attr_accessor :options
     attr_accessor :secret_options
+    attr_accessor :bridge_options
+    attr_accessor :bridge_secret_options
     attr_accessor :protocols
+    attr_accessor :bridge_protocols
     attr_accessor :interfaces
     attr_accessor :log_stream
     attr_accessor :needs_dependencies
@@ -49,6 +57,7 @@ module OpenC3
     attr_accessor :prefix
     attr_accessor :shard
     attr_accessor :db_shard
+    attr_accessor :bridge_name
 
     # NOTE: The following three class methods are used by the ModelController
     # and are reimplemented to enable various Model class methods to work
@@ -111,6 +120,9 @@ module OpenC3
       options: [],
       secret_options: [],
       protocols: [],
+      bridge_options: [],
+      bridge_secret_options: [],
+      bridge_protocols: [],
       log_stream: nil,
       updated_at: nil,
       plugin: nil,
@@ -124,6 +136,7 @@ module OpenC3
       prefix: nil,
       shard: 0,
       db_shard: 0,
+      bridge_name: nil,
       scope:
     )
       if self.class._get_type == 'INTERFACE'
@@ -157,7 +170,10 @@ module OpenC3
       @disable_disconnect = disable_disconnect
       @options = options
       @secret_options = secret_options
+      @bridge_options = bridge_options
+      @bridge_secret_options = bridge_secret_options
       @protocols = protocols
+      @bridge_protocols = bridge_protocols
       @log_stream = log_stream
       @needs_dependencies = needs_dependencies
       @cmd = cmd
@@ -180,6 +196,7 @@ module OpenC3
       @prefix = prefix
       @shard = shard.to_i # to_i to handle nil
       @db_shard = db_shard.to_i # to_i to handle nil
+      @bridge_name = bridge_name&.to_s&.upcase
       @secrets = secrets
     end
 
@@ -238,6 +255,9 @@ module OpenC3
         'options' => @options,
         'secret_options' => @secret_options,
         'protocols' => @protocols,
+        'bridge_options' => @bridge_options,
+        'bridge_secret_options' => @bridge_secret_options,
+        'bridge_protocols' => @bridge_protocols,
         'log_stream' => @log_stream,
         'plugin' => @plugin,
         'needs_dependencies' => @needs_dependencies,
@@ -250,13 +270,14 @@ module OpenC3
         'prefix' => @prefix,
         'shard' => @shard,
         'db_shard' => @db_shard,
+        'bridge_name' => @bridge_name,
         'updated_at' => @updated_at
       }
     end
 
     def ensure_target_exists(target_name)
       target = TargetModel.get(name: target_name, scope: @scope)
-      raise "Target #{target_name} does not exist" unless target
+      raise "Target '#{target_name}' does not exist (InterfaceModel)" unless target
       target
     end
 
@@ -277,6 +298,8 @@ module OpenC3
 
     # Handles Interface/Router specific configuration keywords
     def handle_config(parser, keyword, parameters)
+      type = self.class._get_type
+
       case keyword
       when 'MAP_TARGET'
         usage = "#{keyword} <Target Name> <ENABLED/DISABLED>"
@@ -334,6 +357,14 @@ module OpenC3
         parser.verify_num_parameters(2, nil, "#{keyword} <Option Name> <Option Value 1> <Option Value 2 (optional)> <etc>")
         @options << parameters.dup
 
+      when 'BRIDGE_OPTION'
+        if type == 'INTERFACE'
+          parser.verify_num_parameters(2, nil, "#{keyword} <Option Name> <Option Value 1> <Option Value 2 (optional)> <etc>")
+          @bridge_options << parameters.dup
+        else
+          raise ConfigParser::Error.new(parser, "BRIDGE_OPTION not supported for Router: #{keyword} #{parameters.join(" ")}")
+        end
+
       when 'PROTOCOL'
         usage = "#{keyword} <READ WRITE READ_WRITE> <protocol filename or classname> <Protocol specific parameters>"
         parser.verify_num_parameters(2, nil, usage)
@@ -343,6 +374,19 @@ module OpenC3
 
         @protocols << parameters.dup
 
+      when 'BRIDGE_PROTOCOL'
+        if type == 'INTERFACE'
+          usage = "#{keyword} <READ WRITE READ_WRITE> <protocol filename or classname> <Protocol specific parameters>"
+          parser.verify_num_parameters(2, nil, usage)
+          unless %w(READ WRITE READ_WRITE).include? parameters[0].upcase
+            raise parser.error("Invalid protocol type: #{parameters[0]}", usage)
+          end
+
+          @bridge_protocols << parameters.dup
+        else
+          raise ConfigParser::Error.new(parser, "BRIDGE_PROTOCOL not supported for Router: #{keyword} #{parameters.join(" ")}")
+        end
+
       when 'DONT_LOG'
         Logger.warn "DONT_LOG is deprecated and does nothing."
 
@@ -352,6 +396,7 @@ module OpenC3
 
       when 'SECRET'
         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)>")
+        validate_secret(parser, keyword, parameters)
         @secrets << parameters[0..2]
         if ConfigParser.handle_nil(parameters[3])
           # Option Name, Secret Name
@@ -359,29 +404,26 @@ module OpenC3
         end
         @secrets[-1] << ConfigParser.handle_nil(parameters[4])
 
+      when 'BRIDGE_SECRET'
+        if type == 'INTERFACE'
+          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)>")
+          validate_secret(parser, keyword, parameters)
+          @secrets << parameters[0..2]
+          if ConfigParser.handle_nil(parameters[3])
+            # Option Name, Secret Name
+            @bridge_secret_options << [parameters[3], parameters[1]]
+          end
+          @secrets[-1] << ConfigParser.handle_nil(parameters[4])
+        else
+          raise ConfigParser::Error.new(parser, "BRIDGE_SECRET not supported for Router: #{keyword} #{parameters.join(" ")}")
+        end
+
       when 'ENV'
         parser.verify_num_parameters(2, 2, "#{keyword} <Key> <Value>")
         @env[parameters[0]] = parameters[1]
 
       when 'PORT'
-        usage = "PORT <Number> <Protocol (Optional)"
-        parser.verify_num_parameters(1, 2, usage)
-        begin
-          @ports << [Integer(parameters[0])]
-        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])
-        if protocol
-          # Per https://kubernetes.io/docs/concepts/services-networking/service/#protocol-support
-          if %w(TCP UDP SCTP).include?(protocol.upcase)
-            @ports[-1] << protocol.upcase
-          else
-            raise ConfigParser::Error.new(parser, "Unknown port protocol: #{parameters[1]}", usage)
-          end
-        else
-          @ports[-1] << 'TCP'
-        end
+        parse_port(parser, keyword, parameters)
 
       when 'WORK_DIR'
         parser.verify_num_parameters(1, 1, "#{keyword} <Dir>")
@@ -404,8 +446,17 @@ module OpenC3
         @shard = Integer(parameters[0])
 
       when 'DB_SHARD'
-        parser.verify_num_parameters(1, 1, "#{keyword} <Shard Number Starting from 0>")
+        parser.verify_num_parameters(1, 1, "#{keyword} <DB_Shard Number Starting from 0>")
         @db_shard = Integer(parameters[0])
+
+      when 'BRIDGE'
+        if type == 'INTERFACE'
+          parser.verify_num_parameters(1, 1, "#{keyword} <Bridge Name>")
+          @bridge_name = parameters[0].to_s.upcase
+        else
+          raise ConfigParser::Error.new(parser, "BRIDGE not supported for Router: #{keyword} #{parameters.join(" ")}")
+        end
+
       else
         raise ConfigParser::Error.new(parser, "Unknown keyword and parameters for Interface/Router: #{keyword} #{parameters.join(" ")}")
 
@@ -418,6 +469,11 @@ module OpenC3
     def deploy(gem_path, variables, validate_only: false)
       type = self.class._get_type
       microservice_name = "#{@scope}__#{type}__#{@name}"
+      # A bridged interface runs on the host (openc3-app) rather than in Docker.
+      # COSMOS runs a bridge_interface tunnel + a shared bridge_microservice relay
+      # and hands the real interface's spawn info to openc3-app. See deploy_bridge.
+      return deploy_bridge(gem_path, variables, microservice_name, type, validate_only: validate_only) if @bridge_name
+
       microservice = MicroserviceModel.new(
         name: microservice_name,
         work_dir: @work_dir,
@@ -444,6 +500,92 @@ module OpenC3
       microservice
     end
 
+    # Deploy a bridged interface. This splits the interface across the Docker
+    # side of COSMOS (bridge_interface tunnel + protocols/target processing) and
+    # the host side (openc3-app spawns the real interface for raw data transfer):
+    #   1. A COSMOS interface_microservice that builds a bridge_interface tunnel
+    #      (InterfaceModel#build substitutes BridgeInterface when bridge_name is
+    #      set) and connects to the named bridge_microservice relay.
+    #   2. A shared bridge_microservice relay (one per bridge_name) that this
+    #      interface's stream (ALPN stream/<name>) is added to.
+    #   3. A HostInterfaceMicroserviceModel holding the real interface's spawn info for
+    #      openc3-app to run the interface on the host.
+    def deploy_bridge(gem_path, variables, microservice_name, type, validate_only: false)
+      # The COSMOS side runs the Python interface_microservice which builds a
+      # BridgeInterface (see InterfaceModel#build). It keeps this interface's
+      # protocols and target mapping; the raw device I/O is tunneled to the host.
+      cmd = [BridgeModel.bridge_python_bin, "#{type.downcase}_microservice.py", microservice_name]
+      microservice = MicroserviceModel.new(
+        name: microservice_name,
+        work_dir: BridgeModel::BRIDGE_WORK_DIR,
+        cmd: cmd,
+        env: @env,
+        ports: @ports,
+        container: @container,
+        target_names: @target_names,
+        plugin: @plugin,
+        needs_dependencies: @needs_dependencies,
+        secrets: @secrets,
+        prefix: @prefix,
+        shard: @shard,
+        db_shard: @db_shard,
+        scope: @scope
+      )
+      unless validate_only
+        @target_names.each { |target_name| ensure_target_exists(target_name) }
+        check_bridge_relay()
+        microservice.create
+        microservice.deploy(gem_path, variables)
+        create_host_interface_microservice()
+        ConfigTopic.write({ kind: 'created', type: type.downcase, name: @name, plugin: @plugin }, scope: @scope)
+        Logger.info "Configured bridged #{type.downcase} microservice #{microservice_name} (bridge #{@bridge_name})"
+      end
+      microservice
+    end
+
+    # Name of the shared bridge_microservice relay for a given bridge name.
+    def bridge_relay_name
+      "#{@scope}__BRIDGE__#{@bridge_name}"
+    end
+
+    # Verify the shared bridge_microservice relay for @bridge_name exists.
+    # Multiple bridged interfaces sharing a bridge name all route through the
+    # same relay. The relay discovers which streams to advertise by querying the
+    # HostInterfaceMicroserviceModels for its bridge (see bridge_microservice.py), so we
+    # deliberately do NOT push this interface's stream onto the relay as an
+    # OPTION: mutating (updating) the relay's MicroserviceModel would make the
+    # operator respawn the relay every time a bridged interface is added or
+    # removed. Leaving the model untouched lets the relay adapt live instead.
+    def check_bridge_relay
+      relay = MicroserviceModel.get_model(name: bridge_relay_name, scope: @scope)
+      raise "Bridge #{@bridge_name} does not exist" unless relay
+      relay
+    end
+
+    # Capture the real interface's spawn info for openc3-app. The host side does
+    # raw data transfer only, so protocols and target definitions are omitted;
+    # the connection options and secrets needed to open the device are included.
+    def create_host_interface_microservice
+      host = HostInterfaceMicroserviceModel.new(
+        name: @name,
+        bridge_name: @bridge_name,
+        stream: @name,
+        config_params: @config_params,
+        work_dir: @work_dir,
+        env: @env,
+        options: @bridge_options,
+        secret_options: @bridge_secret_options,
+        protocols: @bridge_protocols,
+        secrets: @secrets,
+        container: @container,
+        needs_dependencies: @needs_dependencies,
+        plugin: @plugin,
+        scope: @scope
+      )
+      host.create(force: true)
+      host
+    end
+
     # Destroys the deployed MicroserviceModel which triggers the operator to kill
     # the microservice. Also directly destroys the Interface/RouterStatusModel in
     # an ensure block. The microservice stop() no longer recreates the status
@@ -469,6 +611,23 @@ module OpenC3
         status_model.destroy if status_model
       rescue Exception => error
         Logger.error("Error destroying #{type&.downcase || 'unknown'} status model #{@name} in scope #{@scope} due to #{error}")
+      ensure
+        undeploy_bridge if @bridge_name
+      end
+    end
+
+    # Clean up the host-side pieces of a bridged interface by destroying its
+    # HostInterfaceMicroserviceModel. The shared bridge_microservice relay is left
+    # untouched: it discovers its streams by querying the HostInterfaceMicroserviceModels,
+    # so removing this one makes the relay drop the stream's ALPN on its own.
+    # (Mutating the relay's MicroserviceModel here would respawn it.) The relay
+    # itself is destroyed with its BridgeModel, not per-interface.
+    def undeploy_bridge
+      begin
+        host = HostInterfaceMicroserviceModel.get_model(name: @name, scope: @scope)
+        host.destroy if host
+      rescue Exception => error
+        Logger.error("Error destroying HostInterfaceMicroservice model #{@name} in scope #{@scope} due to #{error}")
       end
     end
 

data/lib/openc3/models/microservice_model.rb

@@ -17,12 +17,16 @@
 
 require 'openc3/top_level'
 require 'openc3/models/model'
+require 'openc3/models/config_keyword_model'
 require 'openc3/models/metric_model'
 require 'openc3/topics/config_topic'
 require 'openc3/utilities/bucket'
+require 'openc3/utilities/python_venv'
 
 module OpenC3
   class MicroserviceModel < Model
+    include ConfigKeywordModel
+
     PRIMARY_KEY = 'openc3_microservices'
 
     attr_accessor :cmd
@@ -140,6 +144,26 @@ module OpenC3
       @bucket = Bucket.getClient()
     end
 
+    # Resolve the Python environment variables that will be used at runtime.
+    # This mirrors the logic in MicroserviceOperator#convert_microservice_to_process_definition.
+    def runtime_python_env
+      python_bin = ENV['OPENC3_PYTHON_BIN'] || '/openc3/python/.venv/bin/python'
+      result = { 'OPENC3_PYTHON_BIN' => python_bin }
+      if @needs_dependencies && @plugin
+        candidate = PythonVenv.plugin_venv_path(scope: @scope, plugin_name: @plugin)
+        if candidate
+          result['VIRTUAL_ENV'] = candidate
+          result['PYTHONUSERBASE'] = candidate
+          site_packages = Dir.glob("#{candidate}/lib/python*/site-packages").first
+          result['PYTHONPATH'] = site_packages
+        else
+          result['VIRTUAL_ENV'] = nil
+          result['PYTHONUSERBASE'] = PythonVenv::DEFAULT_PYTHONUSERBASE
+        end
+      end
+      result
+    end
+
     def as_json(*a)
       {
         'name' => @name,
@@ -175,24 +199,7 @@ module OpenC3
         parser.verify_num_parameters(1, 1, "#{keyword} <Dir>")
         @work_dir = parameters[0]
       when 'PORT'
-        usage = "PORT <Number> <Protocol (Optional)"
-        parser.verify_num_parameters(1, 2, usage)
-        begin
-          @ports << [Integer(parameters[0])]
-        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])
-        if protocol
-          # Per https://kubernetes.io/docs/concepts/services-networking/service/#protocol-support
-          if %w(TCP UDP SCTP).include?(protocol.upcase)
-            @ports[-1] << protocol.upcase
-          else
-            raise ConfigParser::Error.new(parser, "Unknown port protocol: #{parameters[1]}", usage)
-          end
-        else
-          @ports[-1] << 'TCP'
-        end
+        parse_port(parser, keyword, parameters)
       when 'TOPIC'
         parser.verify_num_parameters(1, 1, "#{keyword} <Topic Name>")
         @topics << parameters[0]
@@ -223,6 +230,7 @@ module OpenC3
         @container = parameters[0]
       when 'SECRET'
         parser.verify_num_parameters(3, 4, "#{keyword} <Secret Type: ENV or FILE> <Secret Name> <Environment Variable Name or File Path> <Secret Store Name (Optional)>")
+        validate_secret(parser, keyword, parameters)
         if ConfigParser.handle_nil(parameters[3])
           @secrets << parameters.dup
         else