runegate 0.4.0

Lightweight Rust-based identity proxy
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

use crate::memory_session_store::MemorySessionStore;
use actix_session::storage::{LoadError, SaveError, SessionKey, SessionStore, UpdateError};
use actix_web::cookie::time::Duration;
use std::collections::HashMap;

use actix_session::storage::RedisSessionStore;

/// A dynamic session store that can wrap either the default in-memory store
/// or a Redis-backed store for distributed deployments in magic-link-only mode.
#[derive(Clone)]
pub enum RunegateSessionStore {
    Memory(MemorySessionStore),
    Redis(RedisSessionStore),
}

impl SessionStore for RunegateSessionStore {
    async fn load(
        &self,
        session_key: &SessionKey,
    ) -> Result<Option<HashMap<String, String>>, LoadError> {
        match self {
            Self::Memory(store) => store.load(session_key).await,
            Self::Redis(store) => store.load(session_key).await,
        }
    }

    async fn save(
        &self,
        session_state: HashMap<String, String>,
        ttl: &Duration,
    ) -> Result<SessionKey, SaveError> {
        match self {
            Self::Memory(store) => store.save(session_state, ttl).await,
            Self::Redis(store) => store.save(session_state, ttl).await,
        }
    }

    async fn update(
        &self,
        session_key: SessionKey,
        session_state: HashMap<String, String>,
        ttl: &Duration,
    ) -> Result<SessionKey, UpdateError> {
        match self {
            Self::Memory(store) => store.update(session_key, session_state, ttl).await,
            Self::Redis(store) => store.update(session_key, session_state, ttl).await,
        }
    }

    async fn update_ttl(
        &self,
        session_key: &SessionKey,
        ttl: &Duration,
    ) -> Result<(), anyhow::Error> {
        match self {
            Self::Memory(store) => store.update_ttl(session_key, ttl).await,
            Self::Redis(store) => store.update_ttl(session_key, ttl).await,
        }
    }

    async fn delete(&self, session_key: &SessionKey) -> Result<(), anyhow::Error> {
        match self {
            Self::Memory(store) => store.delete(session_key).await,
            Self::Redis(store) => store.delete(session_key).await,
        }
    }
}