Merge branch 'tags'

master
Ondřej Hruška 3 years ago
commit 60653314cd
Signed by untrusted user: MightyPork
GPG Key ID: 2C5FD5035250423D
  1. 1
      .gitignore
  2. 15
      CHANGELOG.md
  3. 4
      Cargo.lock
  4. 9
      Cargo.toml
  5. 193
      src/command.rs
  6. 2
      src/error.rs
  7. 604
      src/group_handle.rs
  8. 625
      src/group_handler/handle_mention.rs
  9. 454
      src/group_handler/mod.rs
  10. 2
      src/main.rs
  11. 107
      src/store/data.rs
  12. 21
      src/store/mod.rs
  13. 13
      src/utils.rs

1
.gitignore vendored

@ -4,3 +4,4 @@ group-actor-data.toml
.idea/
groups.json
fedigroups
*.bak

@ -0,0 +1,15 @@
# Changelog
## v0.2
- Add hashtag boosting and back-follow/unfollow
- Add hashtag commands
- Code reorganization
- Improve greeting messages
- Do not crash on unknown notification types (elefren patch)
## v0.1
This is the initial test release
.

4
Cargo.lock generated

@ -276,7 +276,7 @@ checksum = "ea57b42383d091c85abcc2706240b94ab2a8fa1fc81c10ff23c4de06e2a90b5e"
[[package]]
name = "elefren"
version = "0.22.0"
source = "git+https://git.ondrovo.com/MightyPork/elefren-fork.git#de38639fd178ae8ae47adb880ed965437a3d608e"
source = "git+https://git.ondrovo.com/MightyPork/elefren-fork.git?rev=54a0e55#54a0e55964784368864f36580c5630f730bf72dc"
dependencies = [
"chrono",
"doc-comment",
@ -328,7 +328,7 @@ checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
[[package]]
name = "fedigroups"
version = "0.1.0"
version = "0.2.0"
dependencies = [
"anyhow",
"clap",

@ -1,6 +1,6 @@
[package]
name = "fedigroups"
version = "0.1.0"
version = "0.2.0"
authors = ["Ondřej Hruška <ondra@ondrovo.com>"]
edition = "2018"
publish = false
@ -9,17 +9,14 @@ build = "build.rs"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
#elefren = { version = "0.22.0", features = ["toml"] }
#elefren = { path = "../elefren22-fork" }
elefren = { git = "https://git.ondrovo.com/MightyPork/elefren-fork.git" }
elefren = { git = "https://git.ondrovo.com/MightyPork/elefren-fork.git", rev = "54a0e55" }
env_logger = "0.9.0"
#elefren = { path = "../elefren-fork" }
log = "0.4.14"
serde = "1"
serde_json = "1"
#smart-default = "0.6.0"
anyhow = "1"
clap = "2.33.0"
tokio = { version = "1", features = ["full"] }
@ -32,5 +29,3 @@ once_cell = "1.8.0"
native-tls = "0.2.8"
websocket = "0.26.2"
#tokio = { version = "0.2.22", features = ["full"] }

@ -3,22 +3,54 @@ use regex::Regex;
#[derive(Debug, Clone, PartialEq)]
pub enum StatusCommand {
Boost,
/// Ignore this post
Ignore,
/// Boost the previous post in the thread
Boost,
/// Admin: Ban a user
BanUser(String),
/// Admin: Un-ban a server
UnbanUser(String),
/// Admin: Ban a server
BanServer(String),
/// Admin: Un-ban a server
UnbanServer(String),
/// Admin: Add a member to a closed group (or force join)
AddMember(String),
/// Admin: Remove a user from the group, also unfollow
RemoveMember(String),
/// Admin: Add a hashtag to the group
AddTag(String),
/// Admin: Remove a hashtag from the group
RemoveTag(String),
/// Admin: Give admin to a user
GrantAdmin(String),
/// Admin: Revoke admin to a user
RemoveAdmin(String),
/// Admin: Send a public announcement
Announce(String),
/// Admin: Make the group open-access
OpenGroup,
/// Admin: Make the group member-only, this effectively disables posting from non-members
/// and disables /join and follow-back
CloseGroup,
/// Show help. The content varies by group params (open/closed access), the user's privileges
/// and membership status.
Help,
/// Show members. Non-admins will only see a list of admins.
ListMembers,
/// Show tags.
ListTags,
/// Leave the group, this asks the group to unfollow the user and also revokes their membership.
Leave,
/// Join a public group. This is normally not needed, as the group follows back and adds followers as members.
/// Manual join is useful when the follow somehow fails, or when the user wants to be able to
/// post without receiving the group's posts (naughty!)
///
/// In member-only groups, this will just DM the user some info on how to get added.
Join,
/// The group will DM "Pong" back, this is to test that the daemon is running and also that the
/// user is not banned and federates.
Ping,
}
@ -27,12 +59,19 @@ macro_rules! p_user {
r"(@?[a-zA-Z0-9_.-]+@[a-zA-Z0-9_.-]+\.[a-z0-9_-]+|@[a-zA-Z0-9_.-]+)"
};
}
macro_rules! p_server {
() => {
r"([a-zA-Z0-9_.-]+\.[a-zA-Z0-9_-]+)"
};
}
macro_rules! p_hashtag {
() => {
r"#(\w+)"
};
}
macro_rules! command {
($($val:expr),+) => {
Regex::new(concat!(r"(?:^|\s|>|\n)[\\/]", $($val,)+ r"(?:$|[!,]|\W)")).unwrap()
@ -55,6 +94,10 @@ static RE_ADD_MEMBER: once_cell::sync::Lazy<Regex> = Lazy::new(|| command!(r"(?:
static RE_REMOVE_MEMBER: once_cell::sync::Lazy<Regex> = Lazy::new(|| command!(r"(?:kick|remove)\s+", p_user!()));
static RE_ADD_TAG: once_cell::sync::Lazy<Regex> = Lazy::new(|| command!(r"(?:add)\s+", p_hashtag!()));
static RE_REMOVE_TAG: once_cell::sync::Lazy<Regex> = Lazy::new(|| command!(r"(?:remove)\s+", p_hashtag!()));
static RE_GRANT_ADMIN: once_cell::sync::Lazy<Regex> = Lazy::new(|| command!(r"(?:op|admin)\s+", p_user!()));
static RE_REVOKE_ADMIN: once_cell::sync::Lazy<Regex> = Lazy::new(|| command!(r"(?:deop|deadmin)\s+", p_user!()));
@ -67,20 +110,42 @@ static RE_HELP: once_cell::sync::Lazy<Regex> = Lazy::new(|| command!(r"help"));
static RE_MEMBERS: once_cell::sync::Lazy<Regex> = Lazy::new(|| command!(r"(?:members|who)"));
static RE_TAGS: once_cell::sync::Lazy<Regex> = Lazy::new(|| command!(r"(?:hashtags|tags)"));
static RE_LEAVE: once_cell::sync::Lazy<Regex> = Lazy::new(|| command!(r"(?:leave)"));
static RE_JOIN: once_cell::sync::Lazy<Regex> = Lazy::new(|| command!(r"(?:join)"));
static RE_PING: once_cell::sync::Lazy<Regex> = Lazy::new(|| command!(r"(?:ping)"));
static RE_ANNOUNCE: once_cell::sync::Lazy<Regex> =
Lazy::new(|| Regex::new(concat!(r"(?:^|\s|>|\n)[\\/]announce\s+(.*)$")).unwrap());
pub fn parse_status(content: &str) -> Vec<StatusCommand> {
static RE_A_HASHTAG: once_cell::sync::Lazy<Regex> =
Lazy::new(|| Regex::new(concat!(r"(?:^|\b|\s|>|\n)#(\w+)")).unwrap());
pub fn parse_status_tags(content: &str) -> Vec<String> {
debug!("Raw content: {}", content);
let content = content.replace("<br/>", "<br/> ");
let content = content.replace("</p>", "</p> ");
let content = voca_rs::strip::strip_tags(&content);
debug!("Stripped tags: {}", content);
let content = content.replace("<br/>", " ");
// let content = content.replace("<br />", " ");
// let content = content.replace("<BR/>", " ");
// let content = content.replace("<BR />", " ");
let mut tags = vec![];
for c in RE_A_HASHTAG.captures_iter(&content) {
if let Some(s) = c.get(1) {
tags.push(s.as_str().to_string())
}
}
tags
}
pub fn parse_slash_commands(content: &str) -> Vec<StatusCommand> {
debug!("Raw content: {}", content);
let content = content.replace("<br/>", "<br/> ");
let content = content.replace("</p>", "</p> ");
let content = voca_rs::strip::strip_tags(&content);
debug!("Stripped tags: {}", content);
@ -111,6 +176,9 @@ pub fn parse_status(content: &str) -> Vec<StatusCommand> {
if RE_LEAVE.is_match(&content) {
debug!("LEAVE");
commands.push(StatusCommand::Leave);
} else if RE_JOIN.is_match(&content) {
debug!("JOIN");
commands.push(StatusCommand::Join);
}
if RE_PING.is_match(&content) {
@ -123,6 +191,11 @@ pub fn parse_status(content: &str) -> Vec<StatusCommand> {
commands.push(StatusCommand::ListMembers);
}
if RE_TAGS.is_match(&content) {
debug!("TAGS");
commands.push(StatusCommand::ListTags);
}
if RE_OPEN_GROUP.is_match(&content) {
debug!("OPEN GROUP");
commands.push(StatusCommand::OpenGroup);
@ -188,11 +261,27 @@ pub fn parse_status(content: &str) -> Vec<StatusCommand> {
if let Some(s) = c.get(1) {
let s = s.as_str();
let s = s.trim_start_matches('@');
debug!("UNBAN USER: {}", s);
debug!("REMOVE USER: {}", s);
commands.push(StatusCommand::RemoveMember(s.to_owned()));
}
}
for c in RE_ADD_TAG.captures_iter(&content) {
if let Some(s) = c.get(1) {
let s = s.as_str();
debug!("ADD TAG: {}", s);
commands.push(StatusCommand::AddTag(s.to_owned()));
}
}
for c in RE_REMOVE_TAG.captures_iter(&content) {
if let Some(s) = c.get(1) {
let s = s.as_str();
debug!("REMOVE TAG: {}", s);
commands.push(StatusCommand::RemoveTag(s.to_owned()));
}
}
for c in RE_GRANT_ADMIN.captures_iter(&content) {
if let Some(s) = c.get(1) {
let s = s.as_str();
@ -216,11 +305,11 @@ pub fn parse_status(content: &str) -> Vec<StatusCommand> {
#[cfg(test)]
mod test {
use crate::command::{parse_status, StatusCommand};
use crate::command::{parse_slash_commands, StatusCommand, RE_JOIN, RE_ADD_TAG, RE_A_HASHTAG};
use super::{
RE_ADD_MEMBER, RE_ANNOUNCE, RE_BAN_SERVER, RE_BAN_USER, RE_BOOST, RE_CLOSE_GROUP, RE_GRANT_ADMIN, RE_HELP,
RE_IGNORE, RE_LEAVE, RE_MEMBERS, RE_OPEN_GROUP, RE_REMOVE_MEMBER, RE_REVOKE_ADMIN,
RE_IGNORE, RE_LEAVE, RE_MEMBERS, RE_TAGS, RE_OPEN_GROUP, RE_REMOVE_MEMBER, RE_REVOKE_ADMIN,
};
#[test]
@ -276,23 +365,18 @@ mod test {
assert!(RE_BAN_USER.is_match("/ban @LAIN@PleromA.soykaf.com"));
let c = RE_BAN_USER.captures("/ban lain@pleroma.soykaf.com");
assert!(c.is_some());
assert_eq!(c.unwrap().get(1).unwrap().as_str(), "lain@pleroma.soykaf.com");
let c = RE_BAN_USER.captures("/ban lain@pleroma.soykaf.com xx");
assert!(c.is_some());
assert_eq!(c.unwrap().get(1).unwrap().as_str(), "lain@pleroma.soykaf.com");
let c = RE_BAN_USER.captures("/ban @lain@pleroma.soykaf.com");
assert!(c.is_some());
assert_eq!(c.unwrap().get(1).unwrap().as_str(), "@lain@pleroma.soykaf.com");
let c = RE_BAN_USER.captures("/ban @lain");
assert!(c.is_some());
assert_eq!(c.unwrap().get(1).unwrap().as_str(), "@lain");
let c = RE_BAN_USER.captures("/ban @lain xx");
assert!(c.is_some());
assert_eq!(c.unwrap().get(1).unwrap().as_str(), "@lain");
}
@ -306,11 +390,9 @@ mod test {
assert!(!RE_BAN_SERVER.is_match("/ban @pleroma.soykaf.com"));
let c = RE_BAN_SERVER.captures("/ban pleroma.soykaf.com");
assert!(c.is_some());
assert_eq!(c.unwrap().get(1).unwrap().as_str(), "pleroma.soykaf.com");
let c = RE_BAN_SERVER.captures("/ban pleroma.soykaf.com xx");
assert!(c.is_some());
assert_eq!(c.unwrap().get(1).unwrap().as_str(), "pleroma.soykaf.com");
}
@ -321,7 +403,6 @@ mod test {
assert!(RE_ADD_MEMBER.is_match("\\add @lain"));
let c = RE_ADD_MEMBER.captures("/add @lain");
assert!(c.is_some());
assert_eq!(c.unwrap().get(1).unwrap().as_str(), "@lain");
}
@ -337,10 +418,35 @@ mod test {
assert!(RE_REMOVE_MEMBER.is_match("/remove @lain"));
let c = RE_REMOVE_MEMBER.captures("/kick lain@pleroma.soykaf.com");
assert!(c.is_some());
assert_eq!(c.unwrap().get(1).unwrap().as_str(), "lain@pleroma.soykaf.com");
}
#[test]
fn test_add_tag() {
assert!(RE_ADD_TAG.is_match("/add #breadposting"));
assert!(RE_ADD_TAG.is_match("/add #čučkaři"));
assert!(RE_ADD_TAG.is_match("/add #χαλβάς"));
assert!(RE_ADD_TAG.is_match("\\add #ласточка"));
assert!(RE_ADD_TAG.is_match("/add #nya."));
assert!(RE_ADD_TAG.is_match("/add #nya)"));
assert!(RE_ADD_TAG.is_match("/add #nya and more)"));
let c = RE_ADD_TAG.captures("/add #breadposting");
assert_eq!(c.unwrap().get(1).unwrap().as_str(), "breadposting");
let c = RE_ADD_TAG.captures("/add #χαλβάς");
assert_eq!(c.unwrap().get(1).unwrap().as_str(), "χαλβάς");
let c = RE_ADD_TAG.captures("/add #ласточка");
assert_eq!(c.unwrap().get(1).unwrap().as_str(), "ласточка");
let c = RE_ADD_TAG.captures("/add #nya.");
assert_eq!(c.unwrap().get(1).unwrap().as_str(), "nya");
let c = RE_ADD_TAG.captures("/add #nya)");
assert_eq!(c.unwrap().get(1).unwrap().as_str(), "nya");
}
#[test]
fn test_add_admin() {
assert!(!RE_GRANT_ADMIN.is_match("/expel lain@pleroma.soykaf.com"));
@ -350,7 +456,6 @@ mod test {
assert!(RE_GRANT_ADMIN.is_match("\\op @lain"));
let c = RE_GRANT_ADMIN.captures("/op @lain@pleroma.soykaf.com");
assert!(c.is_some());
assert_eq!(c.unwrap().get(1).unwrap().as_str(), "@lain@pleroma.soykaf.com");
}
@ -362,7 +467,6 @@ mod test {
assert!(RE_REVOKE_ADMIN.is_match("/deadmin @lain"));
let c = RE_REVOKE_ADMIN.captures("/deadmin @lain");
assert!(c.is_some());
assert_eq!(c.unwrap().get(1).unwrap().as_str(), "@lain");
}
@ -405,6 +509,34 @@ mod test {
assert!(RE_MEMBERS.is_match("/who"));
}
#[test]
fn test_tags() {
assert!(!RE_TAGS.is_match("/members"));
assert!(RE_TAGS.is_match("/hashtags"));
assert!(RE_TAGS.is_match("dsfsd /tags dfgd d"));
}
#[test]
fn test_match_tag() {
assert!(!RE_A_HASHTAG.is_match("banana sdfsdf sdfsd fdsf sd"));
assert!(RE_A_HASHTAG.is_match("#banana"));
assert!(RE_A_HASHTAG.is_match("#ласточка"));
assert!(RE_A_HASHTAG.is_match("#χαλβάς"));
assert!(RE_A_HASHTAG.is_match("foo #banana gfdfgd"));
for (i, c) in RE_A_HASHTAG.captures_iter("foo #banana #χαλβάς #ласточка").enumerate() {
if i == 0 {
assert_eq!(c.get(1).unwrap().as_str(), "banana");
}
else if i == 1 {
assert_eq!(c.get(1).unwrap().as_str(), "χαλβάς");
}
else if i == 2 {
assert_eq!(c.get(1).unwrap().as_str(), "ласточка");
}
}
}
#[test]
fn test_leave() {
assert!(!RE_LEAVE.is_match("/list"));
@ -414,6 +546,15 @@ mod test {
assert!(RE_LEAVE.is_match("/leave z"));
}
#[test]
fn test_join() {
assert!(!RE_JOIN.is_match("/list"));
assert!(RE_JOIN.is_match("/join"));
assert!(RE_JOIN.is_match("/join"));
assert!(RE_JOIN.is_match("x /join"));
assert!(RE_JOIN.is_match("/join z"));
}
#[test]
fn test_announce() {
assert!(!RE_ANNOUNCE.is_match("/list"));
@ -435,15 +576,15 @@ mod test {
fn test_real_post() {
assert_eq!(
Vec::<StatusCommand>::new(),
parse_status("Hello there is nothing here /fake command")
parse_slash_commands("Hello there is nothing here /fake command")
);
assert_eq!(
vec![StatusCommand::Help],
parse_status("lets see some \\help and /ban @lain")
parse_slash_commands("lets see some \\help and /ban @lain")
);
assert_eq!(
vec![StatusCommand::Ignore],
parse_status("lets see some /ignore and /ban @lain")
parse_slash_commands("lets see some /ignore and /ban @lain")
);
assert_eq!(
vec![
@ -451,7 +592,7 @@ mod test {
StatusCommand::BanUser("piggo@piggo.space".to_string()),
StatusCommand::BanServer("soykaf.com".to_string())
],
parse_status("let's /ban @lain! /ban @piggo@piggo.space and also /ban soykaf.com")
parse_slash_commands("let's /ban @lain! /ban @piggo@piggo.space and also /ban soykaf.com")
);
}
@ -459,13 +600,13 @@ mod test {
fn test_strip() {
assert_eq!(
vec![StatusCommand::BanUser("betty".to_string())],
parse_status(
parse_slash_commands(
r#"Let's bad the naughty bot: /ban <span class="h-card"><a class="u-url mention" data-user="9nXpaGZL88fPAiP8xU" href="https://piggo.space/users/betty" rel="ugc">@<span>betty</span></a></span>"#
)
);
assert_eq!(
vec![StatusCommand::BanUser("betty@abstarbauze.com".to_string())],
parse_status(
parse_slash_commands(
r#"Let's bad the naughty bot: /ban <span class="h-card"><a class="u-url mention" data-user="9nXpaGZL88fPAiP8xU" href="https://piggo.space/users/betty" rel="ugc">@<span>betty@abstarbauze.com</span></a></span>"#
)
);

@ -12,6 +12,8 @@ pub enum GroupError {
GroupNotExist,
#[error("Config error: {0}")]
BadConfig(Cow<'static, str>),
#[error("API request timed out")]
ApiTimeout,
#[error(transparent)]
IoError(#[from] std::io::Error),
#[error(transparent)]

@ -1,604 +0,0 @@
use std::collections::HashSet;
use std::sync::Arc;
use std::time::{Duration, Instant};
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 elefren::{FediClient, StatusBuilder};
use futures::StreamExt;
use crate::command::StatusCommand;
use crate::error::GroupError;
use crate::store::data::GroupConfig;
use crate::store::ConfigStore;
use crate::utils::{normalize_acct, 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>,
}
const DELAY_BEFORE_ACTION: Duration = Duration::from_millis(250);
const DELAY_REOPEN_STREAM: Duration = Duration::from_millis(1000);
const MAX_CATCHUP_NOTIFS: usize = 25;
const PERIODIC_SAVE: Duration = Duration::from_secs(60);
const PING_INTERVAL: Duration = Duration::from_secs(15); // must be < periodic save!
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> {
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.log_error("Error handling a notification");
}
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(DELAY_REOPEN_STREAM).await;
}
}
async fn handle_notification(&mut self, n: Notification) -> Result<(), GroupError> {
debug!("Handling notif #{}", n.id);
let ts = n.timestamp_millis();
self.config.set_last_notif(ts);
let group_acct = self.config.get_acct().to_string();
let notif_acct = normalize_acct(&n.account.acct, &group_acct)?;
let can_write = self.config.can_write(&notif_acct);
let is_admin = self.config.is_admin(&notif_acct);
if self.config.is_banned(&notif_acct) {
warn!("Notification actor {} is banned!", notif_acct);
return Ok(());
}
match n.notification_type {
NotificationType::Mention => {
if let Some(status) = n.status {
let status_acct = normalize_acct(&status.account.acct, &group_acct)?;
if self.config.is_banned(&status_acct) {
warn!("Status author {} is banned!", status_acct);
return Ok(());
}
let commands = crate::command::parse_status(&status.content);
let mut replies = vec![];
let mut announcements = vec![];
let mut do_boost_prev_post = false;
let mut any_admin_cmd = false;
if commands.is_empty() {
debug!("No commands in post");
if status.in_reply_to_id.is_none() {
if can_write {
// Someone tagged the group in OP, boost it.
info!("Boosting OP mention");
tokio::time::sleep(DELAY_BEFORE_ACTION).await;
self.client.reblog(&status.id).await.log_error("Failed to boost");
} else {
replies.push("You are not allowed to post to this group".to_string());
}
} else {
debug!("Not OP, ignore mention");
}
} else {
for cmd in commands {
match cmd {
// ignore is first on purpose
StatusCommand::Ignore => {
debug!("Notif ignored because of ignore command");
return Ok(());
}
StatusCommand::Announce(a) => {
info!("Sending PSA");
announcements.push(a);
}
StatusCommand::Boost => {
if can_write {
do_boost_prev_post = status.in_reply_to_id.is_some();
} else {
replies.push("You are not allowed to share to this group".to_string());
}
}
StatusCommand::BanUser(u) => {
let u = normalize_acct(&u, &group_acct)?;
if is_admin {
if !self.config.is_banned(&u) {
match self.config.ban_user(&u, true) {
Ok(_) => {
any_admin_cmd = true;
replies.push(format!("User {} banned from group!", u));
// no announcement here
}
Err(e) => {
replies.push(format!("Failed to ban user {}: {}", u, e));
}
}
}
} else {
replies.push("Only admins can manage user bans".to_string());
}
}
StatusCommand::UnbanUser(u) => {
let u = normalize_acct(&u, &group_acct)?;
if is_admin {
if self.config.is_banned(&u) {
match self.config.ban_user(&u, false) {
Ok(_) => {
any_admin_cmd = true;
replies.push(format!("User {} un-banned!", u));
// no announcement here
}
Err(_) => {
unreachable!()
}
}
}
} else {
replies.push("Only admins can manage user bans".to_string());
}
}
StatusCommand::BanServer(s) => {
if is_admin {
if !self.config.is_server_banned(&s) {
match self.config.ban_server(&s, true) {
Ok(_) => {
any_admin_cmd = true;
announcements.push(format!("Server \"{}\" has been banned.", s));
replies.push(format!("Server {} banned from group!", s));
}
Err(e) => {
replies.push(format!("Failed to ban server {}: {}", s, e));
}
}
}
} else {
replies.push("Only admins can manage server bans".to_string());
}
}
StatusCommand::UnbanServer(s) => {
if is_admin {
if self.config.is_server_banned(&s) {
match self.config.ban_server(&s, false) {
Ok(_) => {
any_admin_cmd = true;
announcements.push(format!("Server \"{}\" has been un-banned.", s));
replies.push(format!("Server {} un-banned!", s));
}
Err(_) => {
unreachable!()
}
}
}
} else {
replies.push("Only admins can manage server bans".to_string());
}
}
StatusCommand::AddMember(u) => {
let u = normalize_acct(&u, &group_acct)?;
if is_admin {
if !self.config.is_member(&u) {
match self.config.set_member(&u, true) {
Ok(_) => {
any_admin_cmd = true;
replies.push(format!("User {} added to the group!", u));
if self.config.is_member_only() {
announcements
.push(format!("Welcome new member @{} to the group!", u));
}
}
Err(e) => {
replies.push(format!("Failed to add user {} to group: {}", u, e));
}
}
}
} else {
replies.push("Only admins can manage members".to_string());
}
}
StatusCommand::RemoveMember(u) => {
let u = normalize_acct(&u, &group_acct)?;
if is_admin {
if self.config.is_member(&u) {
match self.config.set_member(&u, false) {
Ok(_) => {
any_admin_cmd = true;
replies.push(format!("User {} removed from the group.", u));
}
Err(_) => {
unreachable!()
}
}
}
} else {
replies.push("Only admins can manage members".to_string());
}
}
StatusCommand::GrantAdmin(u) => {
let u = normalize_acct(&u, &group_acct)?;
if is_admin {
if !self.config.is_admin(&u) {
match self.config.set_admin(&u, true) {
Ok(_) => {
any_admin_cmd = true;
replies.push(format!("User {} is now a group admin!", u));
announcements
.push(format!("User @{} can now manage this group!", u));
}
Err(e) => {
replies.push(format!(
"Failed to make user {} a group admin: {}",
u, e
));
}
}
}
} else {
replies.push("Only admins can manage admins".to_string());
}
}
StatusCommand::RemoveAdmin(u) => {
let u = normalize_acct(&u, &group_acct)?;
if is_admin {
if self.config.is_admin(&u) {
match self.config.set_admin(&u, false) {
Ok(_) => {
any_admin_cmd = true;
replies.push(format!("User {} is no longer a group admin!", u));
announcements
.push(format!("User @{} no longer manages this group.", u));
}
Err(e) => {
replies
.push(format!("Failed to revoke {}'s group admin: {}", u, e));
}
}
}
} else {
replies.push("Only admins can manage admins".to_string());
}
}
StatusCommand::OpenGroup => {
if is_admin {
if self.config.is_member_only() {
any_admin_cmd = true;
self.config.set_member_only(false);
replies.push("Group changed to open-access".to_string());
announcements.push("This group is now open-access!".to_string());
}
} else {
replies.push("Only admins can set group options".to_string());
}
}
StatusCommand::CloseGroup => {
if is_admin {
if !self.config.is_member_only() {
any_admin_cmd = true;
self.config.set_member_only(true);
replies.push("Group changed to member-only".to_string());
announcements.push("This group is now member-only!".to_string());
}
} else {
replies.push("Only admins can set group options".to_string());
}
}
StatusCommand::Help => {
if self.config.is_member_only() {
let mut s = "This is a member-only group. ".to_string();
if self.config.can_write(&notif_acct) {
if is_admin {
s.push_str("*You are an admin.*");
} else {
s.push_str("*You are a member.*");
}
} else {
s.push_str("*You are not a member, ask one of the admins to add you.*");
}
replies.push(s);
} else {
let mut s = "This is a public-access group. ".to_string();
if is_admin {
s.push_str("*You are an admin.*");
}
replies.push(s);
}
replies.push(
"\nTo share an original post, mention the group user.\n\
Replies and mentions with commands won't be shared.\n\
\n\
**Supported commands:**\n\
`/boost, /b` - boost the replied-to post into the group\n\
`/ignore, /i` - make the group completely ignore the post\n\
`/ping` - check that the service is alive".to_string(),
);
if self.config.is_member_only() {
replies.push("`/members, /who` - show group members / admins".to_string());
replies.push("`/leave` - leave the group".to_string());
} else {
replies.push("`/members, /who` - show group admins".to_string());
}
if is_admin {
replies.push(
"\n\
**Admin commands:**\n\
`/add user` - add a member (use e-mail style address)\n\
`/kick, /remove user` - kick a member\n\
`/ban x` - ban a user or a server\n\
`/unban x` - lift a ban\n\
`/op, /admin user` - grant admin rights\n\
`/deop, /deadmin user` - revoke admin rights\n\
`/opengroup` - make member-only\n\
`/closegroup` - make public-access\n\
`/announce x` - make a public announcement from the rest of the status"
.to_string(),
);
}
}
StatusCommand::ListMembers => {
let mut show_admins = false;
if is_admin {
if self.config.is_member_only() {
replies.push("Group members:".to_string());
let admins = self.config.get_admins().collect::<HashSet<_>>();
let mut members = self.config.get_members().collect::<Vec<_>>();
members.extend(admins.iter());
members.sort();
members.dedup();
for m in members {
if admins.contains(&m) {
replies.push(format!("{} [admin]", m));
} else {
replies.push(m.to_string());
}
}
} else {
show_admins = true;
}
} else {
show_admins = true;
}
if show_admins {
replies.push("Group admins:".to_string());
let mut admins = self.config.get_admins().collect::<Vec<_>>();
admins.sort();
for a in admins {
replies.push(a.to_string());
}
}
}
StatusCommand::Leave => {
if self.config.is_member(&notif_acct) {
any_admin_cmd = true;
let _ = self.config.set_member(&notif_acct, false);
replies.push("You left the group.".to_string());
}
}
StatusCommand::Ping => {
replies.push("Pong".to_string());
}
}
}
tokio::time::sleep(DELAY_BEFORE_ACTION).await;
}
if do_boost_prev_post {
self.client
.reblog(&status.in_reply_to_id.as_ref().unwrap())
.await
.log_error("Failed to boost");
}
if !replies.is_empty() {
let r = replies.join("\n");
let post = StatusBuilder::new()
.status(format!("@{user}\n{msg}", user = notif_acct, msg = r))
.content_type("text/markdown")
.visibility(Visibility::Direct)
.build()
.expect("error build status");
let _ = self.client.new_status(post).await.log_error("Failed to post");
}
if !announcements.is_empty() {
let msg = announcements.join("\n");
let post = StatusBuilder::new()
.status(format!("**📢 Group announcement**\n{msg}", msg = msg))
.content_type("text/markdown")
.visibility(Visibility::Public)
.build()
.expect("error build status");
let _ = self.client.new_status(post).await.log_error("Failed to post");
}
if any_admin_cmd {
self.save_if_needed().await.log_error("Failed to save");
}
}
}
NotificationType::Follow => {
info!("New follower!");
tokio::time::sleep(Duration::from_millis(500)).await;
let text = if self.config.is_member_only() {
// Admins are listed without @, so they won't become handles here.
// Tagging all admins would be annoying.
let mut admins = self.config.get_admins().cloned().collect::<Vec<_>>();
admins.sort();
format!(
"@{user} welcome to the group! This is a member-only group, you won't be \
able to post. Ask the group admins if you wish to join!\n\n\
Admins: {admins}",
user = notif_acct,
admins = admins.join(", ")
)
} else {
format!(
"@{user} welcome to the group! \
To share a post, tag the group user. Use /help for more info.",
user = notif_acct
)
};
let post = StatusBuilder::new()
.status(text)
.content_type("text/markdown")
.visibility(Visibility::Direct)
.build()
.expect("error build status");
let _ = self.client.new_status(post).await.log_error("Failed to post");
}
_ => {}
}
Ok(())
}
/// Catch up with missed notifications, returns true if any were handled
async fn catch_up_with_missed_notifications(&mut self) -> Result<bool, GroupError> {
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.log_error("Error handling a notification");
}
Ok(true)
}
}

@ -0,0 +1,625 @@
use std::collections::HashSet;
use std::time::Duration;
use elefren::{FediClient, SearchType, StatusBuilder};
use elefren::entities::prelude::Status;
use elefren::status_builder::Visibility;
use crate::command::StatusCommand;
use crate::error::GroupError;
use crate::group_handler::GroupHandle;
use crate::store::data::GroupConfig;
use crate::utils::{LogError, normalize_acct};
pub struct ProcessMention<'a> {
status: Status,
config: &'a mut GroupConfig,
client: &'a mut FediClient,
group_acct: String,
status_acct: String,
status_user_id: String,
can_write: bool,
is_admin: bool,
replies: Vec<String>,
announcements: Vec<String>,
do_boost_prev_post: bool,
want_markdown: bool,
}
impl<'a> ProcessMention<'a> {
async fn lookup_acct_id(&self, acct: &str, followed: bool) -> Result<Option<String>, GroupError> {
debug!("Looking up user ID by acct: {}", acct);
match tokio::time::timeout(Duration::from_secs(5), self.client.search_v2(
acct,
!followed,
Some(SearchType::Accounts),
Some(1),
followed,
)).await {
Err(_) => {
warn!("Account lookup timeout!");
Err(GroupError::ApiTimeout)
}
Ok(Err(e)) => {
// Elefren error
Err(e.into())
}
Ok(Ok(res)) => {
if let Some(item) = res.accounts.into_iter().next() {
debug!("Search done, account found");
Ok(Some(item.id))
} else {
debug!("Search done, nothing found");
Ok(None)
}
}
}
}
fn append_admin_list_to_reply(&mut self) {
let mut admins = self.config.get_admins().collect::<Vec<_>>();
admins.sort();
for a in admins {
self.replies.push(a.to_string());
}
}
fn append_member_list_to_reply(&mut self) {
let admins = self.config.get_admins().collect::<HashSet<_>>();
let mut members = self.config.get_members().collect::<Vec<_>>();
members.extend(admins.iter());
members.sort();
members.dedup();
for m in members {
self.replies.push(if admins.contains(&m) {
format!("{} [admin]", m)
} else {
m.to_string()
});
}
}
async fn follow_user(&self, id: &str) -> Result<(), GroupError> {
self.client.follow(id).await?;
Ok(())
}
async fn unfollow_user(&self, id: &str) -> Result<(), GroupError> {
self.client.unfollow(id).await?;
Ok(())
}
pub(crate) async fn run(gh: &'a mut GroupHandle, status: Status) -> Result<(), GroupError> {
let group_acct = gh.config.get_acct().to_string();
let status_acct = normalize_acct(&status.account.acct, &group_acct)?.to_string();
if gh.config.is_banned(&status_acct) {
warn!("Status author {} is banned!", status_acct);
return Ok(());
}
let pm = Self {
status_user_id: status.account.id.to_string(),
client: &mut gh.client,
can_write: gh.config.can_write(&status_acct),
is_admin: gh.config.is_admin(&status_acct),
replies: vec![],
announcements: vec![],
do_boost_prev_post: false,
want_markdown: false,
group_acct,
status_acct,
status,
config: &mut gh.config,
};
pm.handle().await
}
async fn reblog_status(&self) {
self.client.reblog(&self.status.id)
.await
.log_error("Failed to reblog status")
}
fn add_reply(&mut self, line: impl ToString) {
self.replies.push(line.to_string())
}
fn add_announcement(&mut self, line: impl ToString) {
self.announcements.push(line.to_string())
}
async fn handle(mut self) -> Result<(), GroupError> {
let commands = crate::command::parse_slash_commands(&self.status.content);
if commands.is_empty() {
self.handle_post_with_no_commands().await;
} else {
if commands.contains(&StatusCommand::Ignore) {
debug!("Notif ignored because of ignore command");
return Ok(());
}
for cmd in commands {
match cmd {
StatusCommand::Ignore => {
unreachable!(); // Handled above
}
StatusCommand::Announce(a) => {
self.cmd_announce(a).await;
}
StatusCommand::Boost => {
self.cmd_boost().await;
}
StatusCommand::BanUser(u) => {
self.cmd_ban_user(&u).await
.log_error("Error handling ban-user cmd");
}
StatusCommand::UnbanUser(u) => {
self.cmd_unban_user(&u).await
.log_error("Error handling unban-user cmd");
}
StatusCommand::BanServer(s) => {
self.cmd_ban_server(&s).await;
}
StatusCommand::UnbanServer(s) => {
self.cmd_unban_server(&s).await;
}
StatusCommand::AddMember(u) => {
self.cmd_add_member(&u).await
.log_error("Error handling add-member cmd");
}
StatusCommand::RemoveMember(u) => {
self.cmd_remove_member(&u).await
.log_error("Error handling remove-member cmd");
}
StatusCommand::AddTag(tag) => {
self.cmd_add_tag(tag).await;
}
StatusCommand::RemoveTag(tag) => {
self.cmd_remove_tag(tag).await;
}
StatusCommand::GrantAdmin(u) => {
self.cmd_grant_member(&u).await
.log_error("Error handling grant-admin cmd");
}
StatusCommand::RemoveAdmin(u) => {
self.cmd_revoke_member(&u).await
.log_error("Error handling grant-admin cmd");
}
StatusCommand::OpenGroup => {
self.cmd_open_group().await;
}
StatusCommand::CloseGroup => {
self.cmd_close_group().await;
}
StatusCommand::Help => {
self.cmd_help().await;
}
StatusCommand::ListMembers => {
self.cmd_list_members().await;
}
StatusCommand::ListTags => {
self.cmd_list_tags().await;
}
StatusCommand::Leave => {
self.cmd_leave().await;
}
StatusCommand::Join => {
self.cmd_join().await;
}
StatusCommand::Ping => {
self.cmd_ping().await;
}
}
}
}
if self.do_boost_prev_post {
self.client
.reblog(self.status.in_reply_to_id.as_ref().unwrap())
.await
.log_error("Failed to boost");
}
if !self.replies.is_empty() {
debug!("replies={:?}", self.replies);
let r = self.replies.join("\n");
debug!("r={}", r);
if let Ok(post) = StatusBuilder::new()
.status(format!("@{user}\n{msg}", user = self.status_acct, msg = r))
.content_type(if self.want_markdown {
"text/markdown"
} else {
"text/plain"
})
.visibility(self.status.visibility) // Copy visibility
.build()
{
let _ = self.client.new_status(post)
.await.log_error("Failed to post");
}
}
if !self.announcements.is_empty() {
let msg = self.announcements.join("\n");
let post = StatusBuilder::new()
.status(format!("**📢 Group announcement**\n{msg}", msg = msg))
.content_type("text/markdown")
.visibility(Visibility::Public)
.build()
.expect("error build status");
let _ = self.client.new_status(post)
.await.log_error("Failed to post");
}
Ok(())
}
async fn handle_post_with_no_commands(&mut self) {
debug!("No commands in post");
if self.status.in_reply_to_id.is_none() {
if self.can_write {
// Someone tagged the group in OP, boost it.
info!("Boosting OP mention");
// tokio::time::sleep(DELAY_BEFORE_ACTION).await;
self.reblog_status().await;
} else {
self.add_reply("You are not allowed to post to this group");
}
} else {
debug!("Not OP, ignore mention");
}
}
async fn cmd_announce(&mut self, msg: String) {
info!("Sending PSA");
self.add_announcement(msg);
}
async fn cmd_boost(&mut self) {
if self.can_write {
self.do_boost_prev_post = self.status.in_reply_to_id.is_some();
} else {
self.add_reply("You are not allowed to share to this group");
}
}
async fn cmd_ban_user(&mut self, user: &str) -> Result<(), GroupError> {
let u = normalize_acct(user, &self.group_acct)?;
if self.is_admin {
if !self.config.is_banned(&u) {
match self.config.ban_user(&u, true) {
Ok(_) => {
self.add_reply(format!("User {} banned from group!", u));
self.unfollow_by_acct(&u).await
.log_error("Failed to unfollow banned user");
}
Err(e) => {
self.add_reply(format!("Failed to ban user {}: {}", u, e));
}
}
}
} else {
self.add_reply("Only admins can manage user bans");
}
Ok(())
}
async fn cmd_unban_user(&mut self, user: &str) -> Result<(), GroupError> {
let u = normalize_acct(user, &self.group_acct)?;
if self.is_admin {
if self.config.is_banned(&u) {
match self.config.ban_user(&u, false) {
Ok(_) => {
self.add_reply(format!("User {} un-banned!", u));
// no announcement here
}
Err(_) => {
unreachable!()
}
}
}
} else {
self.add_reply("Only admins can manage user bans");
}
Ok(())
}
async fn cmd_ban_server(&mut self, s: &str) {
if self.is_admin {
if !self.config.is_server_banned(s) {
match self.config.ban_server(s, true) {
Ok(_) => {
self.add_announcement(format!("Server \"{}\" has been banned.", s));
self.add_reply(format!("Server {} banned from group!", s));
}
Err(e) => {
self.add_reply(format!("Failed to ban server {}: {}", s, e));
}
}
}
} else {
self.add_reply("Only admins can manage server bans");
}
}
async fn cmd_unban_server(&mut self, s: &str) {
if self.is_admin {
if self.config.is_server_banned(s) {
match self.config.ban_server(s, false) {
Ok(_) => {
self.add_announcement(format!("Server \"{}\" has been un-banned.", s));
self.add_reply(format!("Server {} un-banned!", s));
}
Err(_) => {
unreachable!()
}
}
}
} else {
self.add_reply("Only admins can manage server bans");
}
}
async fn cmd_add_member(&mut self, user: &str) -> Result<(), GroupError> {
let u = normalize_acct(user, &self.group_acct)?;
if self.is_admin {
if !self.config.is_member(&u) {
match self.config.set_member(&u, true) {
Ok(_) => {
self.add_reply(format!("User {} added to the group!", u));
self.follow_user(&self.status_user_id)
.await.log_error("Failed to follow");
}
Err(e) => {
self.add_reply(format!("Failed to add user {} to group: {}", u, e));
}
}
}
} else {
self.add_reply("Only admins can manage members");
}
Ok(())
}
async fn cmd_remove_member(&mut self, user: &str) -> Result<(), GroupError> {
let u = normalize_acct(user, &self.group_acct)?;
if self.is_admin {
if self.config.is_member(&u) {
match self.config.set_member(&u, false) {
Ok(_) => {
self.add_reply(format!("User {} removed from the group.", u));
self.unfollow_by_acct(&u).await
.log_error("Failed to unfollow removed user");
}
Err(_) => {
unreachable!()
}
}
}
} else {
self.add_reply("Only admins can manage members");
}
Ok(())
}
async fn cmd_add_tag(&mut self, tag: String) {
if self.is_admin {
self.config.add_tag(&tag);
self.add_reply(format!("Tag #{} added to the group!", tag));
} else {
self.add_reply("Only admins can manage group tags");
}
}
async fn cmd_remove_tag(&mut self, tag: String) {
if self.is_admin {
self.config.remove_tag(&tag);
self.add_reply(format!("Tag #{} removed from the group!", tag));
} else {
self.add_reply("Only admins can manage group tags");
}
}
async fn cmd_grant_member(&mut self, user: &str) -> Result<(), GroupError> {
let u = normalize_acct(user, &self.group_acct)?;
if self.is_admin {
if !self.config.is_admin(&u) {
match self.config.set_admin(&u, true) {
Ok(_) => {
// try to make the config a little more sane, admins should be members
let _ = self.config.set_member(&u, true);
self.add_reply(format!("User {} is now a group admin!", u));
self.add_announcement(format!("User @{} can now manage this group!", u));
}
Err(e) => {
self.add_reply(format!(
"Failed to make user {} a group admin: {}",
u, e
));
}
}
}
} else {
self.add_reply("Only admins can manage admins");
}
Ok(())
}
async fn cmd_revoke_member(&mut self, user: &str) -> Result<(), GroupError> {
let u = normalize_acct(user, &self.group_acct)?;
if self.is_admin {
if self.config.is_admin(&u) {
match self.config.set_admin(&u, false) {
Ok(_) => {
self.add_reply(format!("User {} is no longer a group admin!", u));
self.add_announcement(format!("User @{} no longer manages this group.", u));
}
Err(e) => {
self.add_reply(format!("Failed to revoke {}'s group admin: {}", u, e));
}
}
}
} else {
self.add_reply("Only admins can manage admins");
}
Ok(())
}
async fn cmd_open_group(&mut self) {
if self.is_admin {
if self.config.is_member_only() {
self.config.set_member_only(false);
self.add_reply("Group changed to open-access");
self.add_announcement("This group is now open-access!");
}
} else {
self.add_reply("Only admins can set group options");
}
}
async fn cmd_close_group(&mut self) {
if self.is_admin {
if !self.config.is_member_only() {
self.config.set_member_only(true);
self.add_reply("Group changed to member-only");
self.add_announcement("This group is now member-only!");
}
} else {
self.add_reply("Only admins can set group options");
}
}
async fn cmd_help(&mut self) {
self.want_markdown = true;
if self.config.is_member_only() {
self.add_reply("This is a member-only group. ");
} else {
self.add_reply("This is a public-access group. ");
}
if self.config.can_write(&self.status_acct) {
if self.is_admin {
self.add_reply("*You are an admin.*");
} else {
self.add_reply("*You are a member.*");
}
} else {
if self.config.is_member_only() {
self.add_reply("*You are not a member, ask one of the admins to add you.*");
} else {
self.add_reply("*You are not a member, follow or use /join to join the group.*");
}
}
self.add_reply("\n\
To share an original post, mention the group user.\n\
Replies and mentions with commands won't be shared.\n\
\n\
**Supported commands:**\n\
`/boost, /b` - boost the replied-to post into the group\n\
`/ignore, /i` - make the group completely ignore the post\n\
`/ping` - check that the service is alive\n\
`/join` - join the group\n\
`/leave` - leave the group");
if self.config.is_member_only() {
self.add_reply("`/members, /who` - show group members / admins");
} else {
self.add_reply("`/members, /who` - show group admins");
}
if self.is_admin {
self.add_reply("\n\
**Admin commands:**\n\
`/add user` - add a member (use e-mail style address)\n\
`/kick, /remove user` - kick a member\n\
`/ban x` - ban a user or a server\n\
`/unban x` - lift a ban\n\
`/op, /admin user` - grant admin rights\n\
`/deop, /deadmin user` - revoke admin rights\n\
`/opengroup` - make member-only\n\
`/closegroup` - make public-access\n\
`/announce x` - make a public announcement from the rest of the status");
}
}
async fn cmd_list_members(&mut self) {
if self.is_admin {
self.add_reply("Group members:");
self.append_member_list_to_reply();
} else {
self.add_reply("Group admins:");
self.append_admin_list_to_reply();
}
}
async fn cmd_list_tags(&mut self) {
self.add_reply("Group tags:");
let mut tags = self.config.get_tags().collect::<Vec<_>>();
tags.sort();
for t in tags {
self.replies.push(format!("#{}", t).to_string());
}
}
async fn cmd_leave(&mut self) {
if self.config.is_member_or_admin(&self.status_acct) {
// admin can leave but that's a bad idea
let _ = self.config.set_member(&self.status_acct, false);
self.add_reply("You're no longer a group member. Unfollow the group user to stop receiving group messages.");
self.unfollow_user(&self.status_user_id).await
.log_error("Failed to unfollow");
}
}
async fn cmd_join(&mut self) {
if self.config.is_member_or_admin(&self.status_acct) {
debug!("Already member or admin, try to follow-back again");
// Already a member, so let's try to follow the user
// again, maybe first time it failed
self.follow_user(&self.status_user_id).await
.log_error("Failed to follow");
} else {
// Not a member yet
if self.config.is_member_only() {
// No you can't
self.add_reply("\
Sorry, this group is closed to new sign-ups.\n\
Please ask one of the group admins to add you:");
self.append_admin_list_to_reply();
} else {
// Open access, try to follow back
self.follow_user(&self.status_user_id).await
.log_error("Failed to follow");
// This only fails if the user is banned, but that is filtered above
let _ = self.config.set_member(&self.status_acct, true);
self.add_reply("\
Welcome to the group! The group user will now follow you to complete the sign-up. \
Make sure you follow back to receive shared posts!\n\n\
Use /help for more info.");
}
}
}
async fn cmd_ping(&mut self) {
self.add_reply(format!("pong, this is fedigroups service v{}", env!("CARGO_PKG_VERSION")));
}
async fn unfollow_by_acct(&self, acct: &str) -> Result<(), GroupError> {
// Try to unfollow
if let Ok(Some(id)) = self.lookup_acct_id(acct, true).await {
self.unfollow_user(&id).await?;
}
Ok(())
}
}

@ -0,0 +1,454 @@
use std::sync::Arc;
use std::time::{Duration, Instant};
use elefren::{FediClient, StatusBuilder};
use elefren::debug::EventDisplay;
use elefren::debug::NotificationDisplay;
use elefren::debug::StatusDisplay;
use elefren::entities::event::Event;
use elefren::entities::notification::{Notification, NotificationType};
use elefren::entities::status::Status;
use elefren::status_builder::Visibility;
use futures::StreamExt;
use handle_mention::ProcessMention;
use crate::error::GroupError;
use crate::store::ConfigStore;
use crate::store::data::GroupConfig;
use crate::utils::{LogError, normalize_acct, VisExt};
mod handle_mention;
/// 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>,
}
// const DELAY_BEFORE_ACTION: Duration = Duration::from_millis(250);
const DELAY_REOPEN_STREAM: Duration = Duration::from_millis(500);
const MAX_CATCHUP_NOTIFS: usize = 25;
// also statuses
const MAX_CATCHUP_STATUSES: usize = 50;
// higher because we can expect a lot of non-hashtag statuses here
const PERIODIC_SAVE: Duration = Duration::from_secs(60);
const PING_INTERVAL: Duration = Duration::from_secs(15); // must be < periodic save!
impl GroupHandle {
pub async fn save(&mut self) -> Result<(), GroupError> {
debug!("Saving group config & status");
self.store.set_group_config(self.config.clone()).await?;
trace!("Saved");
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 NotifTimestamp for Status {
fn timestamp_millis(&self) -> u64 {
// this may not work well for unseen status tracking,
// if ancient statuses were to appear in the timeline :(
self.created_at.timestamp_millis().max(0) as u64
}
}
impl GroupHandle {
pub async fn run(&mut self) -> Result<(), GroupError> {
assert!(PERIODIC_SAVE >= PING_INTERVAL);
loop {
debug!("Opening streaming API socket");
let mut next_save = Instant::now() + PERIODIC_SAVE; // so we save at start
let mut events = self.client.streaming_user().await?;
let socket_open_time = Instant::now();
let mut last_rx = Instant::now();
let mut last_ping = Instant::now();
match self.catch_up_with_missed_notifications().await {
Ok(true) => {
debug!("Some missed notifs handled");
}
Ok(false) => {
debug!("No notifs missed");
}
Err(e) => {
error!("Failed to handle missed notifs: {}", e);
}
}
match self.catch_up_with_missed_statuses().await {
Ok(true) => {
debug!("Some missed statuses handled");
}
Ok(false) => {
debug!("No statuses missed");
}
Err(e) => {
error!("Failed to handle missed statuses: {}", e);
}
}
if self.config.is_dirty() {
// save asap
next_save = Instant::now() - PERIODIC_SAVE
}
'rx: loop {
if next_save < Instant::now() {
trace!("Save time elapsed, saving if needed");
self.save_if_needed().await.log_error("Failed to save group");
next_save = Instant::now() + PERIODIC_SAVE;
}
if last_rx.elapsed() > PING_INTERVAL * 2 {
warn!("Socket idle too long, close");
break 'rx;
}
if socket_open_time.elapsed() > Duration::from_secs(120) {
debug!("Socket open too long, closing");
break 'rx;
}
trace!("Waiting for message");
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)) => {
last_rx = Instant::now();
debug!("(@{}) Event: {}", self.config.get_acct(), EventDisplay(&event));
match event {
Event::Update(status) => {
self.handle_status(status).await.log_error("Error handling a status");
}
Event::Notification(n) => {
self.handle_notification(n).await.log_error("Error handling a notification");
}
Event::Delete(_id) => {}
Event::FiltersChanged => {}
Event::Heartbeat => {}
}
}
Ok(None) => {
warn!("Group @{} socket closed, restarting...", self.config.get_acct());
break 'rx;
}
Err(_) => {
// Timeout so we can save if needed
}
}
if last_ping.elapsed() > PING_INTERVAL {
last_ping = Instant::now();
trace!("Pinging");
if events.send_ping()
.await.is_err() {
break 'rx;
}
}
}
warn!("Notif stream closed, will reopen");
tokio::time::sleep(DELAY_REOPEN_STREAM).await;
}
}
async fn handle_notification(&mut self, n: Notification) -> Result<(), GroupError> {
debug!("Handling notif #{}", n.id);
let ts = n.timestamp_millis();
self.config.set_last_notif(ts);
let group_acct = self.config.get_acct().to_string();
let notif_user_id = &n.account.id;
let notif_acct = normalize_acct(&n.account.acct, &group_acct)?;
if notif_acct == group_acct {
debug!("This is our post, ignore that");
return Ok(());
}
if self.config.is_banned(&notif_acct) {
warn!("Notification actor {} is banned!", notif_acct);
return Ok(());
}
match n.notification_type {
NotificationType::Mention => {
if let Some(status) = n.status {
self.handle_mention_status(status).await?;
}
}
NotificationType::Follow => {
info!("New follower!");
// Just greet the user always
self.handle_new_follow(&notif_acct, notif_user_id).await;
// if self.config.is_member_or_admin(&notif_acct) {
// // Already joined, just doing something silly, ignore this
// debug!("User already a member, ignoring");
// } else {
//
// }
}
NotificationType::Favourite => {}
NotificationType::Reblog => {}
NotificationType::Other(_) => {}
}
Ok(())
}
/// Handle a non-mention status
async fn handle_status(&mut self, s: Status) -> Result<(), GroupError> {
debug!("Handling status #{}", s.id);
let ts = s.timestamp_millis();
self.config.set_last_status(ts);
if s.visibility.is_private() {
debug!("Status is direct/private, discard");
return Ok(());
}
if !s.content.contains('#') {
debug!("No tags in status, discard");
return Ok(());
}
let group_user = self.config.get_acct();
let status_user = normalize_acct(&s.account.acct, group_user)?;
if status_user == group_user {
debug!("This is our post, discard");
return Ok(());
}
if s.content.contains("/add ")
|| s.content.contains("/remove ")
|| s.content.contains("\\add ")
|| s.content.contains("\\remove ")
{
debug!("Looks like a hashtag manipulation command, discard");
return Ok(());
}
if self.config.is_banned(&status_user) {
debug!("Status author @{} is banned.", status_user);
return Ok(());
}
if !self.config.is_member_or_admin(&status_user) {
debug!("Status author @{} is not a member.", status_user);
return Ok(());
}
let tags = crate::command::parse_status_tags(&s.content);
debug!("Tags in status: {:?}", tags);
'tags: for t in tags {
if self.config.is_tag_followed(&t) {
info!("REBLOG #{} STATUS", &t);
self.client.reblog(&s.id).await
.log_error("Failed to reblog");
break 'tags; // do not reblog multiple times!
}
}
Ok(())
}
async fn follow_user(&mut self, id: &str) -> Result<(), GroupError> {
self.client.follow(id).await?;
Ok(())
}
/// Catch up with missed notifications, returns true if any were handled
async fn catch_up_with_missed_notifications(&mut self) -> Result<bool, GroupError> {
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
}
debug!("Inspecting notif {}", NotificationDisplay(&n));
notifs_to_handle.push(n);
num += 1;
if num > MAX_CATCHUP_NOTIFS {
warn!("Too many notifs missed to catch up!");
break;
}
// sleep so we dont make the api angry
tokio::time::sleep(Duration::from_millis(250)).await;
}
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.log_error("Error handling a notification");
}
Ok(true)
}
/// Catch up with missed statuses, returns true if any were handled
async fn catch_up_with_missed_statuses(&mut self) -> Result<bool, GroupError> {
let last_status = self.config.get_last_status();
let statuses = self.client.get_home_timeline().await?;
let mut iter = statuses.items_iter();
let mut statuses_to_handle = vec![];
// They are retrieved newest first, but we want oldest first for chronological handling
let mut newest_status = None;
let mut num = 0;
while let Some(s) = iter.next_item().await {
let ts = s.timestamp_millis();
if ts <= last_status {
break; // reached our last seen status (hopefully there arent any retro-bumped)
}
debug!("Inspecting status {}", StatusDisplay(&s));
if newest_status.is_none() {
newest_status = Some(ts);
}
if s.content.contains('#') && !s.visibility.is_private() {
statuses_to_handle.push(s);
}
num += 1;
if num > MAX_CATCHUP_STATUSES {
warn!("Too many statuses missed to catch up!");
break;
}
// sleep so we dont make the api angry
tokio::time::sleep(Duration::from_millis(250)).await;
}
if let Some(ts) = newest_status {
self.config.set_last_status(ts);
}
if statuses_to_handle.is_empty() {
return Ok(false);
}
statuses_to_handle.reverse();
debug!("{} statuses to catch up!", statuses_to_handle.len());
for s in statuses_to_handle {
debug!("Handling missed status: {}", StatusDisplay(&s));
self.handle_status(s).await
.log_error("Error handling a status");
}
Ok(true)
}
async fn handle_mention_status(&mut self, status: Status) -> Result<(), GroupError> {
let res = ProcessMention::run(self, status).await;
self.save_if_needed().await
.log_error("Failed to save");
res
}
async fn handle_new_follow(&mut self, notif_acct: &str, notif_user_id: &str) {
let mut follow_back = false;
let text = if self.config.is_member_only() {
// Admins are listed without @, so they won't become handles here.
// Tagging all admins would be annoying.
let mut admins = self.config.get_admins().cloned().collect::<Vec<_>>();
admins.sort();
format!("\
@{user} Welcome! This group has posting restricted to members. \
If you'd like to join, please ask one of the group admins:\n\
{admins}",
user = notif_acct,
admins = admins.join(", ")
)
} else {
follow_back = true;
format!("\
@{user} Welcome to the group! The group user will now follow you back to complete the sign-up. \
To share a post, tag the group user or use one of the group hashtags.\n\n\
Use /help for more info.",
user = notif_acct
)
};
let post = StatusBuilder::new()
.status(text)
.content_type("text/markdown")
.visibility(Visibility::Direct)
.build()
.expect("error build status");
self.client.new_status(post).await
.log_error("Failed to post");
if follow_back {
self.follow_user(notif_user_id).await
.log_error("Failed to follow back");
}
}
}

@ -18,7 +18,7 @@ use crate::utils::acct_to_server;
mod command;
mod error;
mod group_handle;
mod group_handler;
mod store;
mod utils;

@ -7,13 +7,13 @@ use crate::error::GroupError;
/// This is the inner data struct holding the config
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub(crate) struct Config {
groups: HashMap<String, GroupConfig>,
pub(crate) groups: HashMap<String, GroupConfig>,
}
impl Config {
pub(crate) fn iter_groups(&self) -> impl Iterator<Item = &GroupConfig> {
self.groups.values()
}
// 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)
@ -33,6 +33,8 @@ pub(crate) struct GroupConfig {
acct: String,
/// elefren data
appdata: AppData,
/// Hashtags the group will auto-boost from it's members
group_tags: HashSet<String>,
/// 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
@ -43,9 +45,10 @@ pub(crate) struct GroupConfig {
member_only: bool,
/// Banned domain names, e.g. kiwifarms.cc
banned_servers: HashSet<String>,
/// Last seen notification timestamp
/// Last seen notification timestamp (millis)
last_notif_ts: u64,
/// Last seen status timestamp (millis)
last_status_ts: u64,
#[serde(skip)]
dirty: bool,
}
@ -62,12 +65,14 @@ impl Default for GroupConfig {
redirect: Default::default(),
token: Default::default(),
},
group_tags: 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,
last_status_ts: 0,
dirty: false,
}
}
@ -86,19 +91,23 @@ impl GroupConfig {
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;
if self.appdata != appdata {
self.mark_dirty();
}
self.appdata = appdata;
}
pub(crate) fn get_admins(&self) -> impl Iterator<Item = &String> {
self.admin_users.iter()
@ -108,15 +117,32 @@ impl GroupConfig {
self.member_users.iter()
}
pub(crate) fn get_tags(&self) -> impl Iterator<Item = &String> {
self.group_tags.iter()
}
pub(crate) fn set_last_notif(&mut self, ts: u64) {
self.last_notif_ts = self.last_notif_ts.max(ts);
if self.last_notif_ts != ts {
self.mark_dirty();
}
self.last_notif_ts = self.last_notif_ts.max(ts);
}
pub(crate) fn get_last_notif(&self) -> u64 {
self.last_notif_ts
}
pub(crate) fn set_last_status(&mut self, ts: u64) {
if self.last_status_ts != ts {
self.mark_dirty();
}
self.last_status_ts = self.last_status_ts.max(ts);
}
pub(crate) fn get_last_status(&self) -> u64 {
self.last_status_ts
}
pub(crate) fn get_acct(&self) -> &str {
&self.acct
}
@ -129,6 +155,11 @@ impl GroupConfig {
self.member_users.contains(acct)
}
pub(crate) fn is_member_or_admin(&self, acct: &str) -> bool {
self.is_member(acct)
|| self.is_admin(acct)
}
pub(crate) fn is_banned(&self, acct: &str) -> bool {
self.banned_users.contains(acct) || self.is_users_server_banned(acct)
}
@ -152,63 +183,93 @@ impl GroupConfig {
}
pub(crate) fn set_admin(&mut self, acct: &str, admin: bool) -> Result<(), GroupError> {
if admin {
let change = if admin {
if self.is_banned(acct) {
return Err(GroupError::UserIsBanned);
}
self.admin_users.insert(acct.to_owned());
self.admin_users.insert(acct.to_owned())
} else {
self.admin_users.remove(acct);
}
self.admin_users.remove(acct)
};
if change {
self.mark_dirty();
}
Ok(())
}
pub(crate) fn set_member(&mut self, acct: &str, member: bool) -> Result<(), GroupError> {
if member {
let change = if member {
if self.is_banned(acct) {
return Err(GroupError::UserIsBanned);
}
self.member_users.insert(acct.to_owned());
self.member_users.insert(acct.to_owned())
} else {
self.member_users.remove(acct);
}
self.member_users.remove(acct)
};
if change {
self.mark_dirty();
}
Ok(())
}
pub(crate) fn ban_user(&mut self, acct: &str, ban: bool) -> Result<(), GroupError> {
let mut change = false;
if ban {
if self.is_admin(acct) {
return Err(GroupError::UserIsAdmin);
}
self.banned_users.insert(acct.to_owned());
// Banned user is also kicked
change |= self.member_users.remove(acct);
change |= self.banned_users.insert(acct.to_owned());
} else {
self.banned_users.remove(acct);
change |= self.banned_users.remove(acct);
}
if change {
self.mark_dirty();
}
Ok(())
}
pub(crate) fn ban_server(&mut self, server: &str, ban: bool) -> Result<(), GroupError> {
if ban {
let changed = 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());
self.banned_servers.insert(server.to_owned())
} else {
self.banned_servers.remove(server);
}
self.banned_servers.remove(server)
};
if changed {
self.mark_dirty();
}
Ok(())
}
pub(crate) fn add_tag(&mut self, tag: &str) {
if self.group_tags.insert(tag.to_string()) {
self.mark_dirty();
}
}
pub(crate) fn remove_tag(&mut self, tag: &str) {
if self.group_tags.remove(tag) {
self.mark_dirty();
}
}
pub(crate) fn is_tag_followed(&self, tag: &str) -> bool {
self.group_tags.contains(tag)
}
pub(crate) fn set_member_only(&mut self, member_only: bool) {
self.member_only = member_only;
if self.member_only != member_only {
self.mark_dirty();
}
self.member_only = member_only;
}
pub(crate) fn is_member_only(&self) -> bool {
self.member_only

@ -8,7 +8,8 @@ use tokio::sync::RwLock;
use data::{Config, GroupConfig};
use crate::error::GroupError;
use crate::group_handle::GroupHandle;
use crate::group_handler::GroupHandle;
use std::time::Duration;
pub(crate) mod data;
@ -82,6 +83,7 @@ impl ConfigStore {
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();
drop(groups);
println!("--- Re-authenticating bot user @{} ---", acct);
let registration = Registration::new(config.get_appdata().base.to_string())
@ -92,6 +94,8 @@ impl ConfigStore {
.await?;
let client = elefren::helpers::cli::authenticate(registration).await?;
println!("Auth complete");
let appdata = client.data.clone();
config.set_appdata(appdata);
@ -106,8 +110,8 @@ impl ConfigStore {
/// 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();
let groups = self.data.read().await.clone();
let groups_iter = groups.groups.into_values();
// Connect in parallel
futures::stream::iter(groups_iter)
@ -148,17 +152,25 @@ impl ConfigStore {
.collect()
}
/*
pub(crate) async fn get_group_config(&self, group: &str) -> Option<GroupConfig> {
let c = self.data.read().await;
c.get_group_config(group).cloned()
}
*/
//noinspection RsSelfConvention
/// Set group config to the store. The store then saved.
pub(crate) async fn set_group_config(&self, config: GroupConfig) -> Result<(), GroupError> {
let mut data = self.data.write().await;
trace!("Locking mutex");
if let Ok(mut data) = tokio::time::timeout(Duration::from_secs(1), self.data.write()).await {
trace!("Locked");
data.set_group_config(config);
trace!("Writing file");
self.persist(&data).await?;
} else {
error!("DEADLOCK? Timeout waiting for data RW Lock in settings store");
}
Ok(())
}
@ -185,6 +197,7 @@ fn make_scopes() -> Scopes {
| Scopes::read(scopes::Read::Follows)
| Scopes::write(scopes::Write::Statuses)
| Scopes::write(scopes::Write::Media)
| Scopes::write(scopes::Write::Follows)
}
// trait TapOk<T> {

@ -1,6 +1,8 @@
use std::borrow::Cow;
use std::error::Error;
use elefren::status_builder::Visibility;
use crate::error::GroupError;
pub trait LogError {
@ -82,3 +84,14 @@ mod test {
assert_eq!(Err(GroupError::BadConfig("_".into())), normalize_acct("piggo", "uhh"));
}
}
pub trait VisExt: Copy {
/// Check if is private or direct
fn is_private(self) -> bool;
}
impl VisExt for Visibility {
fn is_private(self) -> bool {
self == Visibility::Direct || self == Visibility::Private
}
}

Loading…
Cancel
Save