Add per-repo config and prepare for org-wide webhook

Cargo.toml

@@ -21,6 +21,8 @@ hex = "0.3.2"
 env_logger = "0.6"
 parser = { path = "parser" }
 rust_team_data = { git = "https://github.com/rust-lang/team" }
+glob = "0.3.0"
+toml = "0.5.0"
 
 [dependencies.serde]
 version = "1"

parser/src/command.rs

@@ -2,15 +2,15 @@ use crate::code_block::ColorCodeBlocks;
 use crate::error::Error;
 use crate::token::{Token, Tokenizer};
 
-pub mod label;
+pub mod relabel;
 
 pub fn find_commmand_start(input: &str, bot: &str) -> Option<usize> {
     input.find(&format!("@{}", bot))
 }
 
 #[derive(Debug)]
 pub enum Command<'a> {
-    Label(Result<label::LabelCommand, Error<'a>>),
+    Relabel(Result<relabel::RelabelCommand, Error<'a>>),
     None,
 }
 
@@ -50,14 +50,14 @@ impl<'a> Input<'a> {
 
         {
             let mut tok = original_tokenizer.clone();
-            let res = label::LabelCommand::parse(&mut tok);
+            let res = relabel::RelabelCommand::parse(&mut tok);
             match res {
                 Ok(None) => {}
                 Ok(Some(cmd)) => {
-                    success.push((tok, Command::Label(Ok(cmd))));
+                    success.push((tok, Command::Relabel(Ok(cmd))));
                 }
                 Err(err) => {
-                    success.push((tok, Command::Label(Err(err))));
+                    success.push((tok, Command::Relabel(Err(err))));
                 }
             }
         }
@@ -94,7 +94,7 @@ impl<'a> Input<'a> {
 impl<'a> Command<'a> {
     pub fn is_ok(&self) -> bool {
         match self {
-            Command::Label(r) => r.is_ok(),
+            Command::Relabel(r) => r.is_ok(),
             Command::None => true,
         }
     }

parser/src/command/label.rs → parser/src/command/relabel.rs

@@ -30,7 +30,7 @@ use std::error::Error as _;
 use std::fmt;
 
 #[derive(Debug)]
-pub struct LabelCommand(pub Vec<LabelDelta>);
+pub struct RelabelCommand(pub Vec<LabelDelta>);
 
 #[derive(Debug, PartialEq, Eq)]
 pub enum LabelDelta {
@@ -124,7 +124,7 @@ fn delta_empty() {
     assert_eq!(err.position(), 1);
 }
 
-impl LabelCommand {
+impl RelabelCommand {
     pub fn parse<'a>(input: &mut Tokenizer<'a>) -> Result<Option<Self>, Error<'a>> {
         let mut toks = input.clone();
         if let Some(Token::Word("modify")) = toks.next_token()? {
@@ -163,7 +163,7 @@ impl LabelCommand {
             if let Some(Token::Dot) | Some(Token::EndOfLine) = toks.peek_token()? {
                 toks.next_token()?;
                 *input = toks;
-                return Ok(Some(LabelCommand(deltas)));
+                return Ok(Some(RelabelCommand(deltas)));
             }
         }
     }
@@ -172,7 +172,7 @@ impl LabelCommand {
 #[cfg(test)]
 fn parse<'a>(input: &'a str) -> Result<Option<Vec<LabelDelta>>, Error<'a>> {
     let mut toks = Tokenizer::new(input);
-    Ok(LabelCommand::parse(&mut toks)?.map(|c| c.0))
+    Ok(RelabelCommand::parse(&mut toks)?.map(|c| c.0))
 }
 
 #[test]

src/config.rs

@@ -0,0 +1,61 @@
+use crate::github::GithubClient;
+use failure::Error;
+use std::collections::HashMap;
+use std::sync::{Arc, RwLock};
+use std::time::{Duration, Instant};
+
+static CONFIG_FILE_NAME: &str = "triagebot.toml";
+const REFRESH_EVERY: Duration = Duration::from_secs(2 * 60); // Every two minutes
+
+lazy_static::lazy_static! {
+    static ref CONFIG_CACHE: RwLock<HashMap<String, (Arc<Config>, Instant)>> =
+        RwLock::new(HashMap::new());
+}
+
+#[derive(serde::Deserialize)]
+pub(crate) struct Config {
+    pub(crate) relabel: Option<RelabelConfig>,
+}
+
+#[derive(serde::Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub(crate) struct RelabelConfig {
+    #[serde(default)]
+    pub(crate) allow_unauthenticated: Vec<String>,
+}
+
+pub(crate) fn get(gh: &GithubClient, repo: &str) -> Result<Arc<Config>, Error> {
+    if let Some(config) = get_cached_config(repo) {
+        Ok(config)
+    } else {
+        get_fresh_config(gh, repo)
+    }
+}
+
+fn get_cached_config(repo: &str) -> Option<Arc<Config>> {
+    let cache = CONFIG_CACHE.read().unwrap();
+    cache.get(repo).and_then(|(config, fetch_time)| {
+        if fetch_time.elapsed() < REFRESH_EVERY {
+            Some(config.clone())
+        } else {
+            None
+        }
+    })
+}
+
+fn get_fresh_config(gh: &GithubClient, repo: &str) -> Result<Arc<Config>, Error> {
+    let contents = gh
+        .raw_file(repo, "master", CONFIG_FILE_NAME)?
+        .ok_or_else(|| {
+            failure::err_msg(
+                "This repository is not enabled to use triagebot.\n\
+                 Add a `triagebot.toml` in the root of the master branch to enable it.",
+            )
+        })?;
+    let config = Arc::new(toml::from_slice::<Config>(&contents)?);
+    CONFIG_CACHE
+        .write()
+        .unwrap()
+        .insert(repo.to_string(), (config.clone(), Instant::now()));
+    Ok(config)
+}

src/github.rs

@@ -1,6 +1,7 @@
 use failure::{Error, ResultExt};
 use reqwest::header::{AUTHORIZATION, USER_AGENT};
-use reqwest::{Client, Error as HttpError, RequestBuilder, Response};
+use reqwest::{Client, Error as HttpError, RequestBuilder, Response, StatusCode};
+use std::io::Read;
 
 #[derive(Debug, serde::Deserialize)]
 pub struct User {
@@ -149,6 +150,46 @@ impl Issue {
     }
 }
 
+#[derive(PartialEq, Eq, Debug, serde::Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum IssueCommentAction {
+    Created,
+    Edited,
+    Deleted,
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub struct IssueCommentEvent {
+    pub action: IssueCommentAction,
+    pub issue: Issue,
+    pub comment: Comment,
+    pub repository: Repository,
+}
+
+#[derive(Debug, serde::Deserialize)]
+pub struct Repository {
+    pub full_name: String,
+}
+
+#[derive(Debug)]
+pub enum Event {
+    IssueComment(IssueCommentEvent),
+}
+
+impl Event {
+    pub fn repo_name(&self) -> &str {
+        match self {
+            Event::IssueComment(event) => &event.repository.full_name,
+        }
+    }
+
+    pub fn issue(&self) -> Option<&Issue> {
+        match self {
+            Event::IssueComment(event) => Some(&event.issue),
+        }
+    }
+}
+
 trait RequestSend: Sized {
     fn configure(self, g: &GithubClient) -> Self;
     fn send_req(self) -> Result<Response, HttpError>;
@@ -183,6 +224,23 @@ impl GithubClient {
         &self.client
     }
 
+    pub fn raw_file(&self, repo: &str, branch: &str, path: &str) -> Result<Option<Vec<u8>>, Error> {
+        let url = format!(
+            "https://raw.githubusercontent.com/{}/{}/{}",
+            repo, branch, path
+        );
+        let mut resp = self.get(&url).send()?;
+        match resp.status() {
+            StatusCode::OK => {
+                let mut buf = Vec::with_capacity(resp.content_length().unwrap_or(4) as usize);
+                resp.read_to_end(&mut buf)?;
+                Ok(Some(buf))
+            }
+            StatusCode::NOT_FOUND => Ok(None),
+            status => failure::bail!("failed to GET {}: {}", url, status),
+        }
+    }
+
     fn get(&self, url: &str) -> RequestBuilder {
         log::trace!("get {:?}", url);
         self.client.get(url).configure(self)

src/handlers.rs

@@ -1,20 +1,51 @@
-use crate::github::GithubClient;
-use crate::registry::HandleRegistry;
-use std::sync::Arc;
+use crate::github::{Event, GithubClient};
+use failure::Error;
 
-//mod assign;
-mod label;
-//mod tracking_issue;
+macro_rules! handlers {
+    ($($name:ident = $handler:expr,)*) => {
+        $(mod $name;)*
 
-pub fn register_all(registry: &mut HandleRegistry, client: GithubClient, username: Arc<String>) {
-    registry.register(label::LabelHandler {
-        client: client.clone(),
-        username: username.clone(),
-    });
-    //registry.register(assign::AssignmentHandler {
-    //    client: client.clone(),
-    //});
-    //registry.register(tracking_issue::TrackingIssueHandler {
-    //    client: client.clone(),
-    //});
+        pub fn handle(ctx: &Context, event: &Event) -> Result<(), Error> {
+            $(if let Some(input) = Handler::parse_input(&$handler, ctx, event)? {
+                let config = crate::config::get(&ctx.github, event.repo_name())?;
+                if let Some(config) = &config.$name {
+                    Handler::handle_input(&$handler, ctx, config, event, input)?;
+                } else {
+                    failure::bail!(
+                        "The feature `{}` is not enabled in this repository.\n\
+                         To enable it add its section in the `triagebot.toml` \
+                         in the root of the repository.",
+                        stringify!($name)
+                    );
+                }
+            })*
+            Ok(())
+        }
+    }
+}
+
+handlers! {
+    //assign = assign::AssignmentHandler,
+    relabel = relabel::RelabelHandler,
+    //tracking_issue = tracking_issue::TrackingIssueHandler,
+}
+
+pub struct Context {
+    pub github: GithubClient,
+    pub username: String,
+}
+
+pub trait Handler: Sync + Send {
+    type Input;
+    type Config;
+
+    fn parse_input(&self, ctx: &Context, event: &Event) -> Result<Option<Self::Input>, Error>;
+
+    fn handle_input(
+        &self,
+        ctx: &Context,
+        config: &Self::Config,
+        event: &Event,
+        input: Self::Input,
+    ) -> Result<(), Error>;
 }