opendal/services/webdav/
core.rs

1// Licensed to the Apache Software Foundation (ASF) under one
2// or more contributor license agreements.  See the NOTICE file
3// distributed with this work for additional information
4// regarding copyright ownership.  The ASF licenses this file
5// to you under the Apache License, Version 2.0 (the
6// "License"); you may not use this file except in compliance
7// with the License.  You may obtain a copy of the License at
8//
9//   http://www.apache.org/licenses/LICENSE-2.0
10//
11// Unless required by applicable law or agreed to in writing,
12// software distributed under the License is distributed on an
13// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14// KIND, either express or implied.  See the License for the
15// specific language governing permissions and limitations
16// under the License.
17
18use bytes::Bytes;
19use http::header;
20use http::Request;
21use http::Response;
22use http::StatusCode;
23use serde::Deserialize;
24use std::collections::VecDeque;
25use std::fmt;
26use std::fmt::Debug;
27use std::fmt::Formatter;
28use std::sync::Arc;
29
30use super::error::parse_error;
31use crate::raw::*;
32use crate::*;
33
34/// The request to query all properties of a file or directory.
35///
36/// rfc4918 9.1: retrieve all properties define in specification
37static PROPFIND_REQUEST: &str = r#"<?xml version="1.0" encoding="utf-8" ?><D:propfind xmlns:D="DAV:"><D:allprop/></D:propfind>"#;
38
39/// The header to specify the depth of the query.
40///
41/// Valid values are `0`, `1`, `infinity`.
42///
43/// - `0`: only to the resource itself.
44/// - `1`: to the resource and its internal members only.
45/// - `infinity`: to the resource and all its members.
46///
47/// reference: [RFC4918: 10.2. Depth Header](https://datatracker.ietf.org/doc/html/rfc4918#section-10.2)
48static HEADER_DEPTH: &str = "Depth";
49/// The header to specify the destination of the query.
50///
51/// The Destination request header specifies the URI that identifies a
52/// destination resource for methods such as COPY and MOVE, which take
53/// two URIs as parameters.
54///
55/// reference: [RFC4918: 10.3.  Destination Header](https://datatracker.ietf.org/doc/html/rfc4918#section-10.3)
56static HEADER_DESTINATION: &str = "Destination";
57/// The header to specify the overwrite behavior of the query
58///
59/// The Overwrite request header specifies whether the server should
60/// overwrite a resource mapped to the destination URL during a COPY or
61/// MOVE.
62///
63/// Valid values are `T` and `F`.
64///
65/// A value of "F" states that the server must not perform the COPY or MOVE operation
66/// if the destination URL does map to a resource.
67///
68/// reference: [RFC4918: 10.6.  Overwrite Header](https://datatracker.ietf.org/doc/html/rfc4918#section-10.6)
69static HEADER_OVERWRITE: &str = "Overwrite";
70
71pub struct WebdavCore {
72    pub info: Arc<AccessorInfo>,
73    pub endpoint: String,
74    pub server_path: String,
75    pub root: String,
76    pub authorization: Option<String>,
77}
78
79impl Debug for WebdavCore {
80    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
81        f.debug_struct("WebdavCore")
82            .field("endpoint", &self.endpoint)
83            .field("root", &self.root)
84            .finish_non_exhaustive()
85    }
86}
87
88impl WebdavCore {
89    pub async fn webdav_stat(&self, path: &str) -> Result<Metadata> {
90        let path = build_rooted_abs_path(&self.root, path);
91        self.webdav_stat_rooted_abs_path(&path).await
92    }
93
94    /// Input path must be `rooted_abs_path`.
95    async fn webdav_stat_rooted_abs_path(&self, rooted_abs_path: &str) -> Result<Metadata> {
96        let url = format!("{}{}", self.endpoint, percent_encode_path(rooted_abs_path));
97        let mut req = Request::builder().method("PROPFIND").uri(url);
98
99        req = req.header(header::CONTENT_TYPE, "application/xml");
100        req = req.header(header::CONTENT_LENGTH, PROPFIND_REQUEST.len());
101        if let Some(auth) = &self.authorization {
102            req = req.header(header::AUTHORIZATION, auth);
103        }
104
105        // Only stat the resource itself.
106        req = req.header(HEADER_DEPTH, "0");
107
108        let req = req
109            .body(Buffer::from(Bytes::from(PROPFIND_REQUEST)))
110            .map_err(new_request_build_error)?;
111
112        let resp = self.info.http_client().send(req).await?;
113        if !resp.status().is_success() {
114            return Err(parse_error(resp));
115        }
116
117        let bs = resp.into_body();
118
119        let result: Multistatus = deserialize_multistatus(&bs.to_bytes())?;
120        let propfind_resp = result.response.first().ok_or_else(|| {
121            Error::new(
122                ErrorKind::NotFound,
123                "propfind response is empty, the resource is not exist",
124            )
125        })?;
126
127        let metadata = parse_propstat(&propfind_resp.propstat)?;
128        Ok(metadata)
129    }
130
131    pub async fn webdav_get(
132        &self,
133        path: &str,
134        range: BytesRange,
135        _: &OpRead,
136    ) -> Result<Response<HttpBody>> {
137        let path = build_rooted_abs_path(&self.root, path);
138        let url: String = format!("{}{}", self.endpoint, percent_encode_path(&path));
139
140        let mut req = Request::get(&url);
141
142        if let Some(auth) = &self.authorization {
143            req = req.header(header::AUTHORIZATION, auth.clone())
144        }
145
146        if !range.is_full() {
147            req = req.header(header::RANGE, range.to_header());
148        }
149
150        let req = req.body(Buffer::new()).map_err(new_request_build_error)?;
151
152        self.info.http_client().fetch(req).await
153    }
154
155    pub async fn webdav_put(
156        &self,
157        path: &str,
158        size: Option<u64>,
159        args: &OpWrite,
160        body: Buffer,
161    ) -> Result<Response<Buffer>> {
162        let path = build_rooted_abs_path(&self.root, path);
163        let url = format!("{}{}", self.endpoint, percent_encode_path(&path));
164
165        let mut req = Request::put(&url);
166
167        if let Some(v) = &self.authorization {
168            req = req.header(header::AUTHORIZATION, v)
169        }
170
171        if let Some(v) = size {
172            req = req.header(header::CONTENT_LENGTH, v)
173        }
174
175        if let Some(v) = args.content_type() {
176            req = req.header(header::CONTENT_TYPE, v)
177        }
178
179        if let Some(v) = args.content_disposition() {
180            req = req.header(header::CONTENT_DISPOSITION, v)
181        }
182
183        let req = req.body(body).map_err(new_request_build_error)?;
184
185        self.info.http_client().send(req).await
186    }
187
188    pub async fn webdav_delete(&self, path: &str) -> Result<Response<Buffer>> {
189        let path = build_rooted_abs_path(&self.root, path);
190        let url = format!("{}{}", self.endpoint, percent_encode_path(&path));
191
192        let mut req = Request::delete(&url);
193
194        if let Some(auth) = &self.authorization {
195            req = req.header(header::AUTHORIZATION, auth.clone())
196        }
197
198        let req = req.body(Buffer::new()).map_err(new_request_build_error)?;
199
200        self.info.http_client().send(req).await
201    }
202
203    pub async fn webdav_copy(&self, from: &str, to: &str) -> Result<Response<Buffer>> {
204        // Check if source file exists.
205        let _ = self.webdav_stat(from).await?;
206        // Make sure target's dir is exist.
207        self.webdav_mkcol(get_parent(to)).await?;
208
209        let source = build_rooted_abs_path(&self.root, from);
210        let source_uri = format!("{}{}", self.endpoint, percent_encode_path(&source));
211
212        let target = build_rooted_abs_path(&self.root, to);
213        let target_uri = format!("{}{}", self.endpoint, percent_encode_path(&target));
214
215        let mut req = Request::builder().method("COPY").uri(&source_uri);
216
217        if let Some(auth) = &self.authorization {
218            req = req.header(header::AUTHORIZATION, auth);
219        }
220
221        req = req.header(HEADER_DESTINATION, target_uri);
222        req = req.header(HEADER_OVERWRITE, "T");
223
224        let req = req.body(Buffer::new()).map_err(new_request_build_error)?;
225
226        self.info.http_client().send(req).await
227    }
228
229    pub async fn webdav_move(&self, from: &str, to: &str) -> Result<Response<Buffer>> {
230        // Check if source file exists.
231        let _ = self.webdav_stat(from).await?;
232        // Make sure target's dir is exist.
233        self.webdav_mkcol(get_parent(to)).await?;
234
235        let source = build_rooted_abs_path(&self.root, from);
236        let source_uri = format!("{}{}", self.endpoint, percent_encode_path(&source));
237
238        let target = build_rooted_abs_path(&self.root, to);
239        let target_uri = format!("{}{}", self.endpoint, percent_encode_path(&target));
240
241        let mut req = Request::builder().method("MOVE").uri(&source_uri);
242
243        if let Some(auth) = &self.authorization {
244            req = req.header(header::AUTHORIZATION, auth);
245        }
246
247        req = req.header(HEADER_DESTINATION, target_uri);
248        req = req.header(HEADER_OVERWRITE, "T");
249
250        let req = req.body(Buffer::new()).map_err(new_request_build_error)?;
251
252        self.info.http_client().send(req).await
253    }
254
255    pub async fn webdav_list(&self, path: &str, args: &OpList) -> Result<Response<Buffer>> {
256        let path = build_rooted_abs_path(&self.root, path);
257        let url = format!("{}{}", self.endpoint, percent_encode_path(&path));
258
259        let mut req = Request::builder().method("PROPFIND").uri(&url);
260
261        req = req.header(header::CONTENT_TYPE, "application/xml");
262        req = req.header(header::CONTENT_LENGTH, PROPFIND_REQUEST.len());
263        if let Some(auth) = &self.authorization {
264            req = req.header(header::AUTHORIZATION, auth);
265        }
266
267        if args.recursive() {
268            req = req.header(HEADER_DEPTH, "infinity");
269        } else {
270            req = req.header(HEADER_DEPTH, "1");
271        }
272
273        let req = req
274            .body(Buffer::from(Bytes::from(PROPFIND_REQUEST)))
275            .map_err(new_request_build_error)?;
276
277        self.info.http_client().send(req).await
278    }
279
280    /// Create dir recursively for given path.
281    ///
282    /// # Notes
283    ///
284    /// We only expose this method to the backend since there are dependencies on input path.
285    pub async fn webdav_mkcol(&self, path: &str) -> Result<()> {
286        let path = build_rooted_abs_path(&self.root, path);
287        let mut path = path.as_str();
288
289        let mut dirs = VecDeque::default();
290
291        loop {
292            match self.webdav_stat_rooted_abs_path(path).await {
293                // Dir exists, break the loop.
294                Ok(_) => {
295                    break;
296                }
297                // Dir not found, keep going.
298                Err(err) if err.kind() == ErrorKind::NotFound => {
299                    dirs.push_front(path);
300                    path = get_parent(path);
301                }
302                // Unexpected error found, return it.
303                Err(err) => return Err(err),
304            }
305
306            if path == "/" {
307                break;
308            }
309        }
310
311        for dir in dirs {
312            self.webdav_mkcol_rooted_abs_path(dir).await?;
313        }
314        Ok(())
315    }
316
317    /// Create a dir
318    ///
319    /// Input path must be `rooted_abs_path`
320    ///
321    /// Reference: [RFC4918: 9.3.1.  MKCOL Status Codes](https://datatracker.ietf.org/doc/html/rfc4918#section-9.3.1)
322    async fn webdav_mkcol_rooted_abs_path(&self, rooted_abs_path: &str) -> Result<()> {
323        let url = format!("{}{}", self.endpoint, percent_encode_path(rooted_abs_path));
324
325        let mut req = Request::builder().method("MKCOL").uri(&url);
326
327        if let Some(auth) = &self.authorization {
328            req = req.header(header::AUTHORIZATION, auth.clone())
329        }
330
331        let req = req.body(Buffer::new()).map_err(new_request_build_error)?;
332
333        let resp = self.info.http_client().send(req).await?;
334        let status = resp.status();
335
336        match status {
337            // 201 (Created) - The collection was created.
338            StatusCode::CREATED
339            // 405 (Method Not Allowed) - MKCOL can only be executed on an unmapped URL.
340            //
341            // The MKCOL method can only be performed on a deleted or non-existent resource.
342            // This error means the directory already exists which is allowed by create_dir.
343            | StatusCode::METHOD_NOT_ALLOWED => {
344
345                Ok(())
346            }
347            _ => Err(parse_error(resp)),
348        }
349    }
350}
351
352pub fn deserialize_multistatus(bs: &[u8]) -> Result<Multistatus> {
353    let s = String::from_utf8_lossy(bs);
354    // HACKS! HACKS! HACKS!
355    //
356    // Make sure the string is escaped.
357    // Related to <https://github.com/tafia/quick-xml/issues/719>
358    //
359    // This is a temporary solution, we should find a better way to handle this.
360    let s = s.replace("&()_+-=;", "%26%28%29_%2B-%3D%3B");
361
362    quick_xml::de::from_str(&s).map_err(new_xml_deserialize_error)
363}
364
365pub fn parse_propstat(propstat: &Propstat) -> Result<Metadata> {
366    let Propstat {
367        prop:
368            Prop {
369                getlastmodified,
370                getcontentlength,
371                getcontenttype,
372                getetag,
373                resourcetype,
374                ..
375            },
376        status,
377    } = propstat;
378
379    if let [_, code, text] = status.splitn(3, ' ').collect::<Vec<_>>()[..3] {
380        // As defined in https://tools.ietf.org/html/rfc2068#section-6.1
381        let code = code.parse::<u16>().unwrap();
382        if code >= 400 {
383            return Err(Error::new(
384                ErrorKind::Unexpected,
385                format!("propfind response is unexpected: {} {}", code, text),
386            ));
387        }
388    }
389
390    let mode: EntryMode = if resourcetype.value == Some(ResourceType::Collection) {
391        EntryMode::DIR
392    } else {
393        EntryMode::FILE
394    };
395    let mut m = Metadata::new(mode);
396
397    if let Some(v) = getcontentlength {
398        m.set_content_length(v.parse::<u64>().unwrap());
399    }
400
401    if let Some(v) = getcontenttype {
402        m.set_content_type(v);
403    }
404
405    if let Some(v) = getetag {
406        m.set_etag(v);
407    }
408
409    // https://www.rfc-editor.org/rfc/rfc4918#section-14.18
410    m.set_last_modified(parse_datetime_from_rfc2822(getlastmodified)?);
411
412    // the storage services have returned all the properties
413    Ok(m)
414}
415
416#[derive(Deserialize, Debug, PartialEq, Eq, Clone, Default)]
417#[serde(default)]
418pub struct Multistatus {
419    pub response: Vec<PropfindResponse>,
420}
421
422#[derive(Deserialize, Debug, PartialEq, Eq, Clone)]
423pub struct PropfindResponse {
424    pub href: String,
425    pub propstat: Propstat,
426}
427
428#[derive(Deserialize, Debug, PartialEq, Eq, Clone)]
429pub struct Propstat {
430    pub status: String,
431    pub prop: Prop,
432}
433
434#[derive(Deserialize, Debug, PartialEq, Eq, Clone)]
435pub struct Prop {
436    pub getlastmodified: String,
437    pub getetag: Option<String>,
438    pub getcontentlength: Option<String>,
439    pub getcontenttype: Option<String>,
440    pub resourcetype: ResourceTypeContainer,
441}
442
443#[derive(Deserialize, Debug, PartialEq, Eq, Clone)]
444pub struct ResourceTypeContainer {
445    #[serde(rename = "$value")]
446    pub value: Option<ResourceType>,
447}
448
449#[derive(Deserialize, Debug, PartialEq, Eq, Clone)]
450#[serde(rename_all = "lowercase")]
451pub enum ResourceType {
452    Collection,
453}
454
455#[cfg(test)]
456mod tests {
457    use quick_xml::de::from_str;
458
459    use super::*;
460
461    #[test]
462    fn test_propstat() {
463        let xml = r#"<D:propstat>
464            <D:prop>
465                <D:displayname>/</D:displayname>
466                <D:getlastmodified>Tue, 01 May 2022 06:39:47 GMT</D:getlastmodified>
467                <D:resourcetype><D:collection/></D:resourcetype>
468                <D:lockdiscovery/>
469                <D:supportedlock>
470                    <D:lockentry>
471                        <D:lockscope><D:exclusive/></D:lockscope>
472                        <D:locktype><D:write/></D:locktype>
473                    </D:lockentry>
474                </D:supportedlock>
475            </D:prop>
476            <D:status>HTTP/1.1 200 OK</D:status>
477        </D:propstat>"#;
478
479        let propstat = from_str::<Propstat>(xml).unwrap();
480        assert_eq!(
481            propstat.prop.getlastmodified,
482            "Tue, 01 May 2022 06:39:47 GMT"
483        );
484        assert_eq!(
485            propstat.prop.resourcetype.value.unwrap(),
486            ResourceType::Collection
487        );
488
489        assert_eq!(propstat.status, "HTTP/1.1 200 OK");
490    }
491
492    #[test]
493    fn test_response_simple() {
494        let xml = r#"<D:response>
495            <D:href>/</D:href>
496            <D:propstat>
497                <D:prop>
498                    <D:displayname>/</D:displayname>
499                    <D:getlastmodified>Tue, 01 May 2022 06:39:47 GMT</D:getlastmodified>
500                    <D:resourcetype><D:collection/></D:resourcetype>
501                    <D:lockdiscovery/>
502                    <D:supportedlock>
503                        <D:lockentry>
504                            <D:lockscope><D:exclusive/></D:lockscope>
505                            <D:locktype><D:write/></D:locktype>
506                        </D:lockentry>
507                    </D:supportedlock>
508                </D:prop>
509                <D:status>HTTP/1.1 200 OK</D:status>
510            </D:propstat>
511        </D:response>"#;
512
513        let response = from_str::<PropfindResponse>(xml).unwrap();
514        assert_eq!(response.href, "/");
515
516        assert_eq!(
517            response.propstat.prop.getlastmodified,
518            "Tue, 01 May 2022 06:39:47 GMT"
519        );
520        assert_eq!(
521            response.propstat.prop.resourcetype.value.unwrap(),
522            ResourceType::Collection
523        );
524        assert_eq!(response.propstat.status, "HTTP/1.1 200 OK");
525    }
526
527    #[test]
528    fn test_response_file() {
529        let xml = r#"<D:response>
530        <D:href>/test_file</D:href>
531        <D:propstat>
532          <D:prop>
533            <D:displayname>test_file</D:displayname>
534            <D:getcontentlength>1</D:getcontentlength>
535            <D:getlastmodified>Tue, 07 May 2022 05:52:22 GMT</D:getlastmodified>
536            <D:resourcetype></D:resourcetype>
537            <D:lockdiscovery />
538            <D:supportedlock>
539              <D:lockentry>
540                <D:lockscope>
541                  <D:exclusive />
542                </D:lockscope>
543                <D:locktype>
544                  <D:write />
545                </D:locktype>
546              </D:lockentry>
547            </D:supportedlock>
548          </D:prop>
549          <D:status>HTTP/1.1 200 OK</D:status>
550        </D:propstat>
551      </D:response>"#;
552
553        let response = from_str::<PropfindResponse>(xml).unwrap();
554        assert_eq!(response.href, "/test_file");
555        assert_eq!(
556            response.propstat.prop.getlastmodified,
557            "Tue, 07 May 2022 05:52:22 GMT"
558        );
559        assert_eq!(response.propstat.prop.getcontentlength.unwrap(), "1");
560        assert_eq!(response.propstat.prop.resourcetype.value, None);
561        assert_eq!(response.propstat.status, "HTTP/1.1 200 OK");
562    }
563
564    #[test]
565    fn test_with_multiple_items_simple() {
566        let xml = r#"<D:multistatus xmlns:D="DAV:">
567        <D:response>
568        <D:href>/</D:href>
569        <D:propstat>
570            <D:prop>
571                <D:displayname>/</D:displayname>
572                <D:getlastmodified>Tue, 01 May 2022 06:39:47 GMT</D:getlastmodified>
573                <D:resourcetype><D:collection/></D:resourcetype>
574                <D:lockdiscovery/>
575                <D:supportedlock>
576                    <D:lockentry>
577                        <D:lockscope><D:exclusive/></D:lockscope>
578                        <D:locktype><D:write/></D:locktype>
579                    </D:lockentry>
580                </D:supportedlock>
581            </D:prop>
582            <D:status>HTTP/1.1 200 OK</D:status>
583        </D:propstat>
584    </D:response>
585    <D:response>
586            <D:href>/</D:href>
587            <D:propstat>
588                <D:prop>
589                    <D:displayname>/</D:displayname>
590                    <D:getlastmodified>Tue, 01 May 2022 06:39:47 GMT</D:getlastmodified>
591                    <D:resourcetype><D:collection/></D:resourcetype>
592                    <D:lockdiscovery/>
593                    <D:supportedlock>
594                        <D:lockentry>
595                            <D:lockscope><D:exclusive/></D:lockscope>
596                            <D:locktype><D:write/></D:locktype>
597                        </D:lockentry>
598                    </D:supportedlock>
599                </D:prop>
600                <D:status>HTTP/1.1 200 OK</D:status>
601            </D:propstat>
602        </D:response>
603        </D:multistatus>"#;
604
605        let multistatus = from_str::<Multistatus>(xml).unwrap();
606
607        let response = multistatus.response;
608        assert_eq!(response.len(), 2);
609        assert_eq!(response[0].href, "/");
610        assert_eq!(
611            response[0].propstat.prop.getlastmodified,
612            "Tue, 01 May 2022 06:39:47 GMT"
613        );
614    }
615
616    #[test]
617    fn test_with_multiple_items_mixed() {
618        let xml = r#"<?xml version="1.0" encoding="utf-8"?>
619        <D:multistatus xmlns:D="DAV:">
620          <D:response>
621            <D:href>/</D:href>
622            <D:propstat>
623              <D:prop>
624                <D:displayname>/</D:displayname>
625                <D:getlastmodified>Tue, 07 May 2022 06:39:47 GMT</D:getlastmodified>
626                <D:resourcetype>
627                  <D:collection />
628                </D:resourcetype>
629                <D:lockdiscovery />
630                <D:supportedlock>
631                  <D:lockentry>
632                    <D:lockscope>
633                      <D:exclusive />
634                    </D:lockscope>
635                    <D:locktype>
636                      <D:write />
637                    </D:locktype>
638                  </D:lockentry>
639                </D:supportedlock>
640              </D:prop>
641              <D:status>HTTP/1.1 200 OK</D:status>
642            </D:propstat>
643          </D:response>
644          <D:response>
645            <D:href>/testdir/</D:href>
646            <D:propstat>
647              <D:prop>
648                <D:displayname>testdir</D:displayname>
649                <D:getlastmodified>Tue, 07 May 2022 06:40:10 GMT</D:getlastmodified>
650                <D:resourcetype>
651                  <D:collection />
652                </D:resourcetype>
653                <D:lockdiscovery />
654                <D:supportedlock>
655                  <D:lockentry>
656                    <D:lockscope>
657                      <D:exclusive />
658                    </D:lockscope>
659                    <D:locktype>
660                      <D:write />
661                    </D:locktype>
662                  </D:lockentry>
663                </D:supportedlock>
664              </D:prop>
665              <D:status>HTTP/1.1 200 OK</D:status>
666            </D:propstat>
667          </D:response>
668          <D:response>
669            <D:href>/test_file</D:href>
670            <D:propstat>
671              <D:prop>
672                <D:displayname>test_file</D:displayname>
673                <D:getcontentlength>1</D:getcontentlength>
674                <D:getlastmodified>Tue, 07 May 2022 05:52:22 GMT</D:getlastmodified>
675                <D:resourcetype></D:resourcetype>
676                <D:lockdiscovery />
677                <D:supportedlock>
678                  <D:lockentry>
679                    <D:lockscope>
680                      <D:exclusive />
681                    </D:lockscope>
682                    <D:locktype>
683                      <D:write />
684                    </D:locktype>
685                  </D:lockentry>
686                </D:supportedlock>
687              </D:prop>
688              <D:status>HTTP/1.1 200 OK</D:status>
689            </D:propstat>
690          </D:response>
691        </D:multistatus>"#;
692
693        let multistatus = from_str::<Multistatus>(xml).unwrap();
694
695        let response = multistatus.response;
696        assert_eq!(response.len(), 3);
697        let first_response = &response[0];
698        assert_eq!(first_response.href, "/");
699        assert_eq!(
700            first_response.propstat.prop.getlastmodified,
701            "Tue, 07 May 2022 06:39:47 GMT"
702        );
703
704        let second_response = &response[1];
705        assert_eq!(second_response.href, "/testdir/");
706        assert_eq!(
707            second_response.propstat.prop.getlastmodified,
708            "Tue, 07 May 2022 06:40:10 GMT"
709        );
710
711        let third_response = &response[2];
712        assert_eq!(third_response.href, "/test_file");
713        assert_eq!(
714            third_response.propstat.prop.getlastmodified,
715            "Tue, 07 May 2022 05:52:22 GMT"
716        );
717    }
718
719    #[test]
720    fn test_with_multiple_items_mixed_nginx() {
721        let xml = r#"<?xml version="1.0" encoding="utf-8"?>
722      <D:multistatus xmlns:D="DAV:">
723        <D:response>
724          <D:href>/</D:href>
725          <D:propstat>
726            <D:prop>
727              <D:getlastmodified>Fri, 17 Feb 2023 03:37:22 GMT</D:getlastmodified>
728              <D:resourcetype>
729                <D:collection />
730              </D:resourcetype>
731            </D:prop>
732            <D:status>HTTP/1.1 200 OK</D:status>
733          </D:propstat>
734        </D:response>
735        <D:response>
736          <D:href>/test_file_75</D:href>
737          <D:propstat>
738            <D:prop>
739              <D:getcontentlength>1</D:getcontentlength>
740              <D:getlastmodified>Fri, 17 Feb 2023 03:36:54 GMT</D:getlastmodified>
741              <D:resourcetype></D:resourcetype>
742            </D:prop>
743            <D:status>HTTP/1.1 200 OK</D:status>
744          </D:propstat>
745        </D:response>
746        <D:response>
747          <D:href>/test_file_36</D:href>
748          <D:propstat>
749            <D:prop>
750              <D:getcontentlength>1</D:getcontentlength>
751              <D:getlastmodified>Fri, 17 Feb 2023 03:36:54 GMT</D:getlastmodified>
752              <D:resourcetype></D:resourcetype>
753            </D:prop>
754            <D:status>HTTP/1.1 200 OK</D:status>
755          </D:propstat>
756        </D:response>
757        <D:response>
758          <D:href>/test_file_38</D:href>
759          <D:propstat>
760            <D:prop>
761              <D:getcontentlength>1</D:getcontentlength>
762              <D:getlastmodified>Fri, 17 Feb 2023 03:36:54 GMT</D:getlastmodified>
763              <D:resourcetype></D:resourcetype>
764            </D:prop>
765            <D:status>HTTP/1.1 200 OK</D:status>
766          </D:propstat>
767        </D:response>
768        <D:response>
769          <D:href>/test_file_59</D:href>
770          <D:propstat>
771            <D:prop>
772              <D:getcontentlength>1</D:getcontentlength>
773              <D:getlastmodified>Fri, 17 Feb 2023 03:36:54 GMT</D:getlastmodified>
774              <D:resourcetype></D:resourcetype>
775            </D:prop>
776            <D:status>HTTP/1.1 200 OK</D:status>
777          </D:propstat>
778        </D:response>
779        <D:response>
780          <D:href>/test_file_9</D:href>
781          <D:propstat>
782            <D:prop>
783              <D:getcontentlength>1</D:getcontentlength>
784              <D:getlastmodified>Fri, 17 Feb 2023 03:36:54 GMT</D:getlastmodified>
785              <D:resourcetype></D:resourcetype>
786            </D:prop>
787            <D:status>HTTP/1.1 200 OK</D:status>
788          </D:propstat>
789        </D:response>
790        <D:response>
791          <D:href>/test_file_93</D:href>
792          <D:propstat>
793            <D:prop>
794              <D:getcontentlength>1</D:getcontentlength>
795              <D:getlastmodified>Fri, 17 Feb 2023 03:36:54 GMT</D:getlastmodified>
796              <D:resourcetype></D:resourcetype>
797            </D:prop>
798            <D:status>HTTP/1.1 200 OK</D:status>
799          </D:propstat>
800        </D:response>
801        <D:response>
802          <D:href>/test_file_43</D:href>
803          <D:propstat>
804            <D:prop>
805              <D:getcontentlength>1</D:getcontentlength>
806              <D:getlastmodified>Fri, 17 Feb 2023 03:36:54 GMT</D:getlastmodified>
807              <D:resourcetype></D:resourcetype>
808            </D:prop>
809            <D:status>HTTP/1.1 200 OK</D:status>
810          </D:propstat>
811        </D:response>
812        <D:response>
813          <D:href>/test_file_95</D:href>
814          <D:propstat>
815            <D:prop>
816              <D:getcontentlength>1</D:getcontentlength>
817              <D:getlastmodified>Fri, 17 Feb 2023 03:36:54 GMT</D:getlastmodified>
818              <D:resourcetype></D:resourcetype>
819            </D:prop>
820            <D:status>HTTP/1.1 200 OK</D:status>
821          </D:propstat>
822        </D:response>
823      </D:multistatus>
824      "#;
825
826        let multistatus: Multistatus = from_str(xml).unwrap();
827
828        let response = multistatus.response;
829        assert_eq!(response.len(), 9);
830
831        let first_response = &response[0];
832        assert_eq!(first_response.href, "/");
833        assert_eq!(
834            first_response.propstat.prop.getlastmodified,
835            "Fri, 17 Feb 2023 03:37:22 GMT"
836        );
837    }
838}
opendal/services/webdav/core.rs

opendal/services/webdav/
core.rs
