Compare commits
25 Commits
Author | SHA1 | Date |
---|---|---|
LordMZTE | cda1743f0f | |
LordMZTE | c270953ab2 | |
LordMZTE | 653592649d | |
LordMZTE | 8e963c1852 | |
LordMZTE | ae0bd48c38 | |
LordMZTE | e72b92a678 | |
LordMZTE | c387ad566a | |
LordMZTE | 54ce90d090 | |
Timo Ley | 70159a085d | |
Timo Ley | 3c6ecd6649 | |
Timo Ley | df15a1c3d5 | |
LordMZTE | 28f610a1d2 | |
LordMZTE | 9c1f1c44ac | |
LordMZTE | aea4b48c2b | |
LordMZTE | 5b115d4bbc | |
LordMZTE | 05e00f412b | |
LordMZTE | 298c0a7f6f | |
LordMZTE | 5007f5ddba | |
LordMZTE | 485d44c56f | |
LordMZTE | ccf8c65c80 | |
LordMZTE | 568607fe3e | |
LordMZTE | 58569bae3f | |
LordMZTE | 0e4664ceeb | |
LordMZTE | 0a3950af4f | |
LordMZTE | 8106dc3966 |
73
.drone.yml
73
.drone.yml
|
@ -1,45 +1,46 @@
|
|||
kind: pipeline
|
||||
type: docker
|
||||
name: tests
|
||||
steps:
|
||||
- name: test-linux
|
||||
image: rust
|
||||
commands:
|
||||
- apt update
|
||||
- apt install -y cmake
|
||||
- cargo test -v
|
||||
- name: test-linux
|
||||
image: rust
|
||||
commands:
|
||||
- apt update
|
||||
- apt install -y cmake
|
||||
- cargo test -v
|
||||
|
||||
- name: clippy-linux
|
||||
image: rust
|
||||
commands:
|
||||
- apt update
|
||||
- apt install -y cmake
|
||||
- rustup component add clippy
|
||||
- cargo clippy
|
||||
|
||||
- name: clippy-linux
|
||||
image: rust
|
||||
commands:
|
||||
- apt update
|
||||
- apt install -y cmake
|
||||
- rustup component add clippy
|
||||
- cargo clippy
|
||||
|
||||
---
|
||||
kind: pipeline
|
||||
type: docker
|
||||
name: release
|
||||
steps:
|
||||
- name: release-linux
|
||||
image: rust
|
||||
commands:
|
||||
- apt update
|
||||
- apt install -y cmake
|
||||
- cargo build --release -v
|
||||
- strip target/release/ruff
|
||||
|
||||
- name: publish
|
||||
image: plugins/gitea-release
|
||||
settings:
|
||||
base_url: https://tilera.xyz/git
|
||||
api_key:
|
||||
from_secret: gitea_token
|
||||
note: CHANGELOG.md
|
||||
title: tag-${DRONE_TAG}
|
||||
files:
|
||||
- target/release/ruff
|
||||
when:
|
||||
event: tag
|
||||
depends_on:
|
||||
- release-linux
|
||||
- name: release-linux
|
||||
image: rust
|
||||
commands:
|
||||
- apt update
|
||||
- apt install -y cmake
|
||||
- cargo build --release -v
|
||||
- strip target/release/ruff
|
||||
|
||||
- name: publish
|
||||
image: plugins/gitea-release
|
||||
settings:
|
||||
base_url: https://tilera.xyz/git
|
||||
api_key:
|
||||
from_secret: gitea_token
|
||||
note: CHANGELOG.md
|
||||
title: tag-${DRONE_TAG}
|
||||
files:
|
||||
- target/release/ruff
|
||||
when:
|
||||
event: [tag]
|
||||
depends_on:
|
||||
- release-linux
|
||||
|
|
|
@ -1,4 +1,2 @@
|
|||
# 0.2.2
|
||||
- DATABASE FORMAT CHANGE
|
||||
- meme cache is now updated after reponse has been sent to reduce latency
|
||||
- MIME type and file size is now sent with memes
|
||||
# 0.2.8
|
||||
- fix uffch id
|
||||
|
|
29
Cargo.toml
29
Cargo.toml
|
@ -1,33 +1,32 @@
|
|||
[package]
|
||||
name = "ruff"
|
||||
version = "0.2.2"
|
||||
version = "0.2.8"
|
||||
authors = ["LordMZTE <lord@mzte.de>"]
|
||||
edition = "2018"
|
||||
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[dependencies]
|
||||
anyhow = "1.0"
|
||||
anyhow = "1.0.53"
|
||||
bincode = "1.3.3"
|
||||
clap = "2.33.3"
|
||||
env_logger = "0.8.4"
|
||||
log = "0.4.13"
|
||||
clap = "3.0.10"
|
||||
env_logger = "0.9.0"
|
||||
log = "0.4.14"
|
||||
mime = "0.3.16"
|
||||
mime_guess = "2.0.3"
|
||||
rand = "0.8.4"
|
||||
serde_json = "1.0.61"
|
||||
sled = "0.34.6"
|
||||
structopt = "0.3.21"
|
||||
serde_json = "1.0.78"
|
||||
sled = "0.34.7"
|
||||
structopt = "0.3.26"
|
||||
toml = "0.5.8"
|
||||
|
||||
[dependencies.jm_client_core]
|
||||
#path = "/home/lordmzte/dev/jensmemesclient/jensmemesclient/jm_client_core"
|
||||
git = "https://tilera.xyz/git/lordmzte/jensmemesclient.git"
|
||||
package = "jm_client_core"
|
||||
rev = "0d3a77"
|
||||
[dependencies.libjens]
|
||||
git = "https://tilera.xyz/git/lordmzte/libjens.git"
|
||||
rev = "1.1.0"
|
||||
|
||||
[dependencies.matrix-sdk]
|
||||
git = "https://github.com/matrix-org/matrix-rust-sdk.git"
|
||||
rev = "c79e62d"
|
||||
features = ["encryption"]
|
||||
|
||||
[dependencies.url]
|
||||
|
@ -35,9 +34,9 @@ version = "2.2.2"
|
|||
features = ["serde"]
|
||||
|
||||
[dependencies.serde]
|
||||
version = "1.0"
|
||||
version = "1.0.135"
|
||||
features = ["derive"]
|
||||
|
||||
[dependencies.tokio]
|
||||
version = "1.7.0"
|
||||
version = "1.15.0"
|
||||
features = ["macros"]
|
||||
|
|
24
Dockerfile
24
Dockerfile
|
@ -1,24 +0,0 @@
|
|||
# this uses buster as alpine would always segfault
|
||||
FROM rust:buster as builder
|
||||
LABEL maintainer="LordMZTE <https://github.com/lordmzte>"
|
||||
|
||||
RUN apt install \
|
||||
gcc \
|
||||
libssl-dev
|
||||
|
||||
WORKDIR /usr/src/ruff
|
||||
COPY Cargo.toml ./
|
||||
COPY src/ src/
|
||||
|
||||
RUN cargo build --release
|
||||
|
||||
FROM debian:buster
|
||||
COPY --from=builder /usr/src/ruff/target/release/ruff /usr/bin
|
||||
|
||||
RUN apt update
|
||||
RUN apt install \
|
||||
libssl1.1
|
||||
|
||||
VOLUME /ruffconfig
|
||||
CMD /usr/bin/ruff -c /ruffconfig/config.toml
|
||||
|
|
@ -3,36 +3,46 @@ homeserver_url = "https://matrix.org"
|
|||
user_id = "@ruffbot:matrix.org"
|
||||
password = "xxx"
|
||||
# path to store databases
|
||||
store_path = "store"
|
||||
store_path = "/var/cache/ruff"
|
||||
|
||||
# !sendmeme <id> to make ruff send the meme with the given id
|
||||
sendmeme_command = "!sendmeme"
|
||||
|
||||
# MEMES!!
|
||||
memes = [
|
||||
# random stuff
|
||||
{ keyword = "Xd", id = 1023, match = "contains", match_case = true },
|
||||
{ keyword = "alec", id = 650 },
|
||||
{ keyword = "bastard", id = 375 },
|
||||
{ keyword = "drogen", id = 191 },
|
||||
{ keyword = "fresse", id = 375 },
|
||||
{ keyword = "hendrik", randomcat = "hendrik" },
|
||||
{ keyword = "hey", id = 243 },
|
||||
{ keyword = "hmm", id = 892 },
|
||||
{ keyword = "hmmm", id = 891 },
|
||||
{ keyword = "itbyhf", randomcat = "itbyhf" },
|
||||
{ keyword = "jens", id = 343 },
|
||||
{ keyword = "jonasled", id = 164 },
|
||||
{ keyword = "kappa", id = 182 },
|
||||
{ keyword = "lordmzte", id = 315 },
|
||||
{ keyword = "npm", id = 1080, match = "contains" },
|
||||
{ keyword = "party", id = 619 },
|
||||
{ keyword = "realtox", id = 168 },
|
||||
{ keyword = "sklave", id = 304 },
|
||||
{ keyword = "tilera", id = 316 },
|
||||
{ keyword = "wtf", randomcat = "random", match = "contains" },
|
||||
{ keyword = "wtuff", randomcat = "random", match = "contains" },
|
||||
{ keyword = "xd", id = 1023, match = "contains", match_case = true },
|
||||
|
||||
# üffen
|
||||
{ keyword = "uff", randomcat = "uff" },
|
||||
{ keyword = "biguff", id = 771 },
|
||||
{ keyword = "hmm", id = 892 },
|
||||
{ keyword = "hmmm", id = 891 },
|
||||
{ keyword = "longuff", id = 771 },
|
||||
{ keyword = "uff2d", id = 1063 },
|
||||
{ keyword = "uffag", id = 1061 },
|
||||
{ keyword = "uffal", id = 654 },
|
||||
{ keyword = "uffat", id = 257 },
|
||||
{ keyword = "uffch", id = 286 },
|
||||
{ keyword = "uffch", id = 283 },
|
||||
{ keyword = "uffde", id = 144 },
|
||||
{ keyword = "uffgo", id = 568 },
|
||||
{ keyword = "uffhf", id = 645 },
|
||||
|
|
|
@ -0,0 +1,9 @@
|
|||
[Unit]
|
||||
Description=Next gen uff bot
|
||||
|
||||
[Service]
|
||||
ExecStart=/usr/bin/ruff -c /etc/ruff/config.toml
|
||||
Environment=RUST_LOG=information
|
||||
|
||||
[Install]
|
||||
WantedBy=default.target
|
|
@ -1,4 +1,4 @@
|
|||
use crate::meme::{Meme, MemeIdent};
|
||||
use crate::meme::{Matcher, Meme, MemeIdent};
|
||||
use serde::{
|
||||
de::{self, Deserializer, MapAccess, Visitor},
|
||||
Deserialize,
|
||||
|
@ -12,6 +12,7 @@ pub struct Config {
|
|||
pub user_id: String,
|
||||
pub password: String,
|
||||
pub device_name: Option<String>,
|
||||
pub sendmeme_command: Option<String>,
|
||||
pub memes: Vec<Meme>,
|
||||
pub store_path: PathBuf,
|
||||
#[serde(default = "default_clear_threshold")]
|
||||
|
@ -31,6 +32,8 @@ impl<'de> Deserialize<'de> for Meme {
|
|||
enum Field {
|
||||
Keyword,
|
||||
Ident(IdentField),
|
||||
Matcher,
|
||||
MatchCase,
|
||||
}
|
||||
|
||||
enum IdentField {
|
||||
|
@ -62,6 +65,8 @@ impl<'de> Deserialize<'de> for Meme {
|
|||
"keyword" => Field::Keyword,
|
||||
"randomcat" => Field::Ident(IdentField::RandomCat),
|
||||
"id" => Field::Ident(IdentField::Id),
|
||||
"match" => Field::Matcher,
|
||||
"match_case" => Field::MatchCase,
|
||||
_ => return Err(de::Error::unknown_field(v, FIELDS)),
|
||||
})
|
||||
}
|
||||
|
@ -85,6 +90,9 @@ impl<'de> Deserialize<'de> for Meme {
|
|||
{
|
||||
let mut keyword = None;
|
||||
let mut ident = None;
|
||||
let mut matcher = None;
|
||||
let mut match_case = None;
|
||||
|
||||
while let Some(key) = map.next_key()? {
|
||||
match key {
|
||||
Field::Keyword => {
|
||||
|
@ -111,11 +119,36 @@ impl<'de> Deserialize<'de> for Meme {
|
|||
},
|
||||
}
|
||||
},
|
||||
|
||||
Field::Matcher => {
|
||||
if matcher.is_some() {
|
||||
return Err(de::Error::duplicate_field("match"));
|
||||
}
|
||||
|
||||
matcher = Some(map.next_value()?);
|
||||
},
|
||||
|
||||
Field::MatchCase => {
|
||||
if match_case.is_some() {
|
||||
return Err(de::Error::duplicate_field("match"));
|
||||
}
|
||||
|
||||
match_case = Some(map.next_value()?);
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
let keyword = keyword.ok_or_else(|| de::Error::missing_field("keyword"))?;
|
||||
let ident = ident.ok_or_else(|| de::Error::missing_field("ident"))?;
|
||||
Ok(Meme { keyword, ident })
|
||||
let matcher = matcher.unwrap_or(Matcher::Begins);
|
||||
let match_case = match_case.unwrap_or(false);
|
||||
|
||||
Ok(Meme {
|
||||
keyword,
|
||||
ident,
|
||||
matcher,
|
||||
match_case,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
|
|
230
src/main.rs
230
src/main.rs
|
@ -1,28 +1,38 @@
|
|||
use anyhow::{anyhow, bail, Context};
|
||||
use jm_client_core::JMClient;
|
||||
use libjens::JMClient;
|
||||
use log::{error, info, warn};
|
||||
use matrix_sdk::{
|
||||
api::r0::session::login,
|
||||
async_trait,
|
||||
config::SyncSettings,
|
||||
deserialized_responses::SyncResponse,
|
||||
events::{
|
||||
room::{
|
||||
member::MemberEventContent,
|
||||
message::{MessageEventContent, MessageType, TextMessageEventContent},
|
||||
},
|
||||
AnyToDeviceEvent,
|
||||
StrippedStateEvent,
|
||||
SyncMessageEvent,
|
||||
},
|
||||
encryption::verification::Verification,
|
||||
room::Room,
|
||||
verification::Verification,
|
||||
EventHandler,
|
||||
ruma::{
|
||||
api::client::r0::{
|
||||
session::login,
|
||||
uiaa::{AuthData, Password, UserIdentifier},
|
||||
},
|
||||
assign,
|
||||
events::{
|
||||
room::{
|
||||
member::StrippedRoomMemberEvent,
|
||||
message::{
|
||||
MessageType,
|
||||
RoomMessageEventContent,
|
||||
SyncRoomMessageEvent,
|
||||
TextMessageEventContent,
|
||||
},
|
||||
},
|
||||
AnyToDeviceEvent,
|
||||
SyncMessageEvent,
|
||||
},
|
||||
UserId,
|
||||
},
|
||||
Client,
|
||||
LoopCtrl,
|
||||
};
|
||||
use rand::{rngs::StdRng, SeedableRng};
|
||||
use sled::Db;
|
||||
use std::{
|
||||
collections::BTreeMap,
|
||||
path::PathBuf,
|
||||
sync::{
|
||||
atomic::{AtomicBool, AtomicU32},
|
||||
|
@ -35,8 +45,6 @@ use tokio::sync::{Mutex, RwLock};
|
|||
|
||||
use config::Config;
|
||||
|
||||
use matrix_sdk::{self, api::r0::uiaa::AuthData, identifiers::UserId, Client, SyncSettings};
|
||||
use serde_json::json;
|
||||
mod config;
|
||||
mod meme;
|
||||
mod responder;
|
||||
|
@ -63,37 +71,41 @@ async fn main() -> anyhow::Result<()> {
|
|||
toml::from_slice::<Config>(&config).map_err(|e| anyhow!("Error parsing config: {}", e))?;
|
||||
let config = Arc::new(config);
|
||||
|
||||
let client = Arc::new(RwLock::new(Client::new(config.homeserver_url.clone())?));
|
||||
let client = Client::new(config.homeserver_url.clone())?;
|
||||
|
||||
let device_name = config.device_name.as_ref().map(String::as_ref);
|
||||
let login::Response { user_id, .. } = client
|
||||
.read()
|
||||
.await
|
||||
.login(&config.user_id, &config.password, device_name, device_name)
|
||||
.await?;
|
||||
|
||||
let bot = Arc::new(Bot {
|
||||
client: client.clone(),
|
||||
jm_client: RwLock::new(JMClient::new()),
|
||||
memecache: sled::open(config.store_path.join("memecache"))
|
||||
.map_err(|e| anyhow!("error opening memecache: {}", e))?,
|
||||
config: Arc::clone(&config),
|
||||
meme_count: AtomicU32::new(0),
|
||||
rng: Mutex::new(StdRng::from_rng(rand::thread_rng())?),
|
||||
});
|
||||
|
||||
client
|
||||
.write()
|
||||
.await
|
||||
.set_event_handler(Box::new(Bot {
|
||||
client: Arc::clone(&client),
|
||||
jm_client: RwLock::new(JMClient::new()),
|
||||
memecache: sled::open(config.store_path.join("memecache"))
|
||||
.map_err(|e| anyhow!("error opening memecache: {}", e))?,
|
||||
config: Arc::clone(&config),
|
||||
meme_count: AtomicU32::new(0),
|
||||
rng: Mutex::new(StdRng::from_rng(rand::thread_rng())?),
|
||||
}))
|
||||
.register_event_handler(on_stripped_state_member)
|
||||
.await;
|
||||
let bot_ = Arc::clone(&bot);
|
||||
client
|
||||
.register_event_handler(move |ev, client, room| {
|
||||
on_room_message(ev, client, room, Arc::clone(&bot_))
|
||||
})
|
||||
.await;
|
||||
|
||||
let login::Response { user_id, .. } = client
|
||||
.login(&config.user_id, &config.password, device_name, Some("ruff"))
|
||||
.await?;
|
||||
|
||||
let initial = AtomicBool::from(true);
|
||||
let initial_ref = &initial;
|
||||
let client_ref = &client.read().await;
|
||||
let client_ref = &client;
|
||||
let config_ref = &config;
|
||||
let user_id_ref = &user_id;
|
||||
|
||||
client
|
||||
.read()
|
||||
.await
|
||||
.sync_with_callback(SyncSettings::new(), |response| async move {
|
||||
if let Err(e) = on_response(&response, client_ref).await {
|
||||
error!("Error processing response: {}", e);
|
||||
|
@ -103,7 +115,7 @@ async fn main() -> anyhow::Result<()> {
|
|||
|
||||
if initial.load(std::sync::atomic::Ordering::SeqCst) {
|
||||
if let Err(e) =
|
||||
on_initial_response(client_ref, &user_id_ref, &config_ref.password).await
|
||||
on_initial_response(client_ref, user_id_ref, &config_ref.password).await
|
||||
{
|
||||
error!("Error processing initial response: {}", e);
|
||||
}
|
||||
|
@ -119,7 +131,7 @@ async fn main() -> anyhow::Result<()> {
|
|||
}
|
||||
|
||||
pub struct Bot {
|
||||
client: Arc<RwLock<Client>>,
|
||||
client: Client,
|
||||
jm_client: RwLock<JMClient>,
|
||||
memecache: Db,
|
||||
config: Arc<Config>,
|
||||
|
@ -130,77 +142,60 @@ pub struct Bot {
|
|||
rng: Mutex<StdRng>,
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl EventHandler for Bot {
|
||||
async fn on_stripped_state_member(
|
||||
&self,
|
||||
room: Room,
|
||||
room_member: &StrippedStateEvent<MemberEventContent>,
|
||||
_: Option<MemberEventContent>,
|
||||
) {
|
||||
if room_member.state_key == self.client.read().await.user_id().await.unwrap() {
|
||||
return;
|
||||
}
|
||||
|
||||
if let Room::Invited(room) = room {
|
||||
info!("Autojoining room {}", room.room_id());
|
||||
let mut delay = 2;
|
||||
|
||||
while let Err(err) = self
|
||||
.client
|
||||
.read()
|
||||
.await
|
||||
.join_room_by_id(&room.room_id())
|
||||
.await
|
||||
{
|
||||
// retry autojoin due to synapse sending invites, before the
|
||||
// invited user can join for more information see
|
||||
// https://github.com/matrix-org/synapse/issues/4345
|
||||
warn!(
|
||||
"Failed to join room {} ({:?}), retrying in {}s",
|
||||
room.room_id(),
|
||||
err,
|
||||
delay
|
||||
);
|
||||
|
||||
tokio::time::sleep(Duration::from_secs(delay)).await;
|
||||
delay *= 2;
|
||||
|
||||
if delay > 3600 {
|
||||
error!("Can't join room {} ({:?})", room.room_id(), err);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
info!("Successfully joined room {}", room.room_id());
|
||||
}
|
||||
async fn on_stripped_state_member(event: StrippedRoomMemberEvent, client: Client, room: Room) {
|
||||
if event.state_key == client.user_id().await.unwrap() {
|
||||
return;
|
||||
}
|
||||
|
||||
async fn on_room_message(&self, room: Room, msg: &SyncMessageEvent<MessageEventContent>) {
|
||||
if self
|
||||
.client
|
||||
.read()
|
||||
.await
|
||||
.user_id()
|
||||
.await
|
||||
.map(|u| u == msg.sender)
|
||||
.unwrap_or(true)
|
||||
{
|
||||
return;
|
||||
if let Room::Invited(room) = room {
|
||||
info!("Autojoining room {}", room.room_id());
|
||||
let mut delay = 2;
|
||||
|
||||
while let Err(err) = client.join_room_by_id(room.room_id()).await {
|
||||
// retry autojoin due to synapse sending invites, before the
|
||||
// invited user can join for more information see
|
||||
// https://github.com/matrix-org/synapse/issues/4345
|
||||
warn!(
|
||||
"Failed to join room {} ({:?}), retrying in {}s",
|
||||
room.room_id(),
|
||||
err,
|
||||
delay
|
||||
);
|
||||
|
||||
tokio::time::sleep(Duration::from_secs(delay)).await;
|
||||
delay *= 2;
|
||||
|
||||
if delay > 3600 {
|
||||
error!("Can't join room {} ({:?})", room.room_id(), err);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if let SyncMessageEvent {
|
||||
content:
|
||||
MessageEventContent {
|
||||
msgtype: MessageType::Text(TextMessageEventContent { body: msg_body, .. }),
|
||||
..
|
||||
},
|
||||
..
|
||||
} = msg
|
||||
{
|
||||
if let Err(e) = responder::on_msg(msg_body, room, self).await {
|
||||
error!("Responder error: {}", e);
|
||||
}
|
||||
info!("Successfully joined room {}", room.room_id());
|
||||
}
|
||||
}
|
||||
|
||||
async fn on_room_message(msg: SyncRoomMessageEvent, client: Client, room: Room, bot: Arc<Bot>) {
|
||||
if client
|
||||
.user_id()
|
||||
.await
|
||||
.map(|u| u == msg.sender)
|
||||
.unwrap_or(true)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if let SyncMessageEvent {
|
||||
content:
|
||||
RoomMessageEventContent {
|
||||
msgtype: MessageType::Text(TextMessageEventContent { body: msg_body, .. }),
|
||||
..
|
||||
},
|
||||
..
|
||||
} = msg
|
||||
{
|
||||
if let Err(e) = responder::on_msg(&msg_body, room, &bot).await {
|
||||
error!("Responder error: {}", e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -253,23 +248,6 @@ async fn on_response(response: &SyncResponse, client: &Client) -> anyhow::Result
|
|||
Ok(())
|
||||
}
|
||||
|
||||
fn auth_data<'a>(user: &UserId, password: &str, session: Option<&'a str>) -> AuthData<'a> {
|
||||
let mut auth_parameters = BTreeMap::new();
|
||||
let identifier = json!({
|
||||
"type": "m.id.user",
|
||||
"user": user,
|
||||
});
|
||||
|
||||
auth_parameters.insert("identifier".to_owned(), identifier);
|
||||
auth_parameters.insert("password".to_owned(), password.to_owned().into());
|
||||
|
||||
AuthData::DirectRequest {
|
||||
kind: "m.login.password",
|
||||
auth_parameters,
|
||||
session,
|
||||
}
|
||||
}
|
||||
|
||||
async fn bootstrap_cross_signing(
|
||||
client: &Client,
|
||||
user_id: &UserId,
|
||||
|
@ -278,7 +256,11 @@ async fn bootstrap_cross_signing(
|
|||
info!("bootstrapping e2e");
|
||||
if let Err(e) = client.bootstrap_cross_signing(None).await {
|
||||
if let Some(response) = e.uiaa_response() {
|
||||
let auth_data = auth_data(&user_id, &password, response.session.as_deref());
|
||||
let auth_data = AuthData::Password(assign!(
|
||||
Password::new(UserIdentifier::MatrixId(user_id.as_str()), password),
|
||||
{ session: response.session.as_deref() }
|
||||
));
|
||||
|
||||
client
|
||||
.bootstrap_cross_signing(Some(auth_data))
|
||||
.await
|
||||
|
|
142
src/meme.rs
142
src/meme.rs
|
@ -1,33 +1,86 @@
|
|||
use crate::Bot;
|
||||
use log::error;
|
||||
use rand::seq::IteratorRandom;
|
||||
use serde::Deserialize;
|
||||
|
||||
pub const ALLOWED_SPACES: &str = " ,.;:!?({-_";
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct Meme {
|
||||
pub keyword: String,
|
||||
pub ident: MemeIdent,
|
||||
pub matcher: Matcher,
|
||||
pub match_case: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
#[serde(rename_all = "lowercase")]
|
||||
pub enum Matcher {
|
||||
Begins,
|
||||
Contains,
|
||||
}
|
||||
|
||||
impl Meme {
|
||||
/// checks if the meme should be triggered for the given message
|
||||
pub fn matches(&self, msg: &str) -> bool {
|
||||
let msg = msg.to_ascii_lowercase();
|
||||
msg.starts_with(&self.keyword) &&
|
||||
// msg must have one of allowed chars after keyword
|
||||
msg.chars().nth(self.keyword.len()).map(|c|" ,.;:!?({-_".contains(c)).unwrap_or(true)
|
||||
let mut msg = msg.to_string();
|
||||
let mut keyword = self.keyword.clone();
|
||||
|
||||
if !self.match_case {
|
||||
msg = msg.to_ascii_lowercase();
|
||||
keyword = keyword.to_ascii_lowercase();
|
||||
}
|
||||
|
||||
match self.matcher {
|
||||
Matcher::Begins => {
|
||||
msg.starts_with(&keyword) &&
|
||||
// msg must have one of allowed chars after keyword
|
||||
msg.chars().nth(keyword.len()).map(|c| ALLOWED_SPACES.contains(c)).unwrap_or(true)
|
||||
},
|
||||
|
||||
Matcher::Contains => msg
|
||||
.match_indices(&keyword)
|
||||
.map(|(idx, subs)| {
|
||||
(idx == 0 ||
|
||||
msg.chars()
|
||||
.nth(idx - 1)
|
||||
.map(|c| ALLOWED_SPACES.contains(c))
|
||||
.unwrap_or(true)) &&
|
||||
msg.chars()
|
||||
.nth(idx + subs.len())
|
||||
.map(|c| ALLOWED_SPACES.contains(c))
|
||||
.unwrap_or(true)
|
||||
})
|
||||
.any(|b| b),
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn get_meme(&self, bot: &Bot) -> anyhow::Result<Option<jm_client_core::api::Meme>> {
|
||||
pub async fn get_id(&self, bot: &Bot) -> anyhow::Result<Option<u32>> {
|
||||
let memes = bot.jm_client.read().await.get_memes().await?;
|
||||
match &self.ident {
|
||||
MemeIdent::Id(i) => Ok(memes
|
||||
.iter()
|
||||
.find(|m| m.id.parse::<u32>().ok() == Some(*i))
|
||||
.cloned()),
|
||||
MemeIdent::RandomCat(c) => Ok(memes
|
||||
.iter()
|
||||
.filter(|m| &m.category == c)
|
||||
.choose(&mut *bot.rng.lock().await)
|
||||
.cloned()),
|
||||
MemeIdent::Id(i) => Ok(Some(*i)),
|
||||
MemeIdent::RandomCat(c) => {
|
||||
let meme = memes
|
||||
.iter()
|
||||
.filter(|m| &m.category == c)
|
||||
.choose(&mut *bot.rng.lock().await);
|
||||
|
||||
if let Some(meme) = meme {
|
||||
let id = meme.id.parse::<u32>();
|
||||
match id {
|
||||
Err(e) => {
|
||||
error!(
|
||||
"Error parsing meme ID {} for meme {:?} thanks to tilera's PHP api",
|
||||
&meme.id, &meme
|
||||
);
|
||||
Err(e.into())
|
||||
},
|
||||
Ok(id) => Ok(Some(id)),
|
||||
}
|
||||
} else {
|
||||
Ok(None)
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -37,3 +90,64 @@ pub enum MemeIdent {
|
|||
RandomCat(String),
|
||||
Id(u32),
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn matches_begins_test() {
|
||||
let meme = Meme {
|
||||
keyword: String::from("test"),
|
||||
ident: MemeIdent::Id(42),
|
||||
matcher: Matcher::Begins,
|
||||
match_case: false,
|
||||
};
|
||||
|
||||
assert!(!meme.matches("xxx"));
|
||||
assert!(!meme.matches("testxxx"));
|
||||
assert!(!meme.matches("xxxtestxxx"));
|
||||
assert!(!meme.matches("xxxtest xxx"));
|
||||
assert!(!meme.matches("xxx testxxx"));
|
||||
assert!(meme.matches("test"));
|
||||
assert!(meme.matches("test xxx"));
|
||||
assert!(meme.matches("test; xxx"));
|
||||
assert!(meme.matches("test;xxx"));
|
||||
assert!(meme.matches("TEST"));
|
||||
assert!(meme.matches("TeSt"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn matches_contains_test() {
|
||||
let meme = Meme {
|
||||
keyword: String::from("test"),
|
||||
ident: MemeIdent::Id(42),
|
||||
matcher: Matcher::Contains,
|
||||
match_case: false,
|
||||
};
|
||||
|
||||
assert!(!meme.matches("xxx"));
|
||||
assert!(!meme.matches("xxxtestxxx"));
|
||||
assert!(!meme.matches("xxxtest xxx"));
|
||||
assert!(!meme.matches("xxx testxxx"));
|
||||
assert!(!meme.matches("xxxtest"));
|
||||
assert!(!meme.matches("testxxx"));
|
||||
assert!(meme.matches("xxx test xxx"));
|
||||
assert!(meme.matches("xxx,test.xxx"));
|
||||
assert!(meme.matches("xxx,TEST.xxx"));
|
||||
assert!(meme.matches("xxx,TeSt.xxx"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn matches_case_test() {
|
||||
let meme = Meme {
|
||||
keyword: String::from("TeSt"),
|
||||
ident: MemeIdent::Id(42),
|
||||
matcher: Matcher::Contains,
|
||||
match_case: true,
|
||||
};
|
||||
|
||||
assert!(!meme.matches("test"));
|
||||
assert!(meme.matches("TeSt"));
|
||||
}
|
||||
}
|
||||
|
|
230
src/responder.rs
230
src/responder.rs
|
@ -2,23 +2,24 @@ use crate::{util, Bot};
|
|||
use anyhow::Context;
|
||||
use log::{error, info, warn};
|
||||
use matrix_sdk::{
|
||||
api::r0::media::create_content,
|
||||
events::{
|
||||
room::{
|
||||
room::{Joined, Room},
|
||||
ruma::{
|
||||
api::client::r0::media::create_content,
|
||||
events::room::{
|
||||
message::{
|
||||
FileInfo,
|
||||
FileMessageEventContent,
|
||||
ImageMessageEventContent,
|
||||
MessageEventContent,
|
||||
MessageType,
|
||||
RoomMessageEventContent,
|
||||
VideoInfo,
|
||||
VideoMessageEventContent,
|
||||
},
|
||||
ImageInfo,
|
||||
},
|
||||
AnyMessageEventContent,
|
||||
MxcUri,
|
||||
UInt,
|
||||
},
|
||||
identifiers::MxcUri,
|
||||
room::{Joined, Room},
|
||||
UInt,
|
||||
};
|
||||
use mime::Mime;
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
@ -28,21 +29,28 @@ use std::{io::Cursor, sync::atomic::Ordering};
|
|||
#[derive(Debug, Deserialize, Serialize)]
|
||||
struct CachedMeme {
|
||||
/// mxc url of the meme
|
||||
mxc: MxcUri,
|
||||
mxc: Box<MxcUri>,
|
||||
/// MIME type of the meme
|
||||
#[serde(with = "util::mime_serialize")]
|
||||
mime: Mime,
|
||||
/// file size of the meme
|
||||
size: UInt,
|
||||
/// file name of the meme
|
||||
meme_name: String,
|
||||
}
|
||||
|
||||
impl CachedMeme {
|
||||
fn into_message_type(self, name: String) -> Option<MessageType> {
|
||||
let Self { mxc, mime, size } = self;
|
||||
fn into_message_type(self) -> MessageType {
|
||||
let Self {
|
||||
mxc,
|
||||
mime,
|
||||
size,
|
||||
meme_name,
|
||||
} = self;
|
||||
|
||||
match mime.type_() {
|
||||
mime::IMAGE => Some(MessageType::Image(ImageMessageEventContent::plain(
|
||||
name,
|
||||
mime::IMAGE => MessageType::Image(ImageMessageEventContent::plain(
|
||||
meme_name,
|
||||
mxc,
|
||||
Some(Box::new({
|
||||
let mut info = ImageInfo::new();
|
||||
|
@ -50,9 +58,9 @@ impl CachedMeme {
|
|||
info.size = Some(size);
|
||||
info
|
||||
})),
|
||||
))),
|
||||
mime::VIDEO => Some(MessageType::Video(VideoMessageEventContent::plain(
|
||||
name,
|
||||
)),
|
||||
mime::VIDEO => MessageType::Video(VideoMessageEventContent::plain(
|
||||
meme_name,
|
||||
mxc,
|
||||
Some(Box::new({
|
||||
let mut info = VideoInfo::new();
|
||||
|
@ -60,8 +68,17 @@ impl CachedMeme {
|
|||
info.size = Some(size);
|
||||
info
|
||||
})),
|
||||
))),
|
||||
_ => None,
|
||||
)),
|
||||
_ => MessageType::File(FileMessageEventContent::plain(
|
||||
meme_name,
|
||||
mxc,
|
||||
Some(Box::new({
|
||||
let mut info = FileInfo::new();
|
||||
info.mimetype = Some(mime.to_string());
|
||||
info.size = Some(size);
|
||||
info
|
||||
})),
|
||||
)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -79,95 +96,116 @@ pub async fn on_msg(msg: &str, room: Room, bot: &Bot) -> anyhow::Result<()> {
|
|||
},
|
||||
};
|
||||
|
||||
for meme in &bot.config.memes {
|
||||
if meme.matches(msg) {
|
||||
bot.meme_count.fetch_add(1, Ordering::SeqCst);
|
||||
if let Some(ref sendmeme_cmd) = bot.config.sendmeme_command {
|
||||
let mut words = msg.split(' ');
|
||||
if words.next() == Some(sendmeme_cmd) {
|
||||
if let Some(id) = words.next() {
|
||||
let id = if let Ok(id) = id.parse::<u32>() {
|
||||
id
|
||||
} else {
|
||||
room.send(RoomMessageEventContent::text_plain("Invalid ID!"), None)
|
||||
.await?;
|
||||
return Ok(());
|
||||
};
|
||||
|
||||
let meme_name = &meme.keyword;
|
||||
if let Some(meme) = meme.get_meme(bot).await? {
|
||||
match meme.id.parse::<u32>() {
|
||||
Err(e) => {
|
||||
error!(
|
||||
"Meme {:?} has invalid ID! tilera, you messed up with your stupid php \
|
||||
again: {}",
|
||||
&meme, e
|
||||
);
|
||||
},
|
||||
Ok(id) => {
|
||||
if let Some(ivec) = bot.memecache.get(id.to_le_bytes())? {
|
||||
let cached = bincode::deserialize::<CachedMeme>(&ivec)?;
|
||||
send_meme(&room, cached, meme_name.clone()).await?;
|
||||
} else {
|
||||
info!("Meme {} not found in cache, uploading...", id);
|
||||
let resp = bot
|
||||
.jm_client
|
||||
.read()
|
||||
.await
|
||||
.http
|
||||
.get(&meme.link)
|
||||
.send()
|
||||
.await
|
||||
.context("error downloading meme")?;
|
||||
let resp = resp.bytes().await?;
|
||||
|
||||
if let Some(mime) = mime_guess::from_path(&meme.link).first() {
|
||||
let size = resp.len();
|
||||
let create_content::Response { content_uri, .. } = bot
|
||||
.client
|
||||
.read()
|
||||
.await
|
||||
.upload(&mime, &mut Cursor::new(resp))
|
||||
.await?;
|
||||
|
||||
let cached = CachedMeme {
|
||||
mxc: content_uri,
|
||||
mime,
|
||||
size: UInt::new(size as u64)
|
||||
.context("Meme has file size over allowed limit!")?,
|
||||
};
|
||||
|
||||
bot.memecache
|
||||
.insert(id.to_le_bytes(), bincode::serialize(&cached)?)?;
|
||||
|
||||
send_meme(&room, cached, meme_name.clone()).await?;
|
||||
} else {
|
||||
error!(
|
||||
"Couldn't guess MIME type of meme '{}', skipping.",
|
||||
&meme.link
|
||||
);
|
||||
}
|
||||
}
|
||||
},
|
||||
}
|
||||
} else {
|
||||
error!("Found meme with invalid id! {:?}", &meme);
|
||||
bot.jm_client.write().await.clear_cache().await;
|
||||
bot.meme_count.store(0, Ordering::SeqCst);
|
||||
cache_send_meme(id, bot, room).await?;
|
||||
return Ok(());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// we do this after we have responded, in order to not delay the response
|
||||
if bot.meme_count.load(Ordering::SeqCst) >= bot.config.clear_cache_threshold {
|
||||
let mut client = bot.jm_client.write().await;
|
||||
bot.meme_count.store(0, Ordering::SeqCst);
|
||||
client.clear_cache().await;
|
||||
// memes requested but not used, but they will be cached
|
||||
client.get_memes().await?;
|
||||
for meme in &bot.config.memes {
|
||||
if meme.matches(msg) {
|
||||
if let Some(id) = meme.get_id(bot).await? {
|
||||
cache_send_meme(id, bot, room).await?;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn send_meme(room: &Joined, cached: CachedMeme, meme_name: String) -> anyhow::Result<()> {
|
||||
let msg_ty = cached
|
||||
.into_message_type(meme_name)
|
||||
.context("Found meme that is neither image nor video!")?;
|
||||
async fn cache_send_meme(meme_id: u32, bot: &Bot, room: Joined) -> anyhow::Result<()> {
|
||||
bot.meme_count.fetch_add(1, Ordering::SeqCst);
|
||||
let memes = bot.jm_client.read().await.get_memes().await?;
|
||||
let meme = memes
|
||||
.iter()
|
||||
.find(|m| m.id.parse::<u32>().ok() == Some(meme_id))
|
||||
.cloned();
|
||||
|
||||
room.send(
|
||||
AnyMessageEventContent::RoomMessage(MessageEventContent::new(msg_ty)),
|
||||
None,
|
||||
)
|
||||
.await
|
||||
.context("Failed to send meme")?;
|
||||
if let Some(meme) = meme {
|
||||
if let Some(ivec) = bot.memecache.get(meme_id.to_be_bytes())? {
|
||||
let cached = bincode::deserialize::<CachedMeme>(&ivec)?;
|
||||
send_meme(&room, cached).await?;
|
||||
} else {
|
||||
info!("Meme {} not found in cache, uploading...", meme_id);
|
||||
let resp = bot
|
||||
.jm_client
|
||||
.read()
|
||||
.await
|
||||
.http
|
||||
.get(&meme.link)
|
||||
.send()
|
||||
.await
|
||||
.context("error downloading meme")?;
|
||||
let resp = resp.bytes().await?;
|
||||
|
||||
if let Some(mime) = mime_guess::from_path(&meme.link).first() {
|
||||
let size = resp.len();
|
||||
let create_content::Response { content_uri, .. } =
|
||||
bot.client.upload(&mime, &mut Cursor::new(resp)).await?;
|
||||
|
||||
let cached = CachedMeme {
|
||||
mxc: content_uri,
|
||||
mime,
|
||||
size: UInt::new(size as u64)
|
||||
.context("Meme has file size over allowed limit!")?,
|
||||
meme_name: meme
|
||||
.link
|
||||
.split('/')
|
||||
.last()
|
||||
.unwrap_or(&meme.link)
|
||||
.to_string(),
|
||||
};
|
||||
|
||||
bot.memecache
|
||||
.insert(meme_id.to_be_bytes(), bincode::serialize(&cached)?)?;
|
||||
|
||||
send_meme(&room, cached).await?;
|
||||
// we do this after we have responded, in order to not delay the response
|
||||
if bot.meme_count.load(Ordering::SeqCst) >= bot.config.clear_cache_threshold {
|
||||
let mut client = bot.jm_client.write().await;
|
||||
bot.meme_count.store(0, Ordering::SeqCst);
|
||||
client.clear_cache().await;
|
||||
// memes requested but not used, but they will be cached
|
||||
client.get_memes().await?;
|
||||
}
|
||||
} else {
|
||||
error!(
|
||||
"Couldn't guess MIME type of meme '{}', skipping.",
|
||||
&meme.link
|
||||
);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
room.send(
|
||||
RoomMessageEventContent::text_plain(format!("No meme with id '{}'", meme_id)),
|
||||
None,
|
||||
)
|
||||
.await?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn send_meme(room: &Joined, cached: CachedMeme) -> anyhow::Result<()> {
|
||||
let msg_ty = cached.into_message_type();
|
||||
room.send(RoomMessageEventContent::new(msg_ty), None)
|
||||
.await
|
||||
.context("Failed to send meme")?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
|
|
@ -10,7 +10,7 @@ pub mod mime_serialize {
|
|||
where
|
||||
S: Serializer,
|
||||
{
|
||||
serializer.serialize_str(&data.to_string())
|
||||
serializer.serialize_str(data.as_ref())
|
||||
}
|
||||
|
||||
pub fn deserialize<'de, D>(deserializer: D) -> Result<Mime, D::Error>
|
||||
|
|
Loading…
Reference in New Issue