@ethernity-cloud/sdk-js 1.1.0

package/nodenithy/build/validator/src/swift_stream_service.js

@@ -0,0 +1,147 @@
+const Minio = require('minio');
+const fs = require("fs");
+class SwiftStreamService {
+    constructor(endpoint, port, accessKey, secretKey) {
+        this.client = new Minio.Client({
+            endPoint: endpoint,
+            port: port,
+            accessKey: accessKey,
+            secretKey: secretKey,
+            useSSL: false,
+        });
+    }
+
+    createBucket(bucketName) {
+        return new Promise((resolve, reject) => {
+            this.client.bucketExists(bucketName, (err, exists) => {
+                if (err) {
+                    return reject(err);
+                }
+
+                if (!exists) {
+                    this.client.makeBucket(bucketName, (err) => {
+                        if (err) {
+                            reject(err);
+                        } else {
+                            resolve(`Bucket ${bucketName} successfully created!`);
+                        }
+                    });
+                } else {
+                    resolve(`Bucket ${bucketName} already exists!`);
+                }
+            });
+        });
+    }
+
+    getFileContentBytes(bucketName, fileName) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            this.client.getObject(bucketName, fileName, (err, dataStream) => {
+                if (err) {
+                    return reject(err);
+                }
+
+                dataStream.on('data', (chunk) => {
+                    chunks.push(chunk);
+                });
+
+                dataStream.on('end', () => {
+                    const fileData = Buffer.concat(chunks);
+                    resolve(fileData);
+                });
+
+                dataStream.on('error', (err) => {
+                    reject(err);
+                });
+            });
+        });
+    }
+
+    getFileContent(bucketName, fileName) {
+        return this.getFileContentBytes(bucketName, fileName)
+            .then((fileData) => {
+                return fileData.toString('utf-8');
+            })
+            .catch((err) => {
+                throw err;
+            });
+    }
+
+    putFileContent(bucketName, objectName, objectPath, objectData = null) {
+        return new Promise((resolve, reject) => {
+            this.client.bucketExists(bucketName, (err, exists) => {
+                if (err) {
+                    return reject(err);
+                }
+
+                if (!exists) {
+                    this.createBucket(bucketName)
+                        .then(() => {
+                            if (objectData) {
+                                this.client.putObject(bucketName, objectName, objectData, (err) => {
+                                    if (err) {
+                                        reject(err);
+                                    } else {
+                                        resolve(`${objectName} is successfully uploaded to bucket ${bucketName}.`);
+                                    }
+                                });
+                            } else {
+                                const fileStat = fs.statSync(objectPath);
+                                const fileStream = fs.createReadStream(objectPath);
+
+                                this.client.putObject(bucketName, objectName, fileStream, fileStat.size, (err) => {
+                                    if (err) {
+                                        reject(err);
+                                    } else {
+                                        resolve(`${objectName} is successfully uploaded to bucket ${bucketName}.`);
+                                    }
+                                });
+                            }
+                        })
+                        .catch((err) => {
+                            reject(err);
+                        });
+                } else {
+                    if (objectData) {
+                        this.client.putObject(bucketName, objectName, objectData, (err) => {
+                            if (err) {
+                                reject(err);
+                            } else {
+                                resolve(`${objectName} is successfully uploaded to bucket ${bucketName}.`);
+                            }
+                        });
+                    } else {
+                        const fileStat = fs.statSync(objectPath);
+                        const fileStream = fs.createReadStream(objectPath);
+
+                        this.client.putObject(bucketName, objectName, fileStream, fileStat.size, (err) => {
+                            if (err) {
+                                reject(err);
+                            } else {
+                                resolve(`${objectName} is successfully uploaded to bucket ${bucketName}.`);
+                            }
+                        });
+                    }
+                }
+            });
+        });
+    }
+
+    isObjectInBucket(bucketName, objectName) {
+        return new Promise((resolve, reject) => {
+            this.client.statObject(bucketName, objectName, (err, stat) => {
+                if (err && err.code === 'NotFound') {
+                    resolve([stat, false]);
+                } else if (err) {
+                    reject(err);
+                } else {
+                    // resolve(`Object ${objectName} exists inside ${bucketName}.`);
+                    resolve([stat, true]);
+                }
+            });
+        });
+    }
+
+}
+
+module.exports = SwiftStreamService;

package/nodenithy/build/validator/src/task_status.js

@@ -0,0 +1,15 @@
+class TaskStatus {
+    static SUCCESS = 0;
+    static SYSTEM_ERROR = 1;
+    static KEY_ERROR = 2;
+    static SYNTAX_WARNING = 3;
+    static BASE_EXCEPTION = 4;
+    static PAYLOAD_NOT_DEFINED = 5;
+    static PAYLOAD_CHECKSUM_ERROR = 6;
+    static INPUT_CHECKSUM_ERROR = 7;
+    static EVAL_ERROR = 8;
+}
+
+module.exports = {
+    TaskStatus,
+};

package/nodenithy/build/validator/src/test.js

@@ -0,0 +1,44 @@
+// const tt = require("./etny_crypto");
+//
+// const p = '4c351ff11a73151f3de1fc686c8bdf63c07b28cb814797d0b1dd361d9fea4008';
+//
+// const b = tt.encryptWithPublicKey(p, 'hello');
+// console.log(b.toString('utf8'));
+//
+//
+
+
+const SwiftStreamService = require("./swift_stream_service");
+const etny_crypto = require("./etny_crypto");
+const fs = require('fs');
+
+(async () => {
+    try {
+        console.log('################################');
+        console.log('Initializing SwiftStream Service...');
+        const swiftStreamClient = new SwiftStreamService(
+            "localhost",
+            9000,
+            "swiftstreamadmin",
+            "swiftstreamadmin");
+        console.log('SwiftStream Service started.');
+        console.log('################################');
+
+        const p = '4c351ff11a73151f3de1fc686c8bdf63c07b28cb814797d0b1dd361d9fea4008';
+        const message = '3';
+        const encrypted = etny_crypto.encryptWithPublicKey(p, message);
+        // console.log('Encrypted result:', encrypted.toString('utf8'));
+        console.log('Encrypted result:', encrypted.toString('hex'));
+        // console.log('Encrypted result:', Buffer.from(encrypted, 'hex'));
+        // await fs.promises.writeFile('test.txt', Buffer.from(encrypted, 'hex'));
+        await swiftStreamClient.putFileContent('etny-nodenithy-v2', 'result11.txt', 'test.txt', encrypted.toString('hex'));
+
+        const t = await swiftStreamClient.getFileContent('etny-nodenithy-v2', 'result11.txt');
+        console.log(t);
+        // await swiftStreamClient.putFileContent('etny-nodenithy-v2', 'result1.txt', '/result', Buffer.from(message, 'utf8'));
+        // await swiftStreamClient.putFileContent('etny-nodenithy-v2', 'result2.txt', '/result', Buffer.from(message, 'utf8'));
+    } catch (e) {
+        console.log(e);
+    }
+})();
+