nodedb 0.2.0

Local-first, real-time, edge-to-cloud hybrid database for multi-modal workloads
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

// SPDX-License-Identifier: BUSL-1.1

//! Object ownership CRUD on `PermissionStore`.

use crate::control::security::catalog::{StoredOwner, SystemCatalog};
use crate::types::TenantId;

use super::store::PermissionStore;
use super::types::owner_key;

impl PermissionStore {
    /// Set the owner of an object. Direct CRUD path used by
    /// single-node mode and tests; cluster mode flows through
    /// `CatalogEntry::PutOwner` (or via `install_replicated_owner`
    /// from a parent variant's post_apply).
    pub fn set_owner(
        &self,
        object_type: &str,
        tenant_id: TenantId,
        object_name: &str,
        owner_username: &str,
        catalog: Option<&SystemCatalog>,
    ) -> crate::Result<()> {
        let key = owner_key(object_type, tenant_id.as_u64(), object_name);

        if let Some(catalog) = catalog {
            catalog.put_owner(&StoredOwner {
                object_type: object_type.to_string(),
                object_name: object_name.to_string(),
                tenant_id: tenant_id.as_u64(),
                owner_username: owner_username.to_string(),
            })?;
        }

        let mut owners = match self.owners.write() {
            Ok(o) => o,
            Err(p) => {
                tracing::error!("owner store lock poisoned — recovering data");
                p.into_inner()
            }
        };
        owners.insert(key, owner_username.to_string());
        Ok(())
    }

    /// Remove an ownership record.
    pub fn remove_owner(
        &self,
        object_type: &str,
        tenant_id: TenantId,
        object_name: &str,
        catalog: Option<&SystemCatalog>,
    ) -> crate::Result<()> {
        let key = owner_key(object_type, tenant_id.as_u64(), object_name);

        if let Some(catalog) = catalog {
            catalog.delete_owner(object_type, tenant_id.as_u64(), object_name)?;
        }

        let mut owners = match self.owners.write() {
            Ok(o) => o,
            Err(p) => {
                tracing::error!("owner store lock poisoned — recovering data");
                p.into_inner()
            }
        };
        owners.remove(&key);
        Ok(())
    }

    /// Get the owner of an object.
    pub fn get_owner(
        &self,
        object_type: &str,
        tenant_id: TenantId,
        object_name: &str,
    ) -> Option<String> {
        let key = owner_key(object_type, tenant_id.as_u64(), object_name);
        let owners = match self.owners.read() {
            Ok(o) => o,
            Err(p) => {
                tracing::error!("owner store lock poisoned — recovering data");
                p.into_inner()
            }
        };
        owners.get(&key).cloned()
    }

    /// List all objects of a given type owned in a tenant.
    /// Returns `(object_name, owner_username)` pairs.
    pub fn list_owners(&self, object_type: &str, tenant_id: TenantId) -> Vec<(String, String)> {
        let prefix = format!("{object_type}:{}:", tenant_id.as_u64());
        let owners = match self.owners.read() {
            Ok(o) => o,
            Err(p) => p.into_inner(),
        };
        owners
            .iter()
            .filter_map(|(key, owner)| {
                key.strip_prefix(&prefix)
                    .map(|name| (name.to_string(), owner.clone()))
            })
            .collect()
    }
}