266 lines
8.0 KiB
Rust
266 lines
8.0 KiB
Rust
use actix_web::{web, HttpResponse};
|
|
use chrono::{DateTime, Utc};
|
|
use log::debug;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use meilisearch_error::ResponseError;
|
|
use meilisearch_lib::index::{Settings, Unchecked};
|
|
use meilisearch_lib::MeiliSearch;
|
|
|
|
use crate::extractors::authentication::{policies::*, GuardedData};
|
|
use crate::ApiKeys;
|
|
|
|
mod dump;
|
|
pub mod indexes;
|
|
mod tasks;
|
|
|
|
pub fn configure(cfg: &mut web::ServiceConfig) {
|
|
cfg.service(web::scope("/tasks").configure(tasks::configure))
|
|
.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>,
|
|
},
|
|
}
|
|
|
|
#[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,
|
|
pub error: 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,
|
|
},
|
|
}
|
|
|
|
#[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(
|
|
meilisearch: GuardedData<Private, MeiliSearch>,
|
|
) -> Result<HttpResponse, ResponseError> {
|
|
let response = meilisearch.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(_meilisearch: GuardedData<Private, MeiliSearch>) -> HttpResponse {
|
|
let commit_sha = option_env!("VERGEN_GIT_SHA").unwrap_or("unknown");
|
|
let commit_date = option_env!("VERGEN_GIT_COMMIT_TIMESTAMP").unwrap_or("unknown");
|
|
|
|
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(meilisearch: GuardedData<Admin, ApiKeys>) -> HttpResponse {
|
|
let api_keys = (*meilisearch).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::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, Data, T> {}
|
|
|
|
macro_rules! impl_is_policy {
|
|
($($param:ident)*) => {
|
|
impl<Policy, Func, Data, $($param,)* Res> Is<Policy, Data, (($($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}
|
|
impl_is_policy! {A B C D E}
|
|
|
|
/// 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::tasks::get_all_tasks_status,
|
|
indexes::tasks::get_task_status,
|
|
}
|
|
Admin => { list_keys, }
|
|
}
|
|
}
|