725 lines
22 KiB
Rust
725 lines
22 KiB
Rust
pub mod player;
|
|
pub mod playlist;
|
|
mod response;
|
|
|
|
use std::sync::Arc;
|
|
|
|
use anyhow::{anyhow, Context, Result};
|
|
use async_trait::async_trait;
|
|
use fancy_regex::Regex;
|
|
use log::warn;
|
|
use once_cell::sync::Lazy;
|
|
use rand::Rng;
|
|
use reqwest::{header, Client, ClientBuilder, Method, Request, RequestBuilder, Response};
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use crate::{
|
|
cache::{Cache, ClientData},
|
|
model::Locale,
|
|
util,
|
|
};
|
|
|
|
pub const CLIENT_TYPES: [ClientType; 5] = [
|
|
ClientType::Desktop,
|
|
ClientType::DesktopMusic,
|
|
ClientType::TvHtml5Embed,
|
|
ClientType::Android,
|
|
ClientType::Ios,
|
|
];
|
|
|
|
#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
|
|
#[serde(rename_all = "snake_case")]
|
|
pub enum ClientType {
|
|
Desktop,
|
|
DesktopMusic,
|
|
TvHtml5Embed,
|
|
Android,
|
|
Ios,
|
|
}
|
|
|
|
impl ClientType {
|
|
pub fn is_web(self) -> bool {
|
|
self == Self::Desktop || self == Self::DesktopMusic || self == Self::TvHtml5Embed
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct ContextYT {
|
|
client: ClientInfo,
|
|
/// only used on desktop
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
request: Option<RequestYT>,
|
|
user: User,
|
|
/// only used for the embedded player
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
third_party: Option<ThirdParty>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
struct ClientInfo {
|
|
client_name: String,
|
|
client_version: String,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
client_screen: Option<String>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
device_model: Option<String>,
|
|
platform: String,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
original_url: Option<String>,
|
|
/// Language (`en`, `de`)
|
|
hl: String,
|
|
/// Country (`US`, `DE`)
|
|
gl: String,
|
|
}
|
|
|
|
#[derive(Clone, Debug, Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
struct RequestYT {
|
|
internal_experiment_flags: Vec<String>,
|
|
use_ssl: bool,
|
|
}
|
|
|
|
impl Default for RequestYT {
|
|
fn default() -> Self {
|
|
Self {
|
|
internal_experiment_flags: vec![],
|
|
use_ssl: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, Serialize, Default)]
|
|
#[serde(rename_all = "camelCase")]
|
|
struct User {
|
|
// TO DO: provide a way to enable restricted mode with:
|
|
// "enableSafetyMode": true
|
|
locked_safety_mode: bool,
|
|
}
|
|
|
|
#[derive(Clone, Debug, Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
struct ThirdParty {
|
|
embed_url: String,
|
|
}
|
|
|
|
const DEFAULT_UA: &str =
|
|
"Mozilla/5.0 (Windows NT 10.0; Win64; rv:107.0) Gecko/20100101 Firefox/107.0";
|
|
|
|
const CONSENT_COOKIE: &str = "CONSENT";
|
|
const CONSENT_COOKIE_YES: &str = "YES+yt.462272069.de+FX+";
|
|
const CONSENT_COOKIE_NO: &str = "PENDING+";
|
|
|
|
const YOUTUBEI_V1_URL: &str = "https://www.youtube.com/youtubei/v1/";
|
|
const YOUTUBEI_V1_GAPIS_URL: &str = "https://youtubei.googleapis.com/youtubei/v1/";
|
|
const YOUTUBE_MUSIC_V1_URL: &str = "https://music.youtube.com/youtubei/v1/";
|
|
|
|
const DISABLE_PRETTY_PRINT_PARAMETER: &str = "&prettyPrint=false";
|
|
|
|
const DESKTOP_CLIENT_VERSION: &str = "2.20220801.00.00";
|
|
const DESKTOP_API_KEY: &str = "AIzaSyAO_FJ2SlqU8Q4STEHLGCilw_Y9_11qcW8";
|
|
const TVHTML5_CLIENT_VERSION: &str = "2.0";
|
|
const DESKTOP_MUSIC_API_KEY: &str = "AIzaSyC9XL3ZjWddXya6X74dJoCTL-WEYFDNX30";
|
|
const DESKTOP_MUSIC_CLIENT_VERSION: &str = "1.20220727.01.00";
|
|
|
|
const MOBILE_CLIENT_VERSION: &str = "17.29.35";
|
|
const ANDROID_API_KEY: &str = "AIzaSyA8eiZmM1FaDVjRy-df2KTyQ_vz_yYM39w";
|
|
const IOS_API_KEY: &str = "AIzaSyB-63vPrdThhKuerbB2N_l7Kwwcxj6yUAc";
|
|
const IOS_DEVICE_MODEL: &str = "iPhone14,5";
|
|
|
|
const CLIENT_VERSION_REGEXES: Lazy<[Regex; 3]> = Lazy::new(|| {
|
|
[
|
|
Regex::new("INNERTUBE_CONTEXT_CLIENT_VERSION\":\"([0-9\\.]+?)\"").unwrap(),
|
|
Regex::new("innertube_context_client_version\":\"([0-9\\.]+?)\"").unwrap(),
|
|
Regex::new("client.version=([0-9\\.]+)").unwrap(),
|
|
]
|
|
});
|
|
|
|
pub struct RustyTube {
|
|
pub locale: Arc<Locale>,
|
|
cache: Cache,
|
|
desktop_client: Arc<DesktopClient>,
|
|
desktop_music_client: Arc<DesktopMusicClient>,
|
|
android_client: Arc<AndroidClient>,
|
|
ios_client: Arc<IosClient>,
|
|
tvhtml5embed_client: Arc<TvHtml5EmbedClient>,
|
|
}
|
|
|
|
impl RustyTube {
|
|
#[must_use]
|
|
pub fn new() -> Self {
|
|
Self::new_with_ua("en", "US", Some("rusty-tube.json".to_owned()))
|
|
}
|
|
|
|
#[must_use]
|
|
pub fn new_with_ua(lang: &str, country: &str, cache_file: Option<String>) -> Self {
|
|
let locale = Arc::new(Locale {
|
|
lang: lang.to_owned(),
|
|
country: country.to_owned(),
|
|
});
|
|
|
|
let cache = match cache_file.as_ref() {
|
|
Some(cache_file) => Cache::from_json_file(cache_file),
|
|
None => Cache::default(),
|
|
};
|
|
|
|
Self {
|
|
locale: locale.clone(),
|
|
cache: cache.clone(),
|
|
desktop_client: Arc::new(DesktopClient::new(locale.clone(), cache.clone())),
|
|
desktop_music_client: Arc::new(DesktopMusicClient::new(locale.clone(), cache)),
|
|
android_client: Arc::new(AndroidClient::new(locale.clone())),
|
|
ios_client: Arc::new(IosClient::new(locale.clone())),
|
|
tvhtml5embed_client: Arc::new(TvHtml5EmbedClient::new(locale)),
|
|
}
|
|
}
|
|
|
|
fn get_ytclient(&self, client_type: ClientType) -> Arc<dyn YTClient> {
|
|
match client_type {
|
|
ClientType::Desktop => self.desktop_client.clone(),
|
|
ClientType::DesktopMusic => self.desktop_music_client.clone(),
|
|
ClientType::TvHtml5Embed => self.tvhtml5embed_client.clone(),
|
|
ClientType::Android => self.android_client.clone(),
|
|
ClientType::Ios => self.ios_client.clone(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
pub trait YTClient {
|
|
async fn get_context(&self, localized: bool) -> ContextYT;
|
|
async fn request_builder(&self, method: Method, url: &str) -> RequestBuilder;
|
|
fn http_client(&self) -> Client;
|
|
fn get_type(&self) -> ClientType;
|
|
}
|
|
|
|
async fn exec_request(http: Client, request: Request) -> Result<Response> {
|
|
Ok(http.execute(request).await?.error_for_status()?)
|
|
}
|
|
|
|
async fn exec_request_text(http: Client, request: Request) -> Result<String> {
|
|
Ok(exec_request(http, request).await?.text().await?)
|
|
}
|
|
|
|
pub struct DesktopClient {
|
|
locale: Arc<Locale>,
|
|
http: Client,
|
|
cache: Cache,
|
|
consent_cookie: String,
|
|
}
|
|
|
|
#[async_trait]
|
|
impl YTClient for DesktopClient {
|
|
async fn get_context(&self, localized: bool) -> ContextYT {
|
|
ContextYT {
|
|
client: ClientInfo {
|
|
client_name: "WEB".to_owned(),
|
|
client_version: self.get_client_version().await,
|
|
client_screen: None,
|
|
device_model: None,
|
|
platform: "DESKTOP".to_owned(),
|
|
original_url: Some("https://www.youtube.com/".to_owned()),
|
|
hl: match localized {
|
|
true => self.locale.lang.to_owned(),
|
|
false => "en".to_owned(),
|
|
},
|
|
gl: match localized {
|
|
true => self.locale.country.to_owned(),
|
|
false => "US".to_owned(),
|
|
},
|
|
},
|
|
request: Some(RequestYT::default()),
|
|
user: User::default(),
|
|
third_party: None,
|
|
}
|
|
}
|
|
|
|
async fn request_builder(&self, method: Method, endpoint: &str) -> RequestBuilder {
|
|
self.http
|
|
.request(
|
|
method,
|
|
format!(
|
|
"{}{}?key={}{}",
|
|
YOUTUBEI_V1_URL, endpoint, DESKTOP_API_KEY, DISABLE_PRETTY_PRINT_PARAMETER
|
|
),
|
|
)
|
|
.header(header::ORIGIN, "https://www.youtube.com")
|
|
.header(header::REFERER, "https://www.youtube.com")
|
|
.header(header::COOKIE, self.consent_cookie.to_owned())
|
|
.header("X-YouTube-Client-Name", "1")
|
|
.header("X-YouTube-Client-Version", self.get_client_version().await)
|
|
}
|
|
|
|
fn http_client(&self) -> Client {
|
|
self.http.clone()
|
|
}
|
|
|
|
fn get_type(&self) -> ClientType {
|
|
ClientType::Desktop
|
|
}
|
|
}
|
|
|
|
impl DesktopClient {
|
|
fn new(locale: Arc<Locale>, cache: Cache) -> Self {
|
|
let mut rng = rand::thread_rng();
|
|
|
|
let http = ClientBuilder::new()
|
|
.user_agent(DEFAULT_UA)
|
|
.gzip(true)
|
|
.brotli(true)
|
|
.build()
|
|
.expect("unable to build the HTTP client");
|
|
|
|
Self {
|
|
locale,
|
|
http,
|
|
cache,
|
|
consent_cookie: format!(
|
|
"{}={}{}",
|
|
CONSENT_COOKIE,
|
|
CONSENT_COOKIE_YES,
|
|
rng.gen_range(100..1000)
|
|
),
|
|
}
|
|
}
|
|
|
|
async fn extract_client_version_from_swjs(
|
|
http: Client,
|
|
consent_cookie: &str,
|
|
) -> Result<String> {
|
|
let swjs = exec_request_text(
|
|
http.clone(),
|
|
http.get("https://www.youtube.com/sw.js")
|
|
.header(header::ORIGIN, "https://www.youtube.com")
|
|
.header(header::REFERER, "https://www.youtube.com")
|
|
.header(header::COOKIE, consent_cookie)
|
|
.build()
|
|
.unwrap(),
|
|
)
|
|
.await
|
|
.context("Failed to download sw.js")?;
|
|
|
|
util::get_cg_from_regexes(CLIENT_VERSION_REGEXES.iter(), &swjs, 1)
|
|
.ok_or(anyhow!("Could not find desktop client version in sw.js"))
|
|
}
|
|
|
|
async fn get_client_version(&self) -> String {
|
|
let http = self.http.clone();
|
|
let consent_cookie = self.consent_cookie.clone();
|
|
|
|
let client_data = self
|
|
.cache
|
|
.get_desktop_client_data(async move {
|
|
let client_version =
|
|
Self::extract_client_version_from_swjs(http, &consent_cookie).await?;
|
|
Ok(ClientData {
|
|
version: client_version,
|
|
})
|
|
})
|
|
.await;
|
|
|
|
match client_data {
|
|
Ok(client_data) => client_data.version,
|
|
Err(e) => {
|
|
warn!("{}", e);
|
|
DESKTOP_CLIENT_VERSION.to_owned()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct AndroidClient {
|
|
locale: Arc<Locale>,
|
|
http: Client,
|
|
}
|
|
|
|
#[async_trait]
|
|
impl YTClient for AndroidClient {
|
|
async fn get_context(&self, localized: bool) -> ContextYT {
|
|
ContextYT {
|
|
client: ClientInfo {
|
|
client_name: "ANDROID".to_owned(),
|
|
client_version: MOBILE_CLIENT_VERSION.to_owned(),
|
|
client_screen: None,
|
|
device_model: None,
|
|
platform: "MOBILE".to_owned(),
|
|
original_url: None,
|
|
hl: match localized {
|
|
true => self.locale.lang.to_owned(),
|
|
false => "en".to_owned(),
|
|
},
|
|
gl: match localized {
|
|
true => self.locale.country.to_owned(),
|
|
false => "US".to_owned(),
|
|
},
|
|
},
|
|
request: None,
|
|
user: User::default(),
|
|
third_party: None,
|
|
}
|
|
}
|
|
|
|
async fn request_builder(&self, method: Method, endpoint: &str) -> RequestBuilder {
|
|
self.http
|
|
.request(
|
|
method,
|
|
format!(
|
|
"{}{}?key={}{}",
|
|
YOUTUBEI_V1_GAPIS_URL,
|
|
endpoint,
|
|
ANDROID_API_KEY,
|
|
DISABLE_PRETTY_PRINT_PARAMETER
|
|
),
|
|
)
|
|
.header("X-Goog-Api-Format-Version", "2")
|
|
}
|
|
|
|
fn http_client(&self) -> Client {
|
|
self.http.clone()
|
|
}
|
|
|
|
fn get_type(&self) -> ClientType {
|
|
ClientType::Android
|
|
}
|
|
}
|
|
|
|
impl AndroidClient {
|
|
fn new(locale: Arc<Locale>) -> Self {
|
|
let http = ClientBuilder::new()
|
|
.user_agent(format!(
|
|
"com.google.android.youtube/{} (Linux; U; Android 12; {}) gzip",
|
|
MOBILE_CLIENT_VERSION, locale.country
|
|
))
|
|
.gzip(true)
|
|
.brotli(true)
|
|
.build()
|
|
.expect("unable to build the HTTP client");
|
|
|
|
Self { locale, http }
|
|
}
|
|
}
|
|
|
|
pub struct IosClient {
|
|
locale: Arc<Locale>,
|
|
http: Client,
|
|
}
|
|
|
|
#[async_trait]
|
|
impl YTClient for IosClient {
|
|
async fn get_context(&self, localized: bool) -> ContextYT {
|
|
ContextYT {
|
|
client: ClientInfo {
|
|
client_name: "IOS".to_owned(),
|
|
client_version: MOBILE_CLIENT_VERSION.to_owned(),
|
|
client_screen: None,
|
|
device_model: Some(IOS_DEVICE_MODEL.to_owned()),
|
|
platform: "MOBILE".to_owned(),
|
|
original_url: None,
|
|
hl: match localized {
|
|
true => self.locale.lang.to_owned(),
|
|
false => "en".to_owned(),
|
|
},
|
|
gl: match localized {
|
|
true => self.locale.country.to_owned(),
|
|
false => "US".to_owned(),
|
|
},
|
|
},
|
|
request: None,
|
|
user: User::default(),
|
|
third_party: None,
|
|
}
|
|
}
|
|
|
|
async fn request_builder(&self, method: Method, endpoint: &str) -> RequestBuilder {
|
|
self.http
|
|
.request(
|
|
method,
|
|
format!(
|
|
"{}{}?key={}{}",
|
|
YOUTUBEI_V1_GAPIS_URL, endpoint, IOS_API_KEY, DISABLE_PRETTY_PRINT_PARAMETER
|
|
),
|
|
)
|
|
.header("X-Goog-Api-Format-Version", "2")
|
|
}
|
|
|
|
fn http_client(&self) -> Client {
|
|
self.http.clone()
|
|
}
|
|
|
|
fn get_type(&self) -> ClientType {
|
|
ClientType::Ios
|
|
}
|
|
}
|
|
|
|
impl IosClient {
|
|
fn new(locale: Arc<Locale>) -> Self {
|
|
let http = ClientBuilder::new()
|
|
.user_agent(format!(
|
|
"com.google.ios.youtube/{} ({}; U; CPU iOS 15_4 like Mac OS X; {})",
|
|
MOBILE_CLIENT_VERSION, IOS_DEVICE_MODEL, locale.country
|
|
))
|
|
.gzip(true)
|
|
.brotli(true)
|
|
.build()
|
|
.expect("unable to build the HTTP client");
|
|
|
|
Self { locale, http }
|
|
}
|
|
}
|
|
|
|
pub struct TvHtml5EmbedClient {
|
|
locale: Arc<Locale>,
|
|
http: Client,
|
|
}
|
|
|
|
#[async_trait]
|
|
impl YTClient for TvHtml5EmbedClient {
|
|
async fn get_context(&self, localized: bool) -> ContextYT {
|
|
ContextYT {
|
|
client: ClientInfo {
|
|
client_name: "TVHTML5_SIMPLY_EMBEDDED_PLAYER".to_owned(),
|
|
client_version: TVHTML5_CLIENT_VERSION.to_owned(),
|
|
client_screen: Some("EMBED".to_owned()),
|
|
device_model: None,
|
|
platform: "TV".to_owned(),
|
|
original_url: None,
|
|
hl: match localized {
|
|
true => self.locale.lang.to_owned(),
|
|
false => "en".to_owned(),
|
|
},
|
|
gl: match localized {
|
|
true => self.locale.country.to_owned(),
|
|
false => "US".to_owned(),
|
|
},
|
|
},
|
|
request: Some(RequestYT::default()),
|
|
user: User::default(),
|
|
third_party: Some(ThirdParty {
|
|
embed_url: "https://www.youtube.com/".to_owned(),
|
|
}),
|
|
}
|
|
}
|
|
|
|
async fn request_builder(&self, method: Method, endpoint: &str) -> RequestBuilder {
|
|
self.http
|
|
.request(
|
|
method,
|
|
format!(
|
|
"{}{}?key={}{}",
|
|
YOUTUBEI_V1_URL, endpoint, DESKTOP_API_KEY, DISABLE_PRETTY_PRINT_PARAMETER
|
|
),
|
|
)
|
|
.header(header::ORIGIN, "https://www.youtube.com")
|
|
.header(header::REFERER, "https://www.youtube.com")
|
|
// .header(header::COOKIE, self.consent_cookie_no.to_owned())
|
|
.header("X-YouTube-Client-Name", "1")
|
|
.header("X-YouTube-Client-Version", TVHTML5_CLIENT_VERSION)
|
|
}
|
|
|
|
fn http_client(&self) -> Client {
|
|
self.http.clone()
|
|
}
|
|
|
|
fn get_type(&self) -> ClientType {
|
|
ClientType::TvHtml5Embed
|
|
}
|
|
}
|
|
|
|
impl TvHtml5EmbedClient {
|
|
fn new(locale: Arc<Locale>) -> Self {
|
|
let http = ClientBuilder::new()
|
|
.user_agent(DEFAULT_UA)
|
|
.gzip(true)
|
|
.brotli(true)
|
|
.build()
|
|
.expect("unable to build the HTTP client");
|
|
|
|
Self { locale, http }
|
|
}
|
|
}
|
|
|
|
pub struct DesktopMusicClient {
|
|
locale: Arc<Locale>,
|
|
http: Client,
|
|
cache: Cache,
|
|
consent_cookie: String,
|
|
}
|
|
|
|
#[async_trait]
|
|
impl YTClient for DesktopMusicClient {
|
|
async fn get_context(&self, localized: bool) -> ContextYT {
|
|
ContextYT {
|
|
client: ClientInfo {
|
|
client_name: "WEB_REMIX".to_owned(),
|
|
client_version: self.get_client_version().await,
|
|
client_screen: None,
|
|
device_model: None,
|
|
platform: "DESKTOP".to_owned(),
|
|
original_url: Some("https://music.youtube.com/".to_owned()),
|
|
hl: match localized {
|
|
true => self.locale.lang.to_owned(),
|
|
false => "en".to_owned(),
|
|
},
|
|
gl: match localized {
|
|
true => self.locale.country.to_owned(),
|
|
false => "US".to_owned(),
|
|
},
|
|
},
|
|
request: Some(RequestYT::default()),
|
|
user: User::default(),
|
|
third_party: None,
|
|
}
|
|
}
|
|
|
|
async fn request_builder(&self, method: Method, endpoint: &str) -> RequestBuilder {
|
|
self.http
|
|
.request(
|
|
method,
|
|
format!(
|
|
"{}{}?key={}{}",
|
|
YOUTUBE_MUSIC_V1_URL,
|
|
endpoint,
|
|
DESKTOP_MUSIC_API_KEY,
|
|
DISABLE_PRETTY_PRINT_PARAMETER
|
|
),
|
|
)
|
|
.header(header::ORIGIN, "https://music.youtube.com")
|
|
.header(header::REFERER, "https://music.youtube.com")
|
|
.header(header::COOKIE, self.consent_cookie.to_owned())
|
|
.header("X-YouTube-Client-Name", "67")
|
|
.header("X-YouTube-Client-Version", self.get_client_version().await)
|
|
}
|
|
|
|
fn http_client(&self) -> Client {
|
|
self.http.clone()
|
|
}
|
|
|
|
fn get_type(&self) -> ClientType {
|
|
ClientType::DesktopMusic
|
|
}
|
|
}
|
|
|
|
impl DesktopMusicClient {
|
|
fn new(locale: Arc<Locale>, cache: Cache) -> Self {
|
|
let mut rng = rand::thread_rng();
|
|
|
|
let http = ClientBuilder::new()
|
|
.user_agent(DEFAULT_UA)
|
|
.gzip(true)
|
|
.brotli(true)
|
|
.build()
|
|
.expect("unable to build the HTTP client");
|
|
|
|
Self {
|
|
locale,
|
|
http,
|
|
cache,
|
|
consent_cookie: format!(
|
|
"{}={}{}",
|
|
CONSENT_COOKIE,
|
|
CONSENT_COOKIE_YES,
|
|
rng.gen_range(100..1000)
|
|
),
|
|
}
|
|
}
|
|
|
|
async fn extract_client_version_from_swjs(
|
|
http: Client,
|
|
consent_cookie: &str,
|
|
) -> Result<String> {
|
|
let swjs = exec_request_text(
|
|
http.clone(),
|
|
http.get("https://music.youtube.com/sw.js")
|
|
.header(header::ORIGIN, "https://www.youtube.com")
|
|
.header(header::REFERER, "https://www.youtube.com")
|
|
.header(header::COOKIE, consent_cookie)
|
|
.build()
|
|
.unwrap(),
|
|
)
|
|
.await
|
|
.context("Failed to download sw.js")?;
|
|
|
|
util::get_cg_from_regexes(CLIENT_VERSION_REGEXES.iter(), &swjs, 1)
|
|
.ok_or(anyhow!("Could not find music client version in sw.js"))
|
|
}
|
|
|
|
async fn get_client_version(&self) -> String {
|
|
let http = self.http.clone();
|
|
let consent_cookie = self.consent_cookie.clone();
|
|
|
|
let client_data = self
|
|
.cache
|
|
.get_music_client_data(async move {
|
|
let client_version =
|
|
Self::extract_client_version_from_swjs(http, &consent_cookie).await?;
|
|
Ok(ClientData {
|
|
version: client_version,
|
|
})
|
|
})
|
|
.await;
|
|
|
|
match client_data {
|
|
Ok(client_data) => client_data.version,
|
|
Err(e) => {
|
|
warn!("{}", e);
|
|
DESKTOP_MUSIC_CLIENT_VERSION.to_owned()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use test_log::test;
|
|
|
|
static CLIENT_VERSION_REGEX: Lazy<Regex> =
|
|
Lazy::new(|| Regex::new(r#"^\d+\.\d{8}\.\d{2}\.\d{2}"#).unwrap());
|
|
|
|
#[test(tokio::test)]
|
|
async fn t_extract_desktop_client_version() {
|
|
let rt = RustyTube::new();
|
|
let client = rt.desktop_client;
|
|
let version = DesktopClient::extract_client_version_from_swjs(
|
|
client.http.clone(),
|
|
&client.consent_cookie,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert!(CLIENT_VERSION_REGEX.is_match(&version).unwrap());
|
|
|
|
// Client version changes often,
|
|
// notify during test so the hardcoded version can be updated
|
|
if version != DESKTOP_CLIENT_VERSION {
|
|
println!(
|
|
"INFO: YT Desktop Client was updated, new version: {}",
|
|
version
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test(tokio::test)]
|
|
async fn t_extract_desktop_music_client_version() {
|
|
let rt = RustyTube::new();
|
|
let client = rt.desktop_music_client;
|
|
let version = DesktopMusicClient::extract_client_version_from_swjs(
|
|
client.http.clone(),
|
|
&client.consent_cookie,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
|
|
assert!(CLIENT_VERSION_REGEX.is_match(&version).unwrap());
|
|
|
|
// Client version changes often,
|
|
// notify during test so the hardcoded version can be updated
|
|
if version != DESKTOP_MUSIC_CLIENT_VERSION {
|
|
println!(
|
|
"INFO: YT Desktop Music Client was updated, new version: {}",
|
|
version
|
|
);
|
|
}
|
|
}
|
|
}
|