Skip to main content

risedev/
service_config.rs

1// Copyright 2022 RisingWave Labs
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 serde::{Deserialize, Serialize};
16
17#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
18#[serde(rename_all = "kebab-case")]
19#[serde(deny_unknown_fields)]
20pub struct ComputeNodeConfig {
21    #[serde(rename = "use")]
22    phantom_use: Option<String>,
23    pub id: String,
24
25    pub address: String,
26    #[serde(with = "string")]
27    pub port: u16,
28    pub listen_address: String,
29    pub exporter_port: u16,
30    pub async_stack_trace: String,
31    pub enable_tiered_cache: bool,
32
33    pub provide_minio: Option<Vec<MinioConfig>>,
34    pub provide_meta_node: Option<Vec<MetaNodeConfig>>,
35    pub provide_compute_node: Option<Vec<ComputeNodeConfig>>,
36    pub provide_opendal: Option<Vec<OpendalConfig>>,
37    pub provide_aws_s3: Option<Vec<AwsS3Config>>,
38    pub provide_moat: Option<Vec<MoatConfig>>,
39    pub provide_tempo: Option<Vec<TempoConfig>>,
40    pub user_managed: bool,
41    pub resource_group: String,
42
43    pub total_memory_bytes: usize,
44    pub parallelism: usize,
45    pub role: String,
46}
47
48#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
49#[serde(rename_all = "kebab-case")]
50#[serde(deny_unknown_fields)]
51pub enum MetaBackend {
52    Memory,
53    Sqlite,
54    Postgres,
55    Mysql,
56    Env,
57}
58
59#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
60#[serde(rename_all = "kebab-case")]
61#[serde(deny_unknown_fields)]
62pub struct MetaNodeConfig {
63    #[serde(rename = "use")]
64    phantom_use: Option<String>,
65    pub id: String,
66
67    pub address: String,
68    #[serde(with = "string")]
69    pub port: u16,
70    pub listen_address: String,
71    pub dashboard_port: u16,
72    pub exporter_port: u16,
73
74    pub user_managed: bool,
75
76    pub meta_backend: MetaBackend,
77    pub provide_sqlite_backend: Option<Vec<SqliteConfig>>,
78    pub provide_postgres_backend: Option<Vec<PostgresConfig>>,
79    pub provide_mysql_backend: Option<Vec<MySqlConfig>>,
80    pub provide_prometheus: Option<Vec<PrometheusConfig>>,
81
82    pub provide_compute_node: Option<Vec<ComputeNodeConfig>>,
83    pub provide_compactor: Option<Vec<CompactorConfig>>,
84
85    pub provide_tempo: Option<Vec<TempoConfig>>,
86
87    pub provide_aws_s3: Option<Vec<AwsS3Config>>,
88    pub provide_minio: Option<Vec<MinioConfig>>,
89    pub provide_opendal: Option<Vec<OpendalConfig>>,
90    pub provide_moat: Option<Vec<MoatConfig>>,
91}
92
93#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
94#[serde(rename_all = "kebab-case")]
95#[serde(deny_unknown_fields)]
96pub struct FrontendConfig {
97    #[serde(rename = "use")]
98    phantom_use: Option<String>,
99    pub id: String,
100
101    pub address: String,
102    #[serde(with = "string")]
103    pub port: u16,
104    pub listen_address: String,
105    pub exporter_port: u16,
106    pub health_check_port: u16,
107
108    pub provide_meta_node: Option<Vec<MetaNodeConfig>>,
109    pub provide_tempo: Option<Vec<TempoConfig>>,
110    pub provide_prometheus: Option<Vec<PrometheusConfig>>,
111
112    pub user_managed: bool,
113}
114
115#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
116#[serde(rename_all = "kebab-case")]
117#[serde(deny_unknown_fields)]
118pub struct CompactorConfig {
119    #[serde(rename = "use")]
120    phantom_use: Option<String>,
121    pub id: String,
122
123    pub address: String,
124    #[serde(with = "string")]
125    pub port: u16,
126    pub listen_address: String,
127    pub exporter_port: u16,
128
129    pub provide_minio: Option<Vec<MinioConfig>>,
130
131    pub provide_meta_node: Option<Vec<MetaNodeConfig>>,
132    pub provide_tempo: Option<Vec<TempoConfig>>,
133
134    pub user_managed: bool,
135    pub compaction_worker_threads_number: Option<usize>,
136
137    pub compactor_mode: String,
138}
139
140#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
141#[serde(rename_all = "kebab-case")]
142#[serde(deny_unknown_fields)]
143pub struct MinioConfig {
144    #[serde(rename = "use")]
145    phantom_use: Option<String>,
146    pub id: String,
147
148    pub address: String,
149    #[serde(with = "string")]
150    pub port: u16,
151    pub listen_address: String,
152
153    pub console_address: String,
154    #[serde(with = "string")]
155    pub console_port: u16,
156
157    pub root_user: String,
158    pub root_password: String,
159    pub hummock_bucket: String,
160
161    pub provide_prometheus: Option<Vec<PrometheusConfig>>,
162
163    // For rate limiting minio in a test environment.
164    pub api_requests_max: usize,
165    pub api_requests_deadline: String,
166}
167
168#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
169#[serde(rename_all = "kebab-case")]
170#[serde(deny_unknown_fields)]
171pub struct SqliteConfig {
172    #[serde(rename = "use")]
173    phantom_use: Option<String>,
174    pub id: String,
175
176    pub file: String,
177}
178
179#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
180#[serde(rename_all = "kebab-case")]
181#[serde(deny_unknown_fields)]
182pub struct PrometheusConfig {
183    #[serde(rename = "use")]
184    phantom_use: Option<String>,
185    pub id: String,
186
187    pub address: String,
188    #[serde(with = "string")]
189    pub port: u16,
190    pub listen_address: String,
191
192    pub remote_write: bool,
193    pub remote_write_region: String,
194    pub remote_write_url: String,
195
196    pub scrape_interval: String,
197
198    pub provide_compute_node: Option<Vec<ComputeNodeConfig>>,
199    pub provide_meta_node: Option<Vec<MetaNodeConfig>>,
200    pub provide_minio: Option<Vec<MinioConfig>>,
201    pub provide_compactor: Option<Vec<CompactorConfig>>,
202    pub provide_frontend: Option<Vec<FrontendConfig>>,
203}
204
205#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
206#[serde(rename_all = "kebab-case")]
207#[serde(deny_unknown_fields)]
208pub struct GrafanaConfig {
209    #[serde(rename = "use")]
210    phantom_use: Option<String>,
211    pub id: String,
212    pub address: String,
213    pub listen_address: String,
214    pub port: u16,
215
216    pub provide_prometheus: Option<Vec<PrometheusConfig>>,
217    pub provide_tempo: Option<Vec<TempoConfig>>,
218}
219
220#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
221#[serde(rename_all = "kebab-case")]
222#[serde(deny_unknown_fields)]
223pub struct TempoConfig {
224    #[serde(rename = "use")]
225    phantom_use: Option<String>,
226    pub id: String,
227
228    pub listen_address: String,
229    pub address: String,
230    pub port: u16,
231    pub otlp_port: u16,
232    pub max_bytes_per_trace: usize,
233}
234
235#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
236#[serde(rename_all = "kebab-case")]
237#[serde(deny_unknown_fields)]
238pub struct AwsS3Config {
239    #[serde(rename = "use")]
240    phantom_use: Option<String>,
241    pub id: String,
242    pub bucket: String,
243}
244
245#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
246#[serde(rename_all = "kebab-case")]
247#[serde(deny_unknown_fields)]
248pub struct MotoConfig {
249    #[serde(rename = "use")]
250    phantom_use: Option<String>,
251    pub id: String,
252
253    pub address: String,
254    #[serde(with = "string")]
255    pub port: u16,
256
257    pub image: String,
258    pub user_managed: bool,
259
260    pub provide_minio: Option<Vec<MinioConfig>>,
261}
262
263#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
264#[serde(rename_all = "kebab-case")]
265#[serde(deny_unknown_fields)]
266pub struct OpendalConfig {
267    #[serde(rename = "use")]
268    phantom_use: Option<String>,
269
270    pub id: String,
271    pub engine: String,
272    pub namenode: String,
273    pub bucket: String,
274}
275
276#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
277#[serde(rename_all = "kebab-case")]
278#[serde(deny_unknown_fields)]
279pub struct KafkaConfig {
280    #[serde(rename = "use")]
281    phantom_use: Option<String>,
282    pub id: String,
283
284    /// Advertise address
285    pub address: String,
286    #[serde(with = "string")]
287    pub port: u16,
288    /// Port for other services in docker. They need to connect to `host.docker.internal`, while the host
289    /// need to connect to `localhost`.
290    pub docker_port: u16,
291
292    #[serde(with = "string")]
293    pub controller_port: u16,
294
295    pub image: String,
296    pub persist_data: bool,
297    pub node_id: u32,
298
299    pub user_managed: bool,
300}
301
302#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
303#[serde(rename_all = "kebab-case")]
304#[serde(deny_unknown_fields)]
305pub struct SchemaRegistryConfig {
306    #[serde(rename = "use")]
307    phantom_use: Option<String>,
308
309    pub id: String,
310
311    pub address: String,
312    #[serde(with = "string")]
313    pub port: u16,
314
315    pub provide_kafka: Option<Vec<KafkaConfig>>,
316
317    pub image: String,
318    /// Redpanda supports schema registry natively. You can configure a `user_managed` schema registry
319    /// to use with redpanda.
320    pub user_managed: bool,
321}
322
323#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
324#[serde(rename_all = "kebab-case")]
325#[serde(deny_unknown_fields)]
326pub struct PubsubConfig {
327    #[serde(rename = "use")]
328    phantom_use: Option<String>,
329    pub id: String,
330    #[serde(default)]
331    pub user_managed: bool,
332    pub image: String,
333    #[serde(with = "string")]
334    pub port: u16,
335    pub address: String,
336
337    // `--data-dir` only preserves runtime config such as `env.yaml`; it does not
338    // persist topics, subscriptions, or messages across emulator restarts.
339    // https://github.com/risingwavelabs/risingwave/pull/26697#discussion_r3957685142
340    pub persist_data: bool,
341}
342
343#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
344#[serde(rename_all = "kebab-case")]
345#[serde(deny_unknown_fields)]
346pub struct PulsarConfig {
347    #[serde(rename = "use")]
348    phantom_use: Option<String>,
349    pub id: String,
350
351    pub address: String,
352    pub broker_port: u16,
353    pub http_port: u16,
354
355    pub user_managed: bool,
356    pub image: String,
357    pub persist_data: bool,
358}
359
360#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
361#[serde(rename_all = "kebab-case")]
362#[serde(deny_unknown_fields)]
363pub struct RedisConfig {
364    #[serde(rename = "use")]
365    phantom_use: Option<String>,
366    pub id: String,
367
368    pub port: u16,
369    pub address: String,
370
371    pub image: String,
372    pub user_managed: bool,
373    pub persist_data: bool,
374}
375
376#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
377#[serde(rename_all = "kebab-case")]
378#[serde(deny_unknown_fields)]
379pub struct ClickHouseConfig {
380    #[serde(rename = "use")]
381    phantom_use: Option<String>,
382    pub id: String,
383
384    pub address: String,
385    pub http_port: u16,
386    pub native_port: u16,
387
388    pub user: String,
389    pub password: String,
390    pub database: String,
391
392    pub image: String,
393    pub user_managed: bool,
394    pub persist_data: bool,
395}
396
397#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
398#[serde(rename_all = "kebab-case")]
399#[serde(deny_unknown_fields)]
400pub struct DorisConfig {
401    #[serde(rename = "use")]
402    phantom_use: Option<String>,
403    pub id: String,
404
405    pub address: String,
406    pub http_port: u16,
407    pub query_port: u16,
408
409    pub user: String,
410    pub password: String,
411    pub database: String,
412    pub admin_user: String,
413    pub admin_password: String,
414
415    pub image: String,
416    pub user_managed: bool,
417}
418
419#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
420#[serde(rename_all = "kebab-case")]
421#[serde(deny_unknown_fields)]
422pub struct StarrocksConfig {
423    #[serde(rename = "use")]
424    phantom_use: Option<String>,
425    pub id: String,
426
427    pub address: String,
428    pub http_port: u16,
429    pub query_port: u16,
430
431    pub user: String,
432    pub password: String,
433    pub database: String,
434    pub admin_user: String,
435    pub admin_password: String,
436    pub database_is_disposable: bool,
437
438    pub image: String,
439    pub user_managed: bool,
440}
441
442#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
443#[serde(rename_all = "kebab-case")]
444#[serde(deny_unknown_fields)]
445pub enum Application {
446    Metastore,
447    Connector,
448}
449
450#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
451#[serde(rename_all = "kebab-case")]
452#[serde(deny_unknown_fields)]
453pub struct MySqlConfig {
454    #[serde(rename = "use")]
455    phantom_use: Option<String>,
456    pub id: String,
457
458    pub port: u16,
459    pub address: String,
460
461    pub user: String,
462    pub password: String,
463    pub database: String,
464
465    pub application: Application,
466    pub image: String,
467    pub user_managed: bool,
468    pub persist_data: bool,
469}
470
471#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
472#[serde(rename_all = "kebab-case")]
473#[serde(deny_unknown_fields)]
474pub struct MariaDbConfig {
475    #[serde(rename = "use")]
476    phantom_use: Option<String>,
477    pub id: String,
478    pub port: u16,
479    pub address: String,
480    pub user: String,
481    pub password: String,
482    pub database: String,
483    pub image: String,
484    pub user_managed: bool,
485    pub persist_data: bool,
486}
487
488#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
489#[serde(rename_all = "kebab-case")]
490#[serde(deny_unknown_fields)]
491pub struct PostgresConfig {
492    #[serde(rename = "use")]
493    phantom_use: Option<String>,
494    pub id: String,
495
496    pub port: u16,
497    pub address: String,
498
499    pub user: String,
500    pub password: String,
501    pub database: String,
502
503    pub application: Application,
504    pub image: String,
505    pub user_managed: bool,
506    pub persist_data: bool,
507
508    // Inject latency into any network calls to the postgres service.
509    pub latency_ms: u32,
510}
511
512#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
513#[serde(rename_all = "kebab-case")]
514#[serde(deny_unknown_fields)]
515pub struct OracleConfig {
516    #[serde(rename = "use")]
517    phantom_use: Option<String>,
518    pub id: String,
519
520    pub port: u16,
521    pub address: String,
522
523    pub user: String,
524    pub password: String,
525    pub database: String,
526    pub pdb: String,
527
528    pub image: String,
529    pub user_managed: bool,
530    pub persist_data: bool,
531}
532
533#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
534#[serde(rename_all = "kebab-case")]
535#[serde(deny_unknown_fields)]
536pub struct SqlServerConfig {
537    #[serde(rename = "use")]
538    phantom_use: Option<String>,
539    pub id: String,
540
541    pub port: u16,
542    pub address: String,
543
544    pub user: String,
545    pub password: String,
546    pub database: String,
547
548    pub image: String,
549    pub user_managed: bool,
550    pub persist_data: bool,
551}
552
553#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
554#[serde(rename_all = "kebab-case")]
555#[serde(deny_unknown_fields)]
556pub struct MongoDbConfig {
557    #[serde(rename = "use")]
558    phantom_use: Option<String>,
559    pub id: String,
560
561    pub address: String,
562    pub port: u16,
563
564    pub image: String,
565    pub user_managed: bool,
566    pub persist_data: bool,
567}
568
569#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
570#[serde(rename_all = "kebab-case")]
571#[serde(deny_unknown_fields)]
572pub struct NatsConfig {
573    #[serde(rename = "use")]
574    phantom_use: Option<String>,
575    pub id: String,
576
577    pub address: String,
578    pub port: u16,
579    pub monitor_port: u16,
580
581    pub image: String,
582    pub user_managed: bool,
583    pub persist_data: bool,
584}
585
586#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
587#[serde(rename_all = "kebab-case")]
588#[serde(deny_unknown_fields)]
589pub struct MqttConfig {
590    #[serde(rename = "use")]
591    phantom_use: Option<String>,
592    pub id: String,
593
594    pub address: String,
595    pub port: u16,
596
597    pub image: String,
598    pub user_managed: bool,
599    pub persist_data: bool,
600}
601
602#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
603#[serde(rename_all = "kebab-case")]
604#[serde(deny_unknown_fields)]
605pub struct ElasticSearchConfig {
606    #[serde(rename = "use")]
607    phantom_use: Option<String>,
608    pub id: String,
609
610    pub address: String,
611    pub port: u16,
612
613    pub user: String,
614    pub password: String,
615
616    pub image: String,
617    pub user_managed: bool,
618    pub persist_data: bool,
619}
620
621#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
622#[serde(rename_all = "kebab-case")]
623#[serde(deny_unknown_fields)]
624pub struct OpenSearchConfig {
625    #[serde(rename = "use")]
626    phantom_use: Option<String>,
627    pub id: String,
628
629    pub address: String,
630    pub port: u16,
631
632    pub user: String,
633    pub password: String,
634
635    pub image: String,
636    pub user_managed: bool,
637    pub persist_data: bool,
638}
639
640#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
641#[serde(rename_all = "kebab-case")]
642#[serde(deny_unknown_fields)]
643pub struct LakekeeperConfig {
644    #[serde(rename = "use")]
645    phantom_use: Option<String>,
646    pub id: String,
647
648    pub port: u16,
649    pub address: String,
650
651    pub user_managed: bool,
652    pub persist_data: bool,
653
654    pub catalog_backend: String,
655    pub encryption_key: String,
656    pub provide_postgres_backend: Option<Vec<PostgresConfig>>,
657    pub provide_minio: Option<Vec<MinioConfig>>,
658}
659
660#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
661#[serde(rename_all = "kebab-case")]
662#[serde(deny_unknown_fields)]
663pub struct MoatConfig {
664    #[serde(rename = "use")]
665    phantom_use: Option<String>,
666    pub id: String,
667
668    pub address: String,
669    pub port: u16,
670
671    pub provide_minio: Option<Vec<MinioConfig>>,
672}
673
674/// All service configuration
675#[derive(Clone, Debug, PartialEq)]
676pub enum ServiceConfig {
677    ComputeNode(ComputeNodeConfig),
678    MetaNode(MetaNodeConfig),
679    Frontend(FrontendConfig),
680    Compactor(CompactorConfig),
681    Minio(MinioConfig),
682    Sqlite(SqliteConfig),
683    Prometheus(PrometheusConfig),
684    Grafana(GrafanaConfig),
685    Tempo(TempoConfig),
686    Opendal(OpendalConfig),
687    AwsS3(AwsS3Config),
688    Moto(MotoConfig),
689    Kafka(KafkaConfig),
690    SchemaRegistry(SchemaRegistryConfig),
691    Pubsub(PubsubConfig),
692    Pulsar(PulsarConfig),
693    Redis(RedisConfig),
694    ClickHouse(ClickHouseConfig),
695    Doris(DorisConfig),
696    Starrocks(StarrocksConfig),
697    MySql(MySqlConfig),
698    MariaDb(MariaDbConfig),
699    Postgres(PostgresConfig),
700    Oracle(OracleConfig),
701    SqlServer(SqlServerConfig),
702    MongoDb(MongoDbConfig),
703    ElasticSearch(ElasticSearchConfig),
704    OpenSearch(OpenSearchConfig),
705    Nats(NatsConfig),
706    Mqtt(MqttConfig),
707    Lakekeeper(LakekeeperConfig),
708    Moat(MoatConfig),
709}
710
711#[derive(PartialEq, Eq, Hash, Debug)]
712pub enum TaskGroup {
713    RisingWave,
714    Observability,
715    Kafka,
716    Pubsub,
717    Pulsar,
718    Starrocks,
719    MySql,
720    MariaDb,
721    Postgres,
722    Oracle,
723    SqlServer,
724    MongoDb,
725    ElasticSearch,
726    OpenSearch,
727    Nats,
728    Mqtt,
729    Redis,
730    ClickHouse,
731    Doris,
732    Lakekeeper,
733    Moat,
734}
735
736impl ServiceConfig {
737    pub fn id(&self) -> &str {
738        match self {
739            Self::ComputeNode(c) => &c.id,
740            Self::MetaNode(c) => &c.id,
741            Self::Frontend(c) => &c.id,
742            Self::Compactor(c) => &c.id,
743            Self::Minio(c) => &c.id,
744            Self::Sqlite(c) => &c.id,
745            Self::Prometheus(c) => &c.id,
746            Self::Grafana(c) => &c.id,
747            Self::Tempo(c) => &c.id,
748            Self::AwsS3(c) => &c.id,
749            Self::Moto(c) => &c.id,
750            Self::Kafka(c) => &c.id,
751            Self::Pubsub(c) => &c.id,
752            Self::Pulsar(c) => &c.id,
753            Self::Redis(c) => &c.id,
754            Self::ClickHouse(c) => &c.id,
755            Self::Doris(c) => &c.id,
756            Self::Starrocks(c) => &c.id,
757            Self::Opendal(c) => &c.id,
758            Self::MySql(c) => &c.id,
759            Self::MariaDb(c) => &c.id,
760            Self::Postgres(c) => &c.id,
761            Self::Oracle(c) => &c.id,
762            Self::SqlServer(c) => &c.id,
763            Self::MongoDb(c) => &c.id,
764            Self::ElasticSearch(c) => &c.id,
765            Self::OpenSearch(c) => &c.id,
766            Self::Nats(c) => &c.id,
767            Self::Mqtt(c) => &c.id,
768            Self::SchemaRegistry(c) => &c.id,
769            Self::Lakekeeper(c) => &c.id,
770            Self::Moat(c) => &c.id,
771        }
772    }
773
774    /// Used to check whether the port is occupied before running the service.
775    pub fn port(&self) -> Option<u16> {
776        match self {
777            Self::ComputeNode(c) => Some(c.port),
778            Self::MetaNode(c) => Some(c.port),
779            Self::Frontend(c) => Some(c.port),
780            Self::Compactor(c) => Some(c.port),
781            Self::Minio(c) => Some(c.port),
782            Self::Sqlite(_) => None,
783            Self::Prometheus(c) => Some(c.port),
784            Self::Grafana(c) => Some(c.port),
785            Self::Tempo(c) => Some(c.port),
786            Self::AwsS3(_) => None,
787            Self::Moto(c) => Some(c.port),
788            Self::Kafka(c) => Some(c.port),
789            Self::Pubsub(c) => Some(c.port),
790            Self::Pulsar(c) => Some(c.http_port),
791            Self::Redis(c) => Some(c.port),
792            Self::ClickHouse(c) => Some(c.http_port),
793            Self::Doris(c) => Some(c.query_port),
794            Self::Starrocks(c) => Some(c.query_port),
795            Self::Opendal(_) => None,
796            Self::MySql(c) => Some(c.port),
797            Self::MariaDb(c) => Some(c.port),
798            Self::Postgres(c) => Some(c.port),
799            Self::Oracle(c) => Some(c.port),
800            Self::SqlServer(c) => Some(c.port),
801            Self::MongoDb(c) => Some(c.port),
802            Self::ElasticSearch(c) => Some(c.port),
803            Self::OpenSearch(c) => Some(c.port),
804            Self::Nats(c) => Some(c.port),
805            Self::Mqtt(c) => Some(c.port),
806            Self::SchemaRegistry(c) => Some(c.port),
807            Self::Lakekeeper(c) => Some(c.port),
808            Self::Moat(c) => Some(c.port),
809        }
810    }
811
812    pub fn user_managed(&self) -> bool {
813        match self {
814            Self::ComputeNode(c) => c.user_managed,
815            Self::MetaNode(c) => c.user_managed,
816            Self::Frontend(c) => c.user_managed,
817            Self::Compactor(c) => c.user_managed,
818            Self::Minio(_c) => false,
819            Self::Sqlite(_c) => false,
820            Self::Prometheus(_c) => false,
821            Self::Grafana(_c) => false,
822            Self::Tempo(_c) => false,
823            Self::AwsS3(_c) => false,
824            Self::Moto(c) => c.user_managed,
825            Self::Kafka(c) => c.user_managed,
826            Self::Pubsub(c) => c.user_managed,
827            Self::Pulsar(c) => c.user_managed,
828            Self::Redis(c) => c.user_managed,
829            Self::ClickHouse(c) => c.user_managed,
830            Self::Doris(c) => c.user_managed,
831            Self::Starrocks(c) => c.user_managed,
832            Self::Opendal(_c) => false,
833            Self::MySql(c) => c.user_managed,
834            Self::MariaDb(c) => c.user_managed,
835            Self::Postgres(c) => c.user_managed,
836            Self::Oracle(c) => c.user_managed,
837            Self::SqlServer(c) => c.user_managed,
838            Self::MongoDb(c) => c.user_managed,
839            Self::ElasticSearch(c) => c.user_managed,
840            Self::OpenSearch(c) => c.user_managed,
841            Self::Nats(c) => c.user_managed,
842            Self::Mqtt(c) => c.user_managed,
843            Self::SchemaRegistry(c) => c.user_managed,
844            Self::Lakekeeper(c) => c.user_managed,
845            Self::Moat(_c) => false,
846        }
847    }
848
849    pub fn task_group(&self) -> TaskGroup {
850        use TaskGroup::*;
851        match self {
852            ServiceConfig::ComputeNode(_)
853            | ServiceConfig::MetaNode(_)
854            | ServiceConfig::Frontend(_)
855            | ServiceConfig::Compactor(_)
856            | ServiceConfig::Minio(_)
857            | ServiceConfig::Sqlite(_) => RisingWave,
858            ServiceConfig::Prometheus(_) | ServiceConfig::Grafana(_) | ServiceConfig::Tempo(_) => {
859                Observability
860            }
861            ServiceConfig::Opendal(_) | ServiceConfig::AwsS3(_) => RisingWave,
862            ServiceConfig::Moto(_) => RisingWave,
863            ServiceConfig::Kafka(_) | ServiceConfig::SchemaRegistry(_) => Kafka,
864            ServiceConfig::Pubsub(_) => Pubsub,
865            ServiceConfig::Pulsar(_) => Pulsar,
866            ServiceConfig::Redis(_) => Redis,
867            ServiceConfig::ClickHouse(_) => ClickHouse,
868            ServiceConfig::Doris(_) => Doris,
869            ServiceConfig::Starrocks(_) => Starrocks,
870            ServiceConfig::MySql(my_sql_config) => {
871                if matches!(my_sql_config.application, Application::Metastore) {
872                    RisingWave
873                } else {
874                    MySql
875                }
876            }
877            ServiceConfig::MariaDb(_) => MariaDb,
878            ServiceConfig::Postgres(postgres_config) => {
879                if matches!(postgres_config.application, Application::Metastore) {
880                    RisingWave
881                } else {
882                    Postgres
883                }
884            }
885            ServiceConfig::Oracle(_) => Oracle,
886            ServiceConfig::SqlServer(_) => SqlServer,
887            ServiceConfig::MongoDb(_) => MongoDb,
888            ServiceConfig::ElasticSearch(_) => ElasticSearch,
889            ServiceConfig::OpenSearch(_) => OpenSearch,
890            ServiceConfig::Nats(_) => Nats,
891            ServiceConfig::Mqtt(_) => Mqtt,
892            ServiceConfig::Lakekeeper(_) => Lakekeeper,
893            ServiceConfig::Moat(_) => Moat,
894        }
895    }
896}
897
898mod string {
899    use std::fmt::Display;
900    use std::str::FromStr;
901
902    use serde::{Deserialize, Deserializer, Serializer, de};
903
904    pub fn serialize<T, S>(value: &T, serializer: S) -> Result<S::Ok, S::Error>
905    where
906        T: Display,
907        S: Serializer,
908    {
909        serializer.collect_str(value)
910    }
911
912    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>
913    where
914        T: FromStr,
915        T::Err: Display,
916        D: Deserializer<'de>,
917    {
918        String::deserialize(deserializer)?
919            .parse()
920            .map_err(de::Error::custom)
921    }
922}