public
/
j7s-matrix-sdk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Cleanup

This commit is contained in:
James Pace 2025-02-16 10:26:12 -05:00
parent c0cd3c56c4
commit ddba2763cb
4 changed files with 1 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/bin/broadcaster.rs
View File

@ -4,7 +4,7 @@ async fn main() -> anyhow::Result<()> {
let token = std::env::var("TOKEN")?;
let device_name = "my_bot";
let broadcaster = j7s_matrix_sdk::MatrixBroadcaster::new(&url, &token, &device_name).await?;
let broadcaster = j7s_matrix_sdk::MatrixListener::new(&url, &token, &device_name).await?;
let message = matrix_sdk::ruma::events::room::message::MessageType::text_plain("Hi!");
loop {

87
src/bin/ex.rs
View File

@ -1,87 +0,0 @@
use matrix_sdk::{
config::SyncSettings,
ruma::events::room::{
member::StrippedRoomMemberEvent,
message::{MessageType, OriginalSyncRoomMessageEvent, RoomMessageEventContent},
},
Client, Room, RoomState,
};
use tokio::time::{sleep, Duration};
#[tokio::main]
async fn main() -> anyhow::Result<()> {
let client = Client::builder()
.homeserver_url("http://matrix.internal.jpace121.net:8008")
.build()
.await?;
let token = std::env::var("TOKEN")?;
// First we need to log in.
let mut login_data = serde_json::Map::new();
login_data.insert("token".to_string(), token.into());
client
.matrix_auth()
.login_custom("org.matrix.login.jwt", login_data)?
.initial_device_display_name("bot")
.send()
.await?;
client.add_event_handler(on_stripped_state_member);
let sync_token = client
.sync_once(SyncSettings::default())
.await
.unwrap()
.next_batch;
client.add_event_handler(on_room_message);
let settings = SyncSettings::default().token(sync_token);
client.sync(settings).await?;
Ok(())
}
// This is going to respond to invites.
async fn on_stripped_state_member(
room_member: StrippedRoomMemberEvent,
client: Client,
room: Room,
) {
if room_member.state_key != client.user_id().unwrap() {
return;
}
tokio::spawn(async move {
println!("Autojoining room {}", room.room_id());
let mut delay = 2;
while let Err(err) = room.join().await {
sleep(Duration::from_secs(delay)).await;
delay *= 2;
if delay > 3600 {
eprintln!("Can't join room {} ({err:?})", room.room_id());
break;
}
}
println!("Successfully joined room {}", room.room_id());
});
}
async fn on_room_message(event: OriginalSyncRoomMessageEvent, room: Room, client: Client) {
if room.state() != RoomState::Joined {
return;
}
if event.sender == client.user_id().unwrap() {
return;
}
let MessageType::Text(text_content) = event.content.msgtype else {
return;
};
println!("{:?}", text_content.body);
let content = RoomMessageEventContent::text_plain("i am groot");
room.send(content).await.unwrap();
}

117
src/broadcaster.rs
View File

@ -1,117 +0,0 @@
use anyhow::Context;
use std::sync::Arc;
use tokio::sync::RwLock;
#[derive(Clone)]
pub struct MatrixBroadcaster {
client: Arc<matrix_sdk::Client>,
rooms: Arc<RwLock<Vec<matrix_sdk::Room>>>,
}
impl MatrixBroadcaster {
pub async fn new(url: &str, token: &str, device_name: &str) -> anyhow::Result<Self> {
let mut login_data = serde_json::Map::new();
login_data.insert("token".to_string(), token.into());
// Make a client.
let client = matrix_sdk::Client::builder()
.homeserver_url(url)
.build()
.await
.context("Could not build client.")?;
// Now log the client in.
client
.matrix_auth()
.login_custom("org.matrix.login.jwt", login_data)
.context("Failed to set custom login up.")?
.initial_device_display_name(device_name)
.send()
.await
.context("Failed to login.")?;
// Build our object with the client.
let object = Self {
client: Arc::new(client),
rooms: Arc::new(RwLock::new(Vec::new())),
};
object.spin().await?;
return Ok(object);
}
pub async fn broadcast(
self: &Self,
msg: &matrix_sdk::ruma::events::room::message::MessageType,
) -> anyhow::Result<()> {
let rooms_clone = self.rooms.clone();
let rooms = rooms_clone.read().await.clone();
for room in rooms {
room.send(
matrix_sdk::ruma::events::room::message::RoomMessageEventContent::new(msg.clone()),
)
.await
.context("Failed to send message to room.")?;
}
Ok(())
}
async fn spin(self: &Self) -> anyhow::Result<()> {
// The callback function.
let clone_of_me = self.clone();
let on_stripped_state_member =
|room_member: matrix_sdk::ruma::events::room::member::StrippedRoomMemberEvent,
client: matrix_sdk::Client,
room: matrix_sdk::Room| async move {
clone_of_me.join_callback(room_member, client, room).await;
};
self.client.add_event_handler(on_stripped_state_member);
// Spawn a task to sync.
let spawn_client = self.client.clone();
tokio::spawn(async move {
let sync_err = spawn_client
.sync(matrix_sdk::config::SyncSettings::default())
.await;
if sync_err.is_err() {
log::error!("Sync error: {:?}", sync_err);
}
});
Ok(())
}
async fn join_callback(
self: &Self,
room_member: matrix_sdk::ruma::events::room::member::StrippedRoomMemberEvent,
client: matrix_sdk::Client,
room: matrix_sdk::Room,
) {
// This event wasn't for me...
if room_member.state_key != client.user_id().unwrap() {
return;
}
// Spawn a task to try to join the room.
let self_copy = self.clone();
tokio::spawn(async move {
log::debug!("Autojoining room {}", room.room_id());
let mut delay = 2;
while let Err(err) = room.join().await {
tokio::time::sleep(tokio::time::Duration::from_secs(delay)).await;
delay *= 2;
if delay > 3600 {
log::debug!("Can't join room {} ({err:?})", room.room_id());
break;
}
}
log::debug!("Successfully joined room {}", room.room_id());
let rooms_clone = self_copy.rooms.clone();
let mut rooms = rooms_clone.write().await;
rooms.push(room);
log::debug!("Tracking {} rooms.", rooms.len());
});
}
}

3
src/lib.rs
View File

@ -1,5 +1,2 @@
mod broadcaster;
mod listener;
pub use broadcaster::*;
pub use listener::*;