async setup() {
await super.setup();
// get the wsEndpoint
const wsEndpoint = fs.readFileSync(path.join(DIR, 'wsEndpoint'), 'utf8');
if (!wsEndpoint) {
throw new Error('wsEndpoint not found');
}
// connect to puppeteer
this.global.__BROWSER__ = await puppeteer.connect({
browserWSEndpoint: wsEndpoint,
});
const page = await this.global.__BROWSER__.newPage();
await page.setRequestInterception(true);
page.on('request', interceptedRequest => {
if (interceptedRequest.url() === 'http://pim.com/') {
interceptedRequest.respond({
contentType: 'text/html',
body: baseFile
})
}
});
await page.goto('http://pim.com');
await page.evaluate(async () => await require('pim/fetcher-registry').initialize());
this.global.__PAGE__ = page;
}
await page.evaluate(async serverConfig => {
const puppeteer = require('puppeteer');
window.cdp.close = () => {};
const browser = await puppeteer.connect({transport: window.cdp});
const page = await browser.newPage();
await page.goto(serverConfig.EMPTY_PAGE);
}, serverConfig);
async setup() {
await super.setup();
const wsEndpoint = fs.readFileSync(path.join(DIR, 'wsEndpoint'), 'utf8');
if (!wsEndpoint) {
throw new Error('wsEndpoint not found');
}
this.global.__BROWSER__ = await puppeteer.connect({
browserWSEndpoint: wsEndpoint,
});
}
module.exports = async () => {
let browser;
if (config.puppeteerWSEndpoint) {
browser = await puppeteer.connect({
browserWSEndpoint: config.puppeteerWSEndpoint,
});
} else {
browser = await puppeteer.launch(options);
}
setTimeout(async () => {
if ((await browser.process()).signalCode) {
browser.close();
}
}, 5000);
return browser;
};
await page.evaluate(async(browserWSEndpoint, serverConfig) => {
const puppeteer = require('puppeteer');
const browser = await puppeteer.connect({browserWSEndpoint});
const page = await browser.newPage();
await page.goto(serverConfig.EMPTY_PAGE);
}, browser2.wsEndpoint(), serverConfig);
(async function () {
start = site = id = lastResource = null
resources = []
data = []
var site = config.url
let browser
try {
browser = await puppeteer.connect({ browserWSEndpoint: 'ws://localhost:3000' });
const page = await browser.newPage();
await page.setRequestInterception(true);
await page.setViewport({
width: 1280,
height: 960
})
if (config.auth) {
page.authenticate({
username: config.auth[0],
password: config.auth[1]
})
}
page.on('request', function(req) {
if (isBlackListed(req.url(), config)) {
req.abort()
return
}
if (!start) {
start = Date.now();
}
req.continue()
})
page.on('load', function() {
var totalTime = (Date.now() - start);
log('TOTALTIME', totalTime);
log('RENDERTIME', totalTime - (lastResource - start));
log('TOTALRESOURCES', resources.length);
})
page.on('requestfinished', function(request) {
lastResource = Date.now();
var response = request.response()
var chain = request.redirectChain()
if (chain && chain[0]) {
// Use the statuscode for this, but the URL for the first one.
if (chain[0].url() == config.url || chain[0].url() == config.url + '/') {
request = chain[0]
log('DEBUG', 'Redirect from ' + chain[0].url() + ' detected to ' + response.url())
}
}
if (response && request.url() == config.url || request.url() == config.url + '/') {
// console.log(request.redirectChain())
log('STATUSCODE', response.status())
}
})
page.on('requestfailed', function(req) {
if (isBlackListed(req.url(), config)) {
// Not so interesting. This might for example happen when requests are
// aborted. Like analytics.
return;
}
if (req.url() === site || req.url() == site + '/') {
// Do nothing.
return;
}
log('RESOURCEERROR', JSON.stringify({
url: req.url(),
error: req.failure()
}, 4));
})
page.on('response', function(response) {
resources.push(response.url());
})
page.on('pageerror', function(e) {
log('PAGEERROR', JSON.stringify({message: e.message, trace: e.stack}));
});
page.on('console', function(msg) {
var data = msg.args()
for (let i = 0; i < data.length; ++i) {
log('CONSOLEMSG', `${i}: ${msg.args()[i]}`)
}
});
await page.goto(config.url);
var dir = 'shots/' + md5(site) + '/'
await mkdirp(dir)
var file = dir + start + '.png'
await page.screenshot({
path: file,
clip: {
x: 0,
y: 0,
width: 1280,
height: 960
}
})
log('SCREENSHOT', file)
await browser.close()
callback(null, data)
}
catch (err) {
try {
if (browser) {
await browser.close()
}
}
catch (anotherErr) {
console.log('Could not close browser')
}
callback(err)
}
})()
async function generatePdfPromisePuppeteer (url, pdfOptions) {
const browser = await puppeteer.connect({browserWSEndpoint: config.browserlessEndpoint});
const page = await browser.newPage();
if (pdfOptions.html) {
await page.setRequestInterception(true);
page.once('request', async req => {
req.respond({
body: pdfOptions.html
});
await page.setRequestInterception(false);
});
}
await page.goto(url, {waitUntil: 'networkidle2'});
const puppeteerOptions = {
printBackground: true,
pageRanges: pdfOptions.pageRanges || '',
margin: {
top: pdfOptions.marginTop ? pdfOptions.marginTop : 0 + 'mm',
bottom: pdfOptions.marginBottom ? pdfOptions.marginBottom : 0 + 'mm',
left: pdfOptions.marginLeft ? pdfOptions.marginLeft : 0 + 'mm',
right: pdfOptions.marginRight ? pdfOptions.marginRight : 0 + 'mm'
},
landscape: pdfOptions.landscape,
format: pdfOptions.format
};
if (pdfOptions.headerHtml !== undefined || pdfOptions.footerHtml !== undefined) {
puppeteerOptions.displayHeaderFooter = true;
puppeteerOptions.headerTemplate = pdfOptions.headerHtml ? pdfOptions.headerHtml : '<p></p>';
puppeteerOptions.footerTemplate = pdfOptions.footerHtml ? pdfOptions.footerHtml : '<p></p>';
}
const pdfBuffer = await page.pdf(puppeteerOptions);
await browser.close();
if (pdfOptions.coverUrl) {
// coverPdf takes no margin or header/footer options
const coverPdfOptions = {
html: pdfOptions.coverHtml,
pageRanges: '1',
format: pdfOptions.format,
landscape: pdfOptions.landscape
};
const coverBuffer = await generatePdfPromisePuppeteer(
pdfOptions.coverUrl,
coverPdfOptions
);
const pdfBaseFileName = path.join(os.tmpdir(), Math.random().toString());
const coverPdfFilename = pdfBaseFileName + '_cover.pdf';
const basePdfFilename = pdfBaseFileName + '_base.pdf';
await Promise.all([
writeFileAsync(coverPdfFilename, coverBuffer),
writeFileAsync(basePdfFilename, pdfBuffer)
]);
try {
const fullBuffer = await PDFMerge([coverPdfFilename, basePdfFilename]);
await Promise.all([
unlinkAsync(coverPdfFilename),
unlinkAsync(basePdfFilename)
]);
return fullBuffer;
} catch (err) {
log.error({event: 'concat_pdf_error', err});
return false;
}
}
return pdfBuffer;
}