Merge #11053

11053: feat: Publish platform-specific Code VSIXes r=me a=lnicola Closes #10483 CC #10371 Some notes: - we still build a plain VSIX, just in case - we build the extension on every platform to make the release workflow arguably cleaner - the Windows VSIX includes the PDB (but let's leave #10371 open until we change the Windows stand-alone release to a ZIP file) - `npm` doesn't run if started from `xtask`, possibly something related to path mapping; I moved the `npm` calls outside, but.. - the `Patch` thingy doesn't work any more, so you'll end up with a dirty `package.json` of you run `cargo xtask --client-patch-version`; I don't think we should block on this - there's an untested Alpine build; for better or worse, we special-case `musl` distros as `alpine` - I tested this as much as I could, but not the publishing and nightly updates - you can find some sample artifacts under https://github.com/lnicola/rust-analyzer/releases - we can now run the server from the install location (is Code planning to switch to compressed extensions?), except on NixOS - Code lets you install a VSIX for the wrong platform (with the results one would expect) - I don't know what happens if we try to publish a VSIX without a target This is a relatively risky, but we'll probably have to take our chances with it. r? `@rust-analyzer/review` Co-authored-by: Laurențiu Nicola <lnicola@dend.ro>
2021-12-18 21:16:19 +00:00 · 2021-12-18 21:16:19 +00:00 · b65d9c3e62
commit b65d9c3e62
parent 0dbbf14bd6 9c74f646f4
4 changed files with 104 additions and 59 deletions
--- a/.github/workflows/release.yaml
+++ b/.github/workflows/release.yaml
@ -17,6 +17,7 @@ env:
  RUSTUP_MAX_RETRIES: 10
  FETCH_DEPTH: 0 # pull in the tags for the version string
  MACOSX_DEPLOYMENT_TARGET: 10.15
+  CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc

 jobs:
  dist:
@ -25,24 +26,28 @@ jobs:
        include:
          - os: windows-latest
            target: x86_64-pc-windows-msvc
+            code-target: win32-x64
          - os: windows-latest
            target: aarch64-pc-windows-msvc
+            code-target: win32-arm64
          - os: ubuntu-20.04
            target: x86_64-unknown-linux-gnu
+            code-target: linux-x64
          - os: ubuntu-20.04
            target: aarch64-unknown-linux-gnu
-            cross_linker: aarch64-linux-gnu-gcc
+            code-target: linux-arm64
          - os: macos-11
            target: x86_64-apple-darwin
+            code-target: darwin-x64
          - os: macos-11
            target: aarch64-apple-darwin
+            code-target: darwin-arm64

    name: dist (${{ matrix.target }})
    runs-on: ${{ matrix.os }}

    env:
      RA_TARGET: ${{ matrix.target }}
-      CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: ${{ matrix.cross_linker }}

    steps:
      - name: Checkout repository
@ -77,7 +82,6 @@ jobs:
          components: rust-src

      - name: Install Node.js
-        if: matrix.target == 'x86_64-unknown-linux-gnu'
        uses: actions/setup-node@v1
        with:
          node-version: 14.x
@ -90,13 +94,21 @@ jobs:
        if: matrix.target == 'aarch64-unknown-linux-gnu'
        run: sudo apt-get install gcc-aarch64-linux-gnu

-      - name: Dist (generic)
-        if: matrix.target != 'x86_64-unknown-linux-gnu'
-        run: cargo xtask dist
+      - name: Dist
+        run: cargo xtask dist --client-patch-version ${{ github.run_number }}

-      - name: Dist (Linux)
-        if: matrix.target == 'x86_64-unknown-linux-gnu'
-        run: cargo xtask dist --client-patch-version $GITHUB_RUN_NUMBER
+      - run: npm ci
+        working-directory: editors/code
+
+      - run: npx vsce package -o "../../dist/rust-analyzer-${{ matrix.code-target }}.vsix" --target ${{ matrix.code-target }}
+        working-directory: editors/code
+
+      - if: matrix.target == 'x86_64-unknown-linux-gnu'
+        run: rm -rf editors/code/server
+
+      - if: matrix.target == 'x86_64-unknown-linux-gnu'
+        run: npx vsce package -o ../../dist/rust-analyzer.vsix
+        working-directory: editors/code

      - name: Run analysis-stats on rust-analyzer
        if: matrix.target == 'x86_64-unknown-linux-gnu'
@ -126,7 +138,7 @@ jobs:

    steps:
      - name: Install dependencies
-        run: apk add --no-cache git clang lld musl-dev
+        run: apk add --no-cache git clang lld musl-dev nodejs npm

      - name: Checkout repository
        uses: actions/checkout@v2
@ -134,7 +146,15 @@ jobs:
          fetch-depth: ${{ env.FETCH_DEPTH }}

      - name: Dist
-        run: cargo xtask dist
+        run: cargo xtask dist --client-patch-version ${{ github.run_number }}
+
+      - run: npm ci
+        working-directory: editors/code
+
+      - run: npx vsce package -o "../../dist/rust-analyzer-alpine-x64.vsix" --target alpine-x64
+        working-directory: editors/code
+
+      - run: rm -rf editors/code/server

      - name: Upload artifacts
        uses: actions/upload-artifact@v1
@ -210,4 +230,4 @@ jobs:
        if: github.ref == 'refs/heads/release'
        working-directory: ./editors/code
        # token from https://dev.azure.com/rust-analyzer/
-        run: npx vsce publish --pat ${{ secrets.MARKETPLACE_TOKEN }} --packagePath ../../dist/rust-analyzer.vsix
+        run: npx vsce publish --pat ${{ secrets.MARKETPLACE_TOKEN }} --packagePath ../../dist/rust-analyzer-*.vsix
--- a/editors/code/.gitignore
+++ b/editors/code/.gitignore
@ -1,5 +1,5 @@
 out
 node_modules
+server
 .vscode-test/
 *.vsix
-bundle
--- a/editors/code/src/main.ts
+++ b/editors/code/src/main.ts
@ -221,9 +221,18 @@ async function bootstrapExtension(config: Config, state: PersistentState): Promi
    );
    if (userResponse !== "Update") return;

-    const artifact = latestNightlyRelease.assets.find(artifact => artifact.name === "rust-analyzer.vsix");
-    assert(!!artifact, `Bad release: ${JSON.stringify(latestNightlyRelease)}`);
+    let arch = process.arch;
+    if (arch === "ia32") {
+        arch = "x64";
+    }
+    let platform = process.platform as string;
+    if (platform === "linux" && isMusl()) {
+        platform = "alpine";
+    }
+    const artifactName = `rust-analyzer-${platform}-${arch}.vsix`;

+    const artifact = latestNightlyRelease.assets.find(artifact => artifact.name === artifactName);
+    assert(!!artifact, `Bad release: ${JSON.stringify(latestNightlyRelease)}`);
    const dest = vscode.Uri.joinPath(config.globalStorageUri, "rust-analyzer.vsix");

    await downloadWithRetryDialog(state, async () => {
--- a/xtask/src/dist.rs
+++ b/xtask/src/dist.rs
@ -7,7 +7,7 @@

 use anyhow::Result;
 use flate2::{write::GzEncoder, Compression};
-use xshell::{cmd, mkdir_p, pushd, pushenv, read_file, rm_rf, write_file};
+use xshell::{cmd, cp, mkdir_p, pushd, pushenv, read_file, rm_rf, write_file};

 use crate::{date_iso, flags, project_root};

@ -16,10 +16,15 @@ pub(crate) fn run(self) -> Result<()> {
        let stable =
            std::env::var("GITHUB_REF").unwrap_or_default().as_str() == "refs/heads/release";

-        let dist = project_root().join("dist");
+        let project_root = project_root();
+        let target = Target::get(&project_root);
+        let dist = project_root.join("dist");
        rm_rf(&dist)?;
        mkdir_p(&dist)?;

+        let release_channel = if stable { "stable" } else { "nightly" };
+        dist_server(release_channel, &target)?;
+
        if let Some(patch_version) = self.client_patch_version {
            let version = if stable {
                format!("0.2.{}", patch_version)
@ -28,20 +33,24 @@ pub(crate) fn run(self) -> Result<()> {
                format!("0.3.{}", patch_version)
            };
            let release_tag = if stable { date_iso()? } else { "nightly".to_string() };
-            dist_client(&version, &release_tag)?;
+            dist_client(&version, &release_tag, &target)?;
        }
-        let release_channel = if stable { "stable" } else { "nightly" };
-        dist_server(release_channel)?;
        Ok(())
    }
 }

-fn dist_client(version: &str, release_tag: &str) -> Result<()> {
+fn dist_client(version: &str, release_tag: &str, target: &Target) -> Result<()> {
+    let bundle_path = Path::new("editors").join("code").join("server");
+    mkdir_p(&bundle_path)?;
+    cp(&target.server_path, &bundle_path)?;
+    if let Some(symbols_path) = &target.symbols_path {
+        cp(symbols_path, &bundle_path)?;
+    }
+
    let _d = pushd("./editors/code")?;
    let nightly = release_tag == "nightly";

    let mut patch = Patch::new("./package.json")?;
-
    patch
        .replace(r#""version": "0.4.0-dev""#, &format!(r#""version": "{}""#, version))
        .replace(r#""releaseTag": null"#, &format!(r#""releaseTag": "{}""#, release_tag))
@ -59,12 +68,10 @@ fn dist_client(version: &str, release_tag: &str) -> Result<()> {
    }
    patch.commit()?;

-    cmd!("npm ci").run()?;
-    cmd!("npx vsce package -o ../../dist/rust-analyzer.vsix").run()?;
    Ok(())
 }

-fn dist_server(release_channel: &str) -> Result<()> {
+fn dist_server(release_channel: &str, target: &Target) -> Result<()> {
    let _e = pushenv("RUST_ANALYZER_CHANNEL", release_channel);
    let _e = pushenv("CARGO_PROFILE_RELEASE_LTO", "thin");

@ -73,47 +80,19 @@ fn dist_server(release_channel: &str) -> Result<()> {
    //   * on Linux, this blows up the binary size from 8MB to 43MB, which is unreasonable.
    // let _e = pushenv("CARGO_PROFILE_RELEASE_DEBUG", "1");

-    let target = get_target();
-    if target.contains("-linux-gnu") || target.contains("-linux-musl") {
+    if target.name.contains("-linux-") {
        env::set_var("CC", "clang");
    }

-    cmd!("cargo build --manifest-path ./crates/rust-analyzer/Cargo.toml --bin rust-analyzer --target {target} --release").run()?;
+    let target_name = &target.name;
+    cmd!("cargo build --manifest-path ./crates/rust-analyzer/Cargo.toml --bin rust-analyzer --target {target_name} --release").run()?;

-    let suffix = exe_suffix(&target);
-    let src =
-        Path::new("target").join(&target).join("release").join(format!("rust-analyzer{}", suffix));
-    let dst = Path::new("dist").join(format!("rust-analyzer-{}{}", target, suffix));
-    gzip(&src, &dst.with_extension("gz"))?;
+    let dst = Path::new("dist").join(&target.artifact_name);
+    gzip(&target.server_path, &dst.with_extension("gz"))?;

    Ok(())
 }

-fn get_target() -> String {
-    match env::var("RA_TARGET") {
-        Ok(target) => target,
-        _ => {
-            if cfg!(target_os = "linux") {
-                "x86_64-unknown-linux-gnu".to_string()
-            } else if cfg!(target_os = "windows") {
-                "x86_64-pc-windows-msvc".to_string()
-            } else if cfg!(target_os = "macos") {
-                "x86_64-apple-darwin".to_string()
-            } else {
-                panic!("Unsupported OS, maybe try setting RA_TARGET")
-            }
-        }
-    }
-}
-
-fn exe_suffix(target: &str) -> String {
-    if target.contains("-windows-") {
-        ".exe".into()
-    } else {
-        "".into()
-    }
-}
-
 fn gzip(src_path: &Path, dest_path: &Path) -> Result<()> {
    let mut encoder = GzEncoder::new(File::create(dest_path)?, Compression::best());
    let mut input = io::BufReader::new(File::open(src_path)?);
@ -122,6 +101,41 @@ fn gzip(src_path: &Path, dest_path: &Path) -> Result<()> {
    Ok(())
 }

+struct Target {
+    name: String,
+    server_path: PathBuf,
+    symbols_path: Option<PathBuf>,
+    artifact_name: String,
+}
+
+impl Target {
+    fn get(project_root: &Path) -> Self {
+        let name = match env::var("RA_TARGET") {
+            Ok(target) => target,
+            _ => {
+                if cfg!(target_os = "linux") {
+                    "x86_64-unknown-linux-gnu".to_string()
+                } else if cfg!(target_os = "windows") {
+                    "x86_64-pc-windows-msvc".to_string()
+                } else if cfg!(target_os = "macos") {
+                    "x86_64-apple-darwin".to_string()
+                } else {
+                    panic!("Unsupported OS, maybe try setting RA_TARGET")
+                }
+            }
+        };
+        let out_path = project_root.join("target").join(&name).join("release");
+        let (exe_suffix, symbols_path) = if name.contains("-windows-") {
+            (".exe".into(), Some(out_path.join("rust_analyzer.pdb")))
+        } else {
+            (String::new(), None)
+        };
+        let server_path = out_path.join(format!("rust-analyzer{}", exe_suffix));
+        let artifact_name = format!("rust-analyzer-{}{}", name, exe_suffix);
+        Self { name, server_path, symbols_path, artifact_name }
+    }
+}
+
 struct Patch {
    path: PathBuf,
    original_contents: String,
@ -149,6 +163,8 @@ fn commit(&self) -> Result<()> {

 impl Drop for Patch {
    fn drop(&mut self) {
-        write_file(&self.path, &self.original_contents).unwrap();
+        // FIXME: find a way to bring this back
+        let _ = &self.original_contents;
+        // write_file(&self.path, &self.original_contents).unwrap();
    }
 }