javonet-ruby-sdk 2.3.0 → 2.4.0

data/lib/javonet-ruby-sdk/Binaries/Ruby/Windows/X64/utils/command.rb

@@ -1,4 +1,5 @@
 require_relative 'runtime_name'
+require_relative 'runtime_name_handler'
 require_relative 'command_type'
 
 class Command
@@ -57,7 +58,7 @@ class Command
   end
 
   def to_string
-    'Runtime Library: ' + RuntimeName.get_name(@runtime_name).to_s + ' ' + 'Ruby command type: ' + CommandType.get_name(@command_type).to_s + ' ' + 'with parameters: ' + @payload.to_s
+    'Runtime Library: ' + RuntimeNameHandler.get_name(@runtime_name) + ' ' + 'Ruby command type: ' + CommandType.get_name(@command_type).to_s + ' ' + 'with parameters: ' + @payload.to_s
   end
 
   def eql?(other)

data/lib/javonet-ruby-sdk/Binaries/Ruby/Windows/X64/utils/runtime_name.rb

@@ -8,34 +8,4 @@ module RuntimeName
   RUBY = 6
   NODEJS = 7
   CPP = 8
-
-  def self.get_name(runtime_number)
-    if runtime_number == 0
-      return 'CLR'
-    end
-    if runtime_number == 1
-      return 'GO'
-    end
-    if runtime_number == 2
-      return 'JVM'
-    end
-    if runtime_number == 3
-      return 'NETCORE'
-    end
-    if runtime_number == 4
-      return 'PERL'
-    end
-    if runtime_number == 5
-      return 'PYTHON'
-    end
-    if runtime_number == 6
-      return 'RUBY'
-    end
-    if runtime_number == 7
-      return 'NODEJS'
-    end
-    if runtime_number == 8
-      return 'CPP'
-    end
-  end
 end

data/lib/javonet-ruby-sdk/Binaries/Ruby/Windows/X64/utils/runtime_name_handler.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require_relative './runtime_name'
+
+class RuntimeNameHandler
+  def self.get_name(runtime_name)
+    if runtime_name == RuntimeName::CLR
+      return 'clr'
+    end
+    if runtime_name == RuntimeName::GO
+      return 'go'
+    end
+    if runtime_name == RuntimeName::JVM
+      return 'jvm'
+    end
+    if runtime_name == RuntimeName::NETCORE
+      return 'netcore'
+    end
+    if runtime_name == RuntimeName::PERL
+      return 'perl'
+    end
+    if runtime_name == RuntimeName::PYTHON
+      return 'python'
+    end
+    if runtime_name == RuntimeName::RUBY
+      return 'ruby'
+    end
+    if runtime_name == RuntimeName::NODEJS
+      return 'nodejs'
+    end
+    if runtime_name == RuntimeName::CPP
+      return 'cpp'
+    end
+  end
+end

data/lib/javonet-ruby-sdk/Binaries/Ruby/Windows/X64/utils/tcp_connection_data.rb

@@ -0,0 +1,33 @@
+class TcpConnectionData
+  attr_reader :ip_address, :port
+
+  def initialize(hostname, port)
+    @port = port
+    if hostname == "localhost"
+      @ip_address = "127.0.0.1"
+    else
+      begin
+        @ip_address = IPSocket.getaddress(hostname)
+      rescue SocketError
+        raise "Unable to resolve hostname to an IP address."
+      end
+    end
+  end
+
+  def ==(other)
+    other.is_a?(TcpConnectionData) && @ip_address == other.ip_address && @port == other.port
+  end
+
+  def to_s
+    "#{@ip_address}:#{@port}"
+
+  end
+
+  def get_address_bytes
+    @ip_address.split(".").map(&:to_i)
+  end
+
+  def get_port_bytes
+    [@port & 0xFF, @port >> 8]
+  end
+end

data/lib/javonet-ruby-sdk/Binaries/version.txt

@@ -1 +1 @@
-2.3.0
+2.4.0

data/lib/javonet-ruby-sdk/core/interpreter/interpreter.rb

@@ -3,11 +3,11 @@ require_relative '../protocol/command_deserializer'
 require_relative '../handler/handler'
 
 class Interpreter
-  def execute(command, connection_type, tcp_address)
+  def execute(command, connection_type, tcp_connection_data)
 
     command_serializer = CommandSerializer.new
-    message_byte_array = command_serializer.serialize(command, connection_type, tcp_address)
-    if command.runtime_name == RuntimeName::RUBY
+    message_byte_array = command_serializer.serialize(command, connection_type, tcp_connection_data)
+    if command.runtime_name == RuntimeName::RUBY && connection_type == ConnectionType::IN_MEMORY
       require_relative '../receiver/receiver'
       response_byte_array = Receiver.new.send_command(message_byte_array, message_byte_array.length)
     else
@@ -16,8 +16,7 @@ class Interpreter
     end
 
     command_deserializer = CommandDeserializer.new(response_byte_array,response_byte_array.length)
-    encoded_response = command_deserializer.deserialize
-    return encoded_response
+    command_deserializer.deserialize
   end
 
   def process(byte_array, byte_array_len)
@@ -25,6 +24,6 @@ class Interpreter
     received_command = command_deserializer.deserialize
     handler = Handler.new
     command_serializer = CommandSerializer.new
-    return command_serializer.serialize(handler.handle_command(received_command), 0, "0.0.0.0:0")
+    command_serializer.serialize(handler.handle_command(received_command))
   end
 end

data/lib/javonet-ruby-sdk/core/protocol/command_serializer.rb

@@ -1,6 +1,7 @@
 require_relative 'type_serializer'
 require_relative '../../utils/connection_type'
 require_relative '../../utils/runtime_name'
+require_relative '../../utils/tcp_connection_data'
 
 class CommandSerializer
 
@@ -8,38 +9,21 @@ class CommandSerializer
     @byte_buffer = []
   end
 
-  def serialize(root_command, connection_type = ConnectionType::IN_MEMORY, tcp_address = nil, runtime_version = 0)
+  def serialize(root_command, connection_type = ConnectionType::IN_MEMORY, tcp_connection_data = nil, runtime_version = 0)
     queue = []
     queue.unshift(root_command)
     self.insert_into_buffer([root_command.runtime_name, runtime_version])
-    if connection_type == ConnectionType::TCP
-      self.insert_into_buffer([ConnectionType::TCP])
-      self.insert_into_buffer(self.serialize_tcp(tcp_address))
-    end
-    if connection_type == ConnectionType::IN_MEMORY
-      self.insert_into_buffer([ConnectionType::IN_MEMORY])
-      self.insert_into_buffer([0, 0, 0, 0, 0, 0])
-    end
+    self.insert_into_buffer([connection_type])
+    self.insert_into_buffer(self.serialize_tcp(tcp_connection_data))
     self.insert_into_buffer([RuntimeName::RUBY, root_command.command_type])
     self.serialize_recursively(queue)
   end
 
-  def serialize_tcp(tcp_address)
-    if tcp_address.kind_of?(Array)
-      tcp_address
-    else
-      tcp_address_array = tcp_address.split(':')
-      tcp_address_ip = tcp_address_array[0].split('.')
-      tcp_address_port = tcp_address_array[1]
-      tcp_address_bytearray = []
-      tcp_address_ip.each { |address|
-        tcp_address_bytearray.concat([address.to_i])
-      }
-      port_byte = [tcp_address_port.to_i].pack("s_").bytes
-      tcp_address_bytearray.concat(port_byte)
-      tcp_address_bytearray
+  def serialize_tcp(tcp_connection_data)
+    if tcp_connection_data.nil?
+      return [0, 0, 0, 0, 0, 0]
     end
-
+    tcp_connection_data.get_address_bytes + tcp_connection_data.get_port_bytes
   end
 
   def serialize_primitive(payload_item)

data/lib/javonet-ruby-sdk/core/transmitter/transmitter.rb

@@ -4,10 +4,6 @@ require_relative 'transmitter_wrapper'
 
 class Transmitter
 
-  def self.get_native_error
-    TransmitterWrapper.GetNativeError
-  end
-
   def self.send_command(message_byte_array, message_byte_array_len)
     message = FFI::MemoryPointer.new(:uchar, message_byte_array_len, true)
     message.put_array_of_uchar(0, message_byte_array)
@@ -26,26 +22,39 @@ class Transmitter
     end
   end
 
-  def self.activate_with_licence_file()
+  def self.activate_with_license_file()
     return activate()
   end
 
-  def self.activate_with_credentials(licenceKey)
-    return activate(licenceKey)
+  def self.activate_with_credentials(licenseKey)
+    return activate(licenseKey)
   end
 
-  def self.activate_with_credentials_and_proxy(licenceKey, proxyHost, proxyUserName, proxyPassword)
-    return activate(licenceKey, proxyHost, proxyUserName, proxyPassword)
+  def self.activate_with_credentials_and_proxy(licenseKey, proxyHost, proxyUserName, proxyPassword)
+    return activate(licenseKey, proxyHost, proxyUserName, proxyPassword)
   end
 
-  private_class_method def self.activate(licenceKey = "", proxyHost = "", proxyUserName = "", proxyUserPassword = "")
-    activation_result = TransmitterWrapper.Activate(licenceKey, proxyHost, proxyUserName, proxyUserPassword)
+  private_class_method def self.activate(licenseKey = "", proxyHost = "", proxyUserName = "", proxyUserPassword = "")
+    activation_result = TransmitterWrapper.Activate(licenseKey, proxyHost, proxyUserName, proxyUserPassword)
     if activation_result < 0
       error_message = get_native_error
-      raise Exception.new "Javonet activation result: " + activation_result.to_s + ". " + error_message
+      raise Exception.new "Javonet activation result: " + activation_result.to_s + ". Native error message: " + error_message
     else
       return activation_result
     end
   end
 
+  def self.get_native_error
+    TransmitterWrapper.GetNativeError
+  end
+
+  def self.set_config_source(configPath)
+    set_config_result = TransmitterWrapper.SetConfigSource(configPath)
+    if set_config_result < 0
+      error_message = get_native_error
+      raise Exception.new "Javonet set config source result: " + set_config_result.to_s + ". Native error message: " + error_message
+    else
+      return set_config_result
+    end
+  end
 end

data/lib/javonet-ruby-sdk/core/transmitter/transmitter_wrapper.rb

@@ -12,5 +12,5 @@ module TransmitterWrapper
   attach_function :ReadResponse, [:pointer, :int], :int
   attach_function :Activate, [:pointer, :pointer, :pointer, :pointer], :int
   attach_function :GetNativeError, [], :string
-
+  attach_function :SetConfigSource, [:pointer], :int
 end

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

@@ -0,0 +1,92 @@
+require_relative './internal/abstract_config_runtime_factory'
+require_relative './runtime_context'
+require_relative './../utils/connection_type'
+require_relative './tools/json_file_resolver'
+
+# 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
+  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(RuntimeName::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(RuntimeName::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(RuntimeName::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(RuntimeName::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(RuntimeName::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(RuntimeName::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(RuntimeName::PYTHON, 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))
+      return RuntimeContext.get_instance(runtime, ConnectionType::TCP, conn_data)
+    elsif conn_type == "inMemory"
+      return RuntimeContext.get_instance(runtime, ConnectionType::IN_MEMORY, nil)
+    else
+      raise "Invalid connection type"
+    end
+  end
+end

data/lib/javonet-ruby-sdk/sdk/internal/abstract_config_runtime_factory.rb

@@ -0,0 +1,30 @@
+class AbstractConfigRuntimeFactory
+  def clr(config_name = "default")
+    raise NotImplementedError, "method not implemented"
+  end
+
+  def jvm(config_name = "default")
+    raise NotImplementedError, "method not implemented"
+  end
+
+  def netcore(config_name = "default")
+    raise NotImplementedError, "method not implemented"
+  end
+
+  def perl(config_name = "default")
+    raise NotImplementedError, "method not implemented"
+  end
+
+  def ruby(config_name = "default")
+    raise NotImplementedError, "method not implemented"
+  end
+
+  def nodejs(config_name = "default")
+    raise NotImplementedError, "method not implemented"
+  end
+
+  def python(config_name = "default")
+    raise NotImplementedError, "method not implemented"
+  end
+
+end

data/lib/javonet-ruby-sdk/sdk/{internal/invocation_context.rb → invocation_context.rb}

@@ -1,7 +1,7 @@
-require_relative 'abstract/abstract_invocation_context'
-require_relative '../../core/interpreter/interpreter'
-require_relative '../../core/exceptions/exception_thrower'
-require_relative 'invocation_context_iterator'
+require_relative 'internal/abstract_invocation_context'
+require_relative 'internal/invocation_context_iterator'
+require_relative '../core/interpreter/interpreter'
+require_relative '../core/exceptions/exception_thrower'
 
 # InvocationContext is a class that represents a context for invoking commands.
 # It implements several interfaces for different types of interactions.
@@ -18,8 +18,8 @@ class InvocationContext < AbstractInvocationContext
     @current_command = command
     @response_command = nil
     @interpreter = Interpreter.new
-    # generates error: ruby/lib/javonet-ruby-sdk/sdk/internal/invocation_context.rb:17: warning: finalizer references object to be finalized
-    #ObjectSpace.define_finalizer(self, self.finalize(@current_command, @is_executed, @interpreter, @connection_type, @tcp_ip_address))
+    # generates error: ruby/lib/javonet.rb-ruby-sdk/sdk/internal/invocation_context.rb:17: warning: finalizer references object to be finalized
+    # ObjectSpace.define_finalizer(self, self.finalize(@current_command, @is_executed, @interpreter, @connection_type, @tcp_ip_address))
   end
 
   def finalize(command, is_executed, interpreter, connection_type, tcp_ip_address)

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

@@ -0,0 +1,53 @@
+require_relative './runtime_factory'
+require_relative './config_runtime_factory'
+require_relative './../utils/connection_type'
+require_relative './../utils/tcp_connection_data'
+require_relative './../core/transmitter/transmitter'
+
+# The Javonet class is a singleton class that serves as the entry point for interacting with Javonet.
+# It provides methods to activate and initialize the Javonet SDK.
+# It supports both in-memory and TCP connections.
+# @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/javonet-static-class article on Javonet Guides}
+class Javonet
+
+  Transmitter.activate_with_license_file
+
+  # Initializes Javonet using an in-memory channel on the same machine.
+  # @return [RuntimeFactory] A RuntimeFactory instance configured for an in-memory connection.
+  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/in-memory-channel article on Javonet Guides}
+  def self.in_memory
+    RuntimeFactory.new(ConnectionType::IN_MEMORY, nil)
+  end
+
+  # Initializes Javonet with a TCP connection to a remote machine.
+  # @param address [TcpConnectionData] The address of the remote machine.
+  # @return [RuntimeFactory] A RuntimeFactory instance configured for a TCP connection.
+  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/tcp-channel article on Javonet Guides}
+  def self.tcp(tcp_connection_data)
+    RuntimeFactory.new(ConnectionType::TCP, tcp_connection_data)
+  end
+
+  # Initializes Javonet with a custom configuration file.
+  # @param path [String] Path to a configuration file.
+  # @return [ConfigRuntimeFactory] A ConfigRuntimeFactory instance configured with configuration data
+  # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/configure-channel article on Javonet Guides}
+  def self.with_config(path)
+    Transmitter.set_config_source(path)
+    ConfigRuntimeFactory.new(path)
+  end
+
+  # Activates Javonet with the provided license key and optionally with proxy data.
+  # @param license_key [String] The license key to activate Javonet.
+  # @param proxy_host [String] The host for the proxy server (optional).
+  # @param proxy_user_name [String] The username for the proxy server (optional).
+  # @param proxy_user_password [String] The password for the proxy server (optional).
+  # @return [Integer] The activation status code.
+  # @see https://www.javonet.com/guides/v2/ruby/getting-started/activating-javonet Activating Javonet Guide
+  def self.activate(license_key, proxy_host=nil, proxy_user_name=nil, proxy_password=nil)
+    proxy_host ||= ""
+    proxy_user_name ||= ""
+    proxy_password ||= ""
+    return Transmitter.activate_with_credentials_and_proxy(license_key, proxy_host, proxy_user_name, proxy_password)
+  end
+
+end

data/lib/javonet-ruby-sdk/sdk/{internal/runtime_context.rb → runtime_context.rb}

@@ -1,16 +1,17 @@
-require_relative 'abstract/abstract_runtime_context'
-require_relative 'invocation_context'
-require_relative '../../utils/connection_type'
-require_relative '../../core/interpreter/interpreter'
-
- # Represents a single context which allows interaction with a selected technology.
- # Refers to a single instance of the called runtime within a particular target OS process.
- # This can be either the local currently running process (inMemory) or a particular remote process identified by the IP Address and PORT of the target Javonet instance.
- # Multiple Runtime Contexts can be initialized within one process.
- # Calling the same technology on inMemory communication channel will return the existing instance of runtime context.
- # Calling the same technology on TCP channel but on different nodes will result in unique Runtime Contexts.
- # Within the runtime context, any number of libraries can be loaded and any objects from the target technology can be interacted with, as they are aware of each other due to sharing the same memory space and same runtime instance.
- # @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
+require_relative './internal/abstract_runtime_context'
+require_relative './invocation_context'
+require_relative './../utils/connection_type'
+require_relative './../utils/tcp_connection_data'
+require_relative './../core/interpreter/interpreter'
+
+# Represents a single context which allows interaction with a selected technology.
+# Refers to a single instance of the called runtime within a particular target OS process.
+# This can be either the local currently running process (inMemory) or a particular remote process identified by the IP Address and PORT of the target Javonet instance.
+# Multiple Runtime Contexts can be initialized within one process.
+# Calling the same technology on inMemory communication channel will return the existing instance of runtime context.
+# Calling the same technology on TCP channel but on different nodes will result in unique Runtime Contexts.
+# Within the runtime context, any number of libraries can be loaded and any objects from the target technology can be interacted with, as they are aware of each other due to sharing the same memory space and same runtime instance.
+# @see Refer to this {https://www.javonet.com/guides/v2/ruby/foundations/runtime-context article on Javonet Guides}
 class RuntimeContext < AbstractRuntimeContext
   @@memory_runtime_contexts = Hash.new
   @@network_runtime_contexts = Hash.new
@@ -21,33 +22,35 @@ class RuntimeContext < AbstractRuntimeContext
   # accessor set method
   attr_writer :current_command
 
-  def initialize(runtime_name, connection_type, tcp_address)
+  def initialize(runtime_name, connection_type, tcp_connection_data)
     @runtime_name = runtime_name
     @connection_type = connection_type
-    @tcp_ip_address = tcp_address
+    @tcp_ip_address = tcp_connection_data
     @current_command = nil
     @interpreter = Interpreter.new
   end
 
-  def self.get_instance(runtime_name, connection_type, tcp_address)
-    if (ConnectionType::TCP == connection_type) && tcp_address == nil
-      if @@network_runtime_contexts.has_key?(tcp_address)
-        runtime_ctx = @@network_runtime_contexts[tcp_address]
+  def self.get_instance(runtime_name, connection_type, tcp_connection_data)
+    case connection_type
+    when ConnectionType::IN_MEMORY
+      if @@memory_runtime_contexts.has_key?(runtime_name)
+        runtime_ctx = @@memory_runtime_contexts[runtime_name]
         runtime_ctx.current_command = nil
         return runtime_ctx
       else
-        runtime_ctx = RuntimeContext.new(runtime_name, connection_type, tcp_address)
-        @@network_runtime_contexts[:tcp_address] = runtime_ctx
+        runtime_ctx = RuntimeContext.new(runtime_name, connection_type, tcp_connection_data)
+        @@memory_runtime_contexts[runtime_name] = runtime_ctx
         return runtime_ctx
       end
-    else
-      if (@@memory_runtime_contexts.has_key?(runtime_name))
-        runtime_ctx = @@network_runtime_contexts[runtime_name]
+    when ConnectionType::TCP
+      key = runtime_name.to_s + ":" + tcp_connection_data.to_s
+      if @@network_runtime_contexts.has_key?(key)
+        runtime_ctx = @@network_runtime_contexts[key]
         runtime_ctx.current_command = nil
         return runtime_ctx
       else
-        runtime_ctx = RuntimeContext.new(runtime_name, connection_type, nil)
-        @@memory_runtime_contexts[:tcp_address] = runtime_ctx
+        runtime_ctx = RuntimeContext.new(runtime_name, connection_type, tcp_connection_data)
+        @@network_runtime_contexts[key] = runtime_ctx
         return runtime_ctx
       end
     end
@@ -66,7 +69,7 @@ class RuntimeContext < AbstractRuntimeContext
       raise ExceptionThrower.throw_exception(@response_command)
     end
   end
-  
+
   # Adds a reference to a library. Javonet allows you to reference and use modules or packages written in various languages.
   # This method allows you to use any library from all supported technologies. The necessary libraries need to be referenced.
   # The argument is a relative or full path to the library. If the library has dependencies on other libraries, the latter needs to be added first.
@@ -115,9 +118,9 @@ class RuntimeContext < AbstractRuntimeContext
     return InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command), false)
   end
 
-  # Creates a reference type argument that can be passed to a method with a ref parameter modifier. 
+  # Creates a reference type argument that can be passed to a method with a ref parameter modifier.
   # This method is used when working with methods from the called runtime that require arguments to be passed by reference.
-  # The arguments include the value and optionally the type of the reference. 
+  # The arguments include the value and optionally the type of the reference.
   # The type must be retrieved from the called runtime using the getType method.
   # After creating the reference, it can be used as an argument when invoking methods.
   # @param args [Array] The value and optionally the type of the reference.
@@ -129,9 +132,9 @@ class RuntimeContext < AbstractRuntimeContext
     return InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command), false)
   end
 
-  # Creates a reference type argument that can be passed to a method with an out parameter modifier. 
+  # Creates a reference type argument that can be passed to a method with an out parameter modifier.
   # This method is used when working with methods from the called runtime that require arguments to be passed by reference.
-  # The arguments include the value and optionally the type of the reference. 
+  # The arguments include the value and optionally the type of the reference.
   # The type must be retrieved from the called runtime using the getType method.
   # After creating the reference, it can be used as an argument when invoking methods.
   # @param args [Array] The value and optionally the type of the reference.
@@ -143,9 +146,8 @@ class RuntimeContext < AbstractRuntimeContext
     return InvocationContext.new(@runtime_name, @connection_type, @tcp_ip_address, build_command(local_command), false)
   end
 
-
   def build_command(command)
-    command.payload.each_index {|i|
+    command.payload.each_index { |i|
       command.payload[i] = encapsulate_payload_item(command.payload[i])
     }
     return command.prepend_arg_to_payload(@current_command)
@@ -169,8 +171,6 @@ class RuntimeContext < AbstractRuntimeContext
 
     else
       return Command.new(@runtime_name, CommandType::VALUE, [*payload_item])
-
     end
   end
-
 end