Support building and running josh on Windows

.github/workflows/rust-windows.yml

@@ -0,0 +1,77 @@
+name: rust-windows
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ '**' ]
+    types: [opened, synchronize, reopened, ready_for_review]
+  merge_group:
+
+env:
+  CARGO_TERM_COLOR: always
+  # aws-lc-sys (rustls' default provider) assembles with NASM on x86-64; the
+  # crate ships prebuilt objects behind this switch, so the runner needs no
+  # extra install. ARM64 hosts need clang-cl instead.
+  AWS_LC_SYS_PREBUILT_NASM: 1
+
+jobs:
+  windows:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { arch: x86-64, os: windows-latest }
+          - { arch: arm64, os: windows-11-arm }
+    runs-on: ${{ matrix.os }}
+    name: Windows ${{ matrix.arch }}
+    if: github.event_name != 'pull_request' || github.event.pull_request.draft == false
+    steps:
+    - name: Checkout
+      uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+    - name: Install Rust toolchain
+      uses: dtolnay/rust-toolchain@6c977a6ca4077a0ceb28ffbe03f59d46e9ac8772 # stable
+      with:
+        toolchain: stable
+    # aws-lc-sys' ARM assembly is GNU-syntax, which MSVC cannot assemble: the
+    # build then fails late in lib.exe, archiving objects that were never
+    # written. clang-cl assembles it and stays ABI-compatible with the MSVC
+    # toolchain the Rust side links with. The runner image ships it; the step
+    # reports what it found, and warns loudly if it ever has to install one.
+    - name: Use clang-cl for C dependencies
+      if: matrix.arch == 'arm64'
+      shell: pwsh
+      run: |
+        $clang = Get-Command clang-cl -ErrorAction SilentlyContinue
+        if ($clang) {
+          Write-Host "clang-cl: $($clang.Source)"
+        } else {
+          $found = Get-ChildItem "$env:ProgramFiles\Microsoft Visual Studio", "$env:ProgramFiles\LLVM" `
+            -Recurse -Filter clang-cl.exe -ErrorAction SilentlyContinue |
+            Select-Object -First 1 -ExpandProperty DirectoryName
+          if ($found) {
+            Write-Host "::warning::clang-cl was not on PATH; using $found"
+            Add-Content $env:GITHUB_PATH $found
+          } else {
+            Write-Host "::warning::the runner image no longer ships clang-cl; installing LLVM"
+            choco install llvm -y --no-progress
+            Add-Content $env:GITHUB_PATH "$env:ProgramFiles\LLVM\bin"
+          }
+        }
+        # cc-rs splits these on whitespace, so the bare name has to resolve on PATH.
+        Add-Content $env:GITHUB_ENV "CC=clang-cl"
+        Add-Content $env:GITHUB_ENV "CXX=clang-cl"
+
+    # josh-ssh-shell is unix-only (unix sockets, fifos, raw fds), so the
+    # workspace does not build here.
+    - name: Build
+      run: cargo build --locked -p josh-proxy -p josh-cli
+    # josh compose needs podman and does not run on Windows, so the .t suites
+    # are out of reach; these are the crates whose unit tests run here.
+    - name: Unit tests
+      run: cargo test --locked -p josh-core -p josh-filter -p josh-gix-ext -p josh-git-serde -p josh-search -p josh-memodb
+    # Drives the built binaries, since the .t suites cannot run here: the CLI
+    # against a local repository, and josh-proxy against a git server hosted by
+    # HttpListener, so the job needs nothing that Windows does not ship.
+    - name: Functional tests
+      run: pwsh tests/windows/run.ps1 target/debug -PathForms

Cargo.toml

@@ -78,6 +78,8 @@ serde_json = "1.0.151"
 serde_yaml = "0.9.34"
 toml = "1.1.4"
 tracing-subscriber = { version = "0.3.23", features = ["env-filter"] }
+dunce = "1.0.5"
+socket2 = "0.6.3"
 tempfile = "3.27.0"
 hex = "0.4.3"
 secret-vault-value = "^1"

cq/josh-cq/Cargo.toml

@@ -14,6 +14,7 @@ anyhow.workspace = true
 serde.workspace = true
 serde_json.workspace = true
 git2.workspace = true
+gix-hash.workspace = true
 axum.workspace = true
 tracing.workspace = true
 

cq/josh-cq/src/cq.rs

@@ -68,7 +68,7 @@ pub fn handle_track(
         url,
         None,
         "HEAD",
-        fetched_commit,
+        josh_core::objects::gix_oid(fetched_commit),
         josh_core::objects::CommitData::read(transaction.odb(), head.commit)?.tree_id()?,
         link_mode,
     )?

cq/josh-cq/src/remote.rs

@@ -1,13 +1,14 @@
 use anyhow::Context;
 use anyhow::anyhow;
+use std::str::FromStr;
 
 use std::collections::BTreeMap;
 use std::process::Command;
 
 /// List refs from a remote repository using git ls-remote
 ///
 /// Returns a map of ref names to their OIDs
-pub fn list_refs(url: &str) -> anyhow::Result<BTreeMap<String, git2::Oid>> {
+pub fn list_refs(url: &str) -> anyhow::Result<BTreeMap<String, gix_hash::ObjectId>> {
     let output = Command::new("git")
         .args(["ls-remote", url])
         .output()
@@ -19,12 +20,12 @@ pub fn list_refs(url: &str) -> anyhow::Result<BTreeMap<String, git2::Oid>> {
     }
 
     let stdout = String::from_utf8(output.stdout)?;
-    let refs: BTreeMap<String, git2::Oid> = stdout
+    let refs: BTreeMap<String, gix_hash::ObjectId> = stdout
         .lines()
         .filter_map(|line| {
             let parts: Vec<&str> = line.split('\t').collect();
             if parts.len() == 2 {
-                let oid = git2::Oid::from_str(parts[0]).ok()?;
+                let oid = gix_hash::ObjectId::from_str(parts[0]).ok()?;
                 Some((parts[1].to_string(), oid))
             } else {
                 None

devtools/josh-test-support/src/bench.rs

@@ -33,12 +33,12 @@ pub fn random_string(rng: &mut StdRng, len: usize) -> String {
 pub fn build_index(
     repo: &git2::Repository,
     sig: &git2::Signature,
-    heads: &[git2::Oid],
-) -> Result<git2::Oid> {
+    heads: &[gix::ObjectId],
+) -> Result<gix::ObjectId> {
     let empty_tree = repo.find_tree(repo.treebuilder(None)?.write()?)?;
     let parents = heads
         .iter()
-        .map(|oid| repo.find_commit(*oid))
+        .map(|oid| repo.find_commit(git2_oid(*oid)))
         .collect::<Result<Vec<_>, _>>()?;
     let parent_refs = parents.iter().collect::<Vec<_>>();
     let index = repo.commit(
@@ -49,7 +49,7 @@ pub fn build_index(
         &empty_tree,
         &parent_refs,
     )?;
-    Ok(index)
+    Ok(gix_oid(index))
 }
 
 /// Rebuild, with plain git2 tree walking (no josh code), the tree a pattern filter must produce:
@@ -60,10 +60,10 @@ pub fn build_index(
 /// `require_literal_leading_dot`; a glob-based predicate is exact regardless).
 pub fn expected_tree(
     repo: &git2::Repository,
-    head: git2::Oid,
+    head: gix::ObjectId,
     keep: &dyn Fn(&str) -> bool,
-) -> Result<(git2::Oid, usize)> {
-    let tree = repo.find_commit(head)?.tree()?;
+) -> Result<(gix::ObjectId, usize)> {
+    let tree = repo.find_commit(git2_oid(head))?.tree()?;
     let mut kept: Vec<(String, git2::Oid, i32)> = vec![];
     tree.walk(git2::TreeWalkMode::PreOrder, |root, entry| {
         if entry.kind() == Some(git2::ObjectType::Blob) {
@@ -85,5 +85,5 @@ pub fn expected_tree(
         };
         builder.upsert(path.as_str(), mode, gix_oid(*oid))?;
     }
-    Ok((git2_oid(builder.write()?.detach()), kept.len()))
+    Ok((builder.write()?.detach(), kept.len()))
 }

devtools/josh-test-support/src/provision_repo.rs

@@ -20,7 +20,7 @@ pub struct ProvisionedRepo {
     pub repo: git2::Repository,
     /// The head oid the callback produced (always equal to the `expected` that
     /// was passed to [`provision_repo`]).
-    pub head: git2::Oid,
+    pub head: gix::ObjectId,
 }
 
 impl ProvisionedRepo {
@@ -46,11 +46,11 @@ impl ProvisionedRepo {
 /// new `expected`.
 pub fn provision_repo<C>(
     testcase: &str,
-    expected: &git2::Oid,
+    expected: &gix::ObjectId,
     callback: C,
 ) -> Result<ProvisionedRepo>
 where
-    C: FnMut(&git2::Repository) -> Result<git2::Oid>,
+    C: FnMut(&git2::Repository) -> Result<gix::ObjectId>,
 {
     let expected = *expected;
     let cache_root = cache_root_for(testcase)?;
@@ -71,17 +71,19 @@ fn cache_root_for(testcase: &str) -> Result<PathBuf> {
 }
 
 /// A cached repo is reusable if it opens as a bare repo and contains `expected`.
-fn cache_hit(cache_root: &Path, expected: git2::Oid) -> bool {
+fn cache_hit(cache_root: &Path, expected: gix::ObjectId) -> bool {
     let Ok(repo) = git2::Repository::open_bare(cache_root) else {
         return false;
     };
-    repo.odb().map(|odb| odb.exists(expected)).unwrap_or(false)
+    repo.odb()
+        .map(|odb| odb.exists(crate::bench::git2_oid(expected)))
+        .unwrap_or(false)
 }
 
 /// Build `testcase` from scratch into `cache_root`, erasing any prior cache.
-fn rebuild<C>(cache_root: &Path, expected: git2::Oid, callback: &mut C) -> Result<()>
+fn rebuild<C>(cache_root: &Path, expected: gix::ObjectId, callback: &mut C) -> Result<()>
 where
-    C: FnMut(&git2::Repository) -> Result<git2::Oid>,
+    C: FnMut(&git2::Repository) -> Result<gix::ObjectId>,
 {
     if cache_root.exists() {
         std::fs::remove_dir_all(cache_root)
@@ -130,7 +132,7 @@ where
 }
 
 /// Copy the canonical cached repo into a fresh tempdir and open it.
-fn copy_to_tempdir(cache_root: &Path, expected: git2::Oid) -> Result<ProvisionedRepo> {
+fn copy_to_tempdir(cache_root: &Path, expected: gix::ObjectId) -> Result<ProvisionedRepo> {
     let tmp = tempfile::tempdir().context("creating tempdir for repo copy")?;
     copy_dir_recursive(cache_root, tmp.path())
         .with_context(|| format!("copying {} to tempdir", cache_root.display()))?;

docs/src/SUMMARY.md

@@ -29,5 +29,6 @@
 # Contributing
 - [Testing](./contributing/testing.md)
 - [Development tools](./contributing/dev-tools.md)
+- [Windows](./contributing/windows.md)
 - [josh run](./contributing/josh-run.md)
 - [Tracing]()