Readers never wait for a push or gc 7c06f5b28ade

            // Writers wait while the last pass copies (readers carry on),

            // so the refs copied name only objects copied (#249).

            let guard = store.write_guard(&name).await;

    Read(#[allow(dead_code)] crate::repos::ReadGuard),

    Write(#[allow(dead_code)] crate::repos::WriteGuard),

use tokio::sync::{OwnedMutexGuard, OwnedRwLockReadGuard, OwnedRwLockWriteGuard, RwLock};

/// A repository's locks (oxygenhub#249). Readers never wait for a push or

/// a gc: the store gives every handle one head and finds what a repack

/// moved (oxy-core, "readers never wait"). Writers take `writer` in turn;

/// everyone holds `life` shared, and only deleting or moving the

/// repository holds it alone.

#[derive(Default)]

struct Locks {

    life: Arc<RwLock<()>>,

    writer: Arc<tokio::sync::Mutex<()>>,

}

/// A reader's hold: the repository is not deleted or moved under it.

pub type ReadGuard = OwnedRwLockReadGuard<()>;

/// A writer's hold: no other writer runs, and the repository stays put.

/// Readers carry on.

pub struct WriteGuard {

    _writer: OwnedMutexGuard<()>,

    _life: OwnedRwLockReadGuard<()>,

}

/// Deleting or moving a repository: nothing else runs on it.

pub type ExclusiveGuard = OwnedRwLockWriteGuard<()>;

    locks: Mutex<HashMap<String, Arc<Locks>>>,

    /// fork's owner sets their own. Runs under the source's writer lock, so

    /// no push lands while its files are linked.

        let guard = self.write_guard(src).await;

    fn lock(&self, name: &RepoName) -> Arc<Locks> {

    /// Read while `f` runs on the blocking pool: never waiting for a

    /// writer, only for the repository being deleted or moved.

        let guard = self.read_guard(name).await;

    /// Write while `f` runs on the blocking pool, after the writers ahead.

        let guard = self.write_guard(name).await;

    }

    /// The writer's hold alone, for callers that open the repository

    /// themselves (the protocol server's push, a backup's last pass). The

    /// writer lock first, so a writer queued behind others holds nothing a

    /// delete would wait for.

    pub async fn write_guard(&self, name: &RepoName) -> WriteGuard {

        let locks = self.lock(name);

        let writer = locks.writer.clone().lock_owned().await;

        WriteGuard { _writer: writer, _life: locks.life.clone().read_owned().await }

    pub async fn read_guard(&self, name: &RepoName) -> ReadGuard {

        self.lock(name).life.clone().read_owned().await

    /// Deleting or moving the repository: waits for every reader and

    /// writer, and holds off new ones.

    pub async fn exclusive_guard(&self, name: &RepoName) -> ExclusiveGuard {

        self.lock(name).life.clone().write_owned().await

        let _guard = app.repos.exclusive_guard(&repo).await;

    let _guard = app.wikis.exclusive_guard(&repo).await;

    let _guard = app.repos.exclusive_guard(&repo).await;

    // Packed: the store has no loose objects; their files stay retired for

    // an hour, for readers that listed them before the repack (#249).

    let loose_after = Repo::open(&app.repos.dir(&repo)).unwrap().store().loose_count().unwrap();

    // Andy pushes both: his handle reads the head again first, to see

    // the agent's commit from the other handle (oxygenhub#249).

    client.refresh().unwrap();

/// Readers never wait (oxygenhub#249): a page, the API and a fetch's refs

/// answer while a writer (a push, a gc) holds the repository; writers take

/// turns; deleting or moving it waits for everyone and holds off newcomers.

#[tokio::test(flavor = "multi_thread")]

async fn reads_do_not_wait_for_a_writer() {

    use std::time::Duration;

    let h = hub().await;

    create(&h.app, "andy", "demo").await;

    let work = tempfile::tempdir().unwrap();

    let c = client(&format!("{}/andy/demo", h.base), work.path());

    write(work.path(), "a.txt", "a\n");

    c.commit("A change", &[]).unwrap();

    assert!(c.push("origin", false).unwrap().iter().all(|r| r.ok));

    let name = RepoName::parse("andy/demo").unwrap();

    let writer = h.app.repos.write_guard(&name).await;

    for path in ["/andy/demo", "/andy/demo/changes/main", "/api/v1/repos/andy/demo/bookmarks"] {

        let (st, body) = tokio::time::timeout(Duration::from_secs(10), call(&h.app, "GET", path, None, None))

            .await

            .unwrap_or_else(|_| panic!("{path} waited for the writer"));

        assert_eq!(st, StatusCode::OK, "{path}: {body}");

    }

    let refs = tokio::time::timeout(Duration::from_secs(10), call(&h.app, "POST", "/andy/demo/oxy/v1/refs", Some("site"), None)).await;

    assert!(refs.is_ok(), "a fetch's refs waited for the writer");

    assert!(tokio::time::timeout(Duration::from_millis(300), h.app.repos.write_guard(&name)).await.is_err(), "writers take turns");

    assert!(tokio::time::timeout(Duration::from_millis(300), h.app.repos.exclusive_guard(&name)).await.is_err(), "a delete waits");

    drop(writer);

    let all = tokio::time::timeout(Duration::from_secs(5), h.app.repos.exclusive_guard(&name)).await.expect("then it runs");

    assert!(

        tokio::time::timeout(Duration::from_millis(300), h.app.repos.read_guard(&name)).await.is_err(),

        "nothing reads a repository being deleted"

    );

    drop(all);

}

3. Page and API handlers resolve `{owner}/{name}` to a `RepoHandle`, check the viewer's role, and run every `oxy-core` call inside `spawn_blocking` under the repository's locks (§16.2: readers never wait for writers).

Every `oxy-core` call runs on the blocking pool. **Readers never wait** (oxygenhub#249): each repository has a writer lock that pushes, gc, landings, web edits, Diffusion bumps, Flow's blobs, mirror exports, forks and a backup's last pass take in turn, and a lifecycle lock that everyone holds shared and only deleting or moving the repository holds alone. Page and API reads and fetches take only the shared lifecycle lock, so a push or a gc never holds them up: the store gives each handle one head for its life and finds what a repack moved (a reload and a retry on a miss; repacks retire what they replace for an hour before it is deleted; Oxygen spec §13.4). `oxy-core` itself is single-threaded per `Repo`, so a `Repo` is opened per request and dropped after; store handles are cheap to open because packs are memory mapped.