chore: get rid of chrono in favor of time

Chrono has been unmaintened for a few month now and there is a CVE on it.

make clippy happy

bump milli

meilisearch-http/src/analytics/segment_analytics.rs

@@ -6,7 +6,6 @@ use std::time::{Duration, Instant};
 
 use actix_web::http::header::USER_AGENT;
 use actix_web::HttpRequest;
-use chrono::{DateTime, Utc};
 use http::header::CONTENT_TYPE;
 use meilisearch_auth::SearchRules;
 use meilisearch_lib::index::{SearchQuery, SearchResult};
@@ -18,6 +17,7 @@ use segment::message::{Identify, Track, User};
 use segment::{AutoBatcher, Batcher, HttpClient};
 use serde_json::{json, Value};
 use sysinfo::{DiskExt, System, SystemExt};
+use time::OffsetDateTime;
 use tokio::select;
 use tokio::sync::mpsc::{self, Receiver, Sender};
 use uuid::Uuid;
@@ -323,7 +323,7 @@ impl Segment {
 
 #[derive(Default)]
 pub struct SearchAggregator {
-    timestamp: Option<DateTime<Utc>>,
+    timestamp: Option<OffsetDateTime>,
 
     // context
     user_agents: HashSet<String>,
@@ -360,7 +360,7 @@ pub struct SearchAggregator {
 impl SearchAggregator {
     pub fn from_query(query: &SearchQuery, request: &HttpRequest) -> Self {
         let mut ret = Self::default();
-        ret.timestamp = Some(chrono::offset::Utc::now());
+        ret.timestamp = Some(OffsetDateTime::now_utc());
 
         ret.total_received = 1;
         ret.user_agents = extract_user_agents(request).into_iter().collect();
@@ -504,7 +504,7 @@ impl SearchAggregator {
 
 #[derive(Default)]
 pub struct DocumentsAggregator {
-    timestamp: Option<DateTime<Utc>>,
+    timestamp: Option<OffsetDateTime>,
 
     // set to true when at least one request was received
     updated: bool,
@@ -524,7 +524,7 @@ impl DocumentsAggregator {
         request: &HttpRequest,
     ) -> Self {
         let mut ret = Self::default();
-        ret.timestamp = Some(chrono::offset::Utc::now());
+        ret.timestamp = Some(OffsetDateTime::now_utc());
 
         ret.updated = true;
         ret.user_agents = extract_user_agents(request).into_iter().collect();

meilisearch-http/src/extractors/authentication/mod.rs

@@ -94,10 +94,10 @@ pub trait Policy {
 }
 
 pub mod policies {
-    use chrono::Utc;
     use jsonwebtoken::{dangerous_insecure_decode, decode, Algorithm, DecodingKey, Validation};
     use once_cell::sync::Lazy;
     use serde::{Deserialize, Serialize};
+    use time::OffsetDateTime;
 
     use crate::extractors::authentication::Policy;
     use meilisearch_auth::{Action, AuthController, AuthFilter, SearchRules};
@@ -183,7 +183,7 @@ pub mod policies {
 
             // Check if token is expired.
             if let Some(exp) = exp {
-                if Utc::now().timestamp() > exp {
+                if OffsetDateTime::now_utc().unix_timestamp() > exp {
                     return None;
                 }
             }

meilisearch-http/src/routes/api_key.rs

@@ -1,11 +1,11 @@
 use std::str;
 
 use actix_web::{web, HttpRequest, HttpResponse};
-use chrono::SecondsFormat;
 
 use meilisearch_auth::{Action, AuthController, Key};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use time::OffsetDateTime;
 
 use crate::extractors::authentication::{policies::*, GuardedData};
 use meilisearch_error::ResponseError;
@@ -92,9 +92,12 @@ struct KeyView {
     key: String,
     actions: Vec<Action>,
     indexes: Vec<String>,
-    expires_at: Option<String>,
-    created_at: String,
-    updated_at: String,
+    #[serde(serialize_with = "time::serde::rfc3339::option::serialize")]
+    expires_at: Option<OffsetDateTime>,
+    #[serde(serialize_with = "time::serde::rfc3339::serialize")]
+    created_at: OffsetDateTime,
+    #[serde(serialize_with = "time::serde::rfc3339::serialize")]
+    updated_at: OffsetDateTime,
 }
 
 impl KeyView {
@@ -107,11 +110,9 @@ impl KeyView {
             key: generated_key,
             actions: key.actions,
             indexes: key.indexes,
-            expires_at: key
-                .expires_at
-                .map(|dt| dt.to_rfc3339_opts(SecondsFormat::Secs, true)),
-            created_at: key.created_at.to_rfc3339_opts(SecondsFormat::Secs, true),
-            updated_at: key.updated_at.to_rfc3339_opts(SecondsFormat::Secs, true),
+            expires_at: key.expires_at,
+            created_at: key.created_at,
+            updated_at: key.updated_at,
         }
     }
 }

meilisearch-http/src/routes/indexes/mod.rs

@@ -1,11 +1,11 @@
 use actix_web::{web, HttpRequest, HttpResponse};
-use chrono::{DateTime, Utc};
 use log::debug;
 use meilisearch_error::ResponseError;
 use meilisearch_lib::index_controller::Update;
 use meilisearch_lib::MeiliSearch;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
+use time::OffsetDateTime;
 
 use crate::analytics::Analytics;
 use crate::extractors::authentication::{policies::*, GuardedData};
@@ -95,9 +95,12 @@ pub struct UpdateIndexRequest {
 pub struct UpdateIndexResponse {
     name: String,
     uid: String,
-    created_at: DateTime<Utc>,
-    updated_at: DateTime<Utc>,
-    primary_key: Option<String>,
+    #[serde(serialize_with = "time::serde::rfc3339::serialize")]
+    created_at: OffsetDateTime,
+    #[serde(serialize_with = "time::serde::rfc3339::serialize")]
+    updated_at: OffsetDateTime,
+    #[serde(serialize_with = "time::serde::rfc3339::serialize")]
+    primary_key: OffsetDateTime,
 }
 
 pub async fn get_index(

meilisearch-http/src/routes/indexes/tasks.rs

@@ -1,10 +1,10 @@
 use actix_web::{web, HttpRequest, HttpResponse};
-use chrono::{DateTime, Utc};
 use log::debug;
 use meilisearch_error::ResponseError;
 use meilisearch_lib::MeiliSearch;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
+use time::OffsetDateTime;
 
 use crate::analytics::Analytics;
 use crate::extractors::authentication::{policies::*, GuardedData};
@@ -20,9 +20,12 @@ pub fn configure(cfg: &mut web::ServiceConfig) {
 pub struct UpdateIndexResponse {
     name: String,
     uid: String,
-    created_at: DateTime<Utc>,
-    updated_at: DateTime<Utc>,
-    primary_key: Option<String>,
+    #[serde(serialize_with = "time::serde::rfc3339::serialize")]
+    created_at: OffsetDateTime,
+    #[serde(serialize_with = "time::serde::rfc3339::serialize")]
+    updated_at: OffsetDateTime,
+    #[serde(serialize_with = "time::serde::rfc3339::serialize")]
+    primary_key: OffsetDateTime,
 }
 
 #[derive(Deserialize)]

meilisearch-http/src/routes/mod.rs

@@ -1,7 +1,7 @@
 use actix_web::{web, HttpResponse};
-use chrono::{DateTime, Utc};
 use log::debug;
 use serde::{Deserialize, Serialize};
+use time::OffsetDateTime;
 
 use meilisearch_error::ResponseError;
 use meilisearch_lib::index::{Settings, Unchecked};
@@ -54,8 +54,10 @@ pub struct ProcessedUpdateResult {
     #[serde(rename = "type")]
     pub update_type: UpdateType,
     pub duration: f64, // in seconds
-    pub enqueued_at: DateTime<Utc>,
-    pub processed_at: DateTime<Utc>,
+    #[serde(serialize_with = "time::serde::rfc3339::serialize")]
+    pub enqueued_at: OffsetDateTime,
+    #[serde(serialize_with = "time::serde::rfc3339::serialize")]
+    pub processed_at: OffsetDateTime,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -66,8 +68,10 @@ pub struct FailedUpdateResult {
     pub update_type: UpdateType,
     pub error: ResponseError,
     pub duration: f64, // in seconds
-    pub enqueued_at: DateTime<Utc>,
-    pub processed_at: DateTime<Utc>,
+    #[serde(serialize_with = "time::serde::rfc3339::serialize")]
+    pub enqueued_at: OffsetDateTime,
+    #[serde(serialize_with = "time::serde::rfc3339::serialize")]
+    pub processed_at: OffsetDateTime,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -76,9 +80,13 @@ pub struct EnqueuedUpdateResult {
     pub update_id: u64,
     #[serde(rename = "type")]
     pub update_type: UpdateType,
-    pub enqueued_at: DateTime<Utc>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub started_processing_at: Option<DateTime<Utc>>,
+    #[serde(serialize_with = "time::serde::rfc3339::serialize")]
+    pub enqueued_at: OffsetDateTime,
+    #[serde(
+        skip_serializing_if = "Option::is_none",
+        serialize_with = "time::serde::rfc3339::option::serialize"
+    )]
+    pub started_processing_at: Option<OffsetDateTime>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

meilisearch-http/src/task.rs

@@ -1,4 +1,6 @@
-use chrono::{DateTime, Duration, Utc};
+use std::fmt::Write;
+use std::write;
+
 use meilisearch_error::ResponseError;
 use meilisearch_lib::index::{Settings, Unchecked};
 use meilisearch_lib::milli::update::IndexDocumentsMethod;
@@ -7,6 +9,7 @@ use meilisearch_lib::tasks::task::{
     DocumentDeletion, Task, TaskContent, TaskEvent, TaskId, TaskResult,
 };
 use serde::{Serialize, Serializer};
+use time::{Duration, OffsetDateTime};
 
 use crate::AUTOBATCHING_ENABLED;
 
@@ -79,14 +82,52 @@ enum TaskDetails {
     ClearAll { deleted_documents: Option<u64> },
 }
 
+/// Serialize a `time::Duration` as a best effort ISO 8601 while waiting for
+/// https://github.com/time-rs/time/issues/378.
+/// This code is a port of the old code of time that was removed in 0.2.
 fn serialize_duration<S: Serializer>(
     duration: &Option<Duration>,
     serializer: S,
 ) -> Result<S::Ok, S::Error> {
     match duration {
         Some(duration) => {
-            let duration_str = duration.to_string();
-            serializer.serialize_str(&duration_str)
+            // technically speaking, negative duration is not valid ISO 8601
+            if duration.is_negative() {
+                return serializer.serialize_none();
+            }
+
+            const SECS_PER_DAY: i64 = Duration::DAY.whole_seconds();
+            let secs = duration.whole_seconds();
+            let days = secs / SECS_PER_DAY;
+            let secs = secs - days * SECS_PER_DAY;
+            let hasdate = days != 0;
+            let nanos = duration.subsec_nanoseconds();
+            let hastime = (secs != 0 || nanos != 0) || !hasdate;
+
+            // all the following unwrap can't fail
+            let mut res = String::new();
+            write!(&mut res, "P").unwrap();
+
+            if hasdate {
+                write!(&mut res, "{}D", days).unwrap();
+            }
+
+            const NANOS_PER_MILLI: i32 = Duration::MILLISECOND.subsec_nanoseconds();
+            const NANOS_PER_MICRO: i32 = Duration::MICROSECOND.subsec_nanoseconds();
+
+            if hastime {
+                if nanos == 0 {
+                    write!(&mut res, "T{}S", secs).unwrap();
+                } else if nanos % NANOS_PER_MILLI == 0 {
+                    write!(&mut res, "T{}.{:03}S", secs, nanos / NANOS_PER_MILLI).unwrap();
+                } else if nanos % NANOS_PER_MICRO == 0 {
+                    write!(&mut res, "T{}.{:06}S", secs, nanos / NANOS_PER_MICRO).unwrap();
+                } else {
+                    write!(&mut res, "T{}.{:09}S", secs, nanos).unwrap();
+                }
+            }
+
+            serializer.serialize_str(&res)
         }
         None => serializer.serialize_none(),
     }
@@ -106,9 +147,12 @@ pub struct TaskView {
     error: Option<ResponseError>,
     #[serde(serialize_with = "serialize_duration")]
     duration: Option<Duration>,
-    enqueued_at: DateTime<Utc>,
-    started_at: Option<DateTime<Utc>>,
-    finished_at: Option<DateTime<Utc>>,
+    #[serde(serialize_with = "time::serde::rfc3339::serialize")]
+    enqueued_at: OffsetDateTime,
+    #[serde(serialize_with = "time::serde::rfc3339::option::serialize")]
+    started_at: Option<OffsetDateTime>,
+    #[serde(serialize_with = "time::serde::rfc3339::option::serialize")]
+    finished_at: Option<OffsetDateTime>,
     #[serde(skip_serializing_if = "Option::is_none")]
     batch_uid: Option<Option<BatchId>>,
 }
@@ -302,7 +346,8 @@ pub struct SummarizedTaskView {
     status: TaskStatus,
     #[serde(rename = "type")]
     task_type: TaskType,
-    enqueued_at: DateTime<Utc>,
+    #[serde(serialize_with = "time::serde::rfc3339::serialize")]
+    enqueued_at: OffsetDateTime,
 }
 
 impl From<Task> for SummarizedTaskView {