Forks 07b1a5bbf481

-- Forks (hub spec §4): the repository a fork was made from.

ALTER TABLE repositories ADD COLUMN forked_from INTEGER REFERENCES repositories(id) ON DELETE SET NULL;

CREATE INDEX repositories_forks ON repositories (forked_from) WHERE forked_from IS NOT NULL;

//! Forks (hub spec §4): making one, listing them, and proposing from one

//! back to the repository it came from.

use super::settings::{csrf, require};

use super::{filters, lookup, Error, Page, RepoShell, Shell};

use crate::auth::{roles, Viewer};

use crate::db::{self, accounts};

use crate::repos::RepoName;

use crate::Shared;

use askama::Template;

use axum::extract::{Form, Path, State};

use axum::response::{IntoResponse, Redirect, Response};

use serde::Deserialize;

#[derive(Template)]

#[template(path = "fork_new.html")]

pub struct ForkPage {

    shell: Shell,

    repo: RepoShell,

    owners: Vec<String>,

    name: String,

    error: Option<String>,

}

pub async fn form(State(app): State<Shared>, viewer: Viewer, Path((owner, name)): Path<(String, String)>) -> Result<Page<ForkPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/fork"), &viewer);

    let me = require(&viewer, &shell)?;

    let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let owners = super::repo_settings::owners_for(&app, &me.account).await;

    Ok(Page(ForkPage { repo: RepoShell::new(&app, &row, "code").with_role(role), shell, owners, name, error: None }))

}

#[derive(Deserialize)]

pub struct ForkForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    owner: String,

    name: String,

}

/// Anyone who can read a repository may fork it under an owner they may

/// create repositories for; the fork keeps the source's visibility.

pub async fn create(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Form(f): Form<ForkForm>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/fork"), &viewer);

    let me = require(&viewer, &shell)?;

    csrf(&viewer, &f.csrf_token, &shell)?;

    let (source, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let owners = super::repo_settings::owners_for(&app, &me.account).await;

    let page = |msg: &str| {

        Page(ForkPage {

            shell: shell.clone(),

            repo: RepoShell::new(&app, &row, "code").with_role(role),

            owners: owners.clone(),

            name: f.name.clone(),

            error: Some(msg.into()),

        })

        .into_response()

    };

    let Some(dest) = RepoName::new(f.owner.trim(), f.name.trim()) else {

        return Ok(page("A repository name is letters, digits, dots, dashes and underscores."));

    };

    if dest == source {

        return Ok(page("Pick another owner or name: a repository cannot be its own fork."));

    }

    if !roles::may_create_under(&app.db, &me.account, &dest.owner).await.map_err(|e| Error::from_db(shell.clone(), e))? {

        return Ok(page("You cannot create repositories under that owner."));

    }

    if db::repos::get(&app.db, &dest.owner, &dest.name).await.map_err(|e| Error::from_db(shell.clone(), e))?.is_some()

        || app.repos.exists(&dest)

    {

        return Ok(page("That repository exists."));

    }

    app.repos.fork(&source, &dest).await.map_err(|e| Error::from_repo(shell.clone(), e))?;

    let created = db::repos::create(&app.db, &dest.owner, &dest.name, &row.description, row.visibility())

        .await

        .map_err(|e| Error::from_db(shell.clone(), e))?;

    db::repos::set_forked_from(&app.db, created.id, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    accounts::audit(&app.db, Some(&me.account), "repo.forked", &dest.to_string(), &source.to_string()).await.ok();

    Ok(Redirect::to(&dest.url()).into_response())

}

#[derive(Template)]

#[template(path = "forks.html")]

pub struct ForksPage {

    shell: Shell,

    repo: RepoShell,

    forks: Vec<db::repos::RepoRow>,

}

pub async fn list(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

) -> Result<Page<ForksPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/forks"), &viewer);

    let (_, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let all = db::repos::forks_of(&app.db, row.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let forks = super::home::visible(&app, &shell, &viewer, all).await?;

    Ok(Page(ForksPage { repo: RepoShell::new(&app, &row, "code").with_role(role), shell, forks }))

}

/// What the overview says about forks: where this one came from (when the

/// viewer may see it) and how many forks it has.

pub struct ForkInfo {

    pub upstream: Option<db::repos::RepoRow>,

    pub forks: usize,

}

pub async fn info(app: &Shared, shell: &Shell, viewer: &Viewer, row: &db::repos::RepoRow) -> ForkInfo {

    let upstream = match row.forked_from {

        Some(id) => match db::repos::get_by_id(&app.db, id).await {

            Ok(Some(up)) => super::home::visible(app, shell, viewer, vec![up]).await.ok().and_then(|mut v| v.pop()),

            _ => None,

        },

        None => None,

    };

    let forks = match db::repos::forks_of(&app.db, row.id).await {

        Ok(all) => super::home::visible(app, shell, viewer, all).await.map(|v| v.len()).unwrap_or(0),

        Err(_) => 0,

    };

    ForkInfo { upstream, forks }

}

{% extends "base.html" %}

{% import "repo_tabs.html" as m %}

{% block title %}Fork {{ repo.owner }}/{{ repo.name }}{% endblock %}

{% block tabs %}{% call m::tabs(repo, "code") %}{% endblock %}

{% block content %}

<div class="head"><h1>Fork <small>{{ repo.owner }}/{{ repo.name }}</small></h1></div>

{% if let Some(e) = error %}<p class="error">{{ e }}</p>{% endif %}

<form class="card" method="post" action="{{ repo.url }}/fork">

  <input type="hidden" name="_csrf" value="{{ shell.csrf }}">

  <label for="owner">Owner</label>

  <select id="owner" name="owner">{% for o in owners %}<option value="{{ o }}">{{ o }}</option>{% endfor %}</select>

  <label for="name">Name</label><input type="text" id="name" name="name" value="{{ name }}" required>

  <p class="small mute">The fork is a repository of its own, with every change and bookmark of this one and the same visibility. Its trust policy starts empty. Propose its changes back here from its page.</p>

  <button type="submit">FORK</button>

</form>

{% endblock %}

{% extends "base.html" %}

{% import "repo_tabs.html" as m %}

{% block title %}Forks · {{ repo.owner }}/{{ repo.name }}{% endblock %}

{% block tabs %}{% call m::tabs(repo, "code") %}{% endblock %}

{% block content %}

<div class="head"><h1>Forks <small>{{ forks.len() }}</small></h1></div>

{% if forks.is_empty() %}<p class="empty">No forks you can see.</p>{% else %}

<ul class="rows repos">

{% for r in forks %}

  <li>

    <div><img class="avatar xs" src="/avatar/{{ r.owner }}" alt=""> <a class="name" href="/{{ r.owner }}/{{ r.name }}"><span class="mute">{{ r.owner }} /</span> <strong>{{ r.name }}</strong></a>{% if r.visibility != "public" %} <span class="tag">{{ r.visibility }}</span>{% endif %}</div>

    <div class="right small">updated <time title="{{ r.updated_ms|when_i }}">{{ r.updated_ms|ago_i }}</time></div>

  </li>

{% endfor %}

</ul>

{% endif %}

{% endblock %}

    /// The repository this one was forked from (migration 0009).

    #[sqlx(default)]

    pub forked_from: Option<i64>,

/// Record that `id` is a fork of `from`.

pub async fn set_forked_from(pool: &Pool, id: i64, from: i64) -> sqlx::Result<()> {

    sqlx::query("UPDATE repositories SET forked_from = ? WHERE id = ?").bind(from).bind(id).execute(pool).await?;

    Ok(())

}

/// The forks of `id`, newest activity first.

pub async fn forks_of(pool: &Pool, id: i64) -> sqlx::Result<Vec<RepoRow>> {

    sqlx::query_as("SELECT * FROM repositories WHERE forked_from = ? ORDER BY updated_ms DESC").bind(id).fetch_all(pool).await

}

    /// Fork `src` into `dest` (hub spec §4): a new bare repository with its

    /// own id, the source's objects hard-linked where the file system allows

    /// (copied otherwise; objects are immutable, so sharing them is safe),

    /// and the source's bookmarks. The trust policy is not copied: the

    /// fork's owner sets their own. Runs under the source's read lock.

    pub async fn fork(&self, src: &RepoName, dest: &RepoName) -> Result<(), RepoError> {

        let guard = self.lock(src).read_owned().await;

        let (from, to) = (self.dir(src), self.dir(dest));

        if !self.exists(src) {

            return Err(RepoError::NotFound);

        }

        if to.exists() {

            return Err(RepoError::Exists(dest.to_string()));

        }

        tokio::task::spawn_blocking(move || {

            let _guard = guard;

            let made = (|| -> Result<(), RepoError> {

                drop(Repo::init_bare(&to)?);

                let objects = |d: &Path| d.join(oxy_core::repo::OXY_DIR).join("objects");

                link_tree(&objects(&from), &objects(&to))?;

                let source = Repo::open(&from)?;

                let fork = Repo::open(&to)?;

                let existing: Vec<String> = fork.bookmarks()?.into_iter().map(|b| b.name).collect();

                for b in source.bookmarks()? {

                    if existing.contains(&b.name) {

                        fork.bookmark_set(&b.name, &b.heads)?;

                    } else {

                        fork.bookmark_create(&b.name, Some(&b.heads))?;

                    }

                }

                Ok(())

            })();

            if made.is_err() {

                let _ = std::fs::remove_dir_all(&to);

            }

            made

        })

        .await

        .map_err(|e| RepoError::Io(std::io::Error::other(e.to_string())))?

    }

/// Hard-link every file under `from` into the same place under `to`,

/// copying when a link is not possible (another file system). Temporary

/// files of writers in progress are skipped.

fn link_tree(from: &Path, to: &Path) -> std::io::Result<()> {

    std::fs::create_dir_all(to)?;

    for e in std::fs::read_dir(from)? {

        let e = e?;

        let name = e.file_name();

        let n = name.to_string_lossy();

        if n.starts_with("tmp-") || n.starts_with("sigs-tmp-") || n.contains(".tmp") {

            continue;

        }

        let (src, dst) = (e.path(), to.join(&name));

        if e.file_type()?.is_dir() {

            link_tree(&src, &dst)?;

        } else if !dst.exists() && std::fs::hard_link(&src, &dst).is_err() {

            std::fs::copy(&src, &dst)?;

        }

    }

    Ok(())

}

pub(crate) async fn visible(

    app: &Shared,

    shell: &Shell,

    viewer: &Viewer,

    rows: Vec<db::repos::RepoRow>,

) -> Result<Vec<db::repos::RepoRow>, Error> {

mod forks;

        .route("/{owner}/{name}/fork", get(forks::form).post(forks::create))

        .route("/{owner}/{name}/forks", get(forks::list))

    fork: super::forks::ForkInfo,

    let fork = super::forks::info(&app, &shell, &viewer, &row).await;

    Ok(Page(OverviewPage { shell, repo: rs, o, readme_html, watching, latest_release, quickstart, fork }))

pub(crate) async fn owners_for(app: &Shared, me: &accounts::Account) -> Vec<String> {

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

async fn fork_and_propose_upstream() {

    let h = hub().await;

    let app = &h.app;

    let andy = register(app, "andy").await;

    let bob = register(app, "bob").await;

    app.repos.create(&RepoName::parse("andy/demo").unwrap(), None).unwrap();

    db::repos::create(&app.db, "andy", "demo", "The demo", hub_api::Visibility::Public).await.unwrap();

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

    let mut client = Repo::init(work.path()).unwrap();

    client.config.set("remote.hub.url", &format!("{}/andy/demo", h.base)).unwrap();

    client.config.set("remote.hub.token", "site").unwrap();

    client.save_config().unwrap();

    write(work.path(), "README.md", b"# demo\n");

    client.commit("first", &[]).unwrap();

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

    // Bob forks it; he cannot fork into Andy's name.

    let page = get(app, "/andy/demo", Some(&bob)).await;

    assert!(page.body.contains("/andy/demo/fork"), "a fork button: {}", page.body);

    let csrf = csrf_of(&get(app, "/andy/demo/fork", Some(&bob)).await.body);

    let r = post(app, "/andy/demo/fork", Some(&bob), &format!("_csrf={csrf}&owner=andy&name=other")).await;

    assert!(r.body.contains("cannot create repositories under that owner"), "{}", r.body);

    let r = post(app, "/andy/demo/fork", Some(&bob), &format!("_csrf={csrf}&owner=bob&name=demo")).await;

    assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);

    assert_eq!(r.location.as_deref(), Some("/bob/demo"));

    let forked = get(app, "/bob/demo", Some(&bob)).await;

    assert!(forked.body.contains("README.md") && forked.body.contains("forked from"), "{}", forked.body);

    assert!(forked.body.contains("propose to andy/demo"));

    assert!(get(app, "/andy/demo", None).await.body.contains("1 fork"));

    assert!(get(app, "/andy/demo/forks", None).await.body.contains("/bob/demo"));

    let fork_row = db::repos::get(&app.db, "bob", "demo").await.unwrap().unwrap();

    let up_row = db::repos::get(&app.db, "andy", "demo").await.unwrap().unwrap();

    assert_eq!(fork_row.forked_from, Some(up_row.id));

    assert_eq!(fork_row.description, "The demo");

    let fork_repo = app.repos.open(&RepoName::parse("bob/demo").unwrap()).unwrap();

    let up_repo = app.repos.open(&RepoName::parse("andy/demo").unwrap()).unwrap();

    assert_ne!(fork_repo.id().unwrap(), up_repo.id().unwrap(), "a fork is a repository of its own");

    assert_eq!(fork_repo.bookmark_heads().unwrap(), up_repo.bookmark_heads().unwrap());

    assert_eq!(fork_repo.fsck().unwrap().errors(), 0);

    // Bob works in a clone of his fork, pushes a bookmark, and proposes it upstream.

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

    let mut mine = Repo::clone(&format!("{}/bob/demo", h.base), &bw.path().join("c")).unwrap();

    mine.config.set("remote.origin.token", "site").unwrap();

    mine.save_config().unwrap();

    mine.bookmark_create("feat", None).unwrap();

    mine.bookmark_switch("feat", false).unwrap();

    write(&bw.path().join("c"), "feature.txt", b"new\n");

    mine.commit("Add a feature", &[]).unwrap();

    assert!(mine.push_bookmark("origin", "feat", false).unwrap().iter().all(|r| r.ok));

    let csrf = csrf_of(&get(app, "/andy/demo/proposals/new?source=bob/demo:feat", Some(&bob)).await.body);

    let r =

        post(app, "/andy/demo/proposals/new", Some(&bob), &format!("_csrf={csrf}&title=From+my+fork&target=main&source=bob%2Fdemo%3Afeat"))

            .await;

    assert_eq!(r.status, StatusCode::SEE_OTHER, "{}", r.body);

    let p = get(app, &r.location.unwrap(), Some(&andy)).await;

    assert!(p.body.contains("From my fork") && p.body.contains("fork bob/demo"), "{}", p.body);

    let files = get(app, "/andy/demo/proposal/1?tab=files", Some(&andy)).await;

    assert!(files.body.contains("feature.txt"), "{}", files.body);

}

| `/{owner}/{name}/fork`, `/{owner}/{name}/forks` | Fork under an owner the viewer may create repositories for (same visibility, own repository id, objects hard-linked, bookmarks copied, policy not copied); the list of forks the viewer can see. The overview shows "forked from", the fork count, and on a fork a link that opens a proposal upstream with `owner/name:bookmark` as its source |

    {% if let Some(up) = fork.upstream %}<p class="small">forked from <a href="/{{ up.owner }}/{{ up.name }}">{{ up.owner }}/{{ up.name }}</a></p>{% endif %}

    <div class="bar">

    {% if shell.user.is_some() %}<form class="inline" method="post" action="{{ repo.url }}/watch"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><button type="submit" class="small">{% if watching %}UNWATCH{% else %}WATCH{% endif %}</button></form>

    <a class="go small" href="{{ repo.url }}/fork">fork</a>{% endif %}

    {% if fork.forks > 0 %}<a class="small" href="{{ repo.url }}/forks">{{ fork.forks|plural("fork", "forks") }}</a>{% endif %}

    </div>

    {% if let Some(up) = fork.upstream %}{% if shell.user.is_some() %}<a class="go small" href="/{{ up.owner }}/{{ up.name }}/proposals/new?source={{ repo.owner }}/{{ repo.name }}:{{ repo.default_bookmark }}">propose to {{ up.owner }}/{{ up.name }}</a>{% endif %}{% endif %}