add a means to ban user tokens (or disable the service in weird ways)

This commit is contained in:
Brandon Thomas committed 2023-03-22 16:05:09 -04:00
1 parent 67ab94664c
commit 96563fa345
10 files changed
+281 -7

No files matched your search

@@ -14,11 +14,6 @@ pub async fn mark_tts_inference_job_done(
) -> AnyhowResult<()> {
let status = if success { "complete_success" } else { "complete_failure" };
let job_id = match job_id {
JobIdType::TtsJob(job) => job.0,
JobIdType::GenericJob(job) => job.0,
};
let query_result = sqlx::query!(
r#"
UPDATE tts_inference_jobs
@@ -33,7 +28,7 @@ WHERE id = ?
status,
maybe_result_token,
last_assigned_worker,
job_id,
job_id.0,
)
.execute(pool)
.await;
@@ -1,2 +1,3 @@
pub mod delete_role_disambiguation;
pub mod encrypted_sort_id;
pub mod encrypted_sort_id;
pub mod troll_user_bans;
@@ -0,0 +1,59 @@
use crate::util::troll_user_bans::load_troll_user_set_from_file::load_user_token_set_from_file;
use crate::util::troll_user_bans::troll_user_ban_list::TrollUserBanList;
use errors::AnyhowResult;
use std::path::Path;
pub fn load_user_token_ban_list_from_directory<P: AsRef<Path>>(path: P) -> AnyhowResult<TrollUserBanList> {
let user_token_ban_list = TrollUserBanList::new();
let paths = std::fs::read_dir(path)?;
for entry in paths {
let path = entry?.path();
let path_name = path.to_string_lossy().to_string();
let user_token_set = load_user_token_set_from_file(path)?;
if user_token_set.is_empty() {
continue;
}
user_token_ban_list.add_set(path_name, user_token_set)?;
}
Ok(user_token_ban_list)
}
#[cfg(test)]
mod tests {
use std::path::PathBuf;
use crate::util::troll_user_bans::load_troll_user_ban_list_from_directory::load_user_token_ban_list_from_directory;
fn test_file(path_from_repo_root: &str) -> PathBuf {
// https://doc.rust-lang.org/cargo/reference/environment-variables.html
let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
path.push(format!("../../../../{}", path_from_repo_root));
path
}
#[test]
fn test_load_user_token_ban_list_from_directory() {
let directory = test_file("test_data/text_files/troll_user_token_ban_example/");
let user_token_set = load_user_token_ban_list_from_directory(directory).unwrap();
// Comments are not included
assert_eq!(user_token_set.contains_user_token("# this is test data").unwrap(), false);
// User tokens in both files are
assert_eq!(user_token_set.contains_user_token("U:FOO").unwrap(), true);
assert_eq!(user_token_set.contains_user_token("U:BOB").unwrap(), true);
// All five user tokens were loaded
assert_eq!(user_token_set.total_user_token_count().unwrap(), 5);
}
#[test]
fn empty_files_are_not_loaded() {
let directory = test_file("test_data/text_files/troll_user_token_ban_example/");
let user_token_set = load_user_token_ban_list_from_directory(directory).unwrap();
// NB: There are two files with user tokens and a single empty file, which should not be loaded
assert_eq!(user_token_set.set_count().unwrap(), 2);
}
}
@@ -0,0 +1,54 @@
use crate::util::troll_user_bans::troll_user_set::TrollUserSet;
use errors::AnyhowResult;
use std::collections::HashSet;
use std::fs::File;
use std::io::{BufRead, BufReader};
use std::path::Path;
pub fn load_user_token_set_from_file<P: AsRef<Path>>(path: P) -> AnyhowResult<TrollUserSet> {
let file = File::open(path)?;
let reader = BufReader::new(file);
let lines = reader.lines()
.filter_map(|line| line.ok())
.map(|line| line.trim().to_string())
.filter(|line| !(line.starts_with("#") || line.is_empty()))
.collect::<HashSet<String>>();
Ok(TrollUserSet::from_set(lines))
}
#[cfg(test)]
mod tests {
use std::path::PathBuf;
use tokens::users::user::UserToken;
use crate::util::troll_user_bans::load_troll_user_set_from_file::load_user_token_set_from_file;
fn test_file(path_from_repo_root: &str) -> PathBuf {
// https://doc.rust-lang.org/cargo/reference/environment-variables.html
let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
path.push(format!("../../../../{}", path_from_repo_root));
path
}
#[test]
fn test_load_user_token_set_from_file() {
let filename = test_file("test_data/text_files/troll_user_token_ban_example/user_tokens_and_comments_1.txt");
let user_token_set = load_user_token_set_from_file(filename).unwrap();
// Comments are not included
assert_eq!(user_token_set.contains_user_token("# this is test data"), false);
// User tokens in the file are.
assert_eq!(user_token_set.contains_user_token("U:FOO"), true);
assert_eq!(user_token_set.contains_user_token("U:BAR"), true);
assert_eq!(user_token_set.contains_user_token("U:NINTENDO"), false);
// Typed interface
assert_eq!(user_token_set.contains_user_token_typed(&UserToken::new_from_str("U:FOO")), true);
assert_eq!(user_token_set.contains_user_token_typed(&UserToken::new_from_str("U:NINTENDO")), false);
// Length is expected
assert_eq!(user_token_set.len(), 2);
}
}
@@ -0,0 +1,4 @@
pub mod troll_user_ban_list;
pub mod troll_user_set;
pub mod load_troll_user_ban_list_from_directory;
pub mod load_troll_user_set_from_file;
@@ -0,0 +1,95 @@
use crate::util::troll_user_bans::troll_user_set::TrollUserSet;
use errors::{anyhow, AnyhowResult};
use std::collections::HashMap;
use std::sync::{Arc, RwLock};
#[derive(Clone)]
pub struct TrollUserBanList {
user_token_sets: Arc<RwLock<HashMap<String, TrollUserSet>>>
}
impl TrollUserBanList {
pub fn new() -> Self {
Self {
user_token_sets: Arc::new(RwLock::new(HashMap::new()))
}
}
pub fn contains_user_token<S: AsRef<str>>(&self, user_token: S) -> AnyhowResult<bool> {
match self.user_token_sets.read() {
Err(_) => Err(anyhow!("Can't read lock")),
Ok(sets) => {
for set in sets.values() {
if set.contains_user_token(user_token.as_ref()) {
return Ok(true)
}
}
Ok(false)
},
}
}
pub fn add_set(&self, set_name: String, user_token_set: TrollUserSet) -> AnyhowResult<Option<TrollUserSet>> {
match self.user_token_sets.write() {
Err(_) => Err(anyhow!("Can't read lock")),
Ok(mut sets) => {
Ok(sets.insert(set_name, user_token_set))
},
}
}
pub fn remove_set(&self, set_name: &str) -> AnyhowResult<Option<TrollUserSet>> {
match self.user_token_sets.write() {
Err(_) => Err(anyhow!("Can't read lock")),
Ok(mut sets) => {
Ok(sets.remove(set_name))
},
}
}
pub fn total_user_token_count(&self) -> AnyhowResult<usize> {
match self.user_token_sets.read() {
Err(_) => Err(anyhow!("Can't read lock")),
Ok(sets) => {
Ok(sets.values()
.map(|set| set.len())
.sum())
},
}
}
pub fn set_count(&self) -> AnyhowResult<usize> {
match self.user_token_sets.read() {
Err(_) => Err(anyhow!("Can't read lock")),
Ok(sets) => {
Ok(sets.len())
},
}
}
}
#[cfg(test)]
mod tests {
use crate::util::troll_user_bans::troll_user_ban_list::TrollUserBanList;
use crate::util::troll_user_bans::troll_user_set::TrollUserSet;
#[test]
fn test_contains_user_token() {
let mut user_token_set_1 = TrollUserSet::new();
user_token_set_1.add_user_token("U:FOO".to_string());
user_token_set_1.add_user_token("U:BAR".to_string());
let mut user_token_set_2 = TrollUserSet::new();
user_token_set_2.add_user_token("U:JIM".to_string());
user_token_set_2.add_user_token("U:CRAMER".to_string());
let user_token_ban_list = TrollUserBanList::new();
user_token_ban_list.add_set("set_1".to_string(), user_token_set_1).unwrap();
user_token_ban_list.add_set("set_2".to_string(), user_token_set_2).unwrap();
assert_eq!(user_token_ban_list.contains_user_token("U:FOO").unwrap(), true);
assert_eq!(user_token_ban_list.contains_user_token("U:JIM").unwrap(), true);
assert_eq!(user_token_ban_list.contains_user_token("U:BANKSY").unwrap(), false);
}
}
@@ -0,0 +1,54 @@
use std::collections::HashSet;
use tokens::users::user::UserToken;
#[derive(Clone)]
pub struct TrollUserSet {
pub user_token_set: HashSet<String>,
}
impl TrollUserSet {
pub fn new() -> Self {
Self {
user_token_set: HashSet::new(),
}
}
pub fn from_set(user_token_set: HashSet<String>) -> Self {
Self {
user_token_set,
}
}
pub fn replace_set(&mut self, user_token_set: HashSet<String>) {
self.user_token_set = user_token_set;
}
pub fn add_user_token(&mut self, user_token: String) -> bool {
self.user_token_set.insert(user_token)
}
pub fn add_user_token_typed(&mut self, user_token: UserToken) -> bool {
self.user_token_set.insert(user_token.to_string())
}
pub fn remove_user_token(&mut self, user_token: &str) -> bool {
self.user_token_set.remove(user_token)
}
pub fn contains_user_token<S: AsRef<str>>(&self, user_token: S) -> bool {
self.user_token_set.contains(user_token.as_ref())
}
pub fn contains_user_token_typed(&self, user_token: &UserToken) -> bool {
self.user_token_set.contains(user_token.as_str())
}
pub fn len(&self) -> usize {
self.user_token_set.len()
}
pub fn is_empty(&self) -> bool {
self.user_token_set.is_empty()
}
}
@@ -0,0 +1,5 @@
# this is test data
# example user tokens
U:FOO
U:BAR
@@ -0,0 +1,7 @@
# this is test data
# more example user tokens
U:STEVE
U:JIM
U:BOB