javonet-ruby-sdk 2.3.0 → 2.4.1

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

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

@@ -1,69 +1,64 @@
-require_relative 'abstract/abstract_runtime_factory'
-require_relative '../../utils/connection_type'
-require_relative 'runtime_context'
+require_relative './internal/abstract_runtime_factory'
+require_relative './runtime_context'
+require_relative './../utils/connection_type'
+
 
 # The RuntimeFactory class implements the AbstractRuntimeFactory 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 RuntimeFactory < AbstractRuntimeFactory
 
-  def initialize(connection_type, tcp_address = nil)
+  def initialize(connection_type, tcp_connection_data)
     @connection_type = connection_type
-    if @connection_type == ConnectionType::TCP
-      if tcp_address.nil?
-        raise("Error tcp ip adress is not given!")
-      end
-    end
-    @tcp_address = tcp_address
+    @tcp_connection_data = tcp_connection_data
   end
 
   # Creates a RuntimeContext instance to interact with CLR runtime.
   # @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
-    RuntimeContext.get_instance(RuntimeName::CLR, @connection_type, @tcp_address)
+    RuntimeContext.get_instance(RuntimeName::CLR, @connection_type, @tcp_connection_data)
   end
 
   # Creates a RuntimeContext instance to interact with JVM runtime.
   # @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
-    RuntimeContext.get_instance(RuntimeName::JVM, @connection_type, @tcp_address)
+    RuntimeContext.get_instance(RuntimeName::JVM, @connection_type, @tcp_connection_data)
   end
 
   # Creates a RuntimeContext instance to interact with .NET runtime.
   # @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
-    RuntimeContext.get_instance(RuntimeName::NETCORE, @connection_type, @tcp_address)
+    RuntimeContext.get_instance(RuntimeName::NETCORE, @connection_type, @tcp_connection_data)
   end
 
   # Creates a RuntimeContext instance to interact with Perl runtime.
   # @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
-    RuntimeContext.get_instance(RuntimeName::PERL, @connection_type, @tcp_address)
+    RuntimeContext.get_instance(RuntimeName::PERL, @connection_type, @tcp_connection_data)
   end
 
   # Creates a RuntimeContext instance to interact with Ruby runtime.
   # @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
-    RuntimeContext.get_instance(RuntimeName::RUBY, @connection_type, @tcp_address)
+    RuntimeContext.get_instance(RuntimeName::RUBY, @connection_type, @tcp_connection_data)
   end
 
   # Creates a RuntimeContext instance to interact with Node.js runtime.
   # @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
-    RuntimeContext.get_instance(RuntimeName::NODEJS, @connection_type, @tcp_address)
+    RuntimeContext.get_instance(RuntimeName::NODEJS, @connection_type, @tcp_connection_data)
   end
 
   # Creates a RuntimeContext instance to interact with Python runtime.
   # @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
-    RuntimeContext.get_instance(RuntimeName::PYTHON, @connection_type, @tcp_address)
+    RuntimeContext.get_instance(RuntimeName::PYTHON, @connection_type, @tcp_connection_data)
   end
-
 end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+require 'json'
+
+class JsonFileResolver
+  def initialize(path)
+    @path = path
+    begin
+      file = File.read(@path)
+      @json_object = JSON.parse(file)
+    rescue Errno::ENOENT
+      raise "Configuration file #{@path} not found. Please check your configuration file."
+    end
+  end
+
+  def get_license_key
+    @json_object["licenseKey"] || (raise "License key not found in configuration file. Please check your configuration file.")
+  end
+
+  def get_runtimes
+    @json_object["runtimes"]
+  end
+
+  def get_runtime(runtime_name, config_name)
+    runtimes = get_runtimes
+    if runtimes.key?(runtime_name)
+      runtime = runtimes[runtime_name]
+      if runtime.is_a?(Array)
+        return runtime.find { |item| item["name"] == config_name }
+      elsif runtime["name"] == config_name
+        return runtime
+      end
+    end
+    raise "Runtime config #{config_name} not found in configuration file for runtime #{runtime_name}. Please check your configuration file."
+  end
+
+  def get_channel(runtime_name, config_name)
+    runtime = get_runtime(runtime_name, config_name)
+    runtime["channel"] || (raise "Channel key not found in configuration file for config #{config_name}. Please check your configuration file.")
+  end
+
+  def get_channel_type(runtime_name, config_name)
+    channel = get_channel(runtime_name, config_name)
+    channel["type"] || (raise "Channel type not found in configuration file for config #{config_name}. Please check your configuration file.")
+  end
+
+  def get_channel_host(runtime_name, config_name)
+    channel = get_channel(runtime_name, config_name)
+    channel["host"] || (raise "Channel host not found in configuration file for config #{config_name}. Please check your configuration file.")
+  end
+
+  def get_channel_port(runtime_name, config_name)
+    channel = get_channel(runtime_name, config_name)
+    channel["port"] || (raise "Channel port not found in configuration file for config #{config_name}. Please check your configuration file.")
+  end
+end

data/lib/javonet-ruby-sdk/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/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/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/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.rb

@@ -1,42 +1 @@
-require_relative './javonet-ruby-sdk/utils/connection_type'
-require_relative './javonet-ruby-sdk/sdk/internal/runtime_factory'
-require_relative './javonet-ruby-sdk/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_licence_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
-    connection_type = ConnectionType::IN_MEMORY
-    return RuntimeFactory.new(connection_type)
-  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(address)
-    connection_type = ConnectionType::TCP
-    return RuntimeFactory.new(connection_type, address)
-  end
-
-
-  # Activates Javonet with the provided license key and optionally with proxy data.
-  # @param licence_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(licence_key, proxy_host="", proxy_user_name="", proxy_password="")
-    return Transmitter.activate_with_credentials_and_proxy(licence_key, proxy_host, proxy_user_name, proxy_password)
-  end
-
-end
+require_relative './javonet-ruby-sdk/sdk/javonet'