frontend/
frontend.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;
16
17use common_base::readable_size::ReadableSize;
18use common_config::config::Configurable;
19use common_event_recorder::EventRecorderOptions;
20use common_options::datanode::DatanodeClientOptions;
21use common_options::memory::MemoryOptions;
22use common_telemetry::logging::{LoggingOptions, SlowQueryOptions, TracingOptions};
23use meta_client::MetaClientOptions;
24use query::options::QueryOptions;
25use serde::{Deserialize, Serialize};
26use servers::grpc::GrpcOptions;
27use servers::heartbeat_options::HeartbeatOptions;
28use servers::http::HttpOptions;
29use servers::server::ServerHandlers;
30use snafu::ResultExt;
31
32use crate::error;
33use crate::error::Result;
34use crate::heartbeat::HeartbeatTask;
35use crate::instance::Instance;
36use crate::service_config::{
37    InfluxdbOptions, JaegerOptions, MysqlOptions, OpentsdbOptions, OtlpOptions, PostgresOptions,
38    PromStoreOptions,
39};
40
41#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
42#[serde(default)]
43pub struct FrontendOptions {
44    pub node_id: Option<String>,
45    pub default_timezone: Option<String>,
46    pub default_column_prefix: Option<String>,
47    pub heartbeat: HeartbeatOptions,
48    pub http: HttpOptions,
49    pub grpc: GrpcOptions,
50    /// The internal gRPC options for the frontend service.
51    /// it provide the same service as the public gRPC service, just only for internal use.
52    pub internal_grpc: Option<GrpcOptions>,
53    pub mysql: MysqlOptions,
54    pub postgres: PostgresOptions,
55    pub opentsdb: OpentsdbOptions,
56    pub influxdb: InfluxdbOptions,
57    pub prom_store: PromStoreOptions,
58    pub jaeger: JaegerOptions,
59    pub otlp: OtlpOptions,
60    pub meta_client: Option<MetaClientOptions>,
61    pub logging: LoggingOptions,
62    pub datanode: DatanodeClientOptions,
63    pub user_provider: Option<String>,
64    pub tracing: TracingOptions,
65    pub query: QueryOptions,
66    pub max_in_flight_write_bytes: Option<ReadableSize>,
67    pub slow_query: SlowQueryOptions,
68    pub memory: MemoryOptions,
69    /// The event recorder options.
70    pub event_recorder: EventRecorderOptions,
71}
72
73impl Default for FrontendOptions {
74    fn default() -> Self {
75        Self {
76            node_id: None,
77            default_timezone: None,
78            default_column_prefix: None,
79            heartbeat: HeartbeatOptions::frontend_default(),
80            http: HttpOptions::default(),
81            grpc: GrpcOptions::default(),
82            internal_grpc: None,
83            mysql: MysqlOptions::default(),
84            postgres: PostgresOptions::default(),
85            opentsdb: OpentsdbOptions::default(),
86            influxdb: InfluxdbOptions::default(),
87            jaeger: JaegerOptions::default(),
88            prom_store: PromStoreOptions::default(),
89            otlp: OtlpOptions::default(),
90            meta_client: None,
91            logging: LoggingOptions::default(),
92            datanode: DatanodeClientOptions::default(),
93            user_provider: None,
94            tracing: TracingOptions::default(),
95            query: QueryOptions::default(),
96            max_in_flight_write_bytes: None,
97            slow_query: SlowQueryOptions::default(),
98            memory: MemoryOptions::default(),
99            event_recorder: EventRecorderOptions::default(),
100        }
101    }
102}
103
104impl Configurable for FrontendOptions {
105    fn env_list_keys() -> Option<&'static [&'static str]> {
106        Some(&["meta_client.metasrv_addrs"])
107    }
108}
109
110/// The [`Frontend`] struct is the main entry point for the frontend service
111/// which contains server handlers, frontend instance and some background tasks.
112pub struct Frontend {
113    pub instance: Arc<Instance>,
114    pub servers: ServerHandlers,
115    pub heartbeat_task: Option<HeartbeatTask>,
116}
117
118impl Frontend {
119    pub async fn start(&mut self) -> Result<()> {
120        if let Some(t) = &self.heartbeat_task {
121            t.start().await?;
122        }
123
124        self.servers
125            .start_all()
126            .await
127            .context(error::StartServerSnafu)
128    }
129
130    pub async fn shutdown(&mut self) -> Result<()> {
131        self.servers
132            .shutdown_all()
133            .await
134            .context(error::ShutdownServerSnafu)
135    }
136
137    pub fn server_handlers(&self) -> &ServerHandlers {
138        &self.servers
139    }
140}
141
142#[cfg(test)]
143mod tests {
144    use super::*;
145
146    #[test]
147    fn test_toml() {
148        let opts = FrontendOptions::default();
149        let toml_string = toml::to_string(&opts).unwrap();
150        let _parsed: FrontendOptions = toml::from_str(&toml_string).unwrap();
151    }
152}