testingbot-tunnel-launcher/lib/tunnel-launcher.js

'use strict'

const async = require('async')
const fs = require('fs')
const os = require('os')
const path = require('path')
const spawn = require('child_process').spawn
const downloader = require('./downloader')
let tunnelLocation
let activeTunnel
let started = false

function logger (msg) {
    console.log.apply(console, arguments)
}

function download (options, callback) {
    tunnelLocation = path.normalize(path.join(__dirname, '../testingbot-tunnel.jar'))

    let url = 'https://testingbot.com/tunnel/testingbot-tunnel.jar'

    if (options.tunnelVersion) {
        tunnelLocation = path.normalize(path.join(__dirname, `../testingbot-tunnel-${options.tunnelVersion}.jar`))
        url = `https://testingbot.com/tunnel/testingbot-tunnel-${options.tunnelVersion}.jar`
    }

    try {
        const tunnelFile = fs.statSync(tunnelLocation)
        if (tunnelFile['size'] > 1024) {
            return callback(null)
        }
    } catch (ignore) {}

    downloader.get(url, { fileName: 'testingbot-tunnel', destination: tunnelLocation }, (err, destination) => {
        if (err) {
            return callback(new Error(`Could not download the tunnel from TestingBot - please check your connection. ${err.message}`))
        }

        return callback(null)
    })
}

function run (options, callback) {
    if (!fs.existsSync(tunnelLocation)) {
        return callback(new Error(`Tunnel jar file is not present in ${tunnelLocation}`))
    }

    const checkJava = spawn('java')
    checkJava.on('error', err => {
        return callback(new Error(`Java might not be installed, necessary to use testingbot-tunnel ${err.message}`))
    })

    const onReady = function () {
        started = true
        logger('Tunnel is ready')
        callback(null, activeTunnel)
    }

    const args = []

    args.push('-jar')
    args.push(tunnelLocation)

    if (options.apiKey) {
        args.push(options.apiKey)
    }

    if (options.apiSecret) {
        args.push(options.apiSecret)
    }

    for (const option in options) {
        if ((option === 'apiKey') || (option === 'apiSecret') || (option === 'verbose') || (option === 'tunnelVersion')) {
            continue
        }

        if (options[option]) {
            args.push(`--${option}`)
            args.push(options[option])
        } else {
            args.push(`--${option}`)
        }
    }

    const readyFile = path.join(os.tmpdir(), 'testingbot.ready')
    try {
        if (fs.statSync(readyFile).isFile()) {
            logger('Tunnel Readyfile already exists, removing')
            fs.unlinkSync(readyFile)
        }
    } catch (ignore) {}

    args.push(`-f`)
    args.push(readyFile)

    const readyFileChecker = setInterval(() => {
        fs.stat(readyFile, (error, stat) => {
            if (!error) {
                clearInterval(readyFileChecker)
                onReady()
            }
        })
    }, 800)

    if (options.verbose) {
        logger('Starting tunnel with options', args)
    }
    activeTunnel = spawn('java', args, {})

    activeTunnel.stderr.on('data', data => {
        data = data.toString().trim()
        if (options.verbose && data !== '') {
            logger(data)
        }
        if (data.indexOf('is available for download') > -1) {
            logger(data)
        }
        if (data.indexOf('error code : 401') > -1) {
            activeTunnel.error = 'Invalid credentials. Please supply the correct key/secret obtained from TestingBot.com'
            activeTunnel.close()
        } else if (data.toLowerCase().indexOf('error') > -1) {
            logger(data)
            activeTunnel.error = data
            activeTunnel.close()
        }
    })

    activeTunnel.stdout.on('data', data => {
        data = data.toString().trim()
        if (options.verbose && data !== '') {
            logger(data)
        }
    })

    activeTunnel.close = closeCallback => {
        if (closeCallback) {
            activeTunnel.on('close', () => {
                closeCallback()
            })
        }
        activeTunnel.kill('SIGINT')
    }

    activeTunnel.on('exit', (code, signal) => {
        logger('Closing TestingBot Tunnel')
        if (!started) {
            callback(new Error(activeTunnel.error ? activeTunnel.error : `Could not start TestingBot Tunnel. Exit code ${code} signal: ${signal}`))
        }

        started = false
        activeTunnel = null
    })
}

function killTunnel (callback) {
    if (!callback) {
        callback = function () {}
    }

    if (!activeTunnel) {
        return callback(new Error('no active tunnel'))
    }

    activeTunnel.kill('SIGINT')
    callback(null)
}

function downloadAndRun (options, callback) {
    if (!options) {
        options = {}
    }

    if (!callback) {
        callback = function () {}
    }

    async.waterfall([
        async.apply(download, options),
        async.apply(run, options)
    ], callback)
}

module.exports = downloadAndRun
module.exports.kill = killTunnel