Page MenuHomePhabricator
Differential D12968

[lib] rename `invalidateTunnelbrokerDeviceToken` -> `invalidateTunnelbrokerDeviceTokenActionType`
ClosedPublic
Actions

Authored by kamil on Aug 5 2024, 3:53 AM.
Tags
None
Referenced Files
Unknown Object (File)
Wed, Mar 12, 12:06 AM
Unknown Object (File)
Tue, Mar 4, 11:44 PM
Unknown Object (File)
Mon, Mar 3, 3:46 PM
Unknown Object (File)
Thu, Feb 27, 5:10 PM
Unknown Object (File)
Wed, Feb 26, 11:34 AM
Unknown Object (File)
Tue, Feb 25, 10:06 AM
Unknown Object (File)
Sun, Feb 23, 5:43 PM
Unknown Object (File)
Sun, Feb 23, 2:44 PM
View All Files
Subscribers
ashoat

Details

Reviewers
bartek
tomek
Commits
rCOMM4c77cea7e7a6: [lib] rename `invalidateTunnelbrokerDeviceToken` ->…
Summary

This addresses https://phab.comm.dev/D12912#inline-75150.

Depends on D12912

Test Plan

N/A

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
lib/
actions/
2 lines
reducers/
4 lines
tunnelbroker/
4 lines

Diff 43154

View Options

lib/actions/tunnelbroker-actions.js

Show All 13 Linesuse lapin::options::{
BasicCancelOptions, BasicConsumeOptions, BasicPublishOptions, BasicCancelOptions, BasicConsumeOptions, BasicPublishOptions,
QueueDeclareOptions, QueueDeleteOptions, QueueDeclareOptions, QueueDeleteOptions,
}; };
use lapin::types::FieldTable; use lapin::types::FieldTable;
use lapin::BasicProperties; use lapin::BasicProperties;
use tokio::io::AsyncRead; use tokio::io::AsyncRead;
use tokio::io::AsyncWrite; use tokio::io::AsyncWrite;
use tracing::{debug, error, info, trace}; use tracing::{debug, error, info, trace};
use tunnelbroker_messages::bad_device_token::BadDeviceToken;
use tunnelbroker_messages::{ use tunnelbroker_messages::{
message_to_device_request_status::Failure, message_to_device_request_status::Failure,
message_to_device_request_status::MessageSentStatus, session::DeviceTypes, message_to_device_request_status::MessageSentStatus, session::DeviceTypes,
DeviceToTunnelbrokerMessage, Heartbeat, MessageToDevice, DeviceToTunnelbrokerMessage, Heartbeat, MessageToDevice,
MessageToDeviceRequest, MessageToTunnelbroker, MessageToDeviceRequest, MessageToTunnelbroker,
}; };
use crate::notifs::apns::response::ErrorReason;
use crate::database::{self, DatabaseClient, MessageToDeviceExt}; use crate::database::{self, DatabaseClient, MessageToDeviceExt};
use crate::identity; use crate::identity;
use crate::notifs::apns::error::Error;
use crate::notifs::apns::headers::NotificationHeaders; use crate::notifs::apns::headers::NotificationHeaders;
use crate::notifs::apns::APNsNotif; use crate::notifs::apns::APNsNotif;
use crate::notifs::fcm::firebase_message::{ use crate::notifs::fcm::firebase_message::{
AndroidConfig, AndroidMessagePriority, FCMMessage, AndroidConfig, AndroidMessagePriority, FCMMessage,
}; };
use crate::notifs::web_push::WebPushNotif; use crate::notifs::web_push::WebPushNotif;
use crate::notifs::NotifClient; use crate::notifs::NotifClient;
▲ Show 20 Lines • Show All 337 Lines • ▼ Show 20 Lines match serialized_message {
debug!("Received APNs notif for {}", notif.device_id); debug!("Received APNs notif for {}", notif.device_id);
let Ok(headers) = let Ok(headers) =
serde_json::from_str::<NotificationHeaders>(&notif.headers) serde_json::from_str::<NotificationHeaders>(&notif.headers)
else { else {
return Some(MessageSentStatus::SerializationError(notif.headers)); return Some(MessageSentStatus::SerializationError(notif.headers));
}; };
let device_token = match self.get_device_token(notif.device_id).await { let device_token =
match self.get_device_token(notif.device_id.clone()).await {
Ok(token) => token, Ok(token) => token,
Err(e) => { Err(e) => {
return Some( return Some(self.get_message_to_device_status(
self &notif.client_message_id,
.get_message_to_device_status(&notif.client_message_id, Err(e)), Err(e),
) ))
} }
}; };
let apns_notif = APNsNotif { let apns_notif = APNsNotif {
device_token, device_token: device_token.clone(),
headers, headers,
payload: notif.payload, payload: notif.payload,
}; };
if let Some(apns) = self.notif_client.apns.clone() { if let Some(apns) = self.notif_client.apns.clone() {
let response = apns.send(apns_notif).await; let response = apns.send(apns_notif).await;
if let Err(Error::ResponseError(body)) = &response {
if matches!(
body.reason,
ErrorReason::BadDeviceToken
| ErrorReason::Unregistered
| ErrorReason::ExpiredToken
) {
if let Err(e) = self
.invalidate_device_token(notif.device_id, device_token)
.await
{
error!("Error invalidating device token: {:?}", e);
};
}
}
return Some( return Some(
self self
.get_message_to_device_status(&notif.client_message_id, response), .get_message_to_device_status(&notif.client_message_id, response),
); );
} }
Some(self.get_message_to_device_status( Some(self.get_message_to_device_status(
&notif.client_message_id, &notif.client_message_id,
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines match db_token {
Err(SessionError::InvalidDeviceToken) Err(SessionError::InvalidDeviceToken)
} else { } else {
Ok(token.device_token) Ok(token.device_token)
} }
} }
None => Err(SessionError::MissingDeviceToken), None => Err(SessionError::MissingDeviceToken),
} }
} }
async fn invalidate_device_token(
&self,
device_id: String,
invalidated_token: String,
) -> Result<(), SessionError> {
let bad_device_token_message = BadDeviceToken { invalidated_token };
let payload = serde_json::to_string(&bad_device_token_message)?;
let message_request = MessageToDeviceRequest {
client_message_id: uuid::Uuid::new_v4().to_string(),
device_id: device_id.to_string(),
payload,
};
self.handle_message_to_device(&message_request).await?;
self
.db_client
.mark_device_token_as_invalid(&device_id)
.await
.map_err(SessionError::DatabaseError)?;
Ok(())
}
} }
View Options

lib/reducers/tunnelbroker-device-token-reducer.js

Show All 13 Linesuse lapin::options::{
BasicCancelOptions, BasicConsumeOptions, BasicPublishOptions, BasicCancelOptions, BasicConsumeOptions, BasicPublishOptions,
QueueDeclareOptions, QueueDeleteOptions, QueueDeclareOptions, QueueDeleteOptions,
}; };
use lapin::types::FieldTable; use lapin::types::FieldTable;
use lapin::BasicProperties; use lapin::BasicProperties;
use tokio::io::AsyncRead; use tokio::io::AsyncRead;
use tokio::io::AsyncWrite; use tokio::io::AsyncWrite;
use tracing::{debug, error, info, trace}; use tracing::{debug, error, info, trace};
use tunnelbroker_messages::bad_device_token::BadDeviceToken;
use tunnelbroker_messages::{ use tunnelbroker_messages::{
message_to_device_request_status::Failure, message_to_device_request_status::Failure,
message_to_device_request_status::MessageSentStatus, session::DeviceTypes, message_to_device_request_status::MessageSentStatus, session::DeviceTypes,
DeviceToTunnelbrokerMessage, Heartbeat, MessageToDevice, DeviceToTunnelbrokerMessage, Heartbeat, MessageToDevice,
MessageToDeviceRequest, MessageToTunnelbroker, MessageToDeviceRequest, MessageToTunnelbroker,
}; };
use crate::notifs::apns::response::ErrorReason;
use crate::database::{self, DatabaseClient, MessageToDeviceExt}; use crate::database::{self, DatabaseClient, MessageToDeviceExt};
use crate::identity; use crate::identity;
use crate::notifs::apns::error::Error;
use crate::notifs::apns::headers::NotificationHeaders; use crate::notifs::apns::headers::NotificationHeaders;
use crate::notifs::apns::APNsNotif; use crate::notifs::apns::APNsNotif;
use crate::notifs::fcm::firebase_message::{ use crate::notifs::fcm::firebase_message::{
AndroidConfig, AndroidMessagePriority, FCMMessage, AndroidConfig, AndroidMessagePriority, FCMMessage,
}; };
use crate::notifs::web_push::WebPushNotif; use crate::notifs::web_push::WebPushNotif;
use crate::notifs::NotifClient; use crate::notifs::NotifClient;
▲ Show 20 Lines • Show All 337 Lines • ▼ Show 20 Lines match serialized_message {
debug!("Received APNs notif for {}", notif.device_id); debug!("Received APNs notif for {}", notif.device_id);
let Ok(headers) = let Ok(headers) =
serde_json::from_str::<NotificationHeaders>(&notif.headers) serde_json::from_str::<NotificationHeaders>(&notif.headers)
else { else {
return Some(MessageSentStatus::SerializationError(notif.headers)); return Some(MessageSentStatus::SerializationError(notif.headers));
}; };
let device_token = match self.get_device_token(notif.device_id).await { let device_token =
match self.get_device_token(notif.device_id.clone()).await {
Ok(token) => token, Ok(token) => token,
Err(e) => { Err(e) => {
return Some( return Some(self.get_message_to_device_status(
self &notif.client_message_id,
.get_message_to_device_status(&notif.client_message_id, Err(e)), Err(e),
) ))
} }
}; };
let apns_notif = APNsNotif { let apns_notif = APNsNotif {
device_token, device_token: device_token.clone(),
headers, headers,
payload: notif.payload, payload: notif.payload,
}; };
if let Some(apns) = self.notif_client.apns.clone() { if let Some(apns) = self.notif_client.apns.clone() {
let response = apns.send(apns_notif).await; let response = apns.send(apns_notif).await;
if let Err(Error::ResponseError(body)) = &response {
if matches!(
body.reason,
ErrorReason::BadDeviceToken
| ErrorReason::Unregistered
| ErrorReason::ExpiredToken
) {
if let Err(e) = self
.invalidate_device_token(notif.device_id, device_token)
.await
{
error!("Error invalidating device token: {:?}", e);
};
}
}
return Some( return Some(
self self
.get_message_to_device_status(&notif.client_message_id, response), .get_message_to_device_status(&notif.client_message_id, response),
); );
} }
Some(self.get_message_to_device_status( Some(self.get_message_to_device_status(
&notif.client_message_id, &notif.client_message_id,
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines match db_token {
Err(SessionError::InvalidDeviceToken) Err(SessionError::InvalidDeviceToken)
} else { } else {
Ok(token.device_token) Ok(token.device_token)
} }
} }
None => Err(SessionError::MissingDeviceToken), None => Err(SessionError::MissingDeviceToken),
} }
} }
async fn invalidate_device_token(
&self,
device_id: String,
invalidated_token: String,
) -> Result<(), SessionError> {
let bad_device_token_message = BadDeviceToken { invalidated_token };
let payload = serde_json::to_string(&bad_device_token_message)?;
let message_request = MessageToDeviceRequest {
client_message_id: uuid::Uuid::new_v4().to_string(),
device_id: device_id.to_string(),
payload,
};
self.handle_message_to_device(&message_request).await?;
self
.db_client
.mark_device_token_as_invalid(&device_id)
.await
.map_err(SessionError::DatabaseError)?;
Ok(())
}
} }
View Options

lib/tunnelbroker/use-peer-to-peer-message-handler.js

Show All 13 Linesuse lapin::options::{
BasicCancelOptions, BasicConsumeOptions, BasicPublishOptions, BasicCancelOptions, BasicConsumeOptions, BasicPublishOptions,
QueueDeclareOptions, QueueDeleteOptions, QueueDeclareOptions, QueueDeleteOptions,
}; };
use lapin::types::FieldTable; use lapin::types::FieldTable;
use lapin::BasicProperties; use lapin::BasicProperties;
use tokio::io::AsyncRead; use tokio::io::AsyncRead;
use tokio::io::AsyncWrite; use tokio::io::AsyncWrite;
use tracing::{debug, error, info, trace}; use tracing::{debug, error, info, trace};
use tunnelbroker_messages::bad_device_token::BadDeviceToken;
use tunnelbroker_messages::{ use tunnelbroker_messages::{
message_to_device_request_status::Failure, message_to_device_request_status::Failure,
message_to_device_request_status::MessageSentStatus, session::DeviceTypes, message_to_device_request_status::MessageSentStatus, session::DeviceTypes,
DeviceToTunnelbrokerMessage, Heartbeat, MessageToDevice, DeviceToTunnelbrokerMessage, Heartbeat, MessageToDevice,
MessageToDeviceRequest, MessageToTunnelbroker, MessageToDeviceRequest, MessageToTunnelbroker,
}; };
use crate::notifs::apns::response::ErrorReason;
use crate::database::{self, DatabaseClient, MessageToDeviceExt}; use crate::database::{self, DatabaseClient, MessageToDeviceExt};
use crate::identity; use crate::identity;
use crate::notifs::apns::error::Error;
use crate::notifs::apns::headers::NotificationHeaders; use crate::notifs::apns::headers::NotificationHeaders;
use crate::notifs::apns::APNsNotif; use crate::notifs::apns::APNsNotif;
use crate::notifs::fcm::firebase_message::{ use crate::notifs::fcm::firebase_message::{
AndroidConfig, AndroidMessagePriority, FCMMessage, AndroidConfig, AndroidMessagePriority, FCMMessage,
}; };
use crate::notifs::web_push::WebPushNotif; use crate::notifs::web_push::WebPushNotif;
use crate::notifs::NotifClient; use crate::notifs::NotifClient;
▲ Show 20 Lines • Show All 337 Lines • ▼ Show 20 Lines match serialized_message {
debug!("Received APNs notif for {}", notif.device_id); debug!("Received APNs notif for {}", notif.device_id);
let Ok(headers) = let Ok(headers) =
serde_json::from_str::<NotificationHeaders>(&notif.headers) serde_json::from_str::<NotificationHeaders>(&notif.headers)
else { else {
return Some(MessageSentStatus::SerializationError(notif.headers)); return Some(MessageSentStatus::SerializationError(notif.headers));
}; };
let device_token = match self.get_device_token(notif.device_id).await { let device_token =
match self.get_device_token(notif.device_id.clone()).await {
Ok(token) => token, Ok(token) => token,
Err(e) => { Err(e) => {
return Some( return Some(self.get_message_to_device_status(
self &notif.client_message_id,
.get_message_to_device_status(&notif.client_message_id, Err(e)), Err(e),
) ))
} }
}; };
let apns_notif = APNsNotif { let apns_notif = APNsNotif {
device_token, device_token: device_token.clone(),
headers, headers,
payload: notif.payload, payload: notif.payload,
}; };
if let Some(apns) = self.notif_client.apns.clone() { if let Some(apns) = self.notif_client.apns.clone() {
let response = apns.send(apns_notif).await; let response = apns.send(apns_notif).await;
if let Err(Error::ResponseError(body)) = &response {
if matches!(
body.reason,
ErrorReason::BadDeviceToken
| ErrorReason::Unregistered
| ErrorReason::ExpiredToken
) {
if let Err(e) = self
.invalidate_device_token(notif.device_id, device_token)
.await
{
error!("Error invalidating device token: {:?}", e);
};
}
}
return Some( return Some(
self self
.get_message_to_device_status(&notif.client_message_id, response), .get_message_to_device_status(&notif.client_message_id, response),
); );
} }
Some(self.get_message_to_device_status( Some(self.get_message_to_device_status(
&notif.client_message_id, &notif.client_message_id,
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines match db_token {
Err(SessionError::InvalidDeviceToken) Err(SessionError::InvalidDeviceToken)
} else { } else {
Ok(token.device_token) Ok(token.device_token)
} }
} }
None => Err(SessionError::MissingDeviceToken), None => Err(SessionError::MissingDeviceToken),
} }
} }
async fn invalidate_device_token(
&self,
device_id: String,
invalidated_token: String,
) -> Result<(), SessionError> {
let bad_device_token_message = BadDeviceToken { invalidated_token };
let payload = serde_json::to_string(&bad_device_token_message)?;
let message_request = MessageToDeviceRequest {
client_message_id: uuid::Uuid::new_v4().to_string(),
device_id: device_id.to_string(),
payload,
};
self.handle_message_to_device(&message_request).await?;
self
.db_client
.mark_device_token_as_invalid(&device_id)
.await
.map_err(SessionError::DatabaseError)?;
Ok(())
}
} }