Page MenuHomePhabricator
Differential D13592

[tunnelbroker] Run AMQP on Tokio runtime
ClosedPublic
Actions

Authored by bartek on Oct 3 2024, 8:37 AM.
Tags
None
Referenced Files
Unknown Object (File)
Mon, Mar 31, 8:34 AM
Unknown Object (File)
Wed, Mar 26, 2:08 PM
Unknown Object (File)
Mar 17 2025, 2:30 AM
Unknown Object (File)
Mar 12 2025, 4:51 AM
Unknown Object (File)
Mar 11 2025, 3:55 PM
Unknown Object (File)
Mar 11 2025, 3:26 PM
Unknown Object (File)
Mar 9 2025, 6:57 PM
Unknown Object (File)
Feb 24 2025, 8:26 PM
View All 56 Files
Subscribers
ashoat
tomek

Details

Reviewers
kamil
will
varun
Commits
rCOMM39ddee6b6774: [tunnelbroker] Run AMQP on Tokio runtime
Summary

By default, lapin uses some other executor, but has configuration to use Tokio. We should be doing that as we use Tokio everywhere.

Depends on D13591

Test Plan

tunnelbroker integration tests

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
services/
tunnelbroker/
2 lines
src/
6 lines

Diff 44927

View Options

Cargo.lock

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

services/tunnelbroker/Cargo.toml

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

services/tunnelbroker/src/amqp.rs

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