85 lines
3.1 KiB
Rust
85 lines
3.1 KiB
Rust
use std::io::Write;
|
|
|
|
use clusterflux_coordinator::{service::bind_listener, CoordinatorService};
|
|
use clusterflux_core::{ProjectId, TenantId, UserId};
|
|
use serde_json::json;
|
|
|
|
fn main() -> Result<(), Box<dyn std::error::Error>> {
|
|
let raw_args = std::env::args().skip(1).collect::<Vec<_>>();
|
|
match raw_args.as_slice() {
|
|
[flag] if matches!(flag.as_str(), "--version" | "-V") => {
|
|
println!("clusterflux-coordinator {}", env!("CARGO_PKG_VERSION"));
|
|
return Ok(());
|
|
}
|
|
[flag] if matches!(flag.as_str(), "--help" | "-h") => {
|
|
println!(
|
|
"Clusterflux coordinator.\n\n\
|
|
Usage: clusterflux-coordinator [OPTIONS]\n\n\
|
|
Options:\n \
|
|
--listen <ADDRESS> [default: 127.0.0.1:0]\n \
|
|
--allow-local-trusted-loopback\n \
|
|
-h, --help\n \
|
|
-V, --version"
|
|
);
|
|
return Ok(());
|
|
}
|
|
_ => {}
|
|
}
|
|
|
|
let mut listen = "127.0.0.1:0".to_owned();
|
|
let mut allow_local_trusted = std::env::var("CLUSTERFLUX_ALLOW_LOCAL_TRUSTED_LOOPBACK")
|
|
.ok()
|
|
.as_deref()
|
|
== Some("1");
|
|
let mut args = raw_args.into_iter();
|
|
while let Some(arg) = args.next() {
|
|
if arg == "--listen" {
|
|
listen = args.next().ok_or("--listen requires an address")?;
|
|
} else if arg == "--allow-local-trusted-loopback" {
|
|
allow_local_trusted = true;
|
|
} else {
|
|
return Err(format!("unknown argument: {arg}").into());
|
|
}
|
|
}
|
|
|
|
let (listener, addr) = bind_listener(&listen)?;
|
|
let database_url = std::env::var("DATABASE_URL").ok();
|
|
let mut service = CoordinatorService::new_with_database_url(1, database_url.as_deref())?;
|
|
let self_hosted_session_secret = std::env::var("CLUSTERFLUX_SELF_HOSTED_SESSION_SECRET")
|
|
.ok()
|
|
.filter(|secret| !secret.trim().is_empty());
|
|
if let Some(session_secret) = self_hosted_session_secret.as_deref() {
|
|
service.issue_cli_session(
|
|
TenantId::new(
|
|
std::env::var("CLUSTERFLUX_SELF_HOSTED_TENANT")
|
|
.unwrap_or_else(|_| "tenant".to_owned()),
|
|
),
|
|
ProjectId::new(
|
|
std::env::var("CLUSTERFLUX_SELF_HOSTED_PROJECT")
|
|
.unwrap_or_else(|_| "project".to_owned()),
|
|
),
|
|
UserId::new(
|
|
std::env::var("CLUSTERFLUX_SELF_HOSTED_USER").unwrap_or_else(|_| "user".to_owned()),
|
|
),
|
|
session_secret,
|
|
None,
|
|
)?;
|
|
}
|
|
println!(
|
|
"{}",
|
|
json!({
|
|
"listen": addr.to_string(),
|
|
"client_authority": if allow_local_trusted { "local_trusted_loopback" } else { "strict" },
|
|
"self_hosted_session_bootstrapped": self_hosted_session_secret.is_some(),
|
|
"durable_store": service.durable_store_kind(),
|
|
})
|
|
);
|
|
std::io::stdout().flush()?;
|
|
|
|
if allow_local_trusted {
|
|
service.serve_tcp_local_trusted(listener)?;
|
|
} else {
|
|
service.serve_tcp(listener)?;
|
|
}
|
|
Ok(())
|
|
}
|