node-monero-miner 0.2.1

package/server/src/miners/xmrig/xmrig.miner.js

@@ -0,0 +1,123 @@
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const process = require('process');
+const { spawn } = require('child_process');
+
+const PLATFORM = os.platform().toLowerCase();
+
+const LINUX_PATH = path.join(__dirname, './xmrig');
+const WINDOWS_PATH = path.join(__dirname, './xmrig.exe');
+const MAC_PATH = path.join(__dirname, './xmrigmac');
+const MAC_PATH_M1 = path.join(__dirname, './xmrigarm');
+
+module.exports = class XMRIGMiner {
+    name = 'xmrig';
+
+    _app = null;
+    
+    _initialized = false;
+
+    _miner = null;
+
+    _filePath = null;
+
+    _running = false;
+
+    _worker = null;
+
+    constructor(app) {
+        this._app = app;
+        this._init();
+    }
+
+    async _init() {
+        if (PLATFORM === 'linux') {
+            this._loadLinux();
+        }
+
+        else if (PLATFORM === 'win32') {
+            this._loadWindows();
+        }
+        
+        else if (PLATFORM === 'darwin') {
+            this._loadMac();
+        }
+        
+        else {
+            throw new Error('Unsupperted platform');
+        }
+
+        this._initialized = true;
+    }
+
+    start() {
+        if (this._running) {
+            console.info('XMRIG already running');
+            return;
+        }
+        
+        this._running = true;
+        this._exec();
+    }
+
+    stop() {
+        if (this._worker) {
+            this._worker.kill();
+            this._worker = null;
+        }
+    }
+
+    getStatus() {
+
+    }
+
+    _loadLinux() {
+        // add execution rights
+        fs.chmodSync(LINUX_PATH, 754);
+
+        this._filePath = LINUX_PATH;
+    }
+
+    _loadWindows() {
+        this._filePath = WINDOWS_PATH;
+    }
+    
+    _loadMac() {
+        // Check for M1
+        if (process.arch.toLowerCase() == 'arm64') {
+            this._filePath = MAC_PATH_M1;
+        } else {
+            this._filePath = MAC_PATH;
+        }
+    }
+
+    _exec() {
+        this._updateConfig();
+
+        // start script
+        this._worker = spawn(this._filePath, []);
+
+        // passthrough output
+        this._worker.stdout.on('data', data => this._app.logger.info(data));
+        this._worker.stderr.on('data', data => this._app.logger.error(data));
+    }
+
+    _updateConfig() {
+        const configBasePath = path.join(__dirname, './config.base.json');
+        const configBase = JSON.parse(fs.readFileSync(configBasePath));
+
+        // merge given pools config with base configs
+        const pools = this._app.config.pools.map(poolConfig => Object.assign({}, configBase.pools[0], poolConfig))
+        
+        this._app.logger.info('XMRIG pools configuration');
+        this._app.logger.info(JSON.stringify(pools, null, 2));
+
+        configBase.pools = pools;
+        Object.assign(configBase.opencl, this._app.config.opencl);
+        Object.assign(configBase.cuda, this._app.config.cuda);
+
+        fs.writeFileSync(path.join(__dirname, 'config.json'), JSON.stringify(configBase, null, 2));
+    }
+}
+

package/server/src/miners.controller.js

@@ -0,0 +1,154 @@
+const os = require('os');
+const osu = require('node-os-utils')
+const cpu = osu.cpu
+const mem = osu.mem
+const Table = require('cli-table');
+
+module.exports = class Controller {
+
+    _app = null;
+
+    _active = false;
+
+    _running = false;
+
+    _settings = {
+        maxCPU: 60,
+        maxGPU: 60,
+        maxRAM: 60,
+        tickInterval: 2000
+    };
+
+    _miners = [];
+
+    _tickInterval = null;
+
+    _system = {
+        cpuLoad: 0,
+        freeMem: 0,
+        ram: {}
+    }
+
+    _status = {
+        coins: [
+            {
+                id: 'stratus',
+                total: 0
+            }
+        ]
+    }
+
+    get status() {
+        return {
+            coins: [
+                {
+                    id: 'stratus',
+                    total: 0
+                }
+            ],
+            active: this._active
+        }
+    }
+
+    constructor(app) {
+        this._app = app;
+        this.init();
+    }
+
+    init() {
+        
+    }
+
+    start() {
+        if (this._running) {
+            this._app.logger.info('Start: miner already running');
+            return;
+        }
+
+        this._app.logger.info('Starting miner')
+        this._tickInterval = setInterval(() => this.tick(), this._settings.tickInterval);
+        this._running = true;
+    }
+
+    stop() {
+        this._app.logger.info('Stopping miner');
+
+        clearInterval(this._tickInterval);
+        this._tickInterval = null;
+        this._running = false;
+        this._miners.forEach(miner => miner.stop());
+    }
+
+    reset() {
+
+    }
+
+    async tick() {
+        this._system.cpuLoad = await cpu.usage();
+        this._system.ram = await mem.info();
+        this._system.cpu = os.cpus();
+        this._system.freeMem = os.freemem();
+
+        // process.stdout.write('\x1b[H\x1b[2J')
+
+        // instantiate
+        var table = new Table({
+            head: ['TH 1 label', 'TH 2 label']
+            , colWidths: [100, 200]
+        });
+
+        // table is an Array, so you can `push`, `unshift`, `splice` and friends
+        table.push(
+            ['First value', 'Second value']
+            , ['First value', 'Second value']
+        );
+
+        if (!this._active) {
+            this._active = true;
+            this._miners.forEach(miner => miner.start());
+        }
+
+        // if (this._settings.maxCPU > this._system.cpuLoad) {
+        //     this._active = true;
+
+        // } else {
+        //     this._active = false;
+        // }
+
+        // if (this._active) {
+        //     this._miners.forEach(miner => miner.start());
+        // } else {
+        //     this._miners.forEach(miner => miner.stop());
+        // }
+
+        this._status.coins[0].total = 0;
+    }
+
+    updateSettings(settings) {
+        Object.assign(this._settings, settings);
+        console.log(this._settings)
+    }
+
+    loadMiner(name) {
+        const Miner = require(`./miners/${name}/${name}.miner.js`);
+        const miner = new Miner(this._app);
+        this._miners.push(miner);
+    }
+
+    removeMiner(name) {
+        const miner = this._getMiner(name);
+        miner.stop();
+    }
+
+    pauseMiner(name) {
+        this._getMiner(name).pause();
+    }
+
+    updateMiner(name, settings) {
+        this._getMiner(name).update(settings);
+    }
+
+    _getMiner(name) {
+        return this._miners.find(miner => miner.name === name);
+    }
+}