crappyrules
/
conduit
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

feat: federated room directory

ruma
timokoesters 6 years ago
parent
120b6f4b95
commit
720cc0cffc
No known key found for this signature in database
GPG Key ID: 24DA7517711A2BA4
5 changed files with 43 additions and 66 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 22
      src/client_server.rs
  2. 3
      src/data.rs
  3. 13
      src/ruma_wrapper.rs
  4. 65
      src/server_server.rs
  5. 4
      src/utils.rs

22
src/client_server.rs
Unescape View File

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

3
src/data.rs
Unescape View File

@ -458,7 +458,8 @@ impl Data {
.expect("ruma's reference hashes are correct"); .expect("ruma's reference hashes are correct");
let mut pdu_json = serde_json::to_value(&pdu).unwrap(); 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); self.pdu_leaves_replace(&room_id, &pdu.event_id);

13
src/ruma_wrapper.rs
Unescape View File

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

65
src/server_server.rs
Unescape View File

@ -1,18 +1,14 @@
use crate::{utils, Data, MatrixResult, Ruma}; use crate::{Data, MatrixResult};
use http::header::{HeaderValue, AUTHORIZATION}; use http::header::{HeaderValue, AUTHORIZATION};
use log::error; 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 ruma_federation_api::{v1::get_server_version, v2::get_server_keys};
use serde_json::json; use serde_json::json;
use std::{ use std::{
collections::{BTreeMap, HashMap}, collections::BTreeMap,
convert::{TryFrom, TryInto}, convert::TryFrom,
path::PathBuf,
time::{Duration, SystemTime}, time::{Duration, SystemTime},
}; };
@ -20,28 +16,29 @@ pub async fn send_request<T: Endpoint>(
data: &crate::Data, data: &crate::Data,
destination: String, destination: String,
request: T, request: T,
) -> Option<T::Response> ) -> Option<T::Response> {
{
let mut http_request: http::Request<_> = request.try_into().unwrap(); 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(); let mut request_map = serde_json::Map::new();
if !http_request.body().is_empty() { 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("method".to_owned(), T::METADATA.method.to_string().into());
request_map.insert("uri".to_owned(), T::METADATA.path.into()); request_map.insert("uri".to_owned(), T::METADATA.path.into());
request_map.insert("origin".to_owned(), data.hostname().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(); 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"] let signatures = request_json["signatures"]
.as_object() .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: // Because reqwest::Response -> http::Response is complicated:
match reqwest_response { match reqwest_response {
@ -92,15 +86,13 @@ pub async fn send_request<T: Endpoint>(
.into_iter() .into_iter()
.collect(); .collect();
Some( 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) => { Err(e) => {
println!("ERROR: {}", e); error!("{}", e);
None None
} }
} }
@ -114,7 +106,7 @@ pub fn well_known_server(data: State<Data>) -> Json<String> {
} }
#[get("/_matrix/federation/v1/version")] #[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 { MatrixResult(Ok(get_server_version::Response {
server: get_server_version::Server { server: get_server_version::Server {
name: Some("Conduit".to_owned()), 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(); let mut verify_keys = BTreeMap::new();
verify_keys.insert( verify_keys.insert(
format!("ed25519:{}", data.keypair().version()), 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, verify_keys,
old_verify_keys: BTreeMap::new(), old_verify_keys: BTreeMap::new(),
signatures: 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() .unwrap()
.body(), .body(),
) )
.unwrap(); .unwrap();
ruma_signatures::sign_json(data.hostname(), data.keypair(), &mut response).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( pub fn get_server_keys_deprecated(
data: State<Data>, data: State<Data>,
body: Ruma<get_server_keys::Request>,
_key_id: String, _key_id: String,
) -> Json<String> { ) -> Json<String> {
get_server_keys(data, body) get_server_keys(data)
} }

4
src/utils.rs
Unescape View File

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

Write Preview
Loading…
Cancel
Save