zj/nidobyte - Change S6TFYMRGWC4PSRLQ4OAKE2Z3JFEVGF3RZ5Z3MEN5XSA4INPQILOAC

routes: Move pijul routes to controllers module As with the root routes, now the pijul routes are moved. The mounting of the routes is still done in main.rs though the controller module now collects them. This should DRY this code

Created by zj on September 21, 2021

S6TFYMRGWC4PSRLQ4OAKE2Z3JFEVGF3RZ5Z3MEN5XSA4INPQILOAC

Dependencies

In channels

main

Change contents

File deletion: pijul.rs

BF:BFD[4.179] → [5.367:399]

BF:BFD[5.399] → [5.400:400]

B:BD[5.400] → [5.401:490]

∅:D[2.27] → [5.490:519]

B:BD[5.490] → [5.490:519]

∅:D[6.1942] → [5.562:655]

B:BD[5.562] → [5.562:655]

B:BD[5.655] → [6.1943:2273]

∅:D[6.2273] → [5.655:658]

B:BD[5.655] → [5.655:658]

∅:D[6.2338] → [5.750:771]

B:BD[5.750] → [5.750:771]

B:BD[5.771] → [5.771:872]

∅:D[6.2429] → [5.899:921]

B:BD[5.899] → [5.899:921]

∅:D[7.60] → [5.1045:1046]

B:BD[5.1045] → [5.1045:1046]

∅:D[7.239] → [5.1148:1168]

∅:D[6.2487] → [5.1148:1168]

B:BD[5.1148] → [5.1148:1168]

∅:D[6.2545] → [5.1199:1232]

B:BD[5.1199] → [5.1199:1232]

B:BD[5.1275] → [5.1275:1277]

∅:D[8.27] → [5.1277:1278]

B:BD[5.1277] → [5.1277:1278]

∅:D[8.872] → [5.1278:1310]

∅:D[7.1566] → [5.1278:1310]

B:BD[5.1278] → [5.1278:1310]

∅:D[2.902] → [5.1334:1336]

∅:D[8.915] → [5.1334:1336]

∅:D[7.1621] → [5.1334:1336]

∅:D[6.2581] → [5.1334:1336]

B:BD[5.1334] → [5.1334:1336]

B:BD[5.1310] → [2.840:902]

B:BD[5.1278] → [8.28:551]

∅:D[7.629] → [8.705:706]

B:BD[8.705] → [8.705:706]

∅:D[7.742] → [8.864:870]

B:BD[8.864] → [8.864:870]

∅:D[7.1070] → [8.870:872]

B:BD[8.870] → [8.870:872]

B:BD[8.872] → [7.1071:1092]

∅:D[2.48] → [7.1115:1191]

B:BD[7.1115] → [7.1115:1191]

∅:D[2.102] → [7.1232:1321]

B:BD[7.1232] → [7.1232:1321]

∅:D[2.598] → [7.1518:1519]

B:BD[7.1518] → [7.1518:1519]

∅:D[2.839] → [7.1563:1566]

B:BD[7.1563] → [7.1563:1566]

B:BD[7.1519] → [2.599:839]

B:BD[7.1321] → [2.103:598]

B:BD[7.1191] → [2.49:102]

B:BD[7.1092] → [2.28:48]

B:BD[8.870] → [7.743:1070]

B:BD[8.706] → [7.630:742]

B:BD[8.551] → [7.240:629]

B:BD[5.1277] → [8.0:27]

B:BD[5.1168] → [6.2488:2545]

B:BD[7.89] → [7.89:239]

B:BD[5.921] → [7.0:60]

B:BD[5.872] → [6.2339:2429]

B:BD[5.658] → [6.2274:2338]

B:BD[5.519] → [6.1530:1942]

B:BD[5.490] → [2.0:27]

use crate::database::Database;
use crate::models::projects;
use crate::repoman::RepoMan;
use rocket::{Route, State};
    channel: String, // TODO check if this breaks non-UTF-8 channels
    id: Option<String>,
) -> Option<String> {
    let p = match projects::find(db, org_path, proj_path).await {
        Some(p) => p,
        None => return None,
    };
    match p.repository(&repoman.storage_root) {
        Ok(r) => r.channel_remote_id(channel, id),
        Err(e) => {
            println!("{}", e);
            None
        }
    }
}
async fn changelist(
    db: &State<Database>,
    repoman: &State<RepoMan>,
    org_path: String,
    proj_path: String,
) -> Option<String> {
        Err(e) => {
            None
        }
    }
}
pub fn routes() -> Vec<Route> {
}
    routes![remote_id, changelist, apply, identities, change]
// TODO pijul: When this endpoint returns a 4XX or 5XX status code, it thinks the push still
// succeeded.
#[post("/<org_path>/<proj_path>/.pijul?<apply>", data = "<patch>")]
async fn apply(
    db: &State<Database>,
    repoman: &State<RepoMan>,
    org_path: String,
    proj_path: String,
    apply: String,
    mut patch: TempFile<'_>,
) -> rocket::http::Status {
    let p = if let Some(p) = projects::find(db, org_path, proj_path).await {
        p
    } else {
        return rocket::http::Status::NotFound;
    };
    }
}
#[derive(FromForm)]
    identities: Vec<String>,
}
use rocket::serde::{json::Json, Serialize};
    id: Vec<String>,
    rev: u64,
}
// TODO figure out what I'm supposed to send here?
}
    let hash = crate::models::pijul::changestores::Changestore::hash_from_string(change)?;
    let repo = p.repository(&repoman.storage_root).ok()?;
    let path = repo.changestore().change_file(hash);
    NamedFile::open(path).await.ok()
#[get("/<org_path>/<proj_path>/.pijul?<identities>", rank = 4)]
fn identities(org_path: String, proj_path: String, identities: Identities) -> Json<IdentitieRes> {
    Json(IdentitieRes { id: vec![], rev: 0 })
}
#[get("/<org_path>/<proj_path>/.pijul?<change>", rank = 3)]
async fn change(
    db: &State<Database>,
    repoman: &State<RepoMan>,
    org_path: String,
    proj_path: String,
    change: String,
) -> Option<NamedFile> {
    let p = projects::find(db, org_path, proj_path).await?;
#[derive(Serialize, FromForm)]
struct IdentitieRes {
struct Identities {
    if !repo.valid_change(hash) {
        // TODO clean up
        println!("Not valid as object");
        return rocket::http::Status::InternalServerError;
    }
    if repo.apply_change_to_channel("main", hash).is_ok() {
        return rocket::http::Status::Accepted;
    };
    rocket::http::Status::InternalServerError
    if patch.persist_to(&patch_path).await.is_err() {
        return rocket::http::Status::InternalServerError;
    let repo = p.repository(&repoman.storage_root).unwrap();
    let hash =
        if let Some(h) = crate::models::pijul::changestores::Changestore::hash_from_string(apply) {
            h
        } else {
            return rocket::http::Status::InternalServerError;
        };
    let patch_path = repo.changestore().change_file(hash);
    repo.changestore().ensure_parent_dirs(hash);
use rocket::fs::TempFile;
            println!("error getting changelist: {}", e);
    match p
        .repository(&repoman.storage_root)
        .unwrap()
        .changelist(channel, changelist)
    {
        Ok(out) => Some(out),
    let p = projects::find(db, org_path, proj_path).await?;
    channel: String, // TODO check if this breaks non-UTF-8 channels
    changelist: u64,
#[get("/<org_path>/<proj_path>/.pijul?<changelist>&<channel>")]
/// Because of the overlap with other routes in parameters, this route has
/// rank 2. This way the changelist matches first, and if it doesn't, this route
/// will respond. Note that in the push flow this order is reversed.
#[get("/<org_path>/<proj_path>/.pijul?<channel>&<id>", rank = 2)]
async fn remote_id(
    db: &State<Database>,
    repoman: &State<RepoMan>,
    org_path: String,
    proj_path: String,
use rocket::fs::NamedFile;

Deletion in src/main.rs at line 14 [4.212]
B:BD[9.8067] → [5.5333:5344]
∅:D[5.5344] → [10.4093:4107]
B:BD[9.8067] → [10.4093:4107]
```
mod pijul;
mod projects;
```
Deletion in src/main.rs at line 26 [4.212]
∅:D[11.343] → [10.4108:4156]
B:BD[9.8399] → [10.4108:4156]
B:BD[10.4156] → [5.5507:5544]
```
        .mount("/projects", projects::routes())
        .mount("/", pijul::routes())
```

File addition: pijul.rs (----------)

[3.85]

use crate::database::Database;
use crate::models::projects;
use crate::repoman::RepoMan;
use rocket::fs::NamedFile;
use rocket::{Route, State};
/// Because of the overlap with other routes in parameters, this route has
/// rank 2. This way the changelist matches first, and if it doesn't, this route
/// will respond. Note that in the push flow this order is reversed.
#[get("/<org_path>/<proj_path>/.pijul?<channel>&<id>", rank = 2)]
async fn remote_id(
    db: &State<Database>,
    repoman: &State<RepoMan>,
    org_path: String,
    proj_path: String,
    channel: String, // TODO check if this breaks non-UTF-8 channels
    id: Option<String>,
) -> Option<String> {
    let p = match projects::find(db, org_path, proj_path).await {
        Some(p) => p,
        None => return None,
    };
    match p.repository(&repoman.storage_root) {
        Ok(r) => r.channel_remote_id(channel, id),
        Err(e) => {
            println!("{}", e);
            None
        }
    }
}
#[get("/<org_path>/<proj_path>/.pijul?<changelist>&<channel>")]
async fn changelist(
    db: &State<Database>,
    repoman: &State<RepoMan>,
    org_path: String,
    proj_path: String,
    channel: String, // TODO check if this breaks non-UTF-8 channels
    changelist: u64,
) -> Option<String> {
    let p = projects::find(db, org_path, proj_path).await?;
    match p
        .repository(&repoman.storage_root)
        .unwrap()
        .changelist(channel, changelist)
    {
        Ok(out) => Some(out),
        Err(e) => {
            println!("error getting changelist: {}", e);
            None
        }
    }
}
use rocket::fs::TempFile;
// TODO pijul: When this endpoint returns a 4XX or 5XX status code, it thinks the push still
// succeeded.
#[post("/<org_path>/<proj_path>/.pijul?<apply>", data = "<patch>")]
async fn apply(
    db: &State<Database>,
    repoman: &State<RepoMan>,
    org_path: String,
    proj_path: String,
    apply: String,
    mut patch: TempFile<'_>,
) -> rocket::http::Status {
    let p = if let Some(p) = projects::find(db, org_path, proj_path).await {
        p
    } else {
        return rocket::http::Status::NotFound;
    };
    let repo = p.repository(&repoman.storage_root).unwrap();
    let hash =
        if let Some(h) = crate::models::pijul::changestores::Changestore::hash_from_string(apply) {
            h
        } else {
            return rocket::http::Status::InternalServerError;
        };
    let patch_path = repo.changestore().change_file(hash);
    repo.changestore().ensure_parent_dirs(hash);
    if patch.persist_to(&patch_path).await.is_err() {
        return rocket::http::Status::InternalServerError;
    }
    if !repo.valid_change(hash) {
        // TODO clean up
        println!("Not valid as object");
        return rocket::http::Status::InternalServerError;
    }
    if repo.apply_change_to_channel("main", hash).is_ok() {
        return rocket::http::Status::Accepted;
    };
    rocket::http::Status::InternalServerError
}
#[derive(FromForm)]
struct Identities {
    identities: Vec<String>,
}
use rocket::serde::{json::Json, Serialize};
#[derive(Serialize, FromForm)]
struct IdentitieRes {
    id: Vec<String>,
    rev: u64,
}
// TODO figure out what I'm supposed to send here?
#[get("/<org_path>/<proj_path>/.pijul?<identities>", rank = 4)]
fn identities(org_path: String, proj_path: String, identities: Identities) -> Json<IdentitieRes> {
    Json(IdentitieRes { id: vec![], rev: 0 })
}
#[get("/<org_path>/<proj_path>/.pijul?<change>", rank = 3)]
async fn change(
    db: &State<Database>,
    repoman: &State<RepoMan>,
    org_path: String,
    proj_path: String,
    change: String,
) -> Option<NamedFile> {
    let p = projects::find(db, org_path, proj_path).await?;
    let hash = crate::models::pijul::changestores::Changestore::hash_from_string(change)?;
    let repo = p.repository(&repoman.storage_root).ok()?;
    let path = repo.changestore().change_file(hash);
    NamedFile::open(path).await.ok()
}
pub fn routes() -> Vec<Route> {
    routes![remote_id, changelist, apply, identities, change]
}

Replacement in src/controllers/mod.rs at line 3 [3.384]
B:BD[3.405] → [3.405:419]
```
pub mod root;
```
[3.405]
[3.419]
```
mod pijul;
mod root;
```
Replacement in src/controllers/mod.rs at line 8 [3.384]
B:BD[3.452] → [3.452:471]
```
    root::routes()
```
[3.452]
[3.471]
```
    [root::routes(), pijul::routes()].concat()
```

routes: Move pijul routes to controllers module As with the root routes, now the pijul routes are moved. The mounting of the routes is still done in main.rs though the controller module now collects them. This should DRY this code

Dependencies

In channels

Change contents

File deletion: pijul.rs

Deletion in src/main.rs at line 14 [4.212]

Deletion in src/main.rs at line 26 [4.212]

File addition: pijul.rs (----------)

Replacement in src/controllers/mod.rs at line 3 [3.384]

Replacement in src/controllers/mod.rs at line 8 [3.384]