206 lines
5.7 KiB
Rust
206 lines
5.7 KiB
Rust
use meilisearch_types::error::{Code, ResponseError};
|
|
use meilisearch_types::index_uid::IndexUid;
|
|
use milli::update::IndexDocumentsMethod;
|
|
use serde::{Deserialize, Serialize};
|
|
use time::OffsetDateTime;
|
|
use uuid::Uuid;
|
|
|
|
use super::v4::{Task, TaskContent, TaskEvent};
|
|
use crate::index::{Settings, Unchecked};
|
|
use crate::tasks::task::{DocumentDeletion, TaskId, TaskResult};
|
|
|
|
use super::v2;
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
pub struct DumpEntry {
|
|
pub uuid: Uuid,
|
|
pub uid: String,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
pub struct UpdateEntry {
|
|
pub uuid: Uuid,
|
|
pub update: UpdateStatus,
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
#[serde(tag = "status", rename_all = "camelCase")]
|
|
pub enum UpdateStatus {
|
|
Processing(Processing),
|
|
Enqueued(Enqueued),
|
|
Processed(Processed),
|
|
Failed(Failed),
|
|
}
|
|
|
|
impl From<v2::UpdateResult> for TaskResult {
|
|
fn from(other: v2::UpdateResult) -> Self {
|
|
match other {
|
|
v2::UpdateResult::DocumentsAddition(result) => TaskResult::DocumentAddition {
|
|
indexed_documents: result.nb_documents as u64,
|
|
},
|
|
v2::UpdateResult::DocumentDeletion { deleted } => TaskResult::DocumentDeletion {
|
|
deleted_documents: deleted,
|
|
},
|
|
v2::UpdateResult::Other => TaskResult::Other,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[allow(clippy::large_enum_variant)]
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub enum Update {
|
|
DeleteDocuments(Vec<String>),
|
|
DocumentAddition {
|
|
primary_key: Option<String>,
|
|
method: IndexDocumentsMethod,
|
|
content_uuid: Uuid,
|
|
},
|
|
Settings(Settings<Unchecked>),
|
|
ClearDocuments,
|
|
}
|
|
|
|
impl From<Update> for super::v4::TaskContent {
|
|
fn from(update: Update) -> Self {
|
|
match update {
|
|
Update::DeleteDocuments(ids) => {
|
|
TaskContent::DocumentDeletion(DocumentDeletion::Ids(ids))
|
|
}
|
|
Update::DocumentAddition {
|
|
primary_key,
|
|
method,
|
|
..
|
|
} => TaskContent::DocumentAddition {
|
|
content_uuid: Uuid::default(),
|
|
merge_strategy: method,
|
|
primary_key,
|
|
// document count is unknown for legacy updates
|
|
documents_count: 0,
|
|
allow_index_creation: true,
|
|
},
|
|
Update::Settings(settings) => TaskContent::SettingsUpdate {
|
|
settings,
|
|
// There is no way to know now, so we assume it isn't
|
|
is_deletion: false,
|
|
allow_index_creation: true,
|
|
},
|
|
Update::ClearDocuments => TaskContent::DocumentDeletion(DocumentDeletion::Clear),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[allow(clippy::large_enum_variant)]
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
#[serde(tag = "type")]
|
|
pub enum UpdateMeta {
|
|
DocumentsAddition {
|
|
method: IndexDocumentsMethod,
|
|
primary_key: Option<String>,
|
|
},
|
|
ClearDocuments,
|
|
DeleteDocuments {
|
|
ids: Vec<String>,
|
|
},
|
|
Settings(Settings<Unchecked>),
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize, Clone)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct Enqueued {
|
|
pub update_id: u64,
|
|
pub meta: Update,
|
|
#[serde(with = "time::serde::rfc3339")]
|
|
pub enqueued_at: OffsetDateTime,
|
|
}
|
|
|
|
impl Enqueued {
|
|
fn update_task(self, task: &mut Task) {
|
|
// we do not erase the `TaskId` that was given to us.
|
|
task.content = self.meta.into();
|
|
task.events.push(TaskEvent::Created(self.enqueued_at));
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize, Clone)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct Processed {
|
|
pub success: v2::UpdateResult,
|
|
#[serde(with = "time::serde::rfc3339")]
|
|
pub processed_at: OffsetDateTime,
|
|
#[serde(flatten)]
|
|
pub from: Processing,
|
|
}
|
|
|
|
impl Processed {
|
|
fn update_task(self, task: &mut Task) {
|
|
self.from.update_task(task);
|
|
|
|
let event = TaskEvent::Succeded {
|
|
result: TaskResult::from(self.success),
|
|
timestamp: self.processed_at,
|
|
};
|
|
task.events.push(event);
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize, Clone)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct Processing {
|
|
#[serde(flatten)]
|
|
pub from: Enqueued,
|
|
#[serde(with = "time::serde::rfc3339")]
|
|
pub started_processing_at: OffsetDateTime,
|
|
}
|
|
|
|
impl Processing {
|
|
fn update_task(self, task: &mut Task) {
|
|
self.from.update_task(task);
|
|
|
|
let event = TaskEvent::Processing(self.started_processing_at);
|
|
task.events.push(event);
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct Failed {
|
|
#[serde(flatten)]
|
|
pub from: Processing,
|
|
pub msg: String,
|
|
pub code: Code,
|
|
#[serde(with = "time::serde::rfc3339")]
|
|
pub failed_at: OffsetDateTime,
|
|
}
|
|
|
|
impl Failed {
|
|
fn update_task(self, task: &mut Task) {
|
|
self.from.update_task(task);
|
|
|
|
let event = TaskEvent::Failed {
|
|
error: ResponseError::from_msg(self.msg, self.code),
|
|
timestamp: self.failed_at,
|
|
};
|
|
task.events.push(event);
|
|
}
|
|
}
|
|
|
|
impl From<(UpdateStatus, String, TaskId)> for Task {
|
|
fn from((update, uid, task_id): (UpdateStatus, String, TaskId)) -> Self {
|
|
// Dummy task
|
|
let mut task = super::v4::Task {
|
|
id: task_id,
|
|
index_uid: IndexUid::new_unchecked(uid),
|
|
content: super::v4::TaskContent::IndexDeletion,
|
|
events: Vec::new(),
|
|
};
|
|
|
|
match update {
|
|
UpdateStatus::Processing(u) => u.update_task(&mut task),
|
|
UpdateStatus::Enqueued(u) => u.update_task(&mut task),
|
|
UpdateStatus::Processed(u) => u.update_task(&mut task),
|
|
UpdateStatus::Failed(u) => u.update_task(&mut task),
|
|
}
|
|
|
|
task
|
|
}
|
|
}
|