backups/grapevine
1
0
Fork 0
mirror of https://gitlab.computer.surgery/matrix/grapevine.git synced 2025-12-17 15:51:23 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

sending.rs: move handler functions out of service

Browse source 
These don't take `self`, no reason for them to be associated functions.
This commit is contained in:
Lambda 2024-05-22 20:59:36 +00:00
parent 13f79dfee1
commit 9071e11e06
1 changed files with 239 additions and 245 deletions
Download patch file Download diff file Expand all files Collapse all files

168
src/service/sending.rs
View file

@ -191,7 +191,7 @@ impl Service {
for (outgoing_kind, events) in initial_transactions {
current_transaction_status
.insert(outgoing_kind.clone(), TransactionStatus::Running);
futures.push(Self::handle_events(outgoing_kind.clone(), events));
futures.push(handle_events(outgoing_kind.clone(), events));
}
loop {
@ -204,7 +204,7 @@ impl Service {
response,
&mut current_transaction_status,
)? {
futures.push(Self::handle_events(kind, events));
futures.push(handle_events(kind, events));
}
}
Some(data) = receiver.recv() => {
@ -214,7 +214,7 @@ impl Service {
}) = self
.handle_receiver(data, &mut current_transaction_status)
{
futures.push(Self::handle_events(kind, events));
futures.push(handle_events(kind, events));
}
}
}
@ -626,11 +626,62 @@ impl Service {
Ok(())
}
#[tracing::instrument(skip(events))]
async fn handle_appservice_event(
#[tracing::instrument(skip(self, request))]
pub(crate) async fn send_federation_request<T>(
&self,
destination: &ServerName,
request: T,
) -> Result<T::IncomingResponse>
where
T: OutgoingRequest + Debug,
{
debug!("Waiting for permit");
let permit = self.maximum_requests.acquire().await;
debug!("Got permit");
let response = tokio::time::timeout(
Duration::from_secs(2 * 60),
server_server::send_request(destination, request),
)
.await
.map_err(|_| {
warn!("Timeout waiting for server response of {destination}");
Error::BadServerResponse("Timeout waiting for server response")
})?;
drop(permit);
response
}
/// Sends a request to an appservice
///
/// Only returns None if there is no url specified in the appservice
/// registration file
#[tracing::instrument(
skip(self, registration, request),
fields(appservice_id = registration.id),
)]
pub(crate) async fn send_appservice_request<T>(
&self,
registration: Registration,
request: T,
) -> Result<Option<T::IncomingResponse>>
where
T: OutgoingRequest + Debug,
{
let permit = self.maximum_requests.acquire().await;
let response =
appservice_server::send_request(registration, request).await;
drop(permit);
response
}
}
#[tracing::instrument(skip(events))]
async fn handle_appservice_event(
id: &str,
events: Vec<SendingEventType>,
) -> Result<()> {
) -> Result<()> {
let mut pdu_jsons = Vec::new();
for event in &events {
@ -643,8 +694,8 @@ impl Service {
.get_pdu_from_id(pdu_id)?
.ok_or_else(|| {
Error::bad_database(
"[Appservice] Event in \
servernameevent_data not found in db.",
"[Appservice] Event in servernameevent_data \
not found in db.",
)
})?
.to_room_event(),
@ -659,13 +710,11 @@ impl Service {
let permit = services().sending.maximum_requests.acquire().await;
appservice_server::send_request(
services().appservice.get_registration(id).await.ok_or_else(
|| {
services().appservice.get_registration(id).await.ok_or_else(|| {
Error::bad_database(
"[Appservice] Could not load registration from db.",
)
},
)?,
})?,
appservice::event::push_events::v1::Request {
events: pdu_jsons,
txn_id: general_purpose::URL_SAFE_NO_PAD
@ -686,14 +735,14 @@ impl Service {
drop(permit);
Ok(())
}
}
#[tracing::instrument(skip(events))]
async fn handle_push_event(
#[tracing::instrument(skip(events))]
async fn handle_push_event(
userid: &UserId,
pushkey: &str,
events: Vec<SendingEventType>,
) -> Result<()> {
) -> Result<()> {
let mut pdus = Vec::new();
for event in &events {
@ -769,13 +818,13 @@ impl Service {
}
Ok(())
}
}
#[tracing::instrument(skip(events))]
async fn handle_federation_event(
#[tracing::instrument(skip(events))]
async fn handle_federation_event(
server: &ServerName,
events: Vec<SendingEventType>,
) -> Result<()> {
) -> Result<()> {
let mut edu_jsons = Vec::new();
let mut pdu_jsons = Vec::new();
@ -784,23 +833,19 @@ impl Service {
SendingEventType::Pdu(pdu_id) => {
// TODO: check room version and remove event_id if
// needed
pdu_jsons.push(
PduEvent::convert_to_outgoing_federation_event(
pdu_jsons.push(PduEvent::convert_to_outgoing_federation_event(
services()
.rooms
.timeline
.get_pdu_json_from_id(pdu_id)?
.ok_or_else(|| {
error!(
"event not found: {server} {pdu_id:?}"
);
error!("event not found: {server} {pdu_id:?}");
Error::bad_database(
"[Normal] Event in \
servernamevent_datas not found in db.",
"[Normal] Event in servernamevent_datas not \
found in db.",
)
})?,
),
);
));
}
SendingEventType::Edu(edu) => {
if let Ok(raw) = serde_json::from_slice(edu) {
@ -843,22 +888,22 @@ impl Service {
drop(permit);
Ok(())
}
}
#[tracing::instrument(skip_all)]
async fn handle_events(
#[tracing::instrument(skip_all)]
async fn handle_events(
kind: OutgoingKind,
events: Vec<SendingEventType>,
) -> HandlerResponse {
) -> HandlerResponse {
let ret = match &kind {
OutgoingKind::Appservice(id) => {
Self::handle_appservice_event(id, events).await
handle_appservice_event(id, events).await
}
OutgoingKind::Push(userid, pushkey) => {
Self::handle_push_event(userid, pushkey, events).await
handle_push_event(userid, pushkey, events).await
}
OutgoingKind::Normal(server) => {
Self::handle_federation_event(server, events).await
handle_federation_event(server, events).await
}
};
@ -866,55 +911,4 @@ impl Service {
Ok(()) => Ok(kind),
Err(e) => Err((kind, e)),
}
}
#[tracing::instrument(skip(self, request))]
pub(crate) async fn send_federation_request<T>(
&self,
destination: &ServerName,
request: T,
) -> Result<T::IncomingResponse>
where
T: OutgoingRequest + Debug,
{
debug!("Waiting for permit");
let permit = self.maximum_requests.acquire().await;
debug!("Got permit");
let response = tokio::time::timeout(
Duration::from_secs(2 * 60),
server_server::send_request(destination, request),
)
.await
.map_err(|_| {
warn!("Timeout waiting for server response of {destination}");
Error::BadServerResponse("Timeout waiting for server response")
})?;
drop(permit);
response
}
/// Sends a request to an appservice
///
/// Only returns None if there is no url specified in the appservice
/// registration file
#[tracing::instrument(
skip(self, registration, request),
fields(appservice_id = registration.id),
)]
pub(crate) async fn send_appservice_request<T>(
&self,
registration: Registration,
request: T,
) -> Result<Option<T::IncomingResponse>>
where
T: OutgoingRequest + Debug,
{
let permit = self.maximum_requests.acquire().await;
let response =
appservice_server::send_request(registration, request).await;
drop(permit);
response
}
}