Next

.github/workflows/ci.yml

@@ -6,100 +6,61 @@ on:
 
 jobs:
   lint:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-      - name: Set up Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: 3.2
-          bundler-cache: true
-      - name: Linting
-        run: bundle exec standardrb --no-fix
-
-  test:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-      - name: Set up Ruby
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: '3.2'
-          bundler-cache: true
-      - name: test
-        run: bundle exec rspec spec
-
-  integration_test:
-    runs-on: pub-hk-ubuntu-22.04-xlarge
-    strategy:
-      matrix:
-        stack: ["heroku-20", "heroku-22"]
-        version: ["3.1.4"]
+    runs-on: ubuntu-24.04
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-      - name: Output CHANGELOG
-        run: bin/print_changelog "${{matrix.version}}"
-      - name: Build Docker image
-        run: bin/activate_docker "${{matrix.stack}}"
-      - name: Build and package Ruby runtime
-        run: bin/build_ruby "${{matrix.stack}}" "${{matrix.version}}"
-      - name: Verify ruby executable and output rubygems version
-        run: bin/print_summary "${{matrix.stack}}" "${{matrix.version}}" | tee $GITHUB_STEP_SUMMARY
+      - name: Update Rust toolchain
+        # Most of the time this will be a no-op, since GitHub releases new images every week
+        # which include the latest stable release of Rust, Rustup, Clippy and rustfmt.
+        run: rustup update
+      - name: Rust Cache
+        uses: Swatinem/[email protected]
+      - name: Clippy
+        # Using --all-targets so tests are checked and --deny to fail on warnings.
+        # Not using --locked here and below since Cargo.lock is in .gitignore.
+        run: cargo clippy --all-targets --all-features -- --deny warnings
+      - name: rustfmt
+        run: cargo fmt -- --check
+      - name: Check docs
+        # Using RUSTDOCFLAGS until `cargo doc --check` is stabilised:
+        # https://github.com/rust-lang/cargo/issues/10025
+        run: RUSTDOCFLAGS="-D warnings" cargo doc --all-features --document-private-items --no-deps
 
-  integration_test-heroku-24-amd:
-    runs-on: pub-hk-ubuntu-22.04-xlarge
-    strategy:
-      matrix:
-        stack: ["heroku-24"]
-        version: ["3.2.3"]
+  unit-test:
+    runs-on: ubuntu-24.04
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-      - name: Output CHANGELOG
-        run: bin/print_changelog "${{matrix.version}}"
-      - name: Build Docker image
-        run: bin/activate_docker "${{matrix.stack}}"
-      - name: Build and package Ruby runtime
-        run: bin/build_ruby "${{matrix.stack}}" "${{matrix.version}}"
-      - name: Verify ruby executable and output rubygems version
-        run: bin/print_summary "${{matrix.stack}}" "${{matrix.version}}" amd64 | tee $GITHUB_STEP_SUMMARY
+      - name: Update Rust toolchain
+        run: rustup update
+      - name: Rust Cache
+        uses: Swatinem/[email protected]
+      - name: Run unit tests
+        run: cargo test --all-features
 
-  integration_test-heroku-24-arm:
-    runs-on: pub-hk-ubuntu-22.04-arm-large
+  integration_test:
+    runs-on: ${{ matrix.arch == 'arm64' && 'pub-hk-ubuntu-22.04-arm-medium' || 'ubuntu-latest' }}
     strategy:
       matrix:
-        stack: ["heroku-24"]
+        base_image: ["heroku-20", "heroku-22", "heroku-24"]
         version: ["3.2.3"]
+        arch: ["arm64", "amd64"]
+        exclude:
+          - base_image: "heroku-20"
+            arch: "arm64"
+          - builder: "heroku-22"
+            arch: "arm64"
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-      # Docker (and other tools) are not present on the early-access runners.
-      # We must install them manually: https://github.com/github-early-access/arm-runners-beta
-      - name: Install docker
-        run: |
-          bin/setup_docker_ci
-
-          sudo usermod -aG docker $USER
-          sudo apt-get install acl
-          sudo setfacl --modify user:$USER:rw /var/run/docker.sock
-      # AWS CLI (and other tools) are not present on the early-access runners.
-      # We must install them manually: https://github.com/github-early-access/arm-runners-beta
-      - name: Install AWS CLI
-        run: | # https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html
-          sudo apt-get install -y unzip
-          curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip" -o "awscliv2.zip"
-          unzip awscliv2.zip
-          sudo ./aws/install
-      - name: Verify AWS installed correctly
-        run: aws --version
+      - name: Update Rust toolchain
+        run: rustup update
+      - name: Rust Cache
+        uses: Swatinem/[email protected]
       - name: Output CHANGELOG
         run: bin/print_changelog "${{matrix.version}}"
-      - name: Build Docker image
-        run: bin/activate_docker "${{matrix.stack}}"
-      - name: Build and package Ruby runtime
-        run: bin/build_ruby "${{matrix.stack}}" "${{matrix.version}}"
-      - name: Verify ruby executable and output rubygems version
-        run: bin/print_summary "${{matrix.stack}}" "${{matrix.version}}" arm64 | tee $GITHUB_STEP_SUMMARY
+      - name: Build Ruby
+        run: cargo run --bin build_ruby -- --version ${{matrix.version}} --base-image ${{matrix.base_image}} --arch ${{matrix.arch}}
+      - name: Check Ruby
+        run: cargo run --bin check_ruby -- --version ${{matrix.version}} --base-image ${{matrix.base_image}} --arch ${{matrix.arch}}

build_ruby/src/main.rs

@@ -32,7 +32,8 @@ enum Error {
     CannotRunCmd(CmdError),
 }
 
-fn ruby_dockerfile_contents(distro_number: &str) -> String {
+fn ruby_dockerfile_contents(base_image: &BaseImage) -> String {
+    let distro_number = base_image.distro_number();
     let mut dockerfile = String::new();
     dockerfile.push_str(&format!("FROM heroku/heroku:{distro_number}-build\n"));
     dockerfile.push_str(indoc! {r#"
@@ -69,25 +70,27 @@ fn source_dir() -> PathBuf {
 }
 
 fn build_ruby(args: &RubyArgs) -> Result<(), Error> {
-    let arch = &args.arch;
+    let RubyArgs {
+        arch,
+        version,
+        base_image,
+    } = args;
 
     let mut log = Print::new(std::io::stdout()).h1("Building Ruby");
-    let cache = source_dir().join("cache");
-    let output = source_dir().join("output");
-    let base_image = &args.base_image;
-    let distro_number = base_image.distro_number();
+    let volume_cache_dir = source_dir().join("cache");
+    let volume_output_dir = source_dir().join("output");
 
     let temp_dir = tempfile::tempdir().map_err(Error::CreateTmpDir)?;
     let image_name = format!("heroku/ruby-builder:{base_image}");
-    let dockerfile = ruby_dockerfile_contents(distro_number);
-    let docker_path = temp_dir.path().join("Dockerfile");
+    let dockerfile = ruby_dockerfile_contents(base_image);
+    let dockerfile_path = temp_dir.path().join("Dockerfile");
 
     log = {
         let mut stream = log
             .bullet("Dockerfile")
             .start_stream("Writing contents to tmpdir");
         write!(stream, "{dockerfile}").unwrap();
-        fs_err::write(&docker_path, dockerfile).map_err(Error::CannotWriteDockerfile)?;
+        fs_err::write(&dockerfile_path, dockerfile).map_err(Error::CannotWriteDockerfile)?;
         stream.done().done()
     };
 
@@ -98,7 +101,7 @@ fn build_ruby(args: &RubyArgs) -> Result<(), Error> {
         docker_build.args(["--platform", &format!("linux/{arch}")]);
         docker_build.args(["--progress", "plain"]);
         docker_build.args(["--tag", &image_name]);
-        docker_build.args(["--file", &docker_path.display().to_string()]);
+        docker_build.args(["--file", &dockerfile_path.display().to_string()]);
         docker_build.arg(source_dir().to_str().expect("Path to str"));
         let _ = bullet
             .stream_with(
@@ -112,10 +115,8 @@ fn build_ruby(args: &RubyArgs) -> Result<(), Error> {
 
     log = {
         let mut bullet = log.bullet("Ruby binaries");
-        let outside_cache = cache.display();
-        let outside_output = output.display();
-        let version = &args.version;
-        let base_image = &args.base_image;
+        let outside_cache = volume_cache_dir.display();
+        let outside_output = volume_output_dir.display();
 
         let mut docker_run = Command::new("docker");
         docker_run.arg("run");