Add database and storage of user variables.

This commit introduces the Sled embedded key-value store for keeping
track of user variables on a per-room basis. Extensive changes were
made to the command module to separate concerns and also pass the
database "connection" down the line.

 - A new "Context" object was created to hold information and state
   needed for command execution (namely the database).
 - Database is very simple for now, storing only user variables.
   Refactoring later for storing more complicated types.
 - State actor moved into Actors struct, in preparation for either
   more actors, or ripping the whole thing out entirely.
 - Other modules are also more properly separated, notably
   the config module is entirely self-contained.

.gitignore

@@ -5,3 +5,4 @@ todo.org
 cache
 *.tar
 *.tar.gz
+test-db/

Cargo.lock

@@ -283,9 +283,11 @@ dependencies = [
  "actix",
  "actix-rt",
  "async-trait",
+ "byteorder",
  "combine",
  "dirs",
  "env_logger",
+ "futures 0.3.6",
  "indoc",
  "itertools",
  "log",
@@ -296,10 +298,12 @@ dependencies = [
  "nom",
  "rand",
  "serde",
+ "sled",
  "thiserror",
  "tokio",
  "toml",
  "url",
+ "zerocopy",
 ]
 
 [[package]]
@@ -391,6 +395,15 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b3a71ab494c0b5b860bdc8407ae08978052417070c2ced38573a9157ad75b8ac"
 
+[[package]]
+name = "crc32fast"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba125de2af0df55319f41944744ad91c71113bf74a4646efff39afe1f6842db1"
+dependencies = [
+ "cfg-if 0.1.10",
+]
+
 [[package]]
 name = "crossbeam-channel"
 version = "0.4.4"
@@ -401,6 +414,21 @@ dependencies = [
  "maybe-uninit",
 ]
 
+[[package]]
+name = "crossbeam-epoch"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "058ed274caafc1f60c4997b5fc07bf7dc7cca454af7c6e81edffe5f33f70dace"
+dependencies = [
+ "autocfg",
+ "cfg-if 0.1.10",
+ "crossbeam-utils",
+ "lazy_static",
+ "maybe-uninit",
+ "memoffset",
+ "scopeguard",
+]
+
 [[package]]
 name = "crossbeam-queue"
 version = "0.2.3"
@@ -548,6 +576,16 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "fs2"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213"
+dependencies = [
+ "libc",
+ "winapi 0.3.9",
+]
+
 [[package]]
 name = "fuchsia-zircon"
 version = "0.3.3"
@@ -692,6 +730,15 @@ dependencies = [
  "slab",
 ]
 
+[[package]]
+name = "fxhash"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
+dependencies = [
+ "byteorder",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.1.15"
@@ -1197,6 +1244,15 @@ version = "2.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3728d817d99e5ac407411fa471ff9800a778d88a24685968b36824eaf4bee400"
 
+[[package]]
+name = "memoffset"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "043175f069eda7b85febe4a74abbaeff828d9f8b448515d3151a14a3542811aa"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "mime"
 version = "0.3.16"
@@ -2007,6 +2063,22 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c111b5bd5695e56cffe5129854aa230b39c93a305372fdbb2668ca2394eea9f8"
 
+[[package]]
+name = "sled"
+version = "0.34.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f72c064e63fbca3138ad07f3588c58093f1684f3a99f60dcfa6d46b87e60fde7"
+dependencies = [
+ "crc32fast",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+ "fs2",
+ "fxhash",
+ "libc",
+ "log",
+ "parking_lot",
+]
+
 [[package]]
 name = "smallvec"
 version = "1.4.2"
@@ -2656,6 +2728,27 @@ dependencies = [
  "winapi-build",
 ]
 
+[[package]]
+name = "zerocopy"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6580539ad917b7c026220c4b3f2c08d52ce54d6ce0dc491e66002e35388fab46"
+dependencies = [
+ "byteorder",
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d498dbd1fd7beb83c86709ae1c33ca50942889473473d287d56ce4770a18edfb"
+dependencies = [
+ "proc-macro2",
+ "syn",
+ "synstructure",
+]
+
 [[package]]
 name = "zeroize"
 version = "1.1.1"

Cargo.toml

@@ -25,6 +25,11 @@ indoc = "1.0"
 actix = "0.10"
 actix-rt = "1.1"
 combine = "4.3"
+sled = "0.34"
+zerocopy = "0.3"
+byteorder = "1.3"
+futures = "0.3"
+
 
 # The versioning of the matrix SDK follows its Cargo.toml. The SDK and
 # macros are on master, but it imports the common and base from 0.1.0.

Dockerfile

@@ -1,5 +1,6 @@
 # Builder image with development dependencies.
 FROM bougyman/voidlinux:glibc as builder
+RUN xbps-install -Syu
 RUN xbps-install -Sy base-devel rust cargo cmake wget gnupg
 RUN xbps-install -Sy libressl-devel olm-devel libstdc++-devel
 
@@ -36,4 +37,5 @@ COPY --from=builder \
     /usr/local/bin/
 
 ENV XDG_CACHE_HOME "/cache"
+ENV DATABASE_PATH "/cache/bot-db"
 ENTRYPOINT [ "/usr/local/bin/tini", "-v", "--", "/usr/local/bin/dicebot", "/config/dicebot-config.toml" ]

README.md

@@ -75,6 +75,7 @@ either the Storytelling System or more traditional RPG dice rolls.
 The bot supports a `!help` command for basic help information about
 its capabilities.
 
+### Basic Dice Rolling
 The commands `!roll` and `!r` can handle arbitrary dice roll
 expressions.
 
@@ -84,26 +85,49 @@ expressions.
 !r 3d12 - 5d2 + 3 - 7d3 + 20d20
 ```
 
+This system does not yet have the capability to handle things like D&D
+5e advantage or disadvantage.
+
+### Storytelling System
+
 The commands `!pool` (or `!rp`) and `!chance` are for the Storytelling
 System, and they use a specific syntax to support the dice system. The
 simplest version of the command is `!pool <num>` to roll a pool of the
 given size using the most common type of roll.
 
-The type of roll can be controlled by adding `n`, `e`, or `r` after
+The type of roll can be controlled by adding `n`, `e`, or `r` before
 the number, for 9-again, 8-again, and rote quality rolls. The number
 of successes required for an exceptional success can be controlled by
 `s<num>`, e.g. `s3` to only need 3 successes for an exceptional
-success.
+success. All modifiers should come before the number, with a `:`
+colon.
 
 Examples:
 
 ```
 !pool 8     //regular pool of 8 dice
-!pool 8n    //roll 8 dice, 9-again
+!pool n:8    //roll 8 dice, 9-again
-!pool 8ns3  //roll 8 dice, 9-again with only 3 successes for exceptional
+!pool ns3:8  //roll 8 dice, 9-again with only 3 successes for exceptional
-!pool 5rs2  //5 dice, rote quality, 2 successes for exceptional
+!pool rs2:5  //5 dice, rote quality, 2 successes for exceptional
 ```
 
+### User Variables
+
+Users can store variables for use with the Storytelling dice pool
+system. Variables are stored on a per-room, per-user basis in the
+database (currently located in the cache directory if using the Docker
+image).
+
+Examples:
+
+```
+!set myvar 5 //stores 5 for this room under the name "myvar"
+!get myvar //will print 5
+```
+
+Variables can be referenced in dice pool rolling expressions, for
+example `!pool myvar` or `!pool myvar+3`.
+
 ## Running the Bot
 
 The easiest way to run the bot is to use the [official Docker
@@ -123,13 +147,14 @@ ghcr.io/projectmoon/chronicle-dicebot:$VERSION
 ```
 
 The Docker image requires two volume mounts: the location of the
-[config file][config-file], which should be mounted at `/config/dicebot-config.toml`,
+[config file][config-file], which should be mounted at
-and a cache directory to store client state after initial sync. That
+`/config/dicebot-config.toml`, and a cache directory to store the
-should be mounted at `/cache/`in the container.
+database and client state after initial sync. That should be mounted
+at `/cache/`in the container.
 
 ### Configuration File
 
-The configuration file is a TOML file with two sections.
+The configuration file is a TOML file with three sections.
 
 ```toml
 [matrix]
@@ -137,6 +162,9 @@ home_server = 'https://example.com'
 username = 'thisismyusername'
 password = 'thisismypassword'
 
+[datbase]
+path = '/path/to/database/directory/'
+
 [bot]
 oldest_message_age = 300
 ```
@@ -151,6 +179,12 @@ bot's matrix account.
  - `username`: Bot account username.
  - `password`: Bot account password.
 
+The `[database]` section contains information for connecting to the
+embedded database. Note: **you do not need this** if you are using the
+Docker image.
+ - `path`: Path on the filesystem to use as the database storage
+   directory.
+
 The `[bot]` section has settings for controlling how the bot operates.
 This section is optional and the settings will fall back to their
 default values if the section or setting is not present.

src/actors.rs

@@ -0,0 +1,25 @@
+use crate::config::Config;
+use crate::db::Database;
+use actix::prelude::*;
+use state::DiceBotState;
+use std::sync::Arc;
+
+pub mod state;
+
+pub struct Actors {
+    global_state: Addr<DiceBotState>,
+}
+
+impl Actors {
+    pub fn new(config: &Arc<Config>, _db: &Database) -> Actors {
+        let global_state = DiceBotState::new(&config);
+
+        Actors {
+            global_state: global_state.start(),
+        }
+    }
+
+    pub fn global_state(&self) -> Addr<DiceBotState> {
+        self.global_state.clone()
+    }
+}

src/bin/dicebot-cmd.rs

@@ -1,12 +1,17 @@
-use chronicle_dicebot::commands::parse_command;
+use chronicle_dicebot::commands::Command;
+use chronicle_dicebot::context::Context;
+use chronicle_dicebot::db::Database;
+use chronicle_dicebot::error::BotError;
 
-fn main() -> Result<(), String> {
+fn main() -> Result<(), BotError> {
-    let command = std::env::args().skip(1).collect::<Vec<String>>().join(" ");
+    let db = Database::new(&sled::open("test-db")?);
-    let command = match parse_command(&command) {
+    let input = std::env::args().skip(1).collect::<Vec<String>>().join(" ");
-        Ok(Some(command)) => command,
+    let command = match Command::parse(&input) {
-        Ok(None) => return Err("Command not recognized".into()),
+        Ok(command) => command,
-        Err(e) => return Err(format!("Error parsing command: {}", e)),
+        Err(e) => return Err(e),
     };
-    println!("{}", command.execute().plain());
+
+    let context = Context::new(&db, "roomid", "localuser", &input);
+    println!("{}", command.execute(&context).plain());
     Ok(())
 }

src/bin/dicebot.rs

@@ -1,51 +1,36 @@
 //Needed for nested Result handling from tokio. Probably can go away after 1.47.0.
 #![type_length_limit = "7605144"]
 use actix::prelude::*;
+use chronicle_dicebot::actors::Actors;
 use chronicle_dicebot::bot::DiceBot;
 use chronicle_dicebot::config::*;
+use chronicle_dicebot::db::Database;
 use chronicle_dicebot::error::BotError;
-use chronicle_dicebot::state::DiceBotState;
 use env_logger::Env;
 use log::error;
-use std::fs;
-use std::path::PathBuf;
 use std::sync::Arc;
 
-fn read_config<P: Into<PathBuf>>(config_path: P) -> Result<Config, BotError> {
-    let config_path = config_path.into();
-    let config = {
-        let contents = fs::read_to_string(&config_path)?;
-        deserialize_config(&contents)?
-    };
-
-    Ok(config)
-}
-
-fn deserialize_config(contents: &str) -> Result<Config, BotError> {
-    let config = toml::from_str(&contents)?;
-    Ok(config)
-}
-
 #[actix_rt::main]
 async fn main() {
+    env_logger::from_env(Env::default().default_filter_or("chronicle_dicebot=info,dicebot=info"))
+        .init();
     match run().await {
         Ok(_) => (),
-        Err(e) => error!("Error: {:?}", e),
+        Err(e) => error!("Error: {}", e),
     };
 }
 
 async fn run() -> Result<(), BotError> {
-    env_logger::from_env(Env::default().default_filter_or("chronicle_dicebot=info")).init();
-
     let config_path = std::env::args()
         .skip(1)
         .next()
         .expect("Need a config as an argument");
 
     let cfg = Arc::new(read_config(config_path)?);
-    let bot_state = DiceBotState::new(&cfg).start();
+    let db = Database::new(&sled::open(cfg.database_path())?);
+    let actors = Actors::new(&cfg, &db);
 
-    match DiceBot::new(&cfg, bot_state) {
+    match DiceBot::new(&cfg, actors, &db) {
         Ok(bot) => bot.run().await?,
         Err(e) => println!("Error connecting: {:?}", e),
     };
@@ -53,38 +38,3 @@ async fn run() -> Result<(), BotError> {
     System::current().stop();
     Ok(())
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use indoc::indoc;
-
-    #[test]
-    fn deserialize_config_without_bot_section_test() {
-        let contents = indoc! {"
-            [matrix]
-            home_server = 'https://matrix.example.com'
-            username = 'username'
-            password = 'password'
-        "};
-
-        let cfg: Result<_, _> = deserialize_config(contents);
-        assert_eq!(true, cfg.is_ok());
-    }
-
-    #[test]
-    fn deserialize_config_without_oldest_message_setting_test() {
-        let contents = indoc! {"
-            [matrix]
-            home_server = 'https://matrix.example.com'
-            username = 'username'
-            password = 'password'
-
-            [bot]
-            not_a_real_setting = 2
-        "};
-
-        let cfg: Result<_, _> = deserialize_config(contents);
-        assert_eq!(true, cfg.is_ok());
-    }
-}

src/bot.rs

@@ -1,8 +1,10 @@
-use crate::commands::parse_command;
+use crate::actors::state::LogSkippedOldMessages;
+use crate::actors::Actors;
+use crate::commands::execute_command;
 use crate::config::*;
+use crate::context::Context;
+use crate::db::Database;
 use crate::error::BotError;
-use crate::state::{DiceBotState, LogSkippedOldMessages};
-use actix::Addr;
 use dirs;
 use log::{debug, error, info, trace, warn};
 use matrix_sdk::{
@@ -31,9 +33,11 @@ pub struct DiceBot {
     /// The matrix client.
     client: Client,
 
-    /// Current state of the dice bot. Actor ref to the core state
+    /// Actors used by the dice bot to manage internal state.
-    /// actor.
+    actors: Actors,
-    state: Addr<DiceBotState>,
+
+    /// Active database layer
+    db: Database,
 }
 
 fn cache_dir() -> Result<PathBuf, BotError> {
@@ -57,11 +61,12 @@ impl DiceBot {
     /// actor. This function returns a Result because it is possible
     /// for client creation to fail for some reason (e.g. invalid
     /// homeserver URL).
-    pub fn new(config: &Arc<Config>, state_actor: Addr<DiceBotState>) -> Result<Self, BotError> {
+    pub fn new(config: &Arc<Config>, actors: Actors, db: &Database) -> Result<Self, BotError> {
         Ok(DiceBot {
             client: create_client(&config)?,
             config: config.clone(),
-            state: state_actor,
+            actors: actors,
+            db: db.clone(),
         })
     }
 
@@ -135,13 +140,13 @@ fn check_message_age(
     }
 }
 
-async fn should_process(
+async fn should_process<'a>(
     bot: &DiceBot,
     event: &SyncMessageEvent<MessageEventContent>,
 ) -> Result<(String, String), BotError> {
     //Ignore messages that are older than configured duration.
     if !check_message_age(event, bot.config.oldest_message_age()) {
-        let res = bot.state.send(LogSkippedOldMessages).await;
+        let res = bot.actors.global_state().send(LogSkippedOldMessages).await;
 
         if let Err(e) = res {
             error!("Actix error: {:?}", e);
@@ -209,37 +214,29 @@ impl EventEmitter for DiceBot {
                     return;
                 };
 
-            let (plain, html) = match parse_command(&msg_body) {
-                Ok(Some(command)) => {
-                    let command = command.execute();
-                    (command.plain().into(), command.html().into())
-                }
-                Ok(None) => return, //Ignore non-commands.
-                Err(e) => {
-                    let message = format!("Error parsing command: {}", e);
-                    let html_message = format!("<p><strong>{}</strong></p>", message);
-                    (message, html_message)
-                }
-            };
-
-            let plain = format!("{}\n{}", sender_username, plain);
-            let html = format!("<p>{}</p>\n{}", sender_username, html);
-            let content = AnyMessageEventContent::RoomMessage(MessageEventContent::Notice(
-                NoticeMessageEventContent::html(plain, html),
-            ));
-
             //we clone here to hold the lock for as little time as possible.
             let (room_name, room_id) = {
                 let real_room = room.read().await;
                 (real_room.display_name().clone(), real_room.room_id.clone())
             };
 
-            let result = self.client.room_send(&room_id, content, None).await;
+            let ctx = Context::new(&self.db, &room_id.as_str(), &sender_username, &msg_body);
+
+            if let Some(cmd_result) = execute_command(&ctx) {
+                let response = AnyMessageEventContent::RoomMessage(MessageEventContent::Notice(
+                    NoticeMessageEventContent::html(cmd_result.plain, cmd_result.html),
+                ));
+
+                let result = self.client.room_send(&room_id, response, None).await;
                 if let Err(e) = result {
                     error!("Error sending message: {}", e.to_string());
                 };
 
-            info!("[{}] {} executed: {}", room_name, sender_username, msg_body);
+                info!(
+                    "[{}] {} executed: {}",
+                    room_name, ctx.username, ctx.message_body
+                );
+            }
         }
     }
 }

src/commands.rs

@@ -1,6 +1,7 @@
 use crate::cofd::dice::DicePool;
+use crate::context::Context;
 use crate::dice::ElementExpression;
-use crate::error::BotError;
+use crate::error::{BotError, CommandError};
 use crate::help::HelpTopic;
 use crate::roll::Roll;
 
@@ -22,7 +23,7 @@ impl Execution {
 }
 
 pub trait Command {
-    fn execute(&self) -> Execution;
+    fn execute(&self, ctx: &Context) -> Execution;
     fn name(&self) -> &'static str;
 }
 
@@ -33,7 +34,7 @@ impl Command for RollCommand {
         "roll regular dice"
     }
 
-    fn execute(&self) -> Execution {
+    fn execute(&self, _ctx: &Context) -> Execution {
         let roll = self.0.roll();
         let plain = format!("Dice: {}\nResult: {}", self.0, roll);
         let html = format!(
@@ -51,7 +52,7 @@ impl Command for PoolRollCommand {
         "roll dice pool"
     }
 
-    fn execute(&self) -> Execution {
+    fn execute(&self, _ctx: &Context) -> Execution {
         let roll_result = self.0.roll();
 
         let (plain, html) = match roll_result {
@@ -81,7 +82,7 @@ impl Command for HelpCommand {
         "help information"
     }
 
-    fn execute(&self) -> Execution {
+    fn execute(&self, _ctx: &Context) -> Execution {
         let help = match &self.0 {
             Some(topic) => topic.message(),
             _ => "There is no help for this topic",
@@ -93,24 +94,116 @@ impl Command for HelpCommand {
     }
 }
 
-/// Parse a command string into a dynamic command execution trait
+pub struct GetVariableCommand(String);
-/// object. Returns an error if a command was recognized but not
-/// parsed correctly. Returns Ok(None) if no command was recognized.
-pub fn parse_command(s: &str) -> Result<Option<Box<dyn Command>>, BotError> {
-    // match parser::parse_command(s) {
-    //     Ok(Some(command)) => match &command {
-    //         //Any command, or text transformed into non-command is
-    //         //sent upwards.
-    //         ("", Some(_)) | (_, None) => Ok(command),
 
-    //         //TODO replcae with nom all_consuming?
+impl Command for GetVariableCommand {
-    //         //Any unconsumed input (whitespace should already be
+    fn name(&self) -> &'static str {
-    //         // stripped) is considered a parsing error.
+        "retrieve variable value"
-    //         _ => Err(format!("{}: malformed expression", s)),
+    }
-    //     },
+
-    //     Err(err) => Err(err),
+    fn execute(&self, ctx: &Context) -> Execution {
-    // }
+        let name = &self.0;
-    parser::parse_command(s)
+        let value = match ctx.db.get_user_variable(ctx.room_id, ctx.username, name) {
+            Ok(Some(num)) => format!("{} = {}", name, num),
+            Ok(None) => format!("{} is not set", name),
+            Err(e) => format!("error getting {}: {}", name, e),
+        };
+
+        let plain = format!("Variable: {}", value);
+        let html = format!("<p><strong>Variable:</strong> {}", value);
+        Execution { plain, html }
+    }
+}
+
+pub struct SetVariableCommand(String, i32);
+
+impl Command for SetVariableCommand {
+    fn name(&self) -> &'static str {
+        "set variable value"
+    }
+
+    fn execute(&self, ctx: &Context) -> Execution {
+        let name = &self.0;
+        let value = self.1;
+        let value = match ctx
+            .db
+            .set_user_variable(ctx.room_id, ctx.username, name, value)
+        {
+            Ok(_) => format!("{} = {}", name, value),
+            Err(e) => format!("error setting {}: {}", name, e),
+        };
+
+        let plain = format!("Set Variable: {}", value);
+        let html = format!("<p><strong>Set Variable:</strong> {}", value);
+        Execution { plain, html }
+    }
+}
+
+pub struct DeleteVariableCommand(String);
+
+impl Command for DeleteVariableCommand {
+    fn name(&self) -> &'static str {
+        "delete variable"
+    }
+
+    fn execute(&self, ctx: &Context) -> Execution {
+        let name = &self.0;
+        let value = match ctx.db.delete_user_variable(ctx.room_id, ctx.username, name) {
+            Ok(()) => format!("{} now unset", name),
+            Err(e) => format!("error deleting {}: {}", name, e),
+        };
+
+        let plain = format!("Remove Variable: {}", value);
+        let html = format!("<p><strong>Remove Variable:</strong> {}", value);
+        Execution { plain, html }
+    }
+}
+
+impl dyn Command {
+    /// Parse a command string into a dynamic command execution trait
+    /// object. Returns an error if a command was recognized but not
+    /// parsed correctly. Returns Ok(None) if no command was recognized.
+    pub fn parse(s: &str) -> Result<Box<dyn Command>, BotError> {
+        match parser::parse_command(s) {
+            Ok(Some(command)) => Ok(command),
+            Ok(None) => Err(BotError::CommandError(CommandError::IgnoredCommand)),
+            Err(e) => Err(e),
+        }
+    }
+}
+
+pub struct CommandResult {
+    pub plain: String,
+    pub html: String,
+}
+
+/// Attempt to execute a command, and return the content that should
+/// go back to Matrix, if the command was executed (successfully or
+/// not). If a command is determined to be ignored, this function will
+/// return None, signifying that we should not send a response.
+pub fn execute_command<'a>(ctx: &'a Context) -> Option<CommandResult> {
+    let res = Command::parse(ctx.message_body).map(|cmd| {
+        let execution = cmd.execute(ctx);
+        (execution.plain().into(), execution.html().into())
+    });
+
+    let (plain, html) = match res {
+        Ok(plain_and_html) => plain_and_html,
+        Err(BotError::CommandError(CommandError::IgnoredCommand)) => return None,
+        Err(e) => {
+            let message = format!("Error parsing command: {}", e);
+            let html_message = format!("<p><strong>{}</strong></p>", message);
+            (message, html_message)
+        }
+    };
+
+    let plain = format!("{}\n{}", ctx.username, plain);
+    let html = format!("<p>{}</p>\n{}", ctx.username, html);
+
+    Some(CommandResult {
+        plain: plain,
+        html: html,
+    })
 }
 
 #[cfg(test)]
@@ -119,57 +212,39 @@ mod tests {
 
     #[test]
     fn chance_die_is_not_malformed() {
-        assert!(parse_command("!chance").is_ok());
+        assert!(Command::parse("!chance").is_ok());
     }
 
     #[test]
     fn roll_malformed_expression_test() {
-        assert!(parse_command("!roll 1d20asdlfkj").is_err());
+        assert!(Command::parse("!roll 1d20asdlfkj").is_err());
-        assert!(parse_command("!roll 1d20asdlfkj   ").is_err());
+        assert!(Command::parse("!roll 1d20asdlfkj   ").is_err());
     }
 
     #[test]
     fn roll_dice_pool_malformed_expression_test() {
-        assert!(parse_command("!pool 8abc").is_err());
+        assert!(Command::parse("!pool 8abc").is_err());
-        assert!(parse_command("!pool 8abc    ").is_err());
+        assert!(Command::parse("!pool 8abc    ").is_err());
     }
 
     #[test]
     fn pool_whitespace_test() {
-        assert!(parse_command("!pool ns3:8   ")
+        Command::parse("!pool ns3:8   ").expect("was error");
-            .map(|p| p.is_some())
+        Command::parse("   !pool ns3:8").expect("was error");
-            .expect("was error"));
+        Command::parse("   !pool ns3:8   ").expect("was error");
-        assert!(parse_command("   !pool ns3:8")
-            .map(|p| p.is_some())
-            .expect("was error"));
-        assert!(parse_command("   !pool ns3:8   ")
-            .map(|p| p.is_some())
-            .expect("was error"));
     }
 
     #[test]
     fn help_whitespace_test() {
-        assert!(parse_command("!help stuff   ")
+        Command::parse("!help stuff   ").expect("was error");
-            .map(|p| p.is_some())
+        Command::parse("   !help stuff").expect("was error");
-            .expect("was error"));
+        Command::parse("   !help stuff   ").expect("was error");
-        assert!(parse_command("   !help stuff")
-            .map(|p| p.is_some())
-            .expect("was error"));
-        assert!(parse_command("   !help stuff   ")
-            .map(|p| p.is_some())
-            .expect("was error"));
     }
 
     #[test]
     fn roll_whitespace_test() {
-        assert!(parse_command("!roll 1d4 + 5d6 -3   ")
+        Command::parse("!roll 1d4 + 5d6 -3   ").expect("was error");
-            .map(|p| p.is_some())
+        Command::parse("!roll 1d4 + 5d6 -3   ").expect("was error");
-            .expect("was error"));
+        Command::parse("   !roll 1d4 + 5d6 -3   ").expect("was error");
-        assert!(parse_command("!roll 1d4 + 5d6 -3   ")
-            .map(|p| p.is_some())
-            .expect("was error"));
-        assert!(parse_command("   !roll 1d4 + 5d6 -3   ")
-            .map(|p| p.is_some())
-            .expect("was error"));
     }
 }

src/commands/parser.rs

@@ -1,8 +1,12 @@
 use crate::cofd::parser::{create_chance_die, parse_dice_pool};
-use crate::commands::{Command, HelpCommand, PoolRollCommand, RollCommand};
+use crate::commands::{
+    Command, DeleteVariableCommand, GetVariableCommand, HelpCommand, PoolRollCommand, RollCommand,
+    SetVariableCommand,
+};
 use crate::dice::parser::parse_element_expression;
 use crate::error::BotError;
 use crate::help::parse_help_topic;
+use crate::variables::parse_set_variable;
 use combine::parser::char::{char, letter, space};
 use combine::{any, many1, optional, Parser};
 use nom::Err as NomErr;
@@ -20,6 +24,19 @@ fn parse_roll(input: &str) -> Result<Box<dyn Command>, BotError> {
     }
 }
 
+fn parse_get_variable_command(input: &str) -> Result<Box<dyn Command>, BotError> {
+    Ok(Box::new(GetVariableCommand(input.to_owned())))
+}
+
+fn parse_set_variable_command(input: &str) -> Result<Box<dyn Command>, BotError> {
+    let (variable_name, value) = parse_set_variable(input)?;
+    Ok(Box::new(SetVariableCommand(variable_name, value)))
+}
+
+fn parse_delete_variable_command(input: &str) -> Result<Box<dyn Command>, BotError> {
+    Ok(Box::new(DeleteVariableCommand(input.to_owned())))
+}
+
 fn parse_pool_roll(input: &str) -> Result<Box<dyn Command>, BotError> {
     let pool = parse_dice_pool(input)?;
     Ok(Box::new(PoolRollCommand(pool)))
@@ -72,6 +89,9 @@ fn split_command(input: &str) -> Result<(String, String), BotError> {
 pub fn parse_command(input: &str) -> Result<Option<Box<dyn Command>>, BotError> {
     match split_command(input) {
         Ok((cmd, cmd_input)) => match cmd.as_ref() {
+            "get" => parse_get_variable_command(&cmd_input).map(|command| Some(command)),
+            "set" => parse_set_variable_command(&cmd_input).map(|command| Some(command)),
+            "del" => parse_delete_variable_command(&cmd_input).map(|command| Some(command)),
             "r" | "roll" => parse_roll(&cmd_input).map(|command| Some(command)),
             "rp" | "pool" => parse_pool_roll(&cmd_input).map(|command| Some(command)),
             "chance" => chance_die().map(|command| Some(command)),

src/config.rs

@@ -1,4 +1,23 @@
+use crate::error::ConfigError;
 use serde::{self, Deserialize, Serialize};
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+
+pub fn read_config<P: Into<PathBuf>>(config_path: P) -> Result<Config, ConfigError> {
+    let config_path = config_path.into();
+    let config = {
+        let contents = fs::read_to_string(&config_path)?;
+        deserialize_config(&contents)?
+    };
+
+    Ok(config)
+}
+
+fn deserialize_config(contents: &str) -> Result<Config, ConfigError> {
+    let config = toml::from_str(&contents)?;
+    Ok(config)
+}
 
 /// The "matrix" section of the config, which gives home server, login information, and etc.
 #[derive(Serialize, Deserialize, Clone, Debug)]
@@ -15,6 +34,11 @@ struct MatrixConfig {
 
 const DEFAULT_OLDEST_MESSAGE_AGE: u64 = 15 * 60;
 
+fn db_path_from_env() -> String {
+    env::var("DATABASE_PATH")
+        .expect("could not find database path in config or environment variable")
+}
+
 /// The "bot" section of the config file, for bot settings.
 #[derive(Serialize, Deserialize, Clone, Debug)]
 struct BotConfig {
@@ -22,6 +46,21 @@ struct BotConfig {
     oldest_message_age: Option<u64>,
 }
 
+/// The "database" section of the config file.
+#[derive(Serialize, Deserialize, Clone, Debug)]
+struct DatabaseConfig {
+    /// Path to the database storage directory. Required.
+    path: Option<String>,
+}
+
+impl DatabaseConfig {
+    #[inline]
+    #[must_use]
+    fn path(&self) -> String {
+        self.path.clone().unwrap_or_else(|| db_path_from_env())
+    }
+}
+
 impl BotConfig {
     /// Determine the oldest allowable message age, in seconds. If the
     /// setting is defined, use that value. If it is not defined, fall
@@ -40,6 +79,7 @@ impl BotConfig {
 #[derive(Serialize, Deserialize, Clone, Debug)]
 pub struct Config {
     matrix: MatrixConfig,
+    database: Option<DatabaseConfig>,
     bot: Option<BotConfig>,
 }
 
@@ -65,6 +105,16 @@ impl Config {
         &self.matrix.password
     }
 
+    /// The path to the database storage directory.
+    #[inline]
+    #[must_use]
+    pub fn database_path(&self) -> String {
+        self.database
+            .as_ref()
+            .map(|db| db.path())
+            .unwrap_or_else(|| db_path_from_env())
+    }
+
     /// Figure out the allowed oldest message age, in seconds. This will
     /// be the defined oldest message age in the bot config, if the bot
     /// configuration and associated "oldest_message_age" setting are
@@ -92,6 +142,9 @@ mod tests {
                 username: "".to_owned(),
                 password: "".to_owned(),
             },
+            database: Some(DatabaseConfig {
+                path: Some("".to_owned()),
+            }),
             bot: Some(BotConfig {
                 oldest_message_age: None,
             }),
@@ -108,9 +161,139 @@ mod tests {
                 username: "".to_owned(),
                 password: "".to_owned(),
             },
+            database: Some(DatabaseConfig {
+                path: Some("".to_owned()),
+            }),
             bot: None,
         };
 
         assert_eq!(15 * 60, cfg.oldest_message_age());
     }
+
+    #[test]
+    fn db_path_uses_setting_first_test() {
+        let cfg = Config {
+            matrix: MatrixConfig {
+                home_server: "".to_owned(),
+                username: "".to_owned(),
+                password: "".to_owned(),
+            },
+            database: Some(DatabaseConfig {
+                path: Some("the-db-path".to_owned()),
+            }),
+            bot: None,
+        };
+
+        assert_eq!("the-db-path".to_owned(), cfg.database_path());
+    }
+
+    #[test]
+    fn db_path_uses_env_if_setting_not_defined_test() {
+        env::set_var("DATABASE_PATH", "the-db-path");
+
+        let cfg = Config {
+            matrix: MatrixConfig {
+                home_server: "".to_owned(),
+                username: "".to_owned(),
+                password: "".to_owned(),
+            },
+            database: Some(DatabaseConfig { path: None }),
+            bot: None,
+        };
+
+        assert_eq!("the-db-path".to_owned(), cfg.database_path());
+
+        env::remove_var("DATABASE_PATH");
+    }
+
+    #[test]
+    fn db_path_uses_env_if_section_not_defined_test() {
+        env::set_var("DATABASE_PATH", "the-db-path");
+
+        let cfg = Config {
+            matrix: MatrixConfig {
+                home_server: "".to_owned(),
+                username: "".to_owned(),
+                password: "".to_owned(),
+            },
+            database: None,
+            bot: None,
+        };
+
+        assert_eq!("the-db-path".to_owned(), cfg.database_path());
+
+        env::remove_var("DATABASE_PATH");
+    }
+
+    use indoc::indoc;
+
+    #[test]
+    fn deserialize_config_without_bot_section_test() {
+        let contents = indoc! {"
+            [matrix]
+            home_server = 'https://matrix.example.com'
+            username = 'username'
+            password = 'password'
+
+            [database]
+            path = ''
+        "};
+
+        let cfg: Result<_, _> = deserialize_config(contents);
+        assert_eq!(true, cfg.is_ok());
+    }
+
+    #[test]
+    fn deserialize_config_without_oldest_message_setting_test() {
+        let contents = indoc! {"
+            [matrix]
+            home_server = 'https://matrix.example.com'
+            username = 'username'
+            password = 'password'
+
+            [database]
+            path = ''
+
+            [bot]
+            not_a_real_setting = 2
+        "};
+
+        let cfg: Result<_, _> = deserialize_config(contents);
+        assert_eq!(true, cfg.is_ok());
+    }
+
+    #[test]
+    fn deserialize_config_without_db_path_setting_test() {
+        let contents = indoc! {"
+            [matrix]
+            home_server = 'https://matrix.example.com'
+            username = 'username'
+            password = 'password'
+
+            [database]
+            not_a_real_setting = 1
+
+            [bot]
+            not_a_real_setting = 2
+        "};
+
+        let cfg: Result<_, _> = deserialize_config(contents);
+        assert_eq!(true, cfg.is_ok());
+    }
+
+    #[test]
+    fn deserialize_config_without_db_section_test() {
+        let contents = indoc! {"
+            [matrix]
+            home_server = 'https://matrix.example.com'
+            username = 'username'
+            password = 'password'
+
+            [bot]
+            not_a_real_setting = 2
+        "};
+
+        let cfg: Result<_, _> = deserialize_config(contents);
+        assert_eq!(true, cfg.is_ok());
+    }
 }

src/context.rs

@@ -0,0 +1,27 @@
+use crate::db::Database;
+
+/// A context carried through the system providing access to things
+/// like the database.
+#[derive(Clone)]
+pub struct Context<'a> {
+    pub db: &'a Database,
+    pub room_id: &'a str,
+    pub username: &'a str,
+    pub message_body: &'a str,
+}
+
+impl<'a> Context<'a> {
+    pub fn new(
+        db: &'a Database,
+        room_id: &'a str,
+        username: &'a str,
+        message_body: &'a str,
+    ) -> Context<'a> {
+        Context {
+            db: db,
+            room_id: room_id,
+            username: username,
+            message_body: message_body,
+        }
+    }
+}

src/db.rs

@@ -0,0 +1,82 @@
+use byteorder::LittleEndian;
+use sled::{Db, IVec};
+use thiserror::Error;
+use zerocopy::byteorder::I32;
+use zerocopy::{AsBytes, LayoutVerified};
+
+#[derive(Clone)]
+pub struct Database {
+    db: Db,
+}
+
+#[derive(Error, Debug)]
+pub enum DataError {
+    #[error("value does not exist for key: {0}")]
+    KeyDoesNotExist(String),
+
+    #[error("internal database error: {0}")]
+    InternalError(#[from] sled::Error),
+}
+
+fn to_key(room_id: &str, username: &str, variable_name: &str) -> Vec<u8> {
+    let mut key = vec![];
+    key.extend_from_slice(room_id.as_bytes());
+    key.extend_from_slice(username.as_bytes());
+    key.extend_from_slice(variable_name.as_bytes());
+    key
+}
+
+impl Database {
+    pub fn new(db: &Db) -> Database {
+        Database { db: db.clone() }
+    }
+
+    pub fn get_user_variable(
+        &self,
+        room_id: &str,
+        username: &str,
+        variable_name: &str,
+    ) -> Result<Option<i32>, DataError> {
+        let key = to_key(room_id, username, variable_name);
+
+        if let Some(raw_value) = self.db.get(key)? {
+            let layout: LayoutVerified<&[u8], I32<LittleEndian>> =
+                LayoutVerified::new_unaligned(&*raw_value).expect("bytes do not fit schema");
+
+            let value: I32<LittleEndian> = *layout;
+            Ok(Some(value.get()))
+        } else {
+            Ok(None)
+        }
+    }
+
+    pub fn set_user_variable(
+        &self,
+        room_id: &str,
+        username: &str,
+        variable_name: &str,
+        value: i32,
+    ) -> Result<(), DataError> {
+        let key = to_key(room_id, username, variable_name);
+        let db_value: I32<LittleEndian> = I32::new(value);
+        self.db.insert(key, IVec::from(db_value.as_bytes()))?;
+        Ok(())
+    }
+
+    pub fn delete_user_variable(
+        &self,
+        room_id: &str,
+        username: &str,
+        variable_name: &str,
+    ) -> Result<(), DataError> {
+        let key = to_key(room_id, username, variable_name);
+        if let Some(_) = self.db.remove(key)? {
+            Ok(())
+        } else {
+            let mut key = room_id.to_owned();
+            key.push_str(username);
+            key.push_str(variable_name);
+            Err(DataError::KeyDoesNotExist(key))
+        }
+    }
+}

src/error.rs

@@ -1,11 +1,39 @@
+use crate::db::DataError;
 use thiserror::Error;
 
+#[derive(Error, Debug)]
+pub enum ConfigError {
+    #[error("i/o error: {0}")]
+    IoError(#[from] std::io::Error),
+
+    #[error("toml parsing error: {0}")]
+    TomlParsingError(#[from] toml::de::Error),
+}
+
+#[derive(Error, Debug)]
+pub enum CommandError {
+    #[error("invalid command: {0}")]
+    InvalidCommand(String),
+
+    #[error("ignored command")]
+    IgnoredCommand,
+}
+
 #[derive(Error, Debug)]
 pub enum BotError {
+    #[error("configuration error: {0}")]
+    ConfigurationError(#[from] ConfigError),
+
     /// Sync token couldn't be found.
     #[error("the sync token could not be retrieved")]
     SyncTokenRequired,
 
+    #[error("command error: {0}")]
+    CommandError(#[from] CommandError),
+
+    #[error("database error: {0}")]
+    DataError(#[from] DataError),
+
     #[error("the message should not be processed because it failed validation")]
     ShouldNotProcessError,
 
@@ -31,15 +59,21 @@ pub enum BotError {
     #[error("toml parsing error")]
     TomlParsingError(#[from] toml::de::Error),
 
-    #[error("i/o error")]
+    #[error("i/o error: {0}")]
     IoError(#[from] std::io::Error),
 
+    #[error("actor mailbox error: {0}")]
+    ActixMailboxError(#[from] actix::MailboxError),
+
     #[error("parsing error")]
     ParserError(#[from] combine::error::StringStreamError),
 
-    #[error("dice parsing error")]
+    #[error("dice parsing error: {0}")]
     DiceParsingError(#[from] crate::cofd::parser::DiceParsingError),
 
+    #[error("variable parsing error: {0}")]
+    VariableParsingError(#[from] crate::variables::VariableParsingError),
+
     #[error("legacy parsing error")]
     NomParserError(nom::error::ErrorKind),
 
@@ -48,4 +82,7 @@ pub enum BotError {
 
     #[error("variables not yet supported")]
     VariablesNotSupported,
+
+    #[error("database error")]
+    DatabaseErrror(#[from] sled::Error),
 }

src/lib.rs

@@ -1,10 +1,13 @@
+pub mod actors;
 pub mod bot;
 pub mod cofd;
 pub mod commands;
 pub mod config;
+pub mod context;
+pub mod db;
 pub mod dice;
 pub mod error;
 mod help;
 mod parser;
 pub mod roll;
-pub mod state;
+pub mod variables;

src/variables.rs

@@ -0,0 +1,43 @@
+use crate::error::BotError;
+use combine::parser::char::{digit, letter, spaces};
+use combine::{many1, Parser};
+use thiserror::Error;
+
+enum ParsedValue {
+    Valid(i32),
+    Invalid,
+}
+
+#[derive(Error, Debug)]
+pub enum VariableParsingError {
+    #[error("invalid variable value, must be a number")]
+    InvalidValue,
+
+    #[error("unconsumed input")]
+    UnconsumedInput,
+}
+
+pub fn parse_set_variable(input: &str) -> Result<(String, i32), BotError> {
+    let name = many1(letter()).map(|value: String| value);
+
+    let value = many1(digit()).map(|value: String| match value.parse::<i32>() {
+        Ok(num) => ParsedValue::Valid(num),
+        _ => ParsedValue::Invalid,
+    });
+
+    let mut parser = name.skip(spaces().silent()).and(value);
+    let (result, rest) = parser.parse(input)?;
+
+    if rest.len() == 0 {
+        match result {
+            (variable_name, ParsedValue::Valid(value)) => Ok((variable_name, value)),
+            _ => Err(BotError::VariableParsingError(
+                VariableParsingError::InvalidValue,
+            )),
+        }
+    } else {
+        Err(BotError::VariableParsingError(
+            VariableParsingError::UnconsumedInput,
+        ))
+    }
+}