pdk-rate-limit-lib 1.7.0

PDK Rate Limit Library
Documentation 
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
68
69
70
71
72
73
74
75
76
77
78
79
80

// Copyright (c) 2026, Salesforce, Inc.,
// All rights reserved.
// For full license text, see the LICENSE.txt file

use url::form_urlencoded;

use self::KeyManagerFactory::{Cluster, Local};

/// Factory to create key managers.
pub enum KeyManagerFactory {
    Local(String),
    Cluster(String),
}

impl KeyManagerFactory {
    /// Create a new key manager factory.
    pub fn new(prefix: &str, cluster: bool) -> Self {
        let prefix = prefix.to_string();
        if cluster {
            Cluster(prefix)
        } else {
            Local(prefix)
        }
    }

    /// Create a new key manager with the specified bucket and group.
    pub fn create(&self, bucket: &str, group: &str) -> KeyManager {
        match self {
            Local(prefix) => KeyManager::Local {
                data_key: format!("{prefix}-{bucket}-{group}"),
            },
            Cluster(prefix) => KeyManager::Cluster {
                data_key: format!("{prefix}-{bucket}-{group}"),
                lock_key: format!("{prefix}-{bucket}-{group}-lock"),
                storage_key: form_urlencoded::byte_serialize(
                    format!("{bucket}-{group}").as_bytes(),
                )
                .collect(),
            },
        }
    }
}

/// Key manager for the rate limiting.
pub enum KeyManager {
    Local {
        data_key: String,
    },
    Cluster {
        data_key: String,
        lock_key: String,
        storage_key: String,
    },
}

impl KeyManager {
    /// Get the data key for the key manager.
    pub fn data_key(&self) -> &str {
        match self {
            KeyManager::Local { data_key } => data_key,
            KeyManager::Cluster { data_key, .. } => data_key,
        }
    }

    /// Get the storage key for the key manager.
    pub fn storage_key(&self) -> &str {
        match self {
            KeyManager::Local { .. } => "",
            KeyManager::Cluster { storage_key, .. } => storage_key,
        }
    }

    /// Get the lock key for the key manager.
    pub fn lock_key(&self) -> &str {
        match self {
            KeyManager::Local { .. } => "",
            KeyManager::Cluster { lock_key, .. } => lock_key,
        }
    }
}