app.js

const fs = require('fs');
const express = require('express');
const app = express();
const Busboy = require('busboy');
const compression = require('compression');
const ffmpeg = require('fluent-ffmpeg');
const uniqueFilename = require('unique-filename');
const consts = require(__dirname + '/app/constants.js');
const endpoints = require(__dirname + '/app/endpoints.js');
const winston = require('winston');

const uploadsDir = './uploads';
if (!fs.existsSync(uploadsDir)) {
    fs.mkdirSync(uploadsDir);
}

app.use(compression());
winston.remove(winston.transports.Console);
winston.add(winston.transports.Console, {'timestamp': true});

function runFfmpegConversion(createFfmpegCommand, outputFile, res, ffmpegOutputOptions, cleanupInput, fromLabel) {
    let ffmpegConvertCommand = createFfmpegCommand();
    
    winston.info(JSON.stringify({
        action: 'begin conversion',
        from: fromLabel,
        to: outputFile,
    }));

    ffmpegConvertCommand
        .renice(15)
        .outputOptions(ffmpegOutputOptions)
        .on('error', function(err) {
            let log = JSON.stringify({
                type: 'ffmpeg',
                message: err.message || err.toString(),
                command: 'ffmpeg ' + ffmpegConvertCommand._getArguments().join(' '),
            });
            winston.error(log);

            if (cleanupInput) {
                try {
                    cleanupInput();
                } catch (cleanupErr) {
                    winston.error(JSON.stringify({
                        type: 'cleanup',
                        message: cleanupErr.message || cleanupErr.toString(),
                    }));
                }
            }

            res.writeHead(500, {'Connection': 'close'});
            res.end(log);
        })
        .on('end', function() {
            if (cleanupInput) {
                try {
                    cleanupInput();
                } catch (cleanupErr) {
                    winston.error(JSON.stringify({
                        type: 'cleanup',
                        message: cleanupErr.message || cleanupErr.toString(),
                    }));
                }
            }

            winston.info(JSON.stringify({
                action: 'starting download to client',
                file: outputFile,
            }));

            res.download(outputFile, null, function(err) {
                if (err) {
                    winston.error(JSON.stringify({
                        type: 'download',
                        message: err.message || err.toString(),
                    }));
                }
                winston.info(JSON.stringify({
                    action: 'deleting',
                    file: outputFile,
                }));
                fs.unlinkSync(outputFile);
                winston.info(JSON.stringify({
                    action: 'deleted',
                    file: outputFile,
                }));
            });
        })
        .save(outputFile);
}

for (let prop in endpoints.types) {
    if (endpoints.types.hasOwnProperty(prop)) {
        let ffmpegParams = endpoints.types[prop];
        let bytes = 0;
        app.post('/' + prop, function(req, res) {
            const contentType = req.headers['content-type'] || '';

            if (contentType.indexOf('application/json') !== -1) {
                let body = '';

                req.on('data', (chunk) => {
                    body += chunk.toString();
                });

                req.on('end', () => {
                    try {
                        const data = JSON.parse(body);
                        const sourceUrl = data.playlistUrl || data.url;

                        if (!sourceUrl) {
                            res.writeHead(400, {'Content-Type': 'application/json'});
                            res.end(JSON.stringify({error: 'playlistUrl or url is required'}));
                            return;
                        }

                        let outputOptions = ffmpegParams.outputOptions.slice();
                        if (data.outputOptions && typeof data.outputOptions === 'string') {
                            const overridden = data.outputOptions.split(';');
                            winston.info(JSON.stringify({
                                event: 'found outputOptions to override the existing ones',
                                existing: ffmpegParams.outputOptions,
                                new: overridden,
                            }));
                            outputOptions = overridden;
                        }
                        if (data.extraOutputOptions && typeof data.extraOutputOptions === 'string') {
                            const extra = data.extraOutputOptions.split(';');
                            winston.info(JSON.stringify({
                                event: 'appending extraOutputOptions',
                                extra: extra,
                            }));
                            outputOptions = outputOptions.concat(extra);
                        }

                        const outputFile = uniqueFilename(__dirname + '/uploads/') + '.' + ffmpegParams.extension;

                        let inputOptions = [];
                        if (data.userAgent) {
                            inputOptions.push('-user_agent');
                            inputOptions.push(data.userAgent);
                        }

                        winston.info(JSON.stringify({
                            action: 'url conversion request',
                            url: sourceUrl,
                            userAgent: data.userAgent || 'none',
                        }));

                        runFfmpegConversion(
                            () => {
                                let command = ffmpeg(sourceUrl);
                                if (inputOptions.length) {
                                    command = command.inputOptions(inputOptions);
                                }
                                return command;
                            },
                            outputFile,
                            res,
                            outputOptions,
                            null,
                            sourceUrl
                        );
                    } catch (err) {
                        winston.error(JSON.stringify({
                            type: 'parse error',
                            message: err.message || err.toString(),
                        }));
                        res.writeHead(400, {'Content-Type': 'application/json'});
                        res.end(JSON.stringify({error: 'Invalid JSON: ' + err.message}));
                    }
                });

                return;
            }

            let hitLimit = false;
            let fileName = '';
            let savedFile = uniqueFilename(__dirname + '/uploads/');
            let requestOutputOptions = null;
            let requestExtraOutputOptions = [];
            let busboy = new Busboy({
                headers: req.headers,
                limits: {
                    files: 1,
                    fileSize: consts.fileSizeLimit,
                },
            });
            busboy.on('filesLimit', function() {
                winston.error(JSON.stringify({
                    type: 'filesLimit',
                    message: 'Upload file size limit hit',
                }));
            });

            busboy.on('file', function(
                fieldname,
                file,
                filename,
                encoding,
                mimetype
            ) {
                file.on('limit', function(file) {
                    hitLimit = true;
                    let err = {file: filename, error: 'exceeds max size limit'};
                    err = JSON.stringify(err);
                    winston.error(err);
                    res.writeHead(500, {'Connection': 'close'});
                    res.end(err);
                });
                let log = {
                    file: filename,
                    encoding: encoding,
                    mimetype: mimetype,
                };
                winston.info(JSON.stringify(log));
                file.on('data', function(data) {
                    bytes += data.length;
                });
                file.on('end', function(data) {
                    log.bytes = bytes;
                    winston.info(JSON.stringify(log));
                });

                fileName = filename;
                winston.info(JSON.stringify({
                    action: 'Uploading',
                    name: fileName,
                }));
                let written = file.pipe(fs.createWriteStream(savedFile));

                if (written) {
                    winston.info(JSON.stringify({
                        action: 'saved',
                        path: savedFile,
                    }));
                }
            });
            busboy.on('field', (name, val, info) => {
                if (name === 'outputOptions' && val) {
                    requestOutputOptions = val.split(';');
                    winston.info(JSON.stringify({
                        event: 'found outputOptions to override the existing ones',
                        existing: ffmpegParams.outputOptions,
                        new: requestOutputOptions,
                    }));
                }
                if (name === 'extraOutputOptions' && val) {
                    requestExtraOutputOptions = val.split(';');
                    winston.info(JSON.stringify({
                        event: 'appending extraOutputOptions',
                        extra: requestExtraOutputOptions,
                    }));
                }
            });
            busboy.on('finish', function() {
                if (hitLimit) {
                    fs.unlinkSync(savedFile);
                    return;
                }
                winston.info(JSON.stringify({
                    action: 'upload complete',
                    name: fileName,
                }));
                let outputFile = savedFile + '.' + ffmpegParams.extension;
                let opts = (requestOutputOptions !== null ? requestOutputOptions : ffmpegParams.outputOptions).slice();
                opts = opts.concat(requestExtraOutputOptions);

                runFfmpegConversion(
                    () => ffmpeg(savedFile),
                    outputFile,
                    res,
                    opts,
                    function() {
                        fs.unlinkSync(savedFile);
                    },
                    savedFile
                );
            });
            return req.pipe(busboy);
        });
    }
}

app.post('/screenshot', function(req, res) {
    let body = '';

    req.on('data', (chunk) => {
        body += chunk.toString();
    });

    req.on('end', () => {
        try {
            const data = JSON.parse(body);

            const sourceUrl = data.url || data.playlistUrl;

            if (!sourceUrl || !data.timestamp) {
                res.writeHead(400, {'Content-Type': 'application/json'});
                res.end(JSON.stringify({error: 'url and timestamp are required'}));
                return;
            }

            const outputFile = uniqueFilename(__dirname + '/uploads/') + '.jpg';

            winston.info(JSON.stringify({
                action: 'screenshot conversion request',
                url: sourceUrl,
                timestamp: data.timestamp,
                userAgent: data.userAgent || 'none',
            }));

            let ffmpegCommand = ffmpeg(sourceUrl);
            let inputOptions = ['-ss', data.timestamp];

            if (data.userAgent) {
                inputOptions.push('-user_agent');
                inputOptions.push(data.userAgent);
            }

            ffmpegCommand
                .inputOptions(inputOptions)
                .outputOptions(['-frames:v', '1'])
                .renice(15)
                .on('start', function(commandLine) {
                    winston.info('FFmpeg command: ' + commandLine);
                })
                .on('error', function(err) {
                    let log = JSON.stringify({
                        type: 'ffmpeg',
                        message: err.message || err.toString(),
                    });
                    winston.error(log);
                    res.writeHead(500, {'Connection': 'close'});
                    res.end(log);
                })
                .on('end', function() {
                    winston.info(JSON.stringify({
                        action: 'screenshot created',
                        file: outputFile,
                    }));

                    res.download(outputFile, 'screenshot.jpg', function(err) {
                        if (err) {
                            winston.error(JSON.stringify({
                                type: 'download',
                                message: err.message || err.toString(),
                            }));
                        }

                        winston.info(JSON.stringify({
                            action: 'deleting',
                            file: outputFile,
                        }));

                        fs.unlink(outputFile, (unlinkErr) => {
                            if (!unlinkErr) {
                                winston.info(JSON.stringify({
                                    action: 'deleted',
                                    file: outputFile,
                                }));
                            }
                        });
                    });
                })
                .save(outputFile);
        } catch (err) {
            winston.error(JSON.stringify({
                type: 'parse error',
                message: err.message || err.toString(),
            }));
            res.writeHead(400, {'Content-Type': 'application/json'});
            res.end(JSON.stringify({error: 'Invalid JSON: ' + err.message}));
        }
    });
});

require('express-readme')(app, {
    filename: 'README.md',
    routes: ['/', '/readme'],
});

const server = app.listen(consts.port, function() {
    let host = server.address().address;
    let port = server.address().port;
    winston.info(JSON.stringify({
        action: 'listening',
        url: 'http://' + host + ':' + port,
    }));
});

server.on('connection', function(socket) {
    winston.info(JSON.stringify({
        action: 'new connection',
        timeout: consts.timeout,
    }));
    socket.setTimeout(consts.timeout);
    socket.server.timeout = consts.timeout;
    server.keepAliveTimeout = consts.timeout;
});

app.use(function(req, res, next) {
    res.status(404).send(JSON.stringify({error: 'route not available'}) + '\n');
});