You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
102 lines
3.1 KiB
Rust
102 lines
3.1 KiB
Rust
use std::path::PathBuf;
|
|
|
|
use tokio::fs;
|
|
|
|
use crate::TypeMap;
|
|
use mediarepo_core::bromine::prelude::*;
|
|
use mediarepo_core::mediarepo_api::types::repo::{
|
|
FrontendState, RepositoryMetadata, SizeMetadata, SizeType,
|
|
};
|
|
use mediarepo_core::type_keys::{RepoPathKey, SettingsKey, SizeMetadataKey};
|
|
|
|
use crate::utils::get_repo_from_context;
|
|
|
|
pub struct RepoNamespace;
|
|
|
|
impl NamespaceProvider for RepoNamespace {
|
|
fn name() -> &'static str {
|
|
"repo"
|
|
}
|
|
|
|
fn register(handler: &mut EventHandler) {
|
|
events!(handler,
|
|
"repository_metadata" => Self::get_metadata,
|
|
"size_metadata" => Self::get_size_metadata,
|
|
"frontend_state" => Self::frontend_state,
|
|
"set_frontend_state" => Self::set_frontend_state
|
|
);
|
|
}
|
|
}
|
|
|
|
impl RepoNamespace {
|
|
#[tracing::instrument(skip_all)]
|
|
async fn get_metadata(ctx: &Context, _: Event) -> IPCResult<Response> {
|
|
let repo = get_repo_from_context(ctx).await;
|
|
let counts = repo.get_counts().await?;
|
|
|
|
let metadata = RepositoryMetadata {
|
|
version: env!("CARGO_PKG_VERSION").to_string(),
|
|
file_count: counts.file_count as u64,
|
|
tag_count: counts.tag_count as u64,
|
|
namespace_count: counts.namespace_count as u64,
|
|
mapping_count: counts.mapping_count as u64,
|
|
hash_count: counts.cd_count as u64,
|
|
};
|
|
|
|
tracing::debug!("metadata = {:?}", metadata);
|
|
|
|
ctx.response(metadata)
|
|
}
|
|
|
|
#[tracing::instrument(skip_all)]
|
|
async fn get_size_metadata(ctx: &Context, event: Event) -> IPCResult<Response> {
|
|
let size_type = event.payload::<SizeType>()?;
|
|
let data = ctx.data.read().await;
|
|
let size_cache = data.get::<SizeMetadataKey>().unwrap();
|
|
|
|
let size = if let Some(size) = size_cache.get(&size_type) {
|
|
*size
|
|
} else {
|
|
0
|
|
};
|
|
|
|
ctx.response(SizeMetadata { size, size_type })
|
|
}
|
|
|
|
#[tracing::instrument(skip_all)]
|
|
async fn frontend_state(ctx: &Context, _: Event) -> IPCResult<Response> {
|
|
let path = get_frontend_state_path(ctx).await?;
|
|
let state_string = if path.exists() {
|
|
Some(fs::read_to_string(path).await?)
|
|
} else {
|
|
None
|
|
};
|
|
|
|
ctx.response(FrontendState {
|
|
state: state_string,
|
|
})
|
|
}
|
|
|
|
#[tracing::instrument(skip_all)]
|
|
async fn set_frontend_state(ctx: &Context, event: Event) -> IPCResult<Response> {
|
|
let path = get_frontend_state_path(ctx).await?;
|
|
let state = event.payload::<FrontendState>()?.state;
|
|
if let Some(state_string) = state {
|
|
fs::write(path, state_string.into_bytes()).await?;
|
|
} else {
|
|
fs::remove_file(path).await?;
|
|
}
|
|
|
|
Ok(Response::empty())
|
|
}
|
|
}
|
|
|
|
async fn get_frontend_state_path(ctx: &Context) -> IPCResult<PathBuf> {
|
|
let data = ctx.data.read().await;
|
|
let settings = data.get::<SettingsKey>().unwrap();
|
|
let repo_path = data.get::<RepoPathKey>().unwrap();
|
|
let state_path = settings.paths.frontend_state_file_path(repo_path);
|
|
|
|
Ok(state_path)
|
|
}
|