add logpump

Author: AEnterprise

.cargo/config

@@ -1,2 +1,2 @@
 [build]
-rustflags = ["-C", "target-cpu=native"]
+rustflags = ["-C", "target-cpu=sandybridge" , "-C", "target-feature=+aes,+sse2,+sse4.1,+ssse3"]

Cargo.lock

@@ -13,7 +13,6 @@ bitflags = "1.2"
 chrono = "0.4"
 ctrlc = { version = "3", features = ["termination"] }
 darkredis = "0.7"
-dashmap = { version = "4.0.0-rc6", features=["serde"] }
 flexi_logger = { version = "0.15", default-features = false, features = ["colors", "specfile", "ziplogs"] }
 fluent-bundle = "0.12"
 futures-util = { version = "0.3", default-features = false }

Cargo.toml

@@ -1,44 +1,12 @@
 // use twilight_model::channel::{Reaction, ReactionType};
 // use twilight_model::id::GuildId;
 
-use crate::core::CommandContext;
+use crate::core::{CommandContext, LogType};
 use crate::CommandResult;
 use twilight_model::id::UserId;
 
-pub async fn test(ctx: CommandContext) -> CommandResult {
-    // let reactor = Reactors::new_emoji_list();
-    // let reaction = Reaction {
-    //     channel_id: Default::default(),
-    //     emoji: ReactionType::Unicode { name: "".to_string() },
-    //     guild_id: None,
-    //     member: None,
-    //     message_id: Default::default(),
-    //     user_id: Default::default(),
-    // };
-    // if reactor.processes(&reaction) {
-    //     reactor
-    //         .do_your_thing(ctx.bot_context, &reaction, ctx.message.get_author_as_member()?)
-    //         .await;
-    // }
-
-    // let out = Pattern::new(ctx.parser.parts.len() - 1)
-    //     .arrange(
-    //         ctx.parser
-    //             .parts
-    //             .iter()
-    //             .skip(1)
-    //             .map(String::from)
-    //             .collect::<Vec<String>>(),
-    //     )
-    //     .iter()
-    //     .map(|inner| inner.join("").to_string())
-    //     .collect::<Vec<String>>()
-    //     .join("\n");
-    //
-    // ctx.reply_raw(out).await?;
-    ctx.bot_context
-        .http
-        .delete_ban(ctx.get_guild()?.id, UserId(366972849258496000))
-        .await?;
+pub async fn test(mut ctx: CommandContext) -> CommandResult {
+    let arg = ctx.parser.get_remaining();
+    ctx.log(LogType::TEST(arg), None, None);
     Ok(())
 }

src/commands/debug/test.rs

@@ -19,6 +19,7 @@ pub(crate) mod status;
 pub use stats::BotStats;
 
 use crate::core::cache::Cache;
+use crate::core::logpump::LogData;
 use crate::core::GuildConfig;
 use crate::crypto::EncryptionKey;
 use crate::database::api_structs::{RawTeamMembers, TeamInfo, TeamMember};
@@ -29,6 +30,7 @@ use fluent_bundle::FluentArgs;
 use std::collections::HashMap;
 use std::sync::atomic::AtomicU64;
 use std::sync::Arc;
+use tokio::sync::mpsc::UnboundedSender;
 use tokio::sync::RwLock;
 use unic_langid::LanguageIdentifier;
 
@@ -62,6 +64,7 @@ pub struct BotContext {
     pub start_time: DateTime<Utc>,
     pub global_admins: Vec<UserId>,
     team_info: RawTeamMembers,
+    logpump_sender: UnboundedSender<LogData>,
 }
 
 impl BotContext {
@@ -72,6 +75,7 @@ impl BotContext {
         translations: Translations,
         config_ops: (Option<Vec<u8>>, Vec<u64>),
         stats: Arc<BotStats>,
+        logpump_sender: UnboundedSender<LogData>,
     ) -> Self {
         let scheme_info = bot_core.2;
         let mut shard_states = HashMap::with_capacity(scheme_info.shards_per_cluster as usize);
@@ -112,6 +116,7 @@ impl BotContext {
             start_time: Utc::now(),
             global_admins,
             team_info,
+            logpump_sender,
         }
     }
 
@@ -161,4 +166,8 @@ impl BotContext {
 
         TeamInfo { members }
     }
+
+    pub fn log(&self, data: LogData) {
+        self.logpump_sender.send(data);
+    }
 }

src/core/context/bot/mod.rs

@@ -10,10 +10,11 @@ use twilight_model::{id::MessageId, user::CurrentUser};
 
 use crate::commands::meta::nodes::GearBotPermissions;
 use crate::core::cache::{CachedChannel, CachedGuild, CachedMember, CachedUser};
-use crate::core::{BotContext, GuildConfig};
+use crate::core::{BotContext, GuildConfig, LogData, LogType};
 use crate::parser::Parser;
 use crate::translation::GearBotString;
 use crate::utils::{CommandError, OtherFailure};
+use twilight_model::id::{ChannelId, UserId};
 
 mod messaging;
 mod object_fetcher;
@@ -125,4 +126,20 @@ impl CommandContext {
             None => Err(CommandError::NoDM),
         }
     }
+
+    pub fn log(
+        &self,
+        log_type: LogType,
+        source_channel: Option<ChannelId>,
+        source_user: Option<UserId>,
+    ) -> Result<(), CommandError> {
+        log::debug!("Logging {:?}", log_type);
+        self.bot_context.log(LogData {
+            log_type,
+            guild: self.get_guild()?.id,
+            source_channel,
+            source_user,
+        });
+        Ok(())
+    }
 }

src/core/context/command/mod.rs

@@ -21,11 +21,12 @@ use twilight_model::{
 use crate::core::cache::Cache;
 use crate::core::context::bot::status as bot_status;
 use crate::core::handlers::{commands, general, modlog};
-use crate::core::{BotConfig, BotContext, BotStats, ColdRebootData};
+use crate::core::{logpump, BotConfig, BotContext, BotStats, ColdRebootData};
 use crate::database::Redis;
 use crate::translation::Translations;
 use crate::utils::{EventHandlerError, StartupError};
 use crate::{gearbot_error, gearbot_important, gearbot_info, SchemeInfo};
+use tokio::sync::mpsc::unbounded_channel;
 
 pub async fn run(
     scheme_info: SchemeInfo,
@@ -120,14 +121,20 @@ pub async fn run(
     }
 
     let cluster = cb.build().await?;
+
+    let (sender, receiver) = unbounded_channel();
+
     let context = Arc::new(BotContext::new(
         (cache, cluster, scheme_info),
         (http, bot_user),
         (postgres_pool, redis_pool),
         translations,
         (config.__main_encryption_key, config.global_admins),
         stats,
+        sender,
     ));
+    let ctx = context.clone();
+    let mut logpump_task = tokio::spawn(logpump::run(ctx, receiver));
 
     //establish api connection
     let c = context.clone();
@@ -166,6 +173,9 @@ pub async fn run(
     }
     context.cluster.down();
 
+    //TODO: enable when we move to tokio 0.3
+    // logpump_task.abort();
+
     Ok(())
 }
 

src/core/gearbot.rs

@@ -1,10 +1,12 @@
 use serde::{Deserialize, Serialize};
 use twilight_model::guild::Permissions;
-use twilight_model::id::{RoleId, UserId};
+use twilight_model::id::{ChannelId, RoleId, UserId};
 use unic_langid::LanguageIdentifier;
 
 use crate::commands::meta::nodes::GearBotPermissions;
+use crate::core::{DataLessLogType, LogFilter, LogType};
 use crate::translation::DEFAULT_LANG;
+use std::collections::HashMap;
 
 #[derive(Deserialize, Serialize, Debug)]
 pub struct GuildConfig {
@@ -13,6 +15,7 @@ pub struct GuildConfig {
     pub message_logs: MessageLogs,
     pub language: LanguageIdentifier,
     pub permission_groups: Vec<PermissionGroup>,
+    pub log_channels: HashMap<ChannelId, LogChannelConfig>,
 }
 
 #[derive(Deserialize, Serialize, Debug)]
@@ -40,15 +43,18 @@ pub enum LogStyle {
     Text,
     Embed,
 }
+#[derive(Deserialize, Serialize, Debug, Eq, PartialEq)]
+pub enum LogCategory {
+    TEST,
+}
 
 #[derive(Deserialize, Serialize, Debug)]
-pub struct LogChannelConfig {}
-
-#[derive(Deserialize, Serialize, Debug)]
-pub enum LogCategories {}
-
-#[derive(Deserialize, Serialize, Debug)]
-pub enum LogSubCategory {}
+pub struct LogChannelConfig {
+    pub categories: Vec<LogCategory>,
+    pub disabled_keys: Vec<DataLessLogType>,
+    pub style: LogStyle,
+    pub filters: Vec<LogFilter>,
+}
 
 impl Default for GuildConfig {
     fn default() -> Self {
@@ -100,6 +106,7 @@ impl Default for GuildConfig {
                     users: vec![],
                 },
             ],
+            log_channels: HashMap::new(),
         }
     }
 }

src/core/guild_config.rs

@@ -0,0 +1,10 @@
+use crate::core::logpump::log_type::LogType;
+use twilight_model::id::{ChannelId, GuildId, UserId};
+
+#[derive(Debug)]
+pub struct LogData {
+    pub log_type: LogType,
+    pub guild: GuildId,
+    pub source_channel: Option<ChannelId>,
+    pub source_user: Option<UserId>,
+}

src/core/logpump/log_data.rs

@@ -0,0 +1,36 @@
+use crate::core::{DataLessLogType, LogData, LogType};
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+use twilight_model::id::{ChannelId, UserId};
+
+#[derive(Deserialize, Serialize, Debug)]
+pub struct LogFilter {
+    log_types: Vec<DataLessLogType>,
+    source_channels: Vec<ChannelId>,
+    source_users: Vec<UserId>,
+}
+
+impl LogFilter {
+    pub fn matches(
+        &self,
+        log_type: &DataLessLogType,
+        source_channel: &Option<ChannelId>,
+        source_user: &Option<UserId>,
+    ) -> bool {
+        if self.log_types.contains(log_type) {
+            return true;
+        }
+        if let Some(channel) = source_channel {
+            if self.source_channels.contains(channel) {
+                return true;
+            }
+        }
+
+        if let Some(user) = source_user {
+            if self.source_users.contains(user) {
+                return true;
+            }
+        }
+        false
+    }
+}

src/core/logpump/log_filter.rs

@@ -0,0 +1,42 @@
+use crate::core::guild_config::LogCategory;
+use crate::utils::MessageError;
+use serde::{Deserialize, Serialize};
+use twilight_embed_builder::{EmbedBuildError, EmbedBuilder};
+use twilight_model::channel::embed::Embed;
+
+#[derive(Deserialize, Serialize, Debug, Eq, PartialEq)]
+pub enum LogType {
+    TEST(String),
+}
+
+#[derive(Deserialize, Serialize, Debug, Eq, PartialEq)]
+pub enum DataLessLogType {
+    TEST,
+}
+
+impl LogType {
+    pub fn get_category(&self) -> LogCategory {
+        match self {
+            LogType::TEST(_) => LogCategory::TEST,
+        }
+    }
+
+    pub fn to_embed(&self) -> Result<Embed, MessageError> {
+        Ok(match self {
+            LogType::TEST(data) => EmbedBuilder::new().description(data)?,
+        }
+        .build()?)
+    }
+
+    pub fn to_text(&self) -> &str {
+        match self {
+            LogType::TEST(data) => data,
+        }
+    }
+
+    pub fn dataless(&self) -> DataLessLogType {
+        match self {
+            Self::TEST(_) => DataLessLogType::TEST,
+        }
+    }
+}