feat(webdav): add list and improve create

.github/workflows/service_test_webdav.yml

@@ -27,6 +27,9 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
+      - name: Install nginx full for dav_ext modules
+        run: sudo apt install nginx-full
+
       - name: Start nginx
         shell: bash
         run: |
@@ -51,6 +54,9 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
+      - name: Install nginx full for dav_ext modules
+        run: sudo apt install nginx-full
+
       - name: Start nginx
         shell: bash
         run: |

src/services/webdav/backend.rs

@@ -12,13 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::collections::HashMap;
-use std::fmt::Debug;
-use std::fmt::Formatter;
-
 use async_trait::async_trait;
 use base64::engine::general_purpose;
 use base64::Engine;
+use bytes::Buf;
 use http::header::AUTHORIZATION;
 use http::header::CONTENT_DISPOSITION;
 use http::header::CONTENT_LENGTH;
@@ -27,8 +24,13 @@ use http::Request;
 use http::Response;
 use http::StatusCode;
 use log::debug;
+use std::collections::HashMap;
+use std::fmt::Debug;
+use std::fmt::Formatter;
 
+use super::dir_stream::DirStream;
 use super::error::parse_error;
+use super::list_response::Multistatus;
 use crate::ops::*;
 use crate::raw::*;
 use crate::*;
@@ -41,7 +43,7 @@ use crate::*;
 ///
 /// - [x] read
 /// - [x] write
-/// - [ ] list
+/// - [x] list
 /// - [ ] ~~scan~~
 /// - [ ] ~~presign~~
 /// - [ ] ~~multipart~~
@@ -52,10 +54,6 @@ use crate::*;
 /// Bazel Remote Caching and Ccache HTTP Storage is also part of this service.
 /// Users can use `webdav` to connect those services.
 ///
-/// # Status
-///
-/// - `list` is not supported so far.
-///
 /// # Configuration
 ///
 /// - `endpoint`: set the endpoint for webdav
@@ -274,23 +272,72 @@ impl Debug for WebdavBackend {
 impl Accessor for WebdavBackend {
     type Reader = IncomingAsyncBody;
     type BlockingReader = ();
-    type Pager = ();
+    type Pager = DirStream;
     type BlockingPager = ();
 
     fn metadata(&self) -> AccessorMetadata {
         let mut ma = AccessorMetadata::default();
         ma.set_scheme(Scheme::Webdav)
             .set_root(&self.root)
-            .set_capabilities(AccessorCapability::Read | AccessorCapability::Write)
+            .set_capabilities(
+                AccessorCapability::Read | AccessorCapability::Write | AccessorCapability::List,
+            )
             .set_hints(AccessorHint::ReadStreamable);
 
         ma
     }
 
-    async fn create(&self, path: &str, _: OpCreate) -> Result<RpCreate> {
+    async fn list(&self, path: &str, args: OpList) -> Result<(RpList, Self::Pager)> {
+        // XML body must start without a new line. Otherwise, the server will panic: `xmlParseChunk() failed`
+        let all_prop_xml_body = r#"<?xml version="1.0" encoding="utf-8" ?>
+            <D:propfind xmlns:D="DAV:">
+                <D:allprop/>
+            </D:propfind>
+        "#;
+
+        let async_body = AsyncBody::Bytes(bytes::Bytes::from(all_prop_xml_body));
         let resp = self
-            .webdav_put(path, Some(0), None, None, AsyncBody::Empty)
+            .webdav_propfind(path, None, "application/xml".into(), async_body)
             .await?;
+        let status = resp.status();
+
+        match status {
+            StatusCode::OK | StatusCode::MULTI_STATUS => {
+                let bs = resp.into_body().bytes().await?;
+                let result: Multistatus =
+                    quick_xml::de::from_reader(bs.reader()).map_err(|err| {
+                        Error::new(ErrorKind::Unexpected, &err.to_string())
+                            .with_context("service", Scheme::Webdav)
+                    })?;
+
+                Ok((
+                    RpList::default(),
+                    DirStream::new(&self.root, path, result, args.limit()),
+                ))
+            }
+            StatusCode::NOT_FOUND if path.ends_with('/') => Ok((
+                RpList::default(),
+                DirStream::new(
+                    &self.root,
+                    path,
+                    Multistatus {
+                        response: Vec::new(),
+                    },
+                    args.limit(),
+                ),
+            )),
+            _ => Err(parse_error(resp).await?),
+        }
+    }
+
+    async fn create(&self, path: &str, _: OpCreate) -> Result<RpCreate> {
+        let resp = if path.ends_with("/") {
+            self.webdav_mkcol(path, None, None, AsyncBody::Empty)
+                .await?
+        } else {
+            self.webdav_put(path, Some(0), None, None, AsyncBody::Empty)
+                .await?
+        };
 
         let status = resp.status();
 
@@ -440,6 +487,67 @@ impl WebdavBackend {
         self.client.send_async(req).await
     }
 
+    async fn webdav_mkcol(
+        &self,
+        path: &str,
+        content_type: Option<&str>,
+        content_disposition: Option<&str>,
+        body: AsyncBody,
+    ) -> Result<Response<IncomingAsyncBody>> {
+        let p = build_abs_path(&self.root, path);
+
+        let url = format!("{}/{}", self.endpoint, percent_encode_path(&p));
+
+        let mut req = Request::builder().method("MKCOL").uri(&url);
+        if !self.authorization.is_empty() {
+            req = req.header(AUTHORIZATION, &self.authorization);
+        }
+
+        if let Some(mime) = content_type {
+            req = req.header(CONTENT_TYPE, mime)
+        }
+
+        if let Some(cd) = content_disposition {
+            req = req.header(CONTENT_DISPOSITION, cd)
+        }
+
+        let req = req.body(body).map_err(new_request_build_error)?;
+
+        self.client.send_async(req).await
+    }
+
+    async fn webdav_propfind(
+        &self,
+        path: &str,
+        size: Option<u64>,
+        content_type: Option<&str>,
+        body: AsyncBody,
+    ) -> Result<Response<IncomingAsyncBody>> {
+        let p = build_abs_path(&self.root, path);
+
+        let url = format!("{}/{}", self.endpoint, percent_encode_path(&p));
+        let mut req = Request::builder()
+            .method("PROPFIND")
+            .uri(&url)
+            .header("Depth", "1");
+
+        if !self.authorization.is_empty() {
+            req = req.header(AUTHORIZATION, &self.authorization);
+        };
+
+        if let Some(size) = size {
+            req = req.header(CONTENT_LENGTH, size)
+        }
+
+        if let Some(mime) = content_type {
+            req = req.header(CONTENT_TYPE, mime)
+        }
+
+        let req = req.body(body).map_err(new_request_build_error)?;
+
+        self.client.send_async(req).await
+    }
+
     async fn webdav_head(&self, path: &str) -> Result<Response<IncomingAsyncBody>> {
         let p = build_rooted_abs_path(&self.root, path);
 

src/services/webdav/dir_stream.rs

@@ -0,0 +1,71 @@
+// Copyright 2022 Datafuse Labs.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use crate::raw::build_rel_path;
+use crate::Result;
+use crate::{raw::output, ObjectMetadata, ObjectMode};
+use async_trait::async_trait;
+
+use super::list_response::Multistatus;
+
+pub struct DirStream {
+    root: String,
+    path: String,
+    size: usize,
+    multistates: Multistatus,
+}
+
+impl DirStream {
+    pub fn new(root: &str, path: &str, multistates: Multistatus, limit: Option<usize>) -> Self {
+        Self {
+            root: root.into(),
+            path: path.into(),
+            size: limit.unwrap_or(1000),
+            multistates,
+        }
+    }
+}
+
+#[async_trait]
+impl output::Page for DirStream {
+    async fn next_page(&mut self) -> Result<Option<Vec<output::Entry>>> {
+        let mut oes: Vec<output::Entry> = Vec::new();
+        for _ in 0..self.size {
+            if let Some(de) = self.multistates.response.pop() {
+                let path = de.href.clone();
+                let normalized_path = &if self.root != path {
+                    build_rel_path(&self.root, &path)
+                } else {
+                    path
+                };
+
+                if normalized_path.eq(&self.path) {
+                    // WebDav server may return the current path as an entry.
+                    continue;
+                }
+
+                let entry = if de.propstat.prop.resourcetype.value
+                    == Some(super::list_response::ResourceType::Collection)
+                {
+                    output::Entry::new(normalized_path, ObjectMetadata::new(ObjectMode::DIR))
+                } else {
+                    output::Entry::new(normalized_path, ObjectMetadata::new(ObjectMode::FILE))
+                };
+                oes.push(entry);
+            }
+        }
+
+        Ok(if oes.is_empty() { None } else { Some(oes) })
+    }
+}

src/services/webdav/fixtures/nginx-with-basic-auth.conf

@@ -1,3 +1,5 @@
+load_module /usr/lib/nginx/modules/ngx_http_dav_ext_module.so;
+
 error_log /tmp/error.log;
 pid       /tmp/nginx.pid;
 
@@ -15,7 +17,8 @@ http {
     location / {
       client_body_temp_path /tmp;
       log_not_found off;
-      dav_methods PUT DELETE;
+      dav_methods PUT DELETE MKCOL;
+      dav_ext_methods PROPFIND;
       create_full_put_path on;
       client_max_body_size 1024M;
       auth_basic           "Administrator’s Area";

src/services/webdav/fixtures/nginx.conf

@@ -1,3 +1,5 @@
+load_module /usr/lib/nginx/modules/ngx_http_dav_ext_module.so;
+
 error_log /tmp/error.log;
 pid       /tmp/nginx.pid;
 
@@ -15,7 +17,8 @@ http {
     location / {
       client_body_temp_path /tmp;
       log_not_found off;
-      dav_methods PUT DELETE;
+      dav_methods PUT DELETE MKCOL;
+      dav_ext_methods PROPFIND;
       create_full_put_path on;
       client_max_body_size 1024M;
     }