375 lines
12 KiB
Rust
375 lines
12 KiB
Rust
use std::time::Duration;
|
|
|
|
use actix_web::{web, HttpResponse};
|
|
use chrono::{DateTime, Utc};
|
|
use log::debug;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use crate::error::ResponseError;
|
|
use crate::extractors::authentication::{policies::*, GuardedData};
|
|
use crate::index::{Settings, Unchecked};
|
|
use crate::index_controller::{UpdateMeta, UpdateResult, UpdateStatus};
|
|
use crate::Data;
|
|
|
|
mod dump;
|
|
mod indexes;
|
|
|
|
pub fn configure(cfg: &mut web::ServiceConfig) {
|
|
cfg.service(web::resource("/health").route(web::get().to(get_health)))
|
|
.service(web::scope("/dumps").configure(dump::configure))
|
|
.service(web::resource("/keys").route(web::get().to(list_keys)))
|
|
.service(web::resource("/stats").route(web::get().to(get_stats)))
|
|
.service(web::resource("/version").route(web::get().to(get_version)))
|
|
.service(web::scope("/indexes").configure(indexes::configure));
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
#[allow(clippy::large_enum_variant)]
|
|
#[serde(tag = "name")]
|
|
pub enum UpdateType {
|
|
ClearAll,
|
|
Customs,
|
|
DocumentsAddition {
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
number: Option<usize>,
|
|
},
|
|
DocumentsPartial {
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
number: Option<usize>,
|
|
},
|
|
DocumentsDeletion {
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
number: Option<usize>,
|
|
},
|
|
Settings {
|
|
settings: Settings<Unchecked>,
|
|
},
|
|
}
|
|
|
|
impl From<&UpdateStatus> for UpdateType {
|
|
fn from(other: &UpdateStatus) -> Self {
|
|
use milli::update::IndexDocumentsMethod::*;
|
|
match other.meta() {
|
|
UpdateMeta::DocumentsAddition { method, .. } => {
|
|
let number = match other {
|
|
UpdateStatus::Processed(processed) => match processed.success {
|
|
UpdateResult::DocumentsAddition(ref addition) => {
|
|
Some(addition.nb_documents)
|
|
}
|
|
_ => None,
|
|
},
|
|
_ => None,
|
|
};
|
|
|
|
match method {
|
|
ReplaceDocuments => UpdateType::DocumentsAddition { number },
|
|
UpdateDocuments => UpdateType::DocumentsPartial { number },
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
UpdateMeta::ClearDocuments => UpdateType::ClearAll,
|
|
UpdateMeta::DeleteDocuments { ids } => UpdateType::DocumentsDeletion {
|
|
number: Some(ids.len()),
|
|
},
|
|
UpdateMeta::Settings(settings) => UpdateType::Settings {
|
|
settings: settings.clone(),
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct ProcessedUpdateResult {
|
|
pub update_id: u64,
|
|
#[serde(rename = "type")]
|
|
pub update_type: UpdateType,
|
|
pub duration: f64, // in seconds
|
|
pub enqueued_at: DateTime<Utc>,
|
|
pub processed_at: DateTime<Utc>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct FailedUpdateResult {
|
|
pub update_id: u64,
|
|
#[serde(rename = "type")]
|
|
pub update_type: UpdateType,
|
|
#[serde(flatten)]
|
|
pub response: ResponseError,
|
|
pub duration: f64, // in seconds
|
|
pub enqueued_at: DateTime<Utc>,
|
|
pub processed_at: DateTime<Utc>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
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>>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
#[serde(rename_all = "camelCase", tag = "status")]
|
|
pub enum UpdateStatusResponse {
|
|
Enqueued {
|
|
#[serde(flatten)]
|
|
content: EnqueuedUpdateResult,
|
|
},
|
|
Processing {
|
|
#[serde(flatten)]
|
|
content: EnqueuedUpdateResult,
|
|
},
|
|
Failed {
|
|
#[serde(flatten)]
|
|
content: FailedUpdateResult,
|
|
},
|
|
Processed {
|
|
#[serde(flatten)]
|
|
content: ProcessedUpdateResult,
|
|
},
|
|
}
|
|
|
|
impl From<UpdateStatus> for UpdateStatusResponse {
|
|
fn from(other: UpdateStatus) -> Self {
|
|
let update_type = UpdateType::from(&other);
|
|
|
|
match other {
|
|
UpdateStatus::Processing(processing) => {
|
|
let content = EnqueuedUpdateResult {
|
|
update_id: processing.id(),
|
|
update_type,
|
|
enqueued_at: processing.from.enqueued_at,
|
|
started_processing_at: Some(processing.started_processing_at),
|
|
};
|
|
UpdateStatusResponse::Processing { content }
|
|
}
|
|
UpdateStatus::Enqueued(enqueued) => {
|
|
let content = EnqueuedUpdateResult {
|
|
update_id: enqueued.id(),
|
|
update_type,
|
|
enqueued_at: enqueued.enqueued_at,
|
|
started_processing_at: None,
|
|
};
|
|
UpdateStatusResponse::Enqueued { content }
|
|
}
|
|
UpdateStatus::Processed(processed) => {
|
|
let duration = processed
|
|
.processed_at
|
|
.signed_duration_since(processed.from.started_processing_at)
|
|
.num_milliseconds();
|
|
|
|
// necessary since chrono::duration don't expose a f64 secs method.
|
|
let duration = Duration::from_millis(duration as u64).as_secs_f64();
|
|
|
|
let content = ProcessedUpdateResult {
|
|
update_id: processed.id(),
|
|
update_type,
|
|
duration,
|
|
enqueued_at: processed.from.from.enqueued_at,
|
|
processed_at: processed.processed_at,
|
|
};
|
|
UpdateStatusResponse::Processed { content }
|
|
}
|
|
UpdateStatus::Aborted(_) => unreachable!(),
|
|
UpdateStatus::Failed(failed) => {
|
|
let duration = failed
|
|
.failed_at
|
|
.signed_duration_since(failed.from.started_processing_at)
|
|
.num_milliseconds();
|
|
|
|
// necessary since chrono::duration don't expose a f64 secs method.
|
|
let duration = Duration::from_millis(duration as u64).as_secs_f64();
|
|
|
|
let update_id = failed.id();
|
|
let response = failed.error;
|
|
|
|
let content = FailedUpdateResult {
|
|
update_id,
|
|
update_type,
|
|
response,
|
|
duration,
|
|
enqueued_at: failed.from.from.enqueued_at,
|
|
processed_at: failed.failed_at,
|
|
};
|
|
UpdateStatusResponse::Failed { content }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Deserialize)]
|
|
pub struct IndexParam {
|
|
index_uid: String,
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct IndexUpdateResponse {
|
|
pub update_id: u64,
|
|
}
|
|
|
|
impl IndexUpdateResponse {
|
|
pub fn with_id(update_id: u64) -> Self {
|
|
Self { update_id }
|
|
}
|
|
}
|
|
|
|
/// Always return a 200 with:
|
|
/// ```json
|
|
/// {
|
|
/// "status": "Meilisearch is running"
|
|
/// }
|
|
/// ```
|
|
pub async fn running() -> HttpResponse {
|
|
HttpResponse::Ok().json(serde_json::json!({ "status": "MeiliSearch is running" }))
|
|
}
|
|
|
|
async fn get_stats(data: GuardedData<Private, Data>) -> Result<HttpResponse, ResponseError> {
|
|
let response = data.get_all_stats().await?;
|
|
|
|
debug!("returns: {:?}", response);
|
|
Ok(HttpResponse::Ok().json(response))
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
struct VersionResponse {
|
|
commit_sha: String,
|
|
commit_date: String,
|
|
pkg_version: String,
|
|
}
|
|
|
|
async fn get_version(_data: GuardedData<Private, Data>) -> HttpResponse {
|
|
let commit_sha = match option_env!("COMMIT_SHA") {
|
|
Some("") | None => env!("VERGEN_GIT_SHA"),
|
|
Some(commit_sha) => commit_sha,
|
|
};
|
|
let commit_date = match option_env!("COMMIT_DATE") {
|
|
Some("") | None => env!("VERGEN_GIT_COMMIT_TIMESTAMP"),
|
|
Some(commit_date) => commit_date,
|
|
};
|
|
|
|
HttpResponse::Ok().json(VersionResponse {
|
|
commit_sha: commit_sha.to_string(),
|
|
commit_date: commit_date.to_string(),
|
|
pkg_version: env!("CARGO_PKG_VERSION").to_string(),
|
|
})
|
|
}
|
|
|
|
#[derive(Serialize)]
|
|
struct KeysResponse {
|
|
private: Option<String>,
|
|
public: Option<String>,
|
|
}
|
|
|
|
pub async fn list_keys(data: GuardedData<Admin, Data>) -> HttpResponse {
|
|
let api_keys = data.api_keys.clone();
|
|
HttpResponse::Ok().json(&KeysResponse {
|
|
private: api_keys.private,
|
|
public: api_keys.public,
|
|
})
|
|
}
|
|
|
|
pub async fn get_health() -> Result<HttpResponse, ResponseError> {
|
|
Ok(HttpResponse::Ok().json(serde_json::json!({ "status": "available" })))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
use crate::data::Data;
|
|
use crate::extractors::authentication::GuardedData;
|
|
|
|
/// A type implemented for a route that uses a authentication policy `Policy`.
|
|
///
|
|
/// This trait is used for regression testing of route authenticaton policies.
|
|
trait Is<Policy, T> {}
|
|
|
|
macro_rules! impl_is_policy {
|
|
($($param:ident)*) => {
|
|
impl<Policy, Func, $($param,)* Res> Is<Policy, (($($param,)*), Res)> for Func
|
|
where Func: Fn(GuardedData<Policy, Data>, $($param,)*) -> Res {}
|
|
|
|
};
|
|
}
|
|
|
|
impl_is_policy! {}
|
|
impl_is_policy! {A}
|
|
impl_is_policy! {A B}
|
|
impl_is_policy! {A B C}
|
|
impl_is_policy! {A B C D}
|
|
|
|
/// Emits a compile error if a route doesn't have the correct authentication policy.
|
|
///
|
|
/// This works by trying to cast the route function into a Is<Policy, _> type, where Policy it
|
|
/// the authentication policy defined for the route.
|
|
macro_rules! test_auth_routes {
|
|
($($policy:ident => { $($route:expr,)*})*) => {
|
|
#[test]
|
|
fn test_auth() {
|
|
$($(let _: &dyn Is<$policy, _> = &$route;)*)*
|
|
}
|
|
};
|
|
}
|
|
|
|
test_auth_routes! {
|
|
Public => {
|
|
indexes::search::search_with_url_query,
|
|
indexes::search::search_with_post,
|
|
|
|
indexes::documents::get_document,
|
|
indexes::documents::get_all_documents,
|
|
}
|
|
Private => {
|
|
get_stats,
|
|
get_version,
|
|
|
|
indexes::create_index,
|
|
indexes::list_indexes,
|
|
indexes::get_index_stats,
|
|
indexes::delete_index,
|
|
indexes::update_index,
|
|
indexes::get_index,
|
|
|
|
dump::create_dump,
|
|
|
|
indexes::settings::filterable_attributes::get,
|
|
indexes::settings::displayed_attributes::get,
|
|
indexes::settings::searchable_attributes::get,
|
|
indexes::settings::stop_words::get,
|
|
indexes::settings::synonyms::get,
|
|
indexes::settings::distinct_attribute::get,
|
|
indexes::settings::filterable_attributes::update,
|
|
indexes::settings::displayed_attributes::update,
|
|
indexes::settings::searchable_attributes::update,
|
|
indexes::settings::stop_words::update,
|
|
indexes::settings::synonyms::update,
|
|
indexes::settings::distinct_attribute::update,
|
|
indexes::settings::filterable_attributes::delete,
|
|
indexes::settings::displayed_attributes::delete,
|
|
indexes::settings::searchable_attributes::delete,
|
|
indexes::settings::stop_words::delete,
|
|
indexes::settings::synonyms::delete,
|
|
indexes::settings::distinct_attribute::delete,
|
|
indexes::settings::delete_all,
|
|
indexes::settings::get_all,
|
|
indexes::settings::update_all,
|
|
|
|
indexes::documents::clear_all_documents,
|
|
indexes::documents::delete_documents,
|
|
indexes::documents::update_documents,
|
|
indexes::documents::add_documents,
|
|
indexes::documents::delete_document,
|
|
|
|
indexes::updates::get_all_updates_status,
|
|
indexes::updates::get_update_status,
|
|
}
|
|
Admin => { list_keys, }
|
|
}
|
|
}
|