use chrono::DateTime; use quick_xml::events::Event; use super::error::ParsingError; use super::types::*; use super::xml::{IRead, Node, QRead, Reader, DAV_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() -> Result, ParsingError> or similar for the cases we // really need the object // (2) Rewrite QRead and replace Result, _> with Result<_, _>, not found being a possible // error. // (3) Rewrite vectors with xml.collect() -> Result, _> // (4) Something for alternatives like xml::choices on some lib would be great but no idea yet // ---- ROOT ---- /// Propfind request impl QRead> for PropFind { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "propfind").await?; let propfind: PropFind = loop { // allprop if let Some(_) = xml.maybe_open(DAV_URN, "allprop").await? { xml.close().await?; let includ = xml.maybe_find::>().await?; break PropFind::AllProp(includ); } // propname if let Some(_) = xml.maybe_open(DAV_URN, "propname").await? { xml.close().await?; break PropFind::PropName; } // prop let (mut maybe_prop, mut dirty) = (None, false); xml.maybe_read::>(&mut maybe_prop, &mut dirty) .await?; if let Some(prop) = maybe_prop { break PropFind::Prop(prop); } // not found, skipping xml.skip().await?; }; xml.close().await?; Ok(propfind) } } /// PROPPATCH request impl QRead> for PropertyUpdate { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "propertyupdate").await?; let collected_items = xml.collect::>().await?; xml.close().await?; Ok(PropertyUpdate(collected_items)) } } /// Generic response impl QRead> for Multistatus { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "multistatus").await?; let mut responses = Vec::new(); let mut responsedescription = None; loop { let mut dirty = false; xml.maybe_push(&mut responses, &mut dirty).await?; xml.maybe_read(&mut responsedescription, &mut dirty).await?; if !dirty { match xml.peek() { Event::End(_) => break, _ => xml.skip().await?, }; } } xml.close().await?; Ok(Multistatus { responses, responsedescription, }) } } // LOCK REQUEST impl QRead for LockInfo { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "lockinfo").await?; let (mut m_scope, mut m_type, mut owner) = (None, None, None); loop { let mut dirty = false; xml.maybe_read::(&mut m_scope, &mut dirty) .await?; xml.maybe_read::(&mut m_type, &mut dirty).await?; xml.maybe_read::(&mut owner, &mut dirty).await?; if !dirty { match xml.peek() { Event::End(_) => break, _ => xml.skip().await?, }; } } xml.close().await?; match (m_scope, m_type) { (Some(lockscope), Some(locktype)) => Ok(LockInfo { lockscope, locktype, owner, }), _ => Err(ParsingError::MissingChild), } } } // LOCK RESPONSE impl QRead> for PropValue { async fn qread(xml: &mut Reader) -> Result { println!("---- propvalue"); xml.open(DAV_URN, "prop").await?; let acc = xml.collect::>().await?; xml.close().await?; Ok(PropValue(acc)) } } /// Error response impl QRead> for Error { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "error").await?; let violations = xml.collect::>().await?; xml.close().await?; Ok(Error(violations)) } } // ---- INNER XML impl QRead> for Response { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "response").await?; let (mut status, mut error, mut responsedescription, mut location) = (None, None, None, None); let mut href = Vec::new(); let mut propstat = Vec::new(); loop { let mut dirty = false; xml.maybe_read::(&mut status, &mut dirty).await?; xml.maybe_push::(&mut href, &mut dirty).await?; xml.maybe_push::>(&mut propstat, &mut dirty) .await?; xml.maybe_read::>(&mut error, &mut dirty).await?; xml.maybe_read::(&mut responsedescription, &mut dirty) .await?; xml.maybe_read::(&mut location, &mut dirty) .await?; if !dirty { match xml.peek() { Event::End(_) => break, _ => xml.skip().await?, }; } } xml.close().await?; match (status, &propstat[..], &href[..]) { (Some(status), &[], &[_, ..]) => Ok(Response { status_or_propstat: StatusOrPropstat::Status(href, status), error, responsedescription, location, }), (None, &[_, ..], &[_, ..]) => Ok(Response { status_or_propstat: StatusOrPropstat::PropStat( href.into_iter().next().unwrap(), propstat, ), error, responsedescription, location, }), (Some(_), &[_, ..], _) => Err(ParsingError::InvalidValue), _ => Err(ParsingError::MissingChild), } } } impl QRead> for PropStat { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "propstat").await?; let (mut m_any_prop, mut m_status, mut error, mut responsedescription) = (None, None, None, None); loop { let mut dirty = false; xml.maybe_read::>(&mut m_any_prop, &mut dirty) .await?; xml.maybe_read::(&mut m_status, &mut dirty).await?; xml.maybe_read::>(&mut error, &mut dirty).await?; xml.maybe_read::(&mut responsedescription, &mut dirty) .await?; if !dirty { match xml.peek() { Event::End(_) => break, _ => xml.skip().await?, }; } } xml.close().await?; match (m_any_prop, m_status) { (Some(prop), Some(status)) => Ok(PropStat { prop, status, error, responsedescription, }), _ => Err(ParsingError::MissingChild), } } } impl QRead for Status { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "status").await?; let fullcode = xml.tag_string().await?; let txtcode = fullcode .splitn(3, ' ') .nth(1) .ok_or(ParsingError::InvalidValue)?; let code = http::status::StatusCode::from_bytes(txtcode.as_bytes()) .or(Err(ParsingError::InvalidValue))?; xml.close().await?; Ok(Status(code)) } } impl QRead for ResponseDescription { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "responsedescription").await?; let cnt = xml.tag_string().await?; xml.close().await?; Ok(ResponseDescription(cnt)) } } impl QRead for Location { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "location").await?; let href = xml.find::().await?; xml.close().await?; Ok(Location(href)) } } impl QRead> for PropertyUpdateItem { async fn qread(xml: &mut Reader) -> Result { match Remove::qread(xml).await { Err(ParsingError::Recoverable) => (), otherwise => return otherwise.map(PropertyUpdateItem::Remove), } Set::qread(xml).await.map(PropertyUpdateItem::Set) } } impl QRead> for Remove { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "remove").await?; let propname = xml.find::>().await?; xml.close().await?; Ok(Remove(propname)) } } impl QRead> for Set { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "set").await?; let propvalue = xml.find::>().await?; xml.close().await?; Ok(Set(propvalue)) } } impl QRead> for Violation { async fn qread(xml: &mut Reader) -> Result { if xml .maybe_open(DAV_URN, "lock-token-matches-request-uri") .await? .is_some() { xml.close().await?; Ok(Violation::LockTokenMatchesRequestUri) } else if xml .maybe_open(DAV_URN, "lock-token-submitted") .await? .is_some() { let links = xml.collect::().await?; xml.close().await?; Ok(Violation::LockTokenSubmitted(links)) } else if xml .maybe_open(DAV_URN, "no-conflicting-lock") .await? .is_some() { let links = xml.collect::().await?; xml.close().await?; Ok(Violation::NoConflictingLock(links)) } else if xml .maybe_open(DAV_URN, "no-external-entities") .await? .is_some() { xml.close().await?; Ok(Violation::NoExternalEntities) } else if xml .maybe_open(DAV_URN, "preserved-live-properties") .await? .is_some() { xml.close().await?; Ok(Violation::PreservedLiveProperties) } else if xml .maybe_open(DAV_URN, "propfind-finite-depth") .await? .is_some() { xml.close().await?; Ok(Violation::PropfindFiniteDepth) } else if xml .maybe_open(DAV_URN, "cannot-modify-protected-property") .await? .is_some() { xml.close().await?; Ok(Violation::CannotModifyProtectedProperty) } else { E::Error::qread(xml).await.map(Violation::Extension) } } } impl QRead> for Include { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "include").await?; let acc = xml.collect::>().await?; xml.close().await?; Ok(Include(acc)) } } impl QRead> for PropName { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "prop").await?; let acc = xml.collect::>().await?; xml.close().await?; Ok(PropName(acc)) } } impl QRead> for AnyProp { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "prop").await?; let acc = xml.collect::>().await?; xml.close().await?; Ok(AnyProp(acc)) } } impl QRead> for AnyProperty { async fn qread(xml: &mut Reader) -> Result { match Property::qread(xml).await { Err(ParsingError::Recoverable) => (), otherwise => return otherwise.map(Self::Value), } PropertyRequest::qread(xml).await.map(Self::Request) } } impl QRead> for PropertyRequest { async fn qread(xml: &mut Reader) -> Result { let maybe = if xml.maybe_open(DAV_URN, "creationdate").await?.is_some() { Some(PropertyRequest::CreationDate) } else if xml.maybe_open(DAV_URN, "displayname").await?.is_some() { Some(PropertyRequest::DisplayName) } else if xml .maybe_open(DAV_URN, "getcontentlanguage") .await? .is_some() { Some(PropertyRequest::GetContentLanguage) } else if xml.maybe_open(DAV_URN, "getcontentlength").await?.is_some() { Some(PropertyRequest::GetContentLength) } else if xml.maybe_open(DAV_URN, "getcontenttype").await?.is_some() { Some(PropertyRequest::GetContentType) } else if xml.maybe_open(DAV_URN, "getetag").await?.is_some() { Some(PropertyRequest::GetEtag) } else if xml.maybe_open(DAV_URN, "getlastmodified").await?.is_some() { Some(PropertyRequest::GetLastModified) } else if xml.maybe_open(DAV_URN, "lockdiscovery").await?.is_some() { Some(PropertyRequest::LockDiscovery) } else if xml.maybe_open(DAV_URN, "resourcetype").await?.is_some() { Some(PropertyRequest::ResourceType) } else if xml.maybe_open(DAV_URN, "supportedlock").await?.is_some() { Some(PropertyRequest::SupportedLock) } else { None }; match maybe { Some(pr) => { xml.close().await?; Ok(pr) } None => E::PropertyRequest::qread(xml) .await .map(PropertyRequest::Extension), } } } impl QRead> for Property { async fn qread(xml: &mut Reader) -> Result { // Core WebDAV properties if xml .maybe_open_start(DAV_URN, "creationdate") .await? .is_some() { let datestr = xml.tag_string().await?; xml.close().await?; return Ok(Property::CreationDate(DateTime::parse_from_rfc3339( datestr.as_str(), )?)); } else if xml .maybe_open_start(DAV_URN, "displayname") .await? .is_some() { let name = xml.tag_string().await?; xml.close().await?; return Ok(Property::DisplayName(name)); } else if xml .maybe_open_start(DAV_URN, "getcontentlanguage") .await? .is_some() { let lang = xml.tag_string().await?; xml.close().await?; return Ok(Property::GetContentLanguage(lang)); } else if xml .maybe_open_start(DAV_URN, "getcontentlength") .await? .is_some() { let cl = xml.tag_string().await?.parse::()?; xml.close().await?; return Ok(Property::GetContentLength(cl)); } else if xml .maybe_open_start(DAV_URN, "getcontenttype") .await? .is_some() { let ct = xml.tag_string().await?; xml.close().await?; return Ok(Property::GetContentType(ct)); } else if xml.maybe_open_start(DAV_URN, "getetag").await?.is_some() { let etag = xml.tag_string().await?; xml.close().await?; return Ok(Property::GetEtag(etag)); } else if xml .maybe_open_start(DAV_URN, "getlastmodified") .await? .is_some() { let datestr = xml.tag_string().await?; xml.close().await?; return Ok(Property::GetLastModified(DateTime::parse_from_rfc2822( datestr.as_str(), )?)); } else if xml .maybe_open_start(DAV_URN, "lockdiscovery") .await? .is_some() { let acc = xml.collect::().await?; xml.close().await?; return Ok(Property::LockDiscovery(acc)); } else if xml .maybe_open_start(DAV_URN, "resourcetype") .await? .is_some() { let acc = xml.collect::>().await?; xml.close().await?; return Ok(Property::ResourceType(acc)); } else if xml .maybe_open_start(DAV_URN, "supportedlock") .await? .is_some() { let acc = xml.collect::().await?; xml.close().await?; return Ok(Property::SupportedLock(acc)); } // Option 2: an extension property, delegating E::Property::qread(xml).await.map(Property::Extension) } } impl QRead for ActiveLock { async fn qread(xml: &mut Reader) -> Result { xml.open(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 { let mut dirty = false; xml.maybe_read::(&mut m_scope, &mut dirty) .await?; xml.maybe_read::(&mut m_type, &mut dirty).await?; xml.maybe_read::(&mut m_depth, &mut dirty).await?; xml.maybe_read::(&mut owner, &mut dirty).await?; xml.maybe_read::(&mut timeout, &mut dirty).await?; xml.maybe_read::(&mut locktoken, &mut dirty) .await?; xml.maybe_read::(&mut m_root, &mut dirty).await?; if !dirty { match xml.peek() { Event::End(_) => break, _ => { xml.skip().await?; } } } } xml.close().await?; match (m_scope, m_type, m_depth, m_root) { (Some(lockscope), Some(locktype), Some(depth), Some(lockroot)) => Ok(ActiveLock { lockscope, locktype, depth, owner, timeout, locktoken, lockroot, }), _ => Err(ParsingError::MissingChild), } } } impl QRead for Depth { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "depth").await?; let depth_str = xml.tag_string().await?; xml.close().await?; match depth_str.as_str() { "0" => Ok(Depth::Zero), "1" => Ok(Depth::One), "infinity" => Ok(Depth::Infinity), _ => Err(ParsingError::WrongToken), } } } impl QRead for Owner { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "owner").await?; 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(_) => match Href::qread(xml).await { Ok(href) => { owner = Owner::Href(href); } Err(ParsingError::Recoverable) => { xml.skip().await?; } Err(e) => return Err(e), }, Event::End(_) => break, _ => { xml.skip().await?; } } } xml.close().await?; Ok(owner) } } impl QRead for Timeout { async fn qread(xml: &mut Reader) -> Result { const SEC_PFX: &str = "Second-"; xml.open(DAV_URN, "timeout").await?; 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::()?), None => return Err(ParsingError::InvalidValue), }, }; xml.close().await?; Ok(timeout) } } impl QRead for LockToken { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "locktoken").await?; let href = xml.find::().await?; xml.close().await?; Ok(LockToken(href)) } } impl QRead for LockRoot { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "lockroot").await?; let href = xml.find::().await?; xml.close().await?; Ok(LockRoot(href)) } } impl QRead> for ResourceType { async fn qread(xml: &mut Reader) -> Result { if xml.maybe_open(DAV_URN, "collection").await?.is_some() { xml.close().await?; return Ok(ResourceType::Collection); } E::ResourceType::qread(xml) .await .map(ResourceType::Extension) } } impl QRead for LockEntry { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "lockentry").await?; let (mut maybe_scope, mut maybe_type) = (None, None); loop { let mut dirty = false; xml.maybe_read::(&mut maybe_scope, &mut dirty) .await?; xml.maybe_read::(&mut maybe_type, &mut dirty) .await?; if !dirty { match xml.peek() { Event::End(_) => break, _ => xml.skip().await?, }; } } xml.close().await?; match (maybe_scope, maybe_type) { (Some(lockscope), Some(locktype)) => Ok(LockEntry { lockscope, locktype, }), _ => Err(ParsingError::MissingChild), } } } impl QRead for LockScope { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "lockscope").await?; let lockscope = loop { if xml.maybe_open(DAV_URN, "exclusive").await?.is_some() { xml.close().await?; break LockScope::Exclusive; } if xml.maybe_open(DAV_URN, "shared").await?.is_some() { xml.close().await?; break LockScope::Shared; } xml.skip().await?; }; xml.close().await?; Ok(lockscope) } } impl QRead for LockType { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "locktype").await?; let locktype = loop { if xml.maybe_open(DAV_URN, "write").await?.is_some() { xml.close().await?; break LockType::Write; } xml.skip().await?; }; xml.close().await?; Ok(locktype) } } impl QRead for Href { async fn qread(xml: &mut Reader) -> Result { xml.open(DAV_URN, "href").await?; let url = xml.tag_string().await?; xml.close().await?; Ok(Href(url)) } } #[cfg(test)] mod tests { use super::*; use crate::realization::Core; use chrono::{FixedOffset, TimeZone}; use quick_xml::reader::NsReader; #[tokio::test] async fn basic_propfind_propname() { let src = r#" "#; let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())) .await .unwrap(); let got = rdr.find::>().await.unwrap(); assert_eq!(got, PropFind::::PropName); } #[tokio::test] async fn basic_propfind_prop() { let src = r#" "#; let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())) .await .unwrap(); let got = rdr.find::>().await.unwrap(); assert_eq!( got, PropFind::Prop(PropName(vec![ PropertyRequest::DisplayName, PropertyRequest::GetContentLength, PropertyRequest::GetContentType, PropertyRequest::GetEtag, PropertyRequest::GetLastModified, PropertyRequest::ResourceType, PropertyRequest::SupportedLock, ])) ); } #[tokio::test] async fn rfc_lock_error() { let src = r#" /locked/ "#; let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())) .await .unwrap(); let got = rdr.find::>().await.unwrap(); assert_eq!( got, Error(vec![Violation::LockTokenSubmitted(vec![Href( "/locked/".into() )])]) ); } #[tokio::test] async fn rfc_propertyupdate() { let src = r#" Jim Whitehead Roy Fielding "#; let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())) .await .unwrap(); let got = rdr.find::>().await.unwrap(); assert_eq!( got, PropertyUpdate(vec![ PropertyUpdateItem::Set(Set(PropValue(vec![]))), PropertyUpdateItem::Remove(Remove(PropName(vec![]))), ]) ); } #[tokio::test] async fn rfc_lockinfo() { let src = r#" http://example.org/~ejw/contact.html "#; let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())) .await .unwrap(); let got = rdr.find::().await.unwrap(); assert_eq!( got, LockInfo { lockscope: LockScope::Exclusive, locktype: LockType::Write, owner: Some(Owner::Href(Href( "http://example.org/~ejw/contact.html".into() ))), } ); } #[tokio::test] async fn rfc_multistatus_name() { let src = r#" http://www.example.com/container/ HTTP/1.1 200 OK http://www.example.com/container/front.html HTTP/1.1 200 OK "#; let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())) .await .unwrap(); let got = rdr.find::>().await.unwrap(); assert_eq!( got, Multistatus { responses: vec![ Response { status_or_propstat: StatusOrPropstat::PropStat( Href("http://www.example.com/container/".into()), vec![PropStat { prop: AnyProp(vec![ AnyProperty::Request(PropertyRequest::CreationDate), AnyProperty::Request(PropertyRequest::DisplayName), AnyProperty::Request(PropertyRequest::ResourceType), AnyProperty::Request(PropertyRequest::SupportedLock), ]), status: Status(http::status::StatusCode::OK), error: None, responsedescription: None, }], ), error: None, responsedescription: None, location: None, }, Response { status_or_propstat: StatusOrPropstat::PropStat( Href("http://www.example.com/container/front.html".into()), vec![PropStat { prop: AnyProp(vec![ AnyProperty::Request(PropertyRequest::CreationDate), AnyProperty::Request(PropertyRequest::DisplayName), AnyProperty::Request(PropertyRequest::GetContentLength), AnyProperty::Request(PropertyRequest::GetContentType), AnyProperty::Request(PropertyRequest::GetEtag), AnyProperty::Request(PropertyRequest::GetLastModified), AnyProperty::Request(PropertyRequest::ResourceType), AnyProperty::Request(PropertyRequest::SupportedLock), ]), status: Status(http::status::StatusCode::OK), error: None, responsedescription: None, }], ), error: None, responsedescription: None, location: None, }, ], responsedescription: None, } ); } #[tokio::test] async fn rfc_multistatus_value() { let src = r#" /container/ Box type A Hadrian 1997-12-01T17:42:21-08:00 Example collection HTTP/1.1 200 OK /container/front.html Box type B 1997-12-01T18:27:21-08:00 Example HTML resource 4525 text/html "zzyzx" Mon, 12 Jan 1998 09:25:56 GMT HTTP/1.1 200 OK "#; let mut rdr = Reader::new(NsReader::from_reader(src.as_bytes())) .await .unwrap(); let got = rdr.find::>().await.unwrap(); assert_eq!( got, Multistatus { responses: vec![ Response { status_or_propstat: StatusOrPropstat::PropStat( Href("/container/".into()), vec![PropStat { prop: AnyProp(vec![ AnyProperty::Value(Property::CreationDate( FixedOffset::west_opt(8 * 3600) .unwrap() .with_ymd_and_hms(1997, 12, 01, 17, 42, 21) .unwrap() )), AnyProperty::Value(Property::DisplayName( "Example collection".into() )), AnyProperty::Value(Property::ResourceType(vec![ ResourceType::Collection ])), AnyProperty::Value(Property::SupportedLock(vec![ LockEntry { lockscope: LockScope::Exclusive, locktype: LockType::Write, }, LockEntry { lockscope: LockScope::Shared, locktype: LockType::Write, }, ])), ]), status: Status(http::status::StatusCode::OK), error: None, responsedescription: None, }], ), error: None, responsedescription: None, location: None, }, Response { status_or_propstat: StatusOrPropstat::PropStat( Href("/container/front.html".into()), vec![PropStat { prop: AnyProp(vec![ AnyProperty::Value(Property::CreationDate( FixedOffset::west_opt(8 * 3600) .unwrap() .with_ymd_and_hms(1997, 12, 01, 18, 27, 21) .unwrap() )), AnyProperty::Value(Property::DisplayName( "Example HTML resource".into() )), AnyProperty::Value(Property::GetContentLength(4525)), AnyProperty::Value(Property::GetContentType( "text/html".into() )), AnyProperty::Value(Property::GetEtag(r#""zzyzx""#.into())), AnyProperty::Value(Property::GetLastModified( FixedOffset::west_opt(0) .unwrap() .with_ymd_and_hms(1998, 01, 12, 09, 25, 56) .unwrap() )), //@FIXME know bug, can't disambiguate between an empty resource //type value and a request resource type AnyProperty::Request(PropertyRequest::ResourceType), AnyProperty::Value(Property::SupportedLock(vec![ LockEntry { lockscope: LockScope::Exclusive, locktype: LockType::Write, }, LockEntry { lockscope: LockScope::Shared, locktype: LockType::Write, }, ])), ]), status: Status(http::status::StatusCode::OK), error: None, responsedescription: None, }], ), error: None, responsedescription: None, location: None, }, ], responsedescription: None, } ); } }