Skip to content

Format times without humantime, and cache apt archives in dylint - #25

Open
vinniefalco wants to merge 2 commits into
cppalliance:masterfrom
vinniefalco:master
Open

vinniefalco wants to merge 2 commits into
cppalliance:masterfrom
vinniefalco:master

Conversation

@vinniefalco

@vinniefalco vinniefalco commented Nov 19, 2026 •

Copy link
Copy Markdown
Member

This pull request has two commits that are independent of each other. They share a pull request because both come from the master branch of the fork.

  1. Format the workspace's times without humantime. A small formatter from the standard library takes the place of the crate, and the stopgap entry in deny.toml goes.
  2. Cache the Tauri system packages in the dylint job. The apt step of that job takes about 20 minutes since 2026-11-18 and fails about half of the runs, on this pull request's first commit too. The second commit keeps the downloaded archives in an Actions cache.

Each part below describes one commit.

1. Format the workspace's times without humantime

The workspace used one function of humantime to stamp a time. This pull request writes that text with the standard library alone and removes the crate.

Why

  • The advisory RUSTSEC-2026-0542 marks humantime as unmaintained. It reports no vulnerability, and it says that no safe upgrade is available.
  • deny.toml denies an unmaintained crate that the workspace depends on directly, so cargo deny check failed. Pin the Harness at 4afed45f and contract 0.5 #24 accepted the advisory in deny.toml as a stopgap.
  • The owner decided to write a small formatter. This pull request does that, and the stopgap entry goes.

The formatter

  • The new module crates/workshop/workspace/src/rfc3339.rs has rfc3339_of_seconds, which takes whole seconds since the Unix epoch and returns YYYY-MM-DDTHH:MM:SSZ. now_rfc3339 reads the clock and calls it. now_rfc3339 was in workspace_file/actor.rs, and its two callers change only their import.
  • The date comes from Howard Hinnant's civil_from_days algorithm, which a comment cites: https://howardhinnant.github.io/date_algorithms.html#civil_from_days
  • From 1970-01-01T00:00:00Z through 9999-12-31T23:59:59Z the text is what humantime::format_rfc3339_seconds gave.
  • Two rules cover a clock outside those years. humantime panicked in both cases, and the new code panics on no input.
    • A clock before the Unix epoch reads as the epoch, 1970-01-01T00:00:00Z.
    • A year past 9999 prints with every digit it has, as in 10000-01-01T00:00:00Z. That is not an RFC 3339 text.
  • Nothing parses the text. It is the created_at value of a workspace file, which this repository writes and never reads, and the added_at of each grant, which is stored and read back as text.

How it was proved equal to humantime

Before the crate was removed, a throwaway test compared the new function with humantime::format_rfc3339_seconds for 9,557,899 values, and all were equal. The test is not in this pull request.

  • Every day boundary from 1970 through 9999, each with the second before it and the second after it: 8,798,690 values over 2,932,897 days.
  • Every second of three whole days, which are the first day, February 29 of 2000, and the last day: 259,200 values. Both formatters take the date from the day number alone and the time from the second of the day alone, so every date together with every time of day covers every second of the range.
  • The last second of the range and the eight values that the kept tests pin: 9 values.
  • 500,000 times spread across the range from a fixed seed, each with a part of a second.

The tests that stay pin fixed values with no dependency: eight times, among them both ends of the leap day of 2000 and the two sides of the end of February 2100, and the two rules. Each expected text was checked against humantime in the run above.

What left the manifests

  • Cargo.toml: the line humantime = "2".
  • crates/workshop/workspace/Cargo.toml: the line humantime.workspace = true.
  • Cargo.lock: the humantime 2.4.0 package and its line in the dependencies of workshop-workspace. No other crate needed it, and no other line of the lock changed.
  • deny.toml: the entry for RUSTSEC-2026-0542 and its comment. The list is ignore = [] again, as it was before pull request 24.

What was run here

All of this ran on Windows, on the final tree, with the pinned toolchain 1.99.1.

  • cargo fmt --all --check: pass.
  • The clippy job's command and the check-workshop job's clippy command, with CARGO_BUILD_WARNINGS=deny: pass.
  • The test job's cargo nextest run: 709 passed, 1 skipped.
  • The check-workshop job's test command, with its stub Gateway staged before and removed after: 514 passed, 4 skipped.
  • The docs job's cargo doc and the check-workshop job's cargo doc, with RUSTDOCFLAGS=-D warnings: pass.
  • cargo deny check and cargo deny --log-level error check, with ignore = []: pass. Advisories, bans, licenses, and sources are all ok.
  • cargo audit: exit code 0, with 13 allowed warnings where there were 14. humantime is not among them.
  • The check for one rustls backend: ring is not in the Workshop binary's closure on Windows.
  • cargo dylint --all -- --locked --workspace --all-targets --all-features: pass.
  • cargo test -p build-xtask: 86 passed.
  • node --test crates/workshop/ui/test/docs-claims.mjs: 2 passed.

What was not run

  • The ui job. This pull request changes no file of the UI.
  • check-workshop-linux, and the Linux runs of every other job. No job runs on macOS.

What no test covers

  • A system clock that is set before 1970 or past the year 9999. The tests pin both rules on the two functions that now_rfc3339 calls.
  • A comparison with another formatter. The kept tests pin fixed values.

2. Cache the Tauri system packages in the dylint job

The problem

The dylint job installs the Tauri system packages with apt on ubuntu-24.04. Since 2026-11-18 that one step takes about 20 minutes, and its limit was 20 minutes, so the job fails about half the time.

  • The four runs since 2026-11-18 took 1164, 1183, 1212, and 1213 seconds against a limit of 1200. Two passed and two failed. One of the failures is the run for the push of 956e7800 to master.
  • The eight runs of 2026-11-13 and 2026-11-14 took 24 to 53 seconds.
  • The log of a slow run shows Need to get 69.7 MB of archives. and then Fetched 69.7 MB in 19min 9s (60.7 kB/s). Every archive came from us-east-2.ec2.archive.ubuntu.com, with no error and no retry. The package lists arrived fast in the same run: Fetched 12.9 MB in 2s.
  • ci-green fails when dylint fails, so this blocks pull requests.

The cause

The cause is the runner image, not this repository. actions/runner-images issue 14823 reports the same thing for the same packages: Fetched 74.8 MB in 20min 17s (61.5 kB/s). The image tells apt to leave a mirror only when no data arrives for 15 seconds. A mirror that sends data slowly never trips that, so apt stays on it. The issue is open and has no fix from GitHub.

The job cannot move to ubuntu-22.04, because the prebuilt cargo-dylint and dylint-link need glibc 2.38 or later. In the same minute as a slow dylint run, check-workshop-linux on ubuntu-22.04 fetched 52.4 MB in 2 seconds from another mirror.

What this changes

Only the dylint job of ci.yml changes. Its one install step becomes four steps, and the job keeps the downloaded archives (the .deb files) in an Actions cache, so that apt downloads only the archives the cache lacks.

  1. List the archives of the Tauri system packages. It runs apt-get update, and then asks apt which archives it would download, with apt-get install --print-uris. It writes one line for each archive: the file name, the size, and the SHA-256. The cache key is dylint-apt-archives- and a hash of that sorted list. The key leaves the addresses out, because the mirror differs from runner to runner.
  2. Restore the archives of the Tauri system packages. This is actions/cache/restore@v6 with that key, and with restore-keys: dylint-apt-archives-, so that a run whose list is new starts from the newest older cache.
  3. Install Tauri system packages. It checks each restored file against the list and copies the files that pass into apt's archive directory. Then apt-get install --download-only downloads the rest. Then the step fills the cache directory again with exactly the listed archives, and installs.
  4. Save the archives of the Tauri system packages. This is actions/cache/save@v6. It is a step of its own before the lint, so that a run whose lint fails still saves. It runs only when the restore was not an exact hit and the cache directory holds every listed archive.

The package names now sit in one variable of the job, TAURI_APT_PACKAGES, because two steps hand them to apt.

The hash check

apt checks the hash of an archive that it downloads. It does not check an archive that is already in its archive directory: when that file has the expected size, apt uses it as it is. This is in pkgAcqArchive in apt-pkg/acquire-item.cc of apt 2.7.14. So a restored file must not reach that directory unchecked.

  • The list step takes the SHA-256 of each archive from apt, which reads it from the signed package index. With --print-uris apt prints the MD5 sum unless it is told otherwise, so the step passes -o Acquire::ForceHash=sha256.
  • The install step copies a restored file into apt's directory only when its SHA-256 or SHA-512 is the one in the list. A file with a wrong hash, a file that is not in the list, and a file whose line in the list has no SHA-256 or SHA-512 are all left out. apt downloads those archives itself and checks them as it always does.
  • Before the save, the step empties the cache directory and fills it from apt's directory with the listed archives only, and it checks each one against the list again. So this job never saves a file that it did not check.
  • When a restored file has a wrong hash, the step prints a warning that says to delete that cache. A cache cannot be replaced under the same key, so this is the one case that needs a person.

A run with no cache

It does what the job did before. The restore finds nothing, apt downloads every archive and checks it, and the packages are installed. From a slow mirror that still takes about 20 minutes, one time. The run then saves the cache, and the runs after it do not download.

A problem with the cache costs time and does not fail the job:

  • A listing that fails gives a warning and an empty list, and the run uses no cache.
  • The restore and save steps have continue-on-error: true. A restore that fails, or that runs past its limit, is a run with no cache. A save that fails changes nothing else.
  • A damaged file fails the hash check, and apt downloads that archive again.

The job can still fail where it could fail before: when apt-get update, the download, or the install fails or runs past its limit.

The time limits

  • The install step fails after 30 minutes, where it failed after 20. A full download at the rate of the slow runs takes about 20 minutes, and that is why half of the runs failed. A run with no cache has to finish one time for a cache to exist, so its limit must be clear of 20 minutes. With 30 minutes a full download of 69.7 MB finishes at any rate above about 40 kB/s, and a mirror that sends nothing still ends the step.
  • The list step fails after 10 minutes. It holds apt-get update, which took 2 seconds in the slow runs. The same 12.9 MB at 60 kB/s would take under 4 minutes.
  • The restore and save steps fail after 10 minutes each, so a cache service that does not answer cannot hold the job. Both have continue-on-error: true, so the job goes on.

Who can read and write the cache

This is from the dependency caching reference of GitHub.

  • A run for a push to master saves into the scope of master. Every branch and every pull request can restore that cache, and that includes pull requests from forks.
  • A run for a pull request looks in its own merge ref first and then in its base branch. It saves into its own merge ref (refs/pull/N/merge) only. master and other pull requests cannot restore that cache.
  • So a pull request from a fork can read the cache of master, and it cannot write a cache that master or another pull request reads. And a file from any cache is used only when it has the hash from apt's index.

One cache is about 70 MB. A new key appears when Ubuntu publishes a new version of a listed package. GitHub removes a cache that no run has used for 7 days.

What does not change

  • check-workshop-linux and the Linux builds of the Bundle workflow install the same packages. They are as they were.
  • The other steps of dylint are as they were and in the same order. The workflow has no new job, so the list of jobs in ci-green is as it was.
  • The mirror is the one the image gives the job.
  • The only new actions are actions/cache/restore and actions/cache/save, which are GitHub's own, at the current major version v6. They use the same Actions cache that Swatinem/rust-cache already uses in this job.

What was checked on a Windows machine

These checks ran locally, before the change first ran on a GitHub runner:

  • The workflow parses as YAML. The dylint job has its old steps in the old order, with the four new steps in the place of the old install step. No other job differs from master.
  • bash -n accepts every run: script of the job, in the bash 5.3.15 of Git for Windows and in bash 5.3.9 on Ubuntu under WSL.
  • A dry run of the two new scripts, started the way GitHub starts them (bash --noprofile --norc -eo pipefail), with stand-ins for sudo, apt-get, and apt-config. The stand-in for apt-get accepts a file in its directory by size alone, as apt does. 20 cases with 75 checks passed in Git Bash, and 19 cases with 73 checks passed in WSL. The cases:
    • a restored file with the right hash: apt does not download it
    • a restored file with the right name and size and a wrong hash: it is not handed to apt, apt downloads the archive, and the warning is printed
    • a restored file that is not in the list: it never reaches apt, and it is gone from the cache directory before the save
    • a list entry with no file: apt downloads that one archive and no other
    • names with %3a and with +
    • a hash of a kind the script does not check, and a list where every hash is an MD5 sum: such a file is not taken from the cache and is not saved
    • an empty cache directory, and no cache directory: apt downloads everything and the step succeeds
    • a line with a SHA-512
    • an exact hit: apt downloads nothing and nothing is saved
    • a listing that fails: a warning, an empty list, and an install as before
    • a download that fails: the step fails with the exit code of apt, as before
    • an install that removes the archives afterwards: the cache directory still holds them
    • lines of the listing in an unexpected form, a directory and a symbolic link under listed names, a cache directory outside the temp directory of the runner, a missing list, nothing to download, and an apt-config that fails
    • the key: it is the same for another mirror and another order of lines, and it differs for another size or another hash
  • The list script against the real apt-get install --print-uris of Ubuntu 26.04 under WSL (apt 3.2.0), a command that changes nothing on the system: 188 archives, each with a SHA-256, 23 names with %3a, and no line that the script could not read.
  • node --test crates/workshop/ui/test/docs-claims.mjs passes.

The Rust checks were not run, because the change touches no Rust.

What the two runs on this pull request showed

The second commit ran twice on GitHub's runners, in CI run 44444496865: one time with no cache, and one more time as a re-run of the dylint job alone.

The first run, with no cache. Image ubuntu-24.04 version 20261111.127.1, mirror us-east-2.ec2.archive.ubuntu.com.

Step Time Lines of the log
List 28 s apt would download 163 archives, and 163 of them have a hash this job checks.
Restore under 1 s Cache not found for input keys: dylint-apt-archives-a4fc0f72492983bc8b1db0492c362e04c748950edbb088da0d64b7134e76a25c, dylint-apt-archives-
Install 9 min 2 s 0 archives come from the cache.
Need to get 69.7 MB of archives.
Fetched 69.7 MB in 8min 37s (135 kB/s)
The cache directory holds 163 of the 163 archives to cache.
Save 3 s Cache saved with key: dylint-apt-archives-a4fc0f72492983bc8b1db0492c362e04c748950edbb088da0d64b7134e76a25c

The re-run of the job. Image ubuntu-24.04 version 20261111.370.1, mirror azure.archive.ubuntu.com.

Step Time Lines of the log
List 7 s apt would download 163 archives, and 163 of them have a hash this job checks.
Restore 2 s Cache restored from key: dylint-apt-archives-a4fc0f72492983bc8b1db0492c362e04c748950edbb088da0d64b7134e76a25c
Install 14 s 163 archives come from the cache.
Need to get 0 B/69.7 MB of archives.
The cache directory holds 163 of the 163 archives to cache.
Save skipped

What the two runs show:

  • The apt of the runner prints its listing in the form the script reads. Neither run printed a warning.
  • actions/cache saves and restores a directory under the temp directory of the runner.
  • A pull request from a fork can save a cache. The cache list of the repository has one cache with that key, 69,685,906 bytes, in the scope refs/pull/25/merge.
  • The key is the same on two runners that use two different mirrors.
  • With the cache, apt downloads nothing. The log of the re-run has no Fetched line for the archives.

What they do not show:

  • How much time the cache saves on a slow mirror. The re-run got a runner with a fast mirror, so its 14 seconds are not a fair comparison with the 9 minutes of the first run. The proof is that apt had nothing to download.
  • A run on master. After the merge, the first run on master downloads everything one more time, because master cannot read the cache of a pull request. That run saves the cache that later pull requests start from.
  • A run whose list differs from the list of the newest cache, and a restored file with a wrong hash. Only the dry run covers those two.

The whole dylint job took 14 minutes in the first run and 2 minutes 22 seconds in the re-run. Part of that difference is the cargo cache, which the first run also had to fill.

Summary by CodeRabbit

  • Improvements
    • Workspace timestamps use UTC RFC 3339 formatting with whole-second precision. Times before the Unix epoch display as the epoch, and years beyond 9999 retain all digits.
    • Timestamp formatting handles leap days, the year 2100 boundary, and very large time values.
  • Chores
    • Removed an unused time-formatting dependency.

The advisory `RUSTSEC-2026-0542` marks `humantime` as unmaintained, and the workspace used one function of it, `format_rfc3339_seconds`, to stamp a time. The new module `rfc3339.rs` writes that text with the standard library alone, and `now_rfc3339` moves there from `actor.rs`. The dependency is removed, and so is the `deny.toml` entry that accepted the advisory.

- `rfc3339_of_seconds` takes whole seconds since the Unix epoch as a `u64` and returns `YYYY-MM-DDTHH:MM:SSZ`. `now_rfc3339` reads the clock and calls it through `rfc3339_of`, so the tests pin exact texts with no clock.
- The date comes from the `civil_from_days` algorithm of Howard Hinnant, and a comment cites its address. The arithmetic is unsigned, because no day is before 1970.
- A clock before the Unix epoch reads as the epoch, `1970-01-01T00:00:00Z`. The old code panicked there.
- A time after `9999-12-31T23:59:59Z` prints its year with every digit it has, as in `10000-01-01T00:00:00Z`, which is no RFC 3339 text. The old code panicked there too. The count `u64::MAX` formats.
- The time is stored as text, and `actor.rs` reads the time of a grant back as text. It parses none.
- The `ignore` list of `deny.toml` is `ignore = []` again, and cargo-deny passes without the entry.
- `Cargo.lock` loses the `humantime` package and its line in the dependencies of the workspace crate. No other line of it changes.
- The tests pin eight fixed times from 1970 through 9999, among them both ends of a leap day and the two sides of the end of February 2100, and each of the two rules. No test compares the text with `humantime`, and no test sets the system clock outside those years.
Copilot AI balanced review requested due to automatic review settings November 19, 2026 01:11

@claude claude Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Claude Code Review

This pull request is from a fork — automated review is disabled. A repository maintainer can comment @claude review to run a one-time review.

@coderabbitai

coderabbitai Bot commented Nov 19, 2026 •

Copy link
Copy Markdown

Explain Change →

No actionable comments were generated in the recent review.

Walkthrough

The workspace adds an internal UTC RFC 3339 formatter at whole-second precision and uses it for actor timestamps. The workspace removes the humantime dependency and its advisory exception. The CI dylint job adds verified caching for Tauri system package archives.

Changes: Workspace timestamp formatting

Layer / File(s) Summary
RFC 3339 formatter and tests
crates/workshop/workspace/src/lib.rs, crates/workshop/workspace/src/rfc3339.rs, crates/workshop/workspace/src/rfc3339-tests.rs
A private module formats timestamps as UTC RFC 3339 text at whole-second precision. It treats pre-epoch times as the epoch and preserves all year digits beyond 9999. Tests cover calendar boundaries, subsecond truncation, pre-epoch times, expanded years, and current-time formatting.
Actor wiring and dependency removal
crates/workshop/workspace/src/workspace_file/actor.rs, crates/workshop/workspace/src/workspace.rs, crates/workshop/workspace/src/workspace_file.rs, Cargo.toml, crates/workshop/workspace/Cargo.toml, deny.toml
The actor imports now_rfc3339 from the new module, replacing its local formatter. The workspace removes humantime and its advisory exception.

CI package archive caching

Layer / File(s) Summary
List, verify, install, and cache packages
.github/workflows/ci.yml
The dylint job lists package archives and derives a cache key from their metadata. It restores and verifies archives before installation, then saves the cache only when all listed hashable archives are verified.

Estimated code review effort: 4 (Complex) | ~45 minutes

Sequence Diagram(s)

sequenceDiagram
  participant DylintJob
  participant Apt
  participant ArchiveCache
  DylintJob->>Apt: list package archive metadata
  DylintJob->>ArchiveCache: restore using archive-list digest
  DylintJob->>Apt: install requested packages with verified archives
  DylintJob->>ArchiveCache: save when cache is complete
Loading

Possibly related PRs

Merge Risk: Minimal · up to 7c729

This change swaps an external timestamp formatter for an internal one that is meant to produce the same output, and adds verified package caching to a CI job. No concrete defects were found, so merge risk is minimal. The CI caching steps have not been run on a Linux runner yet.

Pre-merge checks: Passed 4

Check name Status Explanation
Title check Passed The title names two changes: formatting times without humantime (the main change, replacing humantime with a std-library RFC 3339 formatter in rfc3339.rs, removing the dependency and deny.toml excepti…
Linked Issues check Passed Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check Passed Check skipped because no linked issues were found for this pull request.
Description Check Passed Check skipped - CodeRabbit’s high-level summary is enabled.
Full details: Title check

Explanation

The title names two changes: formatting times without humantime (the main change, replacing humantime with a std-library RFC 3339 formatter in rfc3339.rs, removing the dependency and deny.toml exception) and caching apt archives in the dylint CI job (a real, secondary change in ci.yml). The title is specific and matches the changeset, so it passes. It does not cover every detail, which is acceptable.

Finishing Touches

Generate unit tests (beta)

  • Create a new PR
  • Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts
Recent review info

Run configuration

  • Source mode: Auto
  • Repository: Unavailable
  • Branch: Unavailable
  • File: No configuration file from this repository applied
  • Commit: Unavailable
  • Layers: defaults
  • Review profile: CHILL
  • Plan: Essentials
  • Run ID: 27576b0b-3488-4f29-86aa-6788dae08231
Commits

Reviewing files that changed from the base of the PR and between 9b1219e and 7c729cd.

Files selected for processing: 1

  • .github/workflows/ci.yml

Included review availability: This review used your included allowance. 3 included reviews remain after this review. Your included PR review attempts over the past 7 days set your current allowance at 4 reviews per hour.

Copilot AI left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🟢 Approval recommended

No active review issues block the change replacing the unmaintained timestamp dependency with a standard-library formatter.

No open issues 🎉

What changed in this PR

Replaces humantime with a standard-library formatter for Workshop’s workspace timestamps, removing the unmaintained dependency and the advisory exception introduced in PR #24.

Changes:

  • Adds UTC whole-second formatting with explicit behavior before the Unix epoch and after year 9999.
  • Adds fixed-value tests for leap dates, fractional-second truncation, and out-of-range timestamps.
  • Redirects timestamp callers and removes humantime from manifests, the lockfile, and advisory exceptions.
File Description
deny.toml Removes the temporary humantime advisory exception.
crates/​workshop/​workspace/​src/​workspace.rs Imports the new timestamp helper.
crates/​workshop/​workspace/​src/​workspace_file/​actor.rs Uses the new helper and removes the old implementation.
crates/​workshop/​workspace/​src/​workspace_file.rs Removes the old helper re-export.
crates/​workshop/​workspace/​src/​rfc3339.rs Implements timestamp formatting using the standard library.
crates/​workshop/​workspace/​src/​rfc3339-tests.rs Tests date conversion, precision, and boundary behavior.
crates/​workshop/​workspace/​src/​lib.rs Registers the formatter module.
crates/​workshop/​workspace/​Cargo.toml Removes the crate’s humantime dependency.
Cargo.toml Removes the shared humantime dependency declaration.
Cargo.lock Removes humantime and its dependency reference.

Review effort: Balanced

On the `ubuntu-24.04` image apt can download the archives of the Tauri packages at about 60 kB/s, which is 20 minutes for 70 MB and was the limit of the step (actions/runner-images#14823). Four steps of the `dylint` job now keep those archives in an Actions cache: one lists what apt would download and makes the cache key, `actions/cache/restore@v6` restores, the install step hands the restored files to apt and fills the cache directory again, and `actions/cache/save@v6` saves. A run whose cache holds every archive downloads nothing.

- apt takes an archive that is already in its directory when the size is right, and it checks no hash of it. So the install step copies a restored file there only when its SHA-256 or SHA-512 is the one apt listed, and apt downloads every other archive itself.
- apt lists the MD5 sum of an archive by default, so the list step asks for the SHA-256 with `-o Acquire::ForceHash=sha256`. An archive that is listed with no SHA-256 or SHA-512 is never cached.
- The cache key is a hash of the names, sizes, and hashes of the listed archives, sorted, without their addresses, because the mirror differs from runner to runner. `restore-keys` lets a run with a new list start from the cache of an older one.
- A run with no cache does what the job did before: apt downloads every archive and installs it. A listing that fails, a restore that fails, and a restored file with a wrong hash each cost time and do not fail the job.
- The save step is a step of its own before the lint, so a run whose lint fails still saves. It runs only when the restore was no exact hit and `cache-complete` is true, because a cache is never replaced and an incomplete one would stay incomplete.
- The install step fails after 30 minutes, where it failed after 20, because a slow download of every archive takes about 20 and a run with no cache must finish once. The list step, which now holds `apt-get update`, fails after 10 minutes, and so does each cache step.
- The other jobs that install these packages, one in this workflow and the Linux builds of the Bundle workflow, do not change. The workflow gains no job.
- The diff adds no test. Only a CI run executes these steps.
Copilot AI balanced review requested due to automatic review settings November 19, 2026 02:27
@vinniefalco vinniefalco changed the title Format the workspace's times without humantime Format times without humantime, and cache apt archives in dylint Nov 19, 2026

Copilot AI left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🔵 Needs a closer look

The apt-cache workflow has only mocked and WSL validation; real ubuntu-24.04 GitHub runner cold-cache and exact-hit runs are needed to verify archive handling, cache save/restore, and reuse without downloads.

No open issues 🎉

Review effort: Balanced

Copilot AI left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🟢 Approval recommended

No active review issues are recorded for the timestamp formatter replacement and CI caching changes.

No open issues 🎉

Review effort: Balanced

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants