nodedb 0.4.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

// SPDX-License-Identifier: BUSL-1.1

//! Post-apply side effects for ownership `CatalogEntry` variants
//! (orphan path — see `apply::owner`) plus the shared helper used
//! by every sibling post_apply file that replicates ownership as a
//! side effect of a parent `Stored*` entry.

use std::sync::Arc;

use crate::control::security::catalog::StoredOwner;
use crate::control::state::SharedState;

/// Install an owner record derived from a parent `Stored*` entry.
///
/// Every post_apply file that handles an object with an embedded
/// `owner` field (function, trigger, sequence, schedule,
/// change_stream, procedure, materialized_view, collection) calls
/// this instead of constructing `StoredOwner` inline. Objects that
/// have no parent `Stored*` variant (indexes, spatial indexes, raw
/// `ALTER OBJECT OWNER`) use `CatalogEntry::PutOwner` directly.
pub(super) fn install_from_parent(
    object_type: &'static str,
    tenant_id: u64,
    object_name: &str,
    owner_username: &str,
    shared: &SharedState,
) {
    install_from_parent_in_database(
        object_type,
        0,
        tenant_id,
        object_name,
        owner_username,
        shared,
    );
}

pub(super) fn install_from_parent_in_database(
    object_type: &'static str,
    database_id: u64,
    tenant_id: u64,
    object_name: &str,
    owner_username: &str,
    shared: &SharedState,
) {
    shared.permissions.install_replicated_owner(&StoredOwner {
        database_id,
        object_type: object_type.to_string(),
        object_name: object_name.to_string(),
        tenant_id,
        owner_username: owner_username.to_string(),
    });
}

pub fn put(stored: StoredOwner, shared: Arc<SharedState>) {
    shared.permissions.install_replicated_owner(&stored);
    tracing::debug!(
        object_type = %stored.object_type,
        tenant = stored.tenant_id,
        object = %stored.object_name,
        owner = %stored.owner_username,
        "post_apply: owner replicated"
    );
}

pub fn delete(
    object_type: String,
    database_id: u64,
    tenant_id: u64,
    object_name: String,
    shared: Arc<SharedState>,
) {
    let removed = shared
        .permissions
        .install_replicated_remove_owner_in_database(
            &object_type,
            database_id,
            tenant_id,
            &object_name,
        );
    tracing::debug!(
        %object_type, tenant = tenant_id, %object_name, removed,
        "post_apply: owner removed"
    );
}