javonet-nodejs-sdk 2.0.5 → 2.1.1

package/Binaries/Ruby/Windows/X64/core/interpreter/interpreter.rb

@@ -0,0 +1,30 @@
+require_relative '../protocol/command_serializer'
+require_relative '../protocol/command_deserializer'
+require_relative '../handler/handler'
+
+class Interpreter
+  def execute(command, connection_type, tcp_address)
+
+    command_serializer = CommandSerializer.new
+    message_byte_array = command_serializer.encode(command, connection_type, tcp_address)
+    if command.runtime_name == RuntimeName::RUBY
+      require_relative '../receiver/receiver'
+      response_byte_array = Receiver.new.send_command(message_byte_array, message_byte_array.length)
+    else
+      require_relative '../transmitter/transmitter'
+      response_byte_array = Transmitter.send_command(message_byte_array, message_byte_array.length)
+    end
+
+    command_deserializer = CommandDeserializer.new(response_byte_array,response_byte_array.length)
+    encoded_response = command_deserializer.decode
+    return encoded_response
+  end
+
+  def process(byte_array, byte_array_len)
+    command_deserializer = CommandDeserializer.new(byte_array,byte_array_len)
+    received_command = command_deserializer.decode
+    handler = Handler.new
+    command_serializer = CommandSerializer.new
+    return command_serializer.encode(handler.handle_command(received_command), 0, "0.0.0.0:0")
+  end
+end

package/Binaries/Ruby/Windows/X64/core/protocol/command_deserializer.rb

@@ -1,7 +1,7 @@
 require_relative 'type_deserializer'
-require_relative '../../sdk/core/type'
-require_relative '../../sdk/core/ruby_command'
-require_relative '../../sdk/core/string_encoding_mode'
+require_relative '../../utils/type'
+require_relative '../../utils/command'
+require_relative '../../utils/string_encoding_mode'
 
 class CommandDeserializer
 
@@ -9,7 +9,7 @@ class CommandDeserializer
     def initialize(buffer,byte_array_len)
         @buffer = buffer
         @byte_array_len = byte_array_len
-        @command = RubyCommand.new(buffer[0], buffer[10], [])
+        @command = Command.new(buffer[0], buffer[10], [])
         @position = 11
     end
 
@@ -58,7 +58,7 @@ class CommandDeserializer
         command_type = @buffer[p + 6]
 
         @position += 7
-        return_command = RubyCommand.new(runtime, command_type, [])
+        return_command = Command.new(runtime, command_type, [])
         return read_command_recursively(number_of_elements_in_payload, return_command)
     end
 
@@ -67,7 +67,6 @@ class CommandDeserializer
             return cmd
         else
             p = @position
-            arg_size = TypeDeserializer.deserialize_int(@buffer[p+1..p+4])
             new_command = cmd.add_arg_to_payload(self.read_object(@buffer[p]))
             return read_command_recursively(number_of_elements_in_payload_left - 1, new_command)
         end

package/Binaries/Ruby/Windows/X64/core/protocol/command_serializer.rb

@@ -1,6 +1,6 @@
 require_relative 'type_serializer'
-require_relative '../../sdk/internal/connection_type'
-require_relative '../../sdk/core/runtime_lib'
+require_relative '../../utils/connection_type'
+require_relative '../../utils/runtime_name'
 
 class CommandSerializer
 
@@ -9,10 +9,10 @@ class CommandSerializer
   end
 
 
-  def encode(root_command, connection_type, tcp_address = nil, runtimeVersion = 0)
+  def encode(root_command, connection_type = ConnectionType::IN_MEMORY, tcp_address = nil, runtimeVersion = 0)
     queue = []
     queue.unshift(root_command)
-    self.insert_into_buffer([root_command.runtime_lib, runtimeVersion])
+    self.insert_into_buffer([root_command.runtime_name, runtimeVersion])
     if connection_type == ConnectionType::TCP
       self.insert_into_buffer([ConnectionType::TCP])
       self.insert_into_buffer(self.serialize_tcp(tcp_address))
@@ -21,7 +21,7 @@ class CommandSerializer
       self.insert_into_buffer([ConnectionType::IN_MEMORY])
       self.insert_into_buffer([0, 0, 0, 0, 0, 0])
     end
-    self.insert_into_buffer([RuntimeLib::RUBY, root_command.command_type])
+    self.insert_into_buffer([RuntimeName::RUBY, root_command.command_type])
     return self.serialize_recursively(queue)
   end
 
@@ -58,7 +58,7 @@ class CommandSerializer
       serialized_bool = TypeSerializer.serialize_bool(payload_item)
       return serialized_bool
     else
-      return None
+      return nil
     end
   end
 
@@ -75,7 +75,7 @@ class CommandSerializer
     command = queue.shift
     queue.unshift(command.drop_first_payload_argument)
     if command.payload.length > 0
-      if command.payload[0].is_a? RubyCommand
+      if command.payload[0].is_a? Command
         inner_command = command.payload[0]
         self.insert_into_buffer(TypeSerializer.serialize_command(inner_command))
         queue.unshift(inner_command)

package/Binaries/Ruby/Windows/X64/core/protocol/type_deserializer.rb

@@ -1,4 +1,4 @@
-require_relative '../../sdk/core/string_encoding_mode'
+require_relative '../../utils/string_encoding_mode'
 
 class TypeDeserializer
 
@@ -67,7 +67,7 @@ class TypeDeserializer
   # end
 
   def self.deserialize_command(command_byte_array)
-    python_command = RubyCommand.new(RuntimeLib(command_byte_array[0]), RubyCommandType(command_byte_array[1]), [])
+    python_command = Command.new(RuntimeName(command_byte_array[0]), CommandType(command_byte_array[1]), [])
     return python_command
   end
 

package/Binaries/Ruby/Windows/X64/core/protocol/type_serializer.rb

@@ -1,5 +1,5 @@
-require_relative '../../sdk/core/type'
-require_relative '../../sdk/core/string_encoding_mode'
+require_relative '../../utils/type'
+require_relative '../../utils/string_encoding_mode'
 
 class TypeSerializer
 
@@ -62,7 +62,7 @@ class TypeSerializer
 
   def self.serialize_command(command)
       length = [command.payload.length()].pack("i").bytes
-      return [Type::COMMAND] + length + [command.runtime_lib, command.command_type]
+      return [Type::COMMAND] + length + [command.runtime_name, command.command_type]
   end
 
 end

package/Binaries/Ruby/Windows/X64/core/receiver/receiver.rb

@@ -1,16 +1,16 @@
-require_relative '../interpreter/ruby_interpreter'
+require_relative '../interpreter/interpreter'
 
 class Receiver
   
   def initialize
-    @@ruby_interpreter = RubyInterpreter.new
+    @@interpreter = Interpreter.new
   end
 
   def send_command(message_array, message_array_len)
-    return @@ruby_interpreter.process(message_array, message_array_len)
+    @@interpreter.process(message_array, message_array_len)
   end
   
   def heart_beat(message_array, message_array_len)
-    response_array = [49,48]
+    [49,48]
   end
 end

package/Binaries/Ruby/Windows/X64/core/transmitter/transmitter.rb

@@ -0,0 +1,51 @@
+require 'ffi'
+require 'os'
+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)
+    response_byte_array_len = TransmitterWrapper.SendCommand(message, message_byte_array_len)
+    if response_byte_array_len > 0
+      response = FFI::MemoryPointer.new(:uchar, response_byte_array_len, true)
+      TransmitterWrapper.ReadResponse(response, response_byte_array_len)
+      response_byte_array = response.get_array_of_uchar(0, response_byte_array_len)
+      return response_byte_array
+    elsif response_byte_array_len == 0
+      error_message = "Response is empty"
+      raise Exception.new error_message
+    else
+      error_message = get_native_error
+      raise Exception.new "Javonet native error code: " + response_byte_array_len.to_s + ". " + error_message
+    end
+  end
+
+  def self.activate_with_licence_file()
+    return activate()
+  end
+
+  def self.activate_with_credentials(email, licenceKey)
+    return activate(email, licenceKey)
+  end
+
+  def self.activate_with_credentials_and_proxy(email, licenceKey, proxyHost, proxyUserName, proxyPassword)
+    return activate(email, licenceKey, proxyHost, proxyUserName, proxyPassword)
+  end
+
+  private_class_method def self.activate(email = "", licenceKey = "", proxyHost = "", proxyUserName = "", proxyUserPassword = "")
+    activation_result = TransmitterWrapper.Activate(email, licenceKey, proxyHost, proxyUserName, proxyUserPassword)
+    if activation_result < 0
+      error_message = get_native_error
+      raise Exception.new "Javonet activation result: " + activation_result.to_s + ". " + error_message
+    else
+      return activation_result
+    end
+  end
+
+end

package/Binaries/Ruby/Windows/X64/core/transmitter/transmitter_wrapper.rb

@@ -0,0 +1,16 @@
+module TransmitterWrapper
+  extend FFI::Library
+  if OS.linux?
+    ffi_lib File.expand_path('../../../Binaries/Native/Linux/X64/libJavonetRubyRuntimeNative.so', __FILE__)
+  elsif OS.mac?
+    ffi_lib File.expand_path('../../../Binaries/Native/MacOs/X64/libJavonetRubyRuntimeNative.dylib', __FILE__)
+  else
+    RubyInstaller::Runtime.add_dll_directory(File.expand_path('../../../Binaries/Native/Windows/X64/', __FILE__))
+    ffi_lib File.expand_path('../../../Binaries/Native/Windows/X64/JavonetRubyRuntimeNative.dll', __FILE__)
+  end
+  attach_function :SendCommand, [:pointer, :int], :int
+  attach_function :ReadResponse, [:pointer, :int], :int
+  attach_function :Activate, [:pointer, :pointer, :pointer, :pointer, :pointer], :int
+  attach_function :GetNativeError, [], :string
+
+end

package/Binaries/Ruby/Windows/X64/{sdk/core/ruby_command.rb → utils/command.rb}

@@ -1,15 +1,15 @@
-require_relative 'runtime_lib'
-require_relative 'ruby_command_type'
+require_relative 'runtime_name'
+require_relative 'command_type'
 
-class RubyCommand
-  def initialize(runtime_lib, command_type, payload)
-    @runtime_lib = runtime_lib
+class Command
+  def initialize(runtime_name, command_type, payload)
+    @runtime_name = runtime_name
     @command_type = command_type
     @payload = payload
   end
 
-  def runtime_lib
-    @runtime_lib
+  def runtime_name
+    @runtime_name
   end
 
   def command_type
@@ -21,7 +21,7 @@ class RubyCommand
   end
 
   def to_string
-    'Runtime Library: ' + RuntimeLib.get_name(@runtime_lib).to_s + ' ' + 'Ruby command type: ' + RubyCommandType.get_name(@command_type).to_s + ' ' + 'with parameters: ' + @payload.to_s
+    'Runtime Library: ' + RuntimeName.get_name(@runtime_name).to_s + ' ' + 'Ruby command type: ' + CommandType.get_name(@command_type).to_s + ' ' + 'with parameters: ' + @payload.to_s
   end
 
   def eql?(other)
@@ -32,7 +32,7 @@ class RubyCommand
     if other == nil or self.class != other.class
       @is_equal = false
     end
-    if self.command_type == other.command_type and self.runtime_lib == other.runtime_lib
+    if self.command_type == other.command_type and self.runtime_name == other.runtime_name
       @is_equal = true
     end
     if payload.length == other.payload.length
@@ -54,15 +54,15 @@ class RubyCommand
   end
 
   def create_response(response)
-    return RubyCommand.new(@runtime_lib, RubyCommandType::RESPONSE, [response])
+    return Command.new(@runtime_name, CommandType::VALUE, [response])
   end
 
   def create_reference(guid)
-    return RubyCommand.new(@runtime_lib, RubyCommandType::REFERENCE, [guid])
+    return Command.new(@runtime_name, CommandType::REFERENCE, [guid])
   end
 
   def create_array_response(array)
-    return RubyCommand.new(@runtime_lib, RubyCommandType::ARRAY, [array])
+    return Command.new(@runtime_name, CommandType::ARRAY, [array])
   end
 
   def drop_first_payload_argument
@@ -71,17 +71,21 @@ class RubyCommand
     if payload_args.length != 0
       payload_args.delete_at(0)
     end
-    return RubyCommand.new(@runtime_lib, @command_type, payload_args)
+    return Command.new(@runtime_name, @command_type, payload_args)
   end
 
   def add_arg_to_payload(argument)
     merged_payload = payload + [argument]
-    return RubyCommand.new(@runtime_lib, @command_type, merged_payload)
+    return Command.new(@runtime_name, @command_type, merged_payload)
   end
 
-  def add_arg_to_payload_on_beginning(argument)
-    merged_payload = [argument] + payload
-    return RubyCommand.new(@runtime_lib, @command_type, merged_payload)
+  def add_arg_to_payload_on_beginning(current_command)
+    if current_command.nil?
+      return Command.new(@runtime_name, @command_type, @payload)
+    else
+      merged_payload = [current_command] + payload
+      return Command.new(@runtime_name, @command_type, merged_payload)
+    end
   end
 
 end

package/Binaries/Ruby/Windows/X64/{sdk/core/ruby_command_type.rb → utils/command_type.rb}

@@ -1,5 +1,5 @@
-class RubyCommandType
-  RESPONSE = 0
+class CommandType
+  VALUE = 0
   LOAD_LIBRARY = 1
   INVOKE_STATIC_METHOD = 2
   GET_STATIC_FIELD = 3
@@ -18,65 +18,59 @@ class RubyCommandType
   INVOKE_GLOBAL_METHOD = 16
   DESTRUCT_REFERENCE = 17
   ARRAY = 18
-
+  ARRAY_GET_ITEM = 19
+  ARRAY_GET_SIZE = 20
+  ARRAY_GET_RANK = 21
+  ARRAY_SET_ITEM = 22
 
   def self.get_name(command_number)
-    if command_number == 0
-      return 'RESPONSE'
-    end
-    if command_number == 1
+    case command_number
+    when 0
+      return 'VALUE'
+    when 1
       return 'LOAD_LIBRARY'
-    end
-    if command_number == 2
+    when 2
       return 'INVOKE_STATIC_METHOD'
-    end
-    if command_number == 3
+    when 3
       return 'GET_STATIC_FIELD'
-    end
-    if command_number == 4
+    when 4
       return 'SET_STATIC_FIELD'
-    end
-    if command_number == 5
+    when 5
       return 'CREATE_CLASS_INSTANCE'
-    end
-    if command_number == 6
+    when 6
       return 'GET_TYPE'
-    end
-    if command_number == 7
+    when 7
       return 'REFERENCE'
-    end
-    if command_number == 8
+    when 8
       return 'GET_MODULE'
-    end
-    if command_number == 9
+    when 9
       return 'INVOKE_INSTANCE_METHOD'
-    end
-    if command_number == 10
+    when 10
       return 'EXCEPTION'
-    end
-    if command_number == 11
+    when 11
       return 'HEART_BEAT'
-    end
-    if command_number == 12
+    when 12
       return 'CAST'
-    end
-    if command_number == 13
+    when 13
       return 'GET_INSTANCE_FIELD'
-    end
-    if command_number == 14
+    when 14
       return 'OPTIMIZE'
-    end
-    if command_number == 15
+    when 15
       return 'GENERATE_LIB'
-    end
-    if command_number == 16
+    when 16
       return 'INVOKE_GLOBAL_METHOD'
-    end
-    if command_number == 17
+    when 17
       return 'DESTRUCT_REFERENCE'
-    end
-    if command_number == 18
+    when 18
       return 'ARRAY'
+    when 19
+      return 'ARRAY_GET_ITEM'
+    when 20
+      return 'ARRAY_GET_SIZE'
+    when 21
+      return 'ARRAY_GET_RANK'
+    when 22
+      return 'ARRAY_SET_ITEM'
     end
   end
 end

package/Binaries/Ruby/Windows/X64/{sdk/core → utils}/explicit_cast.rb

@@ -1,13 +1,13 @@
 class ExplicitCast
   def cast(value, target_type)
-    RubyCommand.new(
+    Command.new(
       100,
-      RubyCommandType::CAST,
+      CommandType::CAST,
       [
         value,
-        RubyCommand.new(
+        Command.new(
           100,
-          RubyCommandType::GET_TYPE,
+          CommandType::GET_TYPE,
           target_type
         )
       ]

package/Binaries/Ruby/Windows/X64/{sdk/core/runtime_lib.rb → utils/runtime_name.rb}

@@ -1,4 +1,4 @@
-module RuntimeLib
+module RuntimeName
   CLR = 0
   GO = 1
   JVM = 2

package/addon/JavonetNodejsRuntimeAddon.cpp

@@ -1,7 +1,6 @@
 #include "JavonetNodejsRuntimeAddon.h"
 
 void InitializeTransmitter(const FunctionCallbackInfo<Value>& args) {
-
 	isolate = args.GetIsolate();
 	if (args.Length() != 1 || !args[0]->IsString()) {
 		isolate->ThrowException(Exception::TypeError(
@@ -89,19 +88,21 @@ void InitializeTransmitter(const FunctionCallbackInfo<Value>& args) {
 			String::NewFromUtf8(isolate, errorMessage,
 				NewStringType::kNormal).ToLocalChecked()));
 		return;
-}
+	}
 #endif	 //__APPLE__
 
 	SendCommandNative_Fn = (SendCommandNative)getProccessAddress(JavonetNodejsRuntimeNativeLibInstance, "SendCommand");
 	ReadResponseNative_Fn = (ReadResponseNative)getProccessAddress(JavonetNodejsRuntimeNativeLibInstance, "ReadResponse");
 	ActivateNative_Fn = (ActivateNative)getProccessAddress(JavonetNodejsRuntimeNativeLibInstance, "Activate");
+	GetNativeError_Fn = (GetNativeError)getProccessAddress(JavonetNodejsRuntimeNativeLibInstance, "GetNativeError");
 
 	if (SendCommandNative_Fn == nullptr ||
 		ReadResponseNative_Fn == nullptr ||
-		ActivateNative_Fn == nullptr)
+		ActivateNative_Fn == nullptr ||
+		GetNativeError_Fn == nullptr)
 	{
 		isolate->ThrowException(Exception::Error(
-			String::NewFromUtf8(isolate, "Proper functions not found in native library",
+			String::NewFromUtf8(isolate, "Exported functions not found in native library",
 				NewStringType::kNormal).ToLocalChecked()));
 	}
 	bool result = false;
@@ -114,46 +115,53 @@ void SendCommand(const FunctionCallbackInfo<Value>& args)
 	isolate = args.GetIsolate();
 	context = isolate->GetCurrentContext();
 	messageArray = args[0].As<Uint8Array>();
-	messageLen = messageArray->Length();
+	messageArrayLen = messageArray->Length();
+	messageByteArray = new byte[messageArrayLen];
 
-	if (messageLen > 0)
+	for (size_t i = 0; i < messageArrayLen; i++)
 	{
-		message = new byte[messageLen];
-
-		for (size_t i = 0; i < messageLen; i++)
-		{
-			message[i] = messageArray->Get(context, i).ToLocalChecked()->Uint32Value(context).FromMaybe(0);
-		}
-
-		responseLen = SendCommandNative_Fn((byte*)message, messageLen);
-
-		response = new byte[responseLen];
-		ReadResponseNative_Fn(response, responseLen);
-
-		responseArray = Array::New(isolate, responseLen);
-
-		for (size_t j = 0; j < responseLen; j++)
+		messageByteArray[i] = messageArray->Get(context, i).ToLocalChecked()->Uint32Value(context).FromMaybe(0);
+	}
+	responseArrayLen = SendCommandNative_Fn((byte*)messageByteArray, messageArrayLen);
+	
+	if (responseArrayLen > 0) {
+		responseByteArray = new byte[responseArrayLen];
+		ReadResponseNative_Fn(responseByteArray, responseArrayLen);
+		responseArray = Array::New(isolate, responseArrayLen);
+		for (size_t j = 0; j < responseArrayLen; j++)
 		{
-
-			responseArray->Set(context, j, Uint32::New(isolate, (int32_t)response[j]));
+			responseArray->Set(context, j, Uint32::New(isolate, (int32_t)responseByteArray[j]));
 		}
-		if (message)
+		if (messageByteArray)
 		{
-			delete[] message;
-			message = nullptr;
+			delete[] messageByteArray;
+			messageByteArray = nullptr;
 		}
-		if (response)
+		if (responseByteArray)
 		{
-			delete[] response;
-			response = nullptr;
+			delete[] responseByteArray;
+			responseByteArray = nullptr;
 		}
 		args.GetReturnValue().Set(responseArray);
+	}
+	else if (responseArrayLen == 0) {
+		isolate->ThrowException(Exception::Error(
+			String::NewFromUtf8(isolate, "Response is empty",
+				NewStringType::kNormal).ToLocalChecked()));
+		args.GetReturnValue().Set(Number::New(isolate, responseArrayLen));
 		return;
 	}
 	else {
-		args.GetReturnValue().Set(-1);
+		
+		const char* errorMessage = GetNativeError_Fn();
+		std::string errorMessage2 = std::string("Javonet native error code: ") + std::to_string(responseArrayLen) + ". " + std::string(errorMessage);
+		isolate->ThrowException(Exception::Error(
+			String::NewFromUtf8(isolate, errorMessage2.c_str(),
+				NewStringType::kNormal).ToLocalChecked()));
+		args.GetReturnValue().Set(Number::New(isolate, responseArrayLen));
 		return;
 	}
+	return;
 }
 
 void Activate(const FunctionCallbackInfo<Value>& args)
@@ -186,8 +194,16 @@ void Activate(const FunctionCallbackInfo<Value>& args)
 	std::string proxyUserName(*proxyusernamestr);
 	std::string proxyPassword(*proxypasswordstr);
 
-	auto response = ActivateNative_Fn(email.c_str(), licenceKey.c_str(), proxyHost.c_str(), proxyUserName.c_str(), proxyPassword.c_str());
-	args.GetReturnValue().Set(response);
+	auto activationResult = ActivateNative_Fn(email.c_str(), licenceKey.c_str(), proxyHost.c_str(), proxyUserName.c_str(), proxyPassword.c_str());
+	args.GetReturnValue().Set(activationResult);
+	if (activationResult < 0) {
+		const char* errorMessage = GetNativeError_Fn();
+		std::string errorMessage2 = std::string("Javonet activation result: ") + std::to_string(activationResult) + ". " + std::string(errorMessage);
+		isolate->ThrowException(Exception::Error(
+			String::NewFromUtf8(isolate, errorMessage2.c_str(),
+				NewStringType::kNormal).ToLocalChecked()));
+	} 
+	
 	return;
 }
 

package/addon/JavonetNodejsRuntimeAddon.h

@@ -45,16 +45,17 @@ Local<Context> context;
 Local<Uint8Array> messageArray;
 Local<Array> responseArray;
 
-byte* message{ nullptr };
-byte* response{ nullptr };
-size_t messageLen{ 0 };
-size_t responseLen{ 0 };
-uint32_t uint32value{ 0 };
+byte* messageByteArray{ nullptr };
+byte* responseByteArray{ nullptr };
+int messageArrayLen{ 0 };
+int responseArrayLen{ 0 };
 
 typedef int(*SendCommandNative)(byte*, int);
 typedef int(*ReadResponseNative)(byte*, int);
 typedef int(*ActivateNative)(const char*, const char*, const char*, const char*, const char*);
+typedef const char*(*GetNativeError)();
 
 SendCommandNative SendCommandNative_Fn{ nullptr };
 ReadResponseNative ReadResponseNative_Fn{ nullptr };
 ActivateNative ActivateNative_Fn{ nullptr };
+GetNativeError GetNativeError_Fn{ nullptr };

package/lib/Javonet.js

@@ -1,6 +1,6 @@
 const ConnectionType = require('./utils/ConnectionType')
 const RuntimeFactory = require('./sdk/internal/RuntimeFactory')
-const Transmitter = require('./core/transmitter/NodejsTransmitter')
+const Transmitter = require('./core/transmitter/Transmitter')
 
 //static constructor not supported in nodeJS 12.20
 Transmitter.activateWithLicenceFile()