Checkpoint: Migration to axum

crates/caldav/src/calendar/methods/mkcalendar.rs

@@ -1,13 +1,14 @@
 use crate::Error;
 use crate::calendar::prop::SupportedCalendarComponentSet;
-use actix_web::HttpResponse;
-use actix_web::web::{Data, Path};
+use crate::calendar::resource::CalendarResourceService;
+use axum::extract::{Path, State};
+use axum::response::{IntoResponse, Response};
+use http::StatusCode;
 use rustical_ical::CalendarObjectType;
 use rustical_store::auth::User;
-use rustical_store::{Calendar, CalendarStore};
+use rustical_store::{Calendar, CalendarStore, SubscriptionStore};
 use rustical_xml::{Unparsed, XmlDeserialize, XmlDocument, XmlRootTag};
 use tracing::instrument;
-use tracing_actix_web::RootSpan;
 
 #[derive(XmlDeserialize, Clone, Debug)]
 pub struct MkcolCalendarProp {
@@ -48,15 +49,13 @@ struct MkcalendarRequest {
     set: PropElement,
 }
 
-#[instrument(parent = root_span.id(), skip(store, root_span))]
-pub async fn route_mkcalendar<C: CalendarStore>(
-    path: Path<(String, String)>,
-    body: String,
+#[instrument(skip(cal_store))]
+pub async fn route_mkcalendar<C: CalendarStore, S: SubscriptionStore>(
+    Path((principal, cal_id)): Path<(String, String)>,
     user: User,
-    store: Data<C>,
-    root_span: RootSpan,
-) -> Result<HttpResponse, Error> {
-    let (principal, cal_id) = path.into_inner();
+    State(CalendarResourceService { cal_store, .. }): State<CalendarResourceService<C, S>>,
+    body: String,
+) -> Result<Response, Error> {
     if !user.is_principal(&principal) {
         return Err(Error::Unauthorized);
     }
@@ -87,12 +86,10 @@ pub async fn route_mkcalendar<C: CalendarStore>(
             ]),
     };
 
-    match store.insert_calendar(calendar).await {
+    match cal_store.insert_calendar(calendar).await {
         // The spec says we should return a mkcalendar-response but I don't know what goes into it.
         // However, it works without one but breaks on iPadOS when using an empty one :)
-        Ok(()) => Ok(HttpResponse::Created()
-            .insert_header(("Cache-Control", "no-cache"))
-            .body("")),
+        Ok(()) => Ok(StatusCode::CREATED.into_response()),
         Err(err) => {
             dbg!(err.to_string());
             Err(err.into())

crates/caldav/src/calendar/methods/mod.rs

@@ -1,3 +1,3 @@
 pub mod mkcalendar;
-pub mod post;
+// pub mod post;
 pub mod report;

crates/caldav/src/calendar/methods/post.rs

@@ -1,8 +1,7 @@
 use crate::Error;
 use crate::calendar::resource::{CalendarResource, CalendarResourceService};
-use actix_web::http::header;
-use actix_web::web::{Data, Path};
-use actix_web::{HttpRequest, HttpResponse};
+use axum::extract::{Path, State};
+use axum::response::Response;
 use rustical_dav::privileges::UserPrivilege;
 use rustical_dav::resource::Resource;
 use rustical_dav_push::register::PushRegister;
@@ -10,18 +9,14 @@ use rustical_store::auth::User;
 use rustical_store::{CalendarStore, Subscription, SubscriptionStore};
 use rustical_xml::XmlDocument;
 use tracing::instrument;
-use tracing_actix_web::RootSpan;
 
-#[instrument(parent = root_span.id(), skip(resource_service, root_span, req))]
+#[instrument(skip(resource_service))]
 pub async fn route_post<C: CalendarStore, S: SubscriptionStore>(
-    path: Path<(String, String)>,
-    body: String,
+    Path((principal, cal_id)): Path<(String, String)>,
     user: User,
-    resource_service: Data<CalendarResourceService<C, S>>,
-    root_span: RootSpan,
-    req: HttpRequest,
-) -> Result<HttpResponse, Error> {
-    let (principal, cal_id) = path.into_inner();
+    State(resource_service): State<CalendarResourceService<C, S>>,
+    body: String,
+) -> Result<Response, Error> {
     if !user.is_principal(&principal) {
         return Err(Error::Unauthorized);
     }

crates/caldav/src/calendar/methods/report/calendar_multiget.rs

@@ -1,5 +1,4 @@
 use crate::{Error, calendar_object::resource::CalendarObjectPropWrapperName};
-use actix_web::dev::{Path, ResourceDef};
 use rustical_dav::xml::PropfindType;
 use rustical_ical::CalendarObject;
 use rustical_store::CalendarStore;
@@ -23,23 +22,25 @@ pub async fn get_objects_calendar_multiget<C: CalendarStore>(
     cal_id: &str,
     store: &C,
 ) -> Result<(Vec<CalendarObject>, Vec<String>), Error> {
-    let resource_def = ResourceDef::prefix(path).join(&ResourceDef::new("/{object_id}.ics"));
-
     let mut result = vec![];
     let mut not_found = vec![];
 
     for href in &cal_query.href {
-        let mut path = Path::new(href.as_str());
-        if !resource_def.capture_match_info(&mut path) {
+        if let Some(filename) = href.strip_prefix(path) {
+            if let Some(object_id) = filename.strip_suffix(".ics") {
+                match store.get_object(principal, cal_id, object_id).await {
+                    Ok(object) => result.push(object),
+                    Err(rustical_store::Error::NotFound) => not_found.push(href.to_owned()),
+                    Err(err) => return Err(err.into()),
+                };
+            } else {
+                not_found.push(href.to_owned());
+                continue;
+            }
+        } else {
             not_found.push(href.to_owned());
             continue;
-        };
-        let object_id = path.get("object_id").unwrap();
-        match store.get_object(principal, cal_id, object_id).await {
-            Ok(object) => result.push(object),
-            Err(rustical_store::Error::NotFound) => not_found.push(href.to_owned()),
-            Err(err) => return Err(err.into()),
-        };
+        }
     }
 
     Ok((result, not_found))

crates/caldav/src/calendar/methods/report/mod.rs

@@ -1,12 +1,14 @@
 use crate::{
     CalDavPrincipalUri, Error,
+    calendar::resource::CalendarResourceService,
     calendar_object::resource::{
         CalendarObjectPropWrapper, CalendarObjectPropWrapperName, CalendarObjectResource,
     },
 };
-use actix_web::{
-    HttpRequest, Responder,
-    web::{Data, Path},
+use axum::{
+    Extension,
+    extract::{OriginalUri, Path, State},
+    response::IntoResponse,
 };
 use calendar_multiget::{CalendarMultigetRequest, get_objects_calendar_multiget};
 use calendar_query::{CalendarQueryRequest, get_objects_calendar_query};
@@ -19,7 +21,7 @@ use rustical_dav::{
     },
 };
 use rustical_ical::CalendarObject;
-use rustical_store::{CalendarStore, auth::User};
+use rustical_store::{CalendarStore, SubscriptionStore, auth::User};
 use rustical_xml::{XmlDeserialize, XmlDocument};
 use sync_collection::handle_sync_collection;
 use tracing::instrument;
@@ -85,16 +87,15 @@ fn objects_response(
     })
 }
 
-#[instrument(skip(req, cal_store))]
-pub async fn route_report_calendar<C: CalendarStore>(
-    path: Path<(String, String)>,
-    body: String,
+#[instrument(skip(cal_store))]
+pub async fn route_report_calendar<C: CalendarStore, S: SubscriptionStore>(
+    Path((principal, cal_id)): Path<(String, String)>,
     user: User,
-    req: HttpRequest,
-    puri: Data<CalDavPrincipalUri>,
-    cal_store: Data<C>,
-) -> Result<impl Responder, Error> {
-    let (principal, cal_id) = path.into_inner();
+    Extension(puri): Extension<CalDavPrincipalUri>,
+    State(CalendarResourceService { cal_store, .. }): State<CalendarResourceService<C, S>>,
+    OriginalUri(uri): OriginalUri,
+    body: String,
+) -> Result<impl IntoResponse, Error> {
     if !user.is_principal(&principal) {
         return Err(Error::Unauthorized);
     }
@@ -107,20 +108,12 @@ pub async fn route_report_calendar<C: CalendarStore>(
             let objects =
                 get_objects_calendar_query(cal_query, &principal, &cal_id, cal_store.as_ref())
                     .await?;
-            objects_response(
-                objects,
-                vec![],
-                req.path(),
-                &principal,
-                puri.as_ref(),
-                &user,
-                props,
-            )?
+            objects_response(objects, vec![], uri.path(), &principal, &puri, &user, props)?
         }
         ReportRequest::CalendarMultiget(cal_multiget) => {
             let (objects, not_found) = get_objects_calendar_multiget(
                 cal_multiget,
-                req.path(),
+                uri.path(),
                 &principal,
                 &cal_id,
                 cal_store.as_ref(),
@@ -129,9 +122,9 @@ pub async fn route_report_calendar<C: CalendarStore>(
             objects_response(
                 objects,
                 not_found,
-                req.path(),
+                uri.path(),
                 &principal,
-                puri.as_ref(),
+                &puri,
                 &user,
                 props,
             )?
@@ -139,8 +132,8 @@ pub async fn route_report_calendar<C: CalendarStore>(
         ReportRequest::SyncCollection(sync_collection) => {
             handle_sync_collection(
                 sync_collection,
-                req.path(),
-                puri.as_ref(),
+                uri.path(),
+                &puri,
                 &user,
                 &principal,
                 &cal_id,