main.rs 0.0%

0 of 217 lines run, 0 of 54 functions · run #498 on main · run missed

//! `oxygenhub`: `init`, `serve`, `admin`, `check` (hub spec §17.3).

use clap::{Parser, Subcommand};
use hub_api::Visibility;
use oxygenhub::config::Config;
use oxygenhub::repos::RepoName;
use oxygenhub::{db, keys};
use std::path::PathBuf;

#[derive(Parser)]
#[command(name = "oxygenhub", version, about = "A forge for Oxygen repositories")]
struct Cli {
    /// The data directory (hub spec §3.2)
    #[arg(long, global = true, env = "OXYHUB_DATA", default_value = "data")]
    data: PathBuf,
    #[command(subcommand)]
    cmd: Cmd,
}

#[derive(Subcommand)]
enum Cmd {
    /// Create the data directory, keys, database and a default hub.toml
    Init {
        /// What links and clone URLs start with
        #[arg(long)]
        base_url: Option<String>,
        /// Generate a self-signed TLS certificate (developer edition)
        #[arg(long)]
        self_signed: bool,
    },
    /// Run the hub
    Serve {
        /// What this process does: web (pages, API, wire protocol, runner
        /// API), worker (the background tasks), or both, comma-separated.
        /// Overrides [server] roles; every role when neither is given
        /// (docs/roles.md)
        #[arg(long = "role", value_name = "ROLE", value_delimiter = ',')]
        roles: Vec<oxygenhub::config::Role>,
    },
    /// Offline administration
    Admin {
        #[command(subcommand)]
        cmd: AdminCmd,
    },
    /// Verify every repository's objects and signatures
    Check,
    /// Garbage-collect every repository now, as the nightly job does
    Gc,
}

#[derive(Subcommand)]
enum AdminCmd {
    /// Repositories
    Repo {
        #[command(subcommand)]
        cmd: RepoCmd,
    },
    /// Accounts
    User {
        #[command(subcommand)]
        cmd: UserCmd,
    },
    /// Backups (docs/backups.md)
    Backup {
        #[command(subcommand)]
        cmd: BackupCmd,
    },
    /// Copy a SQLite hub's records into this hub's empty PostgreSQL
    /// database, to move a hub (docs/postgres.md)
    #[cfg(feature = "postgres")]
    CopyDb {
        /// The old hub's `hub.db`, from a stopped hub (or a copy of one)
        #[arg(long)]
        from: PathBuf,
        /// Empty this database's tables first (a fresh hub's, a rehearsal's)
        #[arg(long)]
        replace: bool,
    },
}

#[derive(Subcommand)]
enum BackupCmd {
    /// Back up a user's or organisation's repositories now, as its settings say
    Run { owner: String },
    /// Restore every repository of a whole run from a backup directory
    /// (the one holding LATEST, runs/ and blobs/) into this hub
    Restore {
        #[arg(long)]
        from: std::path::PathBuf,
        /// The run (runs/<RUN>); the latest whole one when not given
        #[arg(long)]
        run: Option<String>,
    },
}

#[derive(Subcommand)]
enum UserCmd {
    /// Create an account with a generated password, printed once
    Create {
        username: String,
        #[arg(long, default_value = "")]
        email: String,
        /// Make it a site administrator
        #[arg(long)]
        admin: bool,
    },
    /// Reset an account's password to a new generated one, printed once
    ResetPassword { username: String },
    /// List accounts
    List,
}

#[derive(Subcommand)]
enum RepoCmd {
    /// Create an empty repository OWNER/NAME
    Create {
        slug: String,
        #[arg(long, default_value = "")]
        description: String,
        #[arg(long, default_value = "public")]
        visibility: String,
        /// Bind to this repository id now (32 hex characters, from `.oxy/id`);
        /// otherwise the first push binds it
        #[arg(long)]
        id: Option<String>,
    },
    /// List repositories
    List,
    /// Move a repository to the trash
    Delete { slug: String },
    /// Change the description, default bookmark or visibility
    Set {
        slug: String,
        #[arg(long)]
        description: Option<String>,
        #[arg(long)]
        default_bookmark: Option<String>,
        #[arg(long)]
        visibility: Option<String>,
    },
}

fn main() -> anyhow::Result<()> {
    tune_allocator();
    let rt = tokio::runtime::Builder::new_multi_thread().enable_all().build()?;
    rt.spawn(return_freed_memory());
    let out = rt.block_on(run());
    oxygenhub::shutdown::finish(rt);
    out
}

/// glibc's allocator gives each thread that allocates an arena of its own
/// and keeps what is freed in it: under the hub's worker threads, loaded
/// states that the cache had let go still held their pages, and the hub
/// grew to 12 GB with its state cache capped at 3 GiB (oxygenhub#117).
/// Two arenas, as oxy found for its own threads; MALLOC_ARENA_MAX in the
/// environment still has the last word. Called before any thread starts.
fn tune_allocator() {
    #[cfg(all(target_os = "linux", target_env = "gnu"))]
    if std::env::var_os("MALLOC_ARENA_MAX").is_none() {
        // SAFETY: mallopt is called once, before any other thread exists.
        unsafe {
            libc::mallopt(libc::M_ARENA_MAX, 2);
        }
    }
}

/// Hand freed memory back to the system every minute, so the hub's size
/// follows what it holds rather than its peak (oxygenhub#117).
async fn return_freed_memory() {
    #[cfg(all(target_os = "linux", target_env = "gnu"))]
    loop {
        tokio::time::sleep(std::time::Duration::from_secs(60)).await;
        // SAFETY: malloc_trim only releases free pages.
        let _ = tokio::task::spawn_blocking(|| unsafe { libc::malloc_trim(0) }).await;
    }
}

async fn run() -> anyhow::Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env().add_directive("oxygenhub=info".parse()?))
        .init();
    let cli = Cli::parse();
    match cli.cmd {
        Cmd::Init { base_url, self_signed } => init(&cli.data, base_url, self_signed).await,
        Cmd::Serve { roles } => {
            let mut config = Config::load(&cli.data)?;
            if !roles.is_empty() {
                config.server.roles = roles.iter().map(|r| r.name().to_string()).collect();
            }
            let app = oxygenhub::build(config).await?;
            oxygenhub::serve(app).await
        }
        Cmd::Admin { cmd: AdminCmd::Repo { cmd } } => {
            let config = Config::load(&cli.data)?;
            let app = oxygenhub::build(config).await?;
            repo_admin(&app, cmd).await
        }
        Cmd::Admin { cmd: AdminCmd::Backup { cmd } } => {
            let config = Config::load(&cli.data)?;
            let app = oxygenhub::build(config).await?;
            match cmd {
                BackupCmd::Run { owner } => {
                    let r = oxygenhub::backups::run(&app, &owner, "now").await?;
                    println!(
                        "{} {}: {} repositories, {} of {} files sent ({} KiB){}",
                        r.status,
                        r.at,
                        r.repos,
                        r.sent,
                        r.files,
                        r.bytes / 1024,
                        if r.detail.is_empty() { String::new() } else { format!(": {}", r.detail) }
                    );
                    if r.status == "failed" {
                        std::process::exit(1);
                    }
                    Ok(())
                }
                BackupCmd::Restore { from, run } => {
                    let dest: std::sync::Arc<dyn oxygenhub::backups::Destination> =
                        std::sync::Arc::new(oxygenhub::backups::Directory { root: from });
                    for d in oxygenhub::backups::restore_into_hub(&app, dest, run).await? {
                        println!("restored {d}");
                    }
                    Ok(())
                }
            }
        }
        #[cfg(feature = "postgres")]
        Cmd::Admin { cmd: AdminCmd::CopyDb { from, replace } } => {
            let config = Config::load(&cli.data)?;
            let pool = db::open(&config).await?;
            let copied = db::copy::from_sqlite(&pool, &from, replace).await?;
            for (table, n) in &copied {
                println!("{n:>9}  {table}");
            }
            println!("copied {} rows in {} tables", copied.iter().map(|(_, n)| n).sum::<i64>(), copied.len());
            Ok(())
        }
        Cmd::Admin { cmd: AdminCmd::User { cmd } } => {
            let config = Config::load(&cli.data)?;
            let app = oxygenhub::build(config).await?;
            user_admin(&app, cmd).await
        }
        Cmd::Check => {
            let config = Config::load(&cli.data)?;
            let app = oxygenhub::build(config).await?;
            check(&app).await
        }
        Cmd::Gc => {
            let config = Config::load(&cli.data)?;
            let app = oxygenhub::build(config).await?;
            let done = oxygenhub::maintenance::gc_all(&app).await;
            for d in &done {
                println!("{d}");
            }
            if done.iter().any(|d| d.failed) {
                anyhow::bail!("a repository could not be garbage collected");
            }
            Ok(())
        }
    }
}

async fn init(data: &PathBuf, base_url: Option<String>, self_signed: bool) -> anyhow::Result<()> {
    std::fs::create_dir_all(data)?;
    let toml_path = data.join("hub.toml");
    if !toml_path.exists() {
        let base = base_url.clone().unwrap_or_else(|| "http://127.0.0.1:7300".into());
        let mut text = String::from("# OxygenHub configuration (docs/spec.md section 17.1)\n\n[site]\nname = \"OxygenHub\"\n\n[server]\nbind = \"127.0.0.1:7300\"\n");
        if self_signed {
            text.push_str("tls_bind = \"0.0.0.0:7343\"\n");
        }
        text.push_str(&format!("base_url = \"{base}\"\n\n[tls]\nself_signed = {self_signed}\n\n[auth]\n# Bearer tokens allowed to push until accounts exist.\npush_tokens = []\n"));
        std::fs::write(&toml_path, text)?;
        println!("wrote {}", toml_path.display());
    }
    let mut config = Config::load(data)?;
    if let Some(b) = base_url {
        config.server.base_url = b;
    }
    let app = oxygenhub::build(config).await?;
    println!("hub key {}", app.hub_key.key.to_hex());
    if (self_signed || app.config.tls.self_signed)
        && keys::ensure_self_signed(&app.config.tls_cert(), &app.config.tls_key(), app.config.base_url())?
    {
        println!("wrote self-signed certificate {}", app.config.tls_cert().display());
    }
    println!("data directory {} is ready", data.display());
    Ok(())
}

async fn repo_admin(app: &oxygenhub::Shared, cmd: RepoCmd) -> anyhow::Result<()> {
    match cmd {
        RepoCmd::Create { slug, description, visibility, id } => {
            let name = RepoName::parse(&slug).ok_or_else(|| anyhow::anyhow!("{slug:?} is not a valid owner/name"))?;
            let visibility = Visibility::parse(&visibility).ok_or_else(|| anyhow::anyhow!("visibility is public, internal or private"))?;
            let id = match id {
                Some(h) => {
                    let bytes = hex::decode(h.trim()).ok().and_then(|v| <[u8; 16]>::try_from(v).ok());
                    Some(bytes.ok_or_else(|| anyhow::anyhow!("--id takes 32 hex characters"))?)
                }
                None => None,
            };
            if db::repos::get(&app.db, &name.owner, &name.name).await?.is_some() {
                anyhow::bail!("{name} already exists");
            }
            app.repos.create(&name, id)?;
            db::repos::create(&app.db, &name.owner, &name.name, &description, visibility).await?;
            println!("created {name}: oxy clone {}/{name}", app.config.base_url());
        }
        RepoCmd::List => {
            for r in db::repos::list_with_drops(&app.db).await? {
                let what = if r.is_drop() { format!("drop: {}", r.title) } else { r.description.clone() };
                println!("{:<40} {:<8} {what}", r.slug(), r.visibility);
            }
        }
        RepoCmd::Delete { slug } => {
            let name = RepoName::parse(&slug).ok_or_else(|| anyhow::anyhow!("{slug:?} is not a valid owner/name"))?;
            let row = db::repos::get(&app.db, &name.owner, &name.name).await?.ok_or_else(|| anyhow::anyhow!("{name} does not exist"))?;
            let dest = app.repos.trash(&name)?;
            db::repos::delete(&app.db, row.id).await?;
            println!("moved {name} to {}", dest.display());
        }
        RepoCmd::Set { slug, description, default_bookmark, visibility } => {
            let name = RepoName::parse(&slug).ok_or_else(|| anyhow::anyhow!("{slug:?} is not a valid owner/name"))?;
            let row = db::repos::get(&app.db, &name.owner, &name.name).await?.ok_or_else(|| anyhow::anyhow!("{name} does not exist"))?;
            if let Some(d) = description {
                db::repos::set_description(&app.db, row.id, &d).await?;
            }
            if let Some(b) = default_bookmark {
                db::repos::set_default_bookmark(&app.db, row.id, &b).await?;
            }
            if let Some(v) = visibility {
                let v = Visibility::parse(&v).ok_or_else(|| anyhow::anyhow!("visibility is public, internal or private"))?;
                db::repos::set_visibility(&app.db, row.id, v).await?;
            }
            println!("updated {name}");
        }
    }
    Ok(())
}

async fn user_admin(app: &oxygenhub::Shared, cmd: UserCmd) -> anyhow::Result<()> {
    use oxygenhub::auth;
    use oxygenhub::db::accounts;
    match cmd {
        UserCmd::Create { username, email, admin } => {
            if !oxygenhub::repos::names::valid_owner(&username) {
                anyhow::bail!("{username:?} is not a valid username");
            }
            if accounts::account_by_name(&app.db, &username).await?.is_some() || accounts::org_by_name(&app.db, &username).await?.is_some()
            {
                anyhow::bail!("{username} is taken");
            }
            let password = auth::random_hex(12);
            let hash = auth::hash_password(&password)?;
            accounts::create_account(&app.db, &username, &email, &hash, &auth::random_hex(16), admin).await?;
            accounts::audit(&app.db, None, "admin.user.create", &username, if admin { "administrator" } else { "" }).await?;
            println!("created {username}{}; one-time password: {password}", if admin { " (administrator)" } else { "" });
            println!("sign in at {}/login and change it under Settings", app.config.base_url());
        }
        UserCmd::ResetPassword { username } => {
            let account = accounts::account_by_name(&app.db, &username).await?.ok_or_else(|| anyhow::anyhow!("no such account"))?;
            let password = auth::random_hex(12);
            let hash = auth::hash_password(&password)?;
            accounts::set_password(&app.db, account.id, &hash, &auth::random_hex(16)).await?;
            accounts::audit(&app.db, None, "admin.user.reset_password", &username, "").await?;
            println!("new one-time password for {username}: {password}");
        }
        UserCmd::List => {
            for a in accounts::accounts(&app.db).await? {
                println!(
                    "{:<24} {:<32} {}{}{}",
                    a.username,
                    a.email,
                    if a.is_admin { "admin " } else { "" },
                    if a.banned { "banned " } else { "" },
                    if a.disabled { "disabled" } else { "" }
                );
            }
        }
    }
    Ok(())
}

async fn check(app: &oxygenhub::Shared) -> anyhow::Result<()> {
    let mut problems = 0;
    for r in db::repos::list_with_drops(&app.db).await? {
        let name = RepoName::new(&r.owner, &r.name).unwrap();
        let report = app.repos.read(&name, oxygenhub::repos::view::verification).await;
        match report {
            Ok(v) => {
                println!(
                    "{:<40} {} changes, {} signed, {} sealed, {} unsigned, {} invalid",
                    name,
                    v.total,
                    v.signed,
                    v.sealed,
                    v.unsigned,
                    v.invalid.len()
                );
                problems += v.invalid.len();
            }
            Err(e) => {
                println!("{name:<40} ERROR {e}");
                problems += 1;
            }
        }
    }
    if problems > 0 {
        anyhow::bail!("{problems} problem(s)");
    }
    Ok(())
}

`/`	Search
`g` `c`	Code
`g` `h`	History
`g` `b`	Bookmarks
`g` `t`	Trust
`y`	Permalink to this state (files and trees)
`?`	This sheet

1		//! `oxygenhub`: `init`, `serve`, `admin`, `check` (hub spec §17.3).
2
3		use clap::{Parser, Subcommand};
4		use hub_api::Visibility;
5		use oxygenhub::config::Config;
6		use oxygenhub::repos::RepoName;
7		use oxygenhub::{db, keys};
8		use std::path::PathBuf;
9
10		#[derive(Parser)]
11		#[command(name = "oxygenhub", version, about = "A forge for Oxygen repositories")]
12		struct Cli {
13		/// The data directory (hub spec §3.2)
14		#[arg(long, global = true, env = "OXYHUB_DATA", default_value = "data")]
15		data: PathBuf,
16		#[command(subcommand)]
17		cmd: Cmd,
18		}
19
20		#[derive(Subcommand)]
21		enum Cmd {
22		/// Create the data directory, keys, database and a default hub.toml
23		Init {
24		/// What links and clone URLs start with
25		#[arg(long)]
26		base_url: Option<String>,
27		/// Generate a self-signed TLS certificate (developer edition)
28		#[arg(long)]
29		self_signed: bool,
30		},
31		/// Run the hub
32		Serve {
33		/// What this process does: web (pages, API, wire protocol, runner
34		/// API), worker (the background tasks), or both, comma-separated.
35		/// Overrides [server] roles; every role when neither is given
36		/// (docs/roles.md)
37		#[arg(long = "role", value_name = "ROLE", value_delimiter = ',')]
38		roles: Vec<oxygenhub::config::Role>,
39		},
40		/// Offline administration
41		Admin {
42		#[command(subcommand)]
43		cmd: AdminCmd,
44		},
45		/// Verify every repository's objects and signatures
46		Check,
47		/// Garbage-collect every repository now, as the nightly job does
48		Gc,
49		}
50
51		#[derive(Subcommand)]
52		enum AdminCmd {
53		/// Repositories
54		Repo {
55		#[command(subcommand)]
56		cmd: RepoCmd,
57		},
58		/// Accounts
59		User {
60		#[command(subcommand)]
61		cmd: UserCmd,
62		},
63		/// Backups (docs/backups.md)
64		Backup {
65		#[command(subcommand)]
66		cmd: BackupCmd,
67		},
68		/// Copy a SQLite hub's records into this hub's empty PostgreSQL
69		/// database, to move a hub (docs/postgres.md)
70		#[cfg(feature = "postgres")]
71		CopyDb {
72		/// The old hub's `hub.db`, from a stopped hub (or a copy of one)
73		#[arg(long)]
74		from: PathBuf,
75		/// Empty this database's tables first (a fresh hub's, a rehearsal's)
76		#[arg(long)]
77		replace: bool,
78		},
79		}
80
81		#[derive(Subcommand)]
82		enum BackupCmd {
83		/// Back up a user's or organisation's repositories now, as its settings say
84		Run { owner: String },
85		/// Restore every repository of a whole run from a backup directory
86		/// (the one holding LATEST, runs/ and blobs/) into this hub
87		Restore {
88		#[arg(long)]
89		from: std::path::PathBuf,
90		/// The run (runs/<RUN>); the latest whole one when not given
91		#[arg(long)]
92		run: Option<String>,
93		},
94		}
95
96		#[derive(Subcommand)]
97		enum UserCmd {
98		/// Create an account with a generated password, printed once
99		Create {
100		username: String,
101		#[arg(long, default_value = "")]
102		email: String,
103		/// Make it a site administrator
104		#[arg(long)]
105		admin: bool,
106		},
107		/// Reset an account's password to a new generated one, printed once
108		ResetPassword { username: String },
109		/// List accounts
110		List,
111		}
112
113		#[derive(Subcommand)]
114		enum RepoCmd {
115		/// Create an empty repository OWNER/NAME
116		Create {
117		slug: String,
118		#[arg(long, default_value = "")]
119		description: String,
120		#[arg(long, default_value = "public")]
121		visibility: String,
122		/// Bind to this repository id now (32 hex characters, from `.oxy/id`);
123		/// otherwise the first push binds it
124		#[arg(long)]
125		id: Option<String>,
126		},
127		/// List repositories
128		List,
129		/// Move a repository to the trash
130		Delete { slug: String },
131		/// Change the description, default bookmark or visibility
132		Set {
133		slug: String,
134		#[arg(long)]
135		description: Option<String>,
136		#[arg(long)]
137		default_bookmark: Option<String>,
138		#[arg(long)]
139		visibility: Option<String>,
140		},
141		}
142
143	0×	fn main() -> anyhow::Result<()> {
144	0×	tune_allocator();
145	0×	let rt = tokio::runtime::Builder::new_multi_thread().enable_all().build()?;
146	0×	rt.spawn(return_freed_memory());
147	0×	let out = rt.block_on(run());
148	0×	oxygenhub::shutdown::finish(rt);
149	0×	out
150	0×	}
151
152		/// glibc's allocator gives each thread that allocates an arena of its own
153		/// and keeps what is freed in it: under the hub's worker threads, loaded
154		/// states that the cache had let go still held their pages, and the hub
155		/// grew to 12 GB with its state cache capped at 3 GiB (oxygenhub#117).
156		/// Two arenas, as oxy found for its own threads; MALLOC_ARENA_MAX in the
157		/// environment still has the last word. Called before any thread starts.
158	0×	fn tune_allocator() {
159		#[cfg(all(target_os = "linux", target_env = "gnu"))]
160	0×	if std::env::var_os("MALLOC_ARENA_MAX").is_none() {
161		// SAFETY: mallopt is called once, before any other thread exists.
162	0×	unsafe {
163	0×	libc::mallopt(libc::M_ARENA_MAX, 2);
164	0×	}
165	0×	}
166	0×	}
167
168		/// Hand freed memory back to the system every minute, so the hub's size
169		/// follows what it holds rather than its peak (oxygenhub#117).
170	0×	async fn return_freed_memory() {
171		#[cfg(all(target_os = "linux", target_env = "gnu"))]
172		loop {
173	0×	tokio::time::sleep(std::time::Duration::from_secs(60)).await;
174		// SAFETY: malloc_trim only releases free pages.
175	0×	let _ = tokio::task::spawn_blocking(\|\| unsafe { libc::malloc_trim(0) }).await;
176		}
177		}
178
179	0×	async fn run() -> anyhow::Result<()> {
180	0×	tracing_subscriber::fmt()
181	0×	.with_env_filter(tracing_subscriber::EnvFilter::from_default_env().add_directive("oxygenhub=info".parse()?))
182	0×	.init();
183	0×	let cli = Cli::parse();
184	0×	match cli.cmd {
185	0×	Cmd::Init { base_url, self_signed } => init(&cli.data, base_url, self_signed).await,
186	0×	Cmd::Serve { roles } => {
187	0×	let mut config = Config::load(&cli.data)?;
188	0×	if !roles.is_empty() {
189	0×	config.server.roles = roles.iter().map(\|r\| r.name().to_string()).collect();
190	0×	}
191	0×	let app = oxygenhub::build(config).await?;
192	0×	oxygenhub::serve(app).await
193		}
194	0×	Cmd::Admin { cmd: AdminCmd::Repo { cmd } } => {
195	0×	let config = Config::load(&cli.data)?;
196	0×	let app = oxygenhub::build(config).await?;
197	0×	repo_admin(&app, cmd).await
198		}
199	0×	Cmd::Admin { cmd: AdminCmd::Backup { cmd } } => {
200	0×	let config = Config::load(&cli.data)?;
201	0×	let app = oxygenhub::build(config).await?;
202	0×	match cmd {
203	0×	BackupCmd::Run { owner } => {
204	0×	let r = oxygenhub::backups::run(&app, &owner, "now").await?;
205	0×	println!(
206		"{} {}: {} repositories, {} of {} files sent ({} KiB){}",
207		r.status,
208		r.at,
209		r.repos,
210		r.sent,
211		r.files,
212	0×	r.bytes / 1024,
213	0×	if r.detail.is_empty() { String::new() } else { format!(": {}", r.detail) }
214		);
215	0×	if r.status == "failed" {
216	0×	std::process::exit(1);
217	0×	}
218	0×	Ok(())
219		}
220	0×	BackupCmd::Restore { from, run } => {
221	0×	let dest: std::sync::Arc<dyn oxygenhub::backups::Destination> =
222	0×	std::sync::Arc::new(oxygenhub::backups::Directory { root: from });
223	0×	for d in oxygenhub::backups::restore_into_hub(&app, dest, run).await? {
224	0×	println!("restored {d}");
225	0×	}
226	0×	Ok(())
227		}
228		}
229		}
230		#[cfg(feature = "postgres")]
231		Cmd::Admin { cmd: AdminCmd::CopyDb { from, replace } } => {
232		let config = Config::load(&cli.data)?;
233		let pool = db::open(&config).await?;
234		let copied = db::copy::from_sqlite(&pool, &from, replace).await?;
235		for (table, n) in &copied {
236		println!("{n:>9} {table}");
237		}
238		println!("copied {} rows in {} tables", copied.iter().map(\|(_, n)\| n).sum::<i64>(), copied.len());
239		Ok(())
240		}
241	0×	Cmd::Admin { cmd: AdminCmd::User { cmd } } => {
242	0×	let config = Config::load(&cli.data)?;
243	0×	let app = oxygenhub::build(config).await?;
244	0×	user_admin(&app, cmd).await
245		}
246		Cmd::Check => {
247	0×	let config = Config::load(&cli.data)?;
248	0×	let app = oxygenhub::build(config).await?;
249	0×	check(&app).await
250		}
251		Cmd::Gc => {
252	0×	let config = Config::load(&cli.data)?;
253	0×	let app = oxygenhub::build(config).await?;
254	0×	let done = oxygenhub::maintenance::gc_all(&app).await;
255	0×	for d in &done {
256	0×	println!("{d}");
257	0×	}
258	0×	if done.iter().any(\|d\| d.failed) {
259	0×	anyhow::bail!("a repository could not be garbage collected");
260	0×	}
261	0×	Ok(())
262		}
263		}
264	0×	}
265
266	0×	async fn init(data: &PathBuf, base_url: Option<String>, self_signed: bool) -> anyhow::Result<()> {
267	0×	std::fs::create_dir_all(data)?;
268	0×	let toml_path = data.join("hub.toml");
269	0×	if !toml_path.exists() {
270	0×	let base = base_url.clone().unwrap_or_else(\|\| "http://127.0.0.1:7300".into());
271	0×	let mut text = String::from("# OxygenHub configuration (docs/spec.md section 17.1)\n\n[site]\nname = \"OxygenHub\"\n\n[server]\nbind = \"127.0.0.1:7300\"\n");
272	0×	if self_signed {
273	0×	text.push_str("tls_bind = \"0.0.0.0:7343\"\n");
274	0×	}
275	0×	text.push_str(&format!("base_url = \"{base}\"\n\n[tls]\nself_signed = {self_signed}\n\n[auth]\n# Bearer tokens allowed to push until accounts exist.\npush_tokens = []\n"));
276	0×	std::fs::write(&toml_path, text)?;
277	0×	println!("wrote {}", toml_path.display());
278	0×	}
279	0×	let mut config = Config::load(data)?;
280	0×	if let Some(b) = base_url {
281	0×	config.server.base_url = b;
282	0×	}
283	0×	let app = oxygenhub::build(config).await?;
284	0×	println!("hub key {}", app.hub_key.key.to_hex());
285	0×	if (self_signed \|\| app.config.tls.self_signed)
286	0×	&& keys::ensure_self_signed(&app.config.tls_cert(), &app.config.tls_key(), app.config.base_url())?
287	0×	{
288	0×	println!("wrote self-signed certificate {}", app.config.tls_cert().display());
289	0×	}
290	0×	println!("data directory {} is ready", data.display());
291	0×	Ok(())
292	0×	}
293
294	0×	async fn repo_admin(app: &oxygenhub::Shared, cmd: RepoCmd) -> anyhow::Result<()> {
295	0×	match cmd {
296	0×	RepoCmd::Create { slug, description, visibility, id } => {
297	0×	let name = RepoName::parse(&slug).ok_or_else(\|\| anyhow::anyhow!("{slug:?} is not a valid owner/name"))?;
298	0×	let visibility = Visibility::parse(&visibility).ok_or_else(\|\| anyhow::anyhow!("visibility is public, internal or private"))?;
299	0×	let id = match id {
300	0×	Some(h) => {
301	0×	let bytes = hex::decode(h.trim()).ok().and_then(\|v\| <[u8; 16]>::try_from(v).ok());
302	0×	Some(bytes.ok_or_else(\|\| anyhow::anyhow!("--id takes 32 hex characters"))?)
303		}
304	0×	None => None,
305		};
306	0×	if db::repos::get(&app.db, &name.owner, &name.name).await?.is_some() {
307	0×	anyhow::bail!("{name} already exists");
308	0×	}
309	0×	app.repos.create(&name, id)?;
310	0×	db::repos::create(&app.db, &name.owner, &name.name, &description, visibility).await?;
311	0×	println!("created {name}: oxy clone {}/{name}", app.config.base_url());
312		}
313		RepoCmd::List => {
314	0×	for r in db::repos::list_with_drops(&app.db).await? {
315	0×	let what = if r.is_drop() { format!("drop: {}", r.title) } else { r.description.clone() };
316	0×	println!("{:<40} {:<8} {what}", r.slug(), r.visibility);
317		}
318		}
319	0×	RepoCmd::Delete { slug } => {
320	0×	let name = RepoName::parse(&slug).ok_or_else(\|\| anyhow::anyhow!("{slug:?} is not a valid owner/name"))?;
321	0×	let row = db::repos::get(&app.db, &name.owner, &name.name).await?.ok_or_else(\|\| anyhow::anyhow!("{name} does not exist"))?;
322	0×	let dest = app.repos.trash(&name)?;
323	0×	db::repos::delete(&app.db, row.id).await?;
324	0×	println!("moved {name} to {}", dest.display());
325		}
326	0×	RepoCmd::Set { slug, description, default_bookmark, visibility } => {
327	0×	let name = RepoName::parse(&slug).ok_or_else(\|\| anyhow::anyhow!("{slug:?} is not a valid owner/name"))?;
328	0×	let row = db::repos::get(&app.db, &name.owner, &name.name).await?.ok_or_else(\|\| anyhow::anyhow!("{name} does not exist"))?;
329	0×	if let Some(d) = description {
330	0×	db::repos::set_description(&app.db, row.id, &d).await?;
331	0×	}
332	0×	if let Some(b) = default_bookmark {
333	0×	db::repos::set_default_bookmark(&app.db, row.id, &b).await?;
334	0×	}
335	0×	if let Some(v) = visibility {
336	0×	let v = Visibility::parse(&v).ok_or_else(\|\| anyhow::anyhow!("visibility is public, internal or private"))?;
337	0×	db::repos::set_visibility(&app.db, row.id, v).await?;
338	0×	}
339	0×	println!("updated {name}");
340		}
341		}
342	0×	Ok(())
343	0×	}
344
345	0×	async fn user_admin(app: &oxygenhub::Shared, cmd: UserCmd) -> anyhow::Result<()> {
346		use oxygenhub::auth;
347		use oxygenhub::db::accounts;
348	0×	match cmd {
349	0×	UserCmd::Create { username, email, admin } => {
350	0×	if !oxygenhub::repos::names::valid_owner(&username) {
351	0×	anyhow::bail!("{username:?} is not a valid username");
352	0×	}
353	0×	if accounts::account_by_name(&app.db, &username).await?.is_some() \|\| accounts::org_by_name(&app.db, &username).await?.is_some()
354		{
355	0×	anyhow::bail!("{username} is taken");
356	0×	}
357	0×	let password = auth::random_hex(12);
358	0×	let hash = auth::hash_password(&password)?;
359	0×	accounts::create_account(&app.db, &username, &email, &hash, &auth::random_hex(16), admin).await?;
360	0×	accounts::audit(&app.db, None, "admin.user.create", &username, if admin { "administrator" } else { "" }).await?;
361	0×	println!("created {username}{}; one-time password: {password}", if admin { " (administrator)" } else { "" });
362	0×	println!("sign in at {}/login and change it under Settings", app.config.base_url());
363		}
364	0×	UserCmd::ResetPassword { username } => {
365	0×	let account = accounts::account_by_name(&app.db, &username).await?.ok_or_else(\|\| anyhow::anyhow!("no such account"))?;
366	0×	let password = auth::random_hex(12);
367	0×	let hash = auth::hash_password(&password)?;
368	0×	accounts::set_password(&app.db, account.id, &hash, &auth::random_hex(16)).await?;
369	0×	accounts::audit(&app.db, None, "admin.user.reset_password", &username, "").await?;
370	0×	println!("new one-time password for {username}: {password}");
371		}
372		UserCmd::List => {
373	0×	for a in accounts::accounts(&app.db).await? {
374	0×	println!(
375		"{:<24} {:<32} {}{}{}",
376		a.username,
377		a.email,
378	0×	if a.is_admin { "admin " } else { "" },
379	0×	if a.banned { "banned " } else { "" },
380	0×	if a.disabled { "disabled" } else { "" }
381		);
382		}
383		}
384		}
385	0×	Ok(())
386	0×	}
387
388	0×	async fn check(app: &oxygenhub::Shared) -> anyhow::Result<()> {
389	0×	let mut problems = 0;
390	0×	for r in db::repos::list_with_drops(&app.db).await? {
391	0×	let name = RepoName::new(&r.owner, &r.name).unwrap();
392	0×	let report = app.repos.read(&name, oxygenhub::repos::view::verification).await;
393	0×	match report {
394	0×	Ok(v) => {
395	0×	println!(
396	0×	"{:<40} {} changes, {} signed, {} sealed, {} unsigned, {} invalid",
397	0×	name,
398	0×	v.total,
399	0×	v.signed,
400	0×	v.sealed,
401	0×	v.unsigned,
402	0×	v.invalid.len()
403	0×	);
404	0×	problems += v.invalid.len();
405	0×	}
406	0×	Err(e) => {
407	0×	println!("{name:<40} ERROR {e}");
408	0×	problems += 1;
409	0×	}
410		}
411		}
412	0×	if problems > 0 {
413	0×	anyhow::bail!("{problems} problem(s)");
414	0×	}
415	0×	Ok(())
416	0×	}

Coverage / crates/hub/src/main.rs 0.0%

Keyboard