char
/
conduit
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
conduit/src/client_server/message.rs

176 lines
5.6 KiB
Rust
Raw Normal View History

Sqlite
2021-07-14 07:07:08 +00:00
use crate::{database::DatabaseGuard, pdu::PduBuilder, utils, ConduitResult, Error, Ruma};
Keep track of State at event for state resolution feat: first steps towards joining rooms over federation Add state-res as a dependency of conduit Add reverse_topological_power_sort before append_pdu Implement statehashstatid_pduid tree for keeping track of state Clean up implementation of state_hash as key for tracking state
2020-08-06 12:29:59 +00:00
use ruma::{
api::client::{
error::ErrorKind,
r0::message::{get_message_events, send_message_event},
},
improvement: update ruma
2021-04-22 09:26:20 +00:00
events::EventType,
feat: handle txn ids
2020-08-25 11:24:38 +00:00
EventId,
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
};
Update state-res, use the new Event trait This also bumps ruma to latest and removes js_int infavor of the ruma re-export
2020-12-31 13:40:49 +00:00
use std::{
collections::BTreeMap,
convert::{TryFrom, TryInto},
};
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
#[cfg(feature = "conduit_bin")]
use rocket::{get, put};
#[cfg_attr(
feature = "conduit_bin",
put("/_matrix/client/r0/rooms/<_>/send/<_>/<_>", data = "<body>")
)]
feat: opentelemetry/jaeger support
2021-02-28 11:41:03 +00:00
#[tracing::instrument(skip(db, body))]
feat: send messages over federation
2020-09-14 18:23:19 +00:00
pub async fn send_message_event_route(
Sqlite
2021-07-14 07:07:08 +00:00
db: DatabaseGuard,
Update ruma version
2020-09-08 15:32:03 +00:00
body: Ruma<send_message_event::Request<'_>>,
Update ruma
2020-08-12 21:32:39 +00:00
) -> ConduitResult<send_message_event::Response> {
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device
2020-10-18 18:33:12 +00:00
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
feat: implement appservices this also reverts some stateres changes
2020-12-08 09:33:44 +00:00
let sender_device = body.sender_device.as_deref();
feat: handle txn ids
2020-08-25 11:24:38 +00:00
// Check if this is a new transaction id
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device
2020-10-18 18:33:12 +00:00
if let Some(response) =
db.transaction_ids
.existing_txnid(sender_user, sender_device, &body.txn_id)?
feat: handle txn ids
2020-08-25 11:24:38 +00:00
{
// The client might have sent a txnid of the /sendToDevice endpoint
// This txnid has no response associated with it
if response.is_empty() {
return Err(Error::BadRequest(
ErrorKind::InvalidParam,
"Tried to use txn id already used for an incompatible endpoint.",
));
}
let event_id = EventId::try_from(
utils::string_from_bytes(&response)
.map_err(|_| Error::bad_database("Invalid txnid bytes in database."))?,
)
.map_err(|_| Error::bad_database("Invalid event id in txnid data."))?;
return Ok(send_message_event::Response { event_id }.into());
}
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
Update state-res, use the new Event trait This also bumps ruma to latest and removes js_int infavor of the ruma re-export
2020-12-31 13:40:49 +00:00
let mut unsigned = BTreeMap::new();
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
unsigned.insert("transaction_id".to_owned(), body.txn_id.clone().into());
feat: admin room
2020-10-05 20:19:22 +00:00
let event_id = db.rooms.build_and_append_pdu(
PduBuilder {
improvement: update ruma
2021-04-22 09:26:20 +00:00
event_type: EventType::from(&body.event_type),
improvement: uiaa works like in synapse
2021-05-04 17:03:18 +00:00
content: serde_json::from_str(body.body.body.json().get())
.map_err(|_| Error::BadRequest(ErrorKind::BadJson, "Invalid JSON body."))?,
feat: admin room
2020-10-05 20:19:22 +00:00
unsigned: Some(unsigned),
state_key: None,
redacts: None,
},
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device
2020-10-18 18:33:12 +00:00
&sender_user,
feat: admin room
2020-10-05 20:19:22 +00:00
&body.room_id,
Fix ALL clippy warnings
2021-01-15 16:05:57 +00:00
&db,
feat: admin room
2020-10-05 20:19:22 +00:00
)?;
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device
2020-10-18 18:33:12 +00:00
db.transaction_ids.add_txnid(
sender_user,
sender_device,
&body.txn_id,
event_id.as_bytes(),
)?;
Merge remote-tracking branch 'origin/master' into federation
2020-09-12 20:13:53 +00:00
improvement: flush after every request that manipulates the db
2020-10-21 19:28:02 +00:00
db.flush().await?;
Keep track of State at event for state resolution feat: first steps towards joining rooms over federation Add state-res as a dependency of conduit Add reverse_topological_power_sort before append_pdu Implement statehashstatid_pduid tree for keeping track of state Clean up implementation of state_hash as key for tracking state
2020-08-06 12:29:59 +00:00
Ok(send_message_event::Response::new(event_id).into())
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
}
#[cfg_attr(
feature = "conduit_bin",
get("/_matrix/client/r0/rooms/<_>/messages", data = "<body>")
)]
feat: opentelemetry/jaeger support
2021-02-28 11:41:03 +00:00
#[tracing::instrument(skip(db, body))]
improvement: flush after every request that manipulates the db
2020-10-21 19:28:02 +00:00
pub async fn get_message_events_route(
Sqlite
2021-07-14 07:07:08 +00:00
db: DatabaseGuard,
Update ruma version
2020-09-08 15:32:03 +00:00
body: Ruma<get_message_events::Request<'_>>,
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
) -> ConduitResult<get_message_events::Response> {
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device
2020-10-18 18:33:12 +00:00
let sender_user = body.sender_user.as_ref().expect("user is authenticated");
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device
2020-10-18 18:33:12 +00:00
if !db.rooms.is_joined(sender_user, &body.room_id)? {
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
return Err(Error::BadRequest(
ErrorKind::Forbidden,
"You don't have permission to view this room.",
));
}
let from = body
.from
.clone()
.parse()
.map_err(|_| Error::BadRequest(ErrorKind::InvalidParam, "Invalid `from` value."))?;
let to = body.to.as_ref().map(|t| t.parse());
// Use limit or else 10
let limit = body
.limit
.try_into()
.map_or(Ok::<_, Error>(10_usize), |l: u32| Ok(l as usize))?;
match body.dir {
get_message_events::Direction::Forward => {
let events_after = db
.rooms
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device
2020-10-18 18:33:12 +00:00
.pdus_after(&sender_user, &body.room_id, from)
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
.take(limit)
.filter_map(|r| r.ok()) // Filter out buggy events
improvement: more efficient /sync with gaps
2020-09-17 12:44:47 +00:00
.filter_map(|(pdu_id, pdu)| {
db.rooms
.pdu_count(&pdu_id)
.map(|pdu_count| (pdu_count, pdu))
.ok()
})
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
.take_while(|&(k, _)| Some(Ok(k)) != to) // Stop at `to`
.collect::<Vec<_>>();
let end_token = events_after.last().map(|(count, _)| count.to_string());
let events_after = events_after
.into_iter()
.map(|(_, pdu)| pdu.to_room_event())
.collect::<Vec<_>>();
Keep track of State at event for state resolution feat: first steps towards joining rooms over federation Add state-res as a dependency of conduit Add reverse_topological_power_sort before append_pdu Implement statehashstatid_pduid tree for keeping track of state Clean up implementation of state_hash as key for tracking state
2020-08-06 12:29:59 +00:00
let mut resp = get_message_events::Response::new();
Update ruma version
2020-09-08 15:32:03 +00:00
resp.start = Some(body.from.to_owned());
Keep track of State at event for state resolution feat: first steps towards joining rooms over federation Add state-res as a dependency of conduit Add reverse_topological_power_sort before append_pdu Implement statehashstatid_pduid tree for keeping track of state Clean up implementation of state_hash as key for tracking state
2020-08-06 12:29:59 +00:00
resp.end = end_token;
resp.chunk = events_after;
resp.state = Vec::new();
Ok(resp.into())
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
}
get_message_events::Direction::Backward => {
let events_before = db
.rooms
fix: use device_id when registering TIL body.device_id != (*body).device_id, which is pretty bad, so I renamed body.device_id to body.sender_device
2020-10-18 18:33:12 +00:00
.pdus_until(&sender_user, &body.room_id, from)
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
.take(limit)
.filter_map(|r| r.ok()) // Filter out buggy events
improvement: more efficient /sync with gaps
2020-09-17 12:44:47 +00:00
.filter_map(|(pdu_id, pdu)| {
db.rooms
.pdu_count(&pdu_id)
.map(|pdu_count| (pdu_count, pdu))
.ok()
})
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
.take_while(|&(k, _)| Some(Ok(k)) != to) // Stop at `to`
.collect::<Vec<_>>();
let start_token = events_before.last().map(|(count, _)| count.to_string());
let events_before = events_before
.into_iter()
.map(|(_, pdu)| pdu.to_room_event())
.collect::<Vec<_>>();
Keep track of State at event for state resolution feat: first steps towards joining rooms over federation Add state-res as a dependency of conduit Add reverse_topological_power_sort before append_pdu Implement statehashstatid_pduid tree for keeping track of state Clean up implementation of state_hash as key for tracking state
2020-08-06 12:29:59 +00:00
let mut resp = get_message_events::Response::new();
Update ruma version
2020-09-08 15:32:03 +00:00
resp.start = Some(body.from.to_owned());
Keep track of State at event for state resolution feat: first steps towards joining rooms over federation Add state-res as a dependency of conduit Add reverse_topological_power_sort before append_pdu Implement statehashstatid_pduid tree for keeping track of state Clean up implementation of state_hash as key for tracking state
2020-08-06 12:29:59 +00:00
resp.end = start_token;
resp.chunk = events_before;
resp.state = Vec::new();
Ok(resp.into())
refactor: put endpoints into modules
2020-07-30 16:14:47 +00:00
}
}
}