Second round of improvements (#54)

Author: paolobarbolini

Cargo.toml

@@ -21,9 +21,9 @@ features = ["full"]
 default = ["localfs", "memfs"]
 actix-compat = [ "actix-web" ]
 warp-compat = [ "warp", "hyper" ]
-caldav = [ "icalendar", "chrono" ]
+caldav = [ "icalendar" ]
 all = [ "actix-compat", "warp-compat", "caldav" ]
-localfs = ["libc", "lru", "parking_lot", "reflink-copy"]
+localfs = ["libc", "lru", "tokio/rt-multi-thread", "parking_lot", "reflink-copy"]
 memfs = ["libc"]
 
 [[example]]
@@ -55,8 +55,8 @@ mime_guess = "2.0.0"
 parking_lot = { version = "0.12.0", optional = true }
 percent-encoding = "2.1.0"
 pin-project-lite = "0.2.16"
-tokio = { version = "1.3.0", features = [ "rt-multi-thread", "io-util", "net", "time", "sync" ] }
-time = { version = "0.3.2", default-features = false, features = [ "macros", "formatting" ] }
+tokio = { version = "1.22.0", features = [ "rt" ] }
+chrono = { version = "0.4", default-features = false, features = [ "clock" ] }
 url = "2.2.0"
 uuid = { version = "1.1.2", features = ["v4"] }
 xml-rs = "1"
@@ -67,7 +67,6 @@ warp = { version = "0.3.0", optional = true, default-features = false }
 actix-web = { version = "4.0.0-beta.15", default-features = false, optional = true }
 reflink-copy = { version = "0.1.14", optional = true }
 icalendar = { version = "0.17.1", optional = true }
-chrono = { version = "0.4", default-features = false, features = ["now"], optional = true }
 derive-where = "1.6.0"
 
 [dev-dependencies]

src/handle_gethead.rs

@@ -1,6 +1,7 @@
 use std::cmp;
 use std::io::Write;
 
+use chrono::{DateTime, Utc};
 use futures_util::StreamExt;
 use headers::HeaderMapExt;
 use http::{Request, Response, status::StatusCode};
@@ -14,7 +15,6 @@ use crate::davheaders;
 use crate::davpath::DavPath;
 use crate::errors::*;
 use crate::fs::*;
-use crate::util::systemtime_to_offsetdatetime;
 use crate::{DavInner, DavMethod};
 
 struct Range {
@@ -439,17 +439,9 @@ impl<C: Clone + Send + Sync + 'static> DavInner<C> {
 
                 for dirent in &dirents {
                     let modified = match dirent.meta.modified() {
-                        Ok(t) => {
-                            let tm = systemtime_to_offsetdatetime(t);
-                            format!(
-                                "{:04}-{:02}-{:02} {:02}:{:02}",
-                                tm.year(),
-                                tm.month(),
-                                tm.day(),
-                                tm.hour(),
-                                tm.minute(),
-                            )
-                        }
+                        Ok(t) => DateTime::<Utc>::from(t)
+                            .format("%Y-%m-%d %H:%M")
+                            .to_string(),
                         Err(_) => "".to_string(),
                     };
                     let size = match dirent.meta.is_file() {

src/localfs.rs

@@ -8,6 +8,7 @@ use std::any::Any;
 use std::collections::VecDeque;
 use std::future::{self, Future};
 use std::io::{self, Read, Seek, SeekFrom, Write};
+use std::mem;
 #[cfg(unix)]
 use std::os::unix::{
     ffi::OsStrExt,
@@ -19,7 +20,6 @@ use std::path::{Path, PathBuf};
 use std::pin::Pin;
 use std::pin::pin;
 use std::sync::Arc;
-use std::sync::atomic::{AtomicU32, Ordering};
 use std::task::{Context, Poll};
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
@@ -34,51 +34,21 @@ use crate::davpath::DavPath;
 use crate::fs::*;
 use crate::localfs_macos::DUCacheBuilder;
 
-const RUNTIME_TYPE_BASIC: u32 = 1;
-const RUNTIME_TYPE_THREADPOOL: u32 = 2;
-static RUNTIME_TYPE: AtomicU32 = AtomicU32::new(0);
-
-#[derive(Clone, Copy)]
-#[repr(u32)]
-enum RuntimeType {
-    Basic = RUNTIME_TYPE_BASIC,
-    ThreadPool = RUNTIME_TYPE_THREADPOOL,
-}
-
-impl RuntimeType {
-    #[inline]
-    fn get() -> RuntimeType {
-        match RUNTIME_TYPE.load(Ordering::Relaxed) {
-            RUNTIME_TYPE_BASIC => RuntimeType::Basic,
-            RUNTIME_TYPE_THREADPOOL => RuntimeType::ThreadPool,
-            _ => {
-                let dbg = format!("{:?}", tokio::runtime::Handle::current());
-                let rt = if dbg.contains("ThreadPool") {
-                    RuntimeType::ThreadPool
-                } else {
-                    RuntimeType::Basic
-                };
-                RUNTIME_TYPE.store(rt as u32, Ordering::SeqCst);
-                rt
-            }
-        }
-    }
-}
-
 // Run some code via block_in_place() or spawn_blocking().
 //
 // There's also a method on LocalFs for this, use the freestanding
 // function if you do not want the fs_access_guard() closure to be used.
+#[cfg(feature = "localfs")]
 #[inline]
 async fn blocking<F, R>(func: F) -> R
 where
     F: FnOnce() -> R,
     F: Send + 'static,
     R: Send + 'static,
 {
-    match RuntimeType::get() {
-        RuntimeType::Basic => task::spawn_blocking(func).await.unwrap(),
-        RuntimeType::ThreadPool => task::block_in_place(func),
+    match tokio::runtime::Handle::current().runtime_flavor() {
+        tokio::runtime::RuntimeFlavor::MultiThread => task::block_in_place(func),
+        _ => task::spawn_blocking(func).await.unwrap(),
     }
 }
 
@@ -103,7 +73,10 @@ pub(crate) struct LocalFsInner {
 }
 
 #[derive(Debug)]
-struct LocalFsFile(Option<std::fs::File>);
+struct LocalFsFile {
+    file: Option<std::fs::File>,
+    buf: BytesMut,
+}
 
 struct LocalFsReadDir {
     fs: LocalFs,
@@ -340,7 +313,10 @@ impl DavFileSystem for LocalFs {
                     .create_new(options.create_new)
                     .open(path);
                 match res {
-                    Ok(file) => Ok(Box::new(LocalFsFile(Some(file))) as Box<dyn DavFile>),
+                    Ok(file) => Ok(Box::new(LocalFsFile {
+                        file: Some(file),
+                        buf: BytesMut::new(),
+                    }) as Box<dyn DavFile>),
                     Err(e) => Err(e.into()),
                 }
             })
@@ -676,27 +652,27 @@ impl DavDirEntry for LocalFsDirEntry {
 impl DavFile for LocalFsFile {
     fn metadata(&'_ mut self) -> FsFuture<'_, Box<dyn DavMetaData>> {
         async move {
-            let file = self.0.take().unwrap();
+            let file = self.file.take().unwrap();
             let (meta, file) = blocking(move || (file.metadata(), file)).await;
-            self.0 = Some(file);
+            self.file = Some(file);
             Ok(Box::new(LocalFsMetaData(meta?)) as Box<dyn DavMetaData>)
         }
         .boxed()
     }
 
     fn write_bytes(&'_ mut self, buf: Bytes) -> FsFuture<'_, ()> {
         async move {
-            let mut file = self.0.take().unwrap();
+            let mut file = self.file.take().unwrap();
             let (res, file) = blocking(move || (file.write_all(&buf), file)).await;
-            self.0 = Some(file);
+            self.file = Some(file);
             res.map_err(|e| e.into())
         }
         .boxed()
     }
 
     fn write_buf(&'_ mut self, mut buf: Box<dyn Buf + Send>) -> FsFuture<'_, ()> {
         async move {
-            let mut file = self.0.take().unwrap();
+            let mut file = self.file.take().unwrap();
             let (res, file) = blocking(move || {
                 while buf.remaining() > 0 {
                     let n = match file.write(buf.chunk()) {
@@ -708,48 +684,50 @@ impl DavFile for LocalFsFile {
                 (Ok(()), file)
             })
             .await;
-            self.0 = Some(file);
+            self.file = Some(file);
             res.map_err(|e| e.into())
         }
         .boxed()
     }
 
     fn read_bytes(&'_ mut self, count: usize) -> FsFuture<'_, Bytes> {
         async move {
-            let mut file = self.0.take().unwrap();
-            let (res, file) = blocking(move || {
-                let mut buf = BytesMut::with_capacity(count);
+            let mut file = self.file.take().unwrap();
+            let mut buf = mem::take(&mut self.buf);
+            let (res, file, buf) = blocking(move || {
+                buf.reserve(count);
                 let res = unsafe {
                     buf.set_len(count);
                     file.read(&mut buf).map(|n| {
                         buf.set_len(n);
-                        buf.freeze()
+                        buf.split().freeze()
                     })
                 };
-                (res, file)
+                (res, file, buf)
             })
             .await;
-            self.0 = Some(file);
+            self.file = Some(file);
+            self.buf = buf;
             res.map_err(|e| e.into())
         }
         .boxed()
     }
 
     fn seek(&'_ mut self, pos: SeekFrom) -> FsFuture<'_, u64> {
         async move {
-            let mut file = self.0.take().unwrap();
+            let mut file = self.file.take().unwrap();
             let (res, file) = blocking(move || (file.seek(pos), file)).await;
-            self.0 = Some(file);
+            self.file = Some(file);
             res.map_err(|e| e.into())
         }
         .boxed()
     }
 
     fn flush(&'_ mut self) -> FsFuture<'_, ()> {
         async move {
-            let mut file = self.0.take().unwrap();
+            let mut file = self.file.take().unwrap();
             let (res, file) = blocking(move || (file.flush(), file)).await;
-            self.0 = Some(file);
+            self.file = Some(file);
             res.map_err(|e| e.into())
         }
         .boxed()

src/util.rs

@@ -1,11 +1,10 @@
 use std::io::{Cursor, Write};
-use std::time::{SystemTime, UNIX_EPOCH};
+use std::time::SystemTime;
 
 use bytes::Bytes;
+use chrono::{DateTime, SecondsFormat, Utc};
 use headers::Header;
 use http::method::InvalidMethod;
-use time::format_description::well_known::Rfc3339;
-use time::macros::offset;
 
 use crate::DavResult;
 use crate::body::Body;
@@ -157,16 +156,6 @@ pub(crate) fn dav_xml_error(body: &str) -> Body {
     Body::from(xml)
 }
 
-pub(crate) fn systemtime_to_offsetdatetime(t: SystemTime) -> time::OffsetDateTime {
-    match t.duration_since(UNIX_EPOCH) {
-        Ok(t) => {
-            let tm = time::OffsetDateTime::from_unix_timestamp(t.as_secs() as i64).unwrap();
-            tm.to_offset(offset!(UTC))
-        }
-        Err(_) => time::OffsetDateTime::UNIX_EPOCH.to_offset(offset!(UTC)),
-    }
-}
-
 pub(crate) fn systemtime_to_httpdate(t: SystemTime) -> String {
     let d = headers::Date::from(t);
     let mut v = Vec::new();
@@ -176,11 +165,7 @@ pub(crate) fn systemtime_to_httpdate(t: SystemTime) -> String {
 
 pub(crate) fn systemtime_to_rfc3339_without_nanosecond(t: SystemTime) -> String {
     // 1996-12-19T16:39:57Z
-    systemtime_to_offsetdatetime(t)
-        .replace_nanosecond(0)
-        .ok()
-        .and_then(|x| x.format(&Rfc3339).ok())
-        .unwrap_or("1970-01-01T00:00:00Z".into())
+    DateTime::<Utc>::from(t).to_rfc3339_opts(SecondsFormat::Secs, true)
 }
 
 // A buffer that implements "Write".