javonet-ruby-sdk 2.5.0 → 2.5.2

data/lib/javonet-ruby-sdk/Binaries/Native/Windows/ARM64/dynamicCompilationHeaders/Windows/jni_md.h

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 1996, 1998, Oracle and/or its affiliates. All rights reserved.
+ * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+
+#ifndef _JAVASOFT_JNI_MD_H_
+#define _JAVASOFT_JNI_MD_H_
+
+#define JNIEXPORT __declspec(dllexport)
+#define JNIIMPORT __declspec(dllimport)
+#define JNICALL __stdcall
+
+typedef long jint;
+typedef __int64 jlong;
+typedef signed char jbyte;
+
+#endif /* !_JAVASOFT_JNI_MD_H_ */

data/lib/javonet-ruby-sdk/Binaries/Native/Windows/X64/version.txt

@@ -1 +1 @@
-'2.5.0' 
+'2.5.2' 

data/lib/javonet-ruby-sdk/Binaries/Native/Windows/X86/version.txt

@@ -1 +1 @@
-'2.5.0' 
+'2.5.2' 

data/lib/javonet-ruby-sdk/Binaries/Nodejs/core/interpreter/Interpreter.js

@@ -10,36 +10,55 @@ let Receiver
 class Interpreter {
     handler = new Handler()
 
-    execute(command, connectionType, tcpAddress) {
-        let commandSerializer = new CommandSerializer()
-        let byteMessage = commandSerializer.serialize(command,connectionType, tcpAddress)
-        let responseByteArray
-
-        if (command.runtimeName === Runtime.Nodejs && connectionType === ConnectionType.IN_MEMORY)
-        {
-            // lazy receiver loading
-            if (!Receiver) {
-                Receiver = require('../receiver/Receiver')
-            }
-            responseByteArray = Receiver.sendCommand(byteMessage)
+    async executeAsync(command, connectionData) {
+        try {
+            const messageByteArray = new CommandSerializer().serialize(command, connectionData)
+
+            if (connectionData.connectionType === ConnectionType.WEB_SOCKET) {
+                const { WebSocketClient } = require("../webSocketClient/WebSocketClient");
+                const wsClient = new WebSocketClient(connectionData.hostname, null)
 
+                const responseByteArray = await wsClient.send(messageByteArray)
+                return new CommandDeserializer(responseByteArray).deserialize()
+            }
+            else {
+                return this.execute(command, connectionData)
+            }
+        } catch (error) {
+            // TODO: handle error exception log?
         }
-        else {
-            // lazy transmitter loading
-            if (!Transmitter) {
-                Transmitter = require('../transmitter/Transmitter')
+    }
+    
+    execute(command, connectionData) {
+        try {
+            let messageByteArray = new CommandSerializer().serialize(command, connectionData)
+            let responseByteArray
+            
+            if (command.runtimeName === Runtime.Nodejs && connectionData.connectionType === ConnectionType.IN_MEMORY)
+            {
+                // lazy receiver loading
+                if (!Receiver) {
+                    Receiver = require('../receiver/Receiver')
+                }
+                responseByteArray = Receiver.sendCommand(messageByteArray)
+
+            }
+            else {
+                // lazy transmitter loading
+                if (!Transmitter) {
+                    Transmitter = require('../transmitter/Transmitter')
+                }
+                responseByteArray = Transmitter.sendCommand(messageByteArray)
             }
-            responseByteArray = Transmitter.sendCommand(byteMessage)
+            return new CommandDeserializer(responseByteArray).deserialize()
+        } catch (error) {
+            // TODO: handle error exception log?
         }
-        return new CommandDeserializer(responseByteArray).deserialize()
     }
 
-    process(byteArray) {
-        let commandDeserializer = new CommandDeserializer(byteArray)
-        let receivedCommand = commandDeserializer.deserialize()
-        let responseCommand = this.handler.handleCommand(receivedCommand)
-        let commandSerializer = new CommandSerializer()
-        return commandSerializer.serialize(responseCommand, ConnectionType.IN_MEMORY)
+    process(messageByteArray) {
+        let receivedCommand = new CommandDeserializer(messageByteArray).deserialize()
+        return this.handler.handleCommand(receivedCommand)
     }
 }
 

data/lib/javonet-ruby-sdk/Binaries/Nodejs/core/protocol/CommandSerializer.js

@@ -1,45 +1,21 @@
 const Command = require("../../utils/Command")
 const TypeEncoder = require('./TypeSerializer')
-const ConnectionType = require("../../utils/ConnectionType");
 const Runtime = require('../../utils/RuntimeName')
 
 class CommandSerializer {
     buffer = new Int8Array(2)
 
-    serialize(command, connectionType, tcpConnectionData = null, runtimeVersion = 0) {
+
+    serialize(command, connectionData, runtimeVersion = 0) {
         let deque = [command]
         this.buffer[0] = command.runtimeName
         this.buffer[1] = runtimeVersion
-        this.#insertIntoBuffer(this.#serialize_tcp(connectionType, tcpConnectionData))
+        this.#insertIntoBuffer(connectionData.serializeConnectionData())
         this.#insertIntoBuffer(new Int8Array([Runtime.Nodejs, command.commandType]))
-        return this.#encodeRecursively(deque)
-    }
-
-    #serialize_tcp = function(connectionType, tcpConnectionData) {
-        let encodedTcp = new Int8Array(7)
-        encodedTcp[0] = connectionType
-        if (connectionType === ConnectionType.IN_MEMORY || tcpConnectionData === null) {
-            encodedTcp[1] = 0
-            encodedTcp[2] = 0
-            encodedTcp[3] = 0
-            encodedTcp[4] = 0
-            encodedTcp[5] = 0
-            encodedTcp[6] = 0
-        }
-        else if (ConnectionType.TCP === connectionType) {
-            let address = tcpConnectionData.getAddressBytes()
-            let port = tcpConnectionData.getPortBytes()
-            encodedTcp[1] = address[0]
-            encodedTcp[2] = address[1]
-            encodedTcp[3] = address[2]
-            encodedTcp[4] = address[3]
-            encodedTcp[5] = port[0]
-            encodedTcp[6] = port[1]
-        }
-        return encodedTcp
+        return this.#serializeRecursively(deque)
     }
 
-    #encodeRecursively = function(deque) {
+    #serializeRecursively = function(deque) {
         if (deque.length === 0) return this.buffer;
         let cmd = deque.pop()
         deque.push(cmd.dropFirstPayloadArg())
@@ -52,11 +28,11 @@ class CommandSerializer {
                 let result = TypeEncoder.encodePrimitive(cmd.payload[0])
                 this.#insertIntoBuffer(result)
             }
-            return this.#encodeRecursively(deque)
+            return this.#serializeRecursively(deque)
         } else {
             deque.pop()
         }
-        return this.#encodeRecursively(deque)
+        return this.#serializeRecursively(deque)
     }
 
     #insertIntoBuffer = function(arg) {

data/lib/javonet-ruby-sdk/Binaries/Nodejs/core/receiver/Receiver.js

@@ -1,9 +1,14 @@
 const Interpreter = require('../interpreter/Interpreter')
+const CommandSerializer = require("../protocol/CommandSerializer");
+const InMemoryConnectionData = require("../../utils/connectionData/InMemoryConnectionData");
 const interpreter = new Interpreter()
 
 class Receiver {
+
+    static connectionData = new InMemoryConnectionData();
+
     static sendCommand(messageByteArray) {
-        return interpreter.process(messageByteArray)
+        return new CommandSerializer().serialize(interpreter.process(messageByteArray), this.connectionData)
     }
     static heartBeat(messageByteArray) {
         let response = new Int8Array(2)

data/lib/javonet-ruby-sdk/Binaries/Nodejs/core/transmitter/Transmitter.js

@@ -6,20 +6,8 @@ class Transmitter {
         return wrapper.sendCommand(messageArray)
     }
 
-    static #activate = function(licenseKey = "", proxyHost = "", proxyUserName="", proxyUserPassword="") {
-        return wrapper.activate(licenseKey, proxyHost, proxyUserName, proxyUserPassword)
-    }
-
-    static activateWithLicenseFile() {
-        return this.#activate()
-    }
-
-    static activateWithCredentials(licenseKey) {
-        return this.#activate(licenseKey)
-    }
-
-    static activateWithCredentialsAndProxy(licenseKey, proxyHost, proxyUserName, proxyUserPassword) {
-        return this.#activate(licenseKey, proxyHost, proxyUserName, proxyUserPassword)
+    static activate = function(licenseKey = "") {
+        return wrapper.activate(licenseKey, "", "", "")
     }
 
     static setConfigSource(configSource) {

data/lib/javonet-ruby-sdk/Binaries/Nodejs/core/webSocketClient/WebSocketClient.js

@@ -0,0 +1,133 @@
+const WebSocket = require('ws');
+
+/**
+ * Enum for WebSocket states.
+ * @readonly
+ * @enum {string}
+ */
+const WebSocketStateEnum = {
+  OPEN: 'open',
+  CLOSE: 'close',
+  ERROR: 'error',
+};
+
+/**
+ * WebSocketClient class that handles WebSocket connection, message sending, and automatic disconnection.
+ */
+class WebSocketClient {
+  /**
+   * @param {string} url
+   * @param {object} options
+   */
+  constructor(url, options) {
+    /**
+     * @type {string}
+     */
+    this.url = url;
+
+    /**
+     * @type {WebSocket | null}
+     */
+    this.instance = null;
+
+    /**
+     * @type {boolean} isConnected indicates whether the WebSocket is connected.
+     */
+    this.isConnected = false;
+
+    /**
+     * @type {boolean}
+     */
+    this.isDisconnectedAfterMessage = options?.isDisconnectedAfterMessage ?? false;
+  }
+
+  /**
+   * Sends data through websocket connection
+   * @async
+   * @param {Buffer|ArrayBuffer|Buffer[]} data
+   * @returns {Promise<Buffer|ArrayBuffer|Buffer[]>}
+   */
+  send(data) {
+    return new Promise((resolve, reject) => {
+      try {
+        if (this.isConnected) {
+          this._sendMessage(data, resolve, reject);
+        } else {
+          this._connect().then(() => {
+            this._sendMessage(data, resolve, reject);
+          });
+        }
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  
+  /**
+   * Disconnects the WebSocket by terminating the connection.
+   */
+  disconnect() {
+    if (this.instance) {
+      this.instance.terminate();
+    }
+    this.isConnected = false;
+  }
+
+  /**
+   * Connects to the WebSocket server.
+   * @private
+   * @async
+   * @returns {Promise<void>} - A promise that resolves when the connection is established.
+   */
+  _connect() {
+    return new Promise((resolve, reject) => {
+      this.instance = new WebSocket(this.url);
+
+      this.instance.on(WebSocketStateEnum.OPEN, () => {
+        console.log('[WebSocketClient] connected');
+        this.isConnected = true;
+        resolve();
+      });
+
+      this.instance.on(WebSocketStateEnum.ERROR, (error) => {
+        console.log('[WebSocketClient] error', error);
+        reject(error);
+      });
+
+      this.instance.on(WebSocketStateEnum.CLOSE, () => {
+        console.log('[WebSocketClient] closed');
+        this.isConnected = false;
+      });
+    });
+  }
+
+  /**
+   * Sends the data to the WebSocket server and listens for a response.
+   * @private
+   * @async
+   * @param {string|Buffer|ArrayBuffer|Buffer[]} data - The data to send.
+   * @param {Function} resolve - The resolve function for the Promise.
+   * @param {Function} reject - The reject function for the Promise.
+   */
+  _sendMessage(data, resolve, reject) {
+    this.instance.send(data, (err) => {
+      if (err) {
+        reject(err);
+      }
+    });
+
+    this.instance.on('message', (message) => {
+      resolve(message);
+
+      if (this.isDisconnectedAfterMessage) {
+        this.disconnect();
+      }
+    });
+
+    this.instance.on('error', (error) => {
+      reject(error);
+    });
+  }
+}
+
+module.exports = { WebSocketClient }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/utils/ConnectionType.js

@@ -1,4 +1,5 @@
 module.exports = {
     IN_MEMORY: 0,
-    TCP: 1
+    TCP: 1,
+    WEB_SOCKET: 2
 }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/utils/connectionData/IConnectionData.js

@@ -0,0 +1,17 @@
+const ConnectionType = require('../../utils/ConnectionType');
+
+class IConnectionData {
+    get connectionType() {
+        throw new Error('You have to implement the method connectionType!');
+    }
+
+    get hostname() {
+        throw new Error('You have to implement the method hostname!');
+    }
+
+    serializeConnectionData() {
+        throw new Error('You have to implement the method serializeConnectionData!');
+    }
+}
+
+module.exports = IConnectionData;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/utils/connectionData/InMemoryConnectionData.js

@@ -0,0 +1,28 @@
+const ConnectionType = require('../../utils/ConnectionType');
+const IConnectionData = require('./IConnectionData');
+
+class InMemoryConnectionData extends IConnectionData {
+    constructor() {
+        super();
+        this._connectionType = ConnectionType.IN_MEMORY;
+        this._hostname = ""
+    }
+
+    get connectionType() {
+        return this._connectionType;
+    }
+
+    get hostname() {
+        return this._hostname;
+    }
+
+    serializeConnectionData() {
+        return [this.connectionType, 0, 0, 0, 0, 0, 0];
+    }
+
+    equals(other) {
+        return other instanceof InMemoryConnectionData;
+    }
+}
+
+module.exports = InMemoryConnectionData;

data/lib/javonet-ruby-sdk/Binaries/Nodejs/utils/{TcpConnectionData.js → connectionData/TcpConnectionData.js}

@@ -1,9 +1,14 @@
 const dns = require('dns');
+const ConnectionType = require('../../utils/ConnectionType');
+const IConnectionData = require("./IConnectionData");
 
-class TcpConnectionData {
+class TcpConnectionData extends IConnectionData{
 
     constructor(hostname, port) {
-        this.port = port;
+        super();
+        this._port = port;
+        this._hostname = hostname;
+        this._connectionType = ConnectionType.TCP;
         if (hostname === "localhost") {
             this.ipAddress = "127.0.0.1";
         } else {
@@ -11,9 +16,17 @@ class TcpConnectionData {
         }
     }
 
+    get connectionType() {
+        return this._connectionType;
+    }
+
+    get hostname() {
+        return this._hostname;
+    }
+
     equals(other) {
         if (other instanceof TcpConnectionData) {
-            return this.ipAddress === other.ipAddress && this.port === other.port;
+            return this.ipAddress === other.ipAddress && this._port === other._port;
         }
         return false;
     }
@@ -36,12 +49,19 @@ class TcpConnectionData {
         }
     }
 
-    getAddressBytes() {
+    serializeConnectionData() {
+        let result = [this.connectionType];
+        result = result.concat(this.#getAddressBytes());
+        result = result.concat(this.#getPortBytes());
+        return result;
+    }
+
+    #getAddressBytes() {
         return this.ipAddress.split('.').map(Number);
     }
 
-    getPortBytes() {
-        return [this.port & 0xFF, this.port >> 8];
+    #getPortBytes() {
+        return [this._port & 0xFF, this._port >> 8];
     }
     
 }

data/lib/javonet-ruby-sdk/Binaries/Nodejs/utils/connectionData/WsConnectionData.js

@@ -0,0 +1,33 @@
+const ConnectionType = require('../../utils/ConnectionType');
+const IConnectionData = require('./IConnectionData');
+
+class WsConnectionData extends IConnectionData {
+    constructor(hostname) {
+        super();
+        this._hostname = hostname;
+        this._connectionType = ConnectionType.WEB_SOCKET;
+    }
+
+    get connectionType() {
+        return this._connectionType;
+    }
+
+    get hostname() {
+        return this._hostname;
+    }
+
+    set hostname(value) {
+        this._hostname = value;
+    }
+
+    serializeConnectionData() {
+        return [this.connectionType, 0, 0, 0, 0, 0, 0];
+    }
+
+    equals(other) {
+        return other instanceof WsConnectionData && this._hostname === other.hostname;
+    }
+
+}
+
+module.exports = WsConnectionData;

data/lib/javonet-ruby-sdk/Binaries/Perl/Linux/X64/deps/lib/perl5/x86_64-linux-gnu-thread-multi/List/Util/XS.pm

@@ -3,7 +3,7 @@ use strict;
 use warnings;
 use List::Util;
 
-our $VERSION = "1.66";       # FIXUP
+our $VERSION = "1.68";       # FIXUP
 $VERSION =~ tr/_//d;         # FIXUP
 
 1;

data/lib/javonet-ruby-sdk/Binaries/Perl/Linux/X64/deps/lib/perl5/x86_64-linux-gnu-thread-multi/List/Util.pm

@@ -16,7 +16,7 @@ our @EXPORT_OK  = qw(
   sample shuffle uniq uniqint uniqnum uniqstr zip zip_longest zip_shortest mesh mesh_longest mesh_shortest
   head tail pairs unpairs pairkeys pairvalues pairmap pairgrep pairfirst
 );
-our $VERSION    = "1.66";
+our $VERSION    = "1.68";
 our $XS_VERSION = $VERSION;
 $VERSION =~ tr/_//d;