344 lines
11 KiB
Bash
Executable File
344 lines
11 KiB
Bash
Executable File
#!/bin/bash
|
|
set -euo pipefail
|
|
|
|
function log() {
|
|
local message="${1}" ; shift
|
|
local level="${1:-info}"
|
|
if [[ "${level}" == "error" ]] ; then
|
|
>&2 echo "${message}"
|
|
else
|
|
echo "${message}"
|
|
fi
|
|
}
|
|
|
|
function exit-if-ci() {
|
|
if [[ -n "${ci}" ]] ; then
|
|
log "Pre-built VS Code ${vscodeVersion}-${target}-${arch} is incorrectly built" "error"
|
|
exit 1
|
|
fi
|
|
}
|
|
|
|
# Copy code-server into VS Code along with its dependencies.
|
|
function copy-server() {
|
|
log "Applying patch"
|
|
cd "${vscodeSourcePath}"
|
|
git reset --hard
|
|
git clean -fd
|
|
git apply "${rootPath}/scripts/vscode.patch"
|
|
|
|
local serverPath="${vscodeSourcePath}/src/vs/server"
|
|
rm -rf "${serverPath}"
|
|
mkdir -p "${serverPath}"
|
|
|
|
log "Copying code-server code"
|
|
|
|
cp -r "${rootPath}/src" "${serverPath}"
|
|
cp -r "${rootPath}/typings" "${serverPath}"
|
|
cp "${rootPath}/main.js" "${serverPath}"
|
|
cp "${rootPath}/package.json" "${serverPath}"
|
|
cp "${rootPath}/yarn.lock" "${serverPath}"
|
|
|
|
if [[ -d "${rootPath}/node_modules" ]] ; then
|
|
log "Copying code-server build dependencies"
|
|
cp -r "${rootPath}/node_modules" "${serverPath}"
|
|
else
|
|
log "Installing code-server build dependencies"
|
|
cd "${serverPath}"
|
|
# Ignore scripts to avoid also installing VS Code dependencies which has
|
|
# already been done.
|
|
yarn --ignore-scripts
|
|
rm -r node_modules/@types/node # I keep getting type conflicts
|
|
fi
|
|
|
|
# TODO: Duplicate identifier issue. There must be a better way to fix this.
|
|
if [[ "${target}" == "darwin" ]] ; then
|
|
rm "${serverPath}/node_modules/fsevents/node_modules/safe-buffer/index.d.ts"
|
|
fi
|
|
}
|
|
|
|
# Prepend the nbin shim which enables finding files within the binary.
|
|
function prepend-loader() {
|
|
local filePath="${codeServerBuildPath}/${1}" ; shift
|
|
cat "${rootPath}/scripts/nbin-shim.js" "${filePath}" > "${filePath}.temp"
|
|
mv "${filePath}.temp" "${filePath}"
|
|
# Using : as the delimiter so the escaping here is easier to read.
|
|
# ${parameter/pattern/string}, so the pattern is /: (if the pattern starts
|
|
# with / it matches all instances) and the string is \\: (results in \:).
|
|
if [[ "${target}" == "darwin" ]] ; then
|
|
sed -i "" -e "s:{{ROOT_PATH}}:${codeServerBuildPath//:/\\:}:g" "${filePath}"
|
|
else
|
|
sed -i "s:{{ROOT_PATH}}:${codeServerBuildPath//:/\\:}:g" "${filePath}"
|
|
fi
|
|
}
|
|
|
|
# Copy code-server into VS Code then build it.
|
|
function build-code-server() {
|
|
copy-server
|
|
|
|
# TODO: look into making it do the full minified build for just our code
|
|
# (basically just want to skip extensions, target our server code, and get
|
|
# the same type of build you get with the vscode-linux-x64-min task).
|
|
# Something like: yarn gulp "vscode-server-${target}-${arch}-min"
|
|
log "Building code-server"
|
|
yarn gulp compile-client
|
|
|
|
rm -rf "${codeServerBuildPath}"
|
|
mkdir -p "${codeServerBuildPath}"
|
|
|
|
local json="{\"codeServerVersion\": \"${codeServerVersion}\"}"
|
|
|
|
cp -r "${vscodeBuildPath}/resources/app/extensions" "${codeServerBuildPath}"
|
|
node "${rootPath}/scripts/merge.js" "${vscodeBuildPath}/resources/app/package.json" "${rootPath}/scripts/package.json" "${codeServerBuildPath}/package.json" "${json}"
|
|
node "${rootPath}/scripts/merge.js" "${vscodeBuildPath}/resources/app/product.json" "${rootPath}/scripts/product.json" "${codeServerBuildPath}/product.json"
|
|
cp -r "${vscodeSourcePath}/out" "${codeServerBuildPath}"
|
|
rm -rf "${codeServerBuildPath}/out/vs/server/typings"
|
|
|
|
# Rebuild to make sure the native modules work since at the moment all the
|
|
# pre-built packages are from one Linux system. This means you must build on
|
|
# the target system.
|
|
log "Installing remote dependencies"
|
|
cd "${vscodeSourcePath}/remote"
|
|
if [[ "${target}" != "linux" ]] ; then
|
|
yarn --production --force
|
|
fi
|
|
cp -r "${vscodeSourcePath}/remote/node_modules" "${codeServerBuildPath}"
|
|
|
|
# Only keep the production dependencies.
|
|
cd "${codeServerBuildPath}/out/vs/server"
|
|
yarn --production --ignore-scripts
|
|
|
|
prepend-loader "out/vs/server/main.js"
|
|
prepend-loader "out/bootstrap-fork.js"
|
|
|
|
log "Final build: ${codeServerBuildPath}"
|
|
}
|
|
|
|
# Build VS Code if it hasn't already been built. If we're in the CI and it's
|
|
# not fully built, error and exit.
|
|
function build-vscode() {
|
|
if [[ ! -d "${vscodeSourcePath}" ]] ; then
|
|
exit-if-ci
|
|
log "${vscodeSourceName} does not exist, cloning"
|
|
git clone https://github.com/microsoft/vscode --quiet \
|
|
--branch "${vscodeVersion}" --single-branch --depth=1 \
|
|
"${vscodeSourcePath}"
|
|
else
|
|
log "${vscodeSourceName} already exists, skipping clone"
|
|
fi
|
|
|
|
cd "${vscodeSourcePath}"
|
|
|
|
if [[ ! -d "${vscodeSourcePath}/node_modules" ]] ; then
|
|
exit-if-ci
|
|
log "Installing VS Code dependencies"
|
|
# Not entirely sure why but there seem to be problems with native modules
|
|
# so rebuild them.
|
|
yarn --force
|
|
|
|
# Keep just what we need to keep the pre-built archive smaller.
|
|
rm -rf "${vscodeSourcePath}/test"
|
|
else
|
|
log "${vscodeSourceName}/node_modules already exists, skipping install"
|
|
fi
|
|
|
|
if [[ ! -d "${vscodeBuildPath}" ]] ; then
|
|
exit-if-ci
|
|
log "${vscodeBuildName} does not exist, building"
|
|
local builtPath="${buildPath}/VSCode-${target}-${arch}"
|
|
rm -rf "${builtPath}"
|
|
yarn gulp "vscode-${target}-${arch}-min" --max-old-space-size=32384
|
|
mkdir -p "${vscodeBuildPath}/resources/app"
|
|
# Copy just what we need to keep the pre-built archive smaller.
|
|
mv "${builtPath}/resources/app/extensions" "${vscodeBuildPath}/resources/app"
|
|
mv "${builtPath}/resources/app/"*.json "${vscodeBuildPath}/resources/app"
|
|
rm -rf "${builtPath}"
|
|
else
|
|
log "${vscodeBuildName} already exists, skipping build"
|
|
fi
|
|
}
|
|
|
|
# Download VS Code with either curl or wget depending on which is available.
|
|
function download-vscode() {
|
|
cd "${buildPath}"
|
|
if command -v wget &> /dev/null ; then
|
|
log "Attempting to download ${tarName} with wget"
|
|
wget "${vsSourceUrl}" --quiet --output-document "${tarName}"
|
|
else
|
|
log "Attempting to download ${tarName} with curl"
|
|
curl "${vsSourceUrl}" --silent --fail --output "${tarName}"
|
|
fi
|
|
}
|
|
|
|
# Download pre-built VS Code if necessary. Build if there is no available
|
|
# download but not when in the CI. The pre-built package basically just
|
|
# provides us the dependencies and extensions so we don't have to install and
|
|
# build them respectively which takes a long time.
|
|
function prepare-vscode() {
|
|
if [[ ! -d "${vscodeBuildPath}" || ! -d "${vscodeSourcePath}" ]] ; then
|
|
mkdir -p "${buildPath}"
|
|
# TODO: for now everything uses the Linux build and we rebuild the modules.
|
|
# This means you must build on the target system.
|
|
local tarName="vstar-${vscodeVersion}-${target}-${arch}.tar.gz"
|
|
local linuxTarName="vstar-${vscodeVersion}-linux-${arch}.tar.gz"
|
|
local linuxVscodeBuildName="vscode-${vscodeVersion}-linux-${arch}-built"
|
|
local vsSourceUrl="https://codesrv-ci.cdr.sh/${linuxTarName}"
|
|
if download-vscode ; then
|
|
cd "${buildPath}"
|
|
rm -rf "${vscodeBuildPath}"
|
|
tar -xzf "${tarName}"
|
|
rm "${tarName}"
|
|
if [[ "${target}" != "linux" ]] ; then
|
|
mv "${linuxVscodeBuildName}" "${vscodeBuildName}"
|
|
fi
|
|
elif [[ -n "${ci}" ]] ; then
|
|
log "Pre-built VS Code ${vscodeVersion}-${target}-${arch} does not exist" "error"
|
|
exit 1
|
|
else
|
|
log "${tarName} does not exist, building"
|
|
build-vscode
|
|
return
|
|
fi
|
|
else
|
|
log "VS Code is already downloaded or built"
|
|
fi
|
|
|
|
log "Ensuring VS Code is fully built"
|
|
build-vscode
|
|
}
|
|
|
|
function build-task() {
|
|
prepare-vscode
|
|
build-code-server
|
|
}
|
|
|
|
function vstar-task() {
|
|
local archivePath="${releasePath}/vstar-${vscodeVersion}-${target}-${arch}.tar.gz"
|
|
rm -f "${archivePath}"
|
|
mkdir -p "${releasePath}"
|
|
tar -C "${buildPath}" -czf "${archivePath}" "${vscodeSourceName}" "${vscodeBuildName}"
|
|
log "Archive: ${archivePath}"
|
|
}
|
|
|
|
function package-task() {
|
|
local archivePath="${releasePath}/${binaryName}"
|
|
rm -rf "${archivePath}"
|
|
mkdir -p "${archivePath}"
|
|
|
|
cp "${buildPath}/${binaryName}" "${archivePath}/code-server"
|
|
cp "${rootPath}/README.md" "${archivePath}"
|
|
cp "${vscodeSourcePath}/LICENSE.txt" "${archivePath}"
|
|
cp "${vscodeSourcePath}/ThirdPartyNotices.txt" "${archivePath}"
|
|
|
|
cd "${releasePath}"
|
|
if [[ "${target}" == "darwin" ]] ; then
|
|
zip -r "${binaryName}.zip" "${binaryName}"
|
|
log "Archive: ${archivePath}.zip"
|
|
else
|
|
tar -czf "${binaryName}.tar.gz" "${binaryName}"
|
|
log "Archive: ${archivePath}.tar.gz"
|
|
fi
|
|
}
|
|
|
|
# Package built code into a binary.
|
|
function binary-task() {
|
|
# I had trouble getting VS Code to build with the @coder/nbin dependency due
|
|
# to the types it installs (tons of conflicts), so for now it's a global
|
|
# dependency.
|
|
cd "${rootPath}"
|
|
npm link @coder/nbin
|
|
node "${rootPath}/scripts/nbin.js" "${target}" "${arch}" "${codeServerBuildPath}"
|
|
rm node_modules/@coder/nbin
|
|
mv "${codeServerBuildPath}/code-server" "${buildPath}/${binaryName}"
|
|
log "Binary: ${buildPath}/${binaryName}"
|
|
}
|
|
|
|
# Check if it looks like we are inside VS Code.
|
|
function in-vscode () {
|
|
log "Checking if we are inside VS Code"
|
|
local dir="${1}" ; shift
|
|
|
|
local maybeVscode
|
|
local dirName
|
|
maybeVscode="$(realpath "${dir}/../../..")"
|
|
dirName="$(basename "${maybeVscode}")"
|
|
|
|
if [[ "${dirName}" != "vscode" ]] ; then
|
|
return 1
|
|
fi
|
|
if [[ ! -f "${maybeVscode}/package.json" ]] ; then
|
|
return 1
|
|
fi
|
|
if ! grep '"name": "code-oss-dev"' "${maybeVscode}/package.json" --quiet ; then
|
|
return 1
|
|
fi
|
|
|
|
return 0
|
|
}
|
|
|
|
function ensure-in-vscode-task() {
|
|
if ! in-vscode "${rootPath}"; then
|
|
log "Not in vscode" "error"
|
|
exit 1
|
|
fi
|
|
exit 0
|
|
}
|
|
|
|
function main() {
|
|
local relativeRootPath
|
|
local rootPath
|
|
relativeRootPath="$(dirname "${0}")/.."
|
|
rootPath="$(realpath "${relativeRootPath}")"
|
|
|
|
local task="${1}" ; shift
|
|
if [[ "${task}" == "ensure-in-vscode" ]] ; then
|
|
ensure-in-vscode-task
|
|
fi
|
|
|
|
local codeServerVersion="${1}" ; shift
|
|
local vscodeVersion="${1}" ; shift
|
|
local target="${1}" ; shift
|
|
local arch="${1}" ; shift
|
|
local ci="${CI:-}"
|
|
|
|
# This lets you build in a separate directory since building within this
|
|
# directory while developing makes it hard to keep developing since compiling
|
|
# will compile everything in the build directory as well.
|
|
local outPath="${OUT:-${rootPath}}"
|
|
|
|
# If we're inside a vscode directory, assume we want to develop. In that case
|
|
# we should set an OUT directory and not build in this directory.
|
|
if in-vscode "${outPath}" ; then
|
|
log "Set the OUT environment variable to something outside of VS Code" "error"
|
|
exit 1
|
|
fi
|
|
|
|
local releasePath="${outPath}/release"
|
|
local buildPath="${outPath}/build"
|
|
|
|
local vscodeSourceName="vscode-${vscodeVersion}-source"
|
|
local vscodeBuildName="vscode-${vscodeVersion}-${target}-${arch}-built"
|
|
local vscodeSourcePath="${buildPath}/${vscodeSourceName}"
|
|
local vscodeBuildPath="${buildPath}/${vscodeBuildName}"
|
|
|
|
local codeServerBuildName="code-server${codeServerVersion}-vsc${vscodeVersion}-${target}-${arch}-built"
|
|
local codeServerBuildPath="${buildPath}/${codeServerBuildName}"
|
|
local binaryName="code-server${codeServerVersion}-vsc${vscodeVersion}-${target}-${arch}"
|
|
|
|
log "Running ${task} task"
|
|
log " rootPath: ${rootPath}"
|
|
log " outPath: ${outPath}"
|
|
log " codeServerVersion: ${codeServerVersion}"
|
|
log " vscodeVersion: ${vscodeVersion}"
|
|
log " target: ${target}"
|
|
log " arch: ${arch}"
|
|
if [[ -n "${ci}" ]] ; then
|
|
log " CI: yes"
|
|
else
|
|
log " CI: no"
|
|
fi
|
|
|
|
"${task}-task" "$@"
|
|
}
|
|
|
|
main "$@"
|