MeiliSearch/meilisearch-http/src/routes/index.rs

365 lines
10 KiB
Rust
Raw Normal View History

use actix_web::{web, HttpResponse};
use actix_web_macros::{delete, get, post, put};
use chrono::{DateTime, Utc};
2019-11-20 17:28:46 +01:00
use log::error;
use rand::seq::SliceRandom;
use serde::{Deserialize, Serialize};
2019-10-31 15:00:36 +01:00
use crate::error::ResponseError;
use crate::helpers::Authentication;
use crate::routes::IndexParam;
2020-04-10 19:05:05 +02:00
use crate::Data;
2019-10-31 15:00:36 +01:00
pub fn services(cfg: &mut web::ServiceConfig) {
cfg.service(list_indexes)
.service(get_index)
.service(create_index)
.service(update_index)
.service(delete_index)
.service(get_update_status)
.service(get_all_updates_status);
}
fn generate_uid() -> String {
let mut rng = rand::thread_rng();
let sample = b"abcdefghijklmnopqrstuvwxyz0123456789";
sample
.choose_multiple(&mut rng, 8)
.map(|c| *c as char)
.collect()
}
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct IndexResponse {
name: String,
uid: String,
created_at: DateTime<Utc>,
updated_at: DateTime<Utc>,
primary_key: Option<String>,
}
2019-11-20 11:24:08 +01:00
#[get("/indexes", wrap = "Authentication::Private")]
async fn list_indexes(data: web::Data<Data>) -> Result<HttpResponse, ResponseError> {
let reader = data.db.main_read_txn()?;
2020-04-16 11:09:47 +02:00
let mut response = Vec::new();
for index_uid in data.db.indexes_uids() {
let index = data.db.open_index(&index_uid);
2019-11-20 17:28:46 +01:00
match index {
Some(index) => {
let name = index.main.name(&reader)?.ok_or(ResponseError::internal(
"Impossible to get the name of an index",
))?;
2020-04-10 19:05:05 +02:00
let created_at = index
.main
.created_at(&reader)?
.ok_or(ResponseError::internal(
"Impossible to get the create date of an index",
2020-04-10 19:05:05 +02:00
))?;
let updated_at = index
.main
.updated_at(&reader)?
.ok_or(ResponseError::internal(
"Impossible to get the last update date of an index",
2020-04-10 19:05:05 +02:00
))?;
2019-11-20 17:28:46 +01:00
let primary_key = match index.main.schema(&reader) {
Ok(Some(schema)) => match schema.primary_key() {
Some(primary_key) => Some(primary_key.to_owned()),
2020-03-10 11:29:56 +01:00
None => None,
},
2020-02-26 18:49:17 +01:00
_ => None,
};
let index_response = IndexResponse {
2019-11-20 17:28:46 +01:00
name,
uid: index_uid,
created_at,
updated_at,
primary_key,
2019-11-20 17:28:46 +01:00
};
2020-04-16 11:09:47 +02:00
response.push(index_response);
2019-11-20 17:28:46 +01:00
}
None => error!(
"Index {} is referenced in the indexes list but cannot be found",
index_uid
),
}
}
2020-04-16 11:09:47 +02:00
Ok(HttpResponse::Ok().json(response))
2019-11-19 17:38:02 +01:00
}
#[get("/indexes/{index_uid}", wrap = "Authentication::Private")]
async fn get_index(
data: web::Data<Data>,
path: web::Path<IndexParam>,
) -> Result<HttpResponse, ResponseError> {
2020-04-10 19:05:05 +02:00
let index = data
.db
.open_index(&path.index_uid)
.ok_or(ResponseError::index_not_found(&path.index_uid))?;
2019-11-19 17:38:02 +01:00
let reader = data.db.main_read_txn()?;
2019-11-19 17:38:02 +01:00
let name = index.main.name(&reader)?.ok_or(ResponseError::internal(
"Impossible to get the name of an index",
))?;
2020-04-10 19:05:05 +02:00
let created_at = index
.main
.created_at(&reader)?
.ok_or(ResponseError::internal(
"Impossible to get the create date of an index",
2020-04-10 19:05:05 +02:00
))?;
let updated_at = index
.main
.updated_at(&reader)?
.ok_or(ResponseError::internal(
"Impossible to get the last update date of an index",
2020-04-10 19:05:05 +02:00
))?;
2019-11-19 17:38:02 +01:00
let primary_key = match index.main.schema(&reader) {
Ok(Some(schema)) => match schema.primary_key() {
Some(primary_key) => Some(primary_key.to_owned()),
2020-03-10 11:29:56 +01:00
None => None,
},
2020-02-26 18:49:17 +01:00
_ => None,
};
2020-04-16 11:09:47 +02:00
Ok(HttpResponse::Ok().json(IndexResponse {
2019-11-19 17:38:02 +01:00
name,
uid: path.index_uid.clone(),
2019-11-19 17:38:02 +01:00
created_at,
updated_at,
primary_key,
}))
2019-11-19 17:38:02 +01:00
}
2019-11-20 17:28:46 +01:00
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase", deny_unknown_fields)]
struct IndexCreateRequest {
name: Option<String>,
uid: Option<String>,
primary_key: Option<String>,
}
#[post("/indexes", wrap = "Authentication::Private")]
async fn create_index(
data: web::Data<Data>,
2020-04-10 19:05:05 +02:00
body: web::Json<IndexCreateRequest>,
) -> Result<HttpResponse, ResponseError> {
if let (None, None) = (body.name.clone(), body.uid.clone()) {
return Err(ResponseError::bad_request(
"Index creation must have an uid",
));
}
2020-04-24 15:00:52 +02:00
let uid = match &body.uid {
2020-03-05 11:44:30 +01:00
Some(uid) => {
2020-03-10 11:29:56 +01:00
if uid
.chars()
.all(|x| x.is_ascii_alphanumeric() || x == '-' || x == '_')
{
2020-04-24 15:00:52 +02:00
uid.to_owned()
2020-03-05 11:44:30 +01:00
} else {
return Err(ResponseError::InvalidIndexUid);
2020-03-05 11:44:30 +01:00
}
2020-03-10 11:29:56 +01:00
}
None => loop {
let uid = generate_uid();
if data.db.open_index(&uid).is_none() {
break uid;
}
},
};
2020-04-10 19:05:05 +02:00
let created_index = data
.db
.create_index(&uid)
.map_err(ResponseError::create_index)?;
let mut writer = data.db.main_write_txn()?;
2020-04-24 15:00:52 +02:00
let name = body.name.as_ref().unwrap_or(&uid);
created_index.main.put_name(&mut writer, name)?;
2019-10-31 15:00:36 +01:00
2020-01-23 11:30:18 +01:00
let created_at = created_index
.main
.created_at(&writer)?
.ok_or(ResponseError::internal("Impossible to read created at"))?;
2020-01-23 11:30:18 +01:00
let updated_at = created_index
.main
.updated_at(&writer)?
.ok_or(ResponseError::internal("Impossible to read updated at"))?;
if let Some(id) = body.primary_key.clone() {
if let Some(mut schema) = created_index.main.schema(&writer)? {
2020-04-10 19:05:05 +02:00
schema
.set_primary_key(&id)
.map_err(ResponseError::bad_request)?;
created_index.main.put_schema(&mut writer, &schema)?;
}
2020-01-28 17:45:29 +01:00
}
writer.commit()?;
2019-10-31 15:00:36 +01:00
2020-04-16 11:09:47 +02:00
Ok(HttpResponse::Created().json(IndexResponse {
2020-04-24 15:00:52 +02:00
name: name.to_string(),
uid,
created_at,
updated_at,
primary_key: body.primary_key.clone(),
}))
2019-10-31 15:00:36 +01:00
}
2019-11-20 17:28:46 +01:00
#[derive(Debug, Deserialize)]
2019-11-20 15:00:06 +01:00
#[serde(rename_all = "camelCase", deny_unknown_fields)]
struct UpdateIndexRequest {
name: Option<String>,
primary_key: Option<String>,
2019-11-20 15:00:06 +01:00
}
2019-11-20 17:28:46 +01:00
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
struct UpdateIndexResponse {
2019-11-20 15:00:06 +01:00
name: String,
uid: String,
created_at: DateTime<Utc>,
updated_at: DateTime<Utc>,
primary_key: Option<String>,
2019-11-20 15:00:06 +01:00
}
#[put("/indexes/{index_uid}", wrap = "Authentication::Private")]
async fn update_index(
data: web::Data<Data>,
path: web::Path<IndexParam>,
2020-04-10 19:05:05 +02:00
body: web::Json<IndexCreateRequest>,
) -> Result<HttpResponse, ResponseError> {
2020-04-10 19:05:05 +02:00
let index = data
.db
.open_index(&path.index_uid)
.ok_or(ResponseError::index_not_found(&path.index_uid))?;
2019-11-20 15:00:06 +01:00
let mut writer = data.db.main_write_txn()?;
2020-01-16 16:58:57 +01:00
2020-04-24 15:00:52 +02:00
if let Some(name) = &body.name {
index.main.put_name(&mut writer, name)?;
}
2020-01-16 16:58:57 +01:00
if let Some(id) = body.primary_key.clone() {
if let Some(mut schema) = index.main.schema(&writer)? {
match schema.primary_key() {
Some(_) => {
return Err(ResponseError::bad_request(
"The primary key cannot be updated",
));
2020-03-10 11:29:56 +01:00
}
None => {
schema.set_primary_key(&id)?;
index.main.put_schema(&mut writer, &schema)?;
}
}
}
}
2020-01-16 16:58:57 +01:00
index.main.put_updated_at(&mut writer)?;
writer.commit()?;
2020-01-16 16:58:57 +01:00
let reader = data.db.main_read_txn()?;
let name = index.main.name(&reader)?.ok_or(ResponseError::internal(
"Impossible to get the name of an index",
))?;
2020-04-10 19:05:05 +02:00
let created_at = index
.main
.created_at(&reader)?
.ok_or(ResponseError::internal(
"Impossible to get the create date of an index",
2020-04-10 19:05:05 +02:00
))?;
let updated_at = index
.main
.updated_at(&reader)?
.ok_or(ResponseError::internal(
"Impossible to get the last update date of an index",
2020-04-10 19:05:05 +02:00
))?;
2019-11-20 15:00:06 +01:00
let primary_key = match index.main.schema(&reader) {
2020-03-10 11:29:56 +01:00
Ok(Some(schema)) => match schema.primary_key() {
Some(primary_key) => Some(primary_key.to_owned()),
None => None,
},
2020-02-26 18:49:17 +01:00
_ => None,
};
2020-04-16 11:09:47 +02:00
Ok(HttpResponse::Ok().json(IndexResponse {
name,
uid: path.index_uid.clone(),
2019-11-20 15:00:06 +01:00
created_at,
updated_at,
primary_key,
}))
2019-11-20 15:00:06 +01:00
}
#[delete("/indexes/{index_uid}", wrap = "Authentication::Private")]
async fn delete_index(
data: web::Data<Data>,
path: web::Path<IndexParam>,
) -> Result<HttpResponse, ResponseError> {
data.db.delete_index(&path.index_uid)?;
2019-10-31 15:00:36 +01:00
Ok(HttpResponse::NoContent().finish())
2019-10-31 15:00:36 +01:00
}
2020-04-09 10:39:34 +02:00
2020-04-24 15:00:52 +02:00
#[derive(Deserialize)]
struct UpdateParam {
index_uid: String,
2020-04-10 19:05:05 +02:00
update_id: u64,
}
2020-04-09 10:39:34 +02:00
#[get(
"/indexes/{index_uid}/updates/{update_id}",
wrap = "Authentication::Private"
)]
async fn get_update_status(
2020-04-09 10:39:34 +02:00
data: web::Data<Data>,
path: web::Path<UpdateParam>,
) -> Result<HttpResponse, ResponseError> {
2020-04-10 19:05:05 +02:00
let index = data
.db
.open_index(&path.index_uid)
.ok_or(ResponseError::index_not_found(&path.index_uid))?;
2020-04-09 10:39:34 +02:00
let reader = data.db.update_read_txn()?;
2020-04-09 10:39:34 +02:00
let status = index.update_status(&reader, path.update_id)?;
2020-04-09 10:39:34 +02:00
match status {
2020-04-16 11:09:47 +02:00
Some(status) => Ok(HttpResponse::Ok().json(status)),
None => Err(ResponseError::NotFound(format!(
"Update {} not found",
path.update_id
))),
2020-04-09 10:39:34 +02:00
}
}
#[get("/indexes/{index_uid}/updates", wrap = "Authentication::Private")]
async fn get_all_updates_status(
2020-04-09 10:39:34 +02:00
data: web::Data<Data>,
path: web::Path<IndexParam>,
) -> Result<HttpResponse, ResponseError> {
2020-04-10 19:05:05 +02:00
let index = data
.db
.open_index(&path.index_uid)
.ok_or(ResponseError::index_not_found(&path.index_uid))?;
2020-04-09 10:39:34 +02:00
let reader = data.db.update_read_txn()?;
2020-04-09 10:39:34 +02:00
let response = index.all_updates_status(&reader)?;
2020-04-09 10:39:34 +02:00
2020-04-16 11:09:47 +02:00
Ok(HttpResponse::Ok().json(response))
2020-04-09 10:39:34 +02:00
}