implemented password and token logins

docs/todo.md

@@ -28,7 +28,7 @@
             - [ ] 5.3.6.2   Third-party ID
             - [ ] 5.3.6.3   Phone number
     - [ ] 5.4   Login
-        - [ ] 5.4.1   GET /_matrix/client/r0/login
+        - [x] 5.4.1   ~~GET /_matrix/client/r0/login~~
         - [ ] 5.4.2   POST /_matrix/client/r0/login
         - [ ] 5.4.3   POST /_matrix/client/r0/logout
         - [ ] 5.4.4   POST /_matrix/client/r0/logout/all

src/api/client.rs

@@ -1,16 +1,25 @@
-use crate::api::methods::sync::SyncResponse;
+use crate::api::methods::{login::*, sync::SyncResponse};
 use reqwest::{
     header::{HeaderMap, HeaderValue, CONTENT_TYPE, USER_AGENT},
     Client as reqwest_client, Response, StatusCode,
 };
 use serde::Deserialize;
-use std::{collections::HashMap, error::Error, fmt, time};
+use serde_json::{json, Value};
+use std::{
+    collections::HashMap,
+    error::Error,
+    fmt,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+    thread, time,
+};
 use url::{ParseError, Url};
 
 #[cfg(test)]
 use mockito;
 
-const V2_API_PATH: &str = "/_matrix/client/r0";
 const SUPPORTED_VERSION: &str = "r0.5.0";
 
 #[derive(Debug)]
@@ -71,18 +80,18 @@ pub struct SupportedSpecs {
 #[derive(Deserialize)]
 pub struct DiscoveryInformation {
     #[serde(rename = "m.homeserver")]
-    homeserver: HomeserverInformation,
-    identity_server: Option<IdentityServerInformation>,
+    pub homeserver: HomeserverInformation,
+    pub identity_server: Option<IdentityServerInformation>,
 }
 
 #[derive(Deserialize)]
 pub struct HomeserverInformation {
-    base_url: String,
+    pub base_url: String,
 }
 
 #[derive(Deserialize)]
 pub struct IdentityServerInformation {
-    base_url: String,
+    pub base_url: String,
 }
 
 impl Client {
@@ -166,7 +175,7 @@ impl Client {
         &self,
         method: MatrixHTTPMethod,
         path: &str,
-        content: Option<String>,
+        content: Option<Value>,
         query_params: Option<HashMap<String, String>>,
         headers: Option<HeaderMap>,
     ) -> Result<Response, Box<dyn std::error::Error>> {
@@ -175,6 +184,7 @@ impl Client {
 
         #[cfg(test)]
         let url = &mockito::server_url();
+
         #[cfg(not(test))]
         let url = &self.homeserver_url;
 
@@ -206,7 +216,7 @@ impl Client {
         request = request.headers(headers).query(&query_params);
 
         if let Some(content) = content {
-            request = request.body(content);
+            request = request.body(content.to_string());
         }
 
         loop {
@@ -218,16 +228,17 @@ impl Client {
             if res.status().is_success() {
                 return Ok(res);
             } else if res.status() == StatusCode::TOO_MANY_REQUESTS {
-                let mut body: HashMap<String, String> = res.json()?;
+                let mut body: &Value = &res.json()?;
                 if let Some(value) = body.get("error") {
-                    body = serde_json::from_str(value)?;
+                    body = value;
                 }
 
-                if let Some(value) = body.get("retry_after_ms") {
-                    std::thread::sleep(time::Duration::from_millis(value.parse::<u64>()?));
-                } else {
-                    std::thread::sleep(time::Duration::from_millis(self.default_492_wait_ms));
-                }
+                std::thread::sleep(time::Duration::from_millis(
+                    body.get("retry_after_ms").map_or_else(
+                        || self.default_492_wait_ms,
+                        |v| v.as_u64().unwrap_or_else(|| self.default_492_wait_ms),
+                    ),
+                ));
             } else {
                 return Err(Box::from(ResponseError {
                     code: res.status(),
@@ -289,6 +300,108 @@ impl Client {
     }
 }
 
+// Holds implementation for Section 5.4, Login
+impl Client {
+    /// Implementation of [Section 5.4.1 **GET** `/_matrix/client/r0/login`](https://matrix.org/docs/spec/client_server/r0.5.0#get-matrix-client-r0-login).
+    pub fn login_flows(&self) -> Result<ValidLoginFlows, Box<dyn Error>> {
+        Ok(self
+            .send(
+                MatrixHTTPMethod::Get,
+                "/_matrix/client/r0/login",
+                None,
+                None,
+                None,
+            )?
+            .json()?)
+    }
+
+    /// Implementation of password-based login for
+    /// [5.4.2 **POST** `/_matrix/client/r0/login`](https://matrix.org/docs/spec/client_server/r0.5.0#post-matrix-client-r0-login)
+    ///
+    /// If a specific device ID is specified, then the server will attempt to
+    /// use it. If an existing device ID is used, then any previously assigned
+    /// access tokens to that device ID may be invalidated. If the device ID
+    /// does not exist, then it will be created. If none is provided, then the
+    /// server will generate one.
+    ///
+    /// You may specify a device display name if the provided device ID is not
+    /// known. It is ignored if the device ID already exists.
+    pub fn login_password(
+        &self,
+        identifier: IdentifierType,
+        password: &str,
+        device_id: Option<&str>,
+        initial_device_display_name: Option<&str>,
+    ) -> Result<LoginResponse, Box<dyn Error>> {
+        self.login(
+            json!({
+               "type": "m.login.password",
+               "password": password,
+            }),
+            identifier,
+            device_id,
+            initial_device_display_name,
+        )
+    }
+
+    /// Implementation of token-based login for
+    /// [5.4.2 **POST** `/_matrix/client/r0/login`](https://matrix.org/docs/spec/client_server/r0.5.0#post-matrix-client-r0-login)
+    ///
+    /// If a specific device ID is specified, then the server will attempt to
+    /// use it. If an existing device ID is used, then any previously assigned
+    /// access tokens to that device ID may be invalidated. If the device ID
+    /// does not exist, then it will be created. If none is provided, then the
+    /// server will generate one.
+    ///
+    /// You may specify a device display name if the provided device ID is not
+    /// known. It is ignored if the device ID already exists.
+    pub fn login_token(
+        &self,
+        identifier: IdentifierType,
+        password: &str,
+        device_id: Option<&str>,
+        initial_device_display_name: Option<&str>,
+    ) -> Result<LoginResponse, Box<dyn Error>> {
+        self.login(
+            json!({
+               "type": "m.login.token",
+               "token": password,
+            }),
+            identifier,
+            device_id,
+            initial_device_display_name,
+        )
+    }
+
+    fn login(
+        &self,
+        body: Value,
+        identifier: IdentifierType,
+        device_id: Option<&str>,
+        initial_device_display_name: Option<&str>,
+    ) -> Result<LoginResponse, Box<dyn Error>> {
+        let mut body = body;
+        body["identifier"] = json!(identifier);
+
+        if let Some(id) = device_id {
+            body["device_id"] = json!(id);
+            if let Some(display_name) = initial_device_display_name {
+                body["initial_device_display_name"] = json!(display_name);
+            }
+        }
+
+        Ok(self
+            .send(
+                MatrixHTTPMethod::Post,
+                "/_matrix/client/r0/login",
+                Some(body),
+                None,
+                None,
+            )?
+            .json()?)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -340,6 +453,43 @@ mod tests {
         assert!(resp.unstable_features.is_none());
     }
 
+    #[test]
+    fn send_handles_too_many_requests() {
+        let _mock_version_check = mock("GET", "/_matrix/client/versions")
+            .with_body(r#"{"versions": ["r0.5.0"]}"#)
+            .create();
+
+        let _m2 = mock("GET", "/hello")
+            .with_body(
+                r#"{
+                    "errcode": "M_LIMIT_EXCEEDED",
+                    "error": "Too many requests",
+                    "retry_after_ms": 2000
+                }"#,
+            )
+            .with_status(429)
+            .create();
+
+        // Run request in separate thread. Once async lands use async/await
+        thread::spawn(|| {
+            let resp: Value = Client::new("http://dummy.website", None, None, None)
+                .expect("failed to get valid client")
+                .send(MatrixHTTPMethod::Get, "/hello", None, None, None)
+                .expect("failed to unwrap Response")
+                .json()
+                .unwrap();
+
+            assert_eq!(dbg!(resp)["hello"], "world");
+        });
+
+        // Override 429 response with valid response after initial request
+        // returns a 429. This should really be done with a synchronization
+        // primitive (e.g. condvar) but I don't know how to do that.
+        thread::sleep(time::Duration::from_secs(1));
+        let _m = mock("GET", "/hello")
+            .with_body(r#"{"hello": "world"}"#)
+            .create();
+    }
 }
 #[derive(Default)]
 pub struct ApiError {}

src/api/methods/login.rs

@@ -1,22 +1,34 @@
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
+
+// 5.4.1 GET /_matrix/client/r0/login
 
 /// Response for 5.4.1: GET /_matrix/client/r0/login
 #[derive(Deserialize)]
 pub struct ValidLoginFlows {
     pub flows: Option<LoginFlow>,
 }
-
 #[derive(Deserialize)]
 pub struct LoginFlow {
     pub r#type: Option<String>,
 }
 
-/// Request helper for 5.4.2: POST /_matrix/client/r0/login
-pub struct LoginRequest {
+// 5.4.2 POST /_matrix/client/r0/login
 
+/// Known identifier types for authentication methods. See [Section 5.3.6](https://matrix.org/docs/spec/client_server/r0.5.0#identifier-types)
+/// for more details.
+#[derive(Deserialize, Serialize)]
+pub enum IdentifierType {
+    #[serde(rename = "m.id.user")]
+    User,
+    #[serde(rename = "m.id.thirdparty")]
+    ThirdParty,
+    #[serde(rename = "m.id.phone")]
+    Phone
 }
 
-/// Response object for a valid login from 5.4.2: POST /_matrix/client/r0/login
+
+/// Response for a valid login from 5.4.2: POST /_matrix/client/r0/login
+#[derive(Deserialize)]
 pub struct LoginResponse {
     pub user_id: Option<String>,
     pub access_token: Option<String>,
@@ -25,5 +37,5 @@ pub struct LoginResponse {
     pub well_known: Option<DiscoveryInformation>,
 }
 
-pub struct DiscoveryInformation {
-}
+#[derive(Deserialize)]
+pub struct DiscoveryInformation {}