config store & event loop with reconn
This commit is contained in:
@@ -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);
|
||||
}
|
||||
}
|
||||
+94
-23
@@ -1,33 +1,97 @@
|
||||
#![deny(unused_must_use)]
|
||||
|
||||
#[macro_use]
|
||||
extern crate log;
|
||||
#[macro_use]
|
||||
extern crate smart_default;
|
||||
#[macro_use]
|
||||
extern crate serde;
|
||||
#[macro_use]
|
||||
extern crate thiserror;
|
||||
extern crate elefren;
|
||||
|
||||
use elefren::prelude::*;
|
||||
use elefren::helpers::{cli, toml};
|
||||
use elefren::entities::event::Event;
|
||||
use log::LevelFilter;
|
||||
use elefren::entities::notification::NotificationType;
|
||||
use elefren::entities::account::Account;
|
||||
use elefren::status_builder::Visibility;
|
||||
use elefren::{Registration, Scopes, StatusBuilder, FediClient};
|
||||
use tokio_stream::{Stream, StreamExt};
|
||||
use elefren::scopes;
|
||||
use crate::store::{NewGroupOptions, StoreOptions};
|
||||
use elefren::debug::NotificationDisplay;
|
||||
|
||||
fn main() -> anyhow::Result<()> {
|
||||
simple_logging::log_to_stderr(LevelFilter::Trace);
|
||||
mod store;
|
||||
mod group_handle;
|
||||
mod utils;
|
||||
|
||||
let client = if let Ok(data) = toml::from_file("group-actor-data.toml") {
|
||||
Mastodon::from(data)
|
||||
#[tokio::main]
|
||||
async fn main() -> anyhow::Result<()> {
|
||||
env_logger::Builder::new()
|
||||
.filter_level(LevelFilter::Debug)
|
||||
.write_style(env_logger::WriteStyle::Always)
|
||||
.filter_module("rustls", LevelFilter::Warn)
|
||||
.filter_module("reqwest", LevelFilter::Warn)
|
||||
.init();
|
||||
|
||||
let store = store::ConfigStore::new(StoreOptions {
|
||||
store_path: "groups.json".to_string(),
|
||||
save_pretty: true
|
||||
}).await?;
|
||||
|
||||
/*
|
||||
let mut new_group = store.auth_new_group(NewGroupOptions {
|
||||
server: "https://botsin.space".to_string(),
|
||||
acct: "betty@botsin.space".to_string()
|
||||
}).await?;
|
||||
// */
|
||||
|
||||
let mut groups = store.spawn_groups().await;
|
||||
//groups.push(new_group);
|
||||
|
||||
|
||||
/*
|
||||
let mut betty = groups.remove(0);
|
||||
|
||||
let notifications = betty.client.notifications().await?;
|
||||
let mut iter = notifications.items_iter();
|
||||
|
||||
let mut num = 0;
|
||||
while let Some(n) = iter.next_item().await {
|
||||
debug!("A notification: {}", NotificationDisplay(&n));
|
||||
num += 1;
|
||||
if num > 10 {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return Ok(());
|
||||
*/
|
||||
|
||||
let mut handles = vec![];
|
||||
|
||||
for mut g in groups {
|
||||
handles.push(tokio::spawn(async move {
|
||||
g.run().await
|
||||
}));
|
||||
}
|
||||
|
||||
futures::future::join_all(handles).await;
|
||||
|
||||
/*
|
||||
|
||||
let client = if let Ok(data) = elefren::helpers::toml::from_file("group-actor-data.toml") {
|
||||
FediClient::from(data)
|
||||
} else {
|
||||
register()?
|
||||
register().await?
|
||||
};
|
||||
|
||||
let you = client.verify_credentials()?;
|
||||
|
||||
let you = client.verify_credentials().await?;
|
||||
println!("{:#?}", you);
|
||||
|
||||
for event in client.streaming_user()? {
|
||||
let mut events = client.streaming_user().await?;
|
||||
|
||||
while let Some(event) = events.next().await {
|
||||
match event {
|
||||
Event::Update(status) => {
|
||||
info!("Status: {:?}", status);
|
||||
@@ -36,6 +100,7 @@ fn main() -> anyhow::Result<()> {
|
||||
info!("Notification: {:?}", notification.notification_type);
|
||||
debug!("{:?}", notification);
|
||||
|
||||
/*
|
||||
match notification.notification_type {
|
||||
NotificationType::Mention => {
|
||||
if let Some(status) = notification.status {
|
||||
@@ -72,10 +137,11 @@ fn main() -> anyhow::Result<()> {
|
||||
.visibility(Visibility::Unlisted)
|
||||
.build().expect("error build status");
|
||||
|
||||
let _ = client.new_status(post);
|
||||
let _ = client.new_status(post).await;
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
*/
|
||||
},
|
||||
Event::Delete(id) => {
|
||||
info!("Delete: {}", id);
|
||||
@@ -87,24 +153,29 @@ fn main() -> anyhow::Result<()> {
|
||||
}
|
||||
}
|
||||
|
||||
*/
|
||||
|
||||
println!("Main loop ended!");
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn register() -> anyhow::Result<Mastodon> {
|
||||
/*
|
||||
async fn register() -> anyhow::Result<FediClient> {
|
||||
let registration = Registration::new("https://piggo.space")
|
||||
.client_name("group-actor")
|
||||
.scopes(Scopes::all())
|
||||
.build()?;
|
||||
let client = cli::authenticate(registration)?;
|
||||
toml::to_file(&*client, "group-actor-data.toml")?;
|
||||
.force_login(true)
|
||||
.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)
|
||||
)
|
||||
.build().await?;
|
||||
let client = elefren::helpers::cli::authenticate(registration).await?;
|
||||
elefren::helpers::toml::to_file(&*client, "group-actor-data.toml")?;
|
||||
Ok(client)
|
||||
}
|
||||
|
||||
fn make_mention(user : &Account) -> String {
|
||||
format!(r#"<span class="h-card"><a class="u-url mention" data-user="{id}" href="{url}" rel="ugc">@<span>{handle}</span></a></span>"#,
|
||||
id=user.id,
|
||||
url=user.url, handle=user.acct
|
||||
)
|
||||
}
|
||||
*/
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user