euzu/tuliprox
1
0
Fork 0
mirror of https://github.com/euzu/tuliprox.git synced 2026-10-04 15:02:16 +02:00
Code Issues Packages Projects Releases 5 Wiki Activity

stream properties refactored

Browse Source
This commit is contained in:
euzu
2025-12-27 09:52:28 +01:00
parent d5207e886f
commit cf0c928730
45 changed files with 295 additions and 446 deletions
Download Patch File Download Diff File Expand all files Collapse all files
backend/src/processing/processor/epg.rs
+2 -2
View File
@@ -64,7 +64,7 @@ impl EpgIdCache<'_> {
/// cache.normalize_and_store("Discovery Channel", Some(&"discovery.epg".to_string()));
/// assert!(cache.normalized.contains_key(&cache.normalize("Discovery Channel")));
/// ```
fn normalize_and_store(&mut self, name: &str, epg_id: Option<&String>) {
fn normalize_and_store(&mut self, name: &str, epg_id: Option<&str>) {
self.insert_normalized(name);
if let Some(chan_epg_id) = epg_id {
@@ -124,7 +124,7 @@ impl EpgIdCache<'_> {
if needs_normalization {
let name = &channel.header.name;
self.normalize_and_store(name, channel.header.epg_channel_id.as_ref());
self.normalize_and_store(name, channel.header.epg_channel_id.as_deref());
}
}
}
backend/src/processing/processor/playlist.rs
+2 -2
View File
@@ -110,7 +110,7 @@ fn filter_playlist(playlist: &mut [PlaylistGroup], target: &ConfigTarget) -> Opt
fn assign_channel_no_playlist(new_playlist: &mut [PlaylistGroup]) {
let assigned_chnos: HashSet<u32> = new_playlist.iter().flat_map(|g| &g.channels)
.filter(|c| !c.header.chno == 0)
.filter(|c| c.header.chno != 0)
.map(|c| c.header.chno)
.collect();
let mut chno = 1;
@@ -335,8 +335,8 @@ async fn process_source(client: &reqwest::Client, app_config: Arc<AppConfig>, so
let (playlistgroups, mut error_list) = {
let (downloaded_playlist, mut download_err) = playlist_download_from_input(client, &app_config, input).await;
let (playlist, error) = persist_input_playlist(&app_config, input, downloaded_playlist).await;
error!("Failed to persist input playlist {}", input.name);
if let Some(err) = error {
error!("Failed to persist input playlist {}", input.name);
download_err.push(err);
}
(playlist, download_err)
backend/src/processing/processor/xtream_series.rs
-96
View File
@@ -89,102 +89,6 @@ async fn playlist_resolve_series_info(app_config: &Arc<AppConfig>, client: &reqw
info!("resolved {processed_series_info_count}/{series_info_count} series info");
result
}
//
// async fn process_series_info(
// app_config: &AppConfig,
// fpl: &mut FetchedPlaylist<'_>,
// errors: &mut Vec<TuliproxError>,
// ) -> Vec<PlaylistGroup> {
// let mut result: Vec<PlaylistGroup> = vec![];
// let input = fpl.input;
// let config = app_config.config.load();
// let Ok(Some((info_path, idx_path))) = get_input_storage_path(&input.name, &config.working_dir)
// .map(|storage_path| xtream_get_info_file_paths(&storage_path, XtreamCluster::Series))
// else {
// errors.push(notify_err!("Failed to open input info file for series".to_string()));
// return result;
// };
//
// let mut write_counter = 0usize;
//
// let _file_lock = app_config.file_locks.read_lock(&info_path).await;
//
// // Contains the Series Info with episode listing
// let Ok(mut info_reader) = IndexedDocumentReader::<u32, String>::new(&info_path, &idx_path) else { return result; };
//
// let Some((mut wal_file, wal_path)) = create_resolve_episode_wal_files(&config, input).await else {
// errors.push(notify_err!("Could not create wal file for series episodes record".to_string()));
// return result;
// };
// let mut wal_writer = utils::async_file_writer(&mut wal_file);
//
// for plg in fpl
// .playlistgroups
// .iter_mut()
// .filter(|plg| plg.xtream_cluster == XtreamCluster::Series)
// {
// let mut group_series = vec![];
//
// // Resolve does not handle LocalSeriesInfo
// for pli in plg
// .channels
// .iter_mut()
// .filter(|pli| pli.header.item_type == PlaylistItemType::SeriesInfo)
// {
// let Some(provider_id) = pli.header.get_provider_id() else { continue; };
// let Ok(content) = info_reader.get(&provider_id) else { continue; };
// if content.is_empty() {
// warn!("Series info content is empty, skipping series with provider id: {provider_id}");
// continue;
// }
// match serde_json::from_str::<SeriesStreamProperties>(&content) {
// Ok(series_content) => {
// let (group, series_name) = {
// let header = &pli.header;
// (header.group.clone(), if header.name.is_empty() { header.title.clone() } else { header.name.clone() })
// };
// if let Some(mut series) = parse_xtream_series_info(&series_content, &group, &series_name, input) {
// for pli_episode in &mut series {
// let Some(provider_id) = &pli_episode.header.get_provider_id() else { continue; };
// match write_series_episode_record_to_wal_file(&mut wal_writer, *provider_id, pli.header.additional_properties.as_ref()).await {
// Ok(written_bytes) => {
// write_counter += written_bytes;
// // periodic flush to bound BufWriter memory
// if write_counter >= IO_BUFFER_SIZE {
// write_counter = 0;
// if let Err(err) = wal_writer.flush().await {
// errors.push(notify_err!(format!("Failed periodic flush of wal content writer {err}")));
// }
// }
// }
// Err(err) => { errors.push(info_err!(format!("Failed to write to series episode wal file: {err}"))) }
// }
// }
// group_series.extend(series.into_iter());
// }
// }
// Err(err) => errors.push(info_err!(format!("Failed to parse JSON: {err}"))),
// }
// }
// if !group_series.is_empty() {
// result.push(PlaylistGroup {
// id: plg.id,
// title: plg.title.clone(),
// channels: group_series,
// xtream_cluster: XtreamCluster::Series,
// });
// }
// }
//
// handle_error!(wal_writer.flush().await, |err| errors.push(notify_err!(format!("Failed to resolve series episodes, could not write to wal file {err}"))));
// handle_error!(wal_writer.get_ref().sync_all().await, |err| errors.push(notify_err!(format!("Failed to sync series info to wal file {err}"))));
//
// drop(wal_writer);
// drop(wal_file);
// handle_error!(xtream_update_input_series_episodes_record_from_wal_file(app_config, input, &wal_path).await,
// |err| errors.push(err));
// result
// }
pub async fn playlist_resolve_series(cfg: &Arc<AppConfig>,
client: &reqwest::Client,
backend/src/processing/processor/xtream_vod.rs
+8 -6
View File
@@ -1,15 +1,15 @@
use std::sync::Arc;
use crate::model::FetchedPlaylist;
use crate::model::{AppConfig, ConfigTarget};
use crate::processing::processor::xtream::{playlist_resolve_download_playlist_item};
use crate::processing::processor::{create_resolve_options_function_for_xtream_target};
use crate::repository::xtream_repository::{persists_input_vod_info};
use crate::processing::processor::xtream::playlist_resolve_download_playlist_item;
use crate::processing::processor::create_resolve_options_function_for_xtream_target;
use crate::repository::storage::get_input_storage_path;
use crate::repository::xtream_repository::persists_input_vod_info;
use log::{error, info, log_enabled, Level};
use shared::error::TuliproxError;
use shared::model::{InputType, PlaylistEntry, StreamProperties, VideoStreamProperties, XtreamVideoInfo};
use shared::model::{PlaylistItemType, XtreamCluster};
use std::sync::Arc;
use std::time::Instant;
use crate::repository::storage::get_input_storage_path;
create_resolve_options_function_for_xtream_target!(vod);
@@ -52,7 +52,9 @@ pub async fn playlist_resolve_vod(app_config: &Arc<AppConfig>, client: &reqwest:
if let Some(content) = playlist_resolve_download_playlist_item(client, pli, fpl.input, errors, resolve_delay, XtreamCluster::Video).await {
if let Ok(info) = serde_json::from_str::<XtreamVideoInfo>(&content) {
let video_stream_props = VideoStreamProperties::from_info(&info, pli);
let _ = persists_input_vod_info(app_config, &storage_path, pli.header.xtream_cluster, &input.name, provider_id, &video_stream_props).await;
if let Err(err) = persists_input_vod_info(app_config, &storage_path, pli.header.xtream_cluster, &input.name, provider_id, &video_stream_props).await {
error!("Failed to persist VOD info for provider_id {provider_id}: {err}");
}
// This makes the data available for subsequent processing steps like STRM export.
pli.header.additional_properties = Some(StreamProperties::Video(Box::new(video_stream_props)));
}