Merge pull request #1 from OzGav/CDN-Fix-plus-Podcast

Author: marcelveldt

audio/src/fetch/mod.rs

@@ -306,7 +306,7 @@ struct AudioFileDownloadStatus {
 }
 
 struct AudioFileShared {
-    cdn_url: CdnUrl,
+    cdn_url: String,
     file_size: usize,
     bytes_per_second: usize,
     cond: Condvar,
@@ -426,25 +426,44 @@ impl AudioFileStreaming {
     ) -> Result<AudioFileStreaming, Error> {
         let cdn_url = CdnUrl::new(file_id).resolve_audio(&session).await?;
 
-        if let Ok(url) = cdn_url.try_get_url() {
-            trace!("Streaming from {}", url);
-        }
-
         let minimum_download_size = AudioFetchParams::get().minimum_download_size;
 
-        // When the audio file is really small, this `download_size` may turn out to be
-        // larger than the audio file we're going to stream later on. This is OK; requesting
-        // `Content-Range` > `Content-Length` will return the complete file with status code
-        // 206 Partial Content.
-        let mut streamer =
-            session
+        let mut response_streamer_url = None;
+        let urls = cdn_url.try_get_urls()?;
+        for url in &urls {
+            // When the audio file is really small, this `download_size` may turn out to be
+            // larger than the audio file we're going to stream later on. This is OK; requesting
+            // `Content-Range` > `Content-Length` will return the complete file with status code
+            // 206 Partial Content.
+            let mut streamer = session
                 .spclient()
-                .stream_from_cdn(&cdn_url, 0, minimum_download_size)?;
+                .stream_from_cdn(url, 0, minimum_download_size)?;
+
+            // Get the first chunk with the headers to get the file size.
+            // The remainder of that chunk with possibly also a response body is then
+            // further processed in `audio_file_fetch`.
+            let resp = streamer.next().await.map_or_else(
+                || Err(AudioFileError::NoData.into()),
+                |x| x.map_err(Error::from),
+            );
+
+            match resp {
+                Ok(r) => {
+                    response_streamer_url = Some((r, streamer, url));
+                    break;
+                }
+                Err(e) => warn!("Fetching {url} failed with error {e:?}, trying next"),
+            }
+        }
+
+        let Some((response, streamer, url)) = response_streamer_url else {
+            return Err(Error::unavailable(format!(
+                "{} URLs failed, none left to try",
+                urls.len()
+            )));
+        };
 
-        // Get the first chunk with the headers to get the file size.
-        // The remainder of that chunk with possibly also a response body is then
-        // further processed in `audio_file_fetch`.
-        let response = streamer.next().await.ok_or(AudioFileError::NoData)??;
+        trace!("Streaming from {}", url);
 
         let code = response.status();
         if code != StatusCode::PARTIAL_CONTENT {
@@ -473,7 +492,7 @@ impl AudioFileStreaming {
         };
 
         let shared = Arc::new(AudioFileShared {
-            cdn_url,
+            cdn_url: url.to_string(),
             file_size,
             bytes_per_second,
             cond: Condvar::new(),

core/src/cdn_url.rs

@@ -78,6 +78,7 @@ impl CdnUrl {
         Ok(cdn_url)
     }
 
+    #[deprecated = "This function only returns the first valid URL. Use try_get_urls instead, which allows for fallback logic."]
     pub fn try_get_url(&self) -> Result<&str, Error> {
         if self.urls.is_empty() {
             return Err(CdnUrlError::Unresolved.into());
@@ -95,6 +96,34 @@ impl CdnUrl {
             Err(CdnUrlError::Expired.into())
         }
     }
+
+    pub fn try_get_urls(&self) -> Result<Vec<&str>, Error> {
+        if self.urls.is_empty() {
+            return Err(CdnUrlError::Unresolved.into());
+        }
+
+        let now = Date::now_utc();
+        let urls: Vec<&str> = self
+            .urls
+            .iter()
+            .filter_map(|MaybeExpiringUrl(url, expiry)| match *expiry {
+                Some(expiry) => {
+                    if now < expiry {
+                        Some(url.as_str())
+                    } else {
+                        None
+                    }
+                }
+                None => Some(url.as_str()),
+            })
+            .collect();
+
+        if urls.is_empty() {
+            Err(CdnUrlError::Expired.into())
+        } else {
+            Ok(urls)
+        }
+    }
 }
 
 impl TryFrom<CdnUrlMessage> for MaybeExpiringUrls {

core/src/spclient.rs

@@ -6,7 +6,6 @@ use std::{
 use crate::config::{os_version, OS};
 use crate::{
     apresolve::SocketAddress,
-    cdn_url::CdnUrl,
     config::SessionConfig,
     error::ErrorKind,
     protocol::{
@@ -450,7 +449,12 @@ impl SpClient {
 
             // Reconnection logic: retrieve the endpoint every iteration, so we can try
             // another access point when we are experiencing network issues (see below).
-            let mut url = self.base_url().await?;
+            let mut url = if endpoint.starts_with("/metadata") {
+                String::from("https://spclient.wg.spotify.com")
+            } else {
+                self.base_url().await?
+            };
+
             url.push_str(endpoint);
 
             // Add metrics. There is also an optional `partner` key with a value like
@@ -732,14 +736,13 @@ impl SpClient {
 
     pub fn stream_from_cdn(
         &self,
-        cdn_url: &CdnUrl,
+        cdn_url: &str,
         offset: usize,
         length: usize,
     ) -> Result<IntoStream<ResponseFuture>, Error> {
-        let url = cdn_url.try_get_url()?;
         let req = Request::builder()
             .method(&Method::GET)
-            .uri(url)
+            .uri(cdn_url)
             .header(
                 RANGE,
                 HeaderValue::from_str(&format!("bytes={}-{}", offset, offset + length - 1))?,

src/main.rs

@@ -1971,13 +1971,12 @@ async fn main() {
     if let Some(ref track_id) = setup.single_track {
         // Handle playback of single track + exit
 
-        let mut track = SpotifyId::from_uri(
+        let track = SpotifyId::from_uri(
             track_id
                 .replace("spotty://", "spotify:track:")
                 .replace("://", ":")
                 .as_str(),
         ).unwrap();
-        track.item_type = SpotifyItemType::Track;
 
         if let Some(credentials) = setup.credentials {
             info!("Connecting...");