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

oupsie

Browse Source
This commit is contained in:
g0ldyy
2025-05-10 18:07:41 +02:00
parent f29ac65da5
commit acf07012bb
53 changed files with 154 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files
CHANGELOG.md
+4 -4
View File
@@ -16,7 +16,7 @@ web_ui:
path:
auth:
enabled: true
issuer: m3u_filter
issuer: tuliprox
secret: ef9ab256a8c0abe5de92c2e05ca92baa810472ab702ff1674e9248308ceeec92
userfile: user.txt
```
@@ -70,7 +70,7 @@ url: 'https://localhost.com/epg.xml'
```
```yaml
# multi local file epg
url: ['file:///${env:M3U_FILTER_HOME}/epg.xml', 'file:///${env:M3U_FILTER_HOME}/epg2.xml']
url: ['file:///${env:TULIPROX_HOME}/epg.xml', 'file:///${env:TULIPROX_HOME}/epg2.xml']
```
```yaml
# multi url epg
@@ -510,8 +510,8 @@ reverse_proxy:
- `secret` secret for jwt token
- `userfile` optional userfile with generated userfile in format "username: password" per file, default name is user.txt in config path
* Password generation argument --genpwd to generate passwords for userfile.
* Added env var `M3U_FILTER_LOG` for log level
* Log Level has now module support like `m3u_filter::util=error,m3u_filter::filter=debug,m3u_filter=debug`
* Added env var `TULIPROX_LOG` for log level
* Log Level has now module support like `tuliprox::util=error,tuliprox::filter=debug,tuliprox=debug`
* Multiple Xtream Sources merging into one target is now supported
# v1.1.8(2024-03-06)
README.md
+4 -4
View File
@@ -268,7 +268,7 @@ if set to true, an update is started when the application starts.
- `sanitize_sensitive_info` default true
- `active_clients` default false, if set to true reverse proxy client count is printed as info log.
- `log_level` can be set to `trace`, `debug`, `info`, `warn` and `error`.
You can also set module based level like `hyper_util::client::legacy::connect=error,m3u_filter=debug`
You can also set module based level like `hyper_util::client::legacy::connect=error,tuliprox=debug`
`log_level` priority CLI-Argument, Env-Var, Config, Default(`info`).
@@ -291,7 +291,7 @@ web_ui_enabled: true
web_auth:
enabled: true
secret: very.secret.secret
issuer: m3u_filter
issuer: tuliprox
userfile: user.txt
```
@@ -1297,12 +1297,12 @@ Following log levels are supported:
Use the `-l` or `--log-level` cli-argument to specify the log-level.
The log level can be set through environment variable `M3U_FILTER_LOG`,
The log level can be set through environment variable `TULIPROX_LOG`,
or config.
Precedence is cli-argument, env-var, config, default(`info`).
Log Level has module support like `m3u_filter::util=error,m3u_filter::filter=debug,m3u_filter=debug`
Log Level has module support like `tuliprox::util=error,tuliprox::filter=debug,tuliprox=debug`
## 6. Web-UI
config/config.yml
+1 -1
View File
@@ -33,7 +33,7 @@ web_ui:
path:
auth:
enabled: true
issuer: m3u_filter
issuer: tuliprox
secret: ef9ab256a8c0abe5de92c2e05ca92baa810472ab702ff1674e9248308ceeec92
userfile: user.txt
src/api/endpoints/download_api.rs
+1 -1
View File
@@ -12,7 +12,7 @@ use std::ops::Deref;
use std::sync::Arc;
use std::{fs};
use axum::response::IntoResponse;
use crate::m3u_filter_error::to_io_error;
use crate::tuliprox_error::to_io_error;
use crate::utils::request::create_client;
async fn download_file(active: Arc<RwLock<Option<FileDownload>>>, client: &reqwest::Client) -> Result<(), String> {
src/api/endpoints/v1_api.rs
+1 -1
View File
@@ -6,7 +6,7 @@ use crate::api::model::config::{ServerConfig, ServerInputConfig, ServerSourceCon
use crate::api::model::request::{PlaylistRequest, PlaylistRequestType};
use crate::auth::access_token::create_access_token;
use crate::auth::authenticator::validator_admin;
use crate::m3u_filter_error::M3uFilterError;
use crate::tuliprox_error::M3uFilterError;
use crate::model::StatusCheck;
use crate::model::XtreamPlaylistItem;
use crate::model::{validate_targets, Config, ConfigDto, ConfigInput, ConfigInputOptions, ConfigSource, ConfigTarget, InputType};
src/api/endpoints/xtream_api.rs
+4 -4
View File
@@ -10,9 +10,9 @@ use crate::api::model::request::UserApiRequest;
use crate::api::model::streams::provider_stream::{create_custom_video_stream_response, CustomVideoStreamType}
;
use crate::api::model::xtream::XtreamAuthorizationResponse;
use crate::m3u_filter_error::create_m3u_filter_error_result;
use crate::m3u_filter_error::info_err;
use crate::m3u_filter_error::{str_to_io_error, M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::create_tuliprox_error_result;
use crate::tuliprox_error::info_err;
use crate::tuliprox_error::{str_to_io_error, M3uFilterError, M3uFilterErrorKind};
use crate::model::{ProxyType, ProxyUserCredentials, UserConnectionPermission};
use crate::model::TargetType;
use crate::model::{Config, ConfigInput, ConfigTarget};
@@ -88,7 +88,7 @@ impl FromStr for XtreamApiStreamContext {
Self::MOVIE => Ok(Self::Movie),
Self::SERIES => Ok(Self::Series),
Self::TIMESHIFT => Ok(Self::Timeshift),
_ => create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Unknown CounterModifier: {}", s)
_ => create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Unknown CounterModifier: {}", s)
}
}
}
src/auth/authenticator.rs
+1 -1
View File
@@ -5,7 +5,7 @@ use crate::api::api_utils::get_username_from_auth_header;
use crate::model::WebAuthConfig;
use crate::api::model::app_state::AppState;
use crate::auth::auth_bearer::AuthBearer;
use crate::m3u_filter_error::to_io_error;
use crate::tuliprox_error::to_io_error;
const ROLE_ADMIN: &str = "ADMIN";
const ROLE_USER: &str = "USER";
src/auth/password.rs
+1 -1
View File
@@ -1,6 +1,6 @@
use rand::{Rng};
use rand::distr::Alphanumeric;
use crate::m3u_filter_error::str_to_io_error;
use crate::tuliprox_error::str_to_io_error;
fn generate_salt(length: usize) -> String {
let salt: String = rand::rng()
src/foundation/filter.rs
+10 -10
View File
@@ -6,11 +6,11 @@ use log::{debug, error, log_enabled, trace, Level};
use pest::iterators::Pair;
use pest::Parser;
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
use crate::model::ItemField;
use crate::model::{PlaylistItem, PlaylistItemType};
use crate::tools::directed_graph::DirectedGraph;
use crate::m3u_filter_error::{create_m3u_filter_error_result, info_err};
use crate::tuliprox_error::{create_tuliprox_error_result, info_err};
use crate::utils::CONSTANTS;
use crate::utils::exit;
@@ -243,7 +243,7 @@ fn get_parser_item_field(expr: &Pair<Rule>) -> Result<ItemField, M3uFilterError>
}
}
}
create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "unknown field: {}", expr.as_str())
create_tuliprox_error_result!(M3uFilterErrorKind::Info, "unknown field: {}", expr.as_str())
}
fn get_parser_regexp(
@@ -257,7 +257,7 @@ fn get_parser_regexp(
let regstr = apply_templates_to_pattern(&parsed_text, templates);
let re = regex::Regex::new(regstr.as_str());
if re.is_err() {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {}", regstr);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {}", regstr);
}
let regexp = re.unwrap();
let captures = regexp
@@ -275,7 +275,7 @@ fn get_parser_regexp(
captures,
});
}
create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "unknown field: {}", expr.as_str())
create_tuliprox_error_result!(M3uFilterErrorKind::Info, "unknown field: {}", expr.as_str())
}
fn get_parser_field_comparison(
@@ -315,7 +315,7 @@ fn get_parser_type_comparison(expr: Pair<Rule>) -> Result<Filter, M3uFilterError
let expr_inner = expr.into_inner();
let text_item_type = expr_inner.as_str();
let item_type = get_filter_item_type(text_item_type);
item_type.map_or_else(|| create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "cant parse item type: {text_item_type}"), |itype| Ok(Filter::TypeComparison(ItemField::Type, itype)))
item_type.map_or_else(|| create_tuliprox_error_result!(M3uFilterErrorKind::Info, "cant parse item type: {text_item_type}"), |itype| Ok(Filter::TypeComparison(ItemField::Type, itype)))
}
macro_rules! handle_expr {
@@ -400,7 +400,7 @@ fn get_parser_binary_op(expr: &Pair<Rule>) -> Result<BinaryOperator, M3uFilterEr
match expr.as_rule() {
Rule::and => Ok(BinaryOperator::And),
Rule::or => Ok(BinaryOperator::Or),
_ => create_m3u_filter_error_result!(
_ => create_tuliprox_error_result!(
M3uFilterErrorKind::Info,
"Unknown binary operator {}",
expr.as_str()
@@ -471,7 +471,7 @@ pub fn get_filter(
result.map_or_else(
|| {
create_m3u_filter_error_result!(
create_tuliprox_error_result!(
M3uFilterErrorKind::Info,
"Unable to parse filter: {}",
&filter_text
@@ -480,7 +480,7 @@ pub fn get_filter(
Ok,
)
}
Err(err) => create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "{}", err),
Err(err) => create_tuliprox_error_result!(M3uFilterErrorKind::Info, "{}", err),
}
}
@@ -508,7 +508,7 @@ fn build_dependency_graph(
);
}
if !cycles.is_empty() {
return create_m3u_filter_error_result!(
return create_tuliprox_error_result!(
M3uFilterErrorKind::Info,
"Cyclic dependencies in templates detected!"
);
src/m3u_filter_error.rs
+8 -8
View File
@@ -43,23 +43,23 @@ pub use info_err;
#[macro_export]
macro_rules! create_m3u_filter_error {
macro_rules! create_tuliprox_error {
($kind: expr, $($arg:tt)*) => {
M3uFilterError::new($kind, format!($($arg)*))
}
}
pub use create_m3u_filter_error;
pub use create_tuliprox_error;
#[macro_export]
macro_rules! create_m3u_filter_error_result {
macro_rules! create_tuliprox_error_result {
($kind: expr, $($arg:tt)*) => {
Err(M3uFilterError::new($kind, format!($($arg)*)))
}
}
pub use create_m3u_filter_error_result;
pub use create_tuliprox_error_result;
#[macro_export]
macro_rules! handle_m3u_filter_error_result_list {
macro_rules! handle_tuliprox_error_result_list {
($kind:expr, $result: expr) => {
let errors = $result
.filter_map(|result| {
@@ -76,10 +76,10 @@ macro_rules! handle_m3u_filter_error_result_list {
}
}
pub use handle_m3u_filter_error_result_list;
pub use handle_tuliprox_error_result_list;
#[macro_export]
macro_rules! handle_m3u_filter_error_result {
macro_rules! handle_tuliprox_error_result {
($kind:expr, $result: expr) => {
if let Err(err) = $result {
return Err(M3uFilterError::new($kind, err.to_string()));
@@ -87,7 +87,7 @@ macro_rules! handle_m3u_filter_error_result {
}
}
pub use handle_m3u_filter_error_result;
pub use handle_tuliprox_error_result;
#[derive(Debug, PartialEq, Eq)]
src/main.rs
+1 -1
View File
@@ -103,7 +103,7 @@ fn main() {
let config_path: String = args.config_path.unwrap_or_else(file_utils::get_default_config_path);
let config_file: String = args.config_file.unwrap_or_else(|| file_utils::get_default_config_file_path(&config_path));
let env_log_level = std::env::var("M3U_FILTER_LOG");
let env_log_level = std::env::var("TULIPROX_LOG");
init_logger(args.log_level.as_ref(), env_log_level.ok(), config_file.as_str());
if args.healthcheck {
src/model/api_proxy.rs
+3 -3
View File
@@ -1,5 +1,5 @@
use crate::api::model::app_state::AppState;
use crate::m3u_filter_error::{create_m3u_filter_error_result, info_err, M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{create_tuliprox_error_result, info_err, M3uFilterError, M3uFilterErrorKind};
use crate::model::{Config, ClusterFlags};
use crate::repository::user_repository::{backup_api_user_db_file, get_api_user_db_path, load_api_user, merge_api_user};
use crate::utils::default_as_true;
@@ -95,7 +95,7 @@ impl FromStr for ProxyType {
}
}
create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Unknown ProxyType: {}", s)
create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Unknown ProxyType: {}", s)
}
}
@@ -179,7 +179,7 @@ impl FromStr for ProxyUserStatus {
Self::TRIAL => Ok(Self::Trial),
Self::DISABLED => Ok(Self::Disabled),
Self::PENDING => Ok(Self::Pending),
_ => create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Unknown ProxyType: {}", s)
_ => create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Unknown ProxyType: {}", s)
}
}
}
src/model/config.rs
+12 -12
View File
@@ -11,14 +11,14 @@ use path_clean::PathClean;
use rand::Rng;
use crate::foundation::filter::{prepare_templates, PatternTemplate};
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
use crate::model::{ApiProxyConfig, ApiProxyServerInfo, ProxyUserCredentials, Mappings};
use crate::utils::{default_as_default, default_connect_timeout_secs, default_grace_period_millis, default_grace_period_timeout_secs};
use crate::utils::file_lock_manager::FileLockManager;
use crate::utils::file_utils;
use crate::utils::{parse_size_base_2, parse_to_kbps};
use crate::utils::exit;
use crate::m3u_filter_error::{ create_m3u_filter_error_result};
use crate::tuliprox_error::{ create_tuliprox_error_result};
use crate::model::{ConfigInput, ConfigInputOptions, IpCheckConfig, ProxyConfig, ConfigSource, ConfigTarget, HdHomeRunConfig, LogConfig, MessagingConfig, ProcessTargets, TargetOutput, VideoConfig, WebUiConfig};
const STREAM_QUEUE_SIZE: usize = 1024; // mpsc channel holding messages. with 8192byte chunks and 2Mbit/s approx 8MB
@@ -407,10 +407,10 @@ impl Config {
if let Some(username) = output_username {
if let Some((_, config_target)) = self.get_target_for_username(username).await {
if config_target.name != target_name {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "User:{username} does not belong to target: {}", target_name);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "User:{username} does not belong to target: {}", target_name);
}
} else {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "User: {username} does not exist");
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "User: {username} does not exist");
}
Ok(())
} else {
@@ -572,20 +572,20 @@ impl Config {
for input in &source.inputs {
let input_name = input.name.trim().to_string();
if input_name.is_empty() {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "input name required");
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "input name required");
}
if seen_names.contains(input_name.as_str()) {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "input names should be unique: {}", input_name);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "input names should be unique: {}", input_name);
}
seen_names.insert(input_name);
if let Some(aliases) = &input.aliases {
for alias in aliases {
let input_name = alias.name.trim().to_string();
if input_name.is_empty() {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "input name required");
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "input name required");
}
if seen_names.contains(input_name.as_str()) {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "input names should be unique: {}", input_name);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "input names should be unique: {}", input_name);
}
seen_names.insert(input_name);
}
@@ -603,11 +603,11 @@ impl Config {
// check target name is unique
let target_name = target.name.trim().to_string();
if target_name.is_empty() {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "target name required");
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "target name required");
}
if !default_target_name.eq_ignore_ascii_case(target_name.as_str()) {
if seen_names.contains(target_name.as_str()) {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "target names should be unique: {}", target_name);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "target names should be unique: {}", target_name);
}
seen_names.insert(target_name);
}
@@ -622,7 +622,7 @@ impl Config {
if let Some(targets) = &schedule.targets {
for target_name in targets {
if !target_names.contains(target_name) {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Unknown target name in scheduler: {}", target_name);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Unknown target name in scheduler: {}", target_name);
}
}
}
@@ -820,7 +820,7 @@ pub fn validate_targets(target_args: Option<&Vec<String>>, sources: &Vec<ConfigS
let missing_targets: Vec<String> = check_targets.iter().filter(|&(_, v)| *v == 0).map(|(k, _)| k.to_string()).collect();
if !missing_targets.is_empty() {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "No target found for {}", missing_targets.join(", "));
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "No target found for {}", missing_targets.join(", "));
}
// let processing_targets: Vec<String> = check_targets.iter().filter(|&(_, v)| *v != 0).map(|(k, _)| k.to_string()).collect();
// info!("Processing targets {}", processing_targets.join(", "));
src/model/config_download.rs
+2 -2
View File
@@ -1,4 +1,4 @@
use crate::m3u_filter_error::{create_m3u_filter_error_result, M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{create_tuliprox_error_result, M3uFilterError, M3uFilterErrorKind};
use regex::Regex;
use std::borrow::BorrowMut;
use std::collections::HashMap;
@@ -57,7 +57,7 @@ impl VideoConfig {
downl.t_re_episode_pattern = Some(pattern);
}
Err(err) => {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {episode_pattern} {err}");
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {episode_pattern} {err}");
}
}
}
src/model/config_epg.rs
+2 -2
View File
@@ -1,6 +1,6 @@
use log::warn;
use regex::Regex;
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind, create_m3u_filter_error_result};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind, create_tuliprox_error_result};
use crate::utils::CONSTANTS;
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
@@ -99,7 +99,7 @@ impl EpgSmartMatchConfig {
Some(regstr) => {
let re = regex::Regex::new(regstr.as_str());
if re.is_err() {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {}", regstr);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {}", regstr);
}
Some(re.unwrap())
}
src/model/config_input.rs
+4 -4
View File
@@ -1,4 +1,4 @@
use crate::m3u_filter_error::{create_m3u_filter_error_result, handle_m3u_filter_error_result_list, info_err, M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{create_tuliprox_error_result, handle_tuliprox_error_result_list, info_err, M3uFilterError, M3uFilterErrorKind};
use crate::model::EpgConfig;
use crate::utils::config_reader::csv_read_inputs;
use crate::utils::default_as_true;
@@ -94,7 +94,7 @@ impl FromStr for InputType {
} else if s.eq(Self::XTREAM_BATCH) {
Ok(Self::XtreamBatch)
} else {
create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Unknown InputType: {}", s)
create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Unknown InputType: {}", s)
}
}
}
@@ -139,7 +139,7 @@ impl FromStr for InputFetchMethod {
} else if s.eq(Self::POST_METHOD) {
Ok(Self::POST)
} else {
create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Unknown Fetch Method: {}", s)
create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Unknown Fetch Method: {}", s)
}
}
}
@@ -318,7 +318,7 @@ impl ConfigInput {
if let Some(aliases) = self.aliases.as_mut() {
let input_type = &self.input_type;
handle_m3u_filter_error_result_list!(M3uFilterErrorKind::Info, aliases.iter_mut().enumerate().map(|(idx, i)| i.prepare(index+1+(idx as u16), input_type)));
handle_tuliprox_error_result_list!(M3uFilterErrorKind::Info, aliases.iter_mut().enumerate().map(|(idx, i)| i.prepare(index+1+(idx as u16), input_type)));
}
Ok(index + self.aliases.as_ref().map_or(0, std::vec::Vec::len) as u16)
}
src/model/config_ip_check.rs
+1 -1
View File
@@ -1,5 +1,5 @@
use regex::Regex;
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, Default)]
#[serde(deny_unknown_fields)]
src/model/config_proxy.rs
+1 -1
View File
@@ -1,4 +1,4 @@
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, Default)]
#[serde(deny_unknown_fields)]
src/model/config_rename.rs
+2 -2
View File
@@ -1,4 +1,4 @@
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind, create_m3u_filter_error_result};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind, create_tuliprox_error_result};
use crate::model::ItemField;
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
@@ -18,7 +18,7 @@ impl ConfigRename {
self.re = Some(pattern);
Ok(())
}
Err(err) => create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {} {err}", &self.pattern),
Err(err) => create_tuliprox_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {} {err}", &self.pattern),
}
}
}
src/model/config_sort.rs
+4 -4
View File
@@ -1,5 +1,5 @@
use regex::Regex;
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind, create_m3u_filter_error, handle_m3u_filter_error_result_list};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind, create_tuliprox_error, handle_tuliprox_error_result_list};
use crate::model::{ItemField};
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
@@ -15,7 +15,7 @@ fn compile_regex_vec(patterns: Option<&Vec<String>>) -> Result<Option<Vec<Regex>
.map(|seq| {
seq.iter()
.map(|s| Regex::new(s).map_err(|err| {
create_m3u_filter_error!(M3uFilterErrorKind::Info, "cant parse regex: {s} {err}")
create_tuliprox_error!(M3uFilterErrorKind::Info, "cant parse regex: {s} {err}")
}))
.collect::<Result<Vec<_>, _>>()
})
@@ -62,7 +62,7 @@ impl ConfigSortChannel {
// Compile group_pattern
self.t_re_group_pattern = Some(
Regex::new(&self.group_pattern).map_err(|err| {
create_m3u_filter_error!(M3uFilterErrorKind::Info, "cant parse regex: {} {err}", &self.group_pattern)
create_tuliprox_error!(M3uFilterErrorKind::Info, "cant parse regex: {} {err}", &self.group_pattern)
})?
);
@@ -89,7 +89,7 @@ impl ConfigSort {
group.prepare()?;
}
if let Some(channels) = self.channels.as_mut() {
handle_m3u_filter_error_result_list!(M3uFilterErrorKind::Info, channels.iter_mut().map(ConfigSortChannel::prepare));
handle_tuliprox_error_result_list!(M3uFilterErrorKind::Info, channels.iter_mut().map(ConfigSortChannel::prepare));
}
Ok(())
}
src/model/config_source.rs
+2 -2
View File
@@ -1,4 +1,4 @@
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind, handle_m3u_filter_error_result_list};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind, handle_tuliprox_error_result_list};
use crate::model::ConfigInput;
use crate::model::config_target::ConfigTarget;
@@ -12,7 +12,7 @@ pub struct ConfigSource {
impl ConfigSource {
#[allow(clippy::cast_possible_truncation)]
pub fn prepare(&mut self, index: u16, include_computed: bool) -> Result<u16, M3uFilterError> {
handle_m3u_filter_error_result_list!(M3uFilterErrorKind::Info, self.inputs.iter_mut().enumerate().map(|(idx, i)| i.prepare(index+(idx as u16), include_computed)));
handle_tuliprox_error_result_list!(M3uFilterErrorKind::Info, self.inputs.iter_mut().enumerate().map(|(idx, i)| i.prepare(index+(idx as u16), include_computed)));
Ok(index + (self.inputs.len() as u16))
}
src/model/config_target.rs
+14 -14
View File
@@ -1,5 +1,5 @@
use crate::foundation::filter::{get_filter, Filter, MockValueProcessor, PatternTemplate, ValueProvider};
use crate::m3u_filter_error::{create_m3u_filter_error_result, handle_m3u_filter_error_result, handle_m3u_filter_error_result_list, info_err, M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{create_tuliprox_error_result, handle_tuliprox_error_result, handle_tuliprox_error_result_list, info_err, M3uFilterError, M3uFilterErrorKind};
use crate::model::cluster_flags::ClusterFlags;
use crate::model::config_rename::ConfigRename;
use crate::model::config_sort::ConfigSort;
@@ -208,7 +208,7 @@ impl ConfigTarget {
TargetOutput::Xtream(_) => {
xtream_cnt += 1;
if default_as_default().eq_ignore_ascii_case(&self.name) {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "unique target name is required for xtream type output: {}", self.name);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "unique target name is required for xtream type output: {}", self.name);
}
}
TargetOutput::M3u(m3u_output) => {
@@ -219,7 +219,7 @@ impl ConfigTarget {
strm_cnt += 1;
strm_output.directory = strm_output.directory.trim().to_string();
if strm_output.directory.trim().is_empty() {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "directory is required for strm type: {}", self.name);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "directory is required for strm type: {}", self.name);
}
if let Some(username) = &mut strm_output.username {
*username = username.trim().to_string();
@@ -234,19 +234,19 @@ impl ConfigTarget {
hdhr_cnt += 1;
hdhomerun_output.username = hdhomerun_output.username.trim().to_string();
if hdhomerun_output.username.is_empty() {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Username is required for HdHomeRun type: {}", self.name);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Username is required for HdHomeRun type: {}", self.name);
}
hdhomerun_output.device = hdhomerun_output.device.trim().to_string();
if hdhomerun_output.device.is_empty() {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Device is required for HdHomeRun type: {}", self.name);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Device is required for HdHomeRun type: {}", self.name);
}
if let Some(use_output) = hdhomerun_output.use_output.as_ref() {
match &use_output {
TargetType::M3u => { hdhomerun_needs_m3u = true; }
TargetType::Xtream => { hdhomerun_needs_xtream = true; }
_ => return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "HdHomeRun output option `use_output` only accepts `m3u` or `xtream` for target: {}", self.name),
_ => return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "HdHomeRun output option `use_output` only accepts `m3u` or `xtream` for target: {}", self.name),
}
}
}
@@ -254,22 +254,22 @@ impl ConfigTarget {
}
if m3u_cnt > 1 || strm_cnt > 1 || xtream_cnt > 1 || hdhr_cnt > 1 {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Multiple output formats with same type : {}", self.name);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Multiple output formats with same type : {}", self.name);
}
if strm_cnt > 0 && strm_needs_xtream && xtream_cnt == 0 {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "strm output with a username is only permitted when used in combination with xtream output: {}", self.name);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "strm output with a username is only permitted when used in combination with xtream output: {}", self.name);
}
if hdhr_cnt > 0 {
if xtream_cnt == 0 && m3u_cnt == 0 {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "HdHomeRun output is only permitted when used in combination with xtream or m3u output: {}", self.name);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "HdHomeRun output is only permitted when used in combination with xtream or m3u output: {}", self.name);
}
if hdhomerun_needs_m3u && m3u_cnt == 0 {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "HdHomeRun output has `use_output=m3u` but no `m3u` output defined: {}", self.name);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "HdHomeRun output has `use_output=m3u` but no `m3u` output defined: {}", self.name);
}
if hdhomerun_needs_xtream && xtream_cnt == 0 {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "HdHomeRun output has `use_output=xtream` but no `xtream` output defined: {}", self.name);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "HdHomeRun output has `use_output=xtream` but no `xtream` output defined: {}", self.name);
}
}
@@ -278,7 +278,7 @@ impl ConfigTarget {
match regexps {
Ok(watch_re) => self.t_watch_re = Some(watch_re),
Err(err) => {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Invalid watch regular expression: {}", err);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Invalid watch regular expression: {}", err);
}
}
}
@@ -288,10 +288,10 @@ impl ConfigTarget {
// debug!("Filter: {}", fltr);
self.t_filter = Some(fltr);
if let Some(renames) = self.rename.as_mut() {
handle_m3u_filter_error_result_list!(M3uFilterErrorKind::Info, renames.iter_mut().map(ConfigRename::prepare));
handle_tuliprox_error_result_list!(M3uFilterErrorKind::Info, renames.iter_mut().map(ConfigRename::prepare));
}
if let Some(sort) = self.sort.as_mut() {
handle_m3u_filter_error_result!(M3uFilterErrorKind::Info, sort.prepare());
handle_tuliprox_error_result!(M3uFilterErrorKind::Info, sort.prepare());
}
Ok(())
}
src/model/config_web_auth.rs
+3 -3
View File
@@ -3,7 +3,7 @@ use std::fs::File;
use std::io::BufRead;
use std::path::PathBuf;
use crate::auth::user::UserCredential;
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind, create_m3u_filter_error_result};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind, create_tuliprox_error_result};
use crate::utils::file_utils;
use crate::utils::file_utils::file_reader;
@@ -29,7 +29,7 @@ impl WebAuthConfig {
if !file_utils::path_exists(&userfile_path) {
userfile_path = PathBuf::from(config_path).join(&userfile_name);
if !file_utils::path_exists(&userfile_path) {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Could not find userfile {}", &userfile_name);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Could not find userfile {}", &userfile_name);
}
}
@@ -50,7 +50,7 @@ impl WebAuthConfig {
self.t_users = Some(users);
} else {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Could not read userfile {:?}", &userfile_path);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Could not read userfile {:?}", &userfile_path);
}
Ok(())
}
src/model/config_webui.rs
+1 -1
View File
@@ -1,5 +1,5 @@
use crate::utils::default_as_true;
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
use crate::model::WebAuthConfig;
const RESERVED_PATHS: &[&str] = &[
src/model/hdhomerun_config.rs
+3 -3
View File
@@ -1,6 +1,6 @@
use std::collections::HashSet;
use log::warn;
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind, create_m3u_filter_error_result};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind, create_tuliprox_error_result};
fn default_friendly_name() -> String { String::from("M3uFilterTV") }
fn default_manufacturer() -> String { String::from("Silicondust") }
fn default_model_name() -> String { String::from("HDTC-2US") }
@@ -80,11 +80,11 @@ impl HdHomeRunConfig {
device.prepare(device_num);
if names.contains(&device.name) {
names.insert(&device.name);
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "HdHomeRun duplicate device name {}", device.name);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "HdHomeRun duplicate device name {}", device.name);
}
if device.port > 0 && ports.contains(&device.port) {
ports.insert(device.port);
return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "HdHomeRun duplicate port {}", device.port);
return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "HdHomeRun duplicate port {}", device.port);
}
}
let mut current_port = api_port + 1;
src/model/mapping.rs
+7 -7
View File
@@ -9,8 +9,8 @@ use std::sync::atomic::AtomicU32;
use std::sync::Arc;
use crate::foundation::filter::{apply_templates_to_pattern, get_filter, prepare_templates, Filter, PatternTemplate, RegexWithCaptures, ValueProcessor};
use crate::m3u_filter_error::{create_m3u_filter_error_result, handle_m3u_filter_error_result, info_err};
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{create_tuliprox_error_result, handle_tuliprox_error_result, info_err};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
use crate::model::valid_property;
use crate::model::{ItemField};
use crate::model::{FieldGetAccessor, FieldSetAccessor, PlaylistItem};
@@ -84,7 +84,7 @@ impl FromStr for CounterModifier {
} else if s.eq("prefix") {
Ok(Self::Prefix)
} else {
create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Unknown CounterModifier: {}", s)
create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Unknown CounterModifier: {}", s)
}
}
}
@@ -156,7 +156,7 @@ impl FromStr for TransformModifier {
} else if s.eq("capitalize") {
Ok(Self::Capitalize)
} else {
create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "Unknown TransformModifier: {}", s)
create_tuliprox_error_result!(M3uFilterErrorKind::Info, "Unknown TransformModifier: {}", s)
}
}
}
@@ -184,7 +184,7 @@ impl MapperTransform {
}
match Regex::new(&new_pattern) {
Ok(pattern) => self.t_pattern = Some(pattern),
Err(err) => return create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {new_pattern} {err}"),
Err(err) => return create_tuliprox_error_result!(M3uFilterErrorKind::Info, "cant parse regex: {new_pattern} {err}"),
}
}
}
@@ -455,7 +455,7 @@ impl Mapping {
pub fn prepare(&mut self, templates: Option<&Vec<PatternTemplate>>,
tags: Option<&Vec<MappingTag>>) -> Result<(), M3uFilterError> {
for mapper in &mut self.mapper {
handle_m3u_filter_error_result!(M3uFilterErrorKind::Info, mapper.prepare(templates, tags));
handle_tuliprox_error_result!(M3uFilterErrorKind::Info, mapper.prepare(templates, tags));
}
if let Some(counter_def_list) = &self.counter {
@@ -505,7 +505,7 @@ impl MappingDefinition {
for mapping in &mut self.mapping {
let template_list = self.templates.as_ref();
let tag_list = self.tags.as_ref();
handle_m3u_filter_error_result!(M3uFilterErrorKind::Info, mapping.prepare(template_list, tag_list));
handle_tuliprox_error_result!(M3uFilterErrorKind::Info, mapping.prepare(template_list, tag_list));
}
Ok(())
}
src/modules.rs
+1 -1
View File
@@ -8,7 +8,7 @@ macro_rules! include_modules {
extern crate pest_derive;
pub mod api;
pub mod auth;
pub mod m3u_filter_error;
pub mod tuliprox_error;
pub mod messaging;
pub mod model;
pub mod processing;
src/processing/parser/xmltv.rs
+1 -1
View File
@@ -500,7 +500,7 @@ mod tests {
assert_eq!("odisea.bg", normalize_channel_name("BG | ODISEA ᵁᴴᴰ ³⁸⁴⁰ᴾ", &epg_smart_cfg));
}
use crate::m3u_filter_error::M3uFilterError;
use crate::tuliprox_error::M3uFilterError;
use rphonetic::{Encoder, Metaphone};
#[test]
src/processing/parser/xtream.rs
+4 -4
View File
@@ -1,4 +1,4 @@
use crate::m3u_filter_error::{create_m3u_filter_error_result, M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{create_tuliprox_error_result, M3uFilterError, M3uFilterErrorKind};
use crate::model::ConfigInput;
use crate::model::{PlaylistGroup, PlaylistItem, PlaylistItemHeader, PlaylistItemType, XtreamCluster};
use crate::model::{XtreamCategory, XtreamSeriesInfo, XtreamSeriesInfoEpisode, XtreamStream};
@@ -12,7 +12,7 @@ fn map_to_xtream_category(categories: &Value) -> Result<Vec<XtreamCategory>, M3u
match serde_json::from_value::<Vec<XtreamCategory>>(categories.to_owned()) {
Ok(xtream_categories) => Ok(xtream_categories),
Err(err) => {
create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed to process categories {}", &err)
create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed to process categories {}", &err)
}
}
}
@@ -21,7 +21,7 @@ fn map_to_xtream_streams(xtream_cluster: XtreamCluster, streams: &Value) -> Resu
match serde_json::from_value::<Vec<XtreamStream>>(streams.to_owned()) {
Ok(stream_list) => Ok(stream_list),
Err(err) => {
create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed to map to xtream streams {:?}: {}", xtream_cluster, &err)
create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed to map to xtream streams {:?}: {}", xtream_cluster, &err)
}
}
}
@@ -70,7 +70,7 @@ pub fn parse_xtream_series_info(info: &Value, group_title: &str, series_name: &s
Ok(None)
}
Err(err) => {
create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed to process series info for {series_name} {err}")
create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed to process series info for {series_name} {err}")
}
}
}
src/processing/processor/playlist.rs
+1 -1
View File
@@ -10,7 +10,7 @@ use std::thread;
use tokio::sync::Mutex;
use crate::foundation::filter::{get_field_value, set_field_value, MockValueProcessor, ValueProvider};
use crate::m3u_filter_error::{get_errors_notify_message, notify_err, M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{get_errors_notify_message, notify_err, M3uFilterError, M3uFilterErrorKind};
use crate::messaging::{send_message, MsgKind};
use crate::model::{ConfigTarget, InputType, ItemField, ProcessTargets, ProcessingOrder};
use crate::model::{CounterModifier, Mapping, MappingValueProcessor};
src/processing/processor/xtream.rs
+2 -2
View File
@@ -1,5 +1,5 @@
use crate::m3u_filter_error::{info_err, notify_err};
use crate::m3u_filter_error::{str_to_io_error, to_io_error, M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{info_err, notify_err};
use crate::tuliprox_error::{str_to_io_error, to_io_error, M3uFilterError, M3uFilterErrorKind};
use crate::model::{Config, ConfigInput};
use crate::model::{FetchedPlaylist, PlaylistEntry, PlaylistItem, PlaylistItemType, XtreamCluster};
use crate::repository::storage::get_input_storage_path;
src/processing/processor/xtream_series.rs
+2 -2
View File
@@ -1,4 +1,4 @@
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
use crate::model::{Config, ConfigTarget, InputType};
use crate::model::{FetchedPlaylist, PlaylistGroup, PlaylistItem, PlaylistItemType, XtreamCluster};
use crate::processing::processor::playlist::ProcessingPipe;
@@ -7,7 +7,7 @@ use crate::processing::processor::xtream::{create_resolve_episode_wal_files, cre
use crate::repository::storage::get_input_storage_path;
use crate::repository::xtream_repository::{xtream_get_info_file_paths, xtream_update_input_info_file, xtream_update_input_series_episodes_record_from_wal_file, xtream_update_input_series_record_from_wal_file};
use crate::repository::IndexedDocumentReader;
use crate::m3u_filter_error::{notify_err, info_err};
use crate::tuliprox_error::{notify_err, info_err};
use crate::processing::processor::{handle_error, handle_error_and_return, create_resolve_options_function_for_xtream_target};
use std::collections::HashMap;
use std::fs::File;
src/processing/processor/xtream_vod.rs
+2 -2
View File
@@ -1,9 +1,9 @@
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
use crate::model::{Config, ConfigTarget, InputType};
use crate::model::{FetchedPlaylist, PlaylistItem, PlaylistItemType, XtreamCluster};
use crate::processing::processor::xtream::{create_resolve_info_wal_files, playlist_resolve_download_playlist_item, read_processed_info_ids, should_update_info, write_info_content_to_wal_file};
use crate::repository::xtream_repository::{xtream_update_input_info_file, xtream_update_input_vod_record_from_wal_file, InputVodInfoRecord};
use crate::m3u_filter_error::{notify_err};
use crate::tuliprox_error::{notify_err};
use crate::processing::processor::{handle_error, handle_error_and_return, create_resolve_options_function_for_xtream_target};
use crate::utils::{get_u32_from_serde_value, get_u64_from_serde_value};
use serde_json::{Map, Value};
src/repository/bplustree.rs
+1 -1
View File
@@ -3,7 +3,7 @@ use std::io::{self, BufReader, Read, Seek, SeekFrom, Write};
use std::marker::PhantomData;
use std::mem::size_of;
use std::path::Path;
use crate::m3u_filter_error::{str_to_io_error, to_io_error};
use crate::tuliprox_error::{str_to_io_error, to_io_error};
use crate::utils::file_utils::{file_reader, file_writer, open_read_write_file, rename_or_copy};
use log::error;
use ruzstd::decoding::StreamingDecoder;
src/repository/epg_repository.rs
+1 -1
View File
@@ -1,4 +1,4 @@
use crate::m3u_filter_error::{notify_err, M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{notify_err, M3uFilterError, M3uFilterErrorKind};
use crate::model::{Config, ConfigTarget, TargetOutput};
use crate::model::Epg;
use crate::repository::m3u_repository::m3u_get_epg_file_path;
src/repository/indexed_document.rs
+1 -1
View File
@@ -9,7 +9,7 @@ use crate::utils::file_utils;
use log::error;
use serde::{Deserialize, Serialize};
use tempfile::NamedTempFile;
use crate::m3u_filter_error::{str_to_io_error, to_io_error};
use crate::tuliprox_error::{str_to_io_error, to_io_error};
use crate::utils::{bincode_deserialize, bincode_serialize};
use crate::utils::file_utils::{create_new_file_for_read_write, file_reader, file_writer, open_read_write_file, open_readonly_file, rename_or_copy};
src/repository/kodi_repository.rs
+3 -3
View File
@@ -1,5 +1,5 @@
use crate::m3u_filter_error::{create_m3u_filter_error_result, info_err};
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{create_tuliprox_error_result, info_err};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
use crate::model::{ApiProxyServerInfo, ProxyUserCredentials};
use crate::model::{ClusterFlags, Config, ConfigTarget, StrmTargetOutput};
use crate::model::{
@@ -408,7 +408,7 @@ async fn prepare_strm_output_directory(path: &Path) -> Result<(), M3uFilterError
// Ensure the directory exists
if let Err(e) = tokio::fs::create_dir_all(path).await {
error!("Failed to create directory {path:?}: {e}");
return create_m3u_filter_error_result!(
return create_tuliprox_error_result!(
M3uFilterErrorKind::Notify,
"Error creating STRM directory: {e}"
);
src/repository/m3u_playlist_iterator.rs
+2 -2
View File
@@ -1,5 +1,5 @@
use crate::m3u_filter_error::info_err;
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::info_err;
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
use crate::model::{ProxyType, ProxyUserCredentials};
use crate::model::{Config, ConfigTarget, ConfigTargetOptions, TargetType};
use crate::model::{M3uPlaylistItem, PlaylistItemType, XtreamCluster};
src/repository/m3u_repository.rs
+3 -3
View File
@@ -1,5 +1,5 @@
use crate::m3u_filter_error::{create_m3u_filter_error,info_err};
use crate::m3u_filter_error::{str_to_io_error, M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{create_tuliprox_error,info_err};
use crate::tuliprox_error::{str_to_io_error, M3uFilterError, M3uFilterErrorKind};
use crate::model::ProxyUserCredentials;
use crate::model::{Config, ConfigTarget, M3uTargetOutput};
use crate::model::{M3uPlaylistItem, PlaylistGroup, PlaylistItem, PlaylistItemType};
@@ -18,7 +18,7 @@ use crate::repository::storage_const;
macro_rules! cant_write_result {
($path:expr, $err:expr) => {
create_m3u_filter_error!(M3uFilterErrorKind::Notify, "failed to write m3u playlist: {} - {}", $path.to_str().unwrap() ,$err)
create_tuliprox_error!(M3uFilterErrorKind::Notify, "failed to write m3u playlist: {} - {}", $path.to_str().unwrap() ,$err)
}
}
src/repository/playlist_repository.rs
+2 -2
View File
@@ -1,5 +1,5 @@
use crate::m3u_filter_error::info_err;
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::info_err;
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
use crate::model::{Config, ConfigTarget, TargetOutput};
use crate::model::{PlaylistGroup, PlaylistItemType};
use crate::model::Epg;
src/repository/storage.rs
+2 -2
View File
@@ -1,9 +1,9 @@
use std::path::{Path, PathBuf};
use std::fmt::Write;
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
use crate::model::{Config};
use crate::model::UUIDType;
use crate::m3u_filter_error::{notify_err};
use crate::tuliprox_error::{notify_err};
use crate::repository::storage_const;
use crate::utils::file_utils;
src/repository/xtream_playlist_iterator.rs
+2 -2
View File
@@ -1,7 +1,7 @@
use std::collections::HashSet;
use log::error;
use crate::m3u_filter_error::info_err;
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::info_err;
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
use crate::model::{ProxyUserCredentials};
use crate::model::{Config, ConfigTarget, TargetType};
use crate::model::{XtreamCluster, XtreamPlaylistItem};
src/repository/xtream_repository.rs
+3 -3
View File
@@ -1,4 +1,4 @@
use crate::m3u_filter_error::{create_m3u_filter_error, create_m3u_filter_error_result, info_err, notify_err, str_to_io_error, M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{create_tuliprox_error, create_tuliprox_error_result, info_err, notify_err, str_to_io_error, M3uFilterError, M3uFilterErrorKind};
use crate::model::{ProxyUserCredentials};
use crate::model::{Config, ConfigInput, ConfigTarget, XtreamTargetOutput};
use crate::model::{PlaylistEntry, PlaylistGroup, PlaylistItem, PlaylistItemType, XtreamCluster, XtreamPlaylistItem};
@@ -31,7 +31,7 @@ use std::sync::Arc;
macro_rules! cant_write_result {
($path:expr, $err:expr) => {
create_m3u_filter_error!(
create_tuliprox_error!(
M3uFilterErrorKind::Notify,
"failed to write xtream playlist: {} - {}",
$path.to_str().unwrap(),
@@ -280,7 +280,7 @@ pub async fn xtream_write_playlist(
}
if !errors.is_empty() {
return create_m3u_filter_error_result!(
return create_tuliprox_error_result!(
M3uFilterErrorKind::Notify,
"{}",
errors.join("\n")
src/utils/bincode_utils.rs
+1 -1
View File
@@ -1,5 +1,5 @@
use std::io;
use crate::m3u_filter_error::to_io_error;
use crate::tuliprox_error::to_io_error;
#[inline]
pub fn bincode_serialize<T>(value: &T) -> io::Result<Vec<u8>>
src/utils/crypto_utils.rs
+1 -1
View File
@@ -1,4 +1,4 @@
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
use base64::{engine::general_purpose, Engine as _};
use openssl::symm::{Cipher, Crypter, Mode};
use rand::Rng;
src/utils/file/config_reader.rs
+5 -5
View File
@@ -1,4 +1,4 @@
use crate::m3u_filter_error::{create_m3u_filter_error, create_m3u_filter_error_result, handle_m3u_filter_error_result, info_err, str_to_io_error, to_io_error, M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{create_tuliprox_error, create_tuliprox_error_result, handle_tuliprox_error_result, info_err, str_to_io_error, to_io_error, M3uFilterError, M3uFilterErrorKind};
use crate::model::ApiProxyConfig;
use crate::model::{Config, ConfigDto, ConfigInput, ConfigInputAlias, InputType};
use crate::model::Mappings;
@@ -92,11 +92,11 @@ pub fn read_config(config_path: &str, config_file: &str, sources_file: &str, inc
}
}
Err(e) => {
create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "cant read config file: {}", e)
create_tuliprox_error_result!(M3uFilterErrorKind::Info, "cant read config file: {}", e)
}
}
}
Err(err) => create_m3u_filter_error_result!(M3uFilterErrorKind::Info, "{}", err)
Err(err) => create_tuliprox_error_result!(M3uFilterErrorKind::Info, "{}", err)
}
}
@@ -106,7 +106,7 @@ pub fn read_mapping(mapping_file: &str, resolve_var: bool) -> Result<Option<Mapp
let mapping: Result<Mappings, _> = serde_yaml::from_reader(config_file_reader(file, resolve_var));
return match mapping {
Ok(mut result) => {
handle_m3u_filter_error_result!(M3uFilterErrorKind::Info, result.prepare());
handle_tuliprox_error_result!(M3uFilterErrorKind::Info, result.prepare());
Ok(Some(result))
}
Err(err) => {
@@ -157,7 +157,7 @@ where
File::create(&path)
.and_then(|f| serde_yaml::to_writer(f, &config).map_err(to_io_error))
.map_err(|err| create_m3u_filter_error!(M3uFilterErrorKind::Info, "Could not write file {}: {}", &path.to_str().unwrap_or("?"), err))
.map_err(|err| create_tuliprox_error!(M3uFilterErrorKind::Info, "Could not write file {}: {}", &path.to_str().unwrap_or("?"), err))
}
pub fn save_api_proxy(file_path: &str, backup_dir: &str, config: &ApiProxyConfig) -> Result<(), M3uFilterError> {
src/utils/file/file_lock_manager.rs
+1 -1
View File
@@ -3,7 +3,7 @@ use std::sync::Arc;
use std::{fmt, io};
use std::path::{Path, PathBuf};
use tokio::sync::{Mutex, RwLock, RwLockReadGuard, RwLockWriteGuard};
use crate::m3u_filter_error::str_to_io_error;
use crate::tuliprox_error::str_to_io_error;
#[derive(Clone)]
pub struct FileLockManager {
src/utils/file/file_utils.rs
+1 -1
View File
@@ -4,7 +4,7 @@ use std::fs::{File, OpenOptions};
use std::io::{BufReader, BufWriter, Read, Write};
use std::path::{Path, PathBuf};
use crate::m3u_filter_error::str_to_io_error;
use crate::tuliprox_error::str_to_io_error;
use crate::utils::debug_if_enabled;
use log::{debug, error};
use path_clean::PathClean;
src/utils/network/epg.rs
+1 -1
View File
@@ -1,4 +1,4 @@
use crate::m3u_filter_error::M3uFilterError;
use crate::tuliprox_error::M3uFilterError;
use crate::model::{Config, ConfigInput};
use crate::model::TVGuide;
use crate::repository::storage::short_hash;
src/utils/network/ip_checker.rs
+1 -1
View File
@@ -1,4 +1,4 @@
use crate::m3u_filter_error::{M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::{M3uFilterError, M3uFilterErrorKind};
use crate::model::IpCheckConfig;
use regex::Regex;
use reqwest::Client;
src/utils/network/m3u.rs
+1 -1
View File
@@ -1,5 +1,5 @@
use std::sync::Arc;
use crate::m3u_filter_error::M3uFilterError;
use crate::tuliprox_error::M3uFilterError;
use crate::model::{Config, ConfigInput};
use crate::model::PlaylistGroup;
use crate::processing::parser::m3u;
src/utils/network/request.rs
+11 -11
View File
@@ -14,8 +14,8 @@ use reqwest::header::CONTENT_ENCODING;
use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
use url::Url;
use crate::m3u_filter_error::create_m3u_filter_error_result;
use crate::m3u_filter_error::{str_to_io_error, M3uFilterError, M3uFilterErrorKind};
use crate::tuliprox_error::create_tuliprox_error_result;
use crate::tuliprox_error::{str_to_io_error, M3uFilterError, M3uFilterErrorKind};
use crate::model::format_elapsed_time;
use crate::model::{ConfigInput, ProxyConfig, InputFetchMethod};
use crate::repository::storage::{get_input_storage_path, short_hash};
@@ -36,7 +36,7 @@ pub async fn get_input_text_content_as_file(client: Arc<reqwest::Client>, input:
Ok(content) => Ok(content),
Err(e) => {
error!("cant download input url: {} => {}", sanitize_sensitive_info(url_str), sanitize_sensitive_info(e.to_string().as_str()));
create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed to download")
create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed to download")
}
}
} else {
@@ -49,7 +49,7 @@ pub async fn get_input_text_content_as_file(client: Arc<reqwest::Client>, input:
Ok(_) => {}
Err(e) => {
error!("cant persist to: {} => {}", to_file.to_str().unwrap_or("?"), e);
return create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed to persist: {} => {}", to_file.to_str().unwrap_or("?"), e);
return create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed to persist: {} => {}", to_file.to_str().unwrap_or("?"), e);
}
}
}
@@ -57,7 +57,7 @@ pub async fn get_input_text_content_as_file(client: Arc<reqwest::Client>, input:
if filepath.exists() {
Some(filepath)
} else {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed: file does not exists {filepath:?}");
return create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed: file does not exists {filepath:?}");
}
} else {
None
@@ -69,7 +69,7 @@ pub async fn get_input_text_content_as_file(client: Arc<reqwest::Client>, input:
result.map_or_else(|| {
let msg = format!("cant read input url: {}", sanitize_sensitive_info(url_str));
error!("{msg}");
create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "{msg}")
create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "{msg}")
}, Ok)
}
}
@@ -83,7 +83,7 @@ pub async fn get_input_text_content(client: Arc<reqwest::Client>, input: &Config
Ok((content, _response_url)) => Ok(content),
Err(e) => {
error!("cant download input url: {} => {}", sanitize_sensitive_info(url_str), sanitize_sensitive_info(e.to_string().as_str()));
create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed to download")
create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed to download")
}
}
} else {
@@ -96,7 +96,7 @@ pub async fn get_input_text_content(client: Arc<reqwest::Client>, input: &Config
Ok(_) => {}
Err(e) => {
error!("cant persist to: {} => {}", to_file.to_str().unwrap_or("?"), e);
return create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed to persist: {} => {}", to_file.to_str().unwrap_or("?"), e);
return create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed to persist: {} => {}", to_file.to_str().unwrap_or("?"), e);
}
}
}
@@ -104,7 +104,7 @@ pub async fn get_input_text_content(client: Arc<reqwest::Client>, input: &Config
match get_local_file_content(&filepath) {
Ok(content) => Some(content),
Err(err) => {
return create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "Failed : {}", err);
return create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "Failed : {}", err);
}
}
} else {
@@ -116,7 +116,7 @@ pub async fn get_input_text_content(client: Arc<reqwest::Client>, input: &Config
result.map_or_else(|| {
let msg = format!("cant read input url: {}", sanitize_sensitive_info(url_str));
error!("{msg}");
create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "{msg}")
create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "{msg}")
}, Ok)
}
}
@@ -363,7 +363,7 @@ async fn download_json_content(client: Arc<reqwest::Client>, input: &ConfigInput
pub async fn get_input_json_content(client: Arc<reqwest::Client>, input: &ConfigInput, url: &str, persist_filepath: Option<PathBuf>) -> Result<serde_json::Value, M3uFilterError> {
match download_json_content(client, input, url, persist_filepath).await {
Ok(content) => Ok(content),
Err(e) => create_m3u_filter_error_result!(M3uFilterErrorKind::Notify, "cant download input url: {} => {}", sanitize_sensitive_info(url), sanitize_sensitive_info(e.to_string().as_str()))
Err(e) => create_tuliprox_error_result!(M3uFilterErrorKind::Notify, "cant download input url: {} => {}", sanitize_sensitive_info(url), sanitize_sensitive_info(e.to_string().as_str()))
}
}
src/utils/network/xtream.rs
+1 -1
View File
@@ -1,5 +1,5 @@
use std::sync::Arc;
use crate::m3u_filter_error::{str_to_io_error, M3uFilterError};
use crate::tuliprox_error::{str_to_io_error, M3uFilterError};
use crate::model::{Config, ConfigInput, ConfigTarget};
use crate::model::{PlaylistEntry, PlaylistGroup, XtreamCluster, XtreamPlaylistItem};
use crate::processing::parser::xtream;