javonet-ruby-sdk 2.5.1 → 2.5.3

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/RuntimeLogger.js

@@ -0,0 +1,27 @@
+const os = require('os');
+const process = require('process');
+
+class RuntimeLogger {
+    static notLoggedYet = true;
+
+    static getRuntimeInfo() {
+        try {
+            return `JavaScript Managed Runtime Info:\n` +
+                `Node.js Version: ${process.version}\n` +
+                `OS Version: ${os.type()} ${os.release()}\n` +
+                `Process Architecture: ${os.arch()}\n` +
+                `Current Directory: ${process.cwd()}\n`;
+        } catch (e) {
+            return "JavaScript Managed Runtime Info: Error while fetching runtime info";
+        }
+    }
+
+    static printRuntimeInfo() {
+        if (this.notLoggedYet) {
+            console.log(this.getRuntimeInfo());
+            this.notLoggedYet = false;
+        }
+    }
+}
+
+module.exports = RuntimeLogger;

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;
 

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

@@ -0,0 +1,43 @@
+package Scalar::List::Utils;
+use strict;
+use warnings;
+
+our $VERSION    = "1.68";
+$VERSION =~ tr/_//d;
+
+1;
+
+__END__
+
+=head1 NAME
+
+Scalar::List::Utils - A distribution of general-utility subroutines
+
+=head1 SYNOPSIS
+
+    use Scalar::Util qw(blessed);
+    use List::Util qw(any);
+
+=head1 DESCRIPTION
+
+C<Scalar::List::Utils> does nothing on its own. It is packaged with several
+useful modules.
+
+=head1 MODULES
+
+=head2 L<List::Util>
+
+L<List::Util> contains a selection of useful subroutines for operating on lists
+of values.
+
+=head2 L<Scalar::Util>
+
+L<Scalar::Util> contains a selection of useful subroutines for interrogating
+or manipulating scalar values.
+
+=head2 L<Sub::Util>
+
+L<Sub::Util> contains a selection of useful subroutines for interrogating
+or manipulating subroutine references.
+
+=cut

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

@@ -17,7 +17,7 @@ our @EXPORT_OK = qw(
   dualvar isdual isvstring looks_like_number openhandle readonly set_prototype
   tainted
 );
-our $VERSION    = "1.66";
+our $VERSION    = "1.68";
 $VERSION =~ tr/_//d;
 
 require List::Util; # List::Util loads the XS

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

@@ -15,7 +15,7 @@ our @EXPORT_OK = qw(
   subname set_subname
 );
 
-our $VERSION    = "1.66";
+our $VERSION    = "1.68";
 $VERSION =~ tr/_//d;
 
 require List::Util; # as it has the XS