2021-07-26 21:00:05 +02:00
|
|
|
use crate::addressing::{Address, Addressable};
|
|
|
|
use crate::database::entry::{Entry, InEntry};
|
2021-12-17 23:04:35 +01:00
|
|
|
use crate::database::hierarchies::{list_roots, resolve_path, UHierPath};
|
2021-07-26 21:00:05 +02:00
|
|
|
use crate::database::lang::Query;
|
2021-02-19 21:58:35 +01:00
|
|
|
use crate::database::{
|
2021-07-26 21:00:05 +02:00
|
|
|
get_latest_files, insert_entry, query, remove_object, retrieve_file, retrieve_object, DbPool,
|
2021-02-19 21:58:35 +01:00
|
|
|
};
|
2021-07-26 21:14:12 +02:00
|
|
|
use crate::util::hash::{decode, encode};
|
|
|
|
use crate::util::jobs::JobContainer;
|
2020-08-27 01:07:25 +02:00
|
|
|
use actix_files::NamedFile;
|
2020-09-13 20:10:18 +02:00
|
|
|
use actix_web::error::{ErrorBadRequest, ErrorInternalServerError, ErrorNotFound};
|
2021-12-22 11:56:06 +01:00
|
|
|
use actix_web::http::{self};
|
2021-12-19 22:38:41 +01:00
|
|
|
use actix_web::{delete, error, get, post, put, web, Either, Error, HttpResponse};
|
2020-09-13 13:20:35 +02:00
|
|
|
use anyhow::Result;
|
2021-02-19 21:58:35 +01:00
|
|
|
use futures_util::StreamExt;
|
2021-12-21 17:43:29 +01:00
|
|
|
use log::{debug, info, trace};
|
2020-08-27 01:29:44 +02:00
|
|
|
use serde::Deserialize;
|
2021-05-06 20:23:20 +02:00
|
|
|
use serde_json::json;
|
2020-09-13 13:20:35 +02:00
|
|
|
use std::collections::HashMap;
|
2021-02-20 12:39:03 +01:00
|
|
|
use std::convert::TryFrom;
|
2020-09-13 13:20:35 +02:00
|
|
|
use std::path::PathBuf;
|
2021-02-20 17:36:19 +01:00
|
|
|
use std::sync::{Arc, RwLock};
|
2020-09-12 14:27:45 +02:00
|
|
|
|
2021-12-19 22:38:41 +01:00
|
|
|
#[cfg(feature = "desktop")]
|
|
|
|
use is_executable::IsExecutable;
|
|
|
|
|
2021-06-18 18:28:18 +02:00
|
|
|
const VERSION: &str = env!("CARGO_PKG_VERSION");
|
|
|
|
|
2020-08-30 22:11:32 +02:00
|
|
|
#[derive(Clone)]
|
2020-08-27 01:07:25 +02:00
|
|
|
pub struct State {
|
2021-05-06 20:23:20 +02:00
|
|
|
pub vault_name: Option<String>,
|
2020-08-27 01:07:25 +02:00
|
|
|
pub directory: PathBuf,
|
2020-09-15 19:26:47 +02:00
|
|
|
pub db_pool: DbPool,
|
2021-02-20 17:36:19 +01:00
|
|
|
pub job_container: Arc<RwLock<JobContainer>>,
|
2020-08-27 01:07:25 +02:00
|
|
|
}
|
|
|
|
|
2021-12-19 22:38:41 +01:00
|
|
|
#[derive(Deserialize)]
|
|
|
|
pub struct RawRequest {
|
|
|
|
native: Option<String>,
|
|
|
|
}
|
|
|
|
|
2020-09-25 02:45:17 +02:00
|
|
|
#[get("/api/raw/{hash}")]
|
2021-12-19 22:38:41 +01:00
|
|
|
pub async fn get_raw(
|
|
|
|
state: web::Data<State>,
|
|
|
|
web::Query(query): web::Query<RawRequest>,
|
|
|
|
hash: web::Path<String>,
|
|
|
|
) -> Result<Either<NamedFile, HttpResponse>, Error> {
|
2020-09-13 14:28:58 +02:00
|
|
|
let address = Address::decode(&decode(hash.into_inner()).map_err(ErrorInternalServerError)?)
|
|
|
|
.map_err(ErrorInternalServerError)?;
|
|
|
|
if let Address::Hash(hash) = address {
|
2020-09-15 19:26:47 +02:00
|
|
|
let connection = state.db_pool.get().map_err(ErrorInternalServerError)?;
|
2021-12-19 22:38:41 +01:00
|
|
|
let files = retrieve_file(&connection, hash).map_err(ErrorInternalServerError)?;
|
|
|
|
if let Some(file) = files.get(0) {
|
|
|
|
let file_path = state.directory.join(&file.path);
|
2020-09-12 14:27:45 +02:00
|
|
|
|
2021-12-19 22:38:41 +01:00
|
|
|
if !query.native.is_some() {
|
|
|
|
Ok(Either::A(NamedFile::open(file_path)?))
|
|
|
|
} else {
|
|
|
|
if cfg!(feature = "desktop") {
|
|
|
|
#[cfg(feature = "desktop")]
|
|
|
|
{
|
|
|
|
info!("Opening {:?}...", file_path);
|
2021-12-22 11:56:06 +01:00
|
|
|
let mut response = HttpResponse::NoContent();
|
2021-12-21 17:43:29 +01:00
|
|
|
let path = if !file_path.is_executable() {
|
|
|
|
file_path
|
2021-12-21 16:05:27 +01:00
|
|
|
} else {
|
2021-12-22 11:56:06 +01:00
|
|
|
response
|
|
|
|
.header(
|
|
|
|
http::header::WARNING,
|
|
|
|
"199 - Opening parent directory due to file being executable.",
|
|
|
|
)
|
|
|
|
.header(
|
|
|
|
http::header::ACCESS_CONTROL_EXPOSE_HEADERS,
|
|
|
|
http::header::WARNING.to_string(),
|
|
|
|
);
|
|
|
|
|
2021-12-21 17:43:29 +01:00
|
|
|
file_path
|
|
|
|
.parent()
|
|
|
|
.ok_or_else(|| {
|
|
|
|
ErrorInternalServerError("No parent to open as fallback.")
|
|
|
|
})?
|
|
|
|
.to_path_buf()
|
|
|
|
};
|
|
|
|
opener::open(path).map_err(error::ErrorServiceUnavailable)?;
|
2021-12-22 11:56:06 +01:00
|
|
|
return Ok(Either::B(response.finish()));
|
2021-12-19 22:38:41 +01:00
|
|
|
}
|
2021-12-21 17:43:29 +01:00
|
|
|
|
|
|
|
#[cfg(not(feature = "desktop"))]
|
|
|
|
!unreachable()
|
2021-12-19 22:38:41 +01:00
|
|
|
} else {
|
|
|
|
Err(error::ErrorBadRequest("Desktop features not enabled."))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
Err(error::ErrorNotFound("NOT FOUND"))
|
2020-09-13 14:28:58 +02:00
|
|
|
}
|
|
|
|
} else {
|
2021-12-22 11:56:06 +01:00
|
|
|
Err(ErrorBadRequest(
|
|
|
|
"Address does not refer to a rawable object.",
|
|
|
|
))
|
2020-08-27 01:07:25 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-20 12:12:48 +01:00
|
|
|
#[derive(Deserialize)]
|
|
|
|
pub struct QueryRequest {
|
|
|
|
query: String,
|
|
|
|
}
|
|
|
|
|
|
|
|
#[get("/api/obj")]
|
|
|
|
pub async fn get_query(
|
|
|
|
state: web::Data<State>,
|
|
|
|
web::Query(info): web::Query<QueryRequest>,
|
|
|
|
) -> Result<HttpResponse, Error> {
|
|
|
|
let connection = state.db_pool.get().map_err(ErrorInternalServerError)?;
|
|
|
|
|
2021-12-21 12:01:40 +01:00
|
|
|
let in_query: Query = info.query.as_str().parse().map_err(ErrorBadRequest)?;
|
2021-02-21 12:30:17 +01:00
|
|
|
let entries = query(&connection, in_query).map_err(ErrorInternalServerError)?;
|
|
|
|
let mut result: HashMap<String, Entry> = HashMap::new();
|
|
|
|
for entry in entries {
|
|
|
|
result.insert(
|
2021-02-21 17:08:33 +01:00
|
|
|
encode(
|
|
|
|
entry
|
|
|
|
.address()
|
|
|
|
.map_err(ErrorInternalServerError)?
|
|
|
|
.encode()
|
|
|
|
.map_err(ErrorInternalServerError)?,
|
|
|
|
),
|
2021-02-21 12:30:17 +01:00
|
|
|
entry,
|
|
|
|
);
|
|
|
|
}
|
2021-02-20 12:12:48 +01:00
|
|
|
|
2021-02-21 12:30:17 +01:00
|
|
|
Ok(HttpResponse::Ok().json(&result))
|
2021-02-20 12:12:48 +01:00
|
|
|
}
|
|
|
|
|
2021-12-17 23:04:35 +01:00
|
|
|
trait EntriesAsHash {
|
|
|
|
fn as_hash(&self) -> Result<HashMap<String, &Entry>>;
|
|
|
|
}
|
|
|
|
|
|
|
|
impl EntriesAsHash for Vec<Entry> {
|
|
|
|
fn as_hash(&self) -> Result<HashMap<String, &Entry>> {
|
|
|
|
let mut result: HashMap<String, &Entry> = HashMap::new();
|
|
|
|
for entry in self {
|
|
|
|
result.insert(encode(entry.address()?.encode()?), entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(result)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-29 00:55:09 +02:00
|
|
|
#[get("/api/obj/{address_str}")]
|
2020-09-13 13:20:35 +02:00
|
|
|
pub async fn get_object(
|
|
|
|
state: web::Data<State>,
|
|
|
|
address_str: web::Path<String>,
|
|
|
|
) -> Result<HttpResponse, Error> {
|
2020-09-15 19:26:47 +02:00
|
|
|
let connection = state.db_pool.get().map_err(ErrorInternalServerError)?;
|
2021-12-17 23:04:35 +01:00
|
|
|
let result: Vec<Entry> = retrieve_object(
|
2020-09-15 19:26:47 +02:00
|
|
|
&connection,
|
2020-09-25 02:45:17 +02:00
|
|
|
Address::decode(&decode(address_str.into_inner()).map_err(ErrorBadRequest)?)
|
2021-02-21 17:08:33 +01:00
|
|
|
.map_err(ErrorBadRequest)?,
|
2021-12-17 23:04:35 +01:00
|
|
|
)
|
|
|
|
.map_err(ErrorInternalServerError)?;
|
2020-09-13 13:20:35 +02:00
|
|
|
|
2021-12-17 23:04:35 +01:00
|
|
|
debug!("{:?}", result);
|
|
|
|
Ok(HttpResponse::Ok().json(result.as_hash().map_err(ErrorInternalServerError)?))
|
2020-09-13 13:20:35 +02:00
|
|
|
}
|
|
|
|
|
2021-02-19 21:58:35 +01:00
|
|
|
const MAX_SIZE: usize = 1_000_000;
|
|
|
|
|
|
|
|
#[put("/api/obj")]
|
|
|
|
pub async fn put_object(
|
|
|
|
state: web::Data<State>,
|
|
|
|
mut payload: web::Payload,
|
|
|
|
) -> Result<HttpResponse, Error> {
|
|
|
|
let connection = state.db_pool.get().map_err(ErrorInternalServerError)?;
|
|
|
|
|
|
|
|
let mut body = web::BytesMut::new();
|
|
|
|
while let Some(chunk) = payload.next().await {
|
|
|
|
let chunk = chunk?;
|
|
|
|
// limit max size of in-memory payload
|
|
|
|
if (body.len() + chunk.len()) > MAX_SIZE {
|
|
|
|
return Err(error::ErrorBadRequest("overflow."));
|
|
|
|
}
|
|
|
|
body.extend_from_slice(&chunk);
|
|
|
|
}
|
|
|
|
|
2021-06-20 14:07:15 +02:00
|
|
|
let in_entry = serde_json::from_slice::<InEntry>(&body).map_err(ErrorBadRequest)?;
|
|
|
|
let entry = Entry::try_from(in_entry).map_err(ErrorInternalServerError)?;
|
2021-02-19 21:58:35 +01:00
|
|
|
|
2021-06-20 14:07:15 +02:00
|
|
|
let result_address =
|
|
|
|
insert_entry(&connection, entry.clone()).map_err(ErrorInternalServerError)?;
|
2021-02-19 21:58:35 +01:00
|
|
|
|
2021-06-20 14:07:15 +02:00
|
|
|
Ok(HttpResponse::Ok().json(
|
|
|
|
[(
|
|
|
|
encode(result_address.encode().map_err(ErrorInternalServerError)?),
|
|
|
|
entry,
|
|
|
|
)]
|
|
|
|
.iter()
|
|
|
|
.cloned()
|
|
|
|
.collect::<HashMap<String, Entry>>(),
|
|
|
|
))
|
2021-02-19 21:58:35 +01:00
|
|
|
}
|
|
|
|
|
2020-09-29 00:55:09 +02:00
|
|
|
#[delete("/api/obj/{address_str}")]
|
|
|
|
pub async fn delete_object(
|
|
|
|
state: web::Data<State>,
|
|
|
|
address_str: web::Path<String>,
|
|
|
|
) -> Result<HttpResponse, Error> {
|
|
|
|
let connection = state.db_pool.get().map_err(ErrorInternalServerError)?;
|
|
|
|
let _ = remove_object(
|
|
|
|
&connection,
|
|
|
|
Address::decode(&decode(address_str.into_inner()).map_err(ErrorBadRequest)?)
|
|
|
|
.map_err(ErrorInternalServerError)?,
|
|
|
|
)
|
|
|
|
.map_err(ErrorInternalServerError)?;
|
|
|
|
|
|
|
|
Ok(HttpResponse::Ok().finish())
|
|
|
|
}
|
|
|
|
|
2020-09-25 02:45:17 +02:00
|
|
|
#[get("/api/hier/{path:.*}")]
|
2020-09-13 20:10:18 +02:00
|
|
|
pub async fn list_hier(
|
|
|
|
state: web::Data<State>,
|
|
|
|
path: web::Path<String>,
|
|
|
|
) -> Result<HttpResponse, Error> {
|
2020-09-15 19:26:47 +02:00
|
|
|
let connection = state.db_pool.get().map_err(ErrorInternalServerError)?;
|
2021-12-17 23:42:58 +01:00
|
|
|
if path.is_empty() {
|
|
|
|
Ok(HttpResponse::MovedPermanently()
|
|
|
|
.header("Location", "/api/hier_roots")
|
|
|
|
.finish())
|
2021-12-17 23:04:35 +01:00
|
|
|
} else {
|
2021-12-17 23:42:58 +01:00
|
|
|
let upath: UHierPath = path.into_inner().parse().map_err(ErrorBadRequest)?;
|
|
|
|
trace!("Listing path \"{}\"", upath);
|
|
|
|
|
2021-12-17 23:04:35 +01:00
|
|
|
// todo: 500 if actual error occurs
|
|
|
|
let path = resolve_path(&connection, &upath, false).map_err(ErrorNotFound)?;
|
2021-12-17 23:42:58 +01:00
|
|
|
match path.last() {
|
|
|
|
Some(addr) => Ok(HttpResponse::Found()
|
|
|
|
.header("Location", format!("/api/obj/{}", addr))
|
|
|
|
.finish()),
|
|
|
|
None => Ok(HttpResponse::NotFound().finish()),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[get("/api/hier_roots")]
|
|
|
|
pub async fn list_hier_roots(state: web::Data<State>) -> Result<HttpResponse, Error> {
|
|
|
|
let connection = state.db_pool.get().map_err(ErrorInternalServerError)?;
|
|
|
|
|
|
|
|
let result = list_roots(&connection)
|
|
|
|
.map_err(ErrorInternalServerError)?
|
|
|
|
.into_iter()
|
|
|
|
.map(|root| retrieve_object(&connection, root))
|
|
|
|
.collect::<Result<Vec<Vec<Entry>>>>()
|
|
|
|
.map_err(ErrorInternalServerError)?
|
|
|
|
.concat();
|
|
|
|
|
|
|
|
Ok(HttpResponse::Ok().json(result.as_hash().map_err(ErrorInternalServerError)?))
|
2020-09-13 20:10:18 +02:00
|
|
|
}
|
|
|
|
|
2020-08-27 01:07:25 +02:00
|
|
|
#[post("/api/refresh")]
|
|
|
|
pub async fn api_refresh(state: web::Data<State>) -> Result<HttpResponse, Error> {
|
2020-09-20 19:28:44 +02:00
|
|
|
let _pool = state.db_pool.clone();
|
|
|
|
let _directory = state.directory.clone();
|
2021-03-06 22:14:17 +01:00
|
|
|
actix::spawn(crate::filesystem::rescan_vault(
|
2021-02-20 17:36:19 +01:00
|
|
|
_pool,
|
|
|
|
_directory,
|
|
|
|
state.job_container.clone(),
|
|
|
|
));
|
2020-08-27 01:07:25 +02:00
|
|
|
Ok(HttpResponse::Ok().finish())
|
|
|
|
}
|
2021-02-20 17:36:19 +01:00
|
|
|
|
2021-04-23 23:28:58 +02:00
|
|
|
#[get("/api/files/{hash}")]
|
|
|
|
pub async fn get_file(
|
|
|
|
state: web::Data<State>,
|
|
|
|
hash: web::Path<String>,
|
|
|
|
) -> Result<HttpResponse, Error> {
|
|
|
|
let address = Address::decode(&decode(hash.into_inner()).map_err(ErrorInternalServerError)?)
|
|
|
|
.map_err(ErrorInternalServerError)?;
|
|
|
|
|
|
|
|
if let Address::Hash(hash) = address {
|
|
|
|
let connection = state.db_pool.get().map_err(ErrorInternalServerError)?;
|
|
|
|
let response = retrieve_file(&connection, hash).map_err(ErrorInternalServerError)?;
|
|
|
|
|
|
|
|
Ok(HttpResponse::Ok().json(response))
|
|
|
|
} else {
|
|
|
|
Err(ErrorBadRequest("Address does not refer to a file."))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-21 19:51:23 +01:00
|
|
|
#[get("/api/files/latest")]
|
|
|
|
pub async fn latest_files(state: web::Data<State>) -> Result<HttpResponse, Error> {
|
|
|
|
let connection = state.db_pool.get().map_err(ErrorInternalServerError)?;
|
|
|
|
let files = get_latest_files(&connection, 100).map_err(ErrorInternalServerError)?;
|
|
|
|
Ok(HttpResponse::Ok().json(&files))
|
|
|
|
}
|
|
|
|
|
2021-02-20 17:36:19 +01:00
|
|
|
#[get("/api/jobs")]
|
|
|
|
pub async fn get_jobs(state: web::Data<State>) -> Result<HttpResponse, Error> {
|
|
|
|
let jobs = state.job_container.read().unwrap().get_jobs();
|
|
|
|
Ok(HttpResponse::Ok().json(&jobs))
|
|
|
|
}
|
2021-05-06 20:23:20 +02:00
|
|
|
|
|
|
|
#[get("/api/info")]
|
|
|
|
pub async fn get_info(state: web::Data<State>) -> Result<HttpResponse, Error> {
|
|
|
|
Ok(HttpResponse::Ok().json(json!({
|
|
|
|
"name": state.vault_name,
|
2021-06-18 18:28:18 +02:00
|
|
|
"location": state.directory,
|
|
|
|
"version": VERSION
|
2021-05-06 20:23:20 +02:00
|
|
|
})))
|
|
|
|
}
|