Fix drone yml to produce docker images again.

Add contributing information.

Add support/community section.

Add matrix room badge
Co-Authored-By: projectmoon <projectmoon@noreply.git.agnos.is>
Co-Committed-By: projectmoon <projectmoon@noreply.git.agnos.is>

.drone.yml

@@ -14,8 +14,9 @@ steps:
 - name: docker
   image: plugins/docker
   when:
-    branch:
-    - master
+    ref:
+    - refs/tags/v*
+    - refs/heads/master
   settings:
     auto_tag: true
     username:

Cargo.toml

@@ -2,5 +2,5 @@
 
 members = [
     "dicebot",
-    "rpc",
+    "rpc"
 ]

Dockerfile

@@ -9,7 +9,7 @@ RUN rustup-init -qy
 ENV TINI_VERSION v0.19.0
 ADD https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini /usr/local/bin/tini
 ADD https://github.com/krallin/tini/releases/download/${TINI_VERSION}/tini.asc /tini.asc
-RUN gpg --batch --keyserver hkp://p80.pool.sks-keyservers.net:80 --recv-keys 595E85A6B1B4779EA4DAAEC70B588DFF0527A9B7 \
+RUN gpg --batch --keyserver hkp://keyserver.ubuntu.com --recv-keys 595E85A6B1B4779EA4DAAEC70B588DFF0527A9B7 \
  && gpg --batch --verify /tini.asc /usr/local/bin/tini
 RUN chmod +x /usr/local/bin/tini
 

README.md

@@ -1,6 +1,7 @@
 # Tenebrous Dicebot
 
 [![Build Status](https://drone.agnos.is/api/badges/projectmoon/tenebrous-dicebot/status.svg)](https://drone.agnos.is/projectmoon/tenebrous-dicebot)
+[![Matrix Chat](https://img.shields.io/matrix/tenebrous:agnos.is?label=matrix&server_fqdn=matrix.org)][matrix-room]
 
 _This repository is hosted on [Agnos.is Git][main-repo] and mirrored
 to [GitHub][github-repo]._
@@ -24,6 +25,23 @@ System.
 * Works in encrypted or unencrypted Matrix rooms.
 * Storing variables created by the user.
 
+## Support and Community
+
+The project has a Matrix room at [#tenebrous:agnos.is][matrix-room].
+It is also possible to make a post in [GitHub
+Discussions][github-discussions].
+
+For reporting bugs, we prefer that you open an issue on
+[git.agnos.is][agnosis-git-issues]. However, you may also open an
+issue on [GitHub][github-issues].
+
+### Development and Contributions
+
+All development occurs on [git.agnos.is][main-repo]. If you wish to
+contribute, please open a pull request there. In some cases, pull
+requests from GitHub may be accepted. All contributions must be
+licensed under [AGPL 3.0 or later][agpl] to be accepted.
+
 ## Building and Installation
 
 ### Docker Image
@@ -46,6 +64,17 @@ root of the repository.
 After pulling or building the image, see [instructions on how to use
 the Docker image](#running-the-bot).
 
+### Install from crates.io
+
+The project can be from [crates.io][crates-io]. To install it, execute
+`cargo install tenebrous-dicebot`. This will make the following
+executables available on your system:
+
+* `dicebot`: Main dicebot executable.
+* `dicebot-cmd`: Run dicebot commands from the command line.
+* `dicebot_migrate`: Standalone database migrator (not required).
+* `tonic_client`: Test client for the gRPC connection (not required).
+
 ### Build from Source
 
 Precompiled executables are not yet available. Clone this repository
@@ -254,3 +283,9 @@ support added for Chronicles of Darkness and Call of Cthulhu.
 [main-repo]: https://git.agnos.is/projectmoon/tenebrous-dicebot
 [github-repo]: https://github.com/ProjectMoon/matrix-dicebot
 [roadmap]: https://git.agnos.is/projectmoon/tenebrous-dicebot/wiki/Roadmap
+[crates-io]: https://crates.io/crates/tenebrous-dicebot
+[matrix-room]: https://matrix.to/#/#tenebrous:agnos.is
+[agnosis-git-issues]: https://git.agnos.is/projectmoon/tenebrous-dicebot/issues
+[github-discussions]: https://github.com/ProjectMoon/matrix-dicebot/discussions
+[github-issues]: https://github.com/ProjectMoon/matrix-dicebot/issues
+[agpl]: https://www.gnu.org/licenses/agpl-3.0.en.html

dicebot/Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "tenebrous-dicebot"
-version = "0.10.0"
-authors = ["Taylor C. Richberger <taywee@gmx.com>", "projectmoon <projectmoon@agnos.is>"]
+version = "0.13.1"
+authors = ["projectmoon <projectmoon@agnos.is>", "Taylor C. Richberger <taywee@gmx.com>"]
 edition = "2018"
 license = 'AGPL-3.0-or-later'
 description = 'An async Matrix dice bot for role-playing games'
-readme = 'README.md'
+readme = '../README.md'
 repository = 'https://git.agnos.is/projectmoon/matrix-dicebot'
 keywords = ["games", "dice", "matrix", "bot"]
 categories = ["games"]
@@ -14,6 +14,8 @@ categories = ["games"]
 tonic-build = "0.4"
 
 [dependencies]
+# indexmap version locked fixes a dependency cycle.
+indexmap = "=1.6.2"
 log = "0.4"
 tracing-subscriber = "0.2"
 toml = "0.5"
@@ -30,15 +32,15 @@ combine = "4.5"
 futures = "0.3"
 html2text = "0.2"
 phf = { version = "0.8", features = ["macros"] }
-matrix-sdk = { git = "https://github.com/matrix-org/matrix-rust-sdk", branch = "master" }
-refinery = { version = "0.5", features = ["rusqlite"]}
+matrix-sdk = { version = "0.3" }
+refinery = { version = "0.6", features = ["rusqlite"]}
 barrel = { version = "0.6", features = ["sqlite3"] }
 tempfile = "3"
 substring = "1.4"
 fuse-rust = "0.2"
 tonic = "0.4"
 prost = "0.7"
-tenebrous-rpc = { path = "../rpc" }
+tenebrous-rpc = { path = "../rpc", version = "0.1.0" }
 
 [dependencies.sqlx]
 version = "0.5"

dicebot/src/bin/tonic_client.rs

@@ -1,5 +1,5 @@
 use tenebrous_rpc::protos::dicebot::UserIdRequest;
-use tenebrous_rpc::protos::dicebot::{dicebot_client::DicebotClient, GetVariableRequest};
+use tenebrous_rpc::protos::dicebot::{dicebot_client::DicebotClient};
 use tonic::{metadata::MetadataValue, transport::Channel, Request};
 
 async fn create_client(
@@ -23,21 +23,11 @@ async fn create_client(
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut client = create_client("example-key").await?;
 
-    // let request = tonic::Request::new(GetVariableRequest {
-    //     user_id: "@projectmoon:agnos.is".into(),
-    //     room_id: "!agICWvldGfuCywUVUM:agnos.is".into(),
-    //     variable_name: "stuff".into(),
-    // });
-
-    // let response = client.get_variable(request).await?.into_inner();
-
     let request = tonic::Request::new(UserIdRequest {
         user_id: "@projectmoon:agnos.is".into(),
     });
 
     let response = client.rooms_for_user(request).await?.into_inner();
-    // println!("RESPONSE={:?}", response);
-    // println!("User friendly response is: {:?}", response.value);
     println!("Rooms: {:?}", response.rooms);
     Ok(())
 }

dicebot/src/db/sqlite/rooms.rs

@@ -53,22 +53,27 @@ impl Rooms for Database {
 mod tests {
     use crate::db::sqlite::Database;
     use crate::db::Rooms;
+    use std::future::Future;
 
-    async fn create_db() -> Database {
+    async fn with_db<Fut>(f: impl FnOnce(Database) -> Fut)
+    where
+        Fut: Future<Output = ()>,
+    {
         let db_path = tempfile::NamedTempFile::new_in(".").unwrap();
         crate::db::sqlite::migrator::migrate(db_path.path().to_str().unwrap())
             .await
             .unwrap();
 
-        Database::new(db_path.path().to_str().unwrap())
+        let db = Database::new(db_path.path().to_str().unwrap())
             .await
-            .unwrap()
+            .unwrap();
+
+        f(db).await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn should_process_test() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             let first_check = db
                 .should_process("myroom", "myeventid")
                 .await
@@ -82,5 +87,7 @@ mod tests {
                 .expect("should_process failed in first insert");
 
             assert_eq!(second_check, false);
+        })
+        .await;
     }
 }

dicebot/src/db/sqlite/state.rs

@@ -37,22 +37,27 @@ impl DbState for Database {
 mod tests {
     use crate::db::sqlite::Database;
     use crate::db::DbState;
+    use std::future::Future;
 
-    async fn create_db() -> Database {
+    async fn with_db<Fut>(f: impl FnOnce(Database) -> Fut)
+    where
+        Fut: Future<Output = ()>,
+    {
         let db_path = tempfile::NamedTempFile::new_in(".").unwrap();
         crate::db::sqlite::migrator::migrate(db_path.path().to_str().unwrap())
             .await
             .unwrap();
 
-        Database::new(db_path.path().to_str().unwrap())
+        let db = Database::new(db_path.path().to_str().unwrap())
             .await
-            .unwrap()
+            .unwrap();
+
+        f(db).await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn set_and_get_device_id() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             db.set_device_id("device_id")
                 .await
                 .expect("Could not set device ID");
@@ -61,19 +66,22 @@ mod tests {
 
             assert!(device_id.is_some());
             assert_eq!(device_id.unwrap(), "device_id");
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn no_device_id_set_returns_none() {
-        let db = create_db().await;
+        with_db(|db| async move {
             let device_id = db.get_device_id().await.expect("Could not get device ID");
             assert!(device_id.is_none());
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn can_update_device_id() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             db.set_device_id("device_id")
                 .await
                 .expect("Could not set device ID");
@@ -86,5 +94,7 @@ mod tests {
 
             assert!(device_id.is_some());
             assert_eq!(device_id.unwrap(), "device_id2");
+        })
+        .await;
     }
 }

dicebot/src/db/sqlite/users.rs

@@ -91,22 +91,27 @@ mod tests {
     use crate::db::sqlite::Database;
     use crate::db::Users;
     use crate::models::AccountStatus;
+    use std::future::Future;
 
-    async fn create_db() -> Database {
+    async fn with_db<Fut>(f: impl FnOnce(Database) -> Fut)
+    where
+        Fut: Future<Output = ()>,
+    {
         let db_path = tempfile::NamedTempFile::new_in(".").unwrap();
         crate::db::sqlite::migrator::migrate(db_path.path().to_str().unwrap())
             .await
             .unwrap();
 
-        Database::new(db_path.path().to_str().unwrap())
+        let db = Database::new(db_path.path().to_str().unwrap())
             .await
-            .unwrap()
+            .unwrap();
+
+        f(db).await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn create_and_get_full_user_test() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             let insert_result = db
                 .upsert_user(&User {
                     username: "myuser".to_string(),
@@ -129,12 +134,13 @@ mod tests {
             assert_eq!(user.password, Some("abc".to_string()));
             assert_eq!(user.account_status, AccountStatus::Registered);
             assert_eq!(user.active_room, Some("myroom".to_string()));
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn can_get_user_with_no_state_record() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             let insert_result = db
                 .upsert_user(&User {
                     username: "myuser".to_string(),
@@ -164,12 +170,13 @@ mod tests {
 
             //These should be default values because the state record is missing.
             assert_eq!(user.active_room, None);
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn can_insert_without_password() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             let insert_result = db
                 .upsert_user(&User {
                     username: "myuser".to_string(),
@@ -189,12 +196,13 @@ mod tests {
             let user = user.unwrap();
             assert_eq!(user.username, "myuser");
             assert_eq!(user.password, None);
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn can_insert_without_active_room() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             let insert_result = db
                 .upsert_user(&User {
                     username: "myuser".to_string(),
@@ -214,12 +222,13 @@ mod tests {
             let user = user.unwrap();
             assert_eq!(user.username, "myuser");
             assert_eq!(user.active_room, None);
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn can_update_user() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             let insert_result1 = db
                 .upsert_user(&User {
                     username: "myuser".to_string(),
@@ -254,12 +263,13 @@ mod tests {
             assert_eq!(user.password, Some("123".to_string()));
             assert_eq!(user.active_room, Some("room".to_string()));
             assert_eq!(user.account_status, AccountStatus::AwaitingActivation);
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn can_delete_user() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             let insert_result = db
                 .upsert_user(&User {
                     username: "myuser".to_string(),
@@ -280,27 +290,32 @@ mod tests {
                 .expect("User retrieval query failed");
 
             assert!(user.is_none());
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn username_not_in_db_returns_none() {
-        let db = create_db().await;
+        with_db(|db| async move {
             let user = db
                 .get_user("does not exist")
                 .await
                 .expect("Get user query failure");
 
             assert!(user.is_none());
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn authenticate_user_is_some_with_valid_password() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             let insert_result = db
                 .upsert_user(&User {
                     username: "myuser".to_string(),
-                password: Some(crate::logic::hash_password("abc").expect("password hash error!")),
+                    password: Some(
+                        crate::logic::hash_password("abc").expect("password hash error!"),
+                    ),
                     ..Default::default()
                 })
                 .await;
@@ -315,16 +330,19 @@ mod tests {
             assert!(user.is_some());
             let user = user.unwrap();
             assert_eq!(user.username, "myuser");
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn authenticate_user_is_none_with_wrong_password() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             let insert_result = db
                 .upsert_user(&User {
                     username: "myuser".to_string(),
-                password: Some(crate::logic::hash_password("abc").expect("password hash error!")),
+                    password: Some(
+                        crate::logic::hash_password("abc").expect("password hash error!"),
+                    ),
                     ..Default::default()
                 })
                 .await;
@@ -337,5 +355,7 @@ mod tests {
                 .expect("User retrieval query failed");
 
             assert!(user.is_none());
+        })
+        .await;
     }
 }

dicebot/src/db/sqlite/variables.rs

@@ -102,22 +102,27 @@ mod tests {
     use super::*;
     use crate::db::sqlite::Database;
     use crate::db::Variables;
+    use std::future::Future;
 
-    async fn create_db() -> Database {
+    async fn with_db<Fut>(f: impl FnOnce(Database) -> Fut)
+    where
+        Fut: Future<Output = ()>,
+    {
         let db_path = tempfile::NamedTempFile::new_in(".").unwrap();
         crate::db::sqlite::migrator::migrate(db_path.path().to_str().unwrap())
             .await
             .unwrap();
 
-        Database::new(db_path.path().to_str().unwrap())
+        let db = Database::new(db_path.path().to_str().unwrap())
             .await
-            .unwrap()
+            .unwrap();
+
+        f(db).await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn set_and_get_variable_test() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             db.set_user_variable("myuser", "myroom", "myvariable", 1)
                 .await
                 .expect("Could not set variable");
@@ -128,12 +133,13 @@ mod tests {
                 .expect("Could not get variable");
 
             assert_eq!(value, 1);
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn get_missing_variable_test() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             let value = db.get_user_variable("myuser", "myroom", "myvariable").await;
 
             assert!(value.is_err());
@@ -141,12 +147,13 @@ mod tests {
                 value.err().unwrap(),
                 DataError::KeyDoesNotExist(_)
             ));
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn get_other_user_variable_test() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             db.set_user_variable("myuser1", "myroom", "myvariable", 1)
                 .await
                 .expect("Could not set variable");
@@ -160,12 +167,13 @@ mod tests {
                 value.err().unwrap(),
                 DataError::KeyDoesNotExist(_)
             ));
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn count_variables_test() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             for variable_name in &["var1", "var2", "var3"] {
                 db.set_user_variable("myuser", "myroom", variable_name, 1)
                     .await
@@ -178,12 +186,13 @@ mod tests {
                 .expect("Could not get count.");
 
             assert_eq!(count, 3);
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn count_variables_respects_user_id() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             for variable_name in &["var1", "var2", "var3"] {
                 db.set_user_variable("different-user", "myroom", variable_name, 1)
                     .await
@@ -196,12 +205,13 @@ mod tests {
                 .expect("Could not get count.");
 
             assert_eq!(count, 0);
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn count_variables_respects_room_id() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             for variable_name in &["var1", "var2", "var3"] {
                 db.set_user_variable("myuser", "different-room", variable_name, 1)
                     .await
@@ -214,12 +224,13 @@ mod tests {
                 .expect("Could not get count.");
 
             assert_eq!(count, 0);
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn delete_variable_test() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             for variable_name in &["var1", "var2", "var3"] {
                 db.set_user_variable("myuser", "myroom", variable_name, 1)
                     .await
@@ -240,5 +251,7 @@ mod tests {
             let var1 = db.get_user_variable("myuser", "myroom", "var1").await;
             assert!(var1.is_err());
             assert!(matches!(var1.err().unwrap(), DataError::KeyDoesNotExist(_)));
+        })
+        .await;
     }
 }

dicebot/src/logic.rs

@@ -71,22 +71,27 @@ mod tests {
     use super::*;
     use crate::db::Users;
     use crate::models::{AccountStatus, User};
+    use std::future::Future;
 
-    async fn create_db() -> Database {
+    async fn with_db<Fut>(f: impl FnOnce(Database) -> Fut)
+    where
+        Fut: Future<Output = ()>,
+    {
         let db_path = tempfile::NamedTempFile::new_in(".").unwrap();
         crate::db::sqlite::migrator::migrate(db_path.path().to_str().unwrap())
             .await
             .unwrap();
 
-        Database::new(db_path.path().to_str().unwrap())
+        let db = Database::new(db_path.path().to_str().unwrap())
             .await
-            .unwrap()
+            .unwrap();
+
+        f(db).await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn get_account_no_user_exists() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             let account = get_account(&db, "@test:example.com")
                 .await
                 .expect("Account retrieval didn't work");
@@ -95,12 +100,13 @@ mod tests {
 
             let user = account.transient_user().unwrap();
             assert_eq!(user.username, "@test:example.com");
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn get_or_create_user_when_user_exists() {
-        let db = create_db().await;
-
+        with_db(|db| async move {
             let user = User {
                 username: "myuser".to_string(),
                 password: Some("abc".to_string()),
@@ -119,5 +125,7 @@ mod tests {
 
             let user_again = account.registered_user().unwrap();
             assert_eq!(user, *user_again);
+        })
+        .await;
     }
 }

rpc/Cargo.toml

@@ -3,6 +3,10 @@ name = "tenebrous-rpc"
 version = "0.1.0"
 authors = ["projectmoon <projectmoon@agnos.is>"]
 edition = "2018"
+description = "gRPC protobuf models for Tenebrous."
+homepage = "https://git.agnos.is/projectmoon/tenebrous-dicebot"
+repository = "https://git.agnos.is/projectmoon/tenebrous-dicebot"
+license = "AGPL-3.0-or-later"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 

rpc/src/main.rs

@@ -1,3 +0,0 @@
-fn main() {
-    println!("Hello, world!");
-}