1mod api;
2mod auth;
3mod db;
4mod env;
5mod rpc;
6
7#[cfg(test)]
8mod db_tests;
9#[cfg(test)]
10mod integration_tests;
11
12use axum::{body::Body, Router};
13use collab::{Error, Result};
14use db::{Db, PostgresDb};
15use serde::Deserialize;
16use std::{
17 net::{SocketAddr, TcpListener},
18 sync::Arc,
19 time::Duration,
20};
21use tracing_log::LogTracer;
22use tracing_subscriber::{filter::EnvFilter, fmt::format::JsonFields, Layer};
23use util::ResultExt;
24
25#[derive(Default, Deserialize)]
26pub struct Config {
27 pub http_port: u16,
28 pub database_url: String,
29 pub api_token: String,
30 pub invite_link_prefix: String,
31 pub honeycomb_api_key: Option<String>,
32 pub honeycomb_dataset: Option<String>,
33 pub live_kit_server: Option<String>,
34 pub live_kit_key: Option<String>,
35 pub live_kit_secret: Option<String>,
36 pub rust_log: Option<String>,
37 pub log_json: Option<bool>,
38}
39
40pub struct AppState {
41 db: Arc<dyn Db>,
42 api_token: String,
43 invite_link_prefix: String,
44 live_kit_client: Option<live_kit_server::api::Client>,
45}
46
47impl AppState {
48 async fn new(config: &Config) -> Result<Arc<Self>> {
49 let db = PostgresDb::new(&config.database_url, 5).await?;
50 let live_kit_client = if let Some(((server, key), secret)) = config
51 .live_kit_server
52 .as_ref()
53 .zip(config.live_kit_key.as_ref())
54 .zip(config.live_kit_secret.as_ref())
55 {
56 Some(live_kit_server::api::Client::new(
57 server.clone(),
58 key.clone(),
59 secret.clone(),
60 ))
61 } else {
62 None
63 };
64
65 let this = Self {
66 db: Arc::new(db),
67 live_kit_client,
68 api_token: config.api_token.clone(),
69 invite_link_prefix: config.invite_link_prefix.clone(),
70 };
71 Ok(Arc::new(this))
72 }
73}
74
75#[tokio::main]
76async fn main() -> Result<()> {
77 if let Err(error) = env::load_dotenv() {
78 eprintln!(
79 "error loading .env.toml (this is expected in production): {}",
80 error
81 );
82 }
83
84 let config = envy::from_env::<Config>().expect("error loading config");
85 init_tracing(&config);
86 let state = AppState::new(&config).await?;
87
88 let listener = TcpListener::bind(&format!("0.0.0.0:{}", config.http_port))
89 .expect("failed to bind TCP listener");
90 let rpc_server = rpc::Server::new(state.clone(), None);
91
92 rpc_server.start_recording_project_activity(Duration::from_secs(5 * 60), rpc::RealExecutor);
93
94 let app = Router::<Body>::new()
95 .merge(api::routes(&rpc_server, state.clone()))
96 .merge(rpc::routes(rpc_server));
97
98 axum::Server::from_tcp(listener)?
99 .serve(app.into_make_service_with_connect_info::<SocketAddr>())
100 .await?;
101
102 Ok(())
103}
104
105pub fn init_tracing(config: &Config) -> Option<()> {
106 use std::str::FromStr;
107 use tracing_subscriber::layer::SubscriberExt;
108 let rust_log = config.rust_log.clone()?;
109
110 LogTracer::init().log_err()?;
111
112 let subscriber = tracing_subscriber::Registry::default()
113 .with(if config.log_json.unwrap_or(false) {
114 Box::new(
115 tracing_subscriber::fmt::layer()
116 .fmt_fields(JsonFields::default())
117 .event_format(
118 tracing_subscriber::fmt::format()
119 .json()
120 .flatten_event(true)
121 .with_span_list(true),
122 ),
123 ) as Box<dyn Layer<_> + Send + Sync>
124 } else {
125 Box::new(
126 tracing_subscriber::fmt::layer()
127 .event_format(tracing_subscriber::fmt::format().pretty()),
128 )
129 })
130 .with(EnvFilter::from_str(rust_log.as_str()).log_err()?);
131
132 tracing::subscriber::set_global_default(subscriber).unwrap();
133
134 None
135}