feat: implement auto database acl after create database

Signed-off-by: shuiyisong <xixing.sys@gmail.com>
This commit is contained in:
shuiyisong
2026-07-20 20:12:37 +08:00
parent 5b1b12d041
commit 9e5d4e88b5
16 changed files with 1030 additions and 37 deletions
+5 -1
View File
@@ -553,13 +553,14 @@ impl StartCommand {
region_failure_detector_controller: Arc::new(NoopRegionFailureDetectorControl),
soft_drop_enabled: false,
soft_drop_retention: None,
create_database_metadata_committer: None,
};
let ddl_manager = DdlManager::try_new(
ddl_context,
procedure_manager.clone(),
Arc::new(StandaloneRepartitionProcedureFactory),
true,
false,
)
.context(error::InitDdlManagerSnafu)?;
@@ -578,6 +579,9 @@ impl StartCommand {
} else {
ddl_manager
};
ddl_manager
.register_loaders()
.context(error::InitDdlManagerSnafu)?;
let procedure_executor = creator
.procedure_executor_creator
+3
View File
@@ -124,6 +124,9 @@ pub struct DdlContext {
pub soft_drop_enabled: bool,
/// Fixed retention used to calculate new soft-drop deadlines.
pub soft_drop_retention: Option<Duration>,
/// Commits create-database metadata and the creator grant atomically.
pub create_database_metadata_committer:
Option<create_database::CreateDatabaseMetadataCommitterRef>,
}
impl DdlContext {
+455 -5
View File
@@ -13,10 +13,12 @@
// limitations under the License.
use std::collections::HashMap;
use std::sync::Arc;
use async_trait::async_trait;
use common_error::ext::{BoxedError, ErrorExt};
use common_procedure::error::{FromJsonSnafu, Result as ProcedureResult, ToJsonSnafu};
use common_procedure::{Context as ProcedureContext, LockKey, Procedure, Status};
use common_procedure::{Context as ProcedureContext, LockKey, Procedure, ProcedureId, Status};
use serde::{Deserialize, Serialize};
use serde_with::{DefaultOnNull, serde_as};
use snafu::{ResultExt, ensure};
@@ -25,8 +27,38 @@ use strum::AsRefStr;
use crate::ddl::DdlContext;
use crate::ddl::utils::map_to_procedure_error;
use crate::error::{self, Result};
use crate::instruction::{CacheIdent, UserCacheIdent};
use crate::key::schema_name::{SchemaNameKey, SchemaNameValue};
use crate::lock_key::{CatalogLock, SchemaLock};
use crate::rpc::ddl::CreatorGrantIntent;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AtomicCreateAccess {
AddedExactAll,
AlreadyEffectiveAll,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AtomicCreateOutcome {
Created(AtomicCreateAccess),
AlreadyCommitted,
UserChanged,
UserMissing,
SchemaConflict,
}
#[async_trait]
pub trait CreateDatabaseMetadataCommitter: Send + Sync {
async fn commit(
&self,
catalog: &str,
schema: &str,
value: &SchemaNameValue,
creator: &CreatorGrantIntent,
) -> std::result::Result<AtomicCreateOutcome, BoxedError>;
}
pub type CreateDatabaseMetadataCommitterRef = Arc<dyn CreateDatabaseMetadataCommitter>;
pub struct CreateDatabaseProcedure {
pub context: DdlContext,
@@ -41,6 +73,7 @@ impl CreateDatabaseProcedure {
schema: String,
create_if_not_exists: bool,
options: HashMap<String, String>,
creator: Option<CreatorGrantIntent>,
context: DdlContext,
) -> Self {
Self {
@@ -51,6 +84,7 @@ impl CreateDatabaseProcedure {
schema,
create_if_not_exists,
options,
creator,
},
}
}
@@ -85,8 +119,72 @@ impl CreateDatabaseProcedure {
Ok(Status::executing(true))
}
pub async fn on_create_metadata(&mut self) -> Result<Status> {
let value: SchemaNameValue = (&self.data.options).try_into()?;
pub async fn on_create_metadata(&mut self, procedure_id: ProcedureId) -> Result<Status> {
let mut value: SchemaNameValue = (&self.data.options).try_into()?;
if let Some(creator) = self.data.creator.as_ref() {
value.create_procedure_id = Some(procedure_id.to_string());
let Some(committer) = self.context.create_database_metadata_committer.as_ref() else {
return error::UnexpectedSnafu {
err_msg: "Create-database creator grant committer is not configured"
.to_string(),
}
.fail();
};
let _timer = crate::metrics::METRIC_META_CREATE_SCHEMA.start_timer();
let outcome = match committer
.commit(&self.data.catalog, &self.data.schema, &value, creator)
.await
{
Ok(outcome) => outcome,
Err(err) if err.is_retryable() => {
return Err(error::Error::RetryLater {
source: err,
clean_poisons: false,
});
}
Err(err) => return Err(err).context(error::ExternalSnafu),
};
match outcome {
AtomicCreateOutcome::Created(_) => {
crate::metrics::METRIC_META_CREATE_SCHEMA_COUNTER.inc();
}
AtomicCreateOutcome::AlreadyCommitted => {}
AtomicCreateOutcome::UserChanged => {
let source = error::UnexpectedSnafu {
err_msg: format!(
"User '{}' changed while creating database '{}.{}'",
creator.username, self.data.catalog, self.data.schema
),
}
.build();
return Err(error::Error::retry_later(source));
}
AtomicCreateOutcome::UserMissing => {
return error::UnexpectedSnafu {
err_msg: format!(
"Creator '{}' no longer exists in catalog '{}'",
creator.username, self.data.catalog
),
}
.fail();
}
AtomicCreateOutcome::SchemaConflict if self.data.create_if_not_exists => {
return Ok(Status::done());
}
AtomicCreateOutcome::SchemaConflict => {
return error::SchemaAlreadyExistsSnafu {
catalog: &self.data.catalog,
schema: &self.data.schema,
}
.fail();
}
}
self.data.state = CreateDatabaseState::InvalidateCreatorCache;
return Ok(Status::executing(true));
}
self.context
.table_metadata_manager
@@ -100,6 +198,33 @@ impl CreateDatabaseProcedure {
Ok(Status::done())
}
pub async fn on_invalidate_creator_cache(&mut self) -> Result<Status> {
let Some(creator) = self.data.creator.as_ref() else {
return Ok(Status::done());
};
let ident = CacheIdent::User(UserCacheIdent {
catalog: self.data.catalog.clone(),
username: creator.username.clone(),
});
let ctx = crate::cache_invalidator::Context {
subject: Some(format!(
"Invalidate creator cache after creating database '{}.{}' for '{}'",
self.data.catalog, self.data.schema, creator.username
)),
};
if let Err(source) = self
.context
.cache_invalidator
.invalidate(&ctx, &[ident])
.await
{
return Err(error::Error::retry_later(source));
}
Ok(Status::done())
}
}
#[async_trait]
@@ -108,12 +233,13 @@ impl Procedure for CreateDatabaseProcedure {
Self::TYPE_NAME
}
async fn execute(&mut self, _ctx: &ProcedureContext) -> ProcedureResult<Status> {
async fn execute(&mut self, ctx: &ProcedureContext) -> ProcedureResult<Status> {
let state = &self.data.state;
match state {
CreateDatabaseState::Prepare => self.on_prepare().await,
CreateDatabaseState::CreateMetadata => self.on_create_metadata().await,
CreateDatabaseState::CreateMetadata => self.on_create_metadata(ctx.procedure_id).await,
CreateDatabaseState::InvalidateCreatorCache => self.on_invalidate_creator_cache().await,
}
.map_err(map_to_procedure_error)
}
@@ -136,6 +262,7 @@ impl Procedure for CreateDatabaseProcedure {
pub enum CreateDatabaseState {
Prepare,
CreateMetadata,
InvalidateCreatorCache,
}
#[serde_as]
@@ -147,4 +274,327 @@ pub struct CreateDatabaseData {
pub create_if_not_exists: bool,
#[serde_as(deserialize_as = "DefaultOnNull")]
pub options: HashMap<String, String>,
#[serde(default)]
pub creator: Option<CreatorGrantIntent>,
}
#[cfg(test)]
mod tests {
use std::collections::VecDeque;
use std::sync::Mutex;
use std::sync::atomic::{AtomicUsize, Ordering};
use common_error::ext::ErrorExt;
use super::*;
use crate::cache_invalidator::{CacheInvalidator, Context};
use crate::test_util::{MockDatanodeManager, new_ddl_context};
const PROCEDURE_ID: &str = "4ee0ba94-11f0-4d4d-9468-5ebf732e3ab2";
fn procedure_id() -> ProcedureId {
ProcedureId::parse_str(PROCEDURE_ID).unwrap()
}
struct MockCommitter {
calls: AtomicUsize,
outcomes: Mutex<VecDeque<std::result::Result<AtomicCreateOutcome, BoxedError>>>,
}
impl MockCommitter {
fn new(
outcomes: impl IntoIterator<Item = std::result::Result<AtomicCreateOutcome, BoxedError>>,
) -> Self {
Self {
calls: AtomicUsize::new(0),
outcomes: Mutex::new(outcomes.into_iter().collect()),
}
}
}
#[async_trait]
impl CreateDatabaseMetadataCommitter for MockCommitter {
async fn commit(
&self,
_catalog: &str,
_schema: &str,
value: &SchemaNameValue,
_creator: &CreatorGrantIntent,
) -> std::result::Result<AtomicCreateOutcome, BoxedError> {
assert_eq!(value.create_procedure_id.as_deref(), Some(PROCEDURE_ID));
self.calls.fetch_add(1, Ordering::Relaxed);
self.outcomes
.lock()
.unwrap()
.pop_front()
.expect("unexpected commit call")
}
}
#[derive(Default)]
struct FailOnceInvalidator {
calls: AtomicUsize,
}
#[async_trait]
impl CacheInvalidator for FailOnceInvalidator {
async fn invalidate(&self, _ctx: &Context, _caches: &[CacheIdent]) -> Result<()> {
if self.calls.fetch_add(1, Ordering::Relaxed) == 0 {
return error::UnexpectedSnafu {
err_msg: "injected cache invalidation failure",
}
.fail();
}
Ok(())
}
fn invalidate_all(&self) -> Result<()> {
Ok(())
}
}
fn procedure(
outcomes: impl IntoIterator<Item = std::result::Result<AtomicCreateOutcome, BoxedError>>,
cache_invalidator: Arc<dyn CacheInvalidator>,
) -> (CreateDatabaseProcedure, Arc<MockCommitter>) {
let mut context = new_ddl_context(Arc::new(MockDatanodeManager::new(())));
context.cache_invalidator = cache_invalidator;
let committer = Arc::new(MockCommitter::new(outcomes));
context.create_database_metadata_committer = Some(committer.clone());
let procedure = CreateDatabaseProcedure::new(
"greptime".to_string(),
"metrics".to_string(),
false,
HashMap::new(),
Some(CreatorGrantIntent {
username: "alice".to_string(),
created_at_ns: 1,
}),
context,
);
(procedure, committer)
}
#[tokio::test]
async fn created_and_recovered_commits_retry_only_cache_invalidation() {
let invalidator = Arc::new(FailOnceInvalidator::default());
let (mut procedure, committer) = procedure(
[Ok(AtomicCreateOutcome::Created(
AtomicCreateAccess::AddedExactAll,
))],
invalidator.clone(),
);
procedure.data.state = CreateDatabaseState::CreateMetadata;
assert!(
!procedure
.on_create_metadata(procedure_id())
.await
.unwrap()
.is_done()
);
assert!(matches!(
procedure.data.state,
CreateDatabaseState::InvalidateCreatorCache
));
assert_eq!(committer.calls.load(Ordering::Relaxed), 1);
assert!(
procedure
.on_invalidate_creator_cache()
.await
.unwrap_err()
.is_retryable()
);
assert!(
procedure
.on_invalidate_creator_cache()
.await
.unwrap()
.is_done()
);
assert_eq!(committer.calls.load(Ordering::Relaxed), 1);
assert_eq!(invalidator.calls.load(Ordering::Relaxed), 2);
}
#[tokio::test]
async fn user_change_is_explicitly_retryable() {
let (mut procedure, committer) = procedure(
[Ok(AtomicCreateOutcome::UserChanged)],
Arc::new(FailOnceInvalidator::default()),
);
procedure.data.state = CreateDatabaseState::CreateMetadata;
let err = procedure
.on_create_metadata(procedure_id())
.await
.unwrap_err();
assert!(err.is_retryable());
assert!(matches!(
procedure.data.state,
CreateDatabaseState::CreateMetadata
));
assert_eq!(committer.calls.load(Ordering::Relaxed), 1);
}
#[tokio::test]
async fn lost_commit_response_replays_as_already_committed() {
let (mut procedure, committer) = procedure(
[
Err(BoxedError::new(
error::ElectionLeaderLeaseChangedSnafu.build(),
)),
Ok(AtomicCreateOutcome::AlreadyCommitted),
],
Arc::new(FailOnceInvalidator::default()),
);
procedure.data.state = CreateDatabaseState::CreateMetadata;
let err = procedure
.on_create_metadata(procedure_id())
.await
.unwrap_err();
assert!(matches!(err, error::Error::RetryLater { .. }));
assert!(matches!(
procedure.data.state,
CreateDatabaseState::CreateMetadata
));
assert!(
!procedure
.on_create_metadata(procedure_id())
.await
.unwrap()
.is_done()
);
assert!(matches!(
procedure.data.state,
CreateDatabaseState::InvalidateCreatorCache
));
assert_eq!(committer.calls.load(Ordering::Relaxed), 2);
}
#[tokio::test]
async fn lost_state_transition_recovers_committed_business_state() {
let (mut procedure, committer) = procedure(
[
Ok(AtomicCreateOutcome::Created(
AtomicCreateAccess::AddedExactAll,
)),
Ok(AtomicCreateOutcome::AlreadyCommitted),
],
Arc::new(FailOnceInvalidator::default()),
);
let context = procedure.context.clone();
procedure.data.state = CreateDatabaseState::CreateMetadata;
let stale_json = procedure.dump().unwrap();
assert!(
!procedure
.on_create_metadata(procedure_id())
.await
.unwrap()
.is_done()
);
assert!(matches!(
procedure.data.state,
CreateDatabaseState::InvalidateCreatorCache
));
let mut recovered = CreateDatabaseProcedure::from_json(&stale_json, context).unwrap();
assert_eq!(recovered.data.creator.as_ref().unwrap().username, "alice");
assert!(
!recovered
.on_create_metadata(procedure_id())
.await
.unwrap()
.is_done()
);
assert!(matches!(
recovered.data.state,
CreateDatabaseState::InvalidateCreatorCache
));
assert_eq!(committer.calls.load(Ordering::Relaxed), 2);
}
#[tokio::test]
async fn missing_creator_uses_legacy_schema_path() {
let mut context = new_ddl_context(Arc::new(MockDatanodeManager::new(())));
let committer = Arc::new(MockCommitter::new([Ok(AtomicCreateOutcome::Created(
AtomicCreateAccess::AddedExactAll,
))]));
context.create_database_metadata_committer = Some(committer.clone());
let mut procedure = CreateDatabaseProcedure::new(
"greptime".to_string(),
"legacy".to_string(),
false,
HashMap::new(),
None,
context,
);
procedure.data.state = CreateDatabaseState::CreateMetadata;
assert!(
procedure
.on_create_metadata(procedure_id())
.await
.unwrap()
.is_done()
);
assert_eq!(committer.calls.load(Ordering::Relaxed), 0);
assert!(
procedure
.context
.table_metadata_manager
.schema_manager()
.exists(SchemaNameKey::new("greptime", "legacy"))
.await
.unwrap()
);
}
#[tokio::test]
async fn creator_without_committer_fails_closed() {
let context = new_ddl_context(Arc::new(MockDatanodeManager::new(())));
let mut procedure = CreateDatabaseProcedure::new(
"greptime".to_string(),
"missing_committer".to_string(),
false,
HashMap::new(),
Some(CreatorGrantIntent {
username: "alice".to_string(),
created_at_ns: 1,
}),
context,
);
procedure.data.state = CreateDatabaseState::CreateMetadata;
assert!(procedure.on_create_metadata(procedure_id()).await.is_err());
assert!(
!procedure
.context
.table_metadata_manager
.schema_manager()
.exists(SchemaNameKey::new("greptime", "missing_committer"))
.await
.unwrap()
);
}
#[test]
fn legacy_procedure_json_defaults_creator() {
let context = new_ddl_context(Arc::new(MockDatanodeManager::new(())));
let procedure = CreateDatabaseProcedure::from_json(
r#"{
"state":"CreateMetadata",
"catalog":"greptime",
"schema":"metrics",
"create_if_not_exists":false,
"options":{}
}"#,
context,
)
.unwrap();
assert!(procedure.data.creator.is_none());
}
}
+72 -8
View File
@@ -34,7 +34,7 @@ use crate::ddl::alter_database::AlterDatabaseProcedure;
use crate::ddl::alter_logical_tables::AlterLogicalTablesProcedure;
use crate::ddl::alter_table::AlterTableProcedure;
use crate::ddl::comment_on::CommentOnProcedure;
use crate::ddl::create_database::CreateDatabaseProcedure;
use crate::ddl::create_database::{CreateDatabaseMetadataCommitterRef, CreateDatabaseProcedure};
use crate::ddl::create_flow::CreateFlowProcedure;
use crate::ddl::create_logical_tables::CreateLogicalTablesProcedure;
use crate::ddl::create_table::CreateTableProcedure;
@@ -135,7 +135,7 @@ macro_rules! procedure_loader_entry {
($procedure:ident) => {
(
$procedure::TYPE_NAME,
&|context: DdlContext| -> BoxedProcedureLoader {
&|context: DdlContext| -> common_procedure::BoxedProcedureLoader {
Box::new(move |json: &str| {
let context = context.clone();
$procedure::from_json(json, context).map(|p| Box::new(p) as _)
@@ -234,6 +234,14 @@ impl DdlManager {
self
}
pub fn with_create_database_metadata_committer(
mut self,
committer: CreateDatabaseMetadataCommitterRef,
) -> Self {
self.ddl_context.create_database_metadata_committer = Some(committer);
self
}
/// Returns the [TableMetadataManagerRef].
pub fn table_metadata_manager(&self) -> &TableMetadataManagerRef {
&self.ddl_context.table_metadata_manager
@@ -251,6 +259,7 @@ impl DdlManager {
CreateLogicalTablesProcedure,
CreateViewProcedure,
CreateFlowProcedure,
CreateDatabaseProcedure,
AlterTableProcedure,
AlterLogicalTablesProcedure,
AlterDatabaseProcedure,
@@ -259,7 +268,6 @@ impl DdlManager {
PurgeDroppedTableProcedure,
DropFlowProcedure,
TruncateTableProcedure,
CreateDatabaseProcedure,
DropDatabaseProcedure,
DropViewProcedure,
CommentOnProcedure
@@ -546,11 +554,18 @@ impl DdlManager {
schema,
create_if_not_exists,
options,
creator,
}: CreateDatabaseTask,
) -> Result<(ProcedureId, Option<Output>)> {
let context = self.create_context();
let procedure =
CreateDatabaseProcedure::new(catalog, schema, create_if_not_exists, options, context);
let procedure = CreateDatabaseProcedure::new(
catalog,
schema,
create_if_not_exists,
options,
creator,
context,
);
let procedure_with_id = ProcedureWithId::with_random_id(Box::new(procedure));
self.execute_procedure_and_wait(procedure_with_id).await
@@ -972,14 +987,16 @@ async fn handle_create_database_task(
ddl_manager: &DdlManager,
create_database_task: CreateDatabaseTask,
) -> Result<SubmitDdlTaskResponse> {
let catalog = create_database_task.catalog.clone();
let schema = create_database_task.schema.clone();
let (id, _) = ddl_manager
.submit_create_database(create_database_task.clone())
.submit_create_database(create_database_task)
.await?;
let procedure_id = id.to_string();
info!(
"Database {}.{} is created via procedure_id {id:?}",
create_database_task.catalog, create_database_task.schema
catalog, schema
);
Ok(SubmitDdlTaskResponse {
@@ -1253,6 +1270,9 @@ mod tests {
use super::DdlManager;
use crate::cache_invalidator::DummyCacheInvalidator;
use crate::ddl::alter_table::AlterTableProcedure;
use crate::ddl::create_database::{
AtomicCreateOutcome, CreateDatabaseMetadataCommitter, CreateDatabaseProcedure,
};
use crate::ddl::create_table::CreateTableProcedure;
use crate::ddl::drop_table::DropTableProcedure;
use crate::ddl::flow_meta::FlowMetadataAllocator;
@@ -1267,9 +1287,10 @@ mod tests {
use crate::peer::Peer;
use crate::region_keeper::MemoryRegionKeeper;
use crate::region_registry::LeaderRegionRegistry;
use crate::rpc::ddl::UndropTableTask;
use crate::rpc::ddl::{CreatorGrantIntent, UndropTableTask};
use crate::sequence::SequenceBuilder;
use crate::state_store::KvStateStore;
use crate::test_util::{MockDatanodeManager, new_ddl_context};
use crate::wal_provider::WalProvider;
/// A dummy implemented [NodeManager].
@@ -1314,6 +1335,47 @@ mod tests {
}
}
struct LoaderCommitter;
#[async_trait::async_trait]
impl CreateDatabaseMetadataCommitter for LoaderCommitter {
async fn commit(
&self,
_catalog: &str,
_schema: &str,
_value: &crate::key::schema_name::SchemaNameValue,
_creator: &CreatorGrantIntent,
) -> std::result::Result<AtomicCreateOutcome, BoxedError> {
unreachable!()
}
}
#[test]
fn test_generic_loader_captures_configured_committer() {
let mut context = new_ddl_context(Arc::new(MockDatanodeManager::new(())));
let committer = Arc::new(LoaderCommitter);
context.create_database_metadata_committer = Some(committer.clone());
let loader = procedure_loader!(CreateDatabaseProcedure)[0].1(context);
assert_eq!(Arc::strong_count(&committer), 2);
let loaded = loader(
r#"{
"state":"CreateMetadata",
"catalog":"greptime",
"schema":"metrics",
"create_if_not_exists":false,
"options":{},
"creator":{"username":"alice","created_at_ns":42}
}"#,
)
.unwrap();
assert_eq!(loaded.type_name(), "metasrv-procedure::CreateDatabase");
assert_eq!(Arc::strong_count(&committer), 3);
drop(loaded);
assert_eq!(Arc::strong_count(&committer), 2);
}
#[test]
fn test_try_new() {
let kv_backend = Arc::new(MemoryKvBackend::new());
@@ -1350,6 +1412,7 @@ mod tests {
region_failure_detector_controller: Arc::new(NoopRegionFailureDetectorControl),
soft_drop_enabled: false,
soft_drop_retention: None,
create_database_metadata_committer: None,
},
procedure_manager.clone(),
Arc::new(DummyRepartitionProcedureFactory),
@@ -1404,6 +1467,7 @@ mod tests {
region_failure_detector_controller: Arc::new(NoopRegionFailureDetectorControl),
soft_drop_enabled: true,
soft_drop_retention: Some(std::time::Duration::from_secs(1)),
create_database_metadata_committer: None,
},
procedure_manager,
Arc::new(DummyRepartitionProcedureFactory),
+9 -1
View File
@@ -1353,7 +1353,7 @@ impl ErrorExt for Error {
| AcquireMySqlClient { error, .. }
| MySqlTransaction { error, .. } => retry_hint_from_sqlx_error(error),
#[cfg(any(feature = "pg_kvbackend", feature = "mysql_kvbackend"))]
SqlExecutionTimeout { .. } => RetryHint::Retryable,
RdsTransactionRetryFailed { .. } | SqlExecutionTimeout { .. } => RetryHint::Retryable,
_ => RetryHint::NonRetryable,
}
}
@@ -1458,6 +1458,14 @@ mod retry_hint_tests {
assert_eq!(err.retry_hint(), RetryHint::Retryable);
}
#[cfg(any(feature = "pg_kvbackend", feature = "mysql_kvbackend"))]
#[test]
fn test_rds_transaction_retry_failed_hint_is_retryable() {
let err = RdsTransactionRetryFailedSnafu.build();
assert_eq!(err.retry_hint(), RetryHint::Retryable);
}
#[test]
fn test_default_hint_is_non_retryable() {
let err = UnexpectedSnafu {
+30 -1
View File
@@ -60,6 +60,9 @@ pub struct SchemaNameValue {
pub ttl: Option<DatabaseTimeToLive>,
#[serde(default)]
pub extra_options: BTreeMap<String, String>,
/// Identifies the create-database procedure that wrote this value.
#[serde(default, skip_serializing_if = "Option::is_none")]
pub create_procedure_id: Option<String>,
}
impl Display for SchemaNameValue {
@@ -103,7 +106,11 @@ impl TryFrom<&HashMap<String, String>> for SchemaNameValue {
})
.collect();
Ok(Self { ttl, extra_options })
Ok(Self {
ttl,
extra_options,
..Default::default()
})
}
}
@@ -452,6 +459,7 @@ mod tests {
Some(SchemaNameValue {
ttl: Some(Duration::from_secs(10).into()),
extra_options: BTreeMap::new(),
create_procedure_id: None,
})
);
@@ -474,10 +482,31 @@ mod tests {
Some(SchemaNameValue {
ttl: Some(Duration::from_secs(15).into()),
extra_options: expected_options,
create_procedure_id: None,
})
);
}
#[test]
fn test_create_procedure_id_serialization() {
let value = SchemaNameValue {
create_procedure_id: Some("4ee0ba94-11f0-4d4d-9468-5ebf732e3ab2".to_string()),
..Default::default()
};
let raw = value.try_as_raw_value().unwrap();
assert_eq!(
SchemaNameValue::try_from_raw_value(&raw).unwrap(),
Some(value)
);
let raw = SchemaNameValue::default().try_as_raw_value().unwrap();
assert!(
!String::from_utf8(raw)
.unwrap()
.contains("create_procedure_id")
);
}
#[tokio::test]
async fn test_key_exist() {
let manager = SchemaManager::new(Arc::new(MemoryKvBackend::default()));
+90 -4
View File
@@ -67,6 +67,18 @@ use crate::key::table_name::{TableNameKey, TableNameManager};
/// Reserved query-context extension key for the frontend peer address that submitted a DDL request.
pub const ORIGIN_FRONTEND_ADDR_EXTENSION_KEY: &str = "__greptime_origin_frontend.addr";
/// Reserved query-context extension key for the authenticated database creator.
pub const CREATE_DATABASE_CREATOR_EXTENSION_KEY: &str = "__greptime_create_database.creator";
/// Internal gRPC metadata key for the authenticated database creator.
pub const CREATE_DATABASE_CREATOR_METADATA_KEY: &str =
"x-greptime-internal-create-database-creator-bin";
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct CreatorGrantIntent {
pub username: String,
pub created_at_ns: i64,
}
/// DDL tasks
#[derive(Debug, Clone)]
pub enum DdlTask {
@@ -171,12 +183,14 @@ impl DdlTask {
schema: String,
create_if_not_exists: bool,
options: HashMap<String, String>,
creator: Option<CreatorGrantIntent>,
) -> Self {
DdlTask::CreateDatabase(CreateDatabaseTask {
catalog,
schema,
create_if_not_exists,
options,
creator,
})
}
@@ -351,7 +365,28 @@ impl TryFrom<SubmitDdlTaskRequest> for PbDdlTaskRequest {
type Error = error::Error;
fn try_from(request: SubmitDdlTaskRequest) -> Result<Self> {
let task = match request.task {
let SubmitDdlTaskRequest {
mut query_context,
wait,
timeout,
task,
} = request;
query_context
.extensions
.remove(CREATE_DATABASE_CREATOR_EXTENSION_KEY);
if let DdlTask::CreateDatabase(CreateDatabaseTask {
creator: Some(creator),
..
}) = &task
{
query_context.extensions.insert(
CREATE_DATABASE_CREATOR_EXTENSION_KEY.to_string(),
serde_json::to_string(creator).context(error::SerdeJsonSnafu)?,
);
}
let task = match task {
DdlTask::CreateTable(task) => Task::CreateTableTask(task.try_into()?),
DdlTask::DropTable(task) => Task::DropTableTask(task.into()),
DdlTask::UndropTable(task) => Task::UndropTableTask(task.into()),
@@ -398,9 +433,9 @@ impl TryFrom<SubmitDdlTaskRequest> for PbDdlTaskRequest {
Ok(Self {
header: None,
query_context: Some(request.query_context.into()),
timeout_secs: request.timeout.as_secs() as u32,
wait: request.wait,
query_context: Some(query_context.into()),
timeout_secs: timeout.as_secs() as u32,
wait,
task: Some(task),
})
}
@@ -1027,6 +1062,8 @@ pub struct CreateDatabaseTask {
pub create_if_not_exists: bool,
#[serde_as(deserialize_as = "DefaultOnNull")]
pub options: HashMap<String, String>,
#[serde(default)]
pub creator: Option<CreatorGrantIntent>,
}
impl TryFrom<PbCreateDatabaseTask> for CreateDatabaseTask {
@@ -1047,6 +1084,7 @@ impl TryFrom<PbCreateDatabaseTask> for CreateDatabaseTask {
schema: schema_name,
create_if_not_exists,
options,
creator: None,
})
}
}
@@ -1060,6 +1098,7 @@ impl TryFrom<CreateDatabaseTask> for PbCreateDatabaseTask {
schema,
create_if_not_exists,
options,
creator: _,
}: CreateDatabaseTask,
) -> Result<Self> {
Ok(PbCreateDatabaseTask {
@@ -1871,6 +1910,53 @@ mod tests {
assert!(matches!(de, DdlTask::PurgeDroppedTable(task) if task == expected));
}
#[test]
fn test_create_database_creator_transport_sanitizes_extension() {
let request = |creator| {
let mut query_context = QueryContext::default();
query_context.extensions.insert(
CREATE_DATABASE_CREATOR_EXTENSION_KEY.to_string(),
"spoofed".to_string(),
);
SubmitDdlTaskRequest::new(
query_context,
DdlTask::new_create_database(
"greptime".to_string(),
"test".to_string(),
false,
HashMap::new(),
creator,
),
)
};
let creator = CreatorGrantIntent {
username: "alice".to_string(),
created_at_ns: 42,
};
let mut pb = PbDdlTaskRequest::try_from(request(Some(creator.clone()))).unwrap();
let encoded = pb
.query_context
.as_ref()
.unwrap()
.extensions
.get(CREATE_DATABASE_CREATOR_EXTENSION_KEY)
.unwrap();
assert_eq!(creator, serde_json::from_str(encoded).unwrap());
assert!(matches!(
DdlTask::try_from(pb.task.take().unwrap()).unwrap(),
DdlTask::CreateDatabase(CreateDatabaseTask { creator: None, .. })
));
let pb = PbDdlTaskRequest::try_from(request(None)).unwrap();
assert!(
!pb.query_context
.unwrap()
.extensions
.contains_key(CREATE_DATABASE_CREATOR_EXTENSION_KEY)
);
}
#[test]
fn test_undrop_table_task_json_roundtrip() {
let task = UndropTableTask { table_id: 1024 };
+1
View File
@@ -208,6 +208,7 @@ pub fn new_ddl_context_with_kv_backend(
region_failure_detector_controller: Arc::new(NoopRegionFailureDetectorControl),
soft_drop_enabled: false,
soft_drop_retention: Some(std::time::Duration::from_secs(7 * 24 * 60 * 60)),
create_database_metadata_committer: None,
}
}
+9
View File
@@ -33,6 +33,8 @@ use operator::flow::FlowServiceOperator;
use operator::insert::Inserter;
use operator::procedure::ProcedureServiceOperator;
use operator::request::Requester;
#[cfg(feature = "enterprise")]
use operator::statement::CreateDatabaseHandlerRef;
use operator::statement::{
ExecutorConfigureContext, StatementExecutor, StatementExecutorConfiguratorRef,
StatementExecutorRef,
@@ -284,6 +286,13 @@ impl FrontendBuilder {
statement_executor
};
#[cfg(feature = "enterprise")]
let statement_executor = if let Some(handler) = plugins.get::<CreateDatabaseHandlerRef>() {
statement_executor.with_create_database_handler(handler)
} else {
statement_executor
};
let statement_executor = Arc::new(statement_executor);
let pipeline_operator = Arc::new(PipelineOperator::new(
+98 -2
View File
@@ -16,6 +16,7 @@ use std::future::Future;
use std::sync::Arc;
use std::time::Duration;
use api::v1::meta::ddl_task_request::Task;
use api::v1::meta::procedure_service_client::ProcedureServiceClient;
use api::v1::meta::{
DdlTaskRequest, DdlTaskResponse, GcRegionsRequest, GcRegionsResponse, GcTableRequest,
@@ -24,6 +25,9 @@ use api::v1::meta::{
ReconcileRequest, ReconcileResponse, RequestHeader, ResponseHeader, Role,
};
use common_grpc::channel_manager::ChannelManager;
use common_meta::rpc::ddl::{
CREATE_DATABASE_CREATOR_EXTENSION_KEY, CREATE_DATABASE_CREATOR_METADATA_KEY,
};
use common_meta::rpc::procedure::{
GcRegionsRequest as MetaGcRegionsRequest, GcResponse as MetaGcResponse,
GcTableRequest as MetaGcTableRequest,
@@ -377,6 +381,7 @@ impl Inner {
}
async fn submit_ddl_task(&self, mut req: DdlTaskRequest) -> Result<DdlTaskResponse> {
let creator = create_database_creator_metadata_value(&req);
req.set_header(
self.id,
self.role,
@@ -388,6 +393,12 @@ impl Inner {
"submit ddl task",
move |mut client| {
let mut req = Request::new(req.clone());
if let Some(value) = creator.as_deref() {
req.metadata_mut().insert_bin(
CREATE_DATABASE_CREATOR_METADATA_KEY,
tonic::metadata::MetadataValue::from_bytes(value.as_bytes()),
);
}
req.set_timeout(timeout);
async move { client.ddl(req).await.map(|res| res.into_inner()) }
},
@@ -417,6 +428,19 @@ impl Inner {
}
}
fn create_database_creator_metadata_value(req: &DdlTaskRequest) -> Option<String> {
// StatementExecutor removes client values before attaching the authenticated creator.
if !matches!(req.task, Some(Task::CreateDatabaseTask(_))) {
return None;
}
req.query_context
.as_ref()?
.extensions
.get(CREATE_DATABASE_CREATOR_EXTENSION_KEY)
.cloned()
}
fn gc_timeout_secs(timeout: Option<Duration>) -> u32 {
timeout
.map(|timeout| timeout.as_secs().max(1).try_into().unwrap_or(u32::MAX))
@@ -439,11 +463,14 @@ mod tests {
use async_trait::async_trait;
use common_error::status_code::StatusCode;
use common_meta::rpc::ddl::{
CommentObjectType, CommentOnTask, DdlTask, QueryContext, SubmitDdlTaskRequest,
CREATE_DATABASE_CREATOR_EXTENSION_KEY, CREATE_DATABASE_CREATOR_METADATA_KEY,
CommentObjectType, CommentOnTask, CreatorGrantIntent, DdlTask, QueryContext,
SubmitDdlTaskRequest,
};
use common_telemetry::common_error::ext::ErrorExt;
use common_telemetry::info;
use tokio::net::TcpListener;
use tokio::sync::mpsc;
use tokio_stream::wrappers::{ReceiverStream, TcpListenerStream};
use tonic::codec::CompressionEncoding;
use tonic::{Request, Response, Status};
@@ -498,6 +525,7 @@ mod tests {
#[derive(Clone)]
struct MockProcedure {
delay: Duration,
request_tx: Option<mpsc::UnboundedSender<Request<DdlTaskRequest>>>,
}
#[async_trait]
@@ -511,8 +539,11 @@ mod tests {
async fn ddl(
&self,
_request: Request<DdlTaskRequest>,
request: Request<DdlTaskRequest>,
) -> Result<Response<DdlTaskResponse>, Status> {
if let Some(request_tx) = &self.request_tx {
request_tx.send(request).unwrap();
}
tokio::time::sleep(self.delay).await;
Ok(Response::new(DdlTaskResponse {
header: Some(ResponseHeader {
@@ -559,6 +590,70 @@ mod tests {
}
}
#[tokio::test(flavor = "multi_thread")]
async fn test_meta_client_forwards_create_database_creator_metadata() {
let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr_str = listener.local_addr().unwrap().to_string();
let (request_tx, mut request_rx) = mpsc::unbounded_channel();
let heartbeat = MockHeartbeat {
leader_addr: addr_str.clone(),
};
let procedure = MockProcedure {
delay: Duration::ZERO,
request_tx: Some(request_tx),
};
let server = tonic::transport::Server::builder()
.add_service(
HeartbeatServer::new(heartbeat).accept_compressed(CompressionEncoding::Zstd),
)
.add_service(
ProcedureServiceServer::new(procedure).accept_compressed(CompressionEncoding::Zstd),
)
.serve_with_incoming(TcpListenerStream::new(listener));
let server_handle = tokio::spawn(server);
let mut client = MetaClientBuilder::new(0, Role::Frontend)
.enable_heartbeat()
.enable_procedure()
.build();
client.start(&[addr_str.as_str()]).await.unwrap();
let creator = CreatorGrantIntent {
username: "alice".to_string(),
created_at_ns: 42,
};
client
.submit_ddl_task(SubmitDdlTaskRequest::new(
QueryContext::default(),
DdlTask::new_create_database(
"greptime".to_string(),
"metrics".to_string(),
false,
Default::default(),
Some(creator.clone()),
),
))
.await
.unwrap();
let request = request_rx.recv().await.unwrap();
let encoded = serde_json::to_string(&creator).unwrap();
assert_eq!(
request
.metadata()
.get_bin(CREATE_DATABASE_CREATOR_METADATA_KEY)
.unwrap()
.to_bytes()
.unwrap()
.as_ref(),
encoded.as_bytes()
);
let extensions = &request.into_inner().query_context.unwrap().extensions;
assert_eq!(extensions[CREATE_DATABASE_CREATOR_EXTENSION_KEY], encoded);
server_handle.abort();
}
#[tokio::test(flavor = "multi_thread")]
async fn test_meta_client_ddl_request_timeout() {
common_telemetry::init_default_ut_logging();
@@ -572,6 +667,7 @@ mod tests {
};
let procedure = MockProcedure {
delay: Duration::from_secs(4),
request_tx: None,
};
let server = tonic::transport::Server::builder()
+5 -1
View File
@@ -432,6 +432,7 @@ impl MetasrvBuilder {
region_failure_detector_controller,
soft_drop_enabled: ddl_soft_drop_enabled(&options),
soft_drop_retention: ddl_soft_drop_retention(&options),
create_database_metadata_committer: None,
};
let procedure_manager_c = procedure_manager.clone();
let repartition_procedure_factory: RepartitionProcedureFactoryRef = if options.gc.enable {
@@ -449,7 +450,7 @@ impl MetasrvBuilder {
ddl_context,
procedure_manager_c,
repartition_procedure_factory,
true,
false,
)
.context(error::InitDdlManagerSnafu)?;
@@ -468,6 +469,9 @@ impl MetasrvBuilder {
} else {
ddl_manager
};
ddl_manager
.register_loaders()
.context(error::InitDdlManagerSnafu)?;
let ddl_manager = Arc::new(ddl_manager);
+1
View File
@@ -548,6 +548,7 @@ pub mod test_data {
region_failure_detector_controller: Arc::new(NoopRegionFailureDetectorControl),
soft_drop_enabled: false,
soft_drop_retention: None,
create_database_metadata_committer: None,
}
}
}
+195 -7
View File
@@ -20,12 +20,15 @@ use api::v1::meta::{
GcRegionsResponse, GcStats, GcTableRequest, GcTableResponse, MigrateRegionRequest,
MigrateRegionResponse, ProcedureDetailRequest, ProcedureDetailResponse, ProcedureStateResponse,
QueryProcedureRequest, ReconcileCatalog, ReconcileDatabase, ReconcileRequest,
ReconcileResponse, ReconcileTable, ResolveStrategy, procedure_service_server,
ReconcileResponse, ReconcileTable, ResolveStrategy, Role, procedure_service_server,
};
use common_meta::key::TableMetadataManagerRef;
use common_meta::key::table_name::TableNameKey;
use common_meta::procedure_executor::ExecutorContext;
use common_meta::rpc::ddl::{DdlTask, SubmitDdlTaskRequest};
use common_meta::rpc::ddl::{
CREATE_DATABASE_CREATOR_EXTENSION_KEY, CREATE_DATABASE_CREATOR_METADATA_KEY,
CreatorGrantIntent, DdlTask, QueryContext, SubmitDdlTaskRequest,
};
use common_meta::rpc::procedure::{
self, GcRegionsRequest as MetaGcRegionsRequest, GcResponse,
GcTableRequest as MetaGcTableRequest,
@@ -33,7 +36,8 @@ use common_meta::rpc::procedure::{
use snafu::{OptionExt, ResultExt};
use store_api::storage::RegionId;
use table::table_reference::TableReference;
use tonic::Request;
use tonic::metadata::MetadataMap;
use tonic::{Request, Status};
use crate::error::{TableMetadataManagerSnafu, TableNotFoundSnafu};
use crate::metasrv::Metasrv;
@@ -78,24 +82,26 @@ impl procedure_service_server::ProcedureService for Metasrv {
async fn ddl(&self, request: Request<PbDdlTaskRequest>) -> GrpcResult<PbDdlTaskResponse> {
check_leader!(self, request, PbDdlTaskResponse, "`ddl`");
let (metadata, _, request) = request.into_parts();
let PbDdlTaskRequest {
header,
query_context,
task,
wait,
timeout_secs,
} = request.into_inner();
} = request;
let header = header.context(error::MissingRequestHeaderSnafu)?;
let query_context = query_context
let mut query_context = query_context
.context(error::MissingRequiredParameterSnafu {
param: "query_context",
})?
.into();
let task: DdlTask = task
let mut task: DdlTask = task
.context(error::MissingRequiredParameterSnafu { param: "task" })?
.try_into()
.context(error::ConvertProtoDataSnafu)?;
restore_create_database_creator(&metadata, header.role, &mut task, &mut query_context)?;
let resp = self
.ddl_manager()
@@ -303,6 +309,54 @@ impl procedure_service_server::ProcedureService for Metasrv {
}
}
fn restore_create_database_creator(
metadata: &MetadataMap,
role: i32,
task: &mut DdlTask,
query_context: &mut QueryContext,
) -> Result<(), Status> {
// The body copy makes metadata loss fail closed; old frontends provide no matching
// internal metadata and cannot turn public hints into trusted creator context.
let forwarded = query_context
.extensions
.remove(CREATE_DATABASE_CREATOR_EXTENSION_KEY);
let internal = metadata
.get_bin(CREATE_DATABASE_CREATOR_METADATA_KEY)
.map(|value| {
value
.to_bytes()
.map_err(|_| Status::invalid_argument("Invalid internal creator metadata"))
})
.transpose()?;
let (forwarded, internal) = match (forwarded, internal) {
(None, None) => return Ok(()),
(Some(forwarded), Some(internal)) => (forwarded, internal),
_ => {
return Err(Status::invalid_argument(
"Untrusted create-database creator context",
));
}
};
let DdlTask::CreateDatabase(task) = task else {
return Err(Status::invalid_argument(
"Untrusted create-database creator context",
));
};
if Role::try_from(role) != Ok(Role::Frontend) || forwarded.as_bytes() != internal.as_ref() {
return Err(Status::invalid_argument(
"Untrusted create-database creator context",
));
}
task.creator = Some(
serde_json::from_str::<CreatorGrantIntent>(&forwarded)
.map_err(|_| Status::invalid_argument("Invalid internal creator metadata"))?,
);
Ok(())
}
impl Metasrv {
fn normalize_gc_timeout(timeout: Duration) -> Option<Duration> {
if timeout.is_zero() {
@@ -443,7 +497,46 @@ fn gc_response_to_table_pb(resp: GcResponse) -> GcTableResponse {
mod tests {
use std::time::Duration;
use super::Metasrv;
use api::v1::meta::Role;
use common_meta::rpc::ddl::{
CREATE_DATABASE_CREATOR_EXTENSION_KEY, CREATE_DATABASE_CREATOR_METADATA_KEY,
CreatorGrantIntent, DdlTask, QueryContext,
};
use tonic::metadata::{MetadataMap, MetadataValue};
use super::{Metasrv, restore_create_database_creator};
fn create_database_task() -> DdlTask {
DdlTask::new_create_database(
"greptime".to_string(),
"metrics".to_string(),
false,
Default::default(),
None,
)
}
fn creator_context(creator: Option<&str>) -> QueryContext {
let mut context = QueryContext::default();
if let Some(creator) = creator {
context.extensions.insert(
CREATE_DATABASE_CREATOR_EXTENSION_KEY.to_string(),
creator.to_string(),
);
}
context
}
fn creator_metadata(creator: Option<&str>) -> MetadataMap {
let mut metadata = MetadataMap::new();
if let Some(creator) = creator {
metadata.insert_bin(
CREATE_DATABASE_CREATOR_METADATA_KEY,
MetadataValue::from_bytes(creator.as_bytes()),
);
}
metadata
}
#[test]
fn test_normalize_gc_timeout() {
@@ -453,4 +546,99 @@ mod tests {
Some(Duration::from_secs(10))
);
}
#[test]
fn test_restore_create_database_creator_requires_matching_internal_metadata() {
let mut task = create_database_task();
let mut legacy = QueryContext::default();
restore_create_database_creator(
&MetadataMap::new(),
Role::Frontend as i32,
&mut task,
&mut legacy,
)
.unwrap();
let creator = CreatorGrantIntent {
username: "alice".to_string(),
created_at_ns: 42,
};
let encoded = serde_json::to_string(&creator).unwrap();
let other = serde_json::to_string(&CreatorGrantIntent {
username: "mallory".to_string(),
created_at_ns: 99,
})
.unwrap();
for (name, body, metadata, role, create_database) in [
(
"body only",
Some(encoded.as_str()),
None,
Role::Frontend,
true,
),
(
"metadata only",
None,
Some(encoded.as_str()),
Role::Frontend,
true,
),
(
"mismatch",
Some(other.as_str()),
Some(encoded.as_str()),
Role::Frontend,
true,
),
("malformed", Some("{"), Some("{"), Role::Frontend, true),
(
"wrong role",
Some(encoded.as_str()),
Some(encoded.as_str()),
Role::Datanode,
true,
),
(
"wrong task",
Some(encoded.as_str()),
Some(encoded.as_str()),
Role::Frontend,
false,
),
] {
let mut task = if create_database {
create_database_task()
} else {
DdlTask::new_drop_database("greptime".to_string(), "metrics".to_string(), false)
};
let mut context = creator_context(body);
assert!(
restore_create_database_creator(
&creator_metadata(metadata),
role as i32,
&mut task,
&mut context,
)
.is_err(),
"{name} must fail closed"
);
}
let mut task = create_database_task();
let mut trusted = creator_context(Some(&encoded));
restore_create_database_creator(
&creator_metadata(Some(&encoded)),
Role::Frontend as i32,
&mut task,
&mut trusted,
)
.unwrap();
let DdlTask::CreateDatabase(task) = task else {
unreachable!();
};
assert_eq!(task.creator, Some(creator));
assert!(trusted.extensions.is_empty());
}
}
+29
View File
@@ -45,6 +45,8 @@ use common_meta::key::view_info::{ViewInfoManager, ViewInfoManagerRef};
use common_meta::key::{TableMetadataManager, TableMetadataManagerRef};
use common_meta::kv_backend::KvBackendRef;
use common_meta::procedure_executor::ProcedureExecutorRef;
#[cfg(feature = "enterprise")]
use common_meta::rpc::ddl::CreatorGrantIntent;
use common_query::Output;
use common_telemetry::{debug, tracing, warn};
use common_time::Timestamp;
@@ -101,6 +103,23 @@ pub trait StatementExecutorConfigurator: Send + Sync {
pub type StatementExecutorConfiguratorRef = Arc<dyn StatementExecutorConfigurator>;
#[cfg(feature = "enterprise")]
#[async_trait::async_trait]
pub trait CreateDatabaseHandler: Send + Sync {
fn creator(
&self,
query_ctx: &QueryContextRef,
) -> std::result::Result<Option<CreatorGrantIntent>, BoxedError>;
async fn refresh_current_user(
&self,
query_ctx: &QueryContextRef,
) -> std::result::Result<(), BoxedError>;
}
#[cfg(feature = "enterprise")]
pub type CreateDatabaseHandlerRef = Arc<dyn CreateDatabaseHandler>;
pub struct ExecutorConfigureContext {
pub kv_backend: KvBackendRef,
}
@@ -119,6 +138,8 @@ pub struct StatementExecutor {
process_manager: Option<ProcessManagerRef>,
origin_frontend_addr: String,
#[cfg(feature = "enterprise")]
create_database_handler: Option<CreateDatabaseHandlerRef>,
#[cfg(feature = "enterprise")]
trigger_querier: Option<TriggerQuerierRef>,
}
@@ -168,6 +189,8 @@ impl StatementExecutor {
process_manager,
origin_frontend_addr,
#[cfg(feature = "enterprise")]
create_database_handler: None,
#[cfg(feature = "enterprise")]
trigger_querier: None,
}
}
@@ -178,6 +201,12 @@ impl StatementExecutor {
self
}
#[cfg(feature = "enterprise")]
pub fn with_create_database_handler(mut self, handler: CreateDatabaseHandlerRef) -> Self {
self.create_database_handler = Some(handler);
self
}
#[cfg(feature = "testing")]
pub async fn execute_stmt(
&self,
+27 -7
View File
@@ -47,7 +47,7 @@ use common_meta::rpc::ddl::trigger::CreateTriggerTask;
#[cfg(feature = "enterprise")]
use common_meta::rpc::ddl::trigger::DropTriggerTask;
use common_meta::rpc::ddl::{
CreateFlowTask, DdlTask, DropFlowTask, DropViewTask, SubmitDdlTaskRequest,
CreateFlowTask, CreatorGrantIntent, DdlTask, DropFlowTask, DropViewTask, SubmitDdlTaskRequest,
SubmitDdlTaskResponse,
};
use common_query::Output;
@@ -2138,7 +2138,15 @@ impl StatementExecutor {
}
);
if !self
#[cfg(feature = "enterprise")]
let creator = match &self.create_database_handler {
Some(handler) => handler.creator(&query_context).context(ExternalSnafu)?,
None => None,
};
#[cfg(not(feature = "enterprise"))]
let creator = None;
let output = if !self
.catalog_manager
.schema_exists(catalog, database, None)
.await
@@ -2150,16 +2158,27 @@ impl StatementExecutor {
database.to_string(),
create_if_not_exists,
options,
query_context,
query_context.clone(),
creator,
)
.await?;
Ok(Output::new_with_affected_rows(1))
Output::new_with_affected_rows(1)
} else if create_if_not_exists {
Ok(Output::new_with_affected_rows(1))
Output::new_with_affected_rows(1)
} else {
error::SchemaExistsSnafu { name: database }.fail()
return error::SchemaExistsSnafu { name: database }.fail();
};
#[cfg(feature = "enterprise")]
if let Some(handler) = &self.create_database_handler {
handler
.refresh_current_user(&query_context)
.await
.context(ExternalSnafu)?;
}
Ok(output)
}
async fn create_database_procedure(
@@ -2169,10 +2188,11 @@ impl StatementExecutor {
create_if_not_exists: bool,
options: HashMap<String, String>,
query_context: QueryContextRef,
creator: Option<CreatorGrantIntent>,
) -> Result<SubmitDdlTaskResponse> {
let request = SubmitDdlTaskRequest::new(
to_meta_query_context(query_context),
DdlTask::new_create_database(catalog, database, create_if_not_exists, options),
DdlTask::new_create_database(catalog, database, create_if_not_exists, options, creator),
);
self.procedure_executor
+1
View File
@@ -252,6 +252,7 @@ impl GreptimeDbStandaloneBuilder {
region_failure_detector_controller: Arc::new(NoopRegionFailureDetectorControl),
soft_drop_enabled: false,
soft_drop_retention: None,
create_database_metadata_committer: None,
},
procedure_manager.clone(),
repartition_procedure_factory,