javonet-nodejs-sdk 2.5.10 → 2.5.12

package/Binaries/Ruby/Windows/X64/core/handler/invoke_global_function_handler.rb

@@ -0,0 +1,45 @@
+require_relative 'abstract_command_handler'
+
+class InvokeGlobalFunctionHandler < AbstractCommandHandler
+  def process(command)
+    invoke_function(command)
+  end
+
+  def invoke_function(command)
+    begin
+      payload = command.payload
+      raise ArgumentError, "InvokeGlobalFunction requires at least one parameter" if payload.empty?
+
+      # Expect the first parameter to be a string in the form "ModuleName.function_name"
+      full_method_string = payload[0]
+      unless full_method_string.is_a?(String) && full_method_string.include?(".")
+        raise ArgumentError, "Expected a string in the format 'ModuleName.function_name'"
+      end
+
+      parts = full_method_string.split(".")
+      if parts.size < 2
+        raise ArgumentError, "Invalid function identifier format. Expected 'ModuleName.function_name'"
+      end
+
+      function_name = parts.pop
+      module_name = parts.join("::") # Convert dot-separated names to Ruby's "::" notation
+
+      begin
+        target = Object.const_get(module_name)
+      rescue NameError => e
+        raise NameError, "Module/Class #{module_name} not found: #{e.message}"
+      end
+
+      args = payload[1..-1] || []
+
+      if target.respond_to?(function_name)
+        target.send(function_name, *args)
+      else
+        available_methods = target.methods.join(', ')
+        raise NoMethodError, "Method #{function_name} not found in module #{module_name}. Available methods: #{available_methods}"
+      end
+    rescue Exception => e
+      e
+    end
+  end
+end

package/Binaries/Ruby/Windows/X64/core/handler/invoke_instance_method_handler.rb

@@ -6,7 +6,7 @@ class InvokeInstanceMethodHandler < AbstractCommandHandler
   end
 
   def process(command)
-    return invoke_instance_method(command)
+    invoke_instance_method(command)
   end
 
   def invoke_instance_method(command)
@@ -14,15 +14,19 @@ class InvokeInstanceMethodHandler < AbstractCommandHandler
       if command.payload.length < @required_parameters_count
         raise ArgumentError.new "InvokeInstanceMethod parameters mismatch"
       end
+
+      instance = command.payload[0]
+      method_name = command.payload[1]
+
       if command.payload.length > 2
         arguments = command.payload[2..]
-        return command.payload[0].send(command.payload[1], *arguments)
+        return instance.send(method_name, *arguments)
       else
-        return command.payload[0].send(command.payload[1])
+        return instance.send(method_name)
       end
     rescue NoMethodError
-      methods = command.payload[0].methods
-      message = "Method #{command.payload[1]} not found in object of class #{command.payload[0].class.name}. Available methods:\n"
+      methods = instance.methods
+      message = "Method #{method_name} not found in object of class #{instance.class.name}. Available methods:\n"
       methods.each { |method_iter| message += "#{method_iter}\n" }
       raise Exception, message
     rescue Exception => e

package/Binaries/Ruby/Windows/X64/core/handler/invoke_static_method_handler.rb

@@ -14,14 +14,15 @@ class InvokeStaticMethodHandler < AbstractCommandHandler
       if command.payload.length < @required_parameters_count
         raise ArgumentError.new "Static method parameters mismatch"
       end
-  
+
+      type = command.payload[0]
       method_name = command.payload[1]
       begin
         if command.payload.length > @required_parameters_count
           args = command.payload[2..]
-          result = command.payload[0].send(method_name, *args)
+          result = type.send(method_name, *args)
         else
-          result = command.payload[0].send(method_name)
+          result = type.send(method_name)
         end
         return result
       rescue NoMethodError

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

@@ -3,9 +3,9 @@ require_relative '../../utils/runtime_logger'
 require_relative '../protocol/command_serializer'
 
 class Receiver
-  
+
   def initialize
-    RuntimeLogger.print_runtime_info
+    puts RuntimeLogger.print_runtime_info
   end
 
   def send_command(message_array, message_array_len)
@@ -15,4 +15,8 @@ class Receiver
   def heart_beat(message_array, message_array_len)
     [49,48]
   end
+
+  def get_runtime_info
+    RuntimeLogger.get_runtime_info(true)
+  end
 end

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

@@ -45,4 +45,14 @@ class Transmitter
       return set_config_result
     end
   end
+
+  def self.set_javonet_working_directory(config_path)
+    set_working_directory_result = TransmitterWrapper.SetWorkingDirectory(config_path)
+    if set_working_directory_result < 0
+      error_message = get_native_error
+      raise Exception.new "Javonet set working directory result: " + set_working_directory_result.to_s + ". Native error message: " + error_message
+    else
+      return set_working_directory_result
+    end
+  end
 end

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

@@ -28,4 +28,5 @@ module TransmitterWrapper
   attach_function :Activate, [:pointer], :int
   attach_function :GetNativeError, [], :string
   attach_function :SetConfigSource, [:pointer], :int
+  attach_function :SetWorkingDirectory, [:pointer], :int
 end

package/Binaries/Ruby/Windows/X64/utils/command_type.rb

@@ -15,7 +15,7 @@ class CommandType
   GET_INSTANCE_FIELD = 13
   OPTIMIZE = 14
   GENERATE_LIB = 15
-  INVOKE_GLOBAL_METHOD = 16
+  INVOKE_GLOBAL_FUNCTION = 16
   DESTRUCT_REFERENCE = 17
   ARRAY_REFERENCE = 18
   ARRAY_GET_ITEM = 19
@@ -36,6 +36,11 @@ class CommandType
   ENABLE_NAMESPACE = 34
   ENABLE_TYPE = 35
   CREATE_NULL = 36
+  GET_STATIC_METHOD_AS_DELEGATE = 37
+  GET_INSTANCE_METHOD_AS_DELEGATE = 38
+  PASS_DELEGATE = 39
+  INVOKE_DELEGATE = 40
+  CONVERT_TYPE = 41
 
   def self.get_name(command_number)
     case command_number
@@ -62,7 +67,7 @@ class CommandType
     when 10
       return 'EXCEPTION'
     when 11
-      return 'HEART_BEAT'
+      return 'HEARTBEAT'
     when 12
       return 'CAST'
     when 13
@@ -72,7 +77,7 @@ class CommandType
     when 15
       return 'GENERATE_LIB'
     when 16
-      return 'INVOKE_GLOBAL_METHOD'
+      return 'INVOKE_GLOBAL_FUNCTION'
     when 17
       return 'DESTRUCT_REFERENCE'
     when 18
@@ -113,6 +118,16 @@ class CommandType
       return 'ENABLE_TYPE'
     when 36
       return 'CREATE_NULL'
+    when 37
+      return 'GET_STATIC_METHOD_AS_DELEGATE'
+    when 38
+      return 'GET_INSTANCE_METHOD_AS_DELEGATE'
+    when 39
+      return 'PASS_DELEGATE'
+    when 40
+      return 'INVOKE_DELEGATE'
+    when 41
+      return 'CONVERT_TYPE'
     else
       raise 'Unknown command type'
     end

package/Binaries/version.txt

@@ -1 +1 @@
-2.5.10
+2.5.12

package/addon/JavonetNodejsRuntimeAddon.cpp

@@ -1,10 +1,12 @@
 #include "JavonetNodejsRuntimeAddon.h"
 
 void InitializeTransmitter(const FunctionCallbackInfo<Value>& args) {
-	isolate = args.GetIsolate();
+    isolate = args.GetIsolate();
+    permanentContext.Reset(isolate, isolate->GetCurrentContext());
+
 	if (args.Length() != 1 || !args[0]->IsString()) {
 		isolate->ThrowException(Exception::TypeError(
-			String::NewFromUtf8(isolate, "Wrong number of arguments or wrong argument types.",
+			String::NewFromUtf8(isolate, "JavonetAddon InitializeTransmitter: Wrong number of arguments or wrong argument types.",
 				NewStringType::kNormal).ToLocalChecked()));
 		return;
 	}
@@ -24,8 +26,8 @@ arch = "X86";
     nativeLibFullPath = nodeJsAddonPath + "\\Binaries\\Native\\Windows\\" + arch + "\\JavonetNodejsRuntimeNative.dll";
 	JavonetNodejsRuntimeNativeLibInstance = LoadLibraryA(nativeLibFullPath.c_str());
 	if (!JavonetNodejsRuntimeNativeLibInstance) {
-		char errorMessage[300];
-		sprintf_s(errorMessage, "%s %s", "Native library not found in: ", nativeLibFullPath.c_str());
+		char errorMessage[1024];
+		sprintf_s(errorMessage, "%s %s", "JavonetAddon InitializeTransmitter: Native library not found in: ", nativeLibFullPath.c_str());
 		isolate->ThrowException(Exception::Error(
 			String::NewFromUtf8(isolate, errorMessage,
 				NewStringType::kNormal).ToLocalChecked()));
@@ -57,7 +59,7 @@ arch = "X86";
 	if (JavonetNodejsRuntimeNativeLibInstance == NULL || error != NULL) {
 		char errorMessage[300];
 
-		sprintf(errorMessage, "%s %s \n%s %s", "Native library not found in: ", nativeLibFullPath.c_str(), "Error: ", error);
+		sprintf(errorMessage, "%s %s \n%s %s", "JavonetAddon InitializeTransmitter: Native library not found in: ", nativeLibFullPath.c_str(), "Error: ", error);
 		isolate->ThrowException(Exception::Error(
 			String::NewFromUtf8(isolate, errorMessage,
 				NewStringType::kNormal).ToLocalChecked()));
@@ -70,18 +72,24 @@ arch = "X86";
 	ActivateNative_Fn = (ActivateNative)getProccessAddress(JavonetNodejsRuntimeNativeLibInstance, "Activate");
 	GetNativeErrorNative_Fn = (GetNativeErrorNative)getProccessAddress(JavonetNodejsRuntimeNativeLibInstance, "GetNativeError");
 	SetConfigSourceNative_Fn = (SetConfigSourceNative)getProccessAddress(JavonetNodejsRuntimeNativeLibInstance, "SetConfigSource");
+	SetWorkingDirectoryNative_Fn = (SetWorkingDirectoryNative)getProccessAddress(JavonetNodejsRuntimeNativeLibInstance, "SetWorkingDirectory");
+	SetCallbackNative_Fn = (SetCallbackNative)getProccessAddress(JavonetNodejsRuntimeNativeLibInstance, "SetCallback");
+
 
 	if (SendCommandNative_Fn == nullptr ||
 		ReadResponseNative_Fn == nullptr ||
 		ActivateNative_Fn == nullptr ||
 		GetNativeErrorNative_Fn == nullptr||
-		SetConfigSourceNative_Fn == nullptr
+		SetConfigSourceNative_Fn == nullptr ||
+		SetWorkingDirectoryNative_Fn == nullptr ||
+		SetCallbackNative_Fn == nullptr
 		)
 	{
 		isolate->ThrowException(Exception::Error(
-			String::NewFromUtf8(isolate, "Exported functions not found in native library",
+			String::NewFromUtf8(isolate, "JavonetAddon InitializeTransmitter: Exported functions not found in native library",
 				NewStringType::kNormal).ToLocalChecked()));
 	}
+
 	bool result = false;
 	args.GetReturnValue().Set(result);
 	return;
@@ -89,8 +97,7 @@ arch = "X86";
 
 void SendCommand(const FunctionCallbackInfo<Value>& args)
 {
-	isolate = args.GetIsolate();
-	context = isolate->GetCurrentContext();
+    v8::Local<v8::Context> context = v8::Local<v8::Context>::New(isolate, permanentContext);
 	messageArray = args[0].As<Uint8Array>();
 	messageArrayLen = messageArray->Length();
 	messageByteArray = new byte[messageArrayLen];
@@ -122,9 +129,9 @@ void SendCommand(const FunctionCallbackInfo<Value>& args)
 		args.GetReturnValue().Set(responseArray);
 	}
 	else if (responseArrayLen == 0) {
-		isolate->ThrowException(Exception::Error(
-			String::NewFromUtf8(isolate, "Response is empty",
-				NewStringType::kNormal).ToLocalChecked()));
+        isolate->ThrowException(Exception::Error(
+            String::NewFromUtf8(isolate, "JavonetAddon SendCommand: Response is empty",
+                NewStringType::kNormal).ToLocalChecked()));
 		args.GetReturnValue().Set(Number::New(isolate, responseArrayLen));
 		return;
 	}
@@ -142,13 +149,12 @@ void SendCommand(const FunctionCallbackInfo<Value>& args)
 
 void Activate(const FunctionCallbackInfo<Value>& args)
 {
-	isolate = args.GetIsolate();
 	if (
 		args.Length() != 1 ||
 		!args[0]->IsString()
 		) {
 		isolate->ThrowException(Exception::TypeError(
-			String::NewFromUtf8(isolate, "Wrong number of arguments or wrong argument types.",
+			String::NewFromUtf8(isolate, "JavonetAddon Activate:  Wrong number of arguments or wrong argument types.",
 				NewStringType::kNormal).ToLocalChecked()));
 		return;
 	}
@@ -170,10 +176,9 @@ void Activate(const FunctionCallbackInfo<Value>& args)
 
 void SetConfigSource(const FunctionCallbackInfo<Value>& args)
 {
-	isolate = args.GetIsolate();
 	if (args.Length() != 1 || !args[0]->IsString()) {
 		isolate->ThrowException(Exception::TypeError(
-			String::NewFromUtf8(isolate, "Wrong number of arguments or wrong argument types.",
+			String::NewFromUtf8(isolate, "JavonetAddon SetConfigSource: Wrong number of arguments or wrong argument types.",
 				NewStringType::kNormal).ToLocalChecked()));
 		return;
 	}
@@ -191,11 +196,104 @@ void SetConfigSource(const FunctionCallbackInfo<Value>& args)
 	return;
 }
 
+void SetJavonetWorkingDirectory(const FunctionCallbackInfo<Value>& args)
+{
+    if (args.Length() != 1 || !args[0]->IsString()) {
+        isolate->ThrowException(Exception::TypeError(
+            String::NewFromUtf8(isolate, "JavonetAddon SetJavonetWorkingDirectory: Wrong number of arguments or wrong argument types.",
+                NewStringType::kNormal).ToLocalChecked()));
+        return;
+    }
+    v8::String::Utf8Value str(isolate, args[0]);
+    std::string workingDirectory(*str);
+    int result = SetWorkingDirectoryNative_Fn(workingDirectory.c_str());
+    args.GetReturnValue().Set(result);
+    if (result < 0) {
+        const char* errorMessage = GetNativeErrorNative_Fn();
+        std::string errorMessage2 = std::string("Javonet set working directory result: ") + std::to_string(result) + ". Native error message: " + std::string(errorMessage);
+        isolate->ThrowException(Exception::Error(
+            String::NewFromUtf8(isolate, errorMessage2.c_str(),
+                NewStringType::kNormal).ToLocalChecked()));
+    }
+    return;
+}
+
+std::vector<byte> nodejsRuntimeCallback(byte* messageByteArray, int32_t messageByteArrayLen) {
+    std::vector<byte> responseVector;
+    v8::Local<v8::Context> context = v8::Local<v8::Context>::New(isolate, permanentContext);
+
+    // Get the `sendCommand` method
+    v8::Local<v8::Object> receiverNativeLocal = v8::Local<v8::Object>::New(isolate, receiverNative);
+
+    v8::Local<v8::Value> sendCommandVal = receiverNativeLocal->Get(
+        isolate->GetCurrentContext(),
+        v8::String::NewFromUtf8(isolate, "sendCommand", v8::NewStringType::kNormal).ToLocalChecked()
+    ).ToLocalChecked();
+
+    if (!sendCommandVal->IsFunction()) {
+        isolate->ThrowException(Exception::TypeError(
+            String::NewFromUtf8(isolate, "JavonetAddon nodejsRuntimeCallback:  Cannot find sendCommand in NativeReceiver",
+                NewStringType::kNormal).ToLocalChecked()));
+        return responseVector;
+    }
+
+    v8::Local<v8::Function> sendCommandFunc = sendCommandVal.As<v8::Function>();
+
+    // Convert messageByteArray to Uint8Array
+    v8::Local<v8::ArrayBuffer> arrayBuffer = v8::ArrayBuffer::New(isolate, messageByteArrayLen);
+    memcpy(arrayBuffer->GetBackingStore()->Data(), messageByteArray, messageByteArrayLen);
+    v8::Local<v8::Uint8Array> uint8Array = v8::Uint8Array::New(arrayBuffer, 0, messageByteArrayLen);
+
+    // Call `sendCommand` with uint8Array
+    v8::Local<v8::Value> args[1] = { uint8Array };
+    v8::Local<v8::Value> result;
+
+    if (!sendCommandFunc->Call(context, receiverNativeLocal, 1, args).ToLocal(&result)) {
+        isolate->ThrowException(Exception::TypeError(
+            String::NewFromUtf8(isolate, "JavonetAddon nodejsRuntimeCallback:  Error during calling callback",
+                NewStringType::kNormal).ToLocalChecked()));
+        return responseVector;
+    }
+
+    // Convert the result (assumed to be Int8Array) back to std::vector<byte>
+    if (result->IsInt8Array()) {
+        v8::Local<v8::Int8Array> resultArray = result.As<v8::Int8Array>();
+        size_t length = resultArray->Length();
+        responseVector.resize(length);
+        resultArray->CopyContents(responseVector.data(), length);
+    } else {
+        isolate->ThrowException(Exception::TypeError(
+            String::NewFromUtf8(isolate, "JavonetAddon nodejsRuntimeCallback:  Wrong return type",
+                NewStringType::kNormal).ToLocalChecked()));
+    }
+
+    return responseVector;
+}
+
+void SetReceiverNative(const v8::FunctionCallbackInfo<v8::Value>& args) {
+    v8::Local<v8::Context> context = v8::Local<v8::Context>::New(isolate, permanentContext);
+
+    if (args.Length() != 1 || !args[0]->IsObject()) {
+        isolate->ThrowException(v8::Exception::TypeError(
+            v8::String::NewFromUtf8(isolate, "JavonetAddon SetReceiverNative: Wrong number of arguments or wrong argument types", v8::NewStringType::kNormal).ToLocalChecked()
+        ));
+        return;
+    }
+
+    // store the receiver object
+    receiverNative.Reset(isolate, args[0].As<v8::Object>());
+
+    // set the callback in native
+    SetCallbackNative_Fn(nodejsRuntimeCallback);
+}
+
 void Initialize(Local<Object> exports) {
 	NODE_SET_METHOD(exports, "initializeTransmitter", InitializeTransmitter);
 	NODE_SET_METHOD(exports, "sendCommand", SendCommand);
 	NODE_SET_METHOD(exports, "activate", Activate);
 	NODE_SET_METHOD(exports, "setConfigSource", SetConfigSource);
+	NODE_SET_METHOD(exports, "setReceiverNative", SetReceiverNative);
+	NODE_SET_METHOD(exports, "setJavonetWorkingDirectory", SetJavonetWorkingDirectory);
 }
 
 NODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)

package/addon/JavonetNodejsRuntimeAddon.h

@@ -1,6 +1,7 @@
 #include "node.h"
 #include "v8.h"
 #include <iostream>
+#include <vector>
 
 
 using v8::FunctionCallbackInfo;
@@ -16,6 +17,7 @@ using v8::Exception;
 using v8::Number;
 using v8::Uint32;
 using v8::Uint8Array;
+using v8::Persistent;
 
 #ifdef _WIN32
 #include "windows.h"
@@ -37,7 +39,8 @@ void* JavonetNodejsRuntimeNativeLibInstance{ nullptr };
 std::string nativeLibFullPath{ "" };
 
 Isolate* isolate = nullptr;
-Local<Context> context;
+Persistent<v8::Context> permanentContext; // permanent context
+v8::Persistent<v8::Object> receiverNative; // permanent receiver object
 
 Local<Uint8Array> messageArray;
 Local<Array> responseArray;
@@ -46,15 +49,22 @@ byte* messageByteArray{ nullptr };
 byte* responseByteArray{ nullptr };
 int messageArrayLen{ 0 };
 int responseArrayLen{ 0 };
+typedef std::vector<byte>(*nodejsCallback)(byte* messageByteArray, int32_t messageByteArrayLen); // type of the callback function
 
 typedef int(*SendCommandNative)(byte*, int);
 typedef int(*ReadResponseNative)(byte*, int);
 typedef int(*ActivateNative)(const char*);
 typedef const char*(*GetNativeErrorNative)();
 typedef int(*SetConfigSourceNative)(const char*);
+typedef int(*SetWorkingDirectoryNative)(const char*);
+typedef bool(*SetCallbackNative)(nodejsCallback); // type of the function to pass callback to the native library
 
 SendCommandNative SendCommandNative_Fn{ nullptr };
 ReadResponseNative ReadResponseNative_Fn{ nullptr };
 ActivateNative ActivateNative_Fn{ nullptr };
 GetNativeErrorNative GetNativeErrorNative_Fn{ nullptr };
-SetConfigSourceNative SetConfigSourceNative_Fn{ nullptr };
+SetConfigSourceNative SetConfigSourceNative_Fn{ nullptr };
+SetWorkingDirectoryNative SetWorkingDirectoryNative_Fn{ nullptr };
+SetCallbackNative SetCallbackNative_Fn{ nullptr }; // function to pass callback to the native library
+
+std::vector<byte> nodejsRuntimeCallback(byte* messageByteArray, int32_t messageByteArrayLen); // callback function to be passed to the native library