Skip to main content

io_webdav/rfc4918/
delete.rs

1//! Generic `DELETE` coroutine (RFC 4918 §9.6).
2//!
3//! Sends a `DELETE` against `path`. Servers may return 204 No Content
4//! (empty body) or a multistatus when the deletion partially failed;
5//! callers inspect the response status to disambiguate.
6//!
7//! # Example
8//!
9//! ```rust,no_run
10//! use std::{
11//!     io::{Read, Write},
12//!     net::TcpStream,
13//! };
14//!
15//! use io_webdav::{
16//!     coroutine::{WebdavCoroutine, WebdavCoroutineState, WebdavYield},
17//!     rfc4918::{WebdavAuth, delete::Delete},
18//! };
19//! use url::Url;
20//!
21//! // Ready stream needed (TCP-connected, TLS-negociated)
22//! let mut stream = TcpStream::connect("dav.example.org:443").unwrap();
23//! let mut buf = [0u8; 4096];
24//!
25//! let base_url: Url = "https://dav.example.org/".parse().unwrap();
26//! let auth = WebdavAuth::None;
27//! let mut coroutine = Delete::new(&base_url, &auth, "io-webdav", "/dav/collection/", None);
28//! let mut arg = None;
29//!
30//! loop {
31//!     match coroutine.resume(arg.take()) {
32//!         WebdavCoroutineState::Yielded(WebdavYield::WantsWrite(bytes)) => {
33//!             stream.write_all(&bytes).unwrap();
34//!         }
35//!         WebdavCoroutineState::Yielded(WebdavYield::WantsRead) => {
36//!             let n = stream.read(&mut buf).unwrap();
37//!             arg = Some(&buf[..n]);
38//!         }
39//!         WebdavCoroutineState::Complete(Ok(_)) => break,
40//!         WebdavCoroutineState::Complete(Err(err)) => panic!("{err}"),
41//!     }
42//! }
43//! ```
44
45use alloc::vec::Vec;
46
47use log::trace;
48use url::Url;
49
50use crate::{
51    coroutine::*,
52    rfc4918::{
53        WebdavAuth,
54        request::WebdavRequest,
55        send::{SendError, SendOk, SendRaw},
56    },
57};
58
59/// Coroutine that runs a `DELETE`.
60#[derive(Debug)]
61pub struct Delete {
62    state: State,
63}
64
65impl Delete {
66    /// Builds a new `DELETE` coroutine. `if_match` carries the optional
67    /// `If-Match` ETag (RFC 9110 §13.1.1).
68    pub fn new(
69        base_url: &Url,
70        auth: &WebdavAuth,
71        user_agent: &str,
72        path: &str,
73        if_match: Option<&str>,
74    ) -> Self {
75        let mut builder = WebdavRequest::delete(base_url, auth, user_agent, path);
76        if let Some(etag) = if_match {
77            builder = builder.if_match(etag);
78        }
79        let request = builder.body(Vec::new());
80        Self {
81            state: State::Send(SendRaw::new(request)),
82        }
83    }
84}
85
86impl WebdavCoroutine for Delete {
87    type Yield = WebdavYield;
88    type Return = Result<SendOk<Vec<u8>>, SendError>;
89
90    fn resume(&mut self, arg: Option<&[u8]>) -> WebdavCoroutineState<Self::Yield, Self::Return> {
91        trace!("sending request");
92        match &mut self.state {
93            State::Send(send) => send.resume(arg),
94        }
95    }
96}
97
98#[derive(Debug)]
99enum State {
100    Send(SendRaw),
101}