feat: federated room directory

src/client_server.rs

@@ -37,8 +37,8 @@ use ruma_events::{collections::only::Event as EduEvent, EventType};
 use ruma_identifiers::{RoomId, UserId};
 use serde_json::json;
 use std::{
-    collections::{BTreeMap, HashMap},
+    collections::BTreeMap,
-    convert::{TryFrom, TryInto},
+    convert::TryInto,
     path::PathBuf,
     time::{Duration, SystemTime},
 };
@@ -753,10 +753,12 @@ pub async fn get_public_rooms_filtered_route(
         })
         .collect::<Vec<_>>();
 
+    chunk.sort_by(|l, r| r.num_joined_members.cmp(&l.num_joined_members));
+
     chunk.extend_from_slice(
         &server_server::send_request(
             &data,
-            "koesters.xyz".to_owned(),
+            "chat.privacytools.io".to_owned(),
             ruma_federation_api::v1::get_public_rooms::Request {
                 limit: None,
                 since: None,
@@ -768,12 +770,10 @@ pub async fn get_public_rooms_filtered_route(
         .unwrap()
         .chunk
         .into_iter()
-        .map(|c| serde_json::from_str(&serde_json::to_string(dbg!(&c)).unwrap()).unwrap())
+        .map(|c| serde_json::from_str(&serde_json::to_string(&c).unwrap()).unwrap())
         .collect::<Vec<_>>(),
     );
 
-    chunk.sort_by(|l, r| r.num_joined_members.cmp(&l.num_joined_members));
-
     let total_room_count_estimate = (chunk.len() as u32).into();
 
     MatrixResult(Ok(get_public_rooms_filtered::Response {
@@ -910,10 +910,7 @@ pub fn sync_route(
         .unwrap_or(0);
     for room_id in joined_roomids {
         let pdus = data.pdus_since(&room_id, since);
-        let room_events = pdus
+        let room_events = pdus.into_iter().map(|pdu| pdu.to_room_event()).collect();
-            .into_iter()
-            .map(|pdu| pdu.to_room_event())
-            .collect();
         let mut edus = data.roomlatests_since(&room_id, since);
         edus.extend_from_slice(&data.roomactives_in(&room_id));
 
@@ -945,10 +942,7 @@ pub fn sync_route(
     let left_roomids = data.rooms_left(body.user_id.as_ref().expect("user is authenticated"));
     for room_id in left_roomids {
         let pdus = data.pdus_since(&room_id, since);
-        let room_events = pdus
+        let room_events = pdus.into_iter().map(|pdu| pdu.to_room_event()).collect();
-            .into_iter()
-            .map(|pdu| pdu.to_room_event())
-            .collect();
         let mut edus = data.roomlatests_since(&room_id, since);
         edus.extend_from_slice(&data.roomactives_in(&room_id));
 

src/data.rs

@@ -458,7 +458,8 @@ impl Data {
         .expect("ruma's reference hashes are correct");
 
         let mut pdu_json = serde_json::to_value(&pdu).unwrap();
-        ruma_signatures::hash_and_sign_event(self.hostname(), self.keypair(), &mut pdu_json);
+        ruma_signatures::hash_and_sign_event(self.hostname(), self.keypair(), &mut pdu_json)
+            .unwrap();
 
         self.pdu_leaves_replace(&room_id, &pdu.event_id);
 

src/ruma_wrapper.rs

@@ -6,15 +6,9 @@ use rocket::{
     Outcome::*,
     Request, State,
 };
-use ruma_api::{
+use ruma_api::Endpoint;
-    Endpoint
-};
 use ruma_identifiers::UserId;
-use std::{
+use std::{convert::TryInto, io::Cursor, ops::Deref};
-    convert::{TryInto},
-    io::Cursor,
-    ops::Deref,
-};
 use tokio::io::AsyncReadExt;
 
 const MESSAGE_LIMIT: u64 = 65535;
@@ -27,8 +21,7 @@ pub struct Ruma<T> {
     pub json_body: serde_json::Value,
 }
 
-impl<'a, T: Endpoint> FromData<'a> for Ruma<T>
+impl<'a, T: Endpoint> FromData<'a> for Ruma<T> {
-{
     type Error = (); // TODO: Better error handling
     type Owned = Data;
     type Borrowed = Self::Owned;

src/server_server.rs

@@ -1,18 +1,14 @@
-use crate::{utils, Data, MatrixResult, Ruma};
+use crate::{Data, MatrixResult};
 use http::header::{HeaderValue, AUTHORIZATION};
 use log::error;
-use rocket::{get, options, post, put, response::content::Json, State};
+use rocket::{get, post, put, response::content::Json, State};
-use ruma_api::{
+use ruma_api::Endpoint;
-    error::{FromHttpRequestError, FromHttpResponseError},
+use ruma_client_api::error::Error;
-    Endpoint,
-};
-use ruma_client_api::error::{Error, ErrorKind};
 use ruma_federation_api::{v1::get_server_version, v2::get_server_keys};
 use serde_json::json;
 use std::{
-    collections::{BTreeMap, HashMap},
+    collections::BTreeMap,
-    convert::{TryFrom, TryInto},
+    convert::TryFrom,
-    path::PathBuf,
     time::{Duration, SystemTime},
 };
 
@@ -20,28 +16,29 @@ pub async fn send_request<T: Endpoint>(
     data: &crate::Data,
     destination: String,
     request: T,
-) -> Option<T::Response>
+) -> Option<T::Response> {
-{
     let mut http_request: http::Request<_> = request.try_into().unwrap();
-    
+
-    *http_request.uri_mut() = format!("https://{}:8448{}", &destination.clone(), T::METADATA.path).parse().unwrap();
+    *http_request.uri_mut() = format!("https://{}:8448{}", &destination.clone(), T::METADATA.path)
+        .parse()
+        .unwrap();
 
     let mut request_map = serde_json::Map::new();
 
     if !http_request.body().is_empty() {
-        request_map.insert("content".to_owned(), 
+        request_map.insert(
-        serde_json::to_value(http_request.body()).unwrap());
+            "content".to_owned(),
+            serde_json::to_value(http_request.body()).unwrap(),
+        );
     };
 
     request_map.insert("method".to_owned(), T::METADATA.method.to_string().into());
     request_map.insert("uri".to_owned(), T::METADATA.path.into());
     request_map.insert("origin".to_owned(), data.hostname().into());
-    request_map.insert("destination".to_owned(), destination.to_string().into());
+    request_map.insert("destination".to_owned(), "privacytools.io".into());
-    //request_map.insert("signatures".to_owned(), json!({}));
 
     let mut request_json = request_map.into();
-    ruma_signatures::sign_json(data.hostname(), data.keypair(), dbg!(&mut request_json)).unwrap();
+    ruma_signatures::sign_json(data.hostname(), data.keypair(), &mut request_json).unwrap();
-    println!("{}", &request_json);
 
     let signatures = request_json["signatures"]
         .as_object()
@@ -67,10 +64,7 @@ pub async fn send_request<T: Endpoint>(
         );
     }
 
-    let reqwest_response = data
+    let reqwest_response = data.reqwest_client().execute(http_request.into()).await;
-        .reqwest_client()
-        .execute(dbg!(http_request.into()))
-        .await;
 
     // Because reqwest::Response -> http::Response is complicated:
     match reqwest_response {
@@ -92,15 +86,13 @@ pub async fn send_request<T: Endpoint>(
                 .into_iter()
                 .collect();
             Some(
-                <T::Response>::try_from(
+                <T::Response>::try_from(http_response.body(body).unwrap())
-                    dbg!(http_response.body(body)).unwrap(),
+                    .ok()
-                )
+                    .unwrap(),
-                .ok()
-                .unwrap(),
             )
         }
         Err(e) => {
-            println!("ERROR: {}", e);
+            error!("{}", e);
             None
         }
     }
@@ -114,7 +106,7 @@ pub fn well_known_server(data: State<Data>) -> Json<String> {
 }
 
 #[get("/_matrix/federation/v1/version")]
-pub fn get_server_version(data: State<Data>) -> MatrixResult<get_server_version::Response, Error> {
+pub fn get_server_version() -> MatrixResult<get_server_version::Response, Error> {
     MatrixResult(Ok(get_server_version::Response {
         server: get_server_version::Server {
             name: Some("Conduit".to_owned()),
@@ -123,8 +115,8 @@ pub fn get_server_version(data: State<Data>) -> MatrixResult<get_server_version:
     }))
 }
 
-#[get("/_matrix/key/v2/server", data = "<body>")]
+#[get("/_matrix/key/v2/server")]
-pub fn get_server_keys(data: State<Data>, body: Ruma<get_server_keys::Request>) -> Json<String> {
+pub fn get_server_keys(data: State<Data>) -> Json<String> {
     let mut verify_keys = BTreeMap::new();
     verify_keys.insert(
         format!("ed25519:{}", data.keypair().version()),
@@ -138,21 +130,20 @@ pub fn get_server_keys(data: State<Data>, body: Ruma<get_server_keys::Request>)
             verify_keys,
             old_verify_keys: BTreeMap::new(),
             signatures: BTreeMap::new(),
-            valid_until_ts: SystemTime::now() + Duration::from_secs(60 * 60 * 24),
+            valid_until_ts: SystemTime::now() + Duration::from_secs(60 * 2),
         })
         .unwrap()
         .body(),
     )
     .unwrap();
     ruma_signatures::sign_json(data.hostname(), data.keypair(), &mut response).unwrap();
-    Json(dbg!(response.to_string()))
+    Json(response.to_string())
 }
 
-#[get("/_matrix/key/v2/server/<_key_id>", data = "<body>")]
+#[get("/_matrix/key/v2/server/<_key_id>")]
 pub fn get_server_keys_deprecated(
     data: State<Data>,
-    body: Ruma<get_server_keys::Request>,
     _key_id: String,
 ) -> Json<String> {
-    get_server_keys(data, body)
+    get_server_keys(data)
 }

src/utils.rs

@@ -27,10 +27,8 @@ pub fn increment(old: Option<&[u8]>) -> Option<Vec<u8>> {
 
 pub fn generate_keypair(old: Option<&[u8]>) -> Option<Vec<u8>> {
     Some(
-        /*
         old.map(|s| s.to_vec())
-            .unwrap_or_else(|| */
+            .unwrap_or_else(|| ruma_signatures::Ed25519KeyPair::generate().unwrap()),
-        ruma_signatures::Ed25519KeyPair::generate().unwrap(),
     )
 }