Skip to main content

frontend/instance/
builder.rs

1// Copyright 2023 Greptime Team
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15use std::sync::Arc;
16use std::sync::atomic::AtomicBool;
17
18use cache::{PARTITION_INFO_CACHE_NAME, TABLE_FLOWNODE_SET_CACHE_NAME, TABLE_ROUTE_CACHE_NAME};
19use catalog::CatalogManagerRef;
20use catalog::kvbackend::KvBackendCatalogManager;
21use catalog::process_manager::ProcessManagerRef;
22use catalog::system_schema::semantic_graph::EntityGraphProviderRef;
23use common_base::Plugins;
24use common_datasource::object_store::LocalFileAccess;
25use common_event_recorder::EventRecorderImpl;
26use common_meta::cache::{LayeredCacheRegistryRef, TableRouteCacheRef};
27use common_meta::cache_invalidator::{CacheInvalidatorRef, DummyCacheInvalidator};
28use common_meta::key::TableMetadataManager;
29use common_meta::key::flow::FlowMetadataManager;
30use common_meta::kv_backend::KvBackendRef;
31use common_meta::node_manager::NodeManagerRef;
32use common_meta::procedure_executor::ProcedureExecutorRef;
33use dashmap::DashMap;
34use operator::delete::Deleter;
35use operator::flow::FlowServiceOperator;
36use operator::insert::Inserter;
37use operator::procedure::ProcedureServiceOperator;
38use operator::request::Requester;
39#[cfg(feature = "enterprise")]
40use operator::statement::CreateDatabaseHandlerRef;
41use operator::statement::{
42    ExecutorConfigureContext, StatementExecutor, StatementExecutorConfiguratorRef,
43    StatementExecutorRef,
44};
45use operator::table::TableMutationOperator;
46use partition::cache::PartitionInfoCacheRef;
47use partition::manager::PartitionRuleManager;
48use pipeline::pipeline_operator::PipelineOperator;
49use query::QueryEngineFactory;
50use query::region_query::RegionQueryHandlerFactoryRef;
51use snafu::{OptionExt, ResultExt};
52
53use crate::error::{self, DataFusionSnafu, ExternalSnafu, Result};
54use crate::events::EventHandlerImpl;
55use crate::frontend::FrontendOptions;
56use crate::heartbeat::frontend_peer_addr;
57use crate::instance::Instance;
58use crate::instance::entity_graph::EntityGraphProviderImpl;
59use crate::instance::region_query::FrontendRegionQueryHandler;
60
61/// The frontend [`Instance`] builder.
62pub struct FrontendBuilder {
63    options: FrontendOptions,
64    kv_backend: KvBackendRef,
65    layered_cache_registry: LayeredCacheRegistryRef,
66    local_cache_invalidator: Option<CacheInvalidatorRef>,
67    catalog_manager: CatalogManagerRef,
68    node_manager: NodeManagerRef,
69    plugins: Option<Plugins>,
70    procedure_executor: ProcedureExecutorRef,
71    process_manager: ProcessManagerRef,
72    local_file_access: LocalFileAccess,
73}
74
75impl FrontendBuilder {
76    #[allow(clippy::too_many_arguments)]
77    pub fn new(
78        options: FrontendOptions,
79        kv_backend: KvBackendRef,
80        layered_cache_registry: LayeredCacheRegistryRef,
81        catalog_manager: CatalogManagerRef,
82        node_manager: NodeManagerRef,
83        procedure_executor: ProcedureExecutorRef,
84        process_manager: ProcessManagerRef,
85    ) -> Self {
86        Self {
87            options,
88            kv_backend,
89            layered_cache_registry,
90            local_cache_invalidator: None,
91            catalog_manager,
92            node_manager,
93            plugins: None,
94            procedure_executor,
95            process_manager,
96            local_file_access: LocalFileAccess::Disabled,
97        }
98    }
99
100    #[cfg(test)]
101    pub(crate) fn new_test(
102        options: &FrontendOptions,
103        meta_client: meta_client::MetaClientRef,
104    ) -> Self {
105        use cache::{build_fundamental_cache_registry, with_default_composite_cache_registry};
106        use common_meta::cache::LayeredCacheRegistryBuilder;
107        use common_meta::kv_backend::memory::MemoryKvBackend;
108
109        let kv_backend = Arc::new(MemoryKvBackend::new());
110
111        // Builds cache registry
112        let layered_cache_builder = LayeredCacheRegistryBuilder::default();
113        let fundamental_cache_registry = build_fundamental_cache_registry(kv_backend.clone());
114        let layered_cache_registry = Arc::new(
115            with_default_composite_cache_registry(
116                layered_cache_builder.add_cache_registry(fundamental_cache_registry),
117            )
118            .unwrap()
119            .build(),
120        );
121
122        Self::new(
123            options.clone(),
124            kv_backend,
125            layered_cache_registry,
126            catalog::memory::MemoryCatalogManager::with_default_setup(),
127            Arc::new(client::client_manager::NodeClients::default()),
128            meta_client,
129            Arc::new(catalog::process_manager::ProcessManager::new(
130                "".to_string(),
131                None,
132            )),
133        )
134    }
135
136    pub fn with_local_cache_invalidator(self, cache_invalidator: CacheInvalidatorRef) -> Self {
137        Self {
138            local_cache_invalidator: Some(cache_invalidator),
139            ..self
140        }
141    }
142
143    pub fn with_local_file_access(mut self, local_file_access: LocalFileAccess) -> Self {
144        self.local_file_access = local_file_access;
145        self
146    }
147
148    pub fn options(&self) -> &FrontendOptions {
149        &self.options
150    }
151
152    pub fn kv_backend(&self) -> &KvBackendRef {
153        &self.kv_backend
154    }
155
156    pub fn layered_cache_registry(&self) -> &LayeredCacheRegistryRef {
157        &self.layered_cache_registry
158    }
159
160    pub fn catalog_manager(&self) -> &CatalogManagerRef {
161        &self.catalog_manager
162    }
163
164    pub fn node_manager(&self) -> &NodeManagerRef {
165        &self.node_manager
166    }
167
168    pub fn procedure_executor(&self) -> &ProcedureExecutorRef {
169        &self.procedure_executor
170    }
171
172    pub fn process_manager(&self) -> &ProcessManagerRef {
173        &self.process_manager
174    }
175
176    pub fn with_plugin(self, plugins: Plugins) -> Self {
177        Self {
178            plugins: Some(plugins),
179            ..self
180        }
181    }
182
183    pub async fn try_build(self) -> Result<Instance> {
184        let kv_backend = self.kv_backend;
185        let node_manager = self.node_manager;
186        let plugins = self.plugins.unwrap_or_default();
187        let process_manager = self.process_manager;
188        let table_route_cache: TableRouteCacheRef =
189            self.layered_cache_registry
190                .get()
191                .context(error::CacheRequiredSnafu {
192                    name: TABLE_ROUTE_CACHE_NAME,
193                })?;
194        let partition_info_cache: PartitionInfoCacheRef = self
195            .layered_cache_registry
196            .get()
197            .context(error::CacheRequiredSnafu {
198                name: PARTITION_INFO_CACHE_NAME,
199            })?;
200        let partition_manager = Arc::new(PartitionRuleManager::new(
201            kv_backend.clone(),
202            table_route_cache.clone(),
203            partition_info_cache.clone(),
204        ));
205
206        let local_cache_invalidator = self
207            .local_cache_invalidator
208            .unwrap_or_else(|| Arc::new(DummyCacheInvalidator));
209
210        let region_query_handler =
211            if let Some(factory) = plugins.get::<RegionQueryHandlerFactoryRef>() {
212                factory.build(partition_manager.clone(), node_manager.clone())
213            } else {
214                FrontendRegionQueryHandler::arc(partition_manager.clone(), node_manager.clone())
215            };
216
217        let table_flownode_cache =
218            self.layered_cache_registry
219                .get()
220                .context(error::CacheRequiredSnafu {
221                    name: TABLE_FLOWNODE_SET_CACHE_NAME,
222                })?;
223
224        let inserter = Arc::new(Inserter::new(
225            self.catalog_manager.clone(),
226            partition_manager.clone(),
227            node_manager.clone(),
228            table_flownode_cache,
229            self.options.auto_create_table,
230        ));
231        let deleter = Arc::new(Deleter::new(
232            self.catalog_manager.clone(),
233            partition_manager.clone(),
234            node_manager.clone(),
235        ));
236        let requester = Arc::new(Requester::new(
237            self.catalog_manager.clone(),
238            partition_manager.clone(),
239            node_manager.clone(),
240        ));
241        let table_mutation_handler = Arc::new(TableMutationOperator::new(
242            inserter.clone(),
243            deleter.clone(),
244            requester,
245        ));
246
247        let table_metadata_manager = Arc::new(TableMetadataManager::new(kv_backend.clone()));
248        let procedure_service_handler = Arc::new(ProcedureServiceOperator::new(
249            self.procedure_executor.clone(),
250            self.catalog_manager.clone(),
251            table_metadata_manager.clone(),
252        ));
253
254        let flow_metadata_manager: Arc<FlowMetadataManager> =
255            Arc::new(FlowMetadataManager::new(kv_backend.clone()));
256        let flow_service = FlowServiceOperator::new(flow_metadata_manager, node_manager.clone());
257
258        let mut query_options = self.options.query.clone();
259        query_options.enable_per_region_metrics = self.options.logging.enable_per_region_metrics;
260        let query_engine = QueryEngineFactory::try_new_with_plugins(
261            self.catalog_manager.clone(),
262            Some(partition_manager.clone()),
263            Some(region_query_handler.clone()),
264            Some(table_mutation_handler),
265            Some(procedure_service_handler),
266            Some(Arc::new(flow_service)),
267            true,
268            plugins.clone(),
269            query_options,
270        )
271        .context(DataFusionSnafu)?
272        .query_engine();
273
274        // Inject the entity-graph provider now that the query engine exists, so the
275        // computed `greptime_private.semantic_entities` / `semantic_relationships`
276        // tables can derive rows. Late binding here breaks the `catalog -> query`
277        // dependency cycle.
278        if let Some(kv_catalog) = self
279            .catalog_manager
280            .as_any()
281            .downcast_ref::<KvBackendCatalogManager>()
282        {
283            let provider: EntityGraphProviderRef = Arc::new(EntityGraphProviderImpl::new(
284                query_engine.clone(),
285                Arc::downgrade(&self.catalog_manager),
286            ));
287            kv_catalog.set_entity_graph_provider(provider);
288        }
289
290        let frontend_peer_addr = frontend_peer_addr(&self.options);
291        let statement_executor = StatementExecutor::new(
292            self.catalog_manager.clone(),
293            query_engine.clone(),
294            self.procedure_executor,
295            kv_backend.clone(),
296            local_cache_invalidator,
297            inserter.clone(),
298            partition_manager,
299            Some(process_manager.clone()),
300            frontend_peer_addr.clone(),
301            self.local_file_access,
302        );
303
304        let statement_executor =
305            if let Some(configurator) = plugins.get::<StatementExecutorConfiguratorRef>() {
306                let ctx = ExecutorConfigureContext {
307                    kv_backend: kv_backend.clone(),
308                };
309                configurator
310                    .configure(statement_executor, ctx)
311                    .await
312                    .context(ExternalSnafu)?
313            } else {
314                statement_executor
315            };
316
317        #[cfg(feature = "enterprise")]
318        let statement_executor = if let Some(handler) = plugins.get::<CreateDatabaseHandlerRef>() {
319            statement_executor.with_create_database_handler(handler)
320        } else {
321            statement_executor
322        };
323
324        let statement_executor = Arc::new(statement_executor);
325
326        let pipeline_operator = Arc::new(PipelineOperator::new(
327            inserter.clone(),
328            statement_executor.clone(),
329            self.catalog_manager.clone(),
330            query_engine.clone(),
331        ));
332
333        plugins.insert::<StatementExecutorRef>(statement_executor.clone());
334
335        let slow_query_recorder = Arc::new(EventRecorderImpl::new(Box::new(
336            EventHandlerImpl::new(statement_executor.clone(), self.options.slow_query.ttl),
337        )));
338        let event_recorder = Arc::new(EventRecorderImpl::with_event_type_filter(
339            Box::new(EventHandlerImpl::new(
340                statement_executor.clone(),
341                self.options.event_recorder.ttl,
342            )),
343            self.options.event_recorder.event_types.clone(),
344        ));
345
346        Ok(Instance {
347            frontend_peer_addr,
348            catalog_manager: self.catalog_manager,
349            pipeline_operator,
350            statement_executor,
351            query_engine,
352            plugins,
353            inserter,
354            deleter,
355            table_metadata_manager,
356            event_recorder,
357            slow_query_recorder,
358            process_manager,
359            otlp_metrics_table_legacy_cache: DashMap::new(),
360            slow_query_options: self.options.slow_query.clone(),
361            influxdb_default_merge_mode: self.options.influxdb.default_merge_mode,
362            trace_ingest_chunk_size: self.options.otlp.trace_ingest_chunk_size,
363            suspend: Arc::new(AtomicBool::new(false)),
364        })
365    }
366}