Coverage / crates/hub/src/db/hooks.rs 90.6%

pub fn format_for_url(url: &str) -> &'static str {

    let host = url.split("://").nth(1).unwrap_or("").split(['/', ':']).next().unwrap_or("").to_ascii_lowercase();

    if matches!(host.as_str(), "discord.com" | "discordapp.com" | "canary.discord.com" | "ptb.discord.com")

        && url.contains("/api/webhooks/")

        "discord"

    } else if host == "hooks.slack.com" {

        "slack"

        "oxygenhub"

}

pub fn masked_url(url: &str) -> String {

    let (scheme, rest) = url.split_once("://").unwrap_or(("", url));

    let (path, query) = rest.split_once('?').map(|(p, q)| (p, Some(q))).unwrap_or((rest, None));

    let parts: Vec<String> =

        path.split('/')

            .enumerate()

            .map(|(i, seg)| {

                if i > 0 && seg.chars().count() > 14 {

                    format!("{}…", seg.chars().take(4).collect::<String>())

                    seg.to_string()

            })

            .collect();

    let mut out = if scheme.is_empty() { parts.join("/") } else { format!("{scheme}://{}", parts.join("/")) };

    if query.is_some() {

        out.push_str("?…");

    }

    out

}

    pub fn wants(&self, event: &str) -> bool {

        self.active && self.events.split(',').map(str::trim).any(|e| e == "*" || event == e || event.starts_with(&format!("{e}.")))

    }

pub async fn hooks_for_repo(pool: &Pool, repo_id: i64) -> sqlx::Result<Vec<Hook>> {

    sqlx::query_as("SELECT * FROM hooks WHERE repo_id = $1 ORDER BY id").bind(repo_id).fetch_all(pool).await

}

pub async fn hooks_for_org(pool: &Pool, org_id: i64) -> sqlx::Result<Vec<Hook>> {

    sqlx::query_as("SELECT * FROM hooks WHERE org_id = $1 ORDER BY id").bind(org_id).fetch_all(pool).await

}

pub async fn hooks_hearing(pool: &Pool, repo_id: i64, owner: &str) -> sqlx::Result<Vec<Hook>> {

    let mut out = hooks_for_repo(pool, repo_id).await?;

    if let Some(org) = super::accounts::org_by_name(pool, owner).await? {

        out.extend(hooks_for_org(pool, org.id).await?);

    }

    Ok(out)

}

pub async fn hook(pool: &Pool, id: i64) -> sqlx::Result<Option<Hook>> {

    sqlx::query_as("SELECT * FROM hooks WHERE id = $1").bind(id).fetch_optional(pool).await

}

pub async fn create_hook(

    pool: &Pool,

    repo_id: Option<i64>,

    org_id: Option<i64>,

    url: &str,

    secret: &str,

    events: &str,

) -> sqlx::Result<Hook> {

    sqlx::query_as(

        "INSERT INTO hooks (repo_id, org_id, url, secret, events, created_ms, format) VALUES ($1, $2, $3, $4, $5, $6, $7) RETURNING *",

    )

    .bind(repo_id)

    .bind(org_id)

    .bind(url)

    .bind(secret)

    .bind(events)

    .bind(now_ms())

    .bind(format_for_url(url))

    .fetch_one(pool)

    .await

}

pub async fn update_hook(

    pool: &Pool,

    id: i64,

    url: Option<&str>,

    secret: Option<&str>,

    events: &str,

    format: &str,

    active: bool,

) -> sqlx::Result<()> {

    sqlx::query(

        "UPDATE hooks SET url = COALESCE($1, url), secret = COALESCE($2, secret), events = $3, format = $4, active = $5 WHERE id = $6",

    )

    .bind(url)

    .bind(secret)

    .bind(events)

    .bind(format)

    .bind(active)

    .bind(id)

    .execute(pool)

    .await?;

    Ok(())

}

pub async fn set_hook_format(pool: &Pool, id: i64, format: &str) -> sqlx::Result<()> {

    sqlx::query("UPDATE hooks SET format = $1 WHERE id = $2").bind(format).bind(id).execute(pool).await?;

    Ok(())

}

pub async fn last_attempt(pool: &Pool, hook_id: i64) -> sqlx::Result<Option<Delivery>> {

    sqlx::query_as("SELECT * FROM deliveries WHERE hook_id = $1 AND attempts > 0 ORDER BY id DESC LIMIT 1")

        .bind(hook_id)

        .fetch_optional(pool)

        .await

}

pub async fn queue_delivery(pool: &Pool, hook_id: i64, delivery: &str, event: &str, payload: &str) -> sqlx::Result<Option<i64>> {

    let waiting: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM deliveries WHERE hook_id = $1 AND delivered_ms IS NULL AND next_ms < $2")

        .bind(hook_id)

        .bind(i64::MAX / 4)

        .fetch_one(pool)

        .await?;

    if waiting >= MAX_WAITING {

        return Ok(None);

    }

    let now = now_ms();

    sqlx::query_scalar(

        "INSERT INTO deliveries (hook_id, delivery, event, payload, created_ms, next_ms) VALUES ($1, $2, $3, $4, $5, $6) RETURNING id",

    )

    .bind(hook_id)

    .bind(delivery)

    .bind(event)

    .bind(payload)

    .bind(now)

    .bind(now)

    .fetch_one(pool)

    .await

    .map(Some)

}

pub async fn due_deliveries(pool: &Pool, limit: i64) -> sqlx::Result<Vec<Delivery>> {

    sqlx::query_as("SELECT * FROM deliveries WHERE delivered_ms IS NULL AND next_ms <= $1 ORDER BY next_ms LIMIT $2")

        .bind(now_ms())

        .bind(limit)

        .fetch_all(pool)

        .await

}

pub async fn deliveries_for_hook(pool: &Pool, hook_id: i64, limit: i64) -> sqlx::Result<Vec<Delivery>> {

    sqlx::query_as("SELECT * FROM deliveries WHERE hook_id = $1 ORDER BY created_ms DESC, id DESC LIMIT $2")

        .bind(hook_id)

        .bind(limit)

        .fetch_all(pool)

        .await

}

pub async fn record_attempt(pool: &Pool, id: i64, attempts: i64, status: Option<i64>, response: &str) -> sqlx::Result<()> {

    let ok = status.is_some_and(|s| (200..300).contains(&s));

    let now = now_ms();

    let delivered: Option<i64> = if ok { Some(now) } else { None };

    let backoff_ms = [60_000i64, 300_000, 1_800_000, 7_200_000, 21_600_000];

    let next = if ok || attempts as usize >= backoff_ms.len() { i64::MAX / 4 } else { now + backoff_ms[attempts as usize] };

    sqlx::query("UPDATE deliveries SET attempts = $1, status = $2, response = $3, delivered_ms = $4, next_ms = $5 WHERE id = $6")

        .bind(attempts + 1)

        .bind(status)

        .bind(response.chars().take(2000).collect::<String>())

        .bind(delivered)

        .bind(next)

        .bind(id)

        .execute(pool)

        .await?;

    Ok(())

}

pub async fn prune_deliveries(pool: &Pool, older_than_ms: i64) -> sqlx::Result<()> {

    sqlx::query("DELETE FROM deliveries WHERE created_ms < $1").bind(older_than_ms).execute(pool).await?;

    Ok(())

}

pub async fn checks_for_state(pool: &Pool, repo_id: i64, state: &str) -> sqlx::Result<Vec<Check>> {

    sqlx::query_as("SELECT * FROM checks WHERE repo_id = $1 AND state = $2 ORDER BY name").bind(repo_id).bind(state).fetch_all(pool).await

}

pub async fn upsert_check(pool: &Pool, repo_id: i64, c: CheckReport<'_>) -> sqlx::Result<Check> {

    let CheckReport { state, name, status, summary, url, reporter, seal } = c;

    let now = now_ms();

    let finished: Option<i64> = if matches!(status, "passed" | "failed" | "cancelled" | "skipped") { Some(now) } else { None };

    sqlx::query_as(

        "INSERT INTO checks (repo_id, state, name, status, summary, url, reporter_id, reporter, seal, started_ms, finished_ms) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11) \

         ON CONFLICT (repo_id, state, name) DO UPDATE SET status = excluded.status, summary = excluded.summary, url = excluded.url, reporter_id = excluded.reporter_id, reporter = excluded.reporter, seal = CASE WHEN excluded.seal = '' THEN checks.seal ELSE excluded.seal END, finished_ms = excluded.finished_ms RETURNING *",

    .bind(repo_id)

    .bind(state)

    .bind(name)

    .bind(status)

    .bind(summary)

    .bind(url)

    .bind(reporter.map(|r| r.0))

    .bind(reporter.map(|r| r.1).unwrap_or(""))

    .bind(seal)

    .bind(now)

    .bind(finished)

    .fetch_one(pool)

    .await

}

pub async fn required_checks(pool: &Pool, repo_id: i64) -> sqlx::Result<Vec<String>> {

    let s: String = sqlx::query_scalar("SELECT required_checks FROM repositories WHERE id = $1").bind(repo_id).fetch_one(pool).await?;

    Ok(s.split(',').map(str::trim).filter(|x| !x.is_empty()).map(String::from).collect())

}

pub async fn set_required_checks(pool: &Pool, repo_id: i64, names: &[String]) -> sqlx::Result<()> {

    sqlx::query("UPDATE repositories SET required_checks = $1 WHERE id = $2").bind(names.join(",")).bind(repo_id).execute(pool).await?;

    Ok(())

}