Coverage / crates/hub/src/web/backups.rs 55.9%

    fn every(&self) -> &'static [(&'static str, &'static str)] {

        backups::EVERY

    }

    fn keeps(&self) -> &'static [i64] {

        backups::KEEP

    }

async fn page(

    app: &Shared,

    shell: Shell,

    kind: &'static str,

    owner: &str,

    notice: Option<String>,

    error: Option<String>,

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

    let e = |e| Error::from_db(shell.clone(), e);

    let setting = backups::setting(&app.db, owner).await.map_err(e)?.unwrap_or_else(|| Setting::off(owner, kind));

    let runs = backups::runs(&app.db, owner, 50).await.map_err(e)?;

    let base = if kind == "org" { format!("/orgs/{owner}/settings/backups") } else { "/settings/backups".into() };

    let dirs = app.config.backups.directories.iter().map(|d| d.display().to_string()).collect();

    Ok(Page(BackupsPage { shell, kind, owner: owner.into(), base, setting, runs, dirs, notice, error }))

}

pub(crate) fn setting_of(app: &Shared, owner: &str, kind: &str, f: &SettingInput) -> Result<Setting, String> {

    if !backups::EVERY.iter().any(|(v, _)| *v == f.every) {

    }

    let keep_days: i64 = f.keep_days.parse().unwrap_or(30);

    if !backups::KEEP.contains(&keep_days) {

    }

    let prefix = f.prefix.trim().trim_matches('/').to_string();

    if prefix.split('/').any(|p| p == ".." || p == ".") {

    }

    let mut region = String::new();

    let (target, provider) = match f.destination.as_str() {

        "dir" => {

            if !app.config.backups.directories.iter().any(|d| d.display().to_string() == f.dir) {

                return Err("Pick one of the directories this hub allows.".into());

            }

            (f.dir.clone(), String::new())

        "s3" => {

            let bucket = f.s3_bucket.trim().trim_start_matches("s3://").trim_end_matches('/').to_string();

            if bucket.is_empty() || !bucket.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || "-.".contains(c)) {

            }

            region = f.s3_region.trim().to_string();

            if region.is_empty() || !region.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == '-') {

            }

            let role = f.s3_role.trim().to_string();

            if !role.starts_with("arn:aws:iam::") || !role.contains(":role/") {

                return Err("Give the IAM role's ARN, arn:aws:iam::ACCOUNT:role/NAME (docs/backups.md §6).".into());

            }

            (bucket, role)

        "gcs" => {

            let bucket = f.bucket.trim().trim_start_matches("gs://").trim_end_matches('/').to_string();

            if bucket.is_empty() || !bucket.chars().all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || "-_.".contains(c)) {

            }

            let provider = f.provider.trim().to_string();

            if !provider.starts_with("//iam.googleapis.com/projects/") || !provider.contains("/providers/") {

                return Err(

                    "Give the workload identity provider's full name, //iam.googleapis.com/projects/…/providers/… (docs/backups.md §6)."

                        .into(),

                );

            }

            (bucket, provider)

    Ok(Setting {

        owner: owner.into(),

        kind: kind.into(),

        every: f.every.clone(),

        destination: f.destination.clone(),

        target,

        prefix,

        provider,

        keep_days,

        updated_ms: 0,

        region,

    })

}

async fn save(app: &Shared, shell: Shell, kind: &'static str, owner: &str, f: &BackupForm) -> Result<Page<BackupsPage>, Error> {

    match setting_of(app, owner, kind, &f.input) {

        Ok(s) => {

            backups::save(&app.db, &s).await.map_err(|e| Error::from_db(shell.clone(), e))?;

            page(app, shell, kind, owner, Some("Saved.".into()), None).await

        Err(why) => page(app, shell, kind, owner, None, Some(why)).await,

}

pub async fn user(State(app): State<Shared>, viewer: Viewer) -> Result<Page<BackupsPage>, Error> {

    let shell = Shell::new(&app, "/settings/backups", &viewer);

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

    page(&app, shell, "user", &me.account.username, None, None).await

}

pub async fn user_save(State(app): State<Shared>, viewer: Viewer, Form(f): Form<BackupForm>) -> Result<Page<BackupsPage>, Error> {

    let shell = Shell::new(&app, "/settings/backups", &viewer);

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

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

    save(&app, shell, "user", &me.account.username, &f).await

}

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

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

    let (_, org) = super::orgs::owned_org(&app, &shell, &viewer, &name).await?;

    page(&app, shell, "org", &org.name, None, None).await

}

pub async fn admin(State(app): State<Shared>, viewer: Viewer) -> Result<Page<AdminPage>, Error> {

    let shell = Shell::new(&app, "/admin/backups", &viewer);

    if !viewer.is_admin() {

        return Err(Error::not_found(shell));

    }

    let (owners, uncovered) = backups::overview(&app.db).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    Ok(Page(AdminPage { shell, owners, uncovered }))

}