parent
1ea3aa7cb0
commit
5a631f785e
GPG Key ID:
2C5FD5035250423D
@ -0,0 +1,209 @@ |
||||
use std::sync::Arc; |
||||
use std::time::{Duration, Instant}; |
||||
|
||||
use elefren::{FediClient, StatusBuilder}; |
||||
use elefren::debug::EventDisplay; |
||||
use elefren::debug::NotificationDisplay; |
||||
use elefren::entities::event::Event; |
||||
use elefren::entities::notification::{Notification, NotificationType}; |
||||
use elefren::status_builder::Visibility; |
||||
use futures::StreamExt; |
||||
|
||||
use crate::store::{ConfigStore, GroupError}; |
||||
use crate::store::data::GroupConfig; |
||||
use crate::utils::LogError; |
||||
|
||||
/// This is one group's config store capable of persistence
|
||||
#[derive(Debug)] |
||||
pub struct GroupHandle { |
||||
pub(crate) client: FediClient, |
||||
pub(crate) config: GroupConfig, |
||||
pub(crate) store: Arc<ConfigStore>, |
||||
} |
||||
|
||||
impl GroupHandle { |
||||
pub async fn save(&mut self) -> Result<(), GroupError> { |
||||
debug!("Saving group config & status"); |
||||
self.store.set_group_config(self.config.clone()).await?; |
||||
self.config.clear_dirty_status(); |
||||
Ok(()) |
||||
} |
||||
|
||||
pub async fn save_if_needed(&mut self) -> Result<(), GroupError> { |
||||
if self.config.is_dirty() { |
||||
self.save().await?; |
||||
} |
||||
Ok(()) |
||||
} |
||||
|
||||
pub async fn reload(&mut self) -> Result<(), GroupError> { |
||||
if let Some(g) = self.store.get_group_config(self.config.get_acct()).await { |
||||
self.config = g; |
||||
Ok(()) |
||||
} else { |
||||
Err(GroupError::GroupNotExist) |
||||
} |
||||
} |
||||
} |
||||
|
||||
trait NotifTimestamp { |
||||
fn timestamp_millis(&self) -> u64; |
||||
} |
||||
|
||||
impl NotifTimestamp for Notification { |
||||
fn timestamp_millis(&self) -> u64 { |
||||
self.created_at.timestamp_millis().max(0) as u64 |
||||
} |
||||
} |
||||
|
||||
impl GroupHandle { |
||||
pub async fn run(&mut self) -> Result<(), GroupError> { |
||||
const PERIODIC_SAVE: Duration = Duration::from_secs(60); |
||||
const PING_INTERVAL: Duration = Duration::from_secs(15); |
||||
|
||||
assert!(PERIODIC_SAVE >= PING_INTERVAL); |
||||
|
||||
let mut next_save = Instant::now() + PERIODIC_SAVE; // so we save at start
|
||||
|
||||
loop { |
||||
debug!("Opening streaming API socket"); |
||||
let mut events = self.client.streaming_user().await?; |
||||
|
||||
match self.catch_up_with_missed_notifications().await { |
||||
Ok(true) => { |
||||
debug!("Some missed notifs handled"); |
||||
// Save asap!
|
||||
next_save = Instant::now() - PERIODIC_SAVE |
||||
} |
||||
Ok(false) => { |
||||
debug!("No notifs missed"); |
||||
} |
||||
Err(e) => { |
||||
error!("Failed to handle missed notifs: {}", e); |
||||
} |
||||
} |
||||
|
||||
loop { |
||||
if next_save < Instant::now() { |
||||
self.save_if_needed().await |
||||
.log_error("Failed to save group"); |
||||
next_save = Instant::now() + PERIODIC_SAVE; |
||||
} |
||||
|
||||
let timeout = next_save.saturating_duration_since(Instant::now()) |
||||
.min(PING_INTERVAL) |
||||
.max(Duration::from_secs(1)); |
||||
|
||||
match tokio::time::timeout(timeout, events.next()).await { |
||||
Ok(Some(event)) => { |
||||
debug!("(@{}) Event: {}", self.config.get_acct(), EventDisplay(&event)); |
||||
match event { |
||||
Event::Update(_status) => {} |
||||
Event::Notification(n) => { |
||||
self.handle_notification(n).await; |
||||
} |
||||
Event::Delete(_id) => {} |
||||
Event::FiltersChanged => {} |
||||
} |
||||
} |
||||
Ok(None) => { |
||||
warn!("Group @{} socket closed, restarting...", self.config.get_acct()); |
||||
break; |
||||
} |
||||
Err(_) => { |
||||
// Timeout so we can save if needed
|
||||
} |
||||
} |
||||
|
||||
trace!("Pinging"); |
||||
events.send_ping().await.log_error("Fail to send ping"); |
||||
} |
||||
|
||||
warn!("Notif stream closed, will reopen"); |
||||
tokio::time::sleep(Duration::from_millis(1000)).await; |
||||
} |
||||
} |
||||
|
||||
async fn handle_notification(&mut self, n: Notification) { |
||||
debug!("Handling notif #{}", n.id); |
||||
let ts = n.timestamp_millis(); |
||||
self.config.set_last_notif(ts); |
||||
|
||||
match n.notification_type { |
||||
NotificationType::Mention => { |
||||
if let Some(status) = n.status { |
||||
if status.content.contains("/gi") || status.content.contains("\\gi") { |
||||
info!("Mention ignored by gi"); |
||||
} else if status.content.contains("/gb") || status.content.contains("\\gb") { |
||||
if let Some(id) = status.in_reply_to_id { |
||||
info!("Boosting prev post by GB"); |
||||
tokio::time::sleep(Duration::from_millis(500)).await; |
||||
// self.client.reblog(&id).await.log_error("Failed to boost");
|
||||
} |
||||
} else { |
||||
info!("Boosting mention"); |
||||
tokio::time::sleep(Duration::from_millis(500)).await; |
||||
// self.client.reblog(&status.id).await.log_error("Failed to boost");
|
||||
} |
||||
} |
||||
} |
||||
NotificationType::Follow => { |
||||
info!("New follower!"); |
||||
tokio::time::sleep(Duration::from_millis(500)).await; |
||||
|
||||
/* |
||||
let post = StatusBuilder::new() |
||||
.status(format!("@{} welcome to the group!", &n.account.acct)) |
||||
.content_type("text/markdown") |
||||
.visibility(Visibility::Unlisted) |
||||
.build().expect("error build status"); |
||||
|
||||
let _ = self.client.new_status(post).await.log_error("Failed to post"); |
||||
*/ |
||||
} |
||||
_ => {} |
||||
} |
||||
} |
||||
|
||||
/// Catch up with missed notifications, returns true if any were handled
|
||||
async fn catch_up_with_missed_notifications(&mut self) -> Result<bool, GroupError> { |
||||
const MAX_CATCHUP_NOTIFS: usize = 25; |
||||
let last_notif = self.config.get_last_notif(); |
||||
|
||||
let notifications = self.client.notifications().await?; |
||||
let mut iter = notifications.items_iter(); |
||||
|
||||
let mut notifs_to_handle = vec![]; |
||||
|
||||
// They are retrieved newest first, but we want oldest first for chronological handling
|
||||
|
||||
let mut num = 0; |
||||
while let Some(n) = iter.next_item().await { |
||||
let ts = n.timestamp_millis(); |
||||
if ts <= last_notif { |
||||
break; // reached our last seen notif
|
||||
} |
||||
notifs_to_handle.push(n); |
||||
num += 1; |
||||
if num > MAX_CATCHUP_NOTIFS { |
||||
warn!("Too many notifs missed to catch up!"); |
||||
break; |
||||
} |
||||
} |
||||
|
||||
if notifs_to_handle.is_empty() { |
||||
return Ok(false); |
||||
} |
||||
|
||||
notifs_to_handle.reverse(); |
||||
|
||||
debug!("{} notifications to catch up!", notifs_to_handle.len()); |
||||
|
||||
for n in notifs_to_handle { |
||||
debug!("Handling missed notification: {}", NotificationDisplay(&n)); |
||||
self.handle_notification(n).await; |
||||
} |
||||
|
||||
return Ok(true); |
||||
} |
||||
} |
||||
@ -0,0 +1,333 @@ |
||||
use std::collections::{HashMap, HashSet}; |
||||
|
||||
use crate::store; |
||||
use crate::store::GroupError; |
||||
use elefren::AppData; |
||||
|
||||
/// This is the inner data struct holding the config
|
||||
#[derive(Debug, Clone, Serialize, Deserialize, Default)] |
||||
pub(crate) struct Config { |
||||
groups: HashMap<String, GroupConfig>, |
||||
} |
||||
|
||||
impl Config { |
||||
pub(crate) fn iter_groups(&self) -> impl Iterator<Item=&GroupConfig>{ |
||||
self.groups.values() |
||||
} |
||||
|
||||
pub(crate) fn get_group_config(&self, acct : &str) -> Option<&GroupConfig> { |
||||
self.groups.get(acct) |
||||
} |
||||
|
||||
pub(crate) fn set_group_config(&mut self, grp : GroupConfig) { |
||||
self.groups.insert(grp.acct.clone(), grp); |
||||
} |
||||
|
||||
} |
||||
|
||||
/// This is the inner data struct holding a group's config
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)] |
||||
#[serde(default)] |
||||
pub(crate) struct GroupConfig { |
||||
enabled: bool, |
||||
/// Group actor's acct
|
||||
acct: String, |
||||
/// elefren data
|
||||
appdata : AppData, |
||||
/// List of admin account "acct" names, e.g. piggo@piggo.space
|
||||
admin_users: HashSet<String>, |
||||
/// List of users allowed to post to the group, if it is member-only
|
||||
member_users: HashSet<String>, |
||||
/// List of users banned from posting to the group
|
||||
banned_users: HashSet<String>, |
||||
/// True if only members should be allowed to write
|
||||
member_only: bool, |
||||
/// Banned domain names, e.g. kiwifarms.cc
|
||||
banned_servers: HashSet<String>, |
||||
/// Last seen notification timestamp
|
||||
last_notif_ts: u64, |
||||
|
||||
#[serde(skip)] |
||||
dirty: bool, |
||||
} |
||||
|
||||
impl Default for GroupConfig { |
||||
fn default() -> Self { |
||||
Self { |
||||
enabled: true, |
||||
acct: "".to_string(), |
||||
appdata: AppData { |
||||
base: Default::default(), |
||||
client_id: Default::default(), |
||||
client_secret: Default::default(), |
||||
redirect: Default::default(), |
||||
token: Default::default() |
||||
}, |
||||
admin_users: Default::default(), |
||||
member_users: Default::default(), |
||||
banned_users: Default::default(), |
||||
member_only: false, |
||||
banned_servers: Default::default(), |
||||
last_notif_ts: 0, |
||||
dirty: false, |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl GroupConfig { |
||||
pub(crate) fn new(acct : String, appdata: AppData) -> Self { |
||||
Self { |
||||
acct, |
||||
appdata, |
||||
..Default::default() |
||||
} |
||||
} |
||||
|
||||
pub(crate) fn is_enabled(&self) -> bool { |
||||
self.enabled |
||||
} |
||||
|
||||
pub(crate) fn set_enabled(&mut self, ena: bool){ |
||||
self.enabled = ena; |
||||
self.mark_dirty(); |
||||
} |
||||
|
||||
pub(crate) fn get_appdata(&self) -> &AppData { |
||||
&self.appdata |
||||
} |
||||
|
||||
pub(crate) fn set_appdata(&mut self, appdata: AppData) { |
||||
self.appdata = appdata; |
||||
self.mark_dirty(); |
||||
} |
||||
|
||||
pub(crate) fn set_last_notif(&mut self, ts: u64) { |
||||
self.last_notif_ts = self.last_notif_ts.max(ts); |
||||
self.mark_dirty(); |
||||
} |
||||
|
||||
pub(crate) fn get_last_notif(&self) -> u64 { |
||||
self.last_notif_ts |
||||
} |
||||
|
||||
pub(crate) fn get_acct(&self) -> &str { |
||||
&self.acct |
||||
} |
||||
|
||||
pub(crate) fn is_admin(&self, acct: &str) -> bool { |
||||
self.admin_users.contains(acct) |
||||
} |
||||
|
||||
pub(crate) fn is_member(&self, acct: &str) -> bool { |
||||
self.member_users.contains(acct) |
||||
} |
||||
|
||||
pub(crate) fn is_banned(&self, acct: &str) -> bool { |
||||
self.banned_users.contains(acct) |
||||
|| self.is_users_server_banned(acct) |
||||
} |
||||
|
||||
/// Check if the user's server is banned
|
||||
fn is_users_server_banned(&self, acct: &str) -> bool { |
||||
let server = acct_to_server(acct); |
||||
self.banned_servers.contains(server) |
||||
} |
||||
|
||||
pub(crate) fn can_write(&self, acct: &str) -> bool { |
||||
if self.is_admin(acct) { |
||||
true |
||||
} else { |
||||
!self.is_banned(acct) && ( |
||||
!self.is_member_only() |
||||
|| self.is_member(acct) |
||||
) |
||||
} |
||||
} |
||||
|
||||
pub(crate) fn set_admin(&mut self, acct: &str, admin: bool) -> Result<(), GroupError> { |
||||
if admin { |
||||
if self.is_banned(acct) { |
||||
return Err(GroupError::UserIsBanned); |
||||
} |
||||
self.admin_users.insert(acct.to_owned()); |
||||
} else { |
||||
self.admin_users.remove(acct); |
||||
} |
||||
self.mark_dirty(); |
||||
Ok(()) |
||||
} |
||||
|
||||
pub(crate) fn set_member(&mut self, acct: &str, member: bool) -> Result<(), GroupError> { |
||||
if member { |
||||
if self.is_banned(acct) { |
||||
return Err(GroupError::UserIsBanned); |
||||
} |
||||
self.member_users.insert(acct.to_owned()); |
||||
} else { |
||||
self.member_users.remove(acct); |
||||
} |
||||
self.mark_dirty(); |
||||
Ok(()) |
||||
} |
||||
|
||||
pub(crate) fn ban_user(&mut self, acct: &str, ban: bool) -> Result<(), GroupError> { |
||||
if ban { |
||||
if self.is_admin(acct) { |
||||
return Err(GroupError::UserIsAdmin); |
||||
} |
||||
self.banned_users.insert(acct.to_owned()); |
||||
} else { |
||||
self.banned_users.remove(acct); |
||||
} |
||||
Ok(()) |
||||
} |
||||
|
||||
pub(crate) fn ban_server(&mut self, server: &str, ban: bool) -> Result<(), GroupError> { |
||||
if ban { |
||||
for acct in &self.admin_users { |
||||
let acct_server = acct_to_server(acct); |
||||
if acct_server == server { |
||||
return Err(GroupError::AdminsOnServer); |
||||
} |
||||
} |
||||
self.banned_servers.insert(server.to_owned()); |
||||
} else { |
||||
self.banned_servers.remove(server); |
||||
} |
||||
self.mark_dirty(); |
||||
Ok(()) |
||||
} |
||||
|
||||
pub(crate) fn set_member_only(&mut self, member_only: bool) { |
||||
self.member_only = member_only; |
||||
self.mark_dirty(); |
||||
} |
||||
|
||||
pub(crate) fn is_member_only(&self) -> bool { |
||||
self.member_only |
||||
} |
||||
|
||||
pub(crate) fn mark_dirty(&mut self) { |
||||
self.dirty = true; |
||||
} |
||||
|
||||
pub(crate) fn is_dirty(&self) -> bool { |
||||
self.dirty |
||||
} |
||||
|
||||
pub(crate) fn clear_dirty_status(&mut self) { |
||||
self.dirty = false; |
||||
} |
||||
} |
||||
|
||||
fn acct_to_server(acct: &str) -> &str { |
||||
acct.split('@').nth(1) |
||||
.unwrap_or_default() |
||||
} |
||||
|
||||
#[cfg(test)] |
||||
mod tests { |
||||
use crate::store::{GroupError}; |
||||
use crate::store::data::{GroupConfig, acct_to_server}; |
||||
|
||||
#[test] |
||||
fn test_acct_to_server() { |
||||
assert_eq!("pikachu.rocks", acct_to_server("raichu@pikachu.rocks")); |
||||
assert_eq!("pikachu.rocks", acct_to_server("m@pikachu.rocks")); |
||||
assert_eq!("", acct_to_server("what")); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_default_rules() { |
||||
let mut group = GroupConfig::default(); |
||||
assert!(!group.is_member_only()); |
||||
assert!(!group.is_member("piggo@piggo.space")); |
||||
assert!(!group.is_admin("piggo@piggo.space")); |
||||
assert!(group.can_write("piggo@piggo.space"), "anyone can post by default"); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_member_only() { |
||||
let mut group = GroupConfig::default(); |
||||
assert!(group.can_write("piggo@piggo.space"), "rando can write in public group"); |
||||
|
||||
group.set_member_only(true); |
||||
assert!(!group.can_write("piggo@piggo.space"), "rando can't write in member-only group"); |
||||
|
||||
// Admin in member only
|
||||
group.set_admin("piggo@piggo.space", true).unwrap(); |
||||
assert!(group.can_write("piggo@piggo.space"), "admin non-member can write in member-only group"); |
||||
group.set_admin("piggo@piggo.space", false).unwrap(); |
||||
assert!(!group.can_write("piggo@piggo.space"), "removed admin removes privileged write access"); |
||||
|
||||
// Member in member only
|
||||
group.set_member("piggo@piggo.space", true).unwrap(); |
||||
assert!(group.can_write("piggo@piggo.space"), "member can post in member-only group"); |
||||
group.set_admin("piggo@piggo.space", true).unwrap(); |
||||
assert!(group.can_write("piggo@piggo.space"), "member+admin can post in member-only group"); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_banned_users() { |
||||
// Banning single user
|
||||
let mut group = GroupConfig::default(); |
||||
group.ban_user("piggo@piggo.space", true).unwrap(); |
||||
assert!(!group.can_write("piggo@piggo.space"), "banned user can't post"); |
||||
group.ban_user("piggo@piggo.space", false).unwrap(); |
||||
assert!(group.can_write("piggo@piggo.space"), "un-ban works"); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_banned_members() { |
||||
// Banning single user
|
||||
let mut group = GroupConfig::default(); |
||||
group.set_member_only(true); |
||||
|
||||
group.set_member("piggo@piggo.space", true).unwrap(); |
||||
assert!(group.can_write("piggo@piggo.space"), "member can write"); |
||||
assert!(group.is_member("piggo@piggo.space"), "member is member"); |
||||
assert!(!group.is_banned("piggo@piggo.space"), "user not banned by default"); |
||||
|
||||
group.ban_user("piggo@piggo.space", true).unwrap(); |
||||
assert!(group.is_member("piggo@piggo.space"), "still member even if banned"); |
||||
assert!(group.is_banned("piggo@piggo.space"), "banned user is banned"); |
||||
|
||||
assert!(!group.can_write("piggo@piggo.space"), "banned member can't post"); |
||||
|
||||
// unban
|
||||
group.ban_user("piggo@piggo.space", false).unwrap(); |
||||
assert!(group.can_write("piggo@piggo.space"), "un-ban works"); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_server_ban() { |
||||
let mut group = GroupConfig::default(); |
||||
assert!(group.can_write("hitler@nazi.camp"), "randos can write"); |
||||
|
||||
group.ban_server("nazi.camp", true).unwrap(); |
||||
assert!(!group.can_write("hitler@nazi.camp"), "users from banned server can't write"); |
||||
assert!(!group.can_write("1488@nazi.camp"), "users from banned server can't write"); |
||||
assert!(group.can_write("troll@freezepeach.xyz"), "other users can still write"); |
||||
|
||||
group.ban_server("nazi.camp", false).unwrap(); |
||||
assert!(group.can_write("hitler@nazi.camp"), "server unban works"); |
||||
} |
||||
|
||||
#[test] |
||||
fn test_sanity() { |
||||
let mut group = GroupConfig::default(); |
||||
|
||||
group.set_admin("piggo@piggo.space", true).unwrap(); |
||||
assert_eq!(Err(GroupError::UserIsAdmin), group.ban_user("piggo@piggo.space", true), "can't bad admin users"); |
||||
group.ban_user("piggo@piggo.space", false).expect("can unbad admin"); |
||||
|
||||
group.ban_user("hitler@nazi.camp", true).unwrap(); |
||||
assert_eq!(Err(GroupError::UserIsBanned), group.set_admin("hitler@nazi.camp", true), "can't make banned users admins"); |
||||
|
||||
group.ban_server("freespeechextremist.com", true).unwrap(); |
||||
assert_eq!(Err(GroupError::UserIsBanned), group.set_admin("nibber@freespeechextremist.com", true), "can't make server-banned users admins"); |
||||
|
||||
assert!(group.is_admin("piggo@piggo.space")); |
||||
assert_eq!(Err(GroupError::AdminsOnServer), group.ban_server("piggo.space", true), "can't bad server with admins"); |
||||
} |
||||
} |
||||
@ -0,0 +1,225 @@ |
||||
use std::collections::{HashMap, HashSet}; |
||||
use std::hash::{Hash, Hasher}; |
||||
use std::path::{Path, PathBuf}; |
||||
use std::sync::Arc; |
||||
|
||||
use elefren::{FediClient, Registration, Scopes, scopes}; |
||||
use elefren::entities::event::Event; |
||||
use futures::StreamExt; |
||||
use tokio::sync::RwLock; |
||||
|
||||
use data::{Config, GroupConfig}; |
||||
|
||||
use crate::group_handle::GroupHandle; |
||||
|
||||
pub(crate) mod data; |
||||
|
||||
#[derive(Debug, Default)] |
||||
pub struct ConfigStore { |
||||
store_path: PathBuf, |
||||
save_pretty: bool, |
||||
data: tokio::sync::RwLock<Config>, |
||||
} |
||||
|
||||
#[derive(Debug)] |
||||
pub struct NewGroupOptions { |
||||
pub server: String, |
||||
pub acct: String, |
||||
} |
||||
|
||||
#[derive(Debug)] |
||||
pub struct StoreOptions { |
||||
pub store_path: String, |
||||
pub save_pretty: bool, |
||||
} |
||||
|
||||
impl ConfigStore { |
||||
/// Create a new instance of the store.
|
||||
/// If a path is given, it will try to load the content from a file.
|
||||
pub async fn new(options: StoreOptions) -> Result<Arc<Self>, GroupError> { |
||||
let path: &Path = options.store_path.as_ref(); |
||||
|
||||
let config = if path.is_file() { |
||||
let f = tokio::fs::read(path).await?; |
||||
serde_json::from_slice(&f)? |
||||
} else { |
||||
let empty = Config::default(); |
||||
tokio::fs::write(path, serde_json::to_string(&empty)?.as_bytes()).await?; |
||||
empty |
||||
}; |
||||
|
||||
Ok(Arc::new(Self { |
||||
store_path: path.to_owned(), |
||||
save_pretty: options.save_pretty, |
||||
data: RwLock::new(config), |
||||
})) |
||||
} |
||||
|
||||
/// Spawn a new group
|
||||
pub async fn auth_new_group(self: &Arc<Self>, opts: NewGroupOptions) -> Result<GroupHandle, GroupError> { |
||||
let registration = Registration::new(&opts.server) |
||||
.client_name("group-actor") |
||||
.force_login(true) |
||||
.scopes(make_scopes()) |
||||
.build().await?; |
||||
|
||||
println!("--- Authenticating NEW bot user @{} ---", opts.acct); |
||||
let client = elefren::helpers::cli::authenticate(registration).await?; |
||||
let appdata = client.data.clone(); |
||||
|
||||
let data = GroupConfig::new(opts.acct, appdata); |
||||
|
||||
// save & persist
|
||||
self.set_group_config(data.clone()).await?; |
||||
|
||||
Ok(GroupHandle { |
||||
client, |
||||
config: data, |
||||
store: self.clone(), |
||||
}) |
||||
} |
||||
|
||||
/// Re-auth an existing group
|
||||
pub async fn reauth_group(self: &Arc<Self>, acct: &str) -> Result<GroupHandle, GroupError> { |
||||
let groups = self.data.read().await; |
||||
let mut config = groups.get_group_config(acct).ok_or(GroupError::GroupNotExist)?.clone(); |
||||
|
||||
println!("--- Re-authenticating bot user @{} ---", acct); |
||||
let registration = Registration::new(config.get_appdata().base.to_string()) |
||||
.client_name("group-actor") |
||||
.force_login(true) |
||||
.scopes(make_scopes()) |
||||
.build().await?; |
||||
|
||||
let client = elefren::helpers::cli::authenticate(registration).await?; |
||||
let appdata = client.data.clone(); |
||||
|
||||
config.set_appdata(appdata); |
||||
self.set_group_config(config.clone()).await?; |
||||
|
||||
Ok(GroupHandle { |
||||
client, |
||||
config, |
||||
store: self.clone(), |
||||
}) |
||||
} |
||||
|
||||
/// Spawn existing group using saved creds
|
||||
pub async fn spawn_groups(self: Arc<Self>) -> Vec<GroupHandle> { |
||||
let groups = self.data.read().await; |
||||
let groups_iter = groups.iter_groups().cloned(); |
||||
|
||||
// Connect in parallel
|
||||
futures::stream::iter(groups_iter).map(|gc| async { |
||||
if !gc.is_enabled() { |
||||
debug!("Group @{} is DISABLED", gc.get_acct()); |
||||
return None; |
||||
} |
||||
|
||||
debug!("Connecting to @{}", gc.get_acct()); |
||||
|
||||
let client = FediClient::from(gc.get_appdata().clone()); |
||||
|
||||
match client.verify_credentials().await { |
||||
Ok(account) => { |
||||
info!("Group account verified: @{}, {}", account.acct, account.display_name); |
||||
} |
||||
Err(e) => { |
||||
error!("Group @{} auth error: {}", gc.get_acct(), e); |
||||
return None; |
||||
} |
||||
}; |
||||
|
||||
Some(GroupHandle { |
||||
client, |
||||
config: gc, |
||||
store: self.clone(), |
||||
}) |
||||
}).buffer_unordered(8).collect::<Vec<_>>().await |
||||
.into_iter().flatten().collect() |
||||
} |
||||
|
||||
pub(crate) async fn get_group_config(&self, group: &str) -> Option<GroupConfig> { |
||||
let c = self.data.read().await; |
||||
c.get_group_config(group).map(|inner| { |
||||
inner.clone() |
||||
}) |
||||
} |
||||
|
||||
//noinspection RsSelfConvention
|
||||
/// Set group config to the store. The store then saved.
|
||||
pub(crate) async fn set_group_config<'a>(&'a self, config: GroupConfig) -> Result<(), GroupError> { |
||||
let mut data = self.data.write().await; |
||||
data.set_group_config(config); |
||||
self.persist(&data).await?; |
||||
Ok(()) |
||||
} |
||||
|
||||
/// Persist the store
|
||||
async fn persist(&self, data: &Config) -> Result<(), GroupError> { |
||||
tokio::fs::write(&self.store_path, |
||||
if self.save_pretty { |
||||
serde_json::to_string_pretty(&data) |
||||
} else { |
||||
serde_json::to_string(&data) |
||||
}?.as_bytes()) |
||||
.await?; |
||||
Ok(()) |
||||
} |
||||
} |
||||
|
||||
#[derive(Debug, Error)] |
||||
pub enum GroupError { |
||||
#[error("Operation refused because the user is admin")] |
||||
UserIsAdmin, |
||||
#[error("Operation refused because the user is banned")] |
||||
UserIsBanned, |
||||
#[error("Server could not be banned because there are admin users on it")] |
||||
AdminsOnServer, |
||||
#[error("Group config is missing in the config store")] |
||||
GroupNotExist, |
||||
#[error(transparent)] |
||||
IoError(#[from] std::io::Error), |
||||
#[error(transparent)] |
||||
Serializer(#[from] serde_json::Error), |
||||
#[error(transparent)] |
||||
Elefren(#[from] elefren::Error), |
||||
} |
||||
|
||||
// this is for tests
|
||||
impl PartialEq for GroupError { |
||||
fn eq(&self, other: &Self) -> bool { |
||||
match (self, other) { |
||||
(Self::UserIsAdmin, Self::UserIsAdmin) => true, |
||||
(Self::UserIsBanned, Self::UserIsBanned) => true, |
||||
(Self::AdminsOnServer, Self::AdminsOnServer) => true, |
||||
(Self::GroupNotExist, Self::GroupNotExist) => true, |
||||
_ => false, |
||||
} |
||||
} |
||||
} |
||||
|
||||
fn make_scopes() -> Scopes { |
||||
Scopes::read(scopes::Read::Accounts) |
||||
| Scopes::read(scopes::Read::Notifications) |
||||
| Scopes::read(scopes::Read::Statuses) |
||||
| Scopes::read(scopes::Read::Follows) |
||||
| Scopes::write(scopes::Write::Statuses) |
||||
| Scopes::write(scopes::Write::Media) |
||||
} |
||||
|
||||
// trait TapOk<T> {
|
||||
// fn tap_ok<F: FnOnce(&T)>(self, f: F) -> Self;
|
||||
// }
|
||||
//
|
||||
// impl<T, E> TapOk<T> for Result<T, E> {
|
||||
// fn tap_ok<F: FnOnce(&T)>(self, f: F) -> Self {
|
||||
// match self {
|
||||
// Ok(v) => {
|
||||
// f(&v);
|
||||
// Ok(v)
|
||||
// }
|
||||
// Err(e) => Err(e)
|
||||
// }
|
||||
// }
|
||||
// }
|
||||
@ -0,0 +1,16 @@ |
||||
use std::error::Error; |
||||
|
||||
pub trait LogError { |
||||
fn log_error<S : AsRef<str>>(self, msg: S); |
||||
} |
||||
|
||||
impl<V, E : Error> LogError for Result<V, E> { |
||||
fn log_error<S : AsRef<str>>(self, msg: S) { |
||||
match self { |
||||
Ok(_) => {} |
||||
Err(e) => { |
||||
error!("{}: {}", msg.as_ref(), e); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
Loading…
Reference in new issue