From 3a29113e965a94bdef06655f1583cc6e86edd606 Mon Sep 17 00:00:00 2001 From: metamuffin Date: Thu, 21 Dec 2023 23:57:42 +0100 Subject: rework import system pt. 1 --- server/src/federation.rs | 61 --------- server/src/import.rs | 254 -------------------------------------- server/src/main.rs | 5 +- server/src/routes/mod.rs | 4 +- server/src/routes/stream.rs | 65 +++++----- server/src/routes/ui/admin/mod.rs | 5 +- server/src/routes/ui/node.rs | 22 ++-- server/src/routes/ui/player.rs | 2 +- server/src/routes/ui/sort.rs | 16 +-- 9 files changed, 59 insertions(+), 375 deletions(-) delete mode 100644 server/src/federation.rs delete mode 100644 server/src/import.rs (limited to 'server/src') diff --git a/server/src/federation.rs b/server/src/federation.rs deleted file mode 100644 index eb2a1ac..0000000 --- a/server/src/federation.rs +++ /dev/null @@ -1,61 +0,0 @@ -/* - This file is part of jellything (https://codeberg.org/metamuffin/jellything) - which is licensed under the GNU Affero General Public License (version 3); see /COPYING. - Copyright (C) 2023 metamuffin -*/ -use anyhow::anyhow; -use jellybase::CONF; -use jellyclient::{Instance, LoginDetails, Session}; -use std::{collections::HashMap, sync::Arc}; -use tokio::sync::RwLock; - -pub struct Federation { - instances: HashMap, - sessions: RwLock>>, -} - -impl Federation { - pub fn initialize() -> Self { - let instances = CONF - .remote_credentials - .iter() - .map(|(k, (_, _, tls))| (k.to_owned(), Instance::new(k.to_owned(), *tls))) - .collect::>(); - - Self { - instances, - sessions: Default::default(), - } - } - - pub fn get_instance(&self, host: &String) -> anyhow::Result<&Instance> { - Ok(self - .instances - .get(host) - .ok_or(anyhow!("unknown instance"))?) - } - pub async fn get_session(&self, host: &String) -> anyhow::Result> { - let mut w = self.sessions.write().await; - if let Some(s) = w.get(host) { - Ok(s.to_owned()) - } else { - let (username, password, _) = CONF - .remote_credentials - .get(host) - .ok_or(anyhow!("no credentials of the remote server"))?; - let s = Arc::new( - self.get_instance(host)? - .to_owned() - .login(LoginDetails { - username: username.to_owned(), - password: password.to_owned(), - expire: None, - drop_permissions: None, - }) - .await?, - ); - w.insert(host.to_owned(), s.clone()); - Ok(s) - } - } -} diff --git a/server/src/import.rs b/server/src/import.rs deleted file mode 100644 index dc32fbf..0000000 --- a/server/src/import.rs +++ /dev/null @@ -1,254 +0,0 @@ -/* - This file is part of jellything (https://codeberg.org/metamuffin/jellything) - which is licensed under the GNU Affero General Public License (version 3); see /COPYING. - Copyright (C) 2023 metamuffin -*/ -use crate::{database::Database, federation::Federation, CONF}; -use anyhow::{anyhow, bail, Context, Ok}; -use async_recursion::async_recursion; -use futures::{stream::FuturesUnordered, StreamExt, TryFutureExt}; -use jellybase::cache::async_cache_file; -use jellyclient::Session; -use jellycommon::{AssetLocation, AssetRole, MediaSource, Node, NodePrivate, RemoteImportOptions}; -use log::{debug, error, info}; -use std::{ - ffi::OsStr, - fs::File, - os::unix::prelude::OsStrExt, - path::PathBuf, - sync::{Arc, LazyLock}, -}; -use tokio::sync::Semaphore; - -static IMPORT_SEM: LazyLock = LazyLock::new(|| Semaphore::new(1)); - -pub async fn import(db: &Database, fed: &Federation) -> anyhow::Result<()> { - info!("clearing node tree"); - let permit = IMPORT_SEM.try_acquire()?; - db.node.clear()?; - info!("importing..."); - let (_, errs) = import_path(CONF.library_path.clone(), db, fed, vec![]) - .await - .context("indexing")?; - info!("import completed"); - drop(permit); - if errs == 0 { - Ok(()) - } else { - Err(anyhow!( - "partial import, {errs} errors occured; see server log" - )) - } -} - -#[async_recursion] -pub async fn import_path( - path: PathBuf, - db: &Database, - fed: &Federation, - mut node_path: Vec, -) -> anyhow::Result<(Vec, usize)> { - if path.is_dir() { - let mpath = path.join("directory.json"); - let children_paths = path.read_dir()?.map(Result::unwrap).filter_map(|e| { - if e.path().extension() == Some(&OsStr::from_bytes(b"jelly")) - || e.metadata().unwrap().is_dir() - { - Some(e.path()) - } else { - None - } - }); - let identifier = if mpath.exists() { - path.file_name().unwrap().to_str().unwrap().to_string() - } else { - node_path - .last() - .cloned() - .ok_or(anyhow!("non-root node requires parent"))? - }; - - node_path.push(identifier.clone()); - let mut all: FuturesUnordered<_> = children_paths - .into_iter() - .map(|p| import_path(p.clone(), db, fed, node_path.clone()).map_err(|e| (p, e))) - .collect(); - node_path.pop(); // we will set the dirs path later and need it to not be included - - let mut children_ids = Vec::new(); - let mut errs = 0; - while let Some(k) = all.next().await { - match k { - core::result::Result::Ok((els, errs2)) => { - errs += errs2; - children_ids.extend(els) - } - Err((p, e)) => { - errs += 1; - error!("import of {p:?} failed: {e:?}") - } - } - } - if mpath.exists() { - let mut node: Node = - serde_json::from_reader(File::open(mpath).context("metadata missing")?)?; - - node.public.children = children_ids; - node.public.path = node_path; - node.public.id = Some(identifier.to_owned()); - info!("adding {identifier}"); - db.node.insert(&identifier, &node)?; - Ok((vec![identifier], errs)) - } else { - Ok((children_ids, errs)) - } - } else if path.is_file() { - info!("loading {path:?}"); - let datafile = File::open(path.clone()).context("cant load metadata")?; - let mut node: Node = serde_json::from_reader(datafile).context("invalid metadata")?; - let identifier = node.private.id.clone().unwrap_or_else(|| { - path.file_name() - .unwrap() - .to_str() - .unwrap() - .strip_suffix(".jelly") - .unwrap() - .to_string() - }); - - let idents = if let Some(io) = node.private.import.take() { - let session = fed - .get_session(&io.host) - .await - .context("creating session")?; - - import_remote(io, db, &session, identifier.clone(), node_path) - .await - .context("federated import")? - } else { - debug!("adding {identifier}"); - node.public.path = node_path; - node.public.id = Some(identifier.to_owned()); - let did_insert = db.node.insert(&identifier, &node)?.is_none(); - if did_insert { - vec![identifier] - } else { - vec![] - } - }; - Ok((idents, 0)) - } else { - bail!("did somebody really put a fifo or socket in the library?!") - } -} - -static SEM_REMOTE_IMPORT: LazyLock = LazyLock::new(|| Semaphore::new(16)); - -#[async_recursion] -async fn import_remote( - mut opts: RemoteImportOptions, - db: &Database, - session: &Arc, - identifier: String, - mut node_path: Vec, -) -> anyhow::Result> { - let _permit = SEM_REMOTE_IMPORT.acquire().await.unwrap(); - info!("loading federated node {identifier:?}"); - - let flatten = opts.flatten; - opts.flatten = false; - - let node = session - .node(&opts.id) - .await - .context("fetching remote node")?; - - if node.federated.as_ref() == Some(&CONF.hostname) { - return Ok(vec![]); // node is federated from us, lets not import it - } - - let poster = - cache_federation_asset(session.to_owned(), opts.id.clone(), AssetRole::Poster).await?; - let backdrop = - cache_federation_asset(session.to_owned(), opts.id.clone(), AssetRole::Backdrop).await?; - - drop(_permit); - - let mut did_insert = false; - if !flatten { - let mut node = Node { - public: node.clone(), - private: NodePrivate { - backdrop: Some(backdrop), - poster: Some(poster), - import: None, - id: None, - source: Some(MediaSource::Remote { - host: opts.host.clone(), - remote_id: opts.id.clone(), - }), - }, - }; - node.public.path = node_path.clone(); - node.public.federated = Some(opts.host.clone()); - node.public - .children - .iter_mut() - .for_each(|c| *c = format!("{}{c}", opts.prefix.clone().unwrap_or(String::new()))); - - debug!("adding {identifier}"); - node.public.id = Some(identifier.to_owned()); - did_insert = db - .node - .fetch_and_update(&identifier, |pnode| Some(pnode.unwrap_or(node.clone())))? - .is_none(); - node_path.push(opts.id.clone()); - } - - let mut children: FuturesUnordered<_> = node - .children - .iter() - .map(|c| { - let prefixed = format!("{}{c}", opts.prefix.clone().unwrap_or(String::new())); - import_remote( - RemoteImportOptions { - id: c.to_owned(), - ..opts.clone() - }, - db, - session, - prefixed, - node_path.clone(), - ) - }) - .collect(); - - let mut children_idents = Vec::new(); - while let Some(r) = children.next().await { - children_idents.extend(r?); - } - Ok(if flatten { - children_idents - } else if did_insert { - vec![identifier] - } else { - vec![] - }) -} - -async fn cache_federation_asset( - session: Arc, - identifier: String, - role: AssetRole, -) -> anyhow::Result { - async_cache_file( - &["federation-asset", role.as_str(), &identifier.clone()], - move |out| async move { - let session = session; - session - .node_asset(identifier.as_str(), role, 1024, out) - .await - }, - ) - .await -} diff --git a/server/src/main.rs b/server/src/main.rs index 6e732bd..d9ddf8b 100644 --- a/server/src/main.rs +++ b/server/src/main.rs @@ -8,16 +8,13 @@ use crate::routes::ui::{account::hash_password, admin::log::enable_logging}; use database::Database; -use federation::Federation; -use jellybase::CONF; +use jellybase::{CONF, federation::Federation}; use jellycommon::user::{PermissionSet, Theme, User}; use log::{error, warn}; use routes::build_rocket; use tokio::fs::create_dir_all; pub use jellybase::database; -pub mod federation; -pub mod import; pub mod routes; #[rocket::main] diff --git a/server/src/routes/mod.rs b/server/src/routes/mod.rs index e95d714..4c7838d 100644 --- a/server/src/routes/mod.rs +++ b/server/src/routes/mod.rs @@ -3,10 +3,10 @@ which is licensed under the GNU Affero General Public License (version 3); see /COPYING. Copyright (C) 2023 metamuffin */ -use crate::{database::Database, federation::Federation, routes::ui::error::MyResult}; +use crate::{database::Database, routes::ui::error::MyResult}; use api::{r_api_account_login, r_api_node_raw, r_api_root, r_api_version}; use base64::Engine; -use jellybase::CONF; +use jellybase::{CONF, federation::Federation}; use log::warn; use progress::{r_player_progress, r_player_watched}; use rand::random; diff --git a/server/src/routes/stream.rs b/server/src/routes/stream.rs index e7b3d54..14db462 100644 --- a/server/src/routes/stream.rs +++ b/server/src/routes/stream.rs @@ -4,14 +4,14 @@ Copyright (C) 2023 metamuffin */ use super::ui::{account::session::Session, error::MyError}; -use crate::{database::Database, federation::Federation}; +use crate::database::Database; use anyhow::{anyhow, Result}; use jellybase::{ + federation::Federation, permission::{NodePermissionExt, PermissionSetExt}, CONF, }; -use jellyclient::LoginDetails; -use jellycommon::{stream::StreamSpec, user::UserPermission, MediaSource}; +use jellycommon::{stream::StreamSpec, user::UserPermission, TrackSource}; use log::{info, warn}; use rocket::{ get, head, @@ -58,35 +58,36 @@ pub async fn r_stream( .as_ref() .ok_or(anyhow!("item does not contain media"))?; - if let MediaSource::Remote { host, remote_id } = source { - session - .user - .permissions - .assert(&UserPermission::FederatedContent)?; - - let (username, password, _) = CONF - .remote_credentials - .get(host) - .ok_or(anyhow!("no credentials on the server-side"))?; - - info!("creating session on {host}"); - let instance = federation.get_instance(&host)?.to_owned(); - let session = instance - .login(LoginDetails { - username: username.to_owned(), - password: password.to_owned(), - expire: Some(60), - drop_permissions: Some(HashSet::from_iter([ - UserPermission::ManageSelf, - UserPermission::Admin, // in case somebody federated the admin :))) - ])), - }) - .await?; - - let uri = session.stream(&remote_id, &spec); - info!("federation redirect"); - return Ok(Either::Right(RedirectResponse(uri))); - } + // TODO federated streams + // if let MediaSource::Remote { host, remote_id } = source { + // session + // .user + // .permissions + // .assert(&UserPermission::FederatedContent)?; + + // let (username, password, _) = CONF + // .remote_credentials + // .get(host) + // .ok_or(anyhow!("no credentials on the server-side"))?; + + // info!("creating session on {host}"); + // let instance = federation.get_instance(&host)?.to_owned(); + // let session = instance + // .login(LoginDetails { + // username: username.to_owned(), + // password: password.to_owned(), + // expire: Some(60), + // drop_permissions: Some(HashSet::from_iter([ + // UserPermission::ManageSelf, + // UserPermission::Admin, // in case somebody federated the admin :))) + // ])), + // }) + // .await?; + + // let uri = session.stream(&remote_id, &spec); + // info!("federation redirect"); + // return Ok(Either::Right(RedirectResponse(uri))); + // } info!( "stream request (range={})", diff --git a/server/src/routes/ui/admin/mod.rs b/server/src/routes/ui/admin/mod.rs index 0d1ee0a..b976192 100644 --- a/server/src/routes/ui/admin/mod.rs +++ b/server/src/routes/ui/admin/mod.rs @@ -9,8 +9,6 @@ pub mod user; use super::account::session::AdminSession; use crate::{ database::Database, - federation::Federation, - import::import, routes::ui::{ admin::log::rocket_uri_macro_r_admin_log, error::MyResult, @@ -19,7 +17,8 @@ use crate::{ uri, }; use anyhow::anyhow; -use jellybase::CONF; +use jellybase::{federation::Federation, CONF}; +use jellyimport::import; use rand::Rng; use rocket::{form::Form, get, post, FromForm, State}; use std::time::Instant; diff --git a/server/src/routes/ui/node.rs b/server/src/routes/ui/node.rs index 6e2f532..bcb7362 100644 --- a/server/src/routes/ui/node.rs +++ b/server/src/routes/ui/node.rs @@ -72,7 +72,7 @@ pub async fn r_library_node_filter<'a>( filter_and_sort_nodes(&filter, &mut children); Ok(Either::Left(LayoutPage { - title: node.title.to_string(), + title: node.title.clone().unwrap_or_default(), content: markup::new! { @NodePage { node: &node, id: &id, udata: &udata, children: &children, filter: &filter } }, @@ -82,14 +82,14 @@ pub async fn r_library_node_filter<'a>( markup::define! { NodeCard<'a>(id: &'a str, node: &'a NodePublic, udata: &'a NodeUserData) { - @let cls = format!("node card poster {}", match node.kind {NodeKind::Channel => "aspect-square", NodeKind::Video => "aspect-thumb", NodeKind::Collection => "aspect-land", _ => "aspect-port"}); + @let cls = format!("node card poster {}", match node.kind.unwrap_or_default() {NodeKind::Channel => "aspect-square", NodeKind::Video => "aspect-thumb", NodeKind::Collection => "aspect-land", _ => "aspect-port"}); div[class=cls] { .poster { a[href=uri!(r_library_node(id))] { img[src=uri!(r_item_assets(id, AssetRole::Poster, Some(1024)))]; } .cardhover.item { - @if !(matches!(node.kind, NodeKind::Collection | NodeKind::Channel)) { + @if !(matches!(node.kind.unwrap_or_default(), NodeKind::Collection | NodeKind::Channel)) { a.play.icon[href=&uri!(r_player(id, PlayerConfig::default()))] { "play_arrow" } } @Props { node, udata } @@ -103,17 +103,17 @@ markup::define! { } } NodePage<'a>(id: &'a str, node: &'a NodePublic, udata: &'a NodeUserData, children: &'a Vec<(String, NodePublic, NodeUserData)>, filter: &'a NodeFilterSort) { - @if !matches!(node.kind, NodeKind::Collection) { + @if !matches!(node.kind.unwrap_or_default(), NodeKind::Collection) { img.backdrop[src=uri!(r_item_assets(id, AssetRole::Backdrop, Some(2048)))]; } .page.node { - @if !matches!(node.kind, NodeKind::Collection) { + @if !matches!(node.kind.unwrap_or_default(), NodeKind::Collection) { div.bigposter { img[src=uri!(r_item_assets(id, AssetRole::Poster, Some(2048)))]; } } .title { h1 { @node.title } @if node.media.is_some() { a.play[href=&uri!(r_player(id, PlayerConfig::default()))] { "Watch now" }} - @if !matches!(node.kind, NodeKind::Collection | NodeKind::Channel) { + @if !matches!(node.kind.unwrap_or_default(), NodeKind::Collection | NodeKind::Channel) { @match udata.watched { WatchedState::None | WatchedState::Progress(_) => { @@ -152,15 +152,15 @@ markup::define! { } } } - @if matches!(node.kind, NodeKind::Collection | NodeKind::Channel) { - @if matches!(node.kind, NodeKind::Collection) { + @if matches!(node.kind.unwrap_or_default(), NodeKind::Collection | NodeKind::Channel) { + @if matches!(node.kind.unwrap_or_default(), NodeKind::Collection) { @if let Some(parent) = &node.path.last().cloned() { a.dirup[href=uri!(r_library_node(parent))] { "Go up" } } } @NodeFilterSortForm { f: filter } } - @match node.kind { + @match node.kind.unwrap_or_default() { NodeKind::Collection | NodeKind::Channel => { ul.children {@for (id, node, udata) in children.iter() { li { @NodeCard { id, node, udata } } @@ -261,7 +261,9 @@ impl MediaInfoExt for MediaInfo { let mut maxdim = 0; for t in &self.tracks { match &t.kind { - SourceTrackKind::Video { width, height, .. } => maxdim = maxdim.max(*width.max(height)), + SourceTrackKind::Video { width, height, .. } => { + maxdim = maxdim.max(*width.max(height)) + } _ => (), } } diff --git a/server/src/routes/ui/player.rs b/server/src/routes/ui/player.rs index 177a5f6..8b8adf6 100644 --- a/server/src/routes/ui/player.rs +++ b/server/src/routes/ui/player.rs @@ -59,7 +59,7 @@ pub fn r_player<'a>( let conf = player_conf(item.clone(), playing)?; Ok(LayoutPage { - title: item.public.title.to_owned(), + title: item.public.title.to_owned().unwrap_or_default(), class: Some("player"), content: markup::new! { @if playing { diff --git a/server/src/routes/ui/sort.rs b/server/src/routes/ui/sort.rs index c7fbfc2..143a101 100644 --- a/server/src/routes/ui/sort.rs +++ b/server/src/routes/ui/sort.rs @@ -139,14 +139,14 @@ pub fn filter_and_sort_nodes( o &= !match p { FilterProperty::FederationLocal => node.federated.is_none(), FilterProperty::FederationRemote => node.federated.is_some(), - FilterProperty::KindMovie => node.kind == NodeKind::Movie, - FilterProperty::KindVideo => node.kind == NodeKind::Video, - FilterProperty::KindCollection => node.kind == NodeKind::Collection, - FilterProperty::KindChannel => node.kind == NodeKind::Channel, - FilterProperty::KindShow => node.kind == NodeKind::Show, - FilterProperty::KindSeries => node.kind == NodeKind::Series, - FilterProperty::KindSeason => node.kind == NodeKind::Season, - FilterProperty::KindEpisode => node.kind == NodeKind::Episode, + FilterProperty::KindMovie => node.kind == Some(NodeKind::Movie), + FilterProperty::KindVideo => node.kind == Some(NodeKind::Video), + FilterProperty::KindCollection => node.kind == Some(NodeKind::Collection), + FilterProperty::KindChannel => node.kind == Some(NodeKind::Channel), + FilterProperty::KindShow => node.kind == Some(NodeKind::Show), + FilterProperty::KindSeries => node.kind == Some(NodeKind::Series), + FilterProperty::KindSeason => node.kind == Some(NodeKind::Season), + FilterProperty::KindEpisode => node.kind == Some(NodeKind::Episode), FilterProperty::Watched => udata.watched == WatchedState::Watched, FilterProperty::Unwatched => udata.watched == WatchedState::None, FilterProperty::WatchProgress => { -- cgit v1.2.3-70-g09d2 From 826c61c9612e855b19c3adb0e93d80bbfb4dc903 Mon Sep 17 00:00:00 2001 From: metamuffin Date: Fri, 22 Dec 2023 00:29:11 +0100 Subject: rework import system pt. 2 --- Cargo.lock | 2 ++ common/src/lib.rs | 4 +-- import/Cargo.toml | 4 +-- import/src/lib.rs | 65 ++++++++++++++++++++++++++++++++++++++++++-- server/src/routes/ui/home.rs | 2 +- tool/src/main.rs | 13 --------- 6 files changed, 69 insertions(+), 21 deletions(-) (limited to 'server/src') diff --git a/Cargo.lock b/Cargo.lock index 9a12441..bd09a54 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1391,9 +1391,11 @@ dependencies = [ "jellybase", "jellyclient", "jellycommon", + "jellymatroska", "jellyremuxer", "log", "reqwest", + "serde", "serde_json", "serde_yaml", "tokio", diff --git a/common/src/lib.rs b/common/src/lib.rs index e953d85..9a3535a 100644 --- a/common/src/lib.rs +++ b/common/src/lib.rs @@ -21,8 +21,8 @@ use std::{collections::BTreeMap, path::PathBuf}; #[derive(Debug, Clone, Deserialize, Serialize, Default)] pub struct Node { - pub public: NodePublic, - pub private: NodePrivate, + #[serde(default)] pub public: NodePublic, + #[serde(default)] pub private: NodePrivate, } #[rustfmt::skip] diff --git a/import/Cargo.toml b/import/Cargo.toml index f2ba7af..a54967c 100644 --- a/import/Cargo.toml +++ b/import/Cargo.toml @@ -7,14 +7,14 @@ edition = "2021" jellycommon = { path = "../common" } jellybase = { path = "../base" } jellyclient = { path = "../client" } -# jellymatroska = { path = "../matroska" } +jellymatroska = { path = "../matroska" } jellyremuxer = { path = "../remuxer" } log = { workspace = true } anyhow = "1.0.75" reqwest = { version = "0.11.22", features = ["blocking", "json"] } -# serde = { version = "1.0.193", features = ["derive"] } +serde = { version = "1.0.193", features = ["derive"] } serde_json = "1.0.108" serde_yaml = "0.9.27" # bincode = { version = "2.0.0-rc.3", features = ["serde"] } diff --git a/import/src/lib.rs b/import/src/lib.rs index 3698f79..ed0af2d 100644 --- a/import/src/lib.rs +++ b/import/src/lib.rs @@ -4,6 +4,9 @@ Copyright (C) 2023 metamuffin */ #![feature(lazy_cell)] +pub mod infojson; +pub mod tmdb; + use anyhow::{Context, Ok}; use async_recursion::async_recursion; use futures::{stream::FuturesUnordered, StreamExt}; @@ -14,16 +17,19 @@ use jellyclient::Session; use jellycommon::{ AssetLocation, AssetRole, ImportOptions, ImportSource, Node, NodePrivate, NodePublic, }; +use jellymatroska::read::EbmlReader; +use jellyremuxer::import::import_metadata; use log::{debug, info}; use std::{ cmp::Ordering, ffi::OsStr, fs::File, + io::BufReader, os::unix::prelude::OsStrExt, path::{Path, PathBuf}, sync::{Arc, LazyLock}, }; -use tokio::sync::Semaphore; +use tokio::{sync::Semaphore, task::spawn_blocking}; static IMPORT_SEM: LazyLock = LazyLock::new(|| Semaphore::new(1)); @@ -48,12 +54,15 @@ pub fn merge_nodes(db: &Database) -> anyhow::Result<()> { nodes.sort_by(|(x, _), (y, _)| compare_index_path(x, y)); - let node = nodes + let mut node = nodes .into_iter() .map(|(_, x)| x) .reduce(|x, y| merge_node(x, y)) .unwrap(); + node.public.id = Some(id.clone()); + node.public.path = vec!["library".to_string()]; // TODO reconstruct from children + db.node.insert(&id, &node)?; } Ok(()) @@ -146,7 +155,44 @@ async fn process_source( ImportSource::Override(n) => insert_node(&id, n)?, ImportSource::Tmdb(_) => todo!(), ImportSource::Media { location } => { - let path = location.path(); + let media_path = location.path(); + + let metadata = spawn_blocking(move || { + let input = BufReader::new(File::open(&media_path).unwrap()); + let mut input = EbmlReader::new(input); + import_metadata(&mut input) + }) + .await??; + + // if let Some(cover) = metadata.cover { + // let pu = path.join(format!( + // "cover.{}", + // match mime.as_str() { + // "image/webp" => "webp", + // "image/jpeg" => "jpeg", + // "image/png" => "png", + // _ => { + // warn!("unknown mime, just using webp"); + // "webp" + // } + // } + // )); + // if !pu.exists() { + // let mut f = tokio::fs::File::create(&pu).await?; + // f.write_all(&data).await?; + // } + // } + + let node = Node { + public: NodePublic { + title: metadata.title, + description: metadata.description, + tagline: metadata.tagline, + ..Default::default() + }, + private: NodePrivate::default(), + }; + insert_node(&id, node)?; } ImportSource::Federated { host } => { let session = fed.get_session(&host).await.context("creating session")?; @@ -374,3 +420,16 @@ async fn cache_federation_asset( ) .await } + +fn make_ident(s: &str) -> String { + let mut out = String::new(); + for s in s.chars() { + match s { + 'a'..='z' | '0'..='9' => out.push(s), + 'A'..='Z' => out.push(s.to_ascii_lowercase()), + '-' | ' ' | '_' | ':' => out.push('-'), + _ => (), + } + } + out +} diff --git a/server/src/routes/ui/home.rs b/server/src/routes/ui/home.rs index bcbc847..74e9b02 100644 --- a/server/src/routes/ui/home.rs +++ b/server/src/routes/ui/home.rs @@ -77,7 +77,7 @@ pub fn r_home(sess: Session, db: &State) -> MyResult { Ok(LayoutPage { title: "Home".to_string(), content: markup::new! { - p { "Welcome back " @sess.user.display_name } + p { "Welcome back, " @sess.user.display_name } h2 { "Explore " @CONF.brand } .homelist { ul {@for (id, node, udata) in &toplevel { li { @NodeCard { id, node, udata } } diff --git a/tool/src/main.rs b/tool/src/main.rs index 34337ce..6384822 100644 --- a/tool/src/main.rs +++ b/tool/src/main.rs @@ -193,19 +193,6 @@ fn main() -> anyhow::Result<()> { } } -fn make_ident(s: &str) -> String { - let mut out = String::new(); - for s in s.chars() { - match s { - 'a'..='z' | '0'..='9' => out.push(s), - 'A'..='Z' => out.push(s.to_ascii_lowercase()), - '-' | ' ' | '_' | ':' => out.push('-'), - _ => (), - } - } - out -} - fn ok_or_warn(r: Result) -> Option { match r { Ok(t) => Some(t), -- cgit v1.2.3-70-g09d2