Attempt at Forgejo Webhook support

Signed-off-by: Maxime “pep” Buquet <pep@bouah.net>

src/bot.rs

@@ -13,7 +13,7 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-use crate::webhook::{format_webhook, WebHook};
+use crate::webhook::{format_webhook, GitlabHook};
 
 use log::debug;
 use xmpp::parsers::message::MessageType;
@@ -74,7 +74,7 @@ impl XmppClient {
 		}
 	}
 
-	pub async fn webhook(&mut self, wh: WebHook) {
+	pub async fn webhook(&mut self, wh: GitlabHook) {
 		debug!("Received Webhook");
 		if let Some(display) = format_webhook(&wh) {
 			debug!("Webhook: {}", display);

src/main.rs

@@ -24,7 +24,7 @@ mod webhook;
 use crate::bot::XmppClient;
 use crate::error::Error;
 use crate::web::webhooks;
-use crate::webhook::WebHook;
+use crate::webhook::Hook;
 
 use std::fs::File;
 use std::io::{Error as IoError, ErrorKind as IoErrorKind, Read};
@@ -130,7 +130,7 @@ async fn main() -> Result<!, Error> {
 		}
 	};
 
-	let (value_tx, mut value_rx) = mpsc::unbounded_channel::<WebHook>();
+	let (value_tx, mut value_rx) = mpsc::unbounded_channel::<Hook>();
 
 	let mut client = XmppClient::new(
 		config.jid,
@@ -169,8 +169,8 @@ async fn main() -> Result<!, Error> {
 				}
 			}
 			wh = value_rx.recv() => {
-				if let Some(wh) = wh {
-					client.webhook(wh).await
+				if let Some(Hook::Gitlab(hook)) = wh {
+					client.webhook(hook).await
 				}
 			}
 		}

src/web.rs

@@ -14,7 +14,7 @@
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 use crate::error::Error;
-use crate::webhook::WebHook;
+use crate::webhook::{ForgejoHook, GitlabHook, Hook};
 
 use std::convert::Infallible;
 use std::sync::{Arc, Mutex};
@@ -36,14 +36,13 @@ fn error_res<E: std::fmt::Debug>(e: E) -> Result<Response<Full<Bytes>>, Infallib
 	Ok(res)
 }
 
-async fn webhooks_inner(req: Request<Incoming>, token: &str) -> Result<WebHook, Error> {
+async fn webhooks_inner(req: Request<Incoming>, token: &str) -> Result<Hook, Error> {
 	match req.method() {
 		&Method::POST => (),
 		_ => return Err(Error::MethodMismatch),
 	}
 
 	debug!("Headers: {:?}", req.headers());
-
 	let headers = req.headers();
 	if let Some(content_type) = headers.get(header::CONTENT_TYPE)
 		&& content_type != "application/json"
@@ -51,27 +50,36 @@ async fn webhooks_inner(req: Request<Incoming>, token: &str) -> Result<WebHook,
 		return Err(Error::InvalidContentType);
 	}
 
-	if let Some(token) = token {
-		match headers.get("X-Gitlab-Token") {
-			Some(val) if val == token => (),
-			_ => return Err(Error::InvalidToken),
-		}
+	if let Some(val) = headers.get("X-Gitlab-Token")
+		&& token != val
+	{
+		return Err(Error::InvalidToken);
+	}
+
+	if let Some(content_type) = headers.get(header::CONTENT_TYPE)
+		&& content_type != "application/json"
+	{
+		return Err(Error::InvalidContentType);
 	}
 
 	let whole_body = req.collect().await?.aggregate();
-	Ok(serde_json::from_reader(whole_body.reader())?)
+	let hook = serde_json::from_reader(whole_body.reader())?;
+	Ok(Hook::Gitlab(hook))
 }
 
 pub async fn webhooks(
 	req: Request<Incoming>,
 	token: &str,
-	value_tx: Arc<Mutex<UnboundedSender<WebHook>>>,
+	value_tx: Arc<Mutex<UnboundedSender<Hook>>>,
 ) -> Result<Response<Full<Bytes>>, Infallible> {
 	match webhooks_inner(req, token).await {
 		Ok(wh) => {
 			debug!("Passed: {:?}", wh);
 
-			value_tx.lock().unwrap().send(wh).unwrap();
+			match wh {
+				hook @ Hook::Gitlab(_) => value_tx.lock().unwrap().send(hook).unwrap(),
+				_ => (),
+			}
 
 			Ok(Response::new(Full::new(Bytes::from("Hello, World!"))))
 		}

src/webhook.rs

@@ -13,12 +13,27 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program. If not, see <https://www.gnu.org/licenses/>.
 
-pub use gitlab::webhooks::{IssueAction, MergeRequestAction, WebHook, WikiPageAction};
+pub use forgejo_hooks::Hook as ForgejoHook;
+pub use gitlab::webhooks::{
+	IssueAction, MergeRequestAction, WebHook as GitlabHook, WikiPageAction,
+};
 use log::debug;
 
-pub fn format_webhook(wh: &WebHook) -> Option<String> {
-	Some(match wh {
-		WebHook::Push(push) => {
+#[derive(Debug)]
+pub enum Hook {
+	Forgejo(ForgejoHook),
+	Gitlab(GitlabHook),
+}
+
+impl From<GitlabHook> for Hook {
+	fn from(hook: GitlabHook) -> Hook {
+		Hook::Gitlab(hook)
+	}
+}
+
+pub fn format_webhook(glh: &GitlabHook) -> Option<String> {
+	Some(match glh {
+		GitlabHook::Push(push) => {
 			if push.ref_ != "refs/heads/main" {
 				// Ignore: Action not on 'main' branch
 				return None;
@@ -45,7 +60,7 @@ pub fn format_webhook(wh: &WebHook) -> Option<String> {
 			}
 			text
 		}
-		WebHook::Issue(issue) => {
+		GitlabHook::Issue(issue) => {
 			let action = match issue.object_attributes.action {
 				Some(IssueAction::Update) => return None,
 				Some(IssueAction::Open) => "opened",
@@ -68,7 +83,7 @@ pub fn format_webhook(wh: &WebHook) -> Option<String> {
 					.unwrap_or("".to_owned())
 			)
 		}
-		WebHook::MergeRequest(merge_req) => {
+		GitlabHook::MergeRequest(merge_req) => {
 			let action = match merge_req.object_attributes.action {
 				Some(MergeRequestAction::Update) => return None,
 				Some(MergeRequestAction::Open) => "opened",
@@ -93,7 +108,7 @@ pub fn format_webhook(wh: &WebHook) -> Option<String> {
 					.unwrap_or("".to_owned())
 			)
 		}
-		WebHook::Note(note) => {
+		GitlabHook::Note(note) => {
 			if let Some(_) = note.snippet {
 				return None;
 			}
@@ -120,11 +135,11 @@ pub fn format_webhook(wh: &WebHook) -> Option<String> {
 				unreachable!()
 			}
 		}
-		WebHook::Build(build) => {
+		GitlabHook::Build(build) => {
 			println!("Build: {:?}", build);
 			return None;
 		}
-		WebHook::WikiPage(page) => {
+		GitlabHook::WikiPage(page) => {
 			let action = match page.object_attributes.action {
 				WikiPageAction::Update => "updated",
 				WikiPageAction::Create => "created",
@@ -138,7 +153,7 @@ pub fn format_webhook(wh: &WebHook) -> Option<String> {
 				page.object_attributes.url,
 			)
 		}
-		_wh => {
+		_glh => {
 			debug!("Webhook not supported");
 			return None;
 		}