315 lines
9 KiB
Rust
315 lines
9 KiB
Rust
use std::{
|
|
fs::File,
|
|
future::Future,
|
|
io::BufReader,
|
|
path::{Path, PathBuf},
|
|
sync::Arc,
|
|
};
|
|
|
|
use anyhow::Result;
|
|
use chrono::{DateTime, Duration, Utc};
|
|
use log::{error, info};
|
|
use serde::{Deserialize, Serialize};
|
|
use tokio::sync::Mutex;
|
|
|
|
#[derive(Default, Debug, Clone)]
|
|
pub struct Cache {
|
|
file: Option<PathBuf>,
|
|
data: Arc<Mutex<CacheData>>,
|
|
}
|
|
|
|
#[derive(Default, Debug, Clone, Serialize, Deserialize)]
|
|
struct CacheData {
|
|
desktop_client: Option<CacheEntry<DesktopClientData>>,
|
|
deobf: Option<CacheEntry<DeobfData>>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
struct CacheEntry<T> {
|
|
last_update: DateTime<Utc>,
|
|
data: T,
|
|
}
|
|
|
|
impl<T> From<T> for CacheEntry<T> {
|
|
fn from(f: T) -> Self {
|
|
Self {
|
|
last_update: Utc::now(),
|
|
data: f,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
|
pub struct DesktopClientData {
|
|
pub client_version: String,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
|
pub struct DeobfData {
|
|
pub js_url: String,
|
|
pub sig_fn: String,
|
|
pub nsig_fn: String,
|
|
pub sts: String,
|
|
}
|
|
|
|
impl Cache {
|
|
pub async fn get_desktop_client_data<F>(&self, updater: F) -> Result<DesktopClientData>
|
|
where
|
|
F: Future<Output = Result<DesktopClientData>> + Send + 'static,
|
|
{
|
|
let mut cache = self.data.lock().await;
|
|
|
|
if cache.desktop_client.is_none()
|
|
|| cache.desktop_client.as_ref().unwrap().last_update < Utc::now() - Duration::hours(24)
|
|
{
|
|
let cdata = updater.await?;
|
|
cache.desktop_client = Some(CacheEntry::from(cdata.clone()));
|
|
self.save(&cache);
|
|
Ok(cdata)
|
|
} else {
|
|
Ok(cache.desktop_client.as_ref().unwrap().data.clone())
|
|
}
|
|
}
|
|
|
|
pub async fn get_deobf_data<F>(&self, updater: F) -> Result<DeobfData>
|
|
where
|
|
F: Future<Output = Result<DeobfData>> + Send + 'static,
|
|
{
|
|
let mut cache = self.data.lock().await;
|
|
if cache.deobf.is_none()
|
|
|| cache.deobf.as_ref().unwrap().last_update < Utc::now() - Duration::hours(1)
|
|
{
|
|
let deobf_data = updater.await?;
|
|
cache.deobf = Some(CacheEntry::from(deobf_data.clone()));
|
|
self.save(&cache);
|
|
Ok(deobf_data)
|
|
} else {
|
|
Ok(cache.deobf.as_ref().unwrap().data.clone())
|
|
}
|
|
}
|
|
|
|
pub async fn to_json(&self) -> Result<String> {
|
|
let cache = self.data.lock().await;
|
|
Ok(serde_json::to_string(&cache.clone())?)
|
|
}
|
|
|
|
pub async fn to_json_file<P: AsRef<Path>>(&self, path: P) -> Result<()> {
|
|
let cache = self.data.lock().await;
|
|
Ok(serde_json::to_writer(&File::create(path)?, &cache.clone())?)
|
|
}
|
|
|
|
pub fn from_json(json: &str) -> Self {
|
|
let data: CacheData = match serde_json::from_str(json) {
|
|
Ok(cd) => cd,
|
|
Err(e) => {
|
|
error!(
|
|
"Could not load cache from json, falling back to default. Error: {}",
|
|
e
|
|
);
|
|
CacheData::default()
|
|
}
|
|
};
|
|
Cache {
|
|
data: Arc::new(Mutex::new(data)),
|
|
file: None,
|
|
}
|
|
}
|
|
|
|
pub fn from_json_file<P: AsRef<Path>>(path: P) -> Self {
|
|
let file = match File::open(path.as_ref()) {
|
|
Ok(file) => file,
|
|
Err(e) => {
|
|
if e.kind() == std::io::ErrorKind::NotFound {
|
|
info!(
|
|
"Cache json file at {} not found, will be created",
|
|
path.as_ref().to_string_lossy()
|
|
)
|
|
} else {
|
|
error!(
|
|
"Could not open cache json file, falling back to default. Error: {}",
|
|
e
|
|
);
|
|
}
|
|
return Cache {
|
|
file: Some(path.as_ref().to_path_buf()),
|
|
..Default::default()
|
|
};
|
|
}
|
|
};
|
|
let data: CacheData = match serde_json::from_reader(BufReader::new(file)) {
|
|
Ok(data) => data,
|
|
Err(e) => {
|
|
error!(
|
|
"Could not load cache from json, falling back to default. Error: {}",
|
|
e
|
|
);
|
|
return Cache {
|
|
file: Some(path.as_ref().to_path_buf()),
|
|
..Default::default()
|
|
};
|
|
}
|
|
};
|
|
Cache {
|
|
data: Arc::new(Mutex::new(data)),
|
|
file: Some(path.as_ref().to_path_buf()),
|
|
}
|
|
}
|
|
|
|
fn save(&self, cache: &CacheData) {
|
|
match self.file.as_ref() {
|
|
Some(file) => match File::create(file) {
|
|
Ok(file) => match serde_json::to_writer(file, cache) {
|
|
Ok(_) => {}
|
|
Err(e) => error!("Could not write cache to json. Error: {}", e),
|
|
},
|
|
Err(e) => error!("Could not open cache json file. Error: {}", e),
|
|
},
|
|
None => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use temp_testdir::TempDir;
|
|
|
|
use super::*;
|
|
|
|
#[tokio::test]
|
|
async fn test() {
|
|
let cache = Cache::default();
|
|
|
|
let cdata = cache
|
|
.get_desktop_client_data(async {
|
|
Ok(DesktopClientData {
|
|
client_version: "1.2.3".to_owned(),
|
|
})
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
cdata,
|
|
DesktopClientData {
|
|
client_version: "1.2.3".to_owned()
|
|
}
|
|
);
|
|
|
|
let deobf_data = cache
|
|
.get_deobf_data(async {
|
|
Ok(DeobfData {
|
|
js_url:
|
|
"https://www.youtube.com/s/player/011af516/player_ias.vflset/en_US/base.js"
|
|
.to_owned(),
|
|
sig_fn: "t_sig_fn".to_owned(),
|
|
nsig_fn: "t_nsig_fn".to_owned(),
|
|
sts: "t_sts".to_owned(),
|
|
})
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
assert_eq!(
|
|
deobf_data,
|
|
DeobfData {
|
|
js_url: "https://www.youtube.com/s/player/011af516/player_ias.vflset/en_US/base.js"
|
|
.to_owned(),
|
|
sig_fn: "t_sig_fn".to_owned(),
|
|
nsig_fn: "t_nsig_fn".to_owned(),
|
|
sts: "t_sts".to_owned(),
|
|
}
|
|
);
|
|
|
|
let json = cache.to_json().await.unwrap();
|
|
let new_cache = Cache::from_json(&json);
|
|
|
|
assert_eq!(
|
|
new_cache
|
|
.get_desktop_client_data(async {
|
|
Ok(DesktopClientData {
|
|
client_version: "".to_owned(),
|
|
})
|
|
})
|
|
.await
|
|
.unwrap(),
|
|
cdata
|
|
);
|
|
|
|
assert_eq!(
|
|
new_cache
|
|
.get_deobf_data(async {
|
|
Ok(DeobfData {
|
|
js_url: "".to_owned(),
|
|
nsig_fn: "".to_owned(),
|
|
sig_fn: "".to_owned(),
|
|
sts: "".to_owned(),
|
|
})
|
|
})
|
|
.await
|
|
.unwrap(),
|
|
deobf_data
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_file() {
|
|
let temp = TempDir::default();
|
|
let mut file_path = PathBuf::from(temp.as_ref());
|
|
file_path.push("cache.json");
|
|
|
|
let cache = Cache::from_json_file(file_path.clone());
|
|
|
|
let cdata = cache
|
|
.get_desktop_client_data(async {
|
|
Ok(DesktopClientData {
|
|
client_version: "1.2.3".to_owned(),
|
|
})
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
let deobf_data = cache
|
|
.get_deobf_data(async {
|
|
Ok(DeobfData {
|
|
js_url:
|
|
"https://www.youtube.com/s/player/011af516/player_ias.vflset/en_US/base.js"
|
|
.to_owned(),
|
|
sig_fn: "t_sig_fn".to_owned(),
|
|
nsig_fn: "t_nsig_fn".to_owned(),
|
|
sts: "t_sts".to_owned(),
|
|
})
|
|
})
|
|
.await
|
|
.unwrap();
|
|
|
|
assert!(file_path.exists());
|
|
let new_cache = Cache::from_json_file(file_path.clone());
|
|
|
|
assert_eq!(
|
|
new_cache
|
|
.get_desktop_client_data(async {
|
|
Ok(DesktopClientData {
|
|
client_version: "".to_owned(),
|
|
})
|
|
})
|
|
.await
|
|
.unwrap(),
|
|
cdata
|
|
);
|
|
|
|
assert_eq!(
|
|
new_cache
|
|
.get_deobf_data(async {
|
|
Ok(DeobfData {
|
|
js_url: "".to_owned(),
|
|
nsig_fn: "".to_owned(),
|
|
sig_fn: "".to_owned(),
|
|
sts: "".to_owned(),
|
|
})
|
|
})
|
|
.await
|
|
.unwrap(),
|
|
deobf_data
|
|
);
|
|
}
|
|
}
|