Migrate core to tokio 1.0

core/src/apresolve.rs

@@ -1,101 +1,69 @@
 const AP_FALLBACK: &'static str = "ap.spotify.com:443";
 const APRESOLVE_ENDPOINT: &'static str = "http://apresolve.spotify.com/";
 
-use futures::{Future, Stream};
-use hyper::client::HttpConnector;
-use hyper::{self, Client, Method, Request, Uri};
-use hyper_proxy::{Intercept, Proxy, ProxyConnector};
-use serde_json;
-use std::str::FromStr;
-use tokio_core::reactor::Handle;
+use hyper::{Body, Client, Method, Request, Uri};
+use std::error::Error;
 use url::Url;
 
-error_chain! {}
-
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct APResolveData {
     ap_list: Vec<String>,
 }
 
-fn apresolve(
-    handle: &Handle,
-    proxy: &Option<Url>,
-    ap_port: &Option<u16>,
-) -> Box<dyn Future<Item = String, Error = Error>> {
-    let url = Uri::from_str(APRESOLVE_ENDPOINT).expect("invalid AP resolve URL");
-    let use_proxy = proxy.is_some();
+async fn apresolve(proxy: &Option<Url>, ap_port: &Option<u16>) -> Result<String, Box<dyn Error>> {
+    let port = ap_port.unwrap_or(443);
 
-    let mut req = Request::new(Method::Get, url.clone());
-    let response = match *proxy {
-        Some(ref val) => {
-            let proxy_url = Uri::from_str(val.as_str()).expect("invalid http proxy");
-            let proxy = Proxy::new(Intercept::All, proxy_url);
-            let connector = HttpConnector::new(4, handle);
+    let req = Request::builder()
+        .method(Method::GET)
+        .uri(
+            APRESOLVE_ENDPOINT
+                .parse::<Uri>()
+                .expect("invalid AP resolve URL"),
+        )
+        .body(Body::empty())?;
+
+    let client = if proxy.is_some() {
+        todo!("proxies not yet supported")
+        /*let proxy = {
+            let proxy_url = val.as_str().parse().expect("invalid http proxy");
+            let mut proxy = Proxy::new(Intercept::All, proxy_url);
+            let connector = HttpConnector::new();
             let proxy_connector = ProxyConnector::from_proxy_unsecured(connector, proxy);
-            if let Some(headers) = proxy_connector.http_headers(&url) {
-                req.headers_mut().extend(headers.iter());
-                req.set_proxy(true);
-            }
-            let client = Client::configure().connector(proxy_connector).build(handle);
-            client.request(req)
-        }
-        _ => {
-            let client = Client::new(handle);
-            client.request(req)
-        }
+            proxy_connector
+        };
+
+        if let Some(headers) = proxy.http_headers(&APRESOLVE_ENDPOINT.parse().unwrap()) {
+            req.headers_mut().extend(headers.clone());
+        };
+        Client::builder().build(proxy)*/
+    } else {
+        Client::new()
     };
 
-    let body = response.and_then(|response| {
-        response.body().fold(Vec::new(), |mut acc, chunk| {
-            acc.extend_from_slice(chunk.as_ref());
-            Ok::<_, hyper::Error>(acc)
-        })
-    });
-    let body = body.then(|result| result.chain_err(|| "HTTP error"));
-    let body =
-        body.and_then(|body| String::from_utf8(body).chain_err(|| "invalid UTF8 in response"));
+    let response = client.request(req).await?;
 
-    let data = body
-        .and_then(|body| serde_json::from_str::<APResolveData>(&body).chain_err(|| "invalid JSON"));
+    let body = hyper::body::to_bytes(response.into_body()).await?;
+    let data: APResolveData = serde_json::from_slice(body.as_ref())?;
 
-    let p = ap_port.clone();
-
-    let ap = data.and_then(move |data| {
-        let mut aps = data.ap_list.iter().filter(|ap| {
-            if p.is_some() {
-                Uri::from_str(ap).ok().map_or(false, |uri| {
-                    uri.port().map_or(false, |port| port == p.unwrap())
-                })
-            } else if use_proxy {
-                // It is unlikely that the proxy will accept CONNECT on anything other than 443.
-                Uri::from_str(ap)
-                    .ok()
-                    .map_or(false, |uri| uri.port().map_or(false, |port| port == 443))
+    let ap = if ap_port.is_some() || proxy.is_some() {
+        data.ap_list.into_iter().find_map(|ap| {
+            if ap.parse::<Uri>().ok()?.port()? == port {
+                Some(ap)
             } else {
-                true
+                None
             }
-        });
-
-        let ap = aps.next().ok_or("empty AP List")?;
-        Ok(ap.clone())
-    });
-
-    Box::new(ap)
+        })
+    } else {
+        data.ap_list.into_iter().next()
+    }
+    .ok_or("empty AP List")?;
+    Ok(ap)
 }
 
-pub(crate) fn apresolve_or_fallback<E>(
-    handle: &Handle,
-    proxy: &Option<Url>,
-    ap_port: &Option<u16>,
-) -> Box<dyn Future<Item = String, Error = E>>
-where
-    E: 'static,
-{
-    let ap = apresolve(handle, proxy, ap_port).or_else(|e| {
-        warn!("Failed to resolve Access Point: {}", e.description());
+pub async fn apresolve_or_fallback(proxy: &Option<Url>, ap_port: &Option<u16>) -> String {
+    apresolve(proxy, ap_port).await.unwrap_or_else(|e| {
+        warn!("Failed to resolve Access Point: {}", e);
         warn!("Using fallback \"{}\"", AP_FALLBACK);
-        Ok(AP_FALLBACK.into())
-    });
-
-    Box::new(ap)
+        AP_FALLBACK.into()
+    })
 }