Page MenuHomePhabricator
Differential D11219

[lib][native][web] Refactor useInitialNotificationsEncryptedMessage to get Olm session creator from context
ClosedPublic
Actions

Authored by ashoat on Mar 3 2024, 8:54 PM.
Tags
None
Referenced Files
F5896460: D11219.id37844.diff
Thu, Apr 17, 11:06 AM
F5882159: D11219.id37752.diff
Thu, Apr 17, 2:47 AM
F5875967: D11219.id.diff
Thu, Apr 17, 12:45 AM
Unknown Object (File)
Wed, Apr 16, 6:55 AM
Unknown Object (File)
Tue, Apr 8, 8:59 PM
Unknown Object (File)
Tue, Apr 8, 8:33 PM
Unknown Object (File)
Sat, Mar 29, 10:12 PM
Unknown Object (File)
Sun, Mar 23, 10:47 PM
View All 68 Files
Subscribers
None

Details

Reviewers
tomek
marcin
Commits
rCOMM590795109555: [lib][native][web] Refactor useInitialNotificationsEncryptedMessage to get Olm…
Summary

Now that we have a cross-platform context exposing this value, we can get it from there and simplify the API for useInitialNotificationsEncryptedMessage a little bit.

Depends on D11218

Test Plan

In addition to the plan described here: https://gist.github.com/Ashoat/75ab690d5c53cdd68a51b02e03e27c58

I also made sure that after session recovery, than an entry in the olm_sessions MariaDB table existed for the new cookie with is_content = 0

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
lib/
keyserver-conn/
1 line
selectors/
13 lines
shared/
35 lines
utils/
1 line
native/
account/
3 lines
13 lines
13 lines
12 lines
data/
3 lines
selectors/
14 lines
5 lines
web/
account/
13 lines
selectors/
12 lines
23 lines

Diff 37844

View Options

lib/keyserver-conn/recovery-utils.js

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines Ok(Self {
.try_into() .try_into()
.expect("Channels vec size doesn't match array size"), .expect("Channels vec size doesn't match array size"),
}) })
} }
fn get_channel( fn get_channel(
&self, &self,
id_hash: impl std::hash::Hash, id_hash: impl std::hash::Hash,
) -> Result<lapin::Channel, lapin::Error> { ) -> Option<lapin::Channel> {
let channel_idx = Self::channel_idx_for_hash(id_hash); let channel_idx = Self::channel_idx_for_hash(id_hash);
let channel = self.channels[channel_idx].clone(); let channel = self.channels[channel_idx].clone();
let channel_id = channel.id(); let channel_id = channel.id();
tracing::trace!(channel_id, channel_idx, "Retrieving AMQP Channel"); tracing::trace!(channel_id, channel_idx, "Retrieving AMQP Channel");
Ok(channel)
if channel.status().connected() {
return Some(channel);
}
warn!(channel_id, channel_idx, "Channel is dead!");
None
}
async fn reset_channel(
&mut self,
id_hash: impl std::hash::Hash,
) -> Result<lapin::Channel, lapin::Error> {
let channel_idx = Self::channel_idx_for_hash(id_hash);
let existing_channel = &self.channels[channel_idx];
if existing_channel.status().connected() {
return Ok(existing_channel.clone());
}
let new_channel = self.conn.create_channel().await?;
debug!(
"Channel for idx={channel_idx} was recreated, new Id={}",
new_channel.id()
);
self.channels[channel_idx] = new_channel.clone();
Ok(new_channel)
} }
fn is_connected(&self) -> bool { fn is_connected(&self) -> bool {
self.conn.status().connected() self.conn.status().connected()
} }
fn channel_idx_for_hash(id_hash: impl std::hash::Hash) -> usize { fn channel_idx_for_hash(id_hash: impl std::hash::Hash) -> usize {
// We have channel pool and want to distribute them between connected // We have channel pool and want to distribute them between connected
Show All 22 Lines pub async fn connect() -> Result<Self, lapin::Error> {
let inner = Arc::new(RwLock::new(conn)); let inner = Arc::new(RwLock::new(conn));
info!("Connected to AMQP endpoint: {}", &CONFIG.amqp_uri); info!("Connected to AMQP endpoint: {}", &CONFIG.amqp_uri);
Ok(Self { inner }) Ok(Self { inner })
} }
pub async fn channel( pub async fn channel(
&self, &self,
id_hash: impl std::hash::Hash, id_hash: impl std::hash::Hash + Clone,
) -> Result<lapin::Channel, lapin::Error> { ) -> Result<lapin::Channel, lapin::Error> {
if !self.is_connected().await { if !self.is_connected().await {
warn!("AMQP disconnected while retrieving channel"); warn!("AMQP disconnected while retrieving channel");
self.reset_conn().await?; self.reset_conn().await?;
} }
self.inner.read().await.get_channel(id_hash)
{
let inner = self.inner.read().await;
if let Some(channel) = inner.get_channel(id_hash.clone()) {
return Ok(channel);
}
}
self.inner.write().await.reset_channel(id_hash).await
} }
async fn reset_conn(&self) -> Result<(), lapin::Error> { async fn reset_conn(&self) -> Result<(), lapin::Error> {
debug!("Resetting connection..."); debug!("Resetting connection...");
let mut inner = self.inner.write().await; let mut inner = self.inner.write().await;
if !inner.is_connected() { if !inner.is_connected() {
let new_conn = ConnectionInner::new().await?; let new_conn = ConnectionInner::new().await?;
*inner = new_conn; *inner = new_conn;
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines
View Options

lib/selectors/socket-selectors.js

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines Ok(Self {
.try_into() .try_into()
.expect("Channels vec size doesn't match array size"), .expect("Channels vec size doesn't match array size"),
}) })
} }
fn get_channel( fn get_channel(
&self, &self,
id_hash: impl std::hash::Hash, id_hash: impl std::hash::Hash,
) -> Result<lapin::Channel, lapin::Error> { ) -> Option<lapin::Channel> {
let channel_idx = Self::channel_idx_for_hash(id_hash); let channel_idx = Self::channel_idx_for_hash(id_hash);
let channel = self.channels[channel_idx].clone(); let channel = self.channels[channel_idx].clone();
let channel_id = channel.id(); let channel_id = channel.id();
tracing::trace!(channel_id, channel_idx, "Retrieving AMQP Channel"); tracing::trace!(channel_id, channel_idx, "Retrieving AMQP Channel");
Ok(channel)
if channel.status().connected() {
return Some(channel);
}
warn!(channel_id, channel_idx, "Channel is dead!");
None
}
async fn reset_channel(
&mut self,
id_hash: impl std::hash::Hash,
) -> Result<lapin::Channel, lapin::Error> {
let channel_idx = Self::channel_idx_for_hash(id_hash);
let existing_channel = &self.channels[channel_idx];
if existing_channel.status().connected() {
return Ok(existing_channel.clone());
}
let new_channel = self.conn.create_channel().await?;
debug!(
"Channel for idx={channel_idx} was recreated, new Id={}",
new_channel.id()
);
self.channels[channel_idx] = new_channel.clone();
Ok(new_channel)
} }
fn is_connected(&self) -> bool { fn is_connected(&self) -> bool {
self.conn.status().connected() self.conn.status().connected()
} }
fn channel_idx_for_hash(id_hash: impl std::hash::Hash) -> usize { fn channel_idx_for_hash(id_hash: impl std::hash::Hash) -> usize {
// We have channel pool and want to distribute them between connected // We have channel pool and want to distribute them between connected
Show All 22 Lines pub async fn connect() -> Result<Self, lapin::Error> {
let inner = Arc::new(RwLock::new(conn)); let inner = Arc::new(RwLock::new(conn));
info!("Connected to AMQP endpoint: {}", &CONFIG.amqp_uri); info!("Connected to AMQP endpoint: {}", &CONFIG.amqp_uri);
Ok(Self { inner }) Ok(Self { inner })
} }
pub async fn channel( pub async fn channel(
&self, &self,
id_hash: impl std::hash::Hash, id_hash: impl std::hash::Hash + Clone,
) -> Result<lapin::Channel, lapin::Error> { ) -> Result<lapin::Channel, lapin::Error> {
if !self.is_connected().await { if !self.is_connected().await {
warn!("AMQP disconnected while retrieving channel"); warn!("AMQP disconnected while retrieving channel");
self.reset_conn().await?; self.reset_conn().await?;
} }
self.inner.read().await.get_channel(id_hash)
{
let inner = self.inner.read().await;
if let Some(channel) = inner.get_channel(id_hash.clone()) {
return Ok(channel);
}
}
self.inner.write().await.reset_channel(id_hash).await
} }
async fn reset_conn(&self) -> Result<(), lapin::Error> { async fn reset_conn(&self) -> Result<(), lapin::Error> {
debug!("Resetting connection..."); debug!("Resetting connection...");
let mut inner = self.inner.write().await; let mut inner = self.inner.write().await;
if !inner.is_connected() { if !inner.is_connected() {
let new_conn = ConnectionInner::new().await?; let new_conn = ConnectionInner::new().await?;
*inner = new_conn; *inner = new_conn;
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines
View Options

lib/shared/crypto-utils.js

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines Ok(Self {
.try_into() .try_into()
.expect("Channels vec size doesn't match array size"), .expect("Channels vec size doesn't match array size"),
}) })
} }
fn get_channel( fn get_channel(
&self, &self,
id_hash: impl std::hash::Hash, id_hash: impl std::hash::Hash,
) -> Result<lapin::Channel, lapin::Error> { ) -> Option<lapin::Channel> {
let channel_idx = Self::channel_idx_for_hash(id_hash); let channel_idx = Self::channel_idx_for_hash(id_hash);
let channel = self.channels[channel_idx].clone(); let channel = self.channels[channel_idx].clone();
let channel_id = channel.id(); let channel_id = channel.id();
tracing::trace!(channel_id, channel_idx, "Retrieving AMQP Channel"); tracing::trace!(channel_id, channel_idx, "Retrieving AMQP Channel");
Ok(channel)
if channel.status().connected() {
return Some(channel);
}
warn!(channel_id, channel_idx, "Channel is dead!");
None
}
async fn reset_channel(
&mut self,
id_hash: impl std::hash::Hash,
) -> Result<lapin::Channel, lapin::Error> {
let channel_idx = Self::channel_idx_for_hash(id_hash);
let existing_channel = &self.channels[channel_idx];
if existing_channel.status().connected() {
return Ok(existing_channel.clone());
}
let new_channel = self.conn.create_channel().await?;
debug!(
"Channel for idx={channel_idx} was recreated, new Id={}",
new_channel.id()
);
self.channels[channel_idx] = new_channel.clone();
Ok(new_channel)
} }
fn is_connected(&self) -> bool { fn is_connected(&self) -> bool {
self.conn.status().connected() self.conn.status().connected()
} }
fn channel_idx_for_hash(id_hash: impl std::hash::Hash) -> usize { fn channel_idx_for_hash(id_hash: impl std::hash::Hash) -> usize {
// We have channel pool and want to distribute them between connected // We have channel pool and want to distribute them between connected
Show All 22 Lines pub async fn connect() -> Result<Self, lapin::Error> {
let inner = Arc::new(RwLock::new(conn)); let inner = Arc::new(RwLock::new(conn));
info!("Connected to AMQP endpoint: {}", &CONFIG.amqp_uri); info!("Connected to AMQP endpoint: {}", &CONFIG.amqp_uri);
Ok(Self { inner }) Ok(Self { inner })
} }
pub async fn channel( pub async fn channel(
&self, &self,
id_hash: impl std::hash::Hash, id_hash: impl std::hash::Hash + Clone,
) -> Result<lapin::Channel, lapin::Error> { ) -> Result<lapin::Channel, lapin::Error> {
if !self.is_connected().await { if !self.is_connected().await {
warn!("AMQP disconnected while retrieving channel"); warn!("AMQP disconnected while retrieving channel");
self.reset_conn().await?; self.reset_conn().await?;
} }
self.inner.read().await.get_channel(id_hash)
{
let inner = self.inner.read().await;
if let Some(channel) = inner.get_channel(id_hash.clone()) {
return Ok(channel);
}
}
self.inner.write().await.reset_channel(id_hash).await
} }
async fn reset_conn(&self) -> Result<(), lapin::Error> { async fn reset_conn(&self) -> Result<(), lapin::Error> {
debug!("Resetting connection..."); debug!("Resetting connection...");
let mut inner = self.inner.write().await; let mut inner = self.inner.write().await;
if !inner.is_connected() { if !inner.is_connected() {
let new_conn = ConnectionInner::new().await?; let new_conn = ConnectionInner::new().await?;
*inner = new_conn; *inner = new_conn;
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines
View Options

lib/utils/config.js

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines Ok(Self {
.try_into() .try_into()
.expect("Channels vec size doesn't match array size"), .expect("Channels vec size doesn't match array size"),
}) })
} }
fn get_channel( fn get_channel(
&self, &self,
id_hash: impl std::hash::Hash, id_hash: impl std::hash::Hash,
) -> Result<lapin::Channel, lapin::Error> { ) -> Option<lapin::Channel> {
let channel_idx = Self::channel_idx_for_hash(id_hash); let channel_idx = Self::channel_idx_for_hash(id_hash);
let channel = self.channels[channel_idx].clone(); let channel = self.channels[channel_idx].clone();
let channel_id = channel.id(); let channel_id = channel.id();
tracing::trace!(channel_id, channel_idx, "Retrieving AMQP Channel"); tracing::trace!(channel_id, channel_idx, "Retrieving AMQP Channel");
Ok(channel)
if channel.status().connected() {
return Some(channel);
}
warn!(channel_id, channel_idx, "Channel is dead!");
None
}
async fn reset_channel(
&mut self,
id_hash: impl std::hash::Hash,
) -> Result<lapin::Channel, lapin::Error> {
let channel_idx = Self::channel_idx_for_hash(id_hash);
let existing_channel = &self.channels[channel_idx];
if existing_channel.status().connected() {
return Ok(existing_channel.clone());
}
let new_channel = self.conn.create_channel().await?;
debug!(
"Channel for idx={channel_idx} was recreated, new Id={}",
new_channel.id()
);
self.channels[channel_idx] = new_channel.clone();
Ok(new_channel)
} }
fn is_connected(&self) -> bool { fn is_connected(&self) -> bool {
self.conn.status().connected() self.conn.status().connected()
} }
fn channel_idx_for_hash(id_hash: impl std::hash::Hash) -> usize { fn channel_idx_for_hash(id_hash: impl std::hash::Hash) -> usize {
// We have channel pool and want to distribute them between connected // We have channel pool and want to distribute them between connected
Show All 22 Lines pub async fn connect() -> Result<Self, lapin::Error> {
let inner = Arc::new(RwLock::new(conn)); let inner = Arc::new(RwLock::new(conn));
info!("Connected to AMQP endpoint: {}", &CONFIG.amqp_uri); info!("Connected to AMQP endpoint: {}", &CONFIG.amqp_uri);
Ok(Self { inner }) Ok(Self { inner })
} }
pub async fn channel( pub async fn channel(
&self, &self,
id_hash: impl std::hash::Hash, id_hash: impl std::hash::Hash + Clone,
) -> Result<lapin::Channel, lapin::Error> { ) -> Result<lapin::Channel, lapin::Error> {
if !self.is_connected().await { if !self.is_connected().await {
warn!("AMQP disconnected while retrieving channel"); warn!("AMQP disconnected while retrieving channel");
self.reset_conn().await?; self.reset_conn().await?;
} }
self.inner.read().await.get_channel(id_hash)
{
let inner = self.inner.read().await;
if let Some(channel) = inner.get_channel(id_hash.clone()) {
return Ok(channel);
}
}
self.inner.write().await.reset_channel(id_hash).await
} }
async fn reset_conn(&self) -> Result<(), lapin::Error> { async fn reset_conn(&self) -> Result<(), lapin::Error> {
debug!("Resetting connection..."); debug!("Resetting connection...");
let mut inner = self.inner.write().await; let mut inner = self.inner.write().await;
if !inner.is_connected() { if !inner.is_connected() {
let new_conn = ConnectionInner::new().await?; let new_conn = ConnectionInner::new().await?;
*inner = new_conn; *inner = new_conn;
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines
View Options

native/account/legacy-recover-keyserver-session.js

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 Lines Ok(Self {
.try_into() .try_into()
.expect("Channels vec size doesn't match array size"), .expect("Channels vec size doesn't match array size"),
}) })
} }
fn get_channel( fn get_channel(
&self, &self,
id_hash: impl std::hash::Hash, id_hash: impl std::hash::Hash,
) -> Result<lapin::Channel, lapin::Error> { ) -> Option<lapin::Channel> {
let channel_idx = Self::channel_idx_for_hash(id_hash); let channel_idx = Self::channel_idx_for_hash(id_hash);
let channel = self.channels[channel_idx].clone(); let channel = self.channels[channel_idx].clone();
let channel_id = channel.id(); let channel_id = channel.id();
tracing::trace!(channel_id, channel_idx, "Retrieving AMQP Channel"); tracing::trace!(channel_id, channel_idx, "Retrieving AMQP Channel");
Ok(channel)
if channel.status().connected() {
return Some(channel);
}
warn!(channel_id, channel_idx, "Channel is dead!");
None
}
async fn reset_channel(
&mut self,
id_hash: impl std::hash::Hash,
) -> Result<lapin::Channel, lapin::Error> {
let channel_idx = Self::channel_idx_for_hash(id_hash);
let existing_channel = &self.channels[channel_idx];
if existing_channel.status().connected() {
return Ok(existing_channel.clone());
}
let new_channel = self.conn.create_channel().await?;
debug!(
"Channel for idx={channel_idx} was recreated, new Id={}",
new_channel.id()
);
self.channels[channel_idx] = new_channel.clone();
Ok(new_channel)
} }
fn is_connected(&self) -> bool { fn is_connected(&self) -> bool {
self.conn.status().connected() self.conn.status().connected()
} }
fn channel_idx_for_hash(id_hash: impl std::hash::Hash) -> usize { fn channel_idx_for_hash(id_hash: impl std::hash::Hash) -> usize {
// We have channel pool and want to distribute them between connected // We have channel pool and want to distribute them between connected
Show All 22 Lines pub async fn connect() -> Result<Self, lapin::Error> {
let inner = Arc::new(RwLock::new(conn)); let inner = Arc::new(RwLock::new(conn));
info!("Connected to AMQP endpoint: {}", &CONFIG.amqp_uri); info!("Connected to AMQP endpoint: {}", &CONFIG.amqp_uri);
Ok(Self { inner }) Ok(Self { inner })
} }
pub async fn channel( pub async fn channel(
&self, &self,
id_hash: impl std::hash::Hash, id_hash: impl std::hash::Hash + Clone,
) -> Result<lapin::Channel, lapin::Error> { ) -> Result<lapin::Channel, lapin::Error> {
if !self.is_connected().await { if !self.is_connected().await {
warn!("AMQP disconnected while retrieving channel"); warn!("AMQP disconnected while retrieving channel");
self.reset_conn().await?; self.reset_conn().await?;
} }
self.inner.read().await.get_channel(id_hash)
{
let inner = self.inner.read().await;
if let Some(channel) = inner.get_channel(id_hash.clone()) {
return Ok(channel);
}
}
self.inner.write().await.reset_channel(id_hash).await
} }
async fn reset_conn(&self) -> Result<(), lapin::Error> { async fn reset_conn(&self) -> Result<(), lapin::Error> {
debug!("Resetting connection..."); debug!("Resetting connection...");
let mut inner = self.inner.write().await; let mut inner = self.inner.write().await;
if !inner.is_connected() { if !inner.is_connected() {
let new_conn = ConnectionInner::new().await?; let new_conn = ConnectionInner::new().await?;
*inner = new_conn; *inner = new_conn;
▲ Show 20 Lines • Show All 41 Lines • Show Last 20 Lines
View Options

native/account/log-in-panel.react.js

Loading...
View Options

native/account/register-panel.react.js

Loading...
View Options

native/account/siwe-hooks.js

Loading...
View Options

native/data/sqlite-data-handler.js

Loading...
View Options

native/selectors/socket-selectors.js

Loading...
View Options

native/socket.react.js

Loading...
View Options

web/account/account-hooks.js

Loading...
View Options

web/selectors/socket-selectors.js

Loading...
View Options

web/socket.react.js

Loading...