Remove use of acquire().

Cargo.lock

@@ -1554,7 +1554,7 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
 [[package]]
 name = "microrm"
-version = "0.5.0-rc.3"
+version = "0.5.0-dev"
 dependencies = [
  "clap",
  "lazy_static",
@@ -1569,7 +1569,7 @@ dependencies = [
 
 [[package]]
 name = "microrm-macros"
-version = "0.5.0-rc.3"
+version = "0.5.0-dev"
 dependencies = [
  "convert_case",
  "proc-macro2",

src/ext.rs

@@ -4,6 +4,7 @@ use crate::{
     config::Config,
     schema::{self, UIDCDatabase},
     server::{self, SessionHelper, UIDCRequest},
+    UIDCError,
 };
 
 mod generic_oidc;
@@ -17,25 +18,33 @@ pub trait ExternalAuthenticator {
 
     fn generate_login_url(&self, realm: &str, redirect: &str) -> String;
     fn generate_registration_url(&self, realm: &str, redirect: &str) -> String;
-    fn extract_login_state(&self, req: UIDCRequest) -> impl Future<Output = tide::Response>;
+    fn extract_login_state(
+        &self,
+        req: UIDCRequest,
+    ) -> impl Future<Output = Result<tide::Response, UIDCError>>;
 
-    fn handle_registration(&self, _req: UIDCRequest) -> tide::Response {
-        todo!()
+    fn handle_registration(
+        &self,
+        _req: UIDCRequest,
+    ) -> impl Future<Output = Result<tide::Response, UIDCError>> {
+        std::future::ready(Err(UIDCError::Abort(
+            "handle_registration not implemented for ExternalAuthenticator",
+        )))
     }
 
-    fn handle_matching_login(
+    async fn handle_matching_login(
         &self,
         req: UIDCRequest,
         user: schema::UserID,
         redirect: &str,
-    ) -> tide::Response {
+    ) -> Result<tide::Response, UIDCError> {
         let sh = SessionHelper::new(&req);
-        let mut lease = req.state().pool.acquire().expect("couldn't get lease");
+        let mut lease = req.state().lease().await?;
 
         let Ok((resp, cookie)) = sh.get_or_build_session(&mut lease, &req) else {
-            return tide::Response::builder(500)
+            return Ok(tide::Response::builder(500)
                 .body("error while building session")
-                .build();
+                .build());
         };
 
         let realm_id = sh.get_realm(&mut lease).unwrap().id();
@@ -64,18 +73,22 @@ pub trait ExternalAuthenticator {
             resp.insert_cookie(cookie);
         }
 
-        return resp;
+        Ok(resp)
     }
 
-    fn handle_no_mapping(&self, req: UIDCRequest, redirect: String) -> tide::Response {
+    fn handle_no_mapping(
+        &self,
+        req: UIDCRequest,
+        redirect: String,
+    ) -> impl std::future::Future<Output = Result<tide::Response, UIDCError>> {
         let sh = SessionHelper::new(&req);
 
-        return sh.render_login_from_auth(
+        std::future::ready(Ok(sh.render_login_from_auth(
             tide::Response::new(200),
             redirect,
             None,
             Some("External user not associated with any local user.".to_string()),
-        );
+        )))
     }
 }
 

src/ext/github.rs

@@ -5,6 +5,7 @@ use crate::{
     config::Config,
     schema::{self, UIDCDatabase},
     server::{ServerStateWrapper, UIDCRequest},
+    UIDCError,
 };
 
 #[derive(Debug, Clone, Deserialize)]
@@ -45,7 +46,7 @@ impl super::ExternalAuthenticator for GithubAuthenticator {
     fn register_routes(&'static self, server: &mut tide::Server<ServerStateWrapper>) {
         server
             .at("/:realm/github_return")
-            .get(|req: UIDCRequest| async { Ok(self.extract_login_state(req).await) });
+            .get(|req: UIDCRequest| async { Ok(self.extract_login_state(req).await?) });
     }
 
     fn generate_login_url(&self, realm: &str, redirect: &str) -> String {
@@ -91,7 +92,7 @@ impl super::ExternalAuthenticator for GithubAuthenticator {
     fn extract_login_state(
         &self,
         req: UIDCRequest,
-    ) -> impl smol::prelude::Future<Output = tide::Response> {
+    ) -> impl smol::prelude::Future<Output = Result<tide::Response, UIDCError>> {
         async move {
             let state = req.state();
             let realm = req.param("realm").unwrap();
@@ -103,9 +104,9 @@ impl super::ExternalAuthenticator for GithubAuthenticator {
                 mode: CallbackRequestType,
             }
             let Ok(query) = req.query::<Query>() else {
-                return tide::Response::builder(400)
+                return Ok(tide::Response::builder(400)
                     .body("Query string invalid.")
-                    .build();
+                    .build());
             };
 
             #[derive(Deserialize)]
@@ -141,9 +142,9 @@ impl super::ExternalAuthenticator for GithubAuthenticator {
             {
                 Ok(resp) => resp,
                 Err(err) => {
-                    return tide::Response::builder(500)
-                        .body(format!("could not parse Github response for token: {err}"))
-                        .build()
+                    return Err(UIDCError::AbortString(format!(
+                        "could not parse Github response for token: {err}"
+                    )))
                 }
             };
 
@@ -167,18 +168,18 @@ impl super::ExternalAuthenticator for GithubAuthenticator {
             {
                 Ok(resp) => resp,
                 Err(err) => {
-                    return tide::Response::builder(500)
-                        .body(format!("could not parse Github response for token: {err}"))
-                        .build()
+                    return Err(UIDCError::AbortString(format!(
+                        "could not parse Github response for token: {err}"
+                    )))
                 }
             };
 
             let user_id = resp.id.to_string();
 
-            let mut lease = state.pool.acquire().expect("could not acquire lease");
+            let mut lease = state.lease().await?;
 
             let Some(realm) = state.db.realms.keyed(realm).get(&mut lease).ok().flatten() else {
-                return tide::Response::builder(404).body("no such realm").build();
+                return Ok(tide::Response::builder(404).body("no such realm").build());
             };
 
             let external_auth_map = realm
@@ -195,9 +196,12 @@ impl super::ExternalAuthenticator for GithubAuthenticator {
             match (query.mode, external_auth_map) {
                 (CallbackRequestType::Login, Some(map)) => {
                     self.handle_matching_login(req, map.internal_user_id, query.redirect.as_str())
+                        .await
                 }
-                (CallbackRequestType::Login, None) => self.handle_no_mapping(req, query.redirect),
-                (CallbackRequestType::Register, _) => self.handle_registration(req),
+                (CallbackRequestType::Login, None) => {
+                    self.handle_no_mapping(req, query.redirect).await
+                }
+                (CallbackRequestType::Register, _) => self.handle_registration(req).await,
             }
         }
     }

src/server.rs

@@ -28,7 +28,7 @@ pub struct ServerStateWrapper {
 }
 
 impl ServerStateWrapper {
-    async fn lease(&self) -> Result<microrm::ConnectionLease, microrm::Error> {
+    pub async fn lease(&self) -> Result<microrm::ConnectionLease, microrm::Error> {
         self.pool.acquire_async().await
     }
 }