printnatura/print-server.js

const mysql = require('mysql2/promise');
const exec = require('child_process').exec;
const fs = require('fs-extra');
const path = require('path');
const colors = require('colors');
const axios = require('axios');
const yml = require('require-yml');

const selectQuery = fs.readFileSync(`sql/selectQueued.sql`).toString();
const jobDataQuery = fs.readFileSync(`sql/jobData.sql`).toString();
const jobArgsQuery = fs.readFileSync(`sql/jobArgs.sql`).toString();
const updateQuery = fs.readFileSync(`sql/updateState.sql`).toString();

class PrintServer {
    async start() {
        let conf = yml(path.join(__dirname, 'config.yml'));
        const localConfFile = path.join(__dirname, 'config.local.yml');
        if (fs.existsSync(localConfFile))
            conf = Object.assign({}, conf, yml(localConfFile));
        this.conf = conf;

        console.clear();
        const decoration = '△▽'.repeat(10);
        const printnatura = colors.bgBlack.bold(' Print'.white + 'Natura '.green);
        console.log(`${decoration} ${printnatura} ${decoration}`);
        if (this.conf.dryPrint)
            this.serverLog('log', 'Running in dry print mode, documents won\'t be printed'.yellow);
        if (this.conf.keepFile)
            this.serverLog('log', 'Keep file enabled, documents won\'t be deleted from disk'.yellow);

        await this.init();
        this.rejectionHandler = (err, p) => this.onRejection(err, p);
        process.on('unhandledRejection', this.rejectionHandler);

        this.serverLog('log', 'Ready to print'.green);
        setTimeout(() => this.poll());
    }
    async stop() {
        this.serverLog('log', 'Bye ( ◕ ‿ ◕ )っ'.green);
        process.off('unhandledRejection', this.rejectionHandler);
        await this.end();
    }
    async init() {
        const conf = this.conf;
        const api = this.api = axios.create({
            baseURL: `${conf.salix.url}/api/`
        });
        api.interceptors.request.use(config => {
            if (this.token)
                config.headers['Authorization'] = this.token
            return config;
        });
        await this.getToken();

        this.pool = await mysql.createPool(conf.db);
    }
    async end() {
        await this.api.post(`Accounts/logout`);
        this.token = null;
        if (this.pollTimeout) {
            clearTimeout(this.pollTimeout);
            this.pollTimeout = null;
        }
        await this.pool.end();
    }
    async getToken() {
        const salix = this.conf.salix;
        let response = await this.api.post(`Accounts/login`, {
            user: salix.user,
            password: salix.password
        });
        this.token = response.data.token;
    }
    serverLog(realm, message) {
        this.log(`Server`, realm, message);
    }
    log(classMsg, realm, message) {
        classMsg = `${classMsg}:`;

        switch(realm) {
            case 'debug':
                if (this.conf.debug) console.debug(classMsg, message.magenta);
                break;
            case 'error':
                console.error(classMsg, message.red);
                break;
            default:
                if (this.conf.log) console.log(classMsg, message);
        }
    }
    onRejection(err, p) {
        console.debug('unhandledRejection');
        this.errorHandler(err);
    }
    errorHandler(err) {
        if (err.code === 'ETIMEDOUT') {
            if (!this.dbDown) {
                this.dbDown = true;
                this.serverLog('error', `DB connection lost: ${err.message}`);
            }
        } else
            console.error(err);
    }
    async poll() {
        const conf = this.conf;
        this.pollTimeout = null;

        if (this.dbDown) {
            try {
                let conn;
                try {
                    conn = await this.pool.getConnection();
                    await conn.ping();
                    this.dbDown = false;
                    this.serverLog('log', 'DB connection recovered'.green);
                } catch (err) {
                    conn.release();
                }
            } catch(e) {}
        }

        if (!this.dbDown) {
            try {
                let jobs;
                let nJobs = 0;
                do {
                    jobs = [];
                    for (let i = 0; i < conf.concurrency; i++) {
                        const jobId = await this.getJob();
                        if (jobId) {
                            const job = this.printJob(jobId);
                            // XXX: Workaround for Promise.all() unhandledRejection
                            // https://stackoverflow.com/questions/67789309/why-do-i-get-an-unhandled-promise-rejection-with-await-promise-all
                            job.catch(() => {});
                            jobs.push(job);
                        }
                        else
                            break;
                    }

                    nJobs += jobs.length;
                    await Promise.all(jobs);
                } while (jobs.length);

                if (nJobs > 0)
                    this.serverLog('debug', `${nJobs} jobs printed`);
            } catch (err) {
                this.errorHandler(err);
            }
        }

        let delay = this.conf.refreshRate;
        if (this.dbDown) delay = this.conf.reconnectTimeout;
        this.pollTimeout = setTimeout(() => this.poll(), delay);
    }
    async getJob() {
        let jobId;

        const conn = await this.pool.getConnection();
        try {
            await conn.beginTransaction();
            try {
                const [[printJob]] = await conn.query(selectQuery);
                if (printJob) {
                    jobId = printJob.id;
                    await conn.query(updateQuery, ['printing', null, jobId]);
                    await conn.commit();
                    this.jobLog(jobId, 'debug', 'get: printing');
                }
            } catch (err) {
                await conn.rollback();
                if (jobId)
                    this.jobLog(jobId, 'error', err.message);
                throw err;
            }
        } finally {
            conn.release();
        }

        return jobId;
    }
    async printJob(jobId) {
        const conf = this.conf;
        let jobData;
        const args = {};
        let tmpFilePath;
        let tmpFileCreated = false;

        const conn = await this.pool.getConnection();
        try {
            await conn.beginTransaction();
            try {
                // Job data
                const [[data]] = await conn.query(jobDataQuery, jobId);
                jobData = data;

                // Job arguments
                const [res] = await conn.query(jobArgsQuery, jobId);
                for (const row of res)
                    args[row.name] = row.value;

                await conn.commit();
            } catch (err) {
                await conn.rollback();
                throw err;
            }

            // Path params
            const usedParams = new Set();
            const methodPath = jobData.method.replace(/{\w+}/g, function(match) {
                const key = match.substr(1, match.length - 2);
                const value = args[key];
                usedParams.add(key);
                return value !== undefined ? value : match;
            });

            let pdfData;
            let url;
            for (let attempts = 0; !pdfData && attempts < 2; attempts++) {
                // URL params
                const params = {userFk: jobData.userFk};
                for (const key in args) {
                    if (!usedParams.has(key))
                        params[key] = args[key];
                }
                const urlParams = new URLSearchParams(params);

                url = `${methodPath}?${urlParams.toString()}`;
                this.jobLog(jobId, 'debug', `api: ${url}`);

                // Request
                try {
                    const response = await this.api({
                        method: 'get',
                        url,
                        responseType: 'arraybuffer',
                        headers: {'Accept': 'application/pdf'}
                    });
                    pdfData = response.data;  
                }
                catch (err) {
                    if (err.response?.statusText === 'Unauthorized') {
                        await this.getToken();
                    } else
                        throw err;
                }
            }

            // Save PDF to disk
            const printer = jobData.printer;
            const tmpPath = conf.tmpDir;
            if (!fs.existsSync(tmpPath))
                fs.mkdirSync(tmpPath)
            tmpFilePath = path.join(tmpPath, `job-${jobId}.pdf`);
            await fs.writeFile(tmpFilePath, pdfData, 'binary');
            tmpFileCreated = true;

            // Print PDF
            const printCommand = `lp -d "${printer}" "${tmpFilePath}"`;
            this.jobLog(jobId, 'debug', `print: ${printCommand}`);
            try {
                if (!conf.dryPrint) await pExec(printCommand);
            } catch(err) {
                throw new Error(`Print error: ${err.message}`);
            } 

            await conn.query(updateQuery, ['printed', null, jobId]);
            this.jobLog(jobId, 'log', `${jobData.report}: '${printCommand}': GET ${url}`);
        } catch (err) {
            let message = err.message;
            if (err.name === 'AxiosError' && err.code === 'ERR_BAD_REQUEST') {
                const resMessage = JSON.parse(err.response.data).error.message;
                message = `${message}: ${resMessage}`;
            }

            await conn.query(updateQuery, ['error', message, jobId]);
            this.jobLog(jobId, 'error', message);

            const jobErr = new Error(`(${jobId}) ${message}`);
            jobErr.stack = err.stack;
            throw jobErr;
        } finally {
            conn.release();
        }

        if (!conf.keepFile) {
            try {
                const shouldDelete = tmpFileCreated
                    || (tmpFilePath && await fs.pathExists(tmpFilePath));
                if (shouldDelete) await fs.unlink(tmpFilePath);
            } catch (err) {
                this.jobLog(jobId, 'error', err.message);
            }
        }
    }
    jobLog(jobId, realm, message) {
        this.log(`Job[${colors.yellow(jobId)}]`, realm, message);
    }
}

module.exports = PrintServer;

function pExec(command) {
    return new Promise(function(resolve, reject) {
        exec(command, function(err, stdout, stderr) {
            if (err) return reject(err);
            resolve({stdout, stderr})
        });
    });
}