Mail settings on the admin page, with a test message 3556d08e17f9

- **A runner's own labels and time limit (#98).** A runner's page under Admin → Runners has a Settings form: labels an administrator gives it beside those it reports (jobs that ask for a label match either), and a job time limit in minutes below the site's, applied when it claims.

- **Mail settings on the admin page (#101).** The SMTP URL and From address are set and saved from Administration, overriding `hub.toml`'s `[email]`, with a button that sends a test message to the administrator's own address; the password is kept on the server and shown masked. An empty URL turns mail off.

- **Spacing (#99, #100).** The Add a runner button stands off the runners table and the webhook and collaborator forms fill their panel; a proposal's project entries keep a space before remove.

    /// Outgoing mail: hub.toml's `[email]`, overridden by what the admin

    /// page saved (#101).

    pub mail: std::sync::RwLock<config::Email>,

    let mail = mail::load(&db, &config.email).await;

        mail: std::sync::RwLock::new(mail),

use crate::config::Email;

pub const SETTING_SMTP: &str = "mail.smtp";

pub const SETTING_FROM: &str = "mail.from";

/// The mail settings in force: what the admin page saved (#101), else

/// hub.toml's `[email]`.

pub async fn load(db: &crate::db::Pool, from_config: &Email) -> Email {

    let mut mail = from_config.clone();

    if let Ok(Some(s)) = crate::db::accounts::setting(db, SETTING_SMTP).await {

        mail.smtp = s;

        mail.from = crate::db::accounts::setting(db, SETTING_FROM).await.ok().flatten().unwrap_or_default();

    }

    mail

}

pub fn settings(app: &Shared) -> Email {

    app.mail.read().unwrap_or_else(|p| p.into_inner()).clone()

}

/// Save the settings and use them from now on. An empty URL turns mail

/// off.

pub async fn save(app: &Shared, smtp: &str, from: &str) -> sqlx::Result<()> {

    crate::db::accounts::set_setting(&app.db, SETTING_SMTP, smtp).await?;

    crate::db::accounts::set_setting(&app.db, SETTING_FROM, from).await?;

    *app.mail.write().unwrap_or_else(|p| p.into_inner()) = Email { smtp: smtp.to_string(), from: from.to_string() };

    Ok(())

}

/// The SMTP URL with its password hidden, for the page.

pub fn masked(smtp: &str) -> String {

    let Some((scheme, rest)) = smtp.split_once("://") else { return smtp.to_string() };

    let Some((userinfo, host)) = rest.rsplit_once('@') else { return smtp.to_string() };

    match userinfo.split_once(':') {

        Some((user, _)) => format!("{scheme}://{user}:***@{host}"),

        None => smtp.to_string(),

    }

}

    let cfg = settings(app);

    let cfg = settings(app);

    /// Mail settings (#101): the SMTP URL with its password masked, the

    /// From address, whether mail is on, and the administrator's own

    /// address for a test message.

    mail_smtp: String,

    mail_from: String,

    mail_enabled: bool,

    my_email: String,

    let mail = crate::mail::settings(app);

    let my_email = match shell.user.as_deref() {

        Some(u) => accounts::account_by_name(&app.db, u).await.map_err(e)?.map(|a| a.email).unwrap_or_default(),

        None => String::new(),

    };

    Ok(Page(AdminPage {

        shell,

        accounts: accounts_list,

        orgs,

        mode,

        invitations,

        audit,

        repos,

        notice,

        mail_smtp: crate::mail::masked(&mail.smtp),

        mail_from: mail.from.clone(),

        mail_enabled: !mail.smtp.is_empty() && !mail.from.is_empty(),

        my_email,

    }))

}

#[derive(Deserialize)]

pub struct MailForm {

    #[serde(rename = "_csrf")]

    csrf_token: String,

    #[serde(default)]

    smtp: String,

    #[serde(default)]

    from: String,

}

/// `POST /admin/mail`: the SMTP URL and From address (#101). The URL

/// comes back masked, so a masked value left as it was keeps the stored

/// one; an empty URL turns mail off.

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

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

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

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

    let current = crate::mail::settings(&app);

    let smtp = f.smtp.trim();

    let smtp = if !current.smtp.is_empty() && smtp == crate::mail::masked(&current.smtp) { current.smtp.clone() } else { smtp.to_string() };

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

    if !smtp.is_empty() && !(smtp.starts_with("smtp://") || smtp.starts_with("smtps://") || smtp.starts_with("file://")) {

        return admin_page(

            &app,

            shell,

            Some("The SMTP URL starts with smtp:// or smtps:// (file:///dir writes messages to a directory, for testing).".into()),

        )

        .await;

    }

    if !smtp.is_empty() && from.is_empty() {

        return admin_page(&app, shell, Some("A From address is needed: OxygenHub <[email protected]>.".into())).await;

    }

    crate::mail::save(&app, &smtp, &from).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    accounts::audit(&app.db, Some(&me), "admin.mail", if smtp.is_empty() { "off" } else { "on" }, &from).await.ok();

    admin_page(&app, shell, Some(if smtp.is_empty() { "Mail is off.".into() } else { "Mail settings saved.".into() })).await

}

/// `POST /admin/mail/test`: a message to the administrator's own address.

pub async fn test_mail(

    State(app): State<Shared>,

    viewer: Viewer,

    Form(f): Form<super::session::CsrfForm>,

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

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

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

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

    if !crate::mail::enabled(&app) {

        return admin_page(&app, shell, Some("Mail is off; save an SMTP URL and a From address first.".into())).await;

    }

    if me.email.is_empty() {

        return admin_page(&app, shell, Some("Your account has no email address to send the test to.".into())).await;

    }

    let notice = match crate::mail::send(

        &app,

        me.name(),

        &me.email,

        "Test message",

        "This is a test message from your hub's mail settings. If you can read it, mail works.",

    )

    .await

    {

        Ok(()) => format!("Sent a test message to {}.", me.email),

        Err(e) => format!("Sending failed: {e}"),

    };

    admin_page(&app, shell, Some(notice)).await

        .route("/admin/runners/{id}/limits", post(runners::set_limits))

        .route("/admin/mail", post(admin::set_mail))

        .route("/admin/mail/test", post(admin::test_mail))

/// Mail settings from the admin page (#101): saved over hub.toml, shown

/// with the password masked, a test message sent to the administrator.

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

async fn mail_settings_are_saved_masked_and_tested_from_the_admin_page() {

    let h = hub().await;

    let app = &h.app;

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

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

    assert!(page.contains("Mail is off"), "{page}");

    let csrf = csrf_of(&page);

    // A directory store for messages, as hub.toml's file:// would be.

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

    let r = post(

        app,

        "/admin/mail",

        Some(&andy),

        &format!("_csrf={csrf}&smtp=file%3A%2F%2F{}&from=Hub+%3Chub%40example.org%3E", outbox.path().display()),

    )

    .await;

    assert!(r.body.contains("Mail settings saved") && r.body.contains("Mail is on"), "{}", r.body);

    assert!(oxygenhub::mail::enabled(app));

    let r = post(app, "/admin/mail/test", Some(&andy), &format!("_csrf={csrf}")).await;

    assert!(r.body.contains("Sent a test message to"), "{}", r.body);

    let sent: Vec<_> = std::fs::read_dir(outbox.path()).unwrap().flatten().collect();

    assert_eq!(sent.len(), 1);

    let text = std::fs::read_to_string(sent[0].path()).unwrap();

    assert!(text.contains("Subject: [") && text.contains("Test message") && text.contains("From: Hub <[email protected]>"), "{text}");

    // An SMTP URL comes back masked, and a masked value left alone keeps the password.

    let r = post(

        app,

        "/admin/mail",

        Some(&andy),

        &format!("_csrf={csrf}&smtp=smtps%3A%2F%2Fhub%3Asecret%40mail.example.org%3A465&from=Hub+%3Chub%40example.org%3E"),

    )

    .await;

    assert!(r.body.contains("smtps://hub:***@mail.example.org:465") && !r.body.contains("secret"), "{}", r.body);

    let r = post(

        app,

        "/admin/mail",

        Some(&andy),

        &format!("_csrf={csrf}&smtp=smtps%3A%2F%2Fhub%3A***%40mail.example.org%3A465&from=Hub+%3Chub%40example.org%3E"),

    )

    .await;

    assert!(r.body.contains("Mail settings saved"), "{}", r.body);

    assert_eq!(oxygenhub::mail::settings(app).smtp, "smtps://hub:[email protected]:465");

    // A bad URL is refused; an empty one turns mail off.

    let r = post(app, "/admin/mail", Some(&andy), &format!("_csrf={csrf}&smtp=mail.example.org&from=x")).await;

    assert!(r.body.contains("starts with smtp://"), "{}", r.body);

    let r = post(app, "/admin/mail", Some(&andy), &format!("_csrf={csrf}&smtp=&from=")).await;

    assert!(r.body.contains("Mail is off"), "{}", r.body);

    assert!(!oxygenhub::mail::enabled(app));

    // Not for everyone.

    let r = post(app, "/admin/mail", None, &format!("_csrf={csrf}&smtp=&from=")).await;

    assert_ne!(r.status, StatusCode::OK);

}

- **Mail.** `[email] smtp` is an `smtp://` or `smtps://` URL, or `file:///path` for development, which writes each message to that directory as a file instead of sending it. Administration has a Mail form (#101) whose SMTP URL and From address, once saved, override `[email]`; the password is shown masked, an empty URL turns mail off, and a button sends a test message to the administrator's own address.

  - A runner's page has a Settings form (#98): labels an administrator gives it beside those it reports (a job asking for a label matches either), and a job time limit in minutes below the site's, applied when it claims.

  <h3>Mail</h3>

  <form class="card" method="post" action="/admin/mail">

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

    <label>SMTP URL</label>

    <input type="text" name="smtp" value="{{ mail_smtp }}" placeholder="smtps://user:[email protected]:465">

    <label>From</label>

    <input type="text" name="from" value="{{ mail_from }}" placeholder="OxygenHub &lt;[email protected]&gt;">

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

  </form>

  <form class="card" method="post" action="/admin/mail/test"><input type="hidden" name="_csrf" value="{{ shell.csrf }}"><button type="submit"{% if !mail_enabled || my_email.is_empty() %} disabled{% endif %}>SEND A TEST{% if !my_email.is_empty() %} TO {{ my_email }}{% endif %}</button></form>

  <p class="small mute">{% if mail_enabled %}Mail is on: verification and reset links go by email.{% else %}Mail is off: verification and reset links are issued by hand.{% endif %} An empty URL turns it off. The password stays on the server and is shown masked.</p>