feat(rust): Time Module Implementation

.config/dictionaries/project.dic

@@ -20,6 +20,7 @@ codepoints
 coti
 crontabs
 cryptoxide
+Datelike
 dbsync
 dcbor
 delegators
@@ -48,6 +49,7 @@ fstat
 fstatat
 futimens
 genhtml
+getres
 GETFL
 gmtime
 happ
@@ -65,6 +67,7 @@ jormungandr
 Jörmungandr
 lcov
 Leshiy
+libc
 linkat
 lintfix
 localizable
@@ -81,6 +84,7 @@ multiera
 nanos
 netkey
 nextest
+nsec
 oneshot
 openapi
 openat
@@ -119,13 +123,16 @@ seckey
 slotno
 smac
 stevenj
+subsec
 symlinkat
+syscall
 tacho
 testcov
 testdocs
 testunit
 thiserror
 timelike
+timespec
 toolsets
 Traceback
 txns

hermes/Cargo.toml

@@ -65,4 +65,7 @@ tracing = "0.1.40"
 tracing-subscriber = "0.3.18"
 criterion = "0.5.1"
 time = "0.3.34"
+chrono = "0.4.34"
+chrono-tz = "0.8.6"
 once_cell = "1.19.0"
+iana-time-zone = "0.1.60"

hermes/bin/Cargo.toml

@@ -29,4 +29,7 @@ hex-literal = { workspace = true }
 thiserror = { workspace = true }
 criterion = { workspace = true, optional = true }
 time = { workspace = true }
+chrono = { workspace = true }
+chrono-tz = { workspace = true }
 once_cell = { workspace = true }
+iana-time-zone = { workspace = true }

hermes/bin/src/runtime_extensions/hermes/cron/mod.rs

@@ -342,8 +342,6 @@ impl Ord for CronComponent {
 
 #[cfg(test)]
 mod tests {
-    use time::Duration;
-
     use super::*;
 
     // Define lower limit for the schedule component values.

hermes/bin/src/runtime_extensions/hermes/localtime/host.rs

@@ -1,10 +1,16 @@
 //! Localtime host implementation for WASM runtime.
 
+use chrono::{Local, TimeZone};
+use chrono_tz::Tz;
+
 use crate::{
     runtime_context::HermesRuntimeContext,
-    runtime_extensions::bindings::{
-        hermes::localtime::api::{Errno, Host, Localtime, Timezone},
-        wasi::clocks::wall_clock::Datetime,
+    runtime_extensions::{
+        bindings::{
+            hermes::localtime::api::{Errno, Host, Localtime, Timezone},
+            wasi::clocks::wall_clock::Datetime,
+        },
+        hermes::localtime::get_tz,
     },
 };
 
@@ -23,9 +29,23 @@ impl Host for HermesRuntimeContext {
     /// `localtime` : the converted time.
     /// `errno`     : An error indicating why conversion failed.
     fn get_localtime(
-        &mut self, _when: Option<Datetime>, _tz: Option<Timezone>,
+        &mut self, when: Option<Datetime>, tz: Option<Timezone>,
     ) -> wasmtime::Result<Result<Localtime, Errno>> {
-        todo!()
+        let timezone = get_tz(tz)?;
+        let local_naive = match when {
+            Some(Datetime {
+                seconds,
+                nanoseconds,
+            }) => {
+                let seconds = seconds.try_into().map_err(|_| Errno::InvalidLocaltime)?;
+                let utc_dt = chrono::DateTime::from_timestamp(seconds, nanoseconds)
+                    .ok_or(Errno::InvalidLocaltime)?;
+                utc_dt.naive_utc()
+            },
+            None => Local::now().naive_utc(),
+        };
+        let local_date_time = timezone.from_utc_datetime(&local_naive);
+        Ok(local_date_time.try_into())
     }
 
     /// Get a new localtime from a localtime, by recalculating time for a new timezone.
@@ -41,9 +61,17 @@ impl Host for HermesRuntimeContext {
     /// `localtime` : the converted time.
     /// `errno`     : An error indicating why conversion failed.
     fn alt_localtime(
-        &mut self, _time: Localtime, _tz: Option<Timezone>,
+        &mut self, time: Localtime, tz: Option<Timezone>,
     ) -> wasmtime::Result<Result<Localtime, Errno>> {
-        todo!()
+        let local_date_time: chrono::DateTime<Tz> = time.try_into()?;
+        let alt_local_date_time = match tz {
+            Some(alt_tz) => {
+                let tz = get_tz(Some(alt_tz))?;
+                tz.from_utc_datetime(&local_date_time.naive_utc())
+            },
+            None => local_date_time,
+        };
+        Ok(alt_local_date_time.try_into())
     }
 
     /// Get a datetime from a localtime.
@@ -56,7 +84,7 @@ impl Host for HermesRuntimeContext {
     ///
     /// `datetime`  : the converted time.
     /// `errno`     : An error indicating why conversion failed.
-    fn get_datetime(&mut self, _time: Localtime) -> wasmtime::Result<Result<Datetime, Errno>> {
-        todo!()
+    fn get_datetime(&mut self, time: Localtime) -> wasmtime::Result<Result<Datetime, Errno>> {
+        Ok(time.try_into())
     }
 }

hermes/bin/src/runtime_extensions/hermes/localtime/mod.rs

@@ -1,6 +1,120 @@
 //! Localtime runtime extension implementation.
 
+use chrono::{Datelike, NaiveDate, TimeZone, Timelike};
+use chrono_tz::{OffsetName, Tz};
+
+use crate::runtime_extensions::bindings::{
+    hermes::localtime::api::{Errno, Localtime, Timezone},
+    wasi::clocks::wall_clock::Datetime,
+};
+
 mod host;
 
 /// Advise Runtime Extensions of a new context
 pub(crate) fn new_context(_ctx: &crate::runtime_context::HermesRuntimeContext) {}
+
+/// Get `Tz` from an optional `Timezone`.
+///
+/// If present, `tz` is parsed into `Tz`, otherwise the system timezone is
+/// returned.
+///
+/// This function returns `Errno::UnknownTimezone` if `tz` cannot be parsed.
+///
+/// **Parameters**
+/// * `tz`: `Option<Timezone>`.
+///
+/// **Returns**
+/// `wasmtime::Result<Result<Tz, Errno>>`.
+pub(crate) fn get_tz(tz: Option<Timezone>) -> Result<Tz, Errno> {
+    let timezone_str = match tz {
+        Some(tz_str) => tz_str,
+        None => iana_time_zone::get_timezone().map_err(|_| Errno::UnknownTimezone)?,
+    };
+    timezone_str.parse().map_err(|_| Errno::UnknownTimezone)
+}
+
+impl TryFrom<chrono::DateTime<Tz>> for Localtime {
+    type Error = Errno;
+
+    fn try_from(dt: chrono::DateTime<Tz>) -> Result<Self, Self::Error> {
+        let localtime = Localtime {
+            year: dt.year().try_into().map_err(|_| Errno::YearOutOfRange)?,
+            month: dt.month().try_into().map_err(|_| Errno::InvalidLocaltime)?,
+            dow: dt
+                .weekday()
+                .number_from_monday()
+                .try_into()
+                .map_err(|_| Errno::InvalidLocaltime)?,
+            day: dt.day().try_into().map_err(|_| Errno::InvalidLocaltime)?,
+            hh: dt.hour().try_into().map_err(|_| Errno::InvalidLocaltime)?,
+            mm: dt
+                .minute()
+                .try_into()
+                .map_err(|_| Errno::InvalidLocaltime)?,
+            ss: dt
+                .second()
+                .try_into()
+                .map_err(|_| Errno::InvalidLocaltime)?,
+            ns: dt.nanosecond(),
+            tz: dt.offset().tz_id().to_string(),
+        };
+        Ok(localtime)
+    }
+}
+
+impl TryInto<chrono::DateTime<Tz>> for Localtime {
+    type Error = Errno;
+
+    fn try_into(self) -> Result<chrono::DateTime<Tz>, Self::Error> {
+        let Localtime {
+            year,
+            month,
+            dow: _,
+            day,
+            hh,
+            mm,
+            ss,
+            ns,
+            tz: orig_tz,
+        } = self;
+        let orig_tz = get_tz(Some(orig_tz))?;
+        let year: i32 = year.try_into().map_err(|_| Errno::YearOutOfRange)?;
+        let month: u32 = month.into();
+        let day: u32 = day.into();
+        let hh: u32 = hh.into();
+        let mm: u32 = mm.into();
+        let ss: u32 = ss.into();
+        let ns: u32 = ns;
+        let naive_date_time = NaiveDate::from_ymd_opt(year, month, day)
+            .ok_or(Errno::InvalidLocaltime)?
+            .and_hms_nano_opt(hh, mm, ss, ns)
+            .ok_or(Errno::InvalidLocaltime)?;
+        let date_time = orig_tz.from_utc_datetime(&naive_date_time);
+        Ok(date_time)
+    }
+}
+
+impl TryFrom<chrono::DateTime<Tz>> for Datetime {
+    type Error = Errno;
+
+    fn try_from(value: chrono::DateTime<Tz>) -> Result<Self, Self::Error> {
+        let seconds = value
+            .timestamp()
+            .try_into()
+            .map_err(|_| Errno::InvalidLocaltime)?;
+        let nanoseconds = value.nanosecond();
+        Ok(Datetime {
+            seconds,
+            nanoseconds,
+        })
+    }
+}
+
+impl TryFrom<Localtime> for Datetime {
+    type Error = Errno;
+
+    fn try_from(value: Localtime) -> Result<Self, Self::Error> {
+        let dt: chrono::DateTime<Tz> = value.try_into()?;
+        dt.try_into()
+    }
+}

hermes/bin/src/runtime_extensions/wasi/clocks/mod.rs

@@ -1,6 +1,7 @@
 //! Host - WASI - Clock implementations
 
 mod monotonic;
+mod state;
 mod wall;
 
 /// Advise Runtime Extensions of a new context

hermes/bin/src/runtime_extensions/wasi/clocks/monotonic/host.rs

@@ -2,7 +2,10 @@
 
 use crate::{
     runtime_context::HermesRuntimeContext,
-    runtime_extensions::bindings::wasi::clocks::monotonic_clock::{Duration, Host, Instant},
+    runtime_extensions::{
+        bindings::wasi::clocks::monotonic_clock::{Duration, Host, Instant},
+        wasi::clocks::state::{monotonic_clock_now, monotonic_clock_res},
+    },
 };
 
 impl Host for HermesRuntimeContext {
@@ -11,12 +14,12 @@ impl Host for HermesRuntimeContext {
     /// The clock is monotonic, therefore calling this function repeatedly will
     /// produce a sequence of non-decreasing values.
     fn now(&mut self) -> wasmtime::Result<Instant> {
-        todo!()
+        monotonic_clock_now()
     }
 
     /// Query the resolution of the clock. Returns the duration of time
     /// corresponding to a clock tick.
     fn resolution(&mut self) -> wasmtime::Result<Duration> {
-        todo!()
+        Ok(monotonic_clock_res())
     }
 }