uqa_execution/catalog/security/
database_lifecycle.rs1use super::roles::{
10 dependencies::{prepare_role_dependencies, RoleDependencyCandidate},
11 locking::RoleLockContext,
12};
13use crate::row_locks::shared_objects::SharedObjectLockSession;
14use std::{collections::BTreeSet, ops::DerefMut};
15use uqa_sql::catalog::security::acl_command::{AclCommandRoles, ResolvedAclRoles};
16use uqa_sql::{
17 ast::GrantDatabaseStmt,
18 catalog::{
19 roles::{guards::RoleCatalogGuards, RoleReferenceNames},
20 security::{
21 acl_warning::acl_warning,
22 database::{
23 apply_database_acl, requested_acl_privileges, resolve_database_grant_targets,
24 validate_database_acl_roles, BoundDatabaseSecurity,
25 },
26 database_inquiry::DatabaseSecurityRead,
27 dependencies::added_acl_roles,
28 },
29 DATABASE_NAME,
30 },
31 SQLError,
32};
33use uqa_storage::{CatalogFacade, StorageBackendResult};
34
35pub const DATABASE_SECURITY_METADATA_KEY: &str = "sql_database_security_json";
36mod persistence;
37pub type DatabaseSecurityWrite<'a> = Box<dyn DerefMut<Target = BoundDatabaseSecurity> + 'a>;
38
39pub trait DatabaseSecurityRegistry {
40 fn security_read(&self) -> DatabaseSecurityRead<'_>;
41 fn security_write(&self) -> DatabaseSecurityWrite<'_>;
42}
43pub trait DatabasePrivilegePublication {
44 fn prepare_writer(&self) -> Result<(), SQLError>;
45 fn refresh_catalog(&self) -> StorageBackendResult<()>;
46 fn persist_security(&self, json: &str) -> Result<(), SQLError>;
47 fn catalog_changed(&self);
48 fn notice(&self, notice: uqa_sql::SQLNotice);
49}
50pub struct DatabasePrivilegeContext<'a> {
51 pub names: &'a dyn RoleReferenceNames,
52 pub locks: &'a dyn SharedObjectLockSession,
53 pub roles: &'a dyn RoleCatalogGuards,
54 pub registry: &'a dyn DatabaseSecurityRegistry,
55 pub publication: &'a dyn DatabasePrivilegePublication,
56}
57
58pub fn grant_database_privileges(
59 context: &DatabasePrivilegeContext<'_>,
60 statement: &GrantDatabaseStmt,
61) -> Result<(), SQLError> {
62 context
63 .publication
64 .refresh_catalog()
65 .map_err(|error| SQLError::Internal(format!("load database privileges: {error}")))?;
66 let mut command_roles = AclCommandRoles::default();
67 let RoleDependencyCandidate {
68 roles,
69 memberships,
70 value:
71 DatabasePrivilegeCandidate {
72 current,
73 next,
74 notice,
75 },
76 ..
77 } = prepare_role_dependencies(
78 &RoleLockContext {
79 roles: context.roles,
80 session: context.locks,
81 },
82 || context.publication.prepare_writer(),
83 || prepare_privileges(context, statement, &mut command_roles),
84 )?;
85 if next != current {
86 let json = persistence::encode(&next, &roles).map_err(|error| {
87 SQLError::Internal(format!("serialize database privileges: {error}"))
88 })?;
89 context.publication.persist_security(&json)?;
90 **context.registry.security_write() = next;
91 context.publication.catalog_changed();
92 }
93 drop(memberships);
94 drop(roles);
95 if let Some(notice) = notice {
96 context.publication.notice(notice);
97 }
98 Ok(())
99}
100
101struct DatabasePrivilegeCandidate {
102 current: BoundDatabaseSecurity,
103 next: BoundDatabaseSecurity,
104 notice: Option<uqa_sql::SQLNotice>,
105}
106
107fn prepare_privileges<'a>(
108 context: &'a DatabasePrivilegeContext<'_>,
109 statement: &GrantDatabaseStmt,
110 command_roles: &mut AclCommandRoles,
111) -> Result<RoleDependencyCandidate<'a, DatabasePrivilegeCandidate>, SQLError> {
112 resolve_database_grant_targets(&statement.databases)?;
113 let roles = context.roles.role_definitions();
114 let ResolvedAclRoles {
115 grantees,
116 current_user,
117 ..
118 } = command_roles.resolve_validated(
119 context.names,
120 &roles,
121 &statement.grantees,
122 statement.grantor.as_ref(),
123 |resolved| {
124 validate_database_acl_roles(
125 statement,
126 &resolved.grantees,
127 resolved.requested_grantor.as_deref(),
128 &resolved.current_user,
129 &roles,
130 )
131 },
132 )?;
133 let privileges = requested_acl_privileges(&statement.privileges)?;
134 let memberships = context.roles.role_memberships();
135 let current = context.registry.security_read().clone();
136 let resolved = current.resolve(&roles).map_err(SQLError::Internal)?;
137 let (next, grantable) = apply_database_acl(
138 statement,
139 &grantees,
140 &privileges,
141 ¤t_user,
142 &roles,
143 &memberships,
144 &resolved,
145 )?;
146 let notice = (grantable != privileges.len())
147 .then(|| acl_warning(statement.is_grant, grantable != 0, DATABASE_NAME));
148 let mut dependencies = BTreeSet::new();
149 added_acl_roles(
150 resolved.acl.as_deref().unwrap_or_default(),
151 &resolved.role_owner,
152 next.acl.as_deref().unwrap_or_default(),
153 &next.role_owner,
154 &mut dependencies,
155 );
156 let next = BoundDatabaseSecurity::bind(&next, &roles).map_err(SQLError::Internal)?;
157 Ok(RoleDependencyCandidate {
158 value: DatabasePrivilegeCandidate {
159 current,
160 next,
161 notice,
162 },
163 memberships,
164 roles,
165 dependencies,
166 })
167}
168
169pub fn restore_database_security_from_metadata(
170 context: &DatabasePrivilegeContext<'_>,
171 catalog: &dyn CatalogFacade,
172 allow_migration: bool,
173) -> StorageBackendResult<()> {
174 let roles = context.roles.role_definitions();
175 let security = persistence::restore(catalog, &roles, allow_migration)?;
176 drop(roles);
177 **context.registry.security_write() = security;
178 Ok(())
179}
180
181#[cfg(test)]
182mod tests;