289 lines
11 KiB
JavaScript
Executable File
289 lines
11 KiB
JavaScript
Executable File
#!/usr/bin/env node
|
|
|
|
import * as path from 'path';
|
|
import * as URL from 'url';
|
|
import * as fs from 'fs';
|
|
import * as http from 'http';
|
|
import * as https from 'https';
|
|
import * as os from 'os';
|
|
import * as util from 'util';
|
|
import * as child_process from 'child_process';
|
|
|
|
const existsAsync = path => new Promise(resolve => fs.stat(path, err => resolve(!err)));
|
|
|
|
const __filename = URL.fileURLToPath(import.meta.url);
|
|
const __dirname = path.dirname(__filename);
|
|
|
|
// Path to jar.mn in the juggler
|
|
const JARMN_PATH = path.join(__dirname, 'juggler', 'jar.mn');
|
|
// Workdir for Firefox repackaging
|
|
const BUILD_DIRECTORY = `/tmp/repackaged-firefox`;
|
|
// Information about currently downloaded build
|
|
const BUILD_INFO_PATH = path.join(BUILD_DIRECTORY, 'build-info.json');
|
|
// Backup OMNI.JA - the original one before repackaging.
|
|
const OMNI_BACKUP_PATH = path.join(BUILD_DIRECTORY, 'omni.ja.backup');
|
|
// Workdir to extract omni.ja
|
|
const OMNI_EXTRACT_DIR = path.join(BUILD_DIRECTORY, 'omni');
|
|
// Path inside omni.ja to juggler
|
|
const OMNI_JUGGLER_DIR = path.join(OMNI_EXTRACT_DIR, 'chrome', 'juggler');
|
|
|
|
const EXECUTABLE_PATHS = {
|
|
'ubuntu18.04': ['firefox', 'firefox'],
|
|
'ubuntu20.04': ['firefox', 'firefox'],
|
|
'mac10.13': ['firefox', 'Nightly.app', 'Contents', 'MacOS', 'firefox'],
|
|
'mac10.14': ['firefox', 'Nightly.app', 'Contents', 'MacOS', 'firefox'],
|
|
'mac10.15': ['firefox', 'Nightly.app', 'Contents', 'MacOS', 'firefox'],
|
|
'mac11': ['firefox', 'Nightly.app', 'Contents', 'MacOS', 'firefox'],
|
|
'mac11-arm64': ['firefox', 'Nightly.app', 'Contents', 'MacOS', 'firefox'],
|
|
'win32': ['firefox', 'firefox.exe'],
|
|
'win64': ['firefox', 'firefox.exe'],
|
|
};
|
|
|
|
const DOWNLOAD_URLS = {
|
|
'ubuntu18.04': 'https://playwright.azureedge.net/builds/firefox/%s/firefox-ubuntu-18.04.zip',
|
|
'ubuntu20.04': 'https://playwright.azureedge.net/builds/firefox/%s/firefox-ubuntu-20.04.zip',
|
|
'mac10.13': 'https://playwright.azureedge.net/builds/firefox/%s/firefox-mac-10.14.zip',
|
|
'mac10.14': 'https://playwright.azureedge.net/builds/firefox/%s/firefox-mac-10.14.zip',
|
|
'mac10.15': 'https://playwright.azureedge.net/builds/firefox/%s/firefox-mac-10.14.zip',
|
|
'mac11': 'https://playwright.azureedge.net/builds/firefox/%s/firefox-mac-10.14.zip',
|
|
'mac11-arm64': 'https://playwright.azureedge.net/builds/firefox/%s/firefox-mac-11.0-arm64.zip',
|
|
'win32': 'https://playwright.azureedge.net/builds/firefox/%s/firefox-win32.zip',
|
|
'win64': 'https://playwright.azureedge.net/builds/firefox/%s/firefox-win64.zip',
|
|
};
|
|
|
|
if (process.argv[2] === '--help' || process.argv[2] === '-h') {
|
|
console.log(`usage: ${path.basename(process.argv[1])} [--prepare] [build number]`);
|
|
console.log(``);
|
|
console.log(`Repackages Firefox with tip-of-tree Juggler implementation`);
|
|
process.exit(1);
|
|
}
|
|
|
|
if (process.argv[2] === '--prepare')
|
|
await prepareFirefoxBuild(process.argv[3], process.argv[4]);
|
|
else
|
|
await repackageJuggler();
|
|
|
|
async function prepareFirefoxBuild(buildNumber, buildPlatform) {
|
|
if (!buildNumber)
|
|
buildNumber = (await fs.promises.readFile(path.join(__dirname, 'BUILD_NUMBER'), 'utf8')).split('\n').shift();
|
|
if (!buildPlatform)
|
|
buildPlatform = getHostPlatform();
|
|
const currentBuildInfo = await fs.promises.readFile(BUILD_INFO_PATH).then(text => JSON.parse(text)).catch(e => ({ buildPlatform: '', buildNumber: '' }));
|
|
|
|
if (currentBuildInfo.buildPlatform === buildPlatform && currentBuildInfo.buildNumber === buildNumber)
|
|
return;
|
|
await fs.promises.rm(BUILD_DIRECTORY, { recursive: true }).catch(e => {});
|
|
await fs.promises.mkdir(BUILD_DIRECTORY);
|
|
const buildZipPath = path.join(BUILD_DIRECTORY, 'firefox.zip');
|
|
|
|
const urlTemplate = DOWNLOAD_URLS[buildPlatform];
|
|
if (!urlTemplate)
|
|
throw new Error(`ERROR: repack-juggler does not support ${buildPlatform}`);
|
|
const url = util.format(urlTemplate, buildNumber);
|
|
console.log(`Downloading Firefox r${buildNumber} for ${buildPlatform} - it might take a few minutes`);
|
|
await downloadFile(url, buildZipPath);
|
|
await spawnAsync('unzip', [ buildZipPath ], {cwd: BUILD_DIRECTORY});
|
|
await fs.promises.writeFile(BUILD_INFO_PATH, JSON.stringify({ buildNumber, buildPlatform }), 'utf8');
|
|
}
|
|
|
|
async function repackageJuggler() {
|
|
const currentBuildInfo = await fs.promises.readFile(BUILD_INFO_PATH).then(text => JSON.parse(text)).catch(e => null);
|
|
if (!currentBuildInfo) {
|
|
console.log('ERROR: build is not prepared!');
|
|
console.log(`run ${path.basename(process.argv[1])} --prepare`);
|
|
}
|
|
const {buildNumber, buildPlatform} = currentBuildInfo;
|
|
|
|
// Find all omni.ja files in the Firefox build.
|
|
const omniPaths = await spawnAsync('find', ['.', '-name', 'omni.ja'], {
|
|
cwd: BUILD_DIRECTORY,
|
|
}).then(({stdout}) => stdout.trim().split('\n').map(aPath => path.join(BUILD_DIRECTORY, aPath)));
|
|
|
|
// Iterate over all omni.ja files and find one that has juggler inside.
|
|
const omniWithJugglerPath = await (async () => {
|
|
for (const omniPath of omniPaths) {
|
|
const {stdout} = await spawnAsync('unzip', ['-Z1', omniPath], {cwd: BUILD_DIRECTORY});
|
|
if (stdout.includes('chrome/juggler'))
|
|
return omniPath;
|
|
}
|
|
return null;
|
|
})();
|
|
|
|
if (!omniWithJugglerPath) {
|
|
console.error('ERROR: did not find omni.ja file with baked in Juggler!');
|
|
process.exit(1);
|
|
} else {
|
|
if (!(await existsAsync(OMNI_BACKUP_PATH)))
|
|
await fs.promises.copyFile(omniWithJugglerPath, OMNI_BACKUP_PATH);
|
|
}
|
|
|
|
// Let's repackage omni folder!
|
|
await fs.promises.rm(OMNI_EXTRACT_DIR, { recursive: true }).catch(e => {});
|
|
await fs.promises.mkdir(OMNI_EXTRACT_DIR);
|
|
|
|
await spawnAsync('unzip', [OMNI_BACKUP_PATH], {cwd: OMNI_EXTRACT_DIR });
|
|
// Remove current juggler directory
|
|
await fs.promises.rm(OMNI_JUGGLER_DIR, { recursive: true });
|
|
// Repopulate with tip-of-tree juggler files
|
|
const jarmn = await fs.promises.readFile(JARMN_PATH, 'utf8');
|
|
const jarLines = jarmn.split('\n').map(line => line.trim()).filter(line => line.startsWith('content/') && line.endsWith(')'));
|
|
for (const line of jarLines) {
|
|
const tokens = line.split(/\s+/);
|
|
const toPath = path.join(OMNI_JUGGLER_DIR, tokens[0]);
|
|
const fromPath = path.join(__dirname, 'juggler', tokens[1].slice(1, -1));
|
|
await fs.promises.mkdir(path.dirname(toPath), { recursive: true});
|
|
await fs.promises.copyFile(fromPath, toPath);
|
|
}
|
|
|
|
await fs.promises.rm(omniWithJugglerPath);
|
|
await spawnAsync('zip', ['-0', '-qr9XD', omniWithJugglerPath, '.'], {cwd: OMNI_EXTRACT_DIR, stdio: 'inherit'});
|
|
|
|
// Output executable path to be used in test.
|
|
console.log(`
|
|
buildNumber: ${buildNumber}
|
|
buildPlatform: ${buildPlatform}
|
|
executablePath: ${path.join(BUILD_DIRECTORY, ...EXECUTABLE_PATHS[buildPlatform])}
|
|
`);
|
|
}
|
|
|
|
|
|
function httpRequest(url, method, response) {
|
|
let options = URL.parse(url);
|
|
options.method = method;
|
|
|
|
const requestCallback = res => {
|
|
if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location)
|
|
httpRequest(res.headers.location, method, response);
|
|
else
|
|
response(res);
|
|
};
|
|
const request = options.protocol === 'https:' ?
|
|
https.request(options, requestCallback) :
|
|
http.request(options, requestCallback);
|
|
request.end();
|
|
return request;
|
|
}
|
|
|
|
function downloadFile(url, destinationPath, progressCallback) {
|
|
let fulfill = ({error}) => {};
|
|
let downloadedBytes = 0;
|
|
let totalBytes = 0;
|
|
|
|
const promise = new Promise(x => { fulfill = x; });
|
|
|
|
const request = httpRequest(url, 'GET', response => {
|
|
if (response.statusCode !== 200) {
|
|
const error = new Error(`Download failed: server returned code ${response.statusCode}. URL: ${url}`);
|
|
// consume response data to free up memory
|
|
response.resume();
|
|
fulfill({error});
|
|
return;
|
|
}
|
|
const file = fs.createWriteStream(destinationPath);
|
|
file.on('finish', () => fulfill({error: null}));
|
|
file.on('error', error => fulfill({error}));
|
|
response.pipe(file);
|
|
totalBytes = parseInt(response.headers['content-length'], 10);
|
|
if (progressCallback)
|
|
response.on('data', onData);
|
|
});
|
|
request.on('error', error => fulfill({error}));
|
|
return promise;
|
|
|
|
function onData(chunk) {
|
|
downloadedBytes += chunk.length;
|
|
progressCallback(downloadedBytes, totalBytes);
|
|
}
|
|
}
|
|
|
|
function spawnAsync(cmd, args, options) {
|
|
// console.log(cmd, ...args, 'CWD:', options.cwd);
|
|
const process = child_process.spawn(cmd, args, options);
|
|
|
|
return new Promise(resolve => {
|
|
let stdout = '';
|
|
let stderr = '';
|
|
if (process.stdout)
|
|
process.stdout.on('data', data => stdout += data);
|
|
if (process.stderr)
|
|
process.stderr.on('data', data => stderr += data);
|
|
process.on('close', code => resolve({stdout, stderr, code}));
|
|
process.on('error', error => resolve({stdout, stderr, code: 0, error}));
|
|
});
|
|
}
|
|
|
|
function getUbuntuVersionSync() {
|
|
if (os.platform() !== 'linux')
|
|
return '';
|
|
try {
|
|
let osReleaseText;
|
|
if (fs.existsSync('/etc/upstream-release/lsb-release'))
|
|
osReleaseText = fs.readFileSync('/etc/upstream-release/lsb-release', 'utf8');
|
|
else
|
|
osReleaseText = fs.readFileSync('/etc/os-release', 'utf8');
|
|
if (!osReleaseText)
|
|
return '';
|
|
return getUbuntuVersionInternal(osReleaseText);
|
|
}
|
|
catch (e) {
|
|
return '';
|
|
}
|
|
}
|
|
|
|
function getUbuntuVersionInternal(osReleaseText) {
|
|
const fields = new Map();
|
|
for (const line of osReleaseText.split('\n')) {
|
|
const tokens = line.split('=');
|
|
const name = tokens.shift();
|
|
let value = tokens.join('=').trim();
|
|
if (value.startsWith('"') && value.endsWith('"'))
|
|
value = value.substring(1, value.length - 1);
|
|
if (!name)
|
|
continue;
|
|
fields.set(name.toLowerCase(), value);
|
|
}
|
|
// For Linux mint
|
|
if (fields.get('distrib_id') && fields.get('distrib_id').toLowerCase() === 'ubuntu')
|
|
return fields.get('distrib_release') || '';
|
|
if (!fields.get('name') || fields.get('name').toLowerCase() !== 'ubuntu')
|
|
return '';
|
|
return fields.get('version_id') || '';
|
|
}
|
|
|
|
function getHostPlatform() {
|
|
const platform = os.platform();
|
|
if (platform === 'darwin') {
|
|
const [major, minor] = child_process.execSync('sw_vers -productVersion', {
|
|
stdio: ['ignore', 'pipe', 'ignore']
|
|
}).toString('utf8').trim().split('.').map(x => parseInt(x, 10));
|
|
let arm64 = false;
|
|
// BigSur is the first version that might run on Apple Silicon.
|
|
if (major >= 11) {
|
|
arm64 = child_process.execSync('/usr/sbin/sysctl -in hw.optional.arm64', {
|
|
stdio: ['ignore', 'pipe', 'ignore']
|
|
}).toString().trim() === '1';
|
|
}
|
|
const LAST_STABLE_MAC_MAJOR_VERSION = 11;
|
|
// All new MacOS releases increase major version.
|
|
let macVersion = `${major}`;
|
|
if (major === 10) {
|
|
// Pre-BigSur MacOS was increasing minor version every release.
|
|
macVersion = `${major}.${minor}`;
|
|
} else if (major > LAST_STABLE_MAC_MAJOR_VERSION) {
|
|
// Best-effort support for MacOS beta versions.
|
|
macVersion = LAST_STABLE_MAC_MAJOR_VERSION + '';
|
|
}
|
|
const archSuffix = arm64 ? '-arm64' : '';
|
|
return `mac${macVersion}${archSuffix}`;
|
|
}
|
|
if (platform === 'linux') {
|
|
const ubuntuVersion = getUbuntuVersionSync();
|
|
if (parseInt(ubuntuVersion, 10) <= 19)
|
|
return 'ubuntu18.04';
|
|
return 'ubuntu20.04';
|
|
}
|
|
if (platform === 'win32')
|
|
return os.arch() === 'x64' ? 'win64' : 'win32';
|
|
return platform;
|
|
}
|