Deuxfleurs/aerogramme
15
0
Fork 1
Code Issues 33 Pull requests 1 Projects 11 Releases 5 Wiki Activity

Implement lockinfo

Browse source
This commit is contained in:
Quentin 2024-03-06 16:09:20 +01:00
parent 05c952f020
commit 96a27d7b22
Signed by: quentin
GPG key ID: E9602264D639FF68
5 changed files with 256 additions and 32 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

275
src/dav/decoder.rs
View file

@ -11,6 +11,15 @@ use super::types::*;
use super::error::ParsingError;
use super::xml::{QRead, Reader, IRead, DAV_URN, CAL_URN};
//@TODO (1) Rewrite all objects as Href,
// where we return Ok(None) instead of trying to find the object at any cost.
// Add a xml.find<E: Qread>() -> Result<Option<E>, ParsingError> or similar for the cases we
// really need the object
// (2) Rewrite QRead and replace Result<Option<_>, _> with Result<_, _>, not found being a possible
// error.
// (3) Rewrite vectors with xml.collect<E: QRead>() -> Result<Vec<E>, _>
// (4) Something for alternatives would be great but no idea yet
// ---- ROOT ----
/// Propfind request
@ -74,11 +83,59 @@ impl<E: Extension> QRead<PropertyUpdate<E>> for PropertyUpdate<E> {
}
}
/// Generic response
//@TODO Multistatus
//@TODO LockInfo
// LOCK REQUEST
impl QRead<LockInfo> for LockInfo {
async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
xml.tag_start(DAV_URN, "lockinfo").await?;
let (mut m_scope, mut m_type, mut owner) = (None, None, None);
loop {
if let Some(v) = LockScope::qread(xml).await? {
m_scope = Some(v);
} else if let Some(v) = LockType::qread(xml).await? {
m_type = Some(v);
} else if let Some(v) = Owner::qread(xml).await? {
owner = Some(v);
} else {
match xml.peek() {
Event::End(_) => break,
_ => xml.skip().await?,
};
}
}
xml.tag_stop(DAV_URN, "lockinfo").await?;
match (m_scope, m_type) {
(Some(lockscope), Some(locktype)) => Ok(Some(LockInfo { lockscope, locktype, owner })),
_ => Err(ParsingError::MissingChild),
}
}
}
// LOCK RESPONSE
impl<E: Extension> QRead<PropValue<E>> for PropValue<E> {
async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
xml.tag_start(DAV_URN, "prop").await?;
let mut acc = Vec::new();
loop {
// Found a property
if let Some(prop) = Property::qread(xml).await? {
acc.push(prop);
continue;
}
// Otherwise skip or escape
match xml.peek() {
Event::End(_) => break,
_ => { xml.skip().await?; },
}
}
xml.tag_stop(DAV_URN, "prop").await?;
Ok(Some(PropValue(acc)))
}
}
//@TODO PropValue
/// Error response
impl<E: Extension> QRead<Error<E>> for Error<E> {
@ -326,29 +383,6 @@ impl<E: Extension> QRead<PropertyRequest<E>> for PropertyRequest<E> {
}
}
impl<E: Extension> QRead<PropValue<E>> for PropValue<E> {
async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
xml.tag_start(DAV_URN, "prop").await?;
let mut acc = Vec::new();
loop {
// Found a property
if let Some(prop) = Property::qread(xml).await? {
acc.push(prop);
continue;
}
// Otherwise skip or escape
match xml.peek() {
Event::End(_) => break,
_ => { xml.skip().await?; },
}
}
xml.tag_stop(DAV_URN, "prop").await?;
Ok(Some(PropValue(acc)))
}
}
impl<E: Extension> QRead<Property<E>> for Property<E> {
async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
use chrono::{DateTime, FixedOffset, TimeZone};
@ -472,7 +506,126 @@ impl<E: Extension> QRead<Property<E>> for Property<E> {
impl QRead<ActiveLock> for ActiveLock {
async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
unimplemented!();
xml.tag_start(DAV_URN, "activelock").await?;
let (mut m_scope, mut m_type, mut m_depth, mut owner, mut timeout, mut locktoken, mut m_root) =
(None, None, None, None, None, None, None);
loop {
if let Some(v) = LockScope::qread(xml).await? {
m_scope = Some(v);
} else if let Some(v) = LockType::qread(xml).await? {
m_type = Some(v);
} else if let Some(v) = Depth::qread(xml).await? {
m_depth = Some(v);
} else if let Some(v) = Owner::qread(xml).await? {
owner = Some(v);
} else if let Some(v) = Timeout::qread(xml).await? {
timeout = Some(v);
} else if let Some(v) = LockToken::qread(xml).await? {
locktoken = Some(v);
} else if let Some(v) = LockRoot::qread(xml).await? {
m_root = Some(v);
} else {
match xml.peek() {
Event::End(_) => break,
_ => { xml.skip().await?; },
}
}
}
xml.tag_stop(DAV_URN, "activelock").await?;
match (m_scope, m_type, m_depth, m_root) {
(Some(lockscope), Some(locktype), Some(depth), Some(lockroot)) =>
Ok(Some(ActiveLock { lockscope, locktype, depth, owner, timeout, locktoken, lockroot })),
_ => Err(ParsingError::MissingChild),
}
}
}
impl QRead<Depth> for Depth {
async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
xml.tag_start(DAV_URN, "depth").await?;
let depth_str = xml.tag_string().await?;
xml.tag_stop(DAV_URN, "depth").await?;
match depth_str.as_str() {
"0" => Ok(Some(Depth::Zero)),
"1" => Ok(Some(Depth::One)),
"infinity" => Ok(Some(Depth::Infinity)),
_ => Err(ParsingError::WrongToken),
}
}
}
impl QRead<Owner> for Owner {
async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
if xml.maybe_tag_start(DAV_URN, "owner").await?.is_none() {
return Ok(None)
}
let mut owner = Owner::Unknown;
loop {
match xml.peek() {
Event::Text(_) | Event::CData(_) => {
let txt = xml.tag_string().await?;
if matches!(owner, Owner::Unknown) {
owner = Owner::Txt(txt);
}
}
Event::Start(_) | Event::Empty(_) => {
if let Some(href) = Href::qread(xml).await? {
owner = Owner::Href(href)
}
xml.skip().await?;
}
Event::End(_) => break,
_ => { xml.skip().await?; },
}
};
xml.tag_stop(DAV_URN, "owner").await?;
Ok(Some(owner))
}
}
impl QRead<Timeout> for Timeout {
async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
const SEC_PFX: &str = "SEC_PFX";
match xml.peek() {
Event::Start(b) if xml.is_tag(DAV_URN, "timeout") => xml.next().await?,
_ => return Ok(None),
};
let timeout = match xml.tag_string().await?.as_str() {
"Infinite" => Timeout::Infinite,
seconds => match seconds.strip_prefix(SEC_PFX) {
Some(secs) => Timeout::Seconds(secs.parse::<u32>()?),
None => return Err(ParsingError::InvalidValue),
},
};
xml.tag_stop(DAV_URN, "timeout").await?;
Ok(Some(timeout))
}
}
impl QRead<LockToken> for LockToken {
async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
match xml.peek() {
Event::Start(b) if xml.is_tag(DAV_URN, "locktoken") => xml.next().await?,
_ => return Ok(None),
};
let href = Href::qread(xml).await?.ok_or(ParsingError::MissingChild)?;
xml.tag_stop(DAV_URN, "locktoken").await?;
Ok(Some(LockToken(href)))
}
}
impl QRead<LockRoot> for LockRoot {
async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
xml.tag_start(DAV_URN, "lockroot").await?;
let href = Href::qread(xml).await?.ok_or(ParsingError::MissingChild)?;
xml.tag_stop(DAV_URN, "lockroot").await?;
Ok(Some(LockRoot(href)))
}
}
@ -495,10 +648,10 @@ impl QRead<LockEntry> for LockEntry {
loop {
match xml.peek() {
Event::Start(b) if xml.is_tag(DAV_URN, "lockscope") => {
Event::Start(_) if xml.is_tag(DAV_URN, "lockscope") => {
maybe_scope = LockScope::qread(xml).await?;
},
Event::Start(b) if xml.is_tag(DAV_URN, "lockentry") => {
Event::Start(_) if xml.is_tag(DAV_URN, "lockentry") => {
maybe_type = LockType::qread(xml).await?;
}
Event::End(_) => break,
@ -518,14 +671,18 @@ impl QRead<LockEntry> for LockEntry {
impl QRead<LockScope> for LockScope {
async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
xml.tag_start(DAV_URN, "lockscope").await?;
if xml.maybe_tag_start(DAV_URN, "lockscope").await?.is_none() {
return Ok(None)
}
let lockscope = loop {
println!("lockscope tag: {:?}", xml.peek());
match xml.peek() {
Event::Empty(b) if xml.is_tag(DAV_URN, "exclusive") => {
Event::Empty(_) if xml.is_tag(DAV_URN, "exclusive") => {
xml.next().await?;
break LockScope::Exclusive
},
Event::Empty(b) if xml.is_tag(DAV_URN, "shared") => {
Event::Empty(_) if xml.is_tag(DAV_URN, "shared") => {
xml.next().await?;
break LockScope::Shared
}
@ -540,7 +697,10 @@ impl QRead<LockScope> for LockScope {
impl QRead<LockType> for LockType {
async fn qread(xml: &mut Reader<impl IRead>) -> Result<Option<Self>, ParsingError> {
xml.tag_start(DAV_URN, "locktype").await?;
if xml.maybe_tag_start(DAV_URN, "locktype").await?.is_none() {
return Ok(None)
}
let locktype = loop {
match xml.peek() {
Event::Empty(b) if xml.is_tag(DAV_URN, "write") => {
@ -639,4 +799,55 @@ mod tests {
])
]));
}
#[tokio::test]
async fn rfc_propertyupdate() {
let src = r#"<?xml version="1.0" encoding="utf-8" ?>
<D:propertyupdate xmlns:D="DAV:"
xmlns:Z="http://ns.example.com/standards/z39.50/">
<D:set>
<D:prop>
<Z:Authors>
<Z:Author>Jim Whitehead</Z:Author>
<Z:Author>Roy Fielding</Z:Author>
</Z:Authors>
</D:prop>
</D:set>
<D:remove>
<D:prop><Z:Copyright-Owner/></D:prop>
</D:remove>
</D:propertyupdate>"#;
let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())).await.unwrap();
let got = PropertyUpdate::<Core>::qread(&mut rdr).await.unwrap().unwrap();
assert_eq!(got, PropertyUpdate(vec![
PropertyUpdateItem::Set(Set(PropValue(vec![]))),
PropertyUpdateItem::Remove(Remove(PropName(vec![]))),
]));
}
#[tokio::test]
async fn rfc_lockinfo1() {
let src = r#"
<?xml version="1.0" encoding="utf-8" ?>
<D:lockinfo xmlns:D='DAV:'>
<D:lockscope><D:exclusive/></D:lockscope>
<D:locktype><D:write/></D:locktype>
<D:owner>
<D:href>http://example.org/~ejw/contact.html</D:href>
</D:owner>
</D:lockinfo>
"#;
let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())).await.unwrap();
let got = LockInfo::qread(&mut rdr).await.unwrap().unwrap();
assert_eq!(got, LockInfo {
lockscope: LockScope::Exclusive,
locktype: LockType::Write,
owner: Some(Owner::Href(Href("http://example.org/~ejw/contact.html".into()))),
});
}
}

1
src/dav/encoder.rs
View file

@ -527,6 +527,7 @@ impl QWrite for Owner {
match self {
Self::Txt(txt) => xml.q.write_event_async(Event::Text(BytesText::new(&txt))).await?,
Self::Href(href) => href.qwrite(xml).await?,
Self::Unknown => (),
}
xml.q.write_event_async(Event::End(end)).await
}

1
src/dav/error.rs
View file

@ -6,6 +6,7 @@ pub enum ParsingError {
NamespacePrefixAlreadyUsed,
WrongToken,
TagNotFound,
InvalidValue,
Utf8Error(std::str::Utf8Error),
QuickXml(quick_xml::Error),
Chrono(chrono::format::ParseError),

1
src/dav/types.rs
View file

@ -366,6 +366,7 @@ pub struct Multistatus<E: Extension> {
pub enum Owner {
Txt(String),
Href(Href),
Unknown,
}
/// 14.18. prop XML Element

10
src/dav/xml.rs
View file

@ -106,6 +106,16 @@ impl<T: IRead> Reader<T> {
}
}
/// maybe find start tag
pub async fn maybe_tag_start(&mut self, ns: &[u8], key: &str) -> Result<Option<Event<'static>>, ParsingError> {
println!("maybe start tag {}", key);
let peek = self.peek();
match peek {
Event::Start(_) | Event::Empty(_) if self.is_tag(ns, key) => Ok(Some(self.next().await?)),
_ => Ok(None),
}
}
/// find start tag
pub async fn tag_start(&mut self, ns: &[u8], key: &str) -> Result<Event<'static>, ParsingError> {
println!("search start tag {}", key);