Refactor "@time" module

- Improve Duration parsing
- Use static constructors for Instant and Duration
- Add tests

Author: khvzak

Cargo.toml

@@ -38,6 +38,7 @@ regex = { version = "1.0", optional = true }
 quick_cache = { version = "0.6", optional = true }
 futures-util = { version = "0.3", optional = true }
 parking_lot = "0.12"
+humantime = "2.3"
 
 # http
 http = { version = "1.3", optional = true }

lua/testing.lua

@@ -2,7 +2,7 @@ local deps = ...
 local assertions = deps.assertions
 
 local println, style = deps.println, deps.style
-local instant = deps.instant
+local Instant = deps.Instant
 
 local Testing = {}
 Testing.__index = Testing
@@ -88,7 +88,7 @@ end
 -- Run a single test
 function Testing:_run_single_test(test)
     local ctx = TestContext.new(test.name)
-    local start_time = instant()
+    local start_time = Instant.now()
     local success, err = true, nil
 
     -- Run before_each hooks
@@ -143,7 +143,7 @@ function Testing:run(opts)
     opts = opts or {}
     local pattern = opts.pattern
     self._results = {}
-    local start_time = instant()
+    local start_time = Instant.now()
 
     -- Run before_all hooks
     for _, func in ipairs(self._hooks.before_all) do

src/http/request.rs

@@ -9,7 +9,7 @@ use mlua::{
 };
 
 use crate::http::{LuaBody, LuaHeaderMapExt, LuaHeaders, LuaMethod};
-use crate::time::Duration;
+use crate::time::LuaDuration;
 
 /// A Lua wrapper around [`http::Request`].
 pub struct LuaRequest {
@@ -181,13 +181,13 @@ impl FromLua for LuaRequest {
 /// Additional custom request parameters
 #[derive(Clone, Debug, Default)]
 pub(crate) struct RequestParams {
-    pub(crate) timeout: Option<Duration>,
+    pub(crate) timeout: Option<LuaDuration>,
 }
 
 impl RequestParams {
     pub(crate) fn from_table(table: &Table) -> Result<Self> {
         let mut params = RequestParams::default();
-        if let Some(timeout) = opt_param!(Duration, Some(table), "timeout")? {
+        if let Some(timeout) = opt_param!(LuaDuration, Some(table), "timeout")? {
             params.timeout = Some(timeout);
         }
         Ok(params)

src/http/server.rs

@@ -17,7 +17,7 @@ use tokio::io::{AsyncRead, AsyncWrite};
 use super::{LuaRequest, LuaResponse};
 use crate::net::common::Accept;
 use crate::net::{AnyListener, AnyStream};
-use crate::time::Duration;
+use crate::time::LuaDuration;
 
 /// Local executor that can spawn `!Send` futures
 #[derive(Clone, Copy)]
@@ -55,7 +55,7 @@ impl LuaHttpServer {
         if let Some(max_headers) = opt_param!(http1, "max_headers")? {
             conn.http1().max_headers(max_headers);
         }
-        if let Some(header_read_timeout) = opt_param!(Duration, http1, "header_read_timeout")? {
+        if let Some(header_read_timeout) = opt_param!(LuaDuration, http1, "header_read_timeout")? {
             conn.http1().header_read_timeout(header_read_timeout.0);
         }
         if let Some(max_buf_size) = opt_param!(http1, "max_buf_size")? {
@@ -83,10 +83,10 @@ impl LuaHttpServer {
         if let Some(max_concurrent_streams) = opt_param!(u32, http2, "max_concurrent_streams")? {
             conn.http2().max_concurrent_streams(max_concurrent_streams);
         }
-        if let Some(keep_alive_interval) = opt_param!(Duration, http2, "keep_alive_interval")? {
+        if let Some(keep_alive_interval) = opt_param!(LuaDuration, http2, "keep_alive_interval")? {
             conn.http2().keep_alive_interval(keep_alive_interval.0);
         }
-        if let Some(keep_alive_timeout) = opt_param!(Duration, http2, "keep_alive_timeout")? {
+        if let Some(keep_alive_timeout) = opt_param!(LuaDuration, http2, "keep_alive_timeout")? {
             conn.http2().keep_alive_timeout(keep_alive_timeout.0);
         }
         if let Some(max_header_list_size) = opt_param!(u32, http2, "max_header_list_size")? {
@@ -167,7 +167,7 @@ impl LuaHttpServer {
     }
 
     /// Shutdown the server gracefully, waiting for existing connections to finish
-    pub async fn graceful_shutdown(&self, wait: Duration) {
+    pub async fn graceful_shutdown(&self, wait: LuaDuration) {
         let shutdown_tx = mem::take(&mut *self.shutdown_notify.lock());
         let _ = shutdown_tx.send(());
         let graceful = mem::take(&mut *self.graceful.lock());
@@ -199,8 +199,8 @@ impl UserData for LuaHttpServer {
 
         registry.add_async_method(
             "graceful_shutdown",
-            |_lua, this, wait: Option<Duration>| async move {
-                let wait = wait.unwrap_or(Duration(std::time::Duration::from_secs(60)));
+            |_lua, this, wait: Option<LuaDuration>| async move {
+                let wait = wait.unwrap_or(LuaDuration(std::time::Duration::from_secs(60)));
                 this.graceful_shutdown(wait).await;
                 Ok(())
             },

src/net/tcp/stream.rs

@@ -11,15 +11,15 @@ use tokio::net::{TcpStream, lookup_host};
 
 use super::{LuaTcpSocket, SocketOptions};
 use crate::net::{AddressProvider, AnySocketAddr};
-use crate::time::Duration;
+use crate::time::LuaDuration;
 
 /// Lua wrapper around tokio [`TcpStream`].
 pub struct LuaTcpStream {
     pub(crate) stream: TcpStream,
     #[allow(unused)]
     pub(crate) host: Option<String>,
-    pub(crate) read_timeout: Option<Duration>,
-    pub(crate) write_timeout: Option<Duration>,
+    pub(crate) read_timeout: Option<LuaDuration>,
+    pub(crate) write_timeout: Option<LuaDuration>,
 }
 
 impl Deref for LuaTcpStream {
@@ -91,12 +91,12 @@ impl UserData for LuaTcpStream {
         registry.add_method("local_addr", |_, this, ()| Ok(this.local_addr()?));
         registry.add_method("peer_addr", |_, this, ()| Ok(this.peer_addr()?));
 
-        registry.add_method_mut("set_read_timeout", |_, this, dur: Option<Duration>| {
+        registry.add_method_mut("set_read_timeout", |_, this, dur: Option<LuaDuration>| {
             this.read_timeout = dur;
             Ok(())
         });
 
-        registry.add_method_mut("set_write_timeout", |_, this, dur: Option<Duration>| {
+        registry.add_method_mut("set_write_timeout", |_, this, dur: Option<LuaDuration>| {
             this.write_timeout = dur;
             Ok(())
         });
@@ -160,10 +160,10 @@ pub async fn connect(
     let addrs = lua_try!(lookup_host((&*host, port)).await);
     let options = SocketOptions::from_table(&params)?;
 
-    let timeout = opt_param!(Duration, params, "timeout")?; // A single timeout for any operation
-    let connect_timeout = opt_param!(Duration, params, "connect_timeout")?.or(timeout);
-    let read_timeout = opt_param!(Duration, params, "read_timeout")?.or(timeout);
-    let write_timeout = opt_param!(Duration, params, "write_timeout")?.or(timeout);
+    let timeout = opt_param!(LuaDuration, params, "timeout")?; // A single timeout for any operation
+    let connect_timeout = opt_param!(LuaDuration, params, "connect_timeout")?.or(timeout);
+    let read_timeout = opt_param!(LuaDuration, params, "read_timeout")?.or(timeout);
+    let write_timeout = opt_param!(LuaDuration, params, "write_timeout")?.or(timeout);
 
     let try_connect = |addr: SocketAddr| async move {
         let sock = LuaTcpSocket::new_for_addr(addr)?;

src/net/tls/stream.rs

@@ -10,16 +10,16 @@ use tokio_rustls::{TlsAcceptor, TlsConnector, TlsStream};
 use super::client::TlsClientConfig;
 use super::server::TlsServerConfig;
 use crate::net::AddressProvider;
-use crate::time::Duration;
+use crate::time::LuaDuration;
 
 /// A TLS stream wrapper for Lua.
 ///
 /// This type wraps a TLS stream and provides read/write methods.
 /// It consumes the underlying stream to prevent further use of the plain stream.
 pub struct LuaTlsStream<S> {
     inner: TlsStream<S>,
-    read_timeout: Option<Duration>,
-    write_timeout: Option<Duration>,
+    read_timeout: Option<LuaDuration>,
+    write_timeout: Option<LuaDuration>,
 }
 
 impl<S> LuaTlsStream<S>
@@ -58,11 +58,11 @@ where
         })
     }
 
-    pub(crate) fn set_read_timeout(&mut self, dur: Option<Duration>) {
+    pub(crate) fn set_read_timeout(&mut self, dur: Option<LuaDuration>) {
         self.read_timeout = dur;
     }
 
-    pub(crate) fn set_write_timeout(&mut self, dur: Option<Duration>) {
+    pub(crate) fn set_write_timeout(&mut self, dur: Option<LuaDuration>) {
         self.write_timeout = dur;
     }
 
@@ -128,12 +128,12 @@ where
         registry.add_method("local_addr", |_, this, ()| Ok(this.local_addr()?));
         registry.add_method("peer_addr", |_, this, ()| Ok(this.peer_addr()?));
 
-        registry.add_method_mut("set_read_timeout", |_, this, dur: Option<Duration>| {
+        registry.add_method_mut("set_read_timeout", |_, this, dur: Option<LuaDuration>| {
             this.read_timeout = dur;
             Ok(())
         });
 
-        registry.add_method_mut("set_write_timeout", |_, this, dur: Option<Duration>| {
+        registry.add_method_mut("set_write_timeout", |_, this, dur: Option<LuaDuration>| {
             this.write_timeout = dur;
             Ok(())
         });

src/net/udp/socket.rs

@@ -6,12 +6,12 @@ use mlua::{Lua, Result, String as LuaString, Table, UserData, UserDataMethods, U
 use tokio::net::UdpSocket;
 
 use crate::net::{AddressProvider, AnySocketAddr};
-use crate::time::Duration;
+use crate::time::LuaDuration;
 
 /// A Lua userdata wrapper around [`UdpSocket`].
 pub struct LuaUdpSocket {
     pub(crate) socket: UdpSocket,
-    pub(crate) recv_timeout: Option<Duration>,
+    pub(crate) recv_timeout: Option<LuaDuration>,
 }
 
 impl Deref for LuaUdpSocket {
@@ -49,7 +49,7 @@ impl UserData for LuaUdpSocket {
         registry.add_method("local_addr", |_, this, ()| Ok(this.local_addr()?));
         registry.add_method("peer_addr", |_, this, ()| Ok(this.peer_addr()?));
 
-        registry.add_method_mut("set_recv_timeout", |_, this, dur: Option<Duration>| {
+        registry.add_method_mut("set_recv_timeout", |_, this, dur: Option<LuaDuration>| {
             this.recv_timeout = dur;
             Ok(())
         });
@@ -122,7 +122,7 @@ pub async fn bind(
     (host, port, params): (String, Option<u16>, Option<Table>),
 ) -> Result<StdResult<LuaUdpSocket, String>> {
     let port = port.unwrap_or(0);
-    let recv_timeout = opt_param!(Duration, params, "recv_timeout")?;
+    let recv_timeout = opt_param!(LuaDuration, params, "recv_timeout")?;
 
     let socket = lua_try!(UdpSocket::bind((host, port)).await);
 

src/net/unix/stream.rs

@@ -10,12 +10,12 @@ use tokio::io::{AsyncRead, AsyncReadExt as _, AsyncWrite, AsyncWriteExt as _, Re
 use tokio::net::UnixStream;
 
 use crate::net::{AddressProvider, AnySocketAddr};
-use crate::time::Duration;
+use crate::time::LuaDuration;
 
 pub struct LuaUnixStream {
     pub(crate) stream: UnixStream,
-    pub(crate) read_timeout: Option<Duration>,
-    pub(crate) write_timeout: Option<Duration>,
+    pub(crate) read_timeout: Option<LuaDuration>,
+    pub(crate) write_timeout: Option<LuaDuration>,
 }
 
 impl Deref for LuaUnixStream {
@@ -85,12 +85,12 @@ impl UserData for LuaUnixStream {
         registry.add_method("local_addr", |_, this, ()| Ok(this.local_addr()?));
         registry.add_method("peer_addr", |_, this, ()| Ok(this.peer_addr()?));
 
-        registry.add_method_mut("set_read_timeout", |_, this, dur: Option<Duration>| {
+        registry.add_method_mut("set_read_timeout", |_, this, dur: Option<LuaDuration>| {
             this.read_timeout = dur;
             Ok(())
         });
 
-        registry.add_method_mut("set_write_timeout", |_, this, dur: Option<Duration>| {
+        registry.add_method_mut("set_write_timeout", |_, this, dur: Option<LuaDuration>| {
             this.write_timeout = dur;
             Ok(())
         });
@@ -139,7 +139,7 @@ pub async fn connect(
     _: Lua,
     (path, params): (PathBuf, Option<Table>),
 ) -> Result<StdResult<LuaUnixStream, String>> {
-    let timeout = opt_param!(Duration, params, "timeout")?; // A single timeout for any operation
+    let timeout = opt_param!(LuaDuration, params, "timeout")?; // A single timeout for any operation
     let connect_timeout = opt_param!(params, "connect_timeout")?.or(timeout);
     let read_timeout = opt_param!(params, "read_timeout")?.or(timeout);
     let write_timeout = opt_param!(params, "write_timeout")?.or(timeout);

src/reqwest.rs

@@ -3,7 +3,7 @@ use mlua::{
 };
 
 use crate::http::{LuaHeaders, LuaRequest, LuaResponse};
-use crate::time::Duration;
+use crate::time::LuaDuration;
 
 /// A Lua wrapper around [`reqwest::Client`].
 #[derive(Clone, Debug)]
@@ -15,16 +15,16 @@ impl UserData for Client {
             let mut builder = reqwest::Client::builder();
 
             // Timeouts and connection pool
-            if let Some(timeout) = opt_param!(Duration, params, "timeout")? {
+            if let Some(timeout) = opt_param!(LuaDuration, params, "timeout")? {
                 builder = builder.timeout(timeout.0);
             }
-            if let Some(connect_timeout) = opt_param!(Duration, params, "connect_timeout")? {
+            if let Some(connect_timeout) = opt_param!(LuaDuration, params, "connect_timeout")? {
                 builder = builder.connect_timeout(connect_timeout.0);
             }
-            if let Some(read_timeout) = opt_param!(Duration, params, "read_timeout")? {
+            if let Some(read_timeout) = opt_param!(LuaDuration, params, "read_timeout")? {
                 builder = builder.read_timeout(read_timeout.0);
             }
-            if let Some(pool_idle_timeout) = opt_param!(Duration, params, "pool_idle_timeout")? {
+            if let Some(pool_idle_timeout) = opt_param!(LuaDuration, params, "pool_idle_timeout")? {
                 builder = builder.pool_idle_timeout(pool_idle_timeout.0);
             }
             if let Some(pool_max_idle_per_host) = opt_param!(params, "pool_max_idle_per_host")? {

src/task.rs

@@ -11,18 +11,18 @@ use tokio::task::{AbortHandle, JoinHandle, JoinSet};
 use tokio::time::{Instant as TokioInstant, MissedTickBehavior};
 use tokio_util::time::FutureExt as _;
 
-use crate::time::Duration;
+use crate::time::LuaDuration;
 
 #[derive(Clone, Default)]
 struct Params {
     name: Option<String>,
-    timeout: Option<Duration>,
+    timeout: Option<LuaDuration>,
 }
 
 pub struct TaskHandle {
     name: Option<String>,
     started: Rc<RefCell<Option<Instant>>>,
-    elapsed: Rc<RefCell<Option<Duration>>>,
+    elapsed: Rc<RefCell<Option<LuaDuration>>>,
     handle: Either<Option<JoinHandle<Result<Value>>>, AbortHandle>,
 }
 
@@ -64,7 +64,7 @@ impl UserData for TaskHandle {
 
         registry.add_method("elapsed", |_, this, ()| match *this.elapsed.borrow() {
             Some(dur) => Ok(Some(dur)),
-            None => Ok(this.started.borrow().map(|s| Duration(s.elapsed()))),
+            None => Ok(this.started.borrow().map(|s| LuaDuration(s.elapsed()))),
         });
 
         registry.add_method("is_finished", |_, this, ()| match this.handle.as_ref() {
@@ -83,7 +83,7 @@ pub struct Task {
 impl Task {
     fn new(func: Function, params: Option<Table>) -> Result<Self> {
         let name: Option<String> = opt_param!(params, "name")?;
-        let timeout: Option<Duration> = opt_param!(params, "timeout")?;
+        let timeout: Option<LuaDuration> = opt_param!(params, "timeout")?;
         Ok(Self {
             func,
             params: Params { name, timeout },
@@ -122,7 +122,7 @@ impl UserData for Group {
                 let abort_handle = this.0.spawn_local(async move {
                     *started2.borrow_mut() = Some(Instant::now());
                     defer! {
-                        *elapsed2.borrow_mut() = Some(Duration(started2.borrow().unwrap().elapsed()));
+                        *elapsed2.borrow_mut() = Some(LuaDuration(started2.borrow().unwrap().elapsed()));
                     }
 
                     let result = match timeout {
@@ -191,7 +191,7 @@ fn spawn_inner(params: Params, fut: impl Future<Output = Result<Value>> + 'stati
     let handle = tokio::task::spawn_local(async move {
         *started2.borrow_mut() = Some(Instant::now());
         defer! {
-            *elapsed2.borrow_mut() = Some(Duration(started2.borrow().unwrap().elapsed()));
+            *elapsed2.borrow_mut() = Some(LuaDuration(started2.borrow().unwrap().elapsed()));
         }
 
         let result = match timeout {
@@ -226,7 +226,7 @@ pub fn spawn(_: &Lua, (func, args): (Either<Function, UserDataRef<Task>>, MultiV
 
 pub fn spawn_every(
     _: &Lua,
-    (dur, func, args): (Duration, Either<Function, UserDataRef<Task>>, MultiValue),
+    (dur, func, args): (LuaDuration, Either<Function, UserDataRef<Task>>, MultiValue),
 ) -> Result<TaskHandle> {
     let (func, params) = match func {
         Either::Left(f) => (f, Params::default()),
@@ -243,7 +243,7 @@ pub fn spawn_every(
     })
 }
 
-pub async fn sleep(_: Lua, dur: Duration) -> Result<()> {
+pub async fn sleep(_: Lua, dur: LuaDuration) -> Result<()> {
     tokio::time::sleep(dur.0).await;
     Ok(())
 }