From 720cc0cffce3363dee2aacbccc6fd53b76ac8397 Mon Sep 17 00:00:00 2001 From: timokoesters Date: Sat, 25 Apr 2020 11:47:32 +0200 Subject: [PATCH] feat: federated room directory --- src/client_server.rs | 22 ++++++--------- src/data.rs | 3 +- src/ruma_wrapper.rs | 13 ++------- src/server_server.rs | 67 +++++++++++++++++++------------------------- src/utils.rs | 4 +-- 5 files changed, 43 insertions(+), 66 deletions(-) diff --git a/src/client_server.rs b/src/client_server.rs index 2c88daac..dac5e47d 100644 --- a/src/client_server.rs +++ b/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}, - convert::{TryFrom, TryInto}, + collections::BTreeMap, + convert::TryInto, path::PathBuf, time::{Duration, SystemTime}, }; @@ -753,10 +753,12 @@ pub async fn get_public_rooms_filtered_route( }) .collect::>(); + 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::>(), ); - 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 - .into_iter() - .map(|pdu| pdu.to_room_event()) - .collect(); + let room_events = pdus.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 - .into_iter() - .map(|pdu| pdu.to_room_event()) - .collect(); + let room_events = pdus.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)); diff --git a/src/data.rs b/src/data.rs index 864536f6..8096a081 100644 --- a/src/data.rs +++ b/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); diff --git a/src/ruma_wrapper.rs b/src/ruma_wrapper.rs index 81294a45..1d3328b7 100644 --- a/src/ruma_wrapper.rs +++ b/src/ruma_wrapper.rs @@ -6,15 +6,9 @@ use rocket::{ Outcome::*, Request, State, }; -use ruma_api::{ - Endpoint -}; +use ruma_api::Endpoint; use ruma_identifiers::UserId; -use std::{ - convert::{TryInto}, - io::Cursor, - ops::Deref, -}; +use std::{convert::TryInto, io::Cursor, ops::Deref}; use tokio::io::AsyncReadExt; const MESSAGE_LIMIT: u64 = 65535; @@ -27,8 +21,7 @@ pub struct Ruma { pub json_body: serde_json::Value, } -impl<'a, T: Endpoint> FromData<'a> for Ruma -{ +impl<'a, T: Endpoint> FromData<'a> for Ruma { type Error = (); // TODO: Better error handling type Owned = Data; type Borrowed = Self::Owned; diff --git a/src/server_server.rs b/src/server_server.rs index 13e1a3fd..a62f23b7 100644 --- a/src/server_server.rs +++ b/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 ruma_api::{ - error::{FromHttpRequestError, FromHttpResponseError}, - Endpoint, -}; -use ruma_client_api::error::{Error, ErrorKind}; +use rocket::{get, post, put, response::content::Json, State}; +use ruma_api::Endpoint; +use ruma_client_api::error::Error; use ruma_federation_api::{v1::get_server_version, v2::get_server_keys}; use serde_json::json; use std::{ - collections::{BTreeMap, HashMap}, - convert::{TryFrom, TryInto}, - path::PathBuf, + collections::BTreeMap, + convert::TryFrom, time::{Duration, SystemTime}, }; @@ -20,28 +16,29 @@ pub async fn send_request( data: &crate::Data, destination: String, request: T, -) -> Option -{ +) -> Option { 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(), - serde_json::to_value(http_request.body()).unwrap()); + request_map.insert( + "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("signatures".to_owned(), json!({})); + request_map.insert("destination".to_owned(), "privacytools.io".into()); let mut request_json = request_map.into(); - ruma_signatures::sign_json(data.hostname(), data.keypair(), dbg!(&mut request_json)).unwrap(); - println!("{}", &request_json); + ruma_signatures::sign_json(data.hostname(), data.keypair(), &mut request_json).unwrap(); let signatures = request_json["signatures"] .as_object() @@ -67,10 +64,7 @@ pub async fn send_request( ); } - let reqwest_response = data - .reqwest_client() - .execute(dbg!(http_request.into())) - .await; + let reqwest_response = data.reqwest_client().execute(http_request.into()).await; // Because reqwest::Response -> http::Response is complicated: match reqwest_response { @@ -92,15 +86,13 @@ pub async fn send_request( .into_iter() .collect(); Some( - ::try_from( - dbg!(http_response.body(body)).unwrap(), - ) - .ok() - .unwrap(), + ::try_from(http_response.body(body).unwrap()) + .ok() + .unwrap(), ) } Err(e) => { - println!("ERROR: {}", e); + error!("{}", e); None } } @@ -114,7 +106,7 @@ pub fn well_known_server(data: State) -> Json { } #[get("/_matrix/federation/v1/version")] -pub fn get_server_version(data: State) -> MatrixResult { +pub fn get_server_version() -> MatrixResult { 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) -> MatrixResult, body: Ruma) -> Json { +#[get("/_matrix/key/v2/server")] +pub fn get_server_keys(data: State) -> Json { 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, body: Ruma) 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 = "")] +#[get("/_matrix/key/v2/server/<_key_id>")] pub fn get_server_keys_deprecated( data: State, - body: Ruma, _key_id: String, ) -> Json { - get_server_keys(data, body) + get_server_keys(data) } diff --git a/src/utils.rs b/src/utils.rs index 07a99f1b..a3600360 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -27,10 +27,8 @@ pub fn increment(old: Option<&[u8]>) -> Option> { pub fn generate_keypair(old: Option<&[u8]>) -> Option> { Some( - /* old.map(|s| s.to_vec()) - .unwrap_or_else(|| */ - ruma_signatures::Ed25519KeyPair::generate().unwrap(), + .unwrap_or_else(|| ruma_signatures::Ed25519KeyPair::generate().unwrap()), ) }