@benmalka/foxdriver
Version:
Foxdriver is a Node library which provides a high-level API to control Firefox over the Remote Debugging Protocol
297 lines (236 loc) • 26.7 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
var _net = require("net");
var _net2 = _interopRequireDefault(_net);
var _events = require("events");
var _safeBuffer = require("safe-buffer");
var _logger = require("./logger");
var _logger2 = _interopRequireDefault(_logger);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
const UNSOLICITED_EVENTS = ['tabNavigated', 'styleApplied', 'propertyChange', 'networkEventUpdate', 'networkEvent', 'propertyChange', 'newMutations', 'appOpen', 'appClose', 'appInstall', 'appUninstall', 'frameUpdate', 'tabListChanged'];
/**
* a Client object handles connecting with a Firefox remote debugging
* server instance (e.g. a Firefox instance), plus sending and receiving
* packets on that conection using the Firefox remote debugging protocol.
*
* Important methods:
* connect - Create the connection to the server.
* makeRequest - Make a request to the server with a JSON message,
* and a callback to call with the response.
*
* Important events:
* 'message' - An unsolicited (e.g. not a response to a prior request)
* packet has been received. These packets usually describe events.
*
* This code was adapted from https://github.com/harthur/firefox-client
*/
class Client extends _events.EventEmitter {
constructor(host, port) {
super();
this.host = host;
this.port = port;
this.incoming = _safeBuffer.Buffer.from('');
this.log = (0, _logger2.default)('Client');
this.supportedDomains = [];
this._pendingRequests = [];
this._activeRequests = {};
}
/**
* create socket connection
*
* @return {Promise} resolves once connected to socket
*/
connect() {
this.socket = _net2.default.createConnection({
host: this.host,
port: this.port
});
this.socket.on('data', this.onData.bind(this));
this.socket.on('error', this.onError.bind(this));
this.socket.on('end', this.onEnd.bind(this));
this.socket.on('timeout', this.onTimeout.bind(this));
return new Promise(resolve => this.socket.on('connect', resolve));
}
/**
* end socket connection
*/
disconnect() {
if (!this.socket) {
return;
}
this.socket.destroy();
this.socket.unref();
}
/**
* Called when a new data chunk is received on the connection.
* Parse data into message(s) and call message handler for any full
* messages that are read in.
*/
onData(data) {
this.incoming = _safeBuffer.Buffer.concat([this.incoming, data]);
while (this.readMessage()) {}
}
/**
* Parse out and process the next message from the data read from
* the connection. Returns true if a full meassage was parsed, false
* otherwise.
*/
readMessage() {
var sep = this.incoming.toString().indexOf(':');
if (sep < 0) {
return false;
}
/**
* beginning of a message is preceded by byteLength(message) + ":"
*/
const count = parseInt(this.incoming.slice(0, sep));
/**
* check if response is complete
*/
if (this.incoming.length - (sep + 1) < count) {
return false;
}
this.incoming = this.incoming.slice(sep + 1);
const packet = this.incoming.slice(0, count);
this.incoming = this.incoming.slice(count);
this.handleMessage(packet);
return true;
}
/**
* Handler for a new message coming in. It's either an unsolicited event
* from the server, or a response to a previous request from the client.
*/
handleMessage(packet) {
let message;
try {
message = JSON.parse(packet.toString());
} catch (e) {
return this.log.error(`Couldn't parse packet from server as JSON ${e}, message:\n${packet}`);
}
if (!message.from) {
if (message.error) {
return this.log.error(message.message);
}
return this.log.error(`Server didn't specify an actor: ${packet}`);
}
/**
* respond to request
*/
if (!UNSOLICITED_EVENTS.includes(message.type) && this._activeRequests[message.from]) {
this.emit('message', message);
this.log.info(`response: ${packet}`);
const callback = this._activeRequests[message.from];
delete this._activeRequests[message.from];
callback(message);
return this._flushRequests();
}
/**
* handle unsolicited event from server
*/
if (message.type) {
// this is an unsolicited event from the server
this.log.info(`unsolicited event: ${packet}`);
return this.emit('message', message);
}
this.log.error(`Unhandled message: ${JSON.stringify(message)}`);
}
/**
* Send a JSON message over the connection to the server.
*/
sendMessage(message) {
if (!message.to) {
throw new Error('No actor specified in request');
}
if (!this.socket) {
throw new Error('Not connected, connect() before sending requests');
}
let str = JSON.stringify(message);
this.emit('send', message);
/**
* message is preceded by byteLength(message):
*/
str = `${_safeBuffer.Buffer.from(str).length}:${str}`;
try {
this.socket.write(str);
} catch (e) {
this.log.error(`Couldn't set socket message: ${e.message}`);
}
}
/**
* Set a request to be sent to an actor on the server. If the actor
* is already handling a request, queue this request until the actor
* has responded to the previous request.
*
* @param {object} request
* Message to be JSON-ified and sent to server.
* @param {function} callback
* Function that's called with the response from the server.
*/
makeRequest(request) {
this.log.info(`request: ${JSON.stringify(request)}`);
if (!request.to) {
throw new Error(`${request.type || ''} request packet has no destination.`);
}
let resolveCb;
const resp = new Promise(resolve => {
resolveCb = resolve;
});
this._pendingRequests.push({
to: request.to,
message: request,
callback: resolveCb
});
this._flushRequests();
return resp;
}
/**
* Activate (send) any pending requests to actors that don't have an
* active request.
*/
_flushRequests() {
this._pendingRequests = this._pendingRequests.filter(request => {
/**
* only one active request per actor at a time
*/
if (this._activeRequests[request.to]) {
return true;
}
/**
* no active requests for this actor, so activate this one
*/
this.sendMessage(request.message);
this.expectReply(request.to, request.callback);
/**
* remove from pending requests
*/
return false;
});
}
/**
* Arrange to hand the next reply from |actor| to |handler|.
*/
expectReply(actor, handler) {
if (this._activeRequests[actor]) {
throw Error(`clashing handlers for next reply from ${actor}`);
}
this._activeRequests[actor] = handler;
}
onError(error) {
var code = error.code ? error.code : error;
this.log.error(`connection error: ${code}`);
this.emit('error', error);
}
onEnd() {
this.log.info('connection closed by server');
this.emit('end');
}
onTimeout() {
this.log.info('connection timeout');
this.emit('timeout');
}
}
exports.default = Client;
module.exports = exports["default"];
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../lib/client.js"],"names":["UNSOLICITED_EVENTS","Client","EventEmitter","constructor","host","port","incoming","Buffer","from","log","supportedDomains","_pendingRequests","_activeRequests","connect","socket","net","createConnection","on","onData","onError","onEnd","onTimeout","Promise","resolve","disconnect","destroy","unref","data","concat","readMessage","sep","toString","indexOf","count","parseInt","slice","length","packet","handleMessage","message","JSON","parse","e","error","includes","type","emit","info","callback","_flushRequests","stringify","sendMessage","to","Error","str","write","makeRequest","request","resolveCb","resp","push","filter","expectReply","actor","handler","code"],"mappings":"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","sourcesContent":["import net from 'net'\r\nimport { EventEmitter } from 'events'\r\nimport { Buffer } from 'safe-buffer'\r\n\r\nimport logger from './logger'\r\n\r\nconst UNSOLICITED_EVENTS = [\r\n    'tabNavigated', 'styleApplied', 'propertyChange', 'networkEventUpdate', 'networkEvent',\r\n    'propertyChange', 'newMutations', 'appOpen', 'appClose', 'appInstall', 'appUninstall',\r\n    'frameUpdate', 'tabListChanged'\r\n]\r\n\r\n/**\r\n * a Client object handles connecting with a Firefox remote debugging\r\n * server instance (e.g. a Firefox instance), plus sending and receiving\r\n * packets on that conection using the Firefox remote debugging protocol.\r\n *\r\n * Important methods:\r\n * connect - Create the connection to the server.\r\n * makeRequest - Make a request to the server with a JSON message,\r\n *   and a callback to call with the response.\r\n *\r\n * Important events:\r\n * 'message' - An unsolicited (e.g. not a response to a prior request)\r\n *    packet has been received. These packets usually describe events.\r\n *\r\n * This code was adapted from https://github.com/harthur/firefox-client\r\n */\r\nexport default class Client extends EventEmitter {\r\n    constructor (host, port) {\r\n        super()\r\n        this.host = host\r\n        this.port = port\r\n        this.incoming = Buffer.from('')\r\n        this.log = logger('Client')\r\n        this.supportedDomains = []\r\n\r\n        this._pendingRequests = []\r\n        this._activeRequests = {}\r\n    }\r\n\r\n    /**\r\n     * create socket connection\r\n     *\r\n     * @return {Promise}  resolves once connected to socket\r\n     */\r\n    connect () {\r\n        this.socket = net.createConnection({\r\n            host: this.host,\r\n            port: this.port\r\n        })\r\n\r\n        this.socket.on('data', ::this.onData)\r\n        this.socket.on('error', ::this.onError)\r\n        this.socket.on('end', ::this.onEnd)\r\n        this.socket.on('timeout', ::this.onTimeout)\r\n\r\n        return new Promise((resolve) => this.socket.on('connect', resolve))\r\n    }\r\n\r\n    /**\r\n     * end socket connection\r\n     */\r\n    disconnect () {\r\n        if (!this.socket) {\r\n            return\r\n        }\r\n        this.socket.destroy()\r\n        this.socket.unref()\r\n    }\r\n\r\n    /**\r\n     * Called when a new data chunk is received on the connection.\r\n     * Parse data into message(s) and call message handler for any full\r\n     * messages that are read in.\r\n     */\r\n    onData (data) {\r\n        this.incoming = Buffer.concat([this.incoming, data])\r\n        while (this.readMessage()) {}\r\n    }\r\n\r\n    /**\r\n     * Parse out and process the next message from the data read from\r\n     * the connection. Returns true if a full meassage was parsed, false\r\n     * otherwise.\r\n     */\r\n    readMessage () {\r\n        var sep = this.incoming.toString().indexOf(':')\r\n\r\n        if (sep < 0) {\r\n            return false\r\n        }\r\n\r\n        /**\r\n         * beginning of a message is preceded by byteLength(message) + \":\"\r\n         */\r\n        const count = parseInt(this.incoming.slice(0, sep))\r\n\r\n        /**\r\n         * check if response is complete\r\n         */\r\n        if (this.incoming.length - (sep + 1) < count) {\r\n            return false\r\n        }\r\n\r\n        this.incoming = this.incoming.slice(sep + 1)\r\n        const packet = this.incoming.slice(0, count)\r\n        this.incoming = this.incoming.slice(count)\r\n        this.handleMessage(packet)\r\n        return true\r\n    }\r\n\r\n    /**\r\n     * Handler for a new message coming in. It's either an unsolicited event\r\n     * from the server, or a response to a previous request from the client.\r\n     */\r\n    handleMessage (packet) {\r\n        let message\r\n\r\n        try {\r\n            message = JSON.parse(packet.toString())\r\n        } catch (e) {\r\n            return this.log.error(`Couldn't parse packet from server as JSON ${e}, message:\\n${packet}`)\r\n        }\r\n\r\n        if (!message.from) {\r\n            if (message.error) {\r\n                return this.log.error(message.message)\r\n            }\r\n\r\n            return this.log.error(`Server didn't specify an actor: ${packet}`)\r\n        }\r\n\r\n        /**\r\n         * respond to request\r\n         */\r\n        if (!UNSOLICITED_EVENTS.includes(message.type) && this._activeRequests[message.from]) {\r\n            this.emit('message', message)\r\n            this.log.info(`response: ${packet}`)\r\n            const callback = this._activeRequests[message.from]\r\n            delete this._activeRequests[message.from]\r\n            callback(message)\r\n            return this._flushRequests()\r\n        }\r\n\r\n        /**\r\n         * handle unsolicited event from server\r\n         */\r\n        if (message.type) {\r\n            // this is an unsolicited event from the server\r\n            this.log.info(`unsolicited event: ${packet}`)\r\n            return this.emit('message', message)\r\n        }\r\n\r\n        this.log.error(`Unhandled message: ${JSON.stringify(message)}`)\r\n    }\r\n\r\n    /**\r\n     * Send a JSON message over the connection to the server.\r\n     */\r\n    sendMessage (message) {\r\n        if (!message.to) {\r\n            throw new Error('No actor specified in request')\r\n        }\r\n\r\n        if (!this.socket) {\r\n            throw new Error('Not connected, connect() before sending requests')\r\n        }\r\n\r\n        let str = JSON.stringify(message)\r\n        this.emit('send', message)\r\n\r\n        /**\r\n         * message is preceded by byteLength(message):\r\n         */\r\n        str = `${(Buffer.from(str)).length}:${str}`\r\n\r\n        try {\r\n            this.socket.write(str)\r\n        } catch (e) {\r\n            this.log.error(`Couldn't set socket message: ${e.message}`)\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Set a request to be sent to an actor on the server. If the actor\r\n     * is already handling a request, queue this request until the actor\r\n     * has responded to the previous request.\r\n     *\r\n     * @param {object} request\r\n     *        Message to be JSON-ified and sent to server.\r\n     * @param {function} callback\r\n     *        Function that's called with the response from the server.\r\n     */\r\n    makeRequest (request) {\r\n        this.log.info(`request: ${JSON.stringify(request)}`)\r\n\r\n        if (!request.to) {\r\n            throw new Error(`${request.type || ''} request packet has no destination.`)\r\n        }\r\n\r\n        let resolveCb\r\n        const resp = new Promise((resolve) => { resolveCb = resolve })\r\n        this._pendingRequests.push({ to: request.to, message: request, callback: resolveCb })\r\n        this._flushRequests()\r\n\r\n        return resp\r\n    }\r\n\r\n    /**\r\n     * Activate (send) any pending requests to actors that don't have an\r\n     * active request.\r\n     */\r\n    _flushRequests () {\r\n        this._pendingRequests = this._pendingRequests.filter((request) => {\r\n            /**\r\n             * only one active request per actor at a time\r\n             */\r\n            if (this._activeRequests[request.to]) {\r\n                return true\r\n            }\r\n\r\n            /**\r\n             * no active requests for this actor, so activate this one\r\n             */\r\n            this.sendMessage(request.message)\r\n            this.expectReply(request.to, request.callback)\r\n\r\n            /**\r\n             * remove from pending requests\r\n             */\r\n            return false\r\n        })\r\n    }\r\n\r\n    /**\r\n     * Arrange to hand the next reply from |actor| to |handler|.\r\n     */\r\n    expectReply (actor, handler) {\r\n        if (this._activeRequests[actor]) {\r\n            throw Error(`clashing handlers for next reply from ${actor}`)\r\n        }\r\n        this._activeRequests[actor] = handler\r\n    }\r\n\r\n    onError (error) {\r\n        var code = error.code ? error.code : error\r\n        this.log.error(`connection error: ${code}`)\r\n        this.emit('error', error)\r\n    }\r\n\r\n    onEnd () {\r\n        this.log.info('connection closed by server')\r\n        this.emit('end')\r\n    }\r\n\r\n    onTimeout () {\r\n        this.log.info('connection timeout')\r\n        this.emit('timeout')\r\n    }\r\n}\r\n"]}