bebot/src/main.rs

#[macro_use(anyhow)]
extern crate anyhow;
#[macro_use]
extern crate log;
#[macro_use]
extern crate serde;

mod config;
mod event;

use std::{env, net::IpAddr, process::exit, sync::Arc, time::Duration};

use anyhow::Context;
use constant_time_eq::constant_time_eq;
use event::{GitlabEvent, GitlabEventExt};
use http::StatusCode;
use matrix_sdk::{
    config::SyncSettings,
    room::Joined,
    ruma::{events::room::message::RoomMessageEventContent, OwnedRoomOrAliasId},
    BaseRoom, Client,
};
use warp::Filter;

use crate::event::MergeRequestAction;

async fn build_sync_settings(matrix_client: &Client) -> SyncSettings {
    let mut settings = SyncSettings::default().timeout(Duration::from_secs(30));
    if let Some(token) = matrix_client.sync_token().await {
        settings = settings.token(token);
    }
    settings
}

async fn matrix_connect(config: &config::Config) -> anyhow::Result<Client> {
    let client = Client::builder()
        .server_name(config.user_id.server_name())
        .user_agent(format!("{}/{}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION")))
        .build()
        .await?;
    client
        .login_username(&config.user_id, &config.password)
        .initial_device_display_name("Bebot")
        .send()
        .await?;
    info!("Connected to matrix as {}; waiting for first sync", config.user_id);

    let settings = build_sync_settings(&client).await;
    client.sync_once(settings).await?;
    info!("First matrix sync complete");

    let sync_client = client.clone();
    tokio::spawn(async move {
        let settings = build_sync_settings(&sync_client).await;
        if let Err(err) = sync_client.sync(settings).await {
            error!("Matrix sync failed: {}", err);
            exit(1);
        }
    });

    Ok(client)
}

async fn ensure_matrix_room_joined(matrix_client: &Client, room_id: &OwnedRoomOrAliasId) -> anyhow::Result<Joined> {
    fn room_matches(a_room: &BaseRoom, our_room: &OwnedRoomOrAliasId) -> bool {
        let our_room_str = our_room.as_str();
        a_room.room_id().as_str() == our_room_str
            || a_room
                .canonical_alias()
                .iter()
                .find(|alias| alias.as_str() == our_room_str)
                .is_some()
            || a_room
                .alt_aliases()
                .iter()
                .find(|alias| alias.as_str() == our_room_str)
                .is_some()
    }

    let mut room = matrix_client
        .joined_rooms()
        .iter()
        .find(|a_room| room_matches(*a_room, room_id))
        .map(|room| room.clone());
    if room.is_none() {
        if let Some(invited) = matrix_client
            .invited_rooms()
            .iter()
            .find(|a_room| room_matches(*a_room, room_id))
        {
            invited.accept_invitation().await?;
        } else {
            matrix_client.join_room_by_id_or_alias(room_id, &[]).await?;
        }
        let settings = build_sync_settings(&matrix_client).await;
        matrix_client.sync_once(settings).await?;
        room = matrix_client
            .joined_rooms()
            .iter()
            .find(|a_room| room_matches(*a_room, room_id))
            .map(|room| room.clone());
    }

    room.ok_or_else(|| anyhow!("Unable to join room {}", room_id))
}

fn build_gitlab_message(event: &GitlabEvent) -> String {
    let project = event.project();
    let refname = event
        .r#ref()
        .split('/')
        .last()
        .unwrap_or_else(|| event.r#ref())
        .to_string();
    format!(
        "*{}* {} **{}** [{}]({})",
        project.path_with_namespace,
        refname,
        event.user(),
        event.title(),
        event.url()
    )
}

async fn handle_gitlab_event(
    event: GitlabEvent,
    room_id: &OwnedRoomOrAliasId,
    matrix_client: &Client,
) -> anyhow::Result<()> {
    if let GitlabEvent::MergeRequest { object_attributes, .. } = &event {
        if object_attributes.action == MergeRequestAction::Other {
            return Ok(());
        }
    }

    let room = ensure_matrix_room_joined(matrix_client, room_id).await?;
    let msg = build_gitlab_message(&event);
    debug!("Sending message to {}: {}", room_id, msg);
    let msg_content = RoomMessageEventContent::text_markdown(&msg);
    room.send(msg_content, None).await?;
    Ok(())
}

async fn run() -> anyhow::Result<()> {
    let config_path = env::args()
        .nth(1)
        .ok_or_else(|| anyhow!("Config file should be passed as only parameter"))?;
    let config = Arc::new(config::load(config_path).await?);
    let addr = config
        .bind_address
        .as_ref()
        .map(|ba| ba.clone())
        .unwrap_or_else(|| "127.0.0.1".to_string())
        .parse::<IpAddr>()
        .context("Failed to parse bind_address")?;
    let port = config.bind_port.unwrap_or(3000);

    let matrix_client = matrix_connect(&config).await.context("Failed to connect to Matrix")?;

    let gitlab = warp::path!("hooks" / "gitlab")
        .and(warp::path::end())
        .and(warp::post())
        .and(warp::header::<String>("x-gitlab-token"))
        .and(warp::body::json())
        .then(move |token: String, event: event::GitlabEvent| {
            let config = Arc::clone(&config);
            let matrix_client = matrix_client.clone();

            async move {
                let project = event.project();
                let config_key = project.homepage.replace("http://", "").replace("https://", "");
                if let Some(repo_config) = config.repo_configs.get(&config_key) {
                    if !constant_time_eq(token.as_bytes(), repo_config.token.as_bytes()) {
                        warn!("Invalid token for repo '{}'", config_key);
                        warp::reply::with_status("Invalid token", StatusCode::FORBIDDEN)
                    } else {
                        debug!("payload: {:?}", event);
                        if let Some(room) = repo_config.room.as_ref().or(config.default_room.as_ref()) {
                            if let Err(err) = handle_gitlab_event(event, &room, &matrix_client).await {
                                warn!("Failed to handle payload: {}", err);
                            }
                            warp::reply::with_status("OK", StatusCode::OK)
                        } else {
                            info!("Channel not configured for repo '{}'", config_key);
                            warp::reply::with_status("Matrix room not configured for repo", StatusCode::NOT_FOUND)
                        }
                    }
                } else {
                    info!("Repo '{}' unconfigured", config_key);
                    warp::reply::with_status("Repo not configured", StatusCode::NOT_FOUND)
                }
            }
        });

    let routes = gitlab.with(warp::log("bebot"));

    warp::serve(routes).run((addr, port)).await;

    Ok(())
}

#[tokio::main]
async fn main() {
    let lenv = env_logger::Env::new()
        .filter("BEBOT_LOG")
        .write_style("BEBOT_LOG_STYLE");
    env_logger::init_from_env(lenv);

    if let Err(err) = run().await {
        error!("{}", err);
        exit(1);
    }
}