Add k8s deploy example

code

.github/workflows/automerge.yml

@@ -0,0 +1,27 @@
+name: automerge
+on:
+  pull_request:
+    types:
+      - labeled
+      - unlabeled
+      - synchronize
+      - opened
+      - edited
+      - ready_for_review
+      - reopened
+      - unlocked
+  pull_request_review:
+    types:
+      - submitted
+  check_suite:
+    types:
+      - completed
+  status: {}
+jobs:
+  automerge:
+    runs-on: ubuntu-latest
+    steps:
+      - name: automerge
+        uses: "pascalgn/automerge-action@v0.13.0"
+        env:
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"

.gitignore

@@ -7,3 +7,4 @@ memory.sqlite3
 /voice
 /.idea
 Cargo.lock
+k8s/k8s-deploy.yaml

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "desubot"
-version = "0.5.0"
+version = "0.5.7"
 authors = ["AB <ab@hexor.ru>"]
 edition = "2018"
 
@@ -12,7 +12,8 @@ tokio = { version = "0.2", features = ["full"]}
 tracing = "0.1.9"
 tracing-futures = "0.2"
 multipart = { version = "0.16", default-features = false, features = ["client"] }
-telegram-bot = "0.8.0"
+#telegram-bot = "0.8.0"
+telegram-bot = { git = "https://github.com/ayrat555/telegram-bot", branch = "ayrat555/api-fixes-10" }
 silicon = "0.4.0"
 hyper = "0.13"
 hyper-tls = { version = "0.4", optional = true  }
@@ -30,7 +31,8 @@ subprocess = "0.2.6"
 serde_json = "1.0"
 markov = "1.1.0"
 rand = "0.7.3"
-mystem = "0.2.1"
+mystem = "^0.2"
+#mystem = { path = "../mystem-rs" }
 async-trait = "0.1.42"
 sqlparser = "0.7.0"
 

Dockerfile

@@ -0,0 +1,14 @@
+# syntax=docker/dockerfile:1
+
+FROM rust:latest AS builder
+WORKDIR /desubot
+ADD ./ /desubot/
+RUN cargo build --release
+
+FROM ubuntu:latest
+WORKDIR /storage
+COPY --from=builder /desubot/target/release/desubot /usr/bin/
+COPY mystem /usr/bin/
+RUN apt update && apt install -y fontconfig openssl ca-certificates && rm -rf /var/lib/apt/lists/*
+ENTRYPOINT desubot
+

README

@@ -7,8 +7,6 @@ Telegram bot with light group statistic and heavy spy features.
 * /here command to mention all members.
 * Alongside with saving whole message bot perform blacklist filter and stemming for every word (only Russian). "Красивую собаку мыли негры" -> "красивый собака мыть негр"
 * Generate sentences using Markov Chains trained on history with /markov_all.
-
-== TODO ==
 * Syntax highlighting for CODE exported to image.
 
 == Important ==

assets/help_text.rs

@@ -1,10 +1,10 @@
-static CODE: &str = "<b>Code highlighter</b>
+#[allow(dead_code)]
+static CODE_HELP: &str = "<b>Code highlighter</b>
 
 <i>Usage</i>
-<pre>/CODE
-#&lt;theme - Dracula by default&gt;
+<pre>/code
 &lt;CODE&gt;
-#&lt;lang - JS by default&gt;</pre>
+#&lt;lang - JS by default&gt; #&lt;theme - Dracula by default&gt;</pre>
 
 Language may be defined by both name and extension - Rust, rs...
 Max lines - 80
@@ -34,3 +34,10 @@ gruvbox-light
 gruvbox-white
 zenburn
 ";
+
+#[allow(dead_code)]
+pub static SQL_HELP: &str = "<b>Perform an SQL command</b>
+<i>* Only one sentence per message.
+* Only SELECT command.
+* Max result length is 100 lines. Use LIMIT 100.
+* SQLITE syntax is available only.</i>";

k8s/k8s-deploy-example.yaml

@@ -0,0 +1,43 @@
+---
+apiVersion: v1
+kind: Secret
+metadata:
+  name: desubot-api-token
+data:
+  token: 123.... # Base64 encoded token.
+---
+apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+  name: desubot
+spec:
+  serviceName: "desubot"
+  replicas: 1
+  selector:
+    matchLabels:
+      app: desubot
+  template:
+    metadata:
+      labels:
+        app: desubot
+    spec:
+      containers:
+      - name: desubot
+        image: ultradesu/desubot:latest
+        volumeMounts:
+        - name: storage
+          mountPath: /storage
+        env:
+        - name: TELEGRAM_BOT_TOKEN
+          valueFrom:
+            secretKeyRef:
+              name: desubot-api-token
+              key: token
+  volumeClaimTemplates:
+  - metadata:
+      name: storage
+    spec:
+      accessModes: [ "ReadWriteOnce" ]
+      resources:
+        requests:
+          storage: 50Gi

src/commands.rs

@@ -17,11 +17,13 @@ use sqlparser::ast::Statement;
 use sqlparser::dialect::GenericDialect;
 use sqlparser::parser::Parser;
 use syntect::easy::HighlightLines;
+use syntect::highlighting::Theme;
 use syntect::parsing::SyntaxReference;
 use syntect::util::LinesWithEndings;
 use telegram_bot::prelude::*;
-use telegram_bot::{Api, Message, ParseMode};
-use syntect::highlighting::Theme;
+use telegram_bot::{Api, Message, ParseMode, UserId};
+
+include!("../assets/help_text.rs");
 
 pub struct Here {
     pub data: String,
@@ -65,6 +67,10 @@ impl Execute for Sql {
 
     async fn exec_with_result(&self, api: &Api, message: &Message) -> Result<String, Error> {
         let mut sql = self.data.clone();
+        debug!("PIZDA - {}", sql);
+        if sql == "/sql" || sql == "/sql-" {
+            return Ok(SQL_HELP.to_string());
+        }
         let is_head = if sql.starts_with('-') {
             sql = sql.replacen("-", "", 1);
             false
@@ -137,7 +143,7 @@ impl Execute for Sql {
             }
             res.push(tmp);
         }
-        if res.len() > 100 {
+        if res.len() >= 100 {
             return Err(Error::SQLResultTooLong(
                 "SQL result too long. Lines limit is 100. Use LIMIT".to_string(),
             ));
@@ -186,7 +192,15 @@ impl Execute for Sql {
 #[async_trait]
 impl Execute for Here {
     async fn exec(&self, api: &Api, message: &Message) -> Result<(), Error> {
-        let members: Vec<telegram_bot::User> = db::get_members(message.chat.id()).unwrap();
+        let members: Vec<telegram_bot::User> =
+            db::get_members(message.chat.id(), 60).unwrap_or(vec![telegram_bot::User {
+                id: UserId::new(124317807),
+                first_name: "Ultradesu".to_string(),
+                last_name: None,
+                username: None,
+                is_bot: false,
+                language_code: None,
+            }]);
         for u in &members {
             debug!("Found user {:?} in chat {}", u, message.chat.id());
         }
@@ -551,11 +565,16 @@ impl Execute for Code {
         unimplemented!()
     }
     async fn exec_with_result(&self, api: &Api, message: &Message) -> Result<String, Error> {
-        let mut lines: Vec<String> = self.data.trim().split("\n").map(|s| s.to_string()).collect();
+        let mut lines: Vec<String> = self
+            .data
+            .trim()
+            .split("\n")
+            .map(|s| s.to_string())
+            .collect();
         if lines.len() >= 81 {
             return Err(CodeHighlightningError);
         }
-        let last_line = &lines[lines.len()-1];
+        let last_line = &lines[lines.len() - 1];
 
         let tags = last_line
             .trim()
@@ -593,7 +612,6 @@ impl Execute for Code {
             .map(|s| s.unwrap())
             .collect();
 
-
         let theme = if theme.len() != 1 {
             ts.themes.get("Dracula").unwrap()
         } else {
@@ -606,6 +624,7 @@ impl Execute for Code {
             .collect::<Vec<_>>();
         let formatter = silicon::formatter::ImageFormatterBuilder::<String>::new()
             .window_controls(false)
+            .line_offset(1)
             .round_corner(false);
         let mut formatter = formatter.build().unwrap();
         let image = formatter.format(&highlight, &theme);

src/db.rs

@@ -180,18 +180,29 @@ pub(crate) async fn get_messages_user_all(
     Ok(messages)
 }
 
-pub(crate) fn get_members(id: telegram_bot::ChatId) -> Result<Vec<telegram_bot::User>> {
+pub(crate) fn get_members(id: telegram_bot::ChatId, limit: u32) -> Result<Vec<telegram_bot::User>> {
+    let where_statement = if limit > 0 {
+        format!("and days_seen <= {}", limit)
+    } else {
+        "".into()
+    };
+    debug!("{}", where_statement);
     let conn = open()?;
-    let mut stmt = conn.prepare_cached(
+    let mut stmt = conn.prepare_cached(&format!(
         "
-        SELECT DISTINCT(u.username), u.id, u.first_name, u.last_name, u.date
+        SELECT DISTINCT(u.username), u.id, u.first_name, u.last_name, u.date,
+        (strftime('%s','now')-r.date)/60/60/24 as days_seen
         FROM relations r
         JOIN user u
         ON u.id = r.user_id
         LEFT JOIN conf c
         ON r.conf_id = c.id
-        WHERE c.id = :id",
-    )?;
+        WHERE c.id = :id
+        {}
+        GROUP BY u.id
+        ORDER BY r.date DESC",
+        where_statement
+    ))?;
     let mut rows = stmt.query_named(&[(":id", &id.to_string())])?;
     let mut users = Vec::new();
 
@@ -214,7 +225,7 @@ pub(crate) async fn add_conf(message: Message) -> Result<(), Error> {
 
     match get_conf(message.chat.id()) {
         Ok(_) => {
-            //info!("Group found: {:?}", message.chat.id());
+            debug!("Group found: {:?}", message.chat.id());
             let update = Conf {
                 id: message.chat.id(),
                 title,
@@ -228,10 +239,10 @@ pub(crate) async fn add_conf(message: Message) -> Result<(), Error> {
                 id = :id",
             )?;
             stmt.execute_named(&[(":id", &update.id.to_string()), (":title", &update.title)])?;
-            //info!("Conf {:?} updated: {:?}", update.title, get_conf(update.id));
+            debug!("Conf {:?} updated: {:?}", update.title, get_conf(update.id));
         }
         Err(_) => {
-            //info!("Group didn't found: {:?}", message.chat.id());
+            debug!("Group didn't found: {:?}", message.chat.id());
 
             let update = Conf {
                 id: message.chat.id(),
@@ -250,7 +261,7 @@ pub(crate) async fn add_conf(message: Message) -> Result<(), Error> {
                 (":title", &update.title),
                 (":date", &unix_time),
             ])?;
-            //info!("Conf {:?} added: {:?}", update.title, get_conf(update.id));
+            debug!("Conf {:?} added: {:?}", update.title, get_conf(update.id));
         }
     }
     Ok(())
@@ -283,7 +294,11 @@ pub(crate) async fn add_user(message: Message) -> Result<(), Error> {
                 (":first_name", &update.first_name),
                 (":last_name", &update.last_name),
             ])?;
-            //println!("User {} updated: {:?}", update.first_name, get_user(user.id));
+            debug!(
+                "User {} updated: {:?}",
+                update.first_name,
+                get_user(update.id)
+            );
         }
         Err(_) => {
             let unix_time = SystemTime::now()
@@ -310,7 +325,7 @@ pub(crate) async fn add_user(message: Message) -> Result<(), Error> {
                 (":last_name", &user.last_name),
                 (":date", &unix_time),
             ])?;
-            //println!("User added: {:?}", user);
+            debug!("User added: {:?}", user);
         }
     }
     Ok(())
@@ -417,6 +432,7 @@ pub(crate) async fn add_sentence(
         };
 
     // Save stemmed words
+    debug!("Going to stem: {}", text);
     let words = mystem.stemming(text)?;
     conn.execute("BEGIN TRANSACTION", params![]);
     for word in words {

src/handlers.rs

@@ -6,7 +6,6 @@ use crate::utils;
 use mystem::MyStem;
 use telegram_bot::*;
 
-
 include!("../assets/help_text.rs");
 
 pub async fn handler(
@@ -25,19 +24,18 @@ pub async fn handler(
                 title,
                 &message.from.id,
                 &message.from.first_name,
-                {if data.len() <= 200 {data} else {&data[..200]}}.replace("\n", " ")
+                data.replace("\n", " ")
             );
 
             let cleaned_message = data.replace(&format!("@{}", me.clone().username.unwrap()), "");
             match cleaned_message.as_str() {
                 s if s.to_string().starts_with("/code") => {
-
                     match {
                         Code {
                             data: s.replace("/code", ""),
                         }
-                            .exec_with_result(&api, &message)
-                            .await
+                        .exec_with_result(&api, &message)
+                        .await
                     } {
                         Ok(path) => {
                             let file = InputFileUpload::with_path(path.clone());
@@ -50,12 +48,17 @@ pub async fn handler(
                         }
                         Err(_) => {
                             let _ = api
-                                .send(message.text_reply(CODE).parse_mode(ParseMode::Html))
+                                .send(message.text_reply(CODE_HELP).parse_mode(ParseMode::Html))
                                 .await?;
                         }
                     }
                 }
-                s if s.contains("/here") => {
+                s if s.contains("/here")
+                    || s.contains("@here")
+                    || s.contains("/хере")
+                    || s.contains("@хере")
+                    || s.contains("\"хере") =>
+                {
                     db::add_sentence(&message, mystem).await?;
                     Here {
                         data: "".to_string(),

src/main.rs

@@ -1,4 +1,6 @@
+#![allow(unreachable_code)]
 use std::{env, process};
+use tokio::time::{delay_for, Duration};
 
 use futures::StreamExt;
 use telegram_bot::*;
@@ -16,7 +18,7 @@ use mystem::MyStem;
 
 #[tokio::main]
 async fn main() -> Result<(), errors::Error> {
-    env_logger::from_env(Env::default().default_filter_or("info")).init();
+    env_logger::Builder::from_env(Env::default().default_filter_or("info")).init();
     let mut mystem = match MyStem::new() {
         Ok(mystem) => mystem,
         Err(e) => {
@@ -44,18 +46,33 @@ async fn main() -> Result<(), errors::Error> {
         me.first_name,
         me.id
     );
-    while let Some(update) = stream.next().await {
-        let update = update?;
-        if let UpdateKind::Message(message) = update.kind {
-            db::add_conf(message.clone()).await?;
-            db::add_user(message.clone()).await?;
-            match handlers::handler(api.clone(), message, token.clone(), &mut mystem, me.clone())
-                .await
-            {
-                Ok(_) => {}
-                Err(e) => warn!("An error occurred handling command. {:?}", e),
-            }
+    loop {
+        while let Some(update) = stream.next().await {
+            match update {
+                Ok(u) => {
+                    if let UpdateKind::Message(message) = u.kind {
+                        db::add_conf(message.clone()).await?;
+                        db::add_user(message.clone()).await?;
+                        match handlers::handler(
+                            api.clone(),
+                            message,
+                            token.clone(),
+                            &mut mystem,
+                            me.clone(),
+                        )
+                        .await
+                        {
+                            Ok(_) => {}
+                            Err(e) => warn!("An error occurred handling command. {:?}", e),
+                        }
+                    }
+                }
+                Err(e) => {
+                    warn!("Telegram API Error: {:?}", e);
+                }
+            };
         }
+        delay_for(Duration::from_secs(2)).await;
     }
     Ok(())
 }