1use 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 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 pub address: String,
286 #[serde(with = "string")]
287 pub port: u16,
288 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 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 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 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#[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 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}