Ralith/idlebot - Change BPTGTWCABG7ZZBUXAPMUNSEET6Q55KG2NMGVZMVKUKYOWMHIF64QC

Persist state with heed

Created by Ralith on January 31, 2021

BPTGTWCABG7ZZBUXAPMUNSEET6Q55KG2NMGVZMVKUKYOWMHIF64QC

Dependencies

In channels

main

Change contents

Replacement in src/main.rs at line 4 [4.17]
B:BD[3.11] → [2.0:19]
∅:D[2.19] → [3.11:60]
B:BD[3.11] → [3.11:60]
```
    cell::RefCell,
    collections::{btree_map, BTreeMap, HashMap},
```
[3.11]
[3.60]
```
    convert::TryFrom,
```

Replacement in src/main.rs at line 16 [4.17]

∅:D[2.70] → [3.250:297]

B:BD[3.250] → [3.250:297]

        sync::sync_events::{self, JoinedRoom},

[2.70]

[3.297]

        sync::sync_events::{self, JoinedRoom, Rooms},

Replacement in src/main.rs at line 24 [4.17]
B:BD[4.321] → [3.422:446]
```
use serde::Deserialize;
```
[4.321]
[2.71]
```
use serde::{Deserialize, Serialize};
```

Replacement in src/main.rs at line 92 [4.17]

B:BD[3.1656] → [2.482:526]

    let state = RefCell::new(State::new());

[3.1656]

[3.1690]

    // FIXME: Should run before connecting. https://github.com/Kerollmops/heed/issues/106
    let state = State::new(&config)?;

Replacement in src/main.rs at line 95 [4.17]
B:BD[3.1691] → [3.1691:1739]
B:BD[3.1739] → [2.527:586]
∅:D[2.586] → [3.1776:1782]
B:BD[3.1776] → [3.1776:1782]
```
    for (id, room) in initial_sync.rooms.join {
        state.borrow_mut().update_room(&config, id, room);
    }
```
[3.1691]
[3.1782]
```
    state.update(&config, initial_sync.rooms);
```

Replacement in src/main.rs at line 110 [4.17]

B:BD[2.716] → [2.716:844]

            for (id, room) in res.rooms.join {
                state.borrow_mut().update_room(&config, id, room);
            }

[2.716]

[2.844]

            state.update(&config, res.rooms);

Replacement in src/main.rs at line 119 [4.17]

B:BD[2.950] → [2.950:1012]

            let least_active = state.borrow().least_active();

[2.950]

[2.1012]

            let least_active = state.least_active();

Replacement in src/main.rs at line 127 [4.17]

B:BD[2.1424] → [2.1424:1512]

                        state.borrow_mut().rooms.get_mut(&room).unwrap().remove(&user);

[2.1424]

[2.1512]

                        state.forget_user(&room, &user);

Replacement in src/main.rs at line 151 [4.17]

B:BD[3.2170] → [3.2170:2209]

    rooms: HashMap<RoomId, RoomState>,

[3.2170]

[3.2209]

    env: heed::Env,
    user_time: heed::Database<heed::types::Unit, heed::types::OwnedType<u64>>,
    time_user: heed::Database<heed::types::Unit, heed::types::Unit>,

Replacement in src/main.rs at line 157 [4.17]

B:BD[3.2225] → [3.2225:2298]

    fn new() -> Self {
        Self {
            rooms: HashMap::new(),

[3.2225]

[3.2298]

    fn new(config: &Config) -> anyhow::Result<Self> {
        std::fs::create_dir_all(&config.state_path).context("accessing state")?;
        let env = heed::EnvOpenOptions::new()
            .max_dbs(20) // FIXME: https://github.com/Kerollmops/heed/issues/106
            .open(&config.state_path)
            .map_err(|e| anyhow::anyhow!("opening state: {}", e))?;
        let user_time = env
            .create_database(Some("user-time"))
            .map_err(|e| anyhow::anyhow!("opening state: {}", e))?;
        let time_user = env
            .create_database(Some("time-user"))
            .map_err(|e| anyhow::anyhow!("opening state: {}", e))?;
        Ok(Self {
            env,
            user_time,
            time_user,
        })
    }
    fn update(&self, config: &Config, rooms: Rooms) {
        let mut txn = self.env.write_txn().unwrap();
        for (id, room) in rooms.join {
            self.update_room(&mut txn, &config, id, room);

Insertion in src/main.rs at line 181 [4.17]

[3.2308]

        txn.commit().unwrap();
    }
    fn least_active(&self) -> Option<(SystemTime, RoomId, UserId)> {
        let txn = self.env.read_txn().unwrap();
        let time_user = self.time_user.remap_key_type::<TimeUserEntry>();
        let ((time, key), ()) = time_user.first(&txn).unwrap()?;
        let time = SystemTime::UNIX_EPOCH + Duration::from_secs(u64::from_be(time));
        Some((
            time,
            RoomId::try_from(key.room).unwrap(),
            UserId::try_from(key.user).unwrap(),
        ))

Replacement in src/main.rs at line 196 [4.17]

B:BD[3.2315] → [2.2153:2232]

    fn update_room(&mut self, config: &Config, id: RoomId, room: JoinedRoom) {

[3.2315]

[3.2377]

    fn update_room(
        &self,
        txn: &mut heed::RwTxn<'_, '_>,
        config: &Config,
        id: RoomId,
        room: JoinedRoom,
    ) {

Deletion in src/main.rs at line 205 [4.17]

B:BD[3.2473] → [3.2473:2546]

        let state = self.rooms.entry(id).or_insert_with(RoomState::new);

Replacement in src/main.rs at line 206 [4.17]

B:BD[3.2587] → [2.2233:2287]

            state.handle_event(config, event.json());

[3.2587]

[3.2633]

            self.handle_event(txn, config, &id, event.json());

Replacement in src/main.rs at line 209 [4.17]

B:BD[3.2687] → [2.2288:2342]

            state.handle_event(config, event.json());

[3.2687]

[3.2733]

            self.handle_event(txn, config, &id, event.json());

Replacement in src/main.rs at line 213 [4.17]

B:BD[2.2344] → [2.2344:2676]

∅:D[2.2676] → [3.2749:2860]

B:BD[3.2749] → [3.2749:2860]

∅:D[3.2860] → [4.993:995]

B:BD[4.993] → [4.993:995]

B:BD[4.995] → [3.2861:3008]

B:BD[3.3008] → [2.2677:2764]

    fn least_active(&self) -> Option<(SystemTime, RoomId, UserId)> {
        let (room, (time, user)) = self
            .rooms
            .iter()
            .filter_map(|(id, room)| Some((id, room.least_active()?)))
            .min_by_key(|&(_room, (time, _user))| time)?;
        Some((time, room.clone(), user.clone()))
    }
}
struct RoomState {
    users: HashMap<UserId, SystemTime>,
    activity: BTreeMap<SystemTime, Vec<UserId>>,
}
impl RoomState {
    fn new() -> Self {
        Self {
            users: HashMap::new(),
            activity: BTreeMap::new(),
        }
    }
    fn handle_event(&mut self, config: &Config, event: &serde_json::value::RawValue) {

[2.2344]

[3.3078]

    fn handle_event(
        &self,
        txn: &mut heed::RwTxn<'_, '_>,
        config: &Config,
        room: &RoomId,
        event: &serde_json::value::RawValue,
    ) {

Replacement in src/main.rs at line 228 [4.17]

B:BD[2.2820] → [2.2820:2860]

            self.update(&event.sender);

[2.2820]

[2.2860]

            self.refresh_user(txn, room, &event.sender);

Replacement in src/main.rs at line 240 [4.17]

B:BD[2.2968] → [2.2968:3016]

                            self.remove(&user);

[2.2968]

[2.3016]

                            self.forget_user_inner(txn, room, &user);

Replacement in src/main.rs at line 251 [4.17]

B:BD[3.3907] → [3.3907:4304]

    fn update(&mut self, user: &UserId) {
        let time = self
            .users
            .entry(user.clone())
            .or_insert_with(SystemTime::now);
        if let btree_map::Entry::Occupied(mut activity) = self.activity.entry(*time) {
            activity.get_mut().retain(|x| x != user);
            if activity.get().is_empty() {
                activity.remove();
            }

[3.3907]

[3.4304]

    fn refresh_user(&self, txn: &mut heed::RwTxn<'_, '_>, room: &RoomId, user: &UserId) {
        let key = Key {
            room: room.as_str(),
            user: user.as_str(),
        };
        let time = SystemTime::now()
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap()
            .as_secs();
        let user_time = self
            .user_time
            .remap_key_type::<heed::types::SerdeBincode<Key>>();
        let time_user = self.time_user.remap_key_type::<TimeUserEntry>();
        let prev_time = user_time.get(txn, &key).unwrap();
        user_time.put(txn, &key, &time).unwrap();
        if let Some(prev_time) = prev_time {
            time_user.delete(txn, &(prev_time.to_be(), key)).unwrap();

Replacement in src/main.rs at line 270 [4.17]

B:BD[3.4314] → [3.4314:4568]

        let now = SystemTime::now();
        let idle = now.duration_since(*time).unwrap_or(Duration::new(0, 0));
        *time = now;
        trace!(id = %user, ?idle, "updated user");
        self.activity.entry(*time).or_default().push(user.clone());

[3.4314]

[3.4568]

        time_user.put(txn, &(time.to_be(), key), &()).unwrap();
        trace!(id = %user, age = time - prev_time.unwrap_or(time), "refreshed user");

Replacement in src/main.rs at line 274 [4.17]

B:BD[3.4575] → [3.4575:4617]

B:BD[3.4617] → [2.3065:3395]

    fn remove(&mut self, user: &UserId) {
        if let Some(time) = self.users.remove(user) {
            if let btree_map::Entry::Occupied(mut activity) = self.activity.entry(time) {
                activity.get_mut().retain(|x| x != user);
                if activity.get().is_empty() {
                    activity.remove();
                }
            }
        }

[3.4575]

[2.3395]

    fn forget_user(&self, room: &RoomId, user: &UserId) {
        let mut txn = self.env.write_txn().unwrap();
        self.forget_user_inner(&mut txn, room, user);
        txn.commit().unwrap();

Replacement in src/main.rs at line 280 [4.17]

B:BD[2.3402] → [2.3402:3555]

    fn least_active(&self) -> Option<(SystemTime, &UserId)> {
        let (&time, users) = self.activity.iter().next()?;
        Some((time, &users[0]))

[2.3402]

[3.4650]

    fn forget_user_inner(&self, txn: &mut heed::RwTxn<'_, '_>, room: &RoomId, user: &UserId) {
        let key = Key {
            room: room.as_str(),
            user: user.as_str(),
        };
        let user_time = self
            .user_time
            .remap_key_type::<heed::types::SerdeBincode<Key>>();
        let time_user = self.time_user.remap_key_type::<TimeUserEntry>();
        let time = user_time.get(txn, &key).unwrap();
        user_time.delete(txn, &key).unwrap();
        if let Some(time) = time {
            time_user.delete(txn, &(time.to_be(), key)).unwrap();
        }
        trace!(id = %user, "forgot user");

Insertion in src/main.rs at line 297 [4.17]

[3.4658]


type TimeUserEntry<'a> = heed::types::SerdeBincode<(u64, Key<'a>)>;

Insertion in src/main.rs at line 300 [4.17]

[3.4659]

#[derive(Serialize, Deserialize, Copy, Clone, Debug)]
struct Key<'a> {
    room: &'a str,
    user: &'a str,
}

Replacement in src/config.rs at line 1 [5.1225]
B:BD[5.1225] → [2.3556:3587]
```
use std::collections::HashSet;
```
[5.1225]
[2.3587]
```
use std::{collections::HashSet, path::PathBuf};
```
Insertion in src/config.rs at line 16 [5.1225]
[2.3650]
[5.1520]
```
    pub state_path: PathBuf,
```

Insertion in Cargo.toml at line 20 [4.1705]

[3.5125]

heed = { version = "0.11", features = ["mdbx", "serde-bincode"], default-features = false }