protractor/built/debugger.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const net = require("net");
const selenium_webdriver_1 = require("selenium-webdriver");
const util = require("util");
const logger_1 = require("./logger");
let breakpointHook = require('./breakpointhook.js');
let logger = new logger_1.Logger('protractor');
class DebugHelper {
    constructor(browserUnderDebug_) {
        this.browserUnderDebug_ = browserUnderDebug_;
    }
    initBlocking(debuggerClientPath, onStartFn, opt_debugPort) {
        this.init_(debuggerClientPath, true, onStartFn, opt_debugPort);
    }
    init(debuggerClientPath, onStartFn, opt_debugPort) {
        this.init_(debuggerClientPath, false, onStartFn, opt_debugPort);
    }
    /**
     *  1) Set up helper functions for debugger clients to call on (e.g.
     *     execute code, get autocompletion).
     *  2) Enter process into debugger mode. (i.e. process._debugProcess).
     *  3) Invoke the debugger client specified by debuggerClientPath.
     *
     * @param {string} debuggerClientPath Absolute path of debugger client to use.
     * @param {boolean} blockUntilExit Whether to block the flow until process exit or resume
     *     immediately.
     * @param {Function} onStartFn Function to call when the debugger starts. The
     *     function takes a single parameter, which represents whether this is the
     *     first time that the debugger is called.
     * @param {number=} opt_debugPort Optional port to use for the debugging
     *     process.
     *
     * @return {Promise} If blockUntilExit, a promise resolved when the debugger process
     *     exits. Otherwise, resolved when the debugger process is ready to begin.
     */
    init_(debuggerClientPath, blockUntilExit, onStartFn, opt_debugPort) {
        const vm_ = require('vm');
        let flow = selenium_webdriver_1.promise.controlFlow();
        let context = { require: require };
        global.list = (locator) => {
            return global.protractor.browser.findElements(locator).then((arr) => {
                let found = [];
                for (let i = 0; i < arr.length; ++i) {
                    arr[i].getText().then((text) => {
                        found.push(text);
                    });
                }
                return found;
            });
        };
        for (let key in global) {
            context[key] = global[key];
        }
        let sandbox = vm_.createContext(context);
        let debuggingDone = selenium_webdriver_1.promise.defer();
        // We run one flow.execute block for the debugging session. All
        // subcommands should be scheduled under this task.
        let executePromise = flow.execute(() => {
            process['debugPort'] = opt_debugPort || process['debugPort'];
            this.validatePortAvailability_(process['debugPort']).then((firstTime) => {
                onStartFn(firstTime);
                let args = [process.pid, process['debugPort']];
                if (this.browserUnderDebug_.debuggerServerPort) {
                    args.push(this.browserUnderDebug_.debuggerServerPort);
                }
                let nodedebug = require('child_process').fork(debuggerClientPath, args);
                process.on('exit', function () {
                    nodedebug.kill('SIGTERM');
                });
                nodedebug
                    .on('message', (m) => {
                    if (m === 'ready') {
                        breakpointHook();
                        if (!blockUntilExit) {
                            debuggingDone.fulfill();
                        }
                    }
                })
                    .on('exit', () => {
                    // Clear this so that we know it's ok to attach a debugger
                    // again.
                    this.dbgCodeExecutor = null;
                    debuggingDone.fulfill();
                });
            });
            return debuggingDone.promise;
        }, 'debugging tasks');
        // Helper used only by debuggers at './debugger/modes/*.js' to insert code
        // into the control flow, via debugger 'evaluate' protocol.
        // In order to achieve this, we maintain a task at the top of the control
        // flow, so that we can insert frames into it.
        // To be able to simulate callback/asynchronous code, we poll this object
        // whenever `breakpointHook` is called.
        this.dbgCodeExecutor = {
            execPromise_: undefined,
            execPromiseResult_: undefined,
            execPromiseError_: undefined,
            // A dummy repl server to make use of its completion function.
            replServer_: require('repl').start({
                input: { on: function () { }, resume: function () { } },
                // dummy readable stream
                output: { write: function () { } },
                useGlobal: true
            }),
            // Execute a function, which could yield a value or a promise,
            // and allow its result to be accessed synchronously
            execute_: function (execFn_) {
                this.execPromiseResult_ = this.execPromiseError_ = undefined;
                this.execPromise_ = execFn_();
                // Note: This needs to be added after setting execPromise to execFn,
                // or else we cause this.execPromise_ to get stuck in pending mode
                // at our next breakpoint.
                this.execPromise_.then((result) => {
                    this.execPromiseResult_ = result;
                    breakpointHook();
                }, (err) => {
                    this.execPromiseError_ = err;
                    breakpointHook();
                });
            },
            // Execute a piece of code.
            // Result is a string representation of the evaluation.
            execute: function (code) {
                let execFn_ = () => {
                    // Run code through vm so that we can maintain a local scope which is
                    // isolated from the rest of the execution.
                    let res;
                    try {
                        res = vm_.runInContext(code, sandbox);
                    }
                    catch (e) {
                        res = selenium_webdriver_1.promise.when('Error while evaluating command: ' + e);
                    }
                    if (!selenium_webdriver_1.promise.isPromise(res)) {
                        res = selenium_webdriver_1.promise.when(res);
                    }
                    return res.then((res) => {
                        if (res === undefined) {
                            return undefined;
                        }
                        else {
                            // The '' forces res to be expanded into a string instead of just
                            // '[Object]'. Then we remove the extra space caused by the ''
                            // using substring.
                            return util.format.apply(this, ['', res]).substring(1);
                        }
                    });
                };
                this.execute_(execFn_);
            },
            // Autocomplete for a line.
            // Result is a JSON representation of the autocomplete response.
            complete: function (line) {
                let execFn_ = () => {
                    let deferred = selenium_webdriver_1.promise.defer();
                    this.replServer_.complete(line, (err, res) => {
                        if (err) {
                            deferred.reject(err);
                        }
                        else {
                            deferred.fulfill(JSON.stringify(res));
                        }
                    });
                    return deferred.promise;
                };
                this.execute_(execFn_);
            },
            // Code finished executing.
            resultReady: function () {
                return !(this.execPromise_.state_ === 'pending');
            },
            // Get asynchronous results synchronously.
            // This will throw if result is not ready.
            getResult: function () {
                if (!this.resultReady()) {
                    throw new Error('Result not ready');
                }
                if (this.execPromiseError_) {
                    throw this.execPromiseError_;
                }
                return this.execPromiseResult_;
            }
        };
        return executePromise;
    }
    /**
     * Validates that the port is free to use. This will only validate the first
     * time it is called. The reason is that on subsequent calls, the port will
     * already be bound to the debugger, so it will not be available, but that is
     * okay.
     *
     * @returns {Promise<boolean>} A promise that becomes ready when the
     * validation
     *     is done. The promise will resolve to a boolean which represents whether
     *     this is the first time that the debugger is called.
     */
    validatePortAvailability_(port) {
        if (this.debuggerValidated_) {
            return selenium_webdriver_1.promise.when(false);
        }
        let doneDeferred = selenium_webdriver_1.promise.defer();
        // Resolve doneDeferred if port is available.
        let tester = net.connect({ port: port }, () => {
            doneDeferred.reject('Port ' + port + ' is already in use. Please specify ' +
                'another port to debug.');
        });
        tester.once('error', (err) => {
            if (err.code === 'ECONNREFUSED') {
                tester
                    .once('close', () => {
                    doneDeferred.fulfill(true);
                })
                    .end();
            }
            else {
                doneDeferred.reject('Unexpected failure testing for port ' + port + ': ' + JSON.stringify(err));
            }
        });
        return doneDeferred.promise.then((firstTime) => {
            this.debuggerValidated_ = true;
            return firstTime;
        }, (err) => {
            console.error(err);
            return process.exit(1);
        });
    }
    isAttached() {
        return !!this.dbgCodeExecutor;
    }
}
exports.DebugHelper = DebugHelper;
//# sourceMappingURL=debugger.js.map