github/puppeteer
0
0
Fork 0
mirror of https://github.com/puppeteer/puppeteer synced 2024-06-14 14:02:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Introduce new interception API (#242)

Browse Source 
This patch introduces new interception API, via killing InterceptedRequest and giving the `abort` and `continue` methods to the Request object.
This commit is contained in:
Andrey Lushnikov
2017-08-11 17:24:31 -07:00
committed by GitHub
parent d793e51a9a
commit 4551afc6dc
7 changed files with 402 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

238
lib/NetworkManager.js
View File

@@ -15,6 +15,7 @@
*/
const EventEmitter = require('events');
const helper = require('./helper');
const Multimap = require('./Multimap');
class NetworkManager extends EventEmitter {
/**
@@ -23,12 +24,19 @@ class NetworkManager extends EventEmitter {
constructor(client) {
super();
this._client = client;
this._requestInterceptor = null;
/** @type {!Map<string, !Request>} */
this._idToRequest = new Map();
this._requestIdToRequest = new Map();
/** @type {!Map<string, !Request>} */
this._interceptionIdToRequest = new Map();
/** @type {!Map<string, string>} */
this._extraHTTPHeaders = new Map();
this._requestInterceptionEnabled = false;
/** @type {!Multimap<string, string>} */
this._requestHashToRequestIds = new Multimap();
/** @type {!Multimap<string, !Object>} */
this._requestHashToInterceptions = new Multimap();
this._client.on('Network.requestWillBeSent', this._onRequestWillBeSent.bind(this));
this._client.on('Network.requestIntercepted', this._onRequestIntercepted.bind(this));
this._client.on('Network.responseReceived', this._onResponseReceived.bind(this));
@@ -64,47 +72,100 @@ class NetworkManager extends EventEmitter {
}
/**
* @param {?function(!InterceptedRequest)} interceptor
* @param {boolean} value
* @return {!Promise}
*/
async setRequestInterceptor(interceptor) {
this._requestInterceptor = interceptor;
await this._client.send('Network.setRequestInterceptionEnabled', {enabled: !!interceptor});
async setRequestInterceptionEnabled(value) {
await this._client.send('Network.setRequestInterceptionEnabled', {enabled: !!value});
this._requestInterceptionEnabled = value;
}
/**
* @param {!Object} event
*/
_onRequestIntercepted(event) {
let request = new InterceptedRequest(this._client, event.interceptionId, event.request);
this._requestInterceptor(request);
if (event.redirectStatusCode) {
let request = this._interceptionIdToRequest.get(event.interceptionId);
console.assert(request, 'INTERNAL ERROR: failed to find request for interception redirect.');
this._handleRequestRedirect(request, event.redirectStatusCode, event.redirectHeaders);
this._handleRequestStart(request._requestId, event.interceptionId, event.redirectUrl, event.request);
return;
}
let requestHash = generateRequestHash(event.request);
this._requestHashToInterceptions.set(requestHash, event);
this._maybeResolveInterception(requestHash);
}
/**
* @param {!Object} event
* @param {!Request} request
* @param {number} redirectStatus
* @param {!Object} redirectHeaders
*/
_onRequestWillBeSent(event) {
if (event.redirectResponse) {
let request = this._idToRequest.get(event.requestId);
let response = new Response(this._client, request, event.redirectResponse);
request._response = response;
this.emit(NetworkManager.Events.Response, response);
this.emit(NetworkManager.Events.RequestFinished, request);
}
let request = new Request(event.requestId, event.request);
this._idToRequest.set(event.requestId, request);
_handleRequestRedirect(request, redirectStatus, redirectHeaders) {
let response = new Response(this._client, request, redirectStatus, redirectHeaders);
request._response = response;
this._requestIdToRequest.delete(request._requestId);
this._interceptionIdToRequest.delete(request._interceptionId);
this.emit(NetworkManager.Events.Response, response);
this.emit(NetworkManager.Events.RequestFinished, request);
}
/**
* @param {string} requestId
* @param {string} interceptionId
* @param {string} url
* @param {!Object} requestPayload
*/
_handleRequestStart(requestId, interceptionId, url, requestPayload) {
let request = new Request(this._client, requestId, interceptionId, url, requestPayload);
this._requestIdToRequest.set(requestId, request);
this._interceptionIdToRequest.set(interceptionId, request);
this.emit(NetworkManager.Events.Request, request);
}
/**
* @param {!Object} event
*/
_onRequestWillBeSent(event) {
if (this._requestInterceptionEnabled) {
// All redirects are handled in requestIntercepted.
if (event.redirectResponse)
return;
let requestHash = generateRequestHash(event.request);
this._requestHashToRequestIds.set(requestHash, event.requestId);
this._maybeResolveInterception(requestHash);
return;
}
if (event.redirectResponse) {
let request = this._requestIdToRequest.get(event.requestId);
this._handleRequestRedirect(request, event.redirectResponse.status, event.redirectResponse.headers);
}
this._handleRequestStart(event.requestId, null, event.request.url, event.request);
}
/**
* @param {string} requestHash
* @param {!{requestEvent: ?Object, interceptionEvent: ?Object}} interception
*/
_maybeResolveInterception(requestHash) {
const requestId = this._requestHashToRequestIds.firstValue(requestHash);
const interception = this._requestHashToInterceptions.firstValue(requestHash);
if (!requestId || !interception)
return;
this._requestHashToRequestIds.delete(requestHash, requestId);
this._requestHashToInterceptions.delete(requestHash, interception);
this._handleRequestStart(requestId, interception.interceptionId, interception.request.url, interception.request);
}
/**
* @param {!Object} event
*/
_onResponseReceived(event) {
let request = this._idToRequest.get(event.requestId);
let request = this._requestIdToRequest.get(event.requestId);
// FileUpload sends a response without a matching request.
if (!request)
return;
let response = new Response(this._client, request, event.response);
let response = new Response(this._client, request, event.response.status, event.response.headers);
request._response = response;
this.emit(NetworkManager.Events.Response, response);
}
@@ -113,13 +174,14 @@ class NetworkManager extends EventEmitter {
* @param {!Object} event
*/
_onLoadingFinished(event) {
let request = this._idToRequest.get(event.requestId);
let request = this._requestIdToRequest.get(event.requestId);
// For certain requestIds we never receive requestWillBeSent event.
// @see https://crbug.com/750469
if (!request)
return;
request._completePromiseFulfill.call(null);
this._idToRequest.delete(event.requestId);
this._requestIdToRequest.delete(event.requestId);
this._interceptionIdToRequest.delete(event.interceptionId);
this.emit(NetworkManager.Events.RequestFinished, request);
}
@@ -127,28 +189,37 @@ class NetworkManager extends EventEmitter {
* @param {!Object} event
*/
_onLoadingFailed(event) {
let request = this._idToRequest.get(event.requestId);
let request = this._requestIdToRequest.get(event.requestId);
// For certain requestIds we never receive requestWillBeSent event.
// @see https://crbug.com/750469
if (!request)
return;
request._completePromiseFulfill.call(null);
this._idToRequest.delete(event.requestId);
this._requestIdToRequest.delete(event.requestId);
this._interceptionIdToRequest.delete(event.interceptionId);
this.emit(NetworkManager.Events.RequestFailed, request);
}
}
class Request {
/**
* @param {!Connection} client
* @param {string} requestId
* @param {string} interceptionId
* @param {string} url
* @param {!Object} payload
*/
constructor(requestId, payload) {
constructor(client, requestId, interceptionId, url, payload) {
this._client = client;
this._requestId = requestId;
this._interceptionId = interceptionId;
this._interceptionHandled = false;
this._response = null;
this._completePromise = new Promise(fulfill => {
this._completePromiseFulfill = fulfill;
});
this.url = payload.url;
this.url = url;
this.method = payload.method;
this.postData = payload.postData;
this.headers = new Map(Object.entries(payload.headers));
@@ -160,25 +231,57 @@ class Request {
response() {
return this._response;
}
/**
* @param {!Object=} overrides
*/
continue(overrides = {}) {
console.assert(this._interceptionId, 'Request Interception is not enabled!');
console.assert(!this._interceptionHandled, 'Request is already handled!');
this._interceptionHandled = true;
let headers = undefined;
if (overrides.headers) {
headers = {};
for (let entry of overrides.headers)
headers[entry[0]] = entry[1];
}
this._client.send('Network.continueInterceptedRequest', {
interceptionId: this._interceptionId,
url: overrides.url,
method: overrides.method,
postData: overrides.postData,
headers: headers
});
}
abort() {
console.assert(this._interceptionId, 'Request Interception is not enabled!');
console.assert(!this._interceptionHandled, 'Request is already handled!');
this._interceptionHandled = true;
this._client.send('Network.continueInterceptedRequest', {
interceptionId: this._interceptionId,
errorReason: 'Failed'
});
}
}
helper.tracePublicAPI(Request);
class Response {
/**
* @param {!Session} client
* @param {?Request} request
* @param {!Object} payload
* @param {!Request} request
* @param {integer} status
* @param {!Object} headers
*/
constructor(client, request, payload) {
constructor(client, request, status, headers) {
this._client = client;
this._request = request;
this._contentPromise = null;
this.headers = new Map(Object.entries(payload.headers));
this.ok = payload.status >= 200 && payload.status <= 299;
this.status = payload.status;
this.statusText = payload.statusText;
this.url = payload.url;
this.headers = new Map(Object.entries(headers));
this.status = status;
this.ok = status >= 200 && status <= 299;
this.url = request.url;
}
/**
@@ -213,7 +316,7 @@ class Response {
}
/**
* @return {?Response}
* @return {!Response}
*/
request() {
return this._request;
@@ -221,52 +324,25 @@ class Response {
}
helper.tracePublicAPI(Response);
class InterceptedRequest {
/**
* @param {!Session} client
* @param {string} interceptionId
* @param {!Object} payload
*/
constructor(client, interceptionId, payload) {
this._client = client;
this._interceptionId = interceptionId;
this._handled = false;
this.url = payload.url;
this.method = payload.method;
this.headers = new Map(Object.entries(payload.headers));
this.postData = payload.postData;
}
abort() {
console.assert(!this._handled, 'This request is already handled!');
this._handled = true;
this._client.send('Network.continueInterceptedRequest', {
interceptionId: this._interceptionId,
errorReason: 'Failed'
});
}
/**
* @param {!Object} overrides
*/
continue(overrides = {}) {
console.assert(!this._handled, 'This request is already handled!');
this._handled = true;
let headers = undefined;
if (overrides.headers) {
headers = {};
for (let entry of overrides.headers.entries())
headers[entry[0]] = entry[1];
}
this._client.send('Network.continueInterceptedRequest', {
interceptionId: this._interceptionId,
url: overrides.url,
method: overrides.method,
postData: overrides.postData,
headers: headers
});
/**
* @param {!Object} request
* @return {string}
*/
function generateRequestHash(request) {
let hash = {
url: request.url,
method: request.method,
postData: request.postData,
headers: {},
};
let headers = Object.keys(request.headers);
headers.sort();
for (let header of headers) {
if (header === 'Accept' || header === 'Referer')
continue;
hash.headers[header] = request.headers[header];
}
return JSON.stringify(hash);
}
NetworkManager.Events = {