use std::time::Duration;
use futures_util::{SinkExt, StreamExt};
use tokio::sync::mpsc;
use tokio_tungstenite::tungstenite::client::IntoClientRequest;
use tokio_tungstenite::tungstenite::http::HeaderValue;
use tokio_tungstenite::tungstenite::{Message, protocol::WebSocketConfig};
use super::messages::{DeviceInfo, device_info_header, encode_subprotocol, update_full_state};
use super::state::{
PlayerState, Redirect, now_ms, parse_error_frame, parse_redirect_frame, parse_state_frame,
};
use crate::error::{Error, Result};
const BASE_URL: &str = "wss://ynison.music.yandex.ru";
const REDIRECT_SERVICE: &str = "redirector.YnisonRedirectService/GetRedirectToYnison";
const STATE_SERVICE: &str = "ynison_state.YnisonStateService/PutYnisonState";
const KEEPALIVE_INTERVAL: Duration = Duration::from_secs(20);
const REDIRECT_TIMEOUT: Duration = Duration::from_secs(10);
#[derive(Debug, Clone)]
pub struct SessionConfig {
pub token: String,
pub device_id: String,
pub device: DeviceInfo,
}
#[derive(Debug, Clone)]
pub struct SessionHandle {
last_activity: std::sync::Arc<std::sync::atomic::AtomicI64>,
}
impl SessionHandle {
fn new() -> Self {
Self {
last_activity: std::sync::Arc::new(std::sync::atomic::AtomicI64::new(now_ms())),
}
}
fn touch(&self) {
self.last_activity
.store(now_ms(), std::sync::atomic::Ordering::Relaxed);
}
#[must_use]
pub fn last_activity_ms(&self) -> i64 {
self.last_activity
.load(std::sync::atomic::Ordering::Relaxed)
}
#[must_use]
pub fn idle_ms(&self) -> i64 {
now_ms() - self.last_activity_ms()
}
}
fn build_request(
url: &str,
config: &SessionConfig,
redirect: Option<&Redirect>,
) -> Result<tokio_tungstenite::tungstenite::http::Request<()>> {
let mut request = url
.into_client_request()
.map_err(|e| Error::ynison(format!("invalid ynison url: {e}")))?;
let bundle = device_info_header(
&config.device_id,
&config.device,
redirect.map(|r| (r.ticket.as_str(), r.session_id.as_str())),
);
let protocols = format!("Bearer, v2, {}", encode_subprotocol(&bundle));
let headers = request.headers_mut();
headers.insert(
"Origin",
HeaderValue::from_static("https://music.yandex.ru"),
);
let mut auth = HeaderValue::from_str(&format!("OAuth {}", config.token))
.map_err(|_| Error::ynison("token contains bytes invalid in a header"))?;
auth.set_sensitive(true);
headers.insert("Authorization", auth);
headers.insert(
"Sec-WebSocket-Protocol",
HeaderValue::from_str(&protocols)
.map_err(|_| Error::ynison("device bundle contains bytes invalid in a header"))?,
);
Ok(request)
}
fn ws_config() -> WebSocketConfig {
WebSocketConfig::default().max_message_size(Some(32 << 20))
}
async fn resolve_redirect(config: &SessionConfig) -> Result<Redirect> {
let url = format!("{BASE_URL}/{REDIRECT_SERVICE}");
let request = build_request(&url, config, None)?;
let (mut socket, _) =
tokio_tungstenite::connect_async_with_config(request, Some(ws_config()), false)
.await
.map_err(|e| Error::ynison(format!("redirect handshake failed: {e}")))?;
let frame = tokio::time::timeout(REDIRECT_TIMEOUT, async {
while let Some(message) = socket.next().await {
match message {
Ok(Message::Text(text)) => return Some(Ok(text.to_string())),
Ok(Message::Close(_)) => {
return Some(Err(Error::ynison("redirect socket closed before a frame")));
},
Ok(_) => {},
Err(e) => return Some(Err(Error::ynison(format!("redirect socket error: {e}")))),
}
}
None
})
.await
.map_err(|_| Error::ynison("the redirect frame did not arrive in time"))?
.ok_or_else(|| Error::ynison("redirect socket ended without a frame"))??;
let _ = socket.close(None).await;
if let Some(error) = parse_error_frame(&frame) {
return Err(Error::Ynison {
message: error.message,
retry_after: error.go_away,
});
}
parse_redirect_frame(&frame)
}
pub async fn run(
config: &SessionConfig,
states: mpsc::Sender<PlayerState>,
handle: SessionHandle,
) -> Result<()> {
let redirect = resolve_redirect(config).await?;
let url = format!("wss://{}/{STATE_SERVICE}", redirect.host);
let request = build_request(&url, config, Some(&redirect))?;
let (mut socket, _) =
tokio_tungstenite::connect_async_with_config(request, Some(ws_config()), false)
.await
.map_err(|e| Error::ynison(format!("state handshake failed: {e}")))?;
handle.touch();
let hello = update_full_state(&config.device_id, &config.device).to_string();
socket
.send(Message::Text(hello.into()))
.await
.map_err(|e| Error::ynison(format!("could not send the initial state: {e}")))?;
let mut keepalive = tokio::time::interval(KEEPALIVE_INTERVAL);
keepalive.tick().await;
loop {
tokio::select! {
_ = keepalive.tick() => {
if socket.send(Message::Ping(Vec::new().into())).await.is_err() {
return Err(Error::ynison("the state socket dropped while pinging"));
}
},
message = socket.next() => {
let Some(message) = message else {
return Ok(()); };
handle.touch();
match message {
Ok(Message::Text(text)) => {
if let Some(error) = parse_error_frame(&text) {
return Err(Error::Ynison {
message: error.message,
retry_after: error.go_away,
});
}
if let Ok(state) = parse_state_frame(&text) {
if states.send(state).await.is_err() {
return Ok(());
}
}
},
Ok(Message::Close(_)) => return Ok(()),
Ok(_) => {}, Err(e) => return Err(Error::ynison(format!("state socket error: {e}"))),
}
},
}
}
}
#[must_use]
pub fn new_handle() -> SessionHandle {
SessionHandle::new()
}
#[cfg(test)]
mod tests {
use super::*;
fn config() -> SessionConfig {
SessionConfig {
token: "test-token".into(),
device_id: "dev123".into(),
device: DeviceInfo::ANDROID,
}
}
#[test]
fn the_request_carries_auth_origin_and_the_device_bundle() {
let request = build_request("wss://example.test/svc", &config(), None).unwrap();
let headers = request.headers();
assert_eq!(headers["Origin"], "https://music.yandex.ru");
assert_eq!(headers["Authorization"], "OAuth test-token");
let protocols = headers["Sec-WebSocket-Protocol"].to_str().unwrap();
assert!(protocols.starts_with("Bearer, v2, "));
assert!(
protocols.contains("%7B"),
"the bundle should be encoded: {protocols}"
);
assert!(!protocols.contains('{'));
}
#[test]
fn the_authorization_header_is_marked_sensitive() {
let request = build_request("wss://example.test/svc", &config(), None).unwrap();
assert!(request.headers()["Authorization"].is_sensitive());
}
#[test]
fn the_second_leg_includes_the_redirect_ticket() {
let redirect = Redirect {
host: "state-host".into(),
ticket: "tkt".into(),
session_id: "sess".into(),
};
let request = build_request("wss://state-host/svc", &config(), Some(&redirect)).unwrap();
let protocols = request.headers()["Sec-WebSocket-Protocol"]
.to_str()
.unwrap();
assert!(
protocols.contains("Ynison-Redirect-Ticket")
|| protocols.contains("%22Ynison-Redirect-Ticket%22")
);
}
#[test]
fn a_token_with_illegal_header_bytes_is_rejected() {
let bad = SessionConfig {
token: "bad\nvalue".into(),
..config()
};
assert!(build_request("wss://example.test/svc", &bad, None).is_err());
}
#[test]
fn an_invalid_url_is_rejected() {
assert!(build_request("not a url", &config(), None).is_err());
}
#[test]
fn a_fresh_handle_starts_idle_at_roughly_zero() {
let handle = new_handle();
assert!(handle.idle_ms() < 1000);
assert!(handle.last_activity_ms() > 0);
}
#[test]
fn touching_a_handle_resets_its_idle_time() {
let handle = new_handle();
let before = handle.last_activity_ms();
std::thread::sleep(Duration::from_millis(5));
handle.touch();
assert!(handle.last_activity_ms() >= before);
}
#[test]
fn handles_share_state_across_clones() {
let handle = new_handle();
let clone = handle.clone();
clone.touch();
assert_eq!(handle.last_activity_ms(), clone.last_activity_ms());
}
}