char/conduit
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

feat: federated room directory

Browse source
This commit is contained in:
timokoesters 2020-04-25 11:47:32 +02:00
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
Show stats Download patch file Download diff file Expand all files Collapse all files

22
src/client_server.rs
View file

@ -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::<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
.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));

3
src/data.rs
View file

@ -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);

13
src/ruma_wrapper.rs
View file

@ -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<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;

67
src/server_server.rs
View file

@ -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<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(),
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<T: Endpoint>(
);
}
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<T: Endpoint>(
.into_iter()
.collect();
Some(
<T::Response>::try_from(
dbg!(http_response.body(body)).unwrap(),
)
.ok()
.unwrap(),
<T::Response>::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<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>")]
pub fn get_server_keys(data: State<Data>, body: Ruma<get_server_keys::Request>) -> Json<String> {
#[get("/_matrix/key/v2/server")]
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)
}

4
src/utils.rs
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>> {
Some(
/*
old.map(|s| s.to_vec())
.unwrap_or_else(|| */
ruma_signatures::Ed25519KeyPair::generate().unwrap(),
.unwrap_or_else(|| ruma_signatures::Ed25519KeyPair::generate().unwrap()),
)
}