Upgrade almost everything except for dbus_mpris

Author: capnfabs

Cargo.lock

@@ -14,24 +14,26 @@ daemonize = "0.4"
 dbus = { version = "0.6", optional = true }
 dbus-tokio = { version = "0.2", optional = true }
 fern = { version = "0.6.0", features = ["syslog-4"] }
-futures = "0.1"
+futures = "0.3.15"
 gethostname = "0.2.0"
 hex = "0.4"
 keyring = { version = "0.10.1", optional = true }
 libc = "0.2.82"
 log = "0.4.6"
 percent-encoding = "2.1.0"
+reqwest = "0.11.3"
 rspotify = "0.8.0"
 serde = { version = "1.0.115", features = ["derive"] }
 sha-1 = "0.9"
 structopt = "0.3.17"
 syslog = "4"
-tokio-core = "0.1"
-tokio-io = "0.1"
-tokio-signal = "0.1"
+tokio = "1.6.1"
+tokio-compat = { version = "0.1.6", features = ["rt-current-thread"] }
+tokio-compat-02 = "0.2.0"
+tokio-stream = "0.1.7"
 url = "1.7"
 xdg = "2.2"
-librespot = { version = "0.1.5", default-features = false, features = ["with-tremor"] }
+librespot = { version = "0.2.0", default-features = false, features = ["with-tremor"] }
 toml = "0.5.8"
 color-eyre = "0.5"
 

Cargo.toml

@@ -14,7 +14,7 @@ use serde::{de::Error, de::Unexpected, Deserialize, Deserializer};
 use sha1::{Digest, Sha1};
 use std::{fmt, fs, path::PathBuf, str::FromStr, string::ToString};
 use structopt::{clap::AppSettings, StructOpt};
-use url::Url;
+use reqwest::Url;
 
 const CONFIG_FILE_NAME: &str = "spotifyd.conf";
 
@@ -128,10 +128,12 @@ impl From<LSDeviceType> for DeviceType {
             LSDeviceType::Tablet => DeviceType::Tablet,
             LSDeviceType::Smartphone => DeviceType::Smartphone,
             LSDeviceType::Speaker => DeviceType::Speaker,
-            LSDeviceType::TV => DeviceType::TV,
-            LSDeviceType::AVR => DeviceType::AVR,
-            LSDeviceType::STB => DeviceType::STB,
+            LSDeviceType::Tv => DeviceType::TV,
+            LSDeviceType::Avr => DeviceType::AVR,
+            LSDeviceType::Stb => DeviceType::STB,
             LSDeviceType::AudioDongle => DeviceType::AudioDongle,
+            // TODO: Implement new LibreSpot device types in Spotifyd
+            _ => DeviceType::Unknown,
         }
     }
 }
@@ -144,9 +146,9 @@ impl From<&DeviceType> for LSDeviceType {
             DeviceType::Tablet => LSDeviceType::Tablet,
             DeviceType::Smartphone => LSDeviceType::Smartphone,
             DeviceType::Speaker => LSDeviceType::Speaker,
-            DeviceType::TV => LSDeviceType::TV,
-            DeviceType::AVR => LSDeviceType::AVR,
-            DeviceType::STB => LSDeviceType::STB,
+            DeviceType::TV => LSDeviceType::Tv,
+            DeviceType::AVR => LSDeviceType::Avr,
+            DeviceType::STB => LSDeviceType::Stb,
             DeviceType::AudioDongle => LSDeviceType::AudioDongle,
         }
     }
@@ -419,7 +421,7 @@ impl fmt::Debug for SharedConfigValues {
                     None => None,
                 }
             };
-        };
+        }
 
         let password_value = extract_credential!(&self.password);
 
@@ -576,7 +578,9 @@ pub(crate) fn get_internal_config(config: CliConfig) -> SpotifydConfig {
         .shared_config
         .cache_path
         .map(PathBuf::from)
-        .map(|path| Cache::new(path, audio_cache));
+        // TODO: plumb size limits, check audio_cache?
+        // TODO: rather than silently disabling cache if constructor fails, maybe we should handle the error?
+        .map(|path| Cache::new(Some(path.clone()), if audio_cache { Some(path.clone()) } else { None }, None).ok()).flatten();
 
     let bitrate: LSBitrate = config
         .shared_config
@@ -676,6 +680,19 @@ pub(crate) fn get_internal_config(config: CliConfig) -> SpotifydConfig {
         },
         None => info!("No proxy specified"),
     }
+
+    // TODO: when we were on librespot 0.1.5, all PlayerConfig values were available in the
+    //  Spotifyd config. The upgrade to librespot 0.2.0 introduces new config variables, and we
+    //  should consider adding them to Spotifyd's config system.
+    let pc = {
+        let mut pc = PlayerConfig::default();
+        pc.bitrate = bitrate;
+        pc.normalisation = config.shared_config.volume_normalisation;
+        pc.normalisation_pregain = normalisation_pregain;
+        pc.gapless = true;
+        pc
+    };
+
     SpotifydConfig {
         username,
         password,
@@ -689,14 +706,9 @@ pub(crate) fn get_internal_config(config: CliConfig) -> SpotifydConfig {
         volume_controller,
         initial_volume,
         device_name,
-        player_config: PlayerConfig {
-            bitrate,
-            normalisation: config.shared_config.volume_normalisation,
-            normalisation_pregain,
-            gapless: true,
-        },
+        player_config: pc,
         session_config: SessionConfig {
-            user_agent: version::version_string(),
+            user_agent: version::VERSION_STRING.to_string(),
             device_id,
             proxy: proxy_url,
             ap_port: Some(443),

src/config.rs

@@ -8,7 +8,8 @@ use dbus_tokio::{
     tree::{AFactory, ATree, ATreeServer},
     AConnection,
 };
-use futures::{sync::oneshot, Async, Future, Poll, Stream};
+use futures::{self, Future, FutureExt};
+use futures::channel::oneshot;
 use librespot::{
     connect::spirc::Spirc,
     core::{
@@ -24,15 +25,15 @@ use rspotify::spotify::{
     util::datetime_to_timestamp,
 };
 use std::{collections::HashMap, env, rc::Rc, thread};
-use tokio_core::reactor::Handle;
+use std::pin::Pin;
+use futures::task::{Context, Poll};
 
 pub struct DbusServer {
     session: Session,
-    handle: Handle,
     spirc: Rc<Spirc>,
     api_token: RspotifyToken,
-    token_request: Option<Box<dyn Future<Item = LibrespotToken, Error = MercuryError>>>,
-    dbus_future: Option<Box<dyn Future<Item = (), Error = ()>>>,
+    token_request: Option<Pin<Box<dyn Future<Output=Result<LibrespotToken, MercuryError>>>>>,
+    dbus_future: Option<Pin<Box<dyn Future<Output = ()>>>>,
     device_name: String,
 }
 
@@ -47,13 +48,11 @@ const SCOPE: &str = "user-read-playback-state,user-read-private,\
 impl DbusServer {
     pub fn new(
         session: Session,
-        handle: Handle,
         spirc: Rc<Spirc>,
         device_name: String,
     ) -> DbusServer {
         DbusServer {
             session,
-            handle,
             spirc,
             api_token: RspotifyToken::default(),
             token_request: None,
@@ -72,20 +71,18 @@ impl DbusServer {
 }
 
 impl Future for DbusServer {
-    type Error = ();
-    type Item = ();
+    type Output = ();
 
-    fn poll(&mut self) -> Poll<(), ()> {
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<()> {
         let mut got_new_token = false;
         if self.is_token_expired() {
             if let Some(ref mut fut) = self.token_request {
-                if let Async::Ready(token) = fut.poll().unwrap() {
+                if let Poll::Ready(Ok(token)) = fut.as_mut().poll(cx) {
                     self.api_token = RspotifyToken::default()
                         .access_token(&token.access_token)
                         .expires_in(token.expires_in)
                         .expires_at(datetime_to_timestamp(token.expires_in));
                     self.dbus_future = Some(create_dbus_server(
-                        self.handle.clone(),
                         self.api_token.clone(),
                         self.spirc.clone(),
                         self.device_name.clone(),
@@ -96,17 +93,17 @@ impl Future for DbusServer {
                 // This is more meant as a fast hotfix than anything else!
                 let client_id =
                     env::var("SPOTIFYD_CLIENT_ID").unwrap_or_else(|_| CLIENT_ID.to_string());
-                self.token_request = Some(get_token(&self.session, &client_id, SCOPE));
+                self.token_request = Some(Box::pin(get_token(&self.session.clone(), &client_id, SCOPE)));
             }
         } else if let Some(ref mut fut) = self.dbus_future {
-            return fut.poll();
+            return fut.as_mut().poll(cx);
         }
 
         if got_new_token {
             self.token_request = None;
         }
 
-        Ok(Async::NotReady)
+        Poll::Pending
     }
 }
 
@@ -115,29 +112,31 @@ fn create_spotify_api(token: &RspotifyToken) -> Spotify {
 }
 
 fn create_dbus_server(
-    handle: Handle,
     api_token: RspotifyToken,
     spirc: Rc<Spirc>,
     device_name: String,
-) -> Box<dyn Future<Item = (), Error = ()>> {
+) -> Pin<Box<dyn Future<Output = ()>>> {
     macro_rules! spotify_api_method {
         ([ $sp:ident, $device:ident $(, $m:ident: $t:ty)*] $f:expr) => {
             {
                 let device_name = utf8_percent_encode(&device_name, NON_ALPHANUMERIC).to_string();
                 let token = api_token.clone();
                 move |m| {
-                    let (p, c) = oneshot::channel();
+                    let (tx, rx) = oneshot::channel();
                     let token = token.clone();
                     let device_name = device_name.clone();
                     $(let $m: Result<$t,_> = m.msg.read1();)*
                     thread::spawn(move || {
                         let $sp = create_spotify_api(&token);
                         let $device = Some(device_name);
                         let _ = $f;
-                        let _ = p.send(());
+                        let _ = tx.send(());
                     });
                     let mret = m.msg.method_return();
-                    c.map_err(|e| MethodErr::failed(&e)).map(|_| vec![mret])
+                    rx.map(|val| match val {
+                        Ok(_) => Ok(vec![mret]),
+                        Err(e) => Err(MethodErr::failed(&e)),
+                    }).into()
                 }
             }
         }
@@ -638,6 +637,8 @@ fn create_dbus_server(
     tree.set_registered(&connection, true)
         .expect("Failed to register tree");
 
+    //let handle = tokio_compat::runtime::Handle::current();
+
     let async_connection = AConnection::new(connection.clone(), handle)
         .expect("Failed to create async dbus connection");
 
@@ -649,7 +650,7 @@ fn create_dbus_server(
             .expect("Failed to unwrap async messages"),
     );
 
-    Box::new(server.for_each(|message| {
+    Box::pin(server.for_each(|message| {
         warn!("Unhandled DBus message: {:?}", message);
         Ok(())
     }))

src/dbus_mpris.rs

@@ -6,7 +6,7 @@ use daemonize::Daemonize;
 use log::{error, info, trace, LevelFilter};
 use std::panic;
 use structopt::StructOpt;
-use tokio_core::reactor::Core;
+use tokio::runtime::Runtime;
 
 #[cfg(feature = "alsa_backend")]
 mod alsa_mixer;
@@ -104,11 +104,11 @@ fn main() -> Result<(), Report> {
         );
     }));
 
-    let mut core = Core::new().unwrap();
-    let handle = core.handle();
-
-    let initial_state = setup::initial_state(handle, internal_config);
-    core.run(initial_state).unwrap();
+    let runtime = Runtime::new().unwrap();
+    runtime.block_on(async {
+       let initial_state = setup::initial_state(internal_config);
+        initial_state.await;
+    });
 
     Ok(())
 }