Basic gitea client.

So far it only supports listing the contents of a repo.

src/gitea_client/mod.rs

@@ -0,0 +1,68 @@
+use serde::Deserialize;
+use tracing::debug;
+
+#[derive(Debug, Clone)]
+pub(crate) struct GiteaClient {
+    api_root: String,
+    token: String,
+    http_client: reqwest::Client,
+}
+
+impl GiteaClient {
+    pub(crate) fn new<R: Into<String>, T: Into<String>>(api_root: R, token: T) -> GiteaClient {
+        GiteaClient {
+            api_root: api_root.into(),
+            token: token.into(),
+            http_client: reqwest::Client::new(),
+        }
+    }
+
+    pub(crate) async fn get_tree<O: AsRef<str>, R: AsRef<str>, C: AsRef<str>>(
+        &self,
+        owner: O,
+        repo: R,
+        commit: C,
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        let url = format!(
+            "{api_root}/v1/repos/{owner}/{repo}/git/trees/{commit}?recursive=true&per_page=10",
+            api_root = self.api_root,
+            owner = owner.as_ref(),
+            repo = repo.as_ref(),
+            commit = commit.as_ref()
+        );
+        let response = self
+            .http_client
+            .get(url)
+            .header("Authorization", format!("token {}", self.token))
+            .send()
+            .await?;
+        let response = response.error_for_status()?;
+        let body = response.text().await?;
+        debug!("Response: {}", body);
+        let parsed_body: ResponseGetTree = serde_json::from_str(body.as_str())?;
+        println!("Response: {:#?}", parsed_body);
+        Ok(())
+    }
+}
+
+/// A single API response for GetTree containing only one page.
+#[derive(Debug, Deserialize)]
+struct ResponseGetTree {
+    sha: String,
+    url: String,
+    tree: Vec<ResponseObjectReference>,
+    truncated: bool,
+    page: u64,
+    total_count: u64,
+}
+
+#[derive(Debug, Deserialize)]
+struct ResponseObjectReference {
+    path: String,
+    mode: String,
+    #[serde(rename = "type")]
+    object_type: String,
+    size: u64,
+    sha: String,
+    url: String,
+}

src/main.rs

@@ -19,11 +19,13 @@ use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::util::SubscriberInitExt;
 
 use self::crd_pipeline_run::PipelineRun;
+use self::gitea_client::GiteaClient;
 use self::webhook::hook;
 use self::webhook::verify_signature;
 use kube::CustomResourceExt;
 
 mod crd_pipeline_run;
+mod gitea_client;
 mod hook_push;
 mod webhook;
 
@@ -44,6 +46,18 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .await
         .expect("Set KUBECONFIG to a valid kubernetes config.");
 
+    let gitea_api_root = std::env::var("WEBHOOK_BRIDGE_API_ROOT")?;
+    let gitea_api_token = std::env::var("WEBHOOK_BRIDGE_OAUTH_TOKEN")?;
+    let gitea = GiteaClient::new(gitea_api_root, gitea_api_token);
+
+    gitea
+        .get_tree(
+            "talexander",
+            "organic",
+            "841a348dd02f31ee8828f069b2a948712369069d",
+        )
+        .await?;
+
     // let jobs: Api<PipelineRun> = Api::namespaced(kubernetes_client, "lighthouse");
     // let jobs: Api<PipelineRun> = Api::default_namespaced(kubernetes_client);
     // tracing::info!("Using crd: {}", serde_json::to_string(&PipelineRun::crd())?);
@@ -53,28 +67,32 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // let pp = PostParams::default();
     // let created_run = jobs.create(&pp, &test_run).await?;
 
-    let app = Router::new()
-        .route("/hook", post(hook))
-        .layer(middleware::from_fn(verify_signature))
-        .route("/health", get(health))
-        .layer((
-            TraceLayer::new_for_http(),
-            // Add a timeout layer so graceful shutdown can't wait forever.
-            TimeoutLayer::new(Duration::from_secs(600)),
-        ))
-        .with_state(AppState { kubernetes_client });
+    // let app = Router::new()
+    //     .route("/hook", post(hook))
+    //     .layer(middleware::from_fn(verify_signature))
+    //     .route("/health", get(health))
+    //     .layer((
+    //         TraceLayer::new_for_http(),
+    //         // Add a timeout layer so graceful shutdown can't wait forever.
+    //         TimeoutLayer::new(Duration::from_secs(600)),
+    //     ))
+    //     .with_state(AppState {
+    //         kubernetes_client,
+    //         gitea,
+    //     });
 
-    let listener = tokio::net::TcpListener::bind("0.0.0.0:9988").await?;
-    tracing::info!("listening on {}", listener.local_addr().unwrap());
-    axum::serve(listener, app)
-        .with_graceful_shutdown(shutdown_signal())
-        .await?;
+    // let listener = tokio::net::TcpListener::bind("0.0.0.0:9988").await?;
+    // tracing::info!("listening on {}", listener.local_addr().unwrap());
+    // axum::serve(listener, app)
+    //     .with_graceful_shutdown(shutdown_signal())
+    //     .await?;
     Ok(())
 }
 
 #[derive(Clone)]
 struct AppState {
     kubernetes_client: Client,
+    gitea: GiteaClient,
 }
 
 async fn shutdown_signal() {