javonet-ruby-sdk 2.6.10 → 2.6.11

data/lib/javonet-ruby-sdk/sdk/config_runtime_factory.rb

@@ -1,132 +1,132 @@
-require 'pathname'
-require_relative './internal/abstract_config_runtime_factory'
-require_relative './runtime_context'
-require_relative './../utils/connection_type'
-require_relative './tools/json_file_resolver'
-require_relative './../core/transmitter/transmitter'
-
-# The ConfigRuntimeFactory class implements the AbstractConfigRuntimeFactory interface and provides methods for creating runtime contexts.
-# Each method corresponds to a specific runtime (CLR, JVM, .NET Core, Perl, Ruby, Node.js, Python) and returns a RuntimeContext instance for that runtime.
-# # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
-class ConfigRuntimeFactory < AbstractConfigRuntimeFactory
-
-  def initialize(path)
-    @path = path
-    Transmitter.set_config_source(path)
-  end
-
-  # Creates a RuntimeContext instance to interact with CLR runtime.
-  # @param config_name [String] The name of the configuration to use.
-  # @return [RuntimeContext] a RuntimeContext instance for the CLR runtime
-  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
-  def clr(config_name = "default")
-    get_runtime_context(RuntimeNameJavonet::CLR, config_name)
-  end
-
-  # Creates a RuntimeContext instance to interact with JVM runtime.
-  # @param config_name [String] The name of the configuration to use.
-  # @return [RuntimeContext] a RuntimeContext instance for the JVM runtime
-  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
-  def jvm(config_name = "default")
-    get_runtime_context(RuntimeNameJavonet::JVM, config_name)
-  end
-
-  # Creates a RuntimeContext instance to interact with .NET runtime.
-  # @param config_name [String] The name of the configuration to use.
-  # @return [RuntimeContext] a RuntimeContext instance for the .NET runtime
-  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
-  def netcore(config_name = "default")
-    get_runtime_context(RuntimeNameJavonet::NETCORE, config_name)
-  end
-
-  # Creates a RuntimeContext instance to interact with Perl runtime.
-  # @param config_name [String] The name of the configuration to use.
-  # @return [RuntimeContext] a RuntimeContext instance for the Perl runtime
-  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
-  def perl(config_name = "default")
-    get_runtime_context(RuntimeNameJavonet::PERL, config_name)
-  end
-
-  # Creates a RuntimeContext instance to interact with Ruby runtime.
-  # @param config_name [String] The name of the configuration to use.
-  # @return [RuntimeContext] a RuntimeContext instance for the Ruby runtime
-  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
-  def ruby(config_name = "default")
-    get_runtime_context(RuntimeNameJavonet::RUBY, config_name)
-  end
-
-  # Creates a RuntimeContext instance to interact with Node.js runtime.
-  # @param config_name [String] The name of the configuration to use.
-  # @return [RuntimeContext] a RuntimeContext instance for the Node.js runtime
-  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
-  def nodejs(config_name = "default")
-    get_runtime_context(RuntimeNameJavonet::NODEJS, config_name)
-  end
-
-  # Creates a RuntimeContext instance to interact with Python runtime.
-  # @param config_name [String] The name of the configuration to use.
-  # @return [RuntimeContext] a RuntimeContext instance for the Python runtime
-  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
-  def python(config_name = "default")
-    get_runtime_context(RuntimeNameJavonet::PYTHON, config_name)
-  end
-
-  # Creates a RuntimeContext instance to interact with PHP runtime.
-  # @param config_name [String] The name of the configuration to use.
-  # @return [RuntimeContext] a RuntimeContext instance for the PHP runtime
-  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
-  def php(config_name = "default")
-    get_runtime_context(RuntimeNameJavonet::PHP, config_name)
-  end
-
-  # Creates a RuntimeContext instance to interact with Python 2.7 runtime.
-  # @param config_name [String] The name of the configuration to use.
-  # @return [RuntimeContext] a RuntimeContext instance for the Python 2.7 runtime
-  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
-  def python27(config_name = "default")
-    get_runtime_context(RuntimeNameJavonet::PYTHON27, config_name)
-  end
-
-  def get_runtime_context(runtime, config_name)
-    jfr = JsonFileResolver.new(@path)
-
-    begin
-      license_key = jfr.get_license_key
-      Transmitter.activate_with_credentials(license_key)
-    rescue
-      # licenseKey not found - do nothing
-    end
-
-    conn_type = jfr.get_channel_type(RuntimeNameHandler.get_name(runtime), config_name)
-    if conn_type == "tcp"
-      conn_data = TcpConnectionData.new(jfr.get_channel_host(RuntimeNameHandler.get_name(runtime), config_name),
-                                        jfr.get_channel_port(RuntimeNameHandler.get_name(runtime), config_name))
-      rtm_ctx =  RuntimeContext.get_instance(runtime, ConnectionType::TCP, conn_data)
-    elsif conn_type == "webSocket"
-      conn_data = WsConnectionData.new(jfr.get_channel_host(RuntimeNameHandler.get_name(runtime), config_name))
-      rtm_ctx = RuntimeContext.get_instance(runtime, ConnectionType::WEB_SOCKET, conn_data)
-    elsif conn_type == "inMemory"
-      rtm_ctx = RuntimeContext.get_instance(runtime, ConnectionType::IN_MEMORY, nil)
-    else
-      raise "Invalid connection type"
-    end
-    load_modules(runtime, config_name, jfr, rtm_ctx)
-    rtm_ctx
-  end
-
-  def load_modules(runtime, config_name, jfr, rtm_ctx)
-    modules = jfr.get_modules(RuntimeNameHandler.get_name(runtime), config_name)
-                 .split(',')
-                 .reject(&:empty?)
-
-    config_directory_absolute_path = File.dirname(@path)
-
-    modules.each do |mod|
-      if Pathname.new(mod).absolute?
-        rtm_ctx.load_library(mod)
-      else
-        rtm_ctx.load_library(File.join(config_directory_absolute_path, mod))
-      end
-    end
-  end
-end
+require 'pathname'
+require_relative './internal/abstract_config_runtime_factory'
+require_relative './runtime_context'
+require_relative './../utils/connection_type'
+require_relative './tools/json_file_resolver'
+require_relative './../core/transmitter/transmitter'
+
+# The ConfigRuntimeFactory class implements the AbstractConfigRuntimeFactory interface and provides methods for creating runtime contexts.
+# Each method corresponds to a specific runtime (CLR, JVM, .NET Core, Perl, Ruby, Node.js, Python) and returns a RuntimeContext instance for that runtime.
+# # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
+class ConfigRuntimeFactory < AbstractConfigRuntimeFactory
+
+  def initialize(path)
+    @path = path
+    Transmitter.set_config_source(path)
+  end
+
+  # Creates a RuntimeContext instance to interact with CLR runtime.
+  # @param config_name [String] The name of the configuration to use.
+  # @return [RuntimeContext] a RuntimeContext instance for the CLR runtime
+  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
+  def clr(config_name = "default")
+    get_runtime_context(RuntimeNameJavonet::CLR, config_name)
+  end
+
+  # Creates a RuntimeContext instance to interact with JVM runtime.
+  # @param config_name [String] The name of the configuration to use.
+  # @return [RuntimeContext] a RuntimeContext instance for the JVM runtime
+  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
+  def jvm(config_name = "default")
+    get_runtime_context(RuntimeNameJavonet::JVM, config_name)
+  end
+
+  # Creates a RuntimeContext instance to interact with .NET runtime.
+  # @param config_name [String] The name of the configuration to use.
+  # @return [RuntimeContext] a RuntimeContext instance for the .NET runtime
+  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
+  def netcore(config_name = "default")
+    get_runtime_context(RuntimeNameJavonet::NETCORE, config_name)
+  end
+
+  # Creates a RuntimeContext instance to interact with Perl runtime.
+  # @param config_name [String] The name of the configuration to use.
+  # @return [RuntimeContext] a RuntimeContext instance for the Perl runtime
+  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
+  def perl(config_name = "default")
+    get_runtime_context(RuntimeNameJavonet::PERL, config_name)
+  end
+
+  # Creates a RuntimeContext instance to interact with Ruby runtime.
+  # @param config_name [String] The name of the configuration to use.
+  # @return [RuntimeContext] a RuntimeContext instance for the Ruby runtime
+  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
+  def ruby(config_name = "default")
+    get_runtime_context(RuntimeNameJavonet::RUBY, config_name)
+  end
+
+  # Creates a RuntimeContext instance to interact with Node.js runtime.
+  # @param config_name [String] The name of the configuration to use.
+  # @return [RuntimeContext] a RuntimeContext instance for the Node.js runtime
+  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
+  def nodejs(config_name = "default")
+    get_runtime_context(RuntimeNameJavonet::NODEJS, config_name)
+  end
+
+  # Creates a RuntimeContext instance to interact with Python runtime.
+  # @param config_name [String] The name of the configuration to use.
+  # @return [RuntimeContext] a RuntimeContext instance for the Python runtime
+  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
+  def python(config_name = "default")
+    get_runtime_context(RuntimeNameJavonet::PYTHON, config_name)
+  end
+
+  # Creates a RuntimeContext instance to interact with PHP runtime.
+  # @param config_name [String] The name of the configuration to use.
+  # @return [RuntimeContext] a RuntimeContext instance for the PHP runtime
+  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
+  def php(config_name = "default")
+    get_runtime_context(RuntimeNameJavonet::PHP, config_name)
+  end
+
+  # Creates a RuntimeContext instance to interact with Python 2.7 runtime.
+  # @param config_name [String] The name of the configuration to use.
+  # @return [RuntimeContext] a RuntimeContext instance for the Python 2.7 runtime
+  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
+  def python27(config_name = "default")
+    get_runtime_context(RuntimeNameJavonet::PYTHON27, config_name)
+  end
+
+  def get_runtime_context(runtime, config_name)
+    jfr = JsonFileResolver.new(@path)
+
+    begin
+      license_key = jfr.get_license_key
+      Transmitter.activate_with_credentials(license_key)
+    rescue
+      # licenseKey not found - do nothing
+    end
+
+    conn_type = jfr.get_channel_type(RuntimeNameHandler.get_name(runtime), config_name)
+    if conn_type == "tcp"
+      conn_data = TcpConnectionData.new(jfr.get_channel_host(RuntimeNameHandler.get_name(runtime), config_name),
+                                        jfr.get_channel_port(RuntimeNameHandler.get_name(runtime), config_name))
+      rtm_ctx =  RuntimeContext.get_instance(runtime, ConnectionType::TCP, conn_data)
+    elsif conn_type == "webSocket"
+      conn_data = WsConnectionData.new(jfr.get_channel_host(RuntimeNameHandler.get_name(runtime), config_name))
+      rtm_ctx = RuntimeContext.get_instance(runtime, ConnectionType::WEB_SOCKET, conn_data)
+    elsif conn_type == "inMemory"
+      rtm_ctx = RuntimeContext.get_instance(runtime, ConnectionType::IN_MEMORY, nil)
+    else
+      raise "Invalid connection type"
+    end
+    load_modules(runtime, config_name, jfr, rtm_ctx)
+    rtm_ctx
+  end
+
+  def load_modules(runtime, config_name, jfr, rtm_ctx)
+    modules = jfr.get_modules(RuntimeNameHandler.get_name(runtime), config_name)
+                 .split(',')
+                 .reject(&:empty?)
+
+    config_directory_absolute_path = File.dirname(@path)
+
+    modules.each do |mod|
+      if Pathname.new(mod).absolute?
+        rtm_ctx.load_library(mod)
+      else
+        rtm_ctx.load_library(File.join(config_directory_absolute_path, mod))
+      end
+    end
+  end
+end

data/lib/javonet-ruby-sdk/sdk/configuration/config.rb

@@ -0,0 +1,32 @@
+require_relative './../../utils/connection_type'
+
+class Config
+  attr_accessor :runtime, :connection_data, :plugins, :modules
+
+  def initialize(runtime, connection_data, plugins = "", modules = "")
+    @runtime = runtime
+    @connection_data = connection_data
+    @plugins = plugins
+    @modules = modules
+  end
+
+  def to_s
+    parts = []
+    parts << "Runtime: #{@runtime}"
+
+    if @connection_data
+      parts << "Host: #{@connection_data}"
+    end
+
+    if @plugins && !@plugins.strip.empty?
+      parts << "Plugins: #{@plugins}"
+    end
+
+    if @modules && !@modules.strip.empty?
+      parts << "Modules: #{@modules}"
+    end
+
+    parts.join(", ")
+  end
+end
+

data/lib/javonet-ruby-sdk/sdk/configuration/config_priority.rb

@@ -0,0 +1,27 @@
+module ConfigPriority
+  RUNTIME_SPECIFIC_ENV = 1
+  GLOBAL_ENV = 2
+  RUNTIME_SPECIFIC_FILE = 3
+  GLOBAL_FILE = 4
+  USER = 5
+  DEFAULT_LIBRARY = 6
+
+  def self.to_s(priority)
+    case priority
+    when RUNTIME_SPECIFIC_ENV
+      "RUNTIME_SPECIFIC_ENV"
+    when GLOBAL_ENV
+      "GLOBAL_ENV"
+    when RUNTIME_SPECIFIC_FILE
+      "RUNTIME_SPECIFIC_FILE"
+    when GLOBAL_FILE
+      "GLOBAL_FILE"
+    when USER
+      "USER"
+    when DEFAULT_LIBRARY
+      "DEFAULT_LIBRARY"
+    else
+      "UNKNOWN_PRIORITY"
+    end
+  end
+end

data/lib/javonet-ruby-sdk/sdk/configuration/config_resolvers/config_resolver.rb

@@ -0,0 +1,80 @@
+require_relative './../../../utils/runtime_name_handler'
+require_relative './../../../utils/tcp_connection_data'
+require_relative './../../../utils/ws_connection_data'
+require_relative './../../../utils/connection_type'
+
+class ConfigResolver
+  def self.try_parse_runtime(runtime)
+    if runtime.nil? || runtime.strip.empty?
+      raise "Runtime string cannot be null or whitespace."
+    end
+    runtime = runtime.strip.downcase
+    RuntimeNameHandler.get_runtime(runtime)
+  end
+
+  def self.build_connection_data(host_value)
+    if host_value.nil? || host_value.strip.empty?
+      return nil  # In-memory connection
+    end
+    hv = host_value.strip
+    lower = hv.downcase
+
+    if lower == "inmemory" || lower == "in-memory"
+      return nil  # In-memory connection
+    end
+
+    if lower.start_with?("ws://") || lower.start_with?("wss://")
+      return WsConnectionData.new(hv)
+    end
+
+    if lower.start_with?("tcp://")
+      begin
+        return ConfigResolver.parse_tcp(hv[6..-1])
+      rescue
+        return nil  # In-memory connection
+      end
+    end
+
+    colon = hv.index(":")
+    if colon && colon > 0 && colon < hv.length - 1
+      port_part = hv[colon + 1..-1]
+      slash = port_part.index("/")
+      if slash && slash >= 0
+        port_part = port_part[0...slash]
+      end
+      begin
+        port = Integer(port_part)
+        host_only = hv[0...colon]
+        if !host_only.strip.empty?
+          begin
+            return TcpConnectionData.new(host_only, port)
+          rescue
+            return nil  # In-memory connection
+          end
+        end
+      rescue
+        # Continue to return in-memory
+      end
+    end
+
+    nil  # In-memory connection
+  end
+
+  def self.parse_tcp(address)
+    slash = address.index("/")
+    host_port = slash && slash >= 0 ? address[0...slash] : address
+    colon = host_port.rindex(":")
+    if !colon || colon <= 0 || colon >= host_port.length - 1
+      raise "Invalid tcp:// format."
+    end
+    host = host_port[0...colon]
+    port_str = host_port[colon + 1..-1]
+    begin
+      port = Integer(port_str)
+    rescue
+      raise "Invalid port in tcp:// address."
+    end
+    TcpConnectionData.new(host, port)
+  end
+end
+

data/lib/javonet-ruby-sdk/sdk/configuration/config_resolvers/connection_string_config_resolver.rb

@@ -0,0 +1,89 @@
+require_relative 'config_resolver'
+require_relative '../config'
+require_relative '../configs_dictionary'
+require_relative '../config_priority'
+require_relative './../../tools/activation_helper'
+
+class ConnectionStringConfigResolver < ConfigResolver
+  def self.add_configs(priority, connection_string_source)
+    if connection_string_source.nil? || connection_string_source.strip.empty?
+      raise "Connection string source cannot be null or empty."
+    end
+
+    normalized = connection_string_source.gsub("\r\n", "\n").gsub("\r", "\n")
+    lines = normalized.split("\n").map(&:strip).reject(&:empty?)
+
+    lines.each do |line|
+      if line.start_with?("#") || line.start_with?("//")
+        next
+      end
+      if line.downcase.start_with?("licensekey")
+        ConnectionStringConfigResolver._set_license_key(line)
+        next
+      end
+      begin
+        key_values = ConnectionStringConfigResolver._parse_key_values(line)
+        config_name = key_values["name"]
+        runtime_value = key_values["runtime"]
+
+        if config_name.nil? || config_name.strip.empty?
+          raise "Missing or empty config name."
+        end
+        if runtime_value.nil? || runtime_value.strip.empty?
+          raise "Missing or empty runtime."
+        end
+
+        runtime_name = ConfigResolver.try_parse_runtime(runtime_value)
+        host_value = key_values["host"]
+        connection_data = ConfigResolver.build_connection_data(host_value)
+        plugins = key_values["plugins"] || ""
+        modules = key_values["modules"] || ""
+
+        config = Config.new(runtime_name, connection_data, plugins, modules)
+        ConfigsDictionary.add_config(config_name, priority, config)
+      rescue => ex
+        puts "Failed to parse config line: '#{line}'. Reason: #{ex}"
+        raise
+      end
+    end
+  end
+
+  def self._set_license_key(line)
+    eq = line.index("=")
+    if eq && eq > 0 && eq < line.length - 1
+      value_portion = line[eq + 1..-1].strip
+      semicolon = value_portion.index(";")
+      if semicolon && semicolon >= 0
+        value_portion = value_portion[0...semicolon].strip
+      end
+      hash_idx = value_portion.index("#")
+      if hash_idx && hash_idx >= 0
+        value_portion = value_portion[0...hash_idx].strip
+      end
+      slashes = value_portion.index("//")
+      if slashes && slashes >= 0
+        value_portion = value_portion[0...slashes].strip
+      end
+      ActivationHelper.temporary_license_key = value_portion
+    end
+  end
+
+  def self._parse_key_values(line)
+    result = {}
+    segments = line.split(";").map(&:strip).reject(&:empty?)
+    segments.each do |segment|
+      eq = segment.index("=")
+      if !eq || eq <= 0 || eq == segment.length - 1
+        puts "Ignoring malformed token '#{segment}' in line: #{line}"
+        next
+      end
+      key = segment[0...eq].strip.downcase
+      value = segment[eq + 1..-1].strip
+      if !key.empty?
+        result[key] = value
+      end
+    end
+    result
+  end
+end
+

data/lib/javonet-ruby-sdk/sdk/configuration/config_resolvers/json_config_resolver.rb

@@ -0,0 +1,66 @@
+require 'json'
+require_relative 'config_resolver'
+require_relative '../config'
+require_relative '../configs_dictionary'
+require_relative '../config_priority'
+require_relative './../../tools/activation_helper'
+
+class JsonConfigResolver < ConfigResolver
+  def self.add_configs(priority, json_object)
+    if json_object.nil?
+      raise "json_object cannot be nil"
+    end
+    if !json_object.is_a?(Hash)
+      raise "Root JSON element must be a dict/object."
+    end
+
+    license_key = json_object["licenseKey"]
+    if license_key.is_a?(String)
+      ActivationHelper.temporary_license_key = license_key.strip
+    end
+
+    configs = json_object["configurations"]
+    if !configs.is_a?(Hash)
+      raise "JSON must contain 'configurations' object."
+    end
+
+    configs.each do |config_name, cfg|
+      begin
+        if !cfg.is_a?(Hash)
+          raise "Configuration value must be an object/dict."
+        end
+
+        runtime_value = JsonConfigResolver._get_required_string(cfg, "runtime")
+        runtime_name = ConfigResolver.try_parse_runtime(runtime_value)
+
+        host = JsonConfigResolver._get_optional_string(cfg, "host")
+        connection_data = ConfigResolver.build_connection_data(host)
+
+        plugins = JsonConfigResolver._get_optional_string(cfg, "plugins")
+        modules = JsonConfigResolver._get_optional_string(cfg, "modules")
+
+        config = Config.new(runtime_name, connection_data, plugins, modules)
+        ConfigsDictionary.add_config(config_name, priority, config)
+      rescue => ex
+        puts "Failed to add config '#{config_name}': #{ex}"
+      end
+    end
+  end
+
+  def self._get_required_string(obj, property)
+    value = obj[property]
+    if !value.is_a?(String) || value.strip.empty?
+      raise "Missing or invalid '#{property}' property."
+    end
+    value.strip
+  end
+
+  def self._get_optional_string(obj, property)
+    value = obj[property]
+    if value.is_a?(String)
+      return value
+    end
+    ""
+  end
+end
+

data/lib/javonet-ruby-sdk/sdk/configuration/config_resolvers/yaml_config_resolver.rb

@@ -0,0 +1,77 @@
+require 'yaml'
+require_relative 'config_resolver'
+require_relative '../config'
+require_relative '../configs_dictionary'
+require_relative '../config_priority'
+require_relative './../../tools/activation_helper'
+
+class YamlConfigResolver < ConfigResolver
+  def self.add_configs(priority, yaml_string)
+    if yaml_string.nil? || yaml_string.strip.empty?
+      raise "YAML string cannot be null or empty."
+    end
+
+    begin
+      data = YAML.safe_load(yaml_string)
+    rescue => ex
+      raise "Failed to parse YAML: #{ex}"
+    end
+
+    if !data.is_a?(Hash)
+      raise "Root YAML node must be a mapping."
+    end
+
+    license_key = data["licenseKey"]
+    if license_key.is_a?(String)
+      ActivationHelper.temporary_license_key = license_key.strip
+    end
+
+    configs = data["configurations"]
+    if !configs.is_a?(Hash)
+      raise "YAML must contain 'configurations' mapping."
+    end
+
+    configs.each do |config_name, cfg|
+      if !config_name.is_a?(String) || config_name.strip.empty?
+        puts "Skipping entry with empty config name."
+        next
+      end
+      if !cfg.is_a?(Hash)
+        puts "Skipping '#{config_name}': value is not a mapping."
+        next
+      end
+      begin
+        runtime_value = YamlConfigResolver._get_required_string(cfg, "runtime")
+        runtime_name = ConfigResolver.try_parse_runtime(runtime_value)
+
+        host = YamlConfigResolver._get_optional_string(cfg, "host")
+        connection_data = ConfigResolver.build_connection_data(host)
+
+        plugins = YamlConfigResolver._get_optional_string(cfg, "plugins")
+        modules = YamlConfigResolver._get_optional_string(cfg, "modules")
+
+        config = Config.new(runtime_name, connection_data, plugins, modules)
+        ConfigsDictionary.add_config(config_name, priority, config)
+      rescue => ex
+        puts "Failed to add config '#{config_name}': #{ex}"
+      end
+    end
+  end
+
+  def self._get_required_string(mapping, key)
+    value = mapping[key]
+    if !value.is_a?(String) || value.strip.empty?
+      raise "Missing or invalid '#{key}' property."
+    end
+    value.strip
+  end
+
+  def self._get_optional_string(mapping, key)
+    value = mapping[key]
+    if value.is_a?(String)
+      return value
+    end
+    ""
+  end
+end
+