runtime.rs (41579B)
1 use crate::app::identity_storage::DaemonIdentity; 2 use anyhow::{Context, Result, bail}; 3 use jsonrpsee::server::ServerHandle; 4 use std::time::Duration; 5 use tracing::{info, warn}; 6 #[cfg(not(test))] 7 use tracing_subscriber::EnvFilter; 8 9 use crate::app::identity_storage::load_service_identity; 10 use crate::app::{cli, config, paths}; 11 use crate::core::Radrootsd; 12 use crate::core::transport_publish::{ 13 PublishPrincipalInit, TransportPublishStore, generate_bearer_token, hash_bearer_token, 14 parse_explicit_transport_kind, parse_nostr_source_policy, parse_target_policy, 15 write_token_file, 16 }; 17 use crate::host_nostr::{ApplicationHandlerSpec, Kind, build_application_handler, build_profile}; 18 use crate::transport::jsonrpc; 19 #[cfg(not(test))] 20 use crate::transport::nostr::listener::spawn_nip46_listener; 21 #[cfg(not(test))] 22 use clap::Parser; 23 use radroots_event::profile::AuthoredProfile; 24 use std::path::PathBuf; 25 26 #[cfg(test)] 27 type RunLoadHookValue = Result<(cli::Args, config::Settings), String>; 28 29 #[cfg(test)] 30 type RunLoadHook = std::sync::Mutex<Option<RunLoadHookValue>>; 31 32 #[cfg(test)] 33 static RUN_LOAD_HOOK: std::sync::OnceLock<RunLoadHook> = std::sync::OnceLock::new(); 34 35 #[cfg(test)] 36 static RUN_BOOTSTRAP_HOOK: std::sync::OnceLock<std::sync::Mutex<Option<Result<(), String>>>> = 37 std::sync::OnceLock::new(); 38 39 #[cfg(test)] 40 static RUN_WAIT_HOOK: std::sync::OnceLock<std::sync::Mutex<Option<RunWaitOutcome>>> = 41 std::sync::OnceLock::new(); 42 43 #[cfg(test)] 44 static RUN_START_RPC_HOOK: std::sync::OnceLock< 45 std::sync::Mutex<Option<Result<ServerHandle, String>>>, 46 > = std::sync::OnceLock::new(); 47 48 #[derive(Clone, Copy)] 49 enum RunWaitOutcome { 50 Shutdown, 51 Stopped, 52 } 53 54 #[cfg(not(test))] 55 fn init_logging(logs_dir: &std::path::Path, default_level: Option<&str>) -> Result<()> { 56 std::fs::create_dir_all(logs_dir) 57 .with_context(|| format!("create log directory {}", logs_dir.display()))?; 58 let appender = tracing_appender::rolling::never(logs_dir, "radrootsd.log"); 59 let (writer, guard) = tracing_appender::non_blocking(appender); 60 static LOG_GUARD: std::sync::OnceLock<tracing_appender::non_blocking::WorkerGuard> = 61 std::sync::OnceLock::new(); 62 let filter = std::env::var("RADROOTS_LOG_LEVEL") 63 .or_else(|_| std::env::var("RUST_LOG")) 64 .ok() 65 .or_else(|| default_level.map(str::to_owned)) 66 .unwrap_or_else(|| "info".to_owned()); 67 tracing_subscriber::fmt() 68 .with_env_filter(EnvFilter::new(filter)) 69 .with_writer(writer) 70 .try_init() 71 .map_err(|error| anyhow::anyhow!("initialize logging: {error}"))?; 72 LOG_GUARD 73 .set(guard) 74 .map_err(|_| anyhow::anyhow!("logging is already initialized"))?; 75 Ok(()) 76 } 77 78 #[cfg(not(test))] 79 async fn shutdown_signal() { 80 let ctrl_c = async { 81 tokio::signal::ctrl_c() 82 .await 83 .expect("failed to install Ctrl+C handler"); 84 }; 85 #[cfg(unix)] 86 let terminate = async { 87 tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate()) 88 .expect("failed to install signal handler") 89 .recv() 90 .await; 91 }; 92 #[cfg(not(unix))] 93 let terminate = std::future::pending::<()>(); 94 tokio::select! { 95 _ = ctrl_c => {}, 96 _ = terminate => {}, 97 } 98 } 99 100 #[derive(Debug, Clone, PartialEq, Eq)] 101 struct RadrootsdRuntimeStartupReport { 102 active_profile: String, 103 config_path: PathBuf, 104 config_path_source: String, 105 canonical_config_path: PathBuf, 106 logs_dir: PathBuf, 107 logs_dir_source: String, 108 canonical_logs_dir: PathBuf, 109 identity_path: PathBuf, 110 identity_path_source: String, 111 canonical_identity_path: PathBuf, 112 transport_publish_database_path: PathBuf, 113 transport_publish_database_path_source: String, 114 canonical_transport_publish_database_path: PathBuf, 115 path_overrides: paths::RadrootsdRuntimePathOverrideContractOutput, 116 default_shared_secret_backend: String, 117 allowed_shared_secret_backends: Vec<String>, 118 } 119 120 #[cfg(test)] 121 fn run_load_hook() -> &'static RunLoadHook { 122 RUN_LOAD_HOOK.get_or_init(|| std::sync::Mutex::new(None)) 123 } 124 125 #[cfg(test)] 126 fn run_bootstrap_hook() -> &'static std::sync::Mutex<Option<Result<(), String>>> { 127 RUN_BOOTSTRAP_HOOK.get_or_init(|| std::sync::Mutex::new(None)) 128 } 129 130 #[cfg(test)] 131 fn run_wait_hook() -> &'static std::sync::Mutex<Option<RunWaitOutcome>> { 132 RUN_WAIT_HOOK.get_or_init(|| std::sync::Mutex::new(None)) 133 } 134 135 #[cfg(test)] 136 fn run_start_rpc_hook() -> &'static std::sync::Mutex<Option<Result<ServerHandle, String>>> { 137 RUN_START_RPC_HOOK.get_or_init(|| std::sync::Mutex::new(None)) 138 } 139 140 #[cfg(test)] 141 fn take_load_hook_result() -> Option<Result<(cli::Args, config::Settings), String>> { 142 run_load_hook() 143 .lock() 144 .unwrap_or_else(std::sync::PoisonError::into_inner) 145 .take() 146 } 147 148 #[cfg(test)] 149 fn take_bootstrap_hook_result() -> Option<Result<(), String>> { 150 run_bootstrap_hook() 151 .lock() 152 .unwrap_or_else(std::sync::PoisonError::into_inner) 153 .take() 154 } 155 156 #[cfg(not(test))] 157 fn take_bootstrap_hook_result() -> Option<Result<(), String>> { 158 None 159 } 160 161 #[cfg(test)] 162 fn take_wait_hook_result() -> Option<RunWaitOutcome> { 163 run_wait_hook() 164 .lock() 165 .unwrap_or_else(std::sync::PoisonError::into_inner) 166 .take() 167 } 168 169 #[cfg(test)] 170 fn take_start_rpc_hook_result() -> Option<Result<ServerHandle, String>> { 171 run_start_rpc_hook() 172 .lock() 173 .unwrap_or_else(std::sync::PoisonError::into_inner) 174 .take() 175 } 176 177 fn load_args_and_settings() -> Result<Option<(cli::Args, config::Settings)>> { 178 #[cfg(test)] 179 { 180 if let Some(result) = take_load_hook_result() { 181 return result.map(Some).map_err(anyhow::Error::msg); 182 } 183 Err(anyhow::anyhow!("run loader hook not set")) 184 } 185 186 #[cfg(not(test))] 187 { 188 let args = match cli::Args::try_parse() { 189 Ok(args) => args, 190 Err(display) 191 if matches!( 192 display.kind(), 193 clap::error::ErrorKind::DisplayHelp | clap::error::ErrorKind::DisplayVersion 194 ) => 195 { 196 display.print()?; 197 return Ok(None); 198 } 199 Err(error) => return Err(error.into()), 200 }; 201 let config_path = args 202 .service 203 .config 204 .clone() 205 .map(Ok) 206 .unwrap_or_else(paths::default_config_path_for_process)?; 207 let settings = 208 config::load_settings_from_path(&config_path).context("load configuration")?; 209 init_logging( 210 std::path::Path::new(settings.config.service.logs_dir.as_str()), 211 None, 212 )?; 213 Ok(Some((args, settings))) 214 } 215 } 216 217 fn runtime_startup_report( 218 args: &cli::Args, 219 settings: &config::Settings, 220 contract: &paths::RadrootsdRuntimeContractOutput, 221 ) -> RadrootsdRuntimeStartupReport { 222 RadrootsdRuntimeStartupReport { 223 active_profile: contract.active_profile.clone(), 224 config_path: args 225 .service 226 .config 227 .clone() 228 .unwrap_or_else(|| contract.canonical_config_path.clone()), 229 config_path_source: cli_or_profile_path_source( 230 args.service.config.is_some(), 231 &args 232 .service 233 .config 234 .clone() 235 .unwrap_or_else(|| contract.canonical_config_path.clone()), 236 &contract.canonical_config_path, 237 ), 238 canonical_config_path: contract.canonical_config_path.clone(), 239 logs_dir: PathBuf::from(settings.config.service.logs_dir.as_str()), 240 logs_dir_source: config_or_profile_path_source( 241 &PathBuf::from(settings.config.service.logs_dir.as_str()), 242 &contract.canonical_logs_dir, 243 ), 244 canonical_logs_dir: contract.canonical_logs_dir.clone(), 245 identity_path: args 246 .service 247 .identity 248 .clone() 249 .unwrap_or_else(|| contract.canonical_identity_path.clone()), 250 identity_path_source: cli_or_profile_path_source( 251 args.service.identity.is_some(), 252 &args 253 .service 254 .identity 255 .clone() 256 .unwrap_or_else(|| contract.canonical_identity_path.clone()), 257 &contract.canonical_identity_path, 258 ), 259 canonical_identity_path: contract.canonical_identity_path.clone(), 260 transport_publish_database_path: settings.config.transport_publish.database_path.clone(), 261 transport_publish_database_path_source: config_or_profile_path_source( 262 &settings.config.transport_publish.database_path, 263 &contract.canonical_transport_publish_database_path, 264 ), 265 canonical_transport_publish_database_path: contract 266 .canonical_transport_publish_database_path 267 .clone(), 268 path_overrides: contract.path_overrides.clone(), 269 default_shared_secret_backend: contract.default_shared_secret_backend.clone(), 270 allowed_shared_secret_backends: contract.allowed_shared_secret_backends.clone(), 271 } 272 } 273 274 fn cli_or_profile_path_source( 275 is_cli_arg: bool, 276 actual_path: &PathBuf, 277 canonical_path: &PathBuf, 278 ) -> String { 279 if is_cli_arg { 280 "cli_arg".to_owned() 281 } else { 282 config_or_profile_path_source(actual_path, canonical_path) 283 } 284 } 285 286 fn config_or_profile_path_source(actual_path: &PathBuf, canonical_path: &PathBuf) -> String { 287 if actual_path == canonical_path { 288 "profile_default".to_owned() 289 } else { 290 "config_artifact".to_owned() 291 } 292 } 293 294 #[cfg(not(test))] 295 fn log_runtime_startup_report(report: &RadrootsdRuntimeStartupReport) { 296 info!( 297 active_profile = report.active_profile.as_str(), 298 profile_source = report.path_overrides.profile_source.as_str(), 299 root_source = report.path_overrides.root_source.as_str(), 300 repo_local_root = ?report.path_overrides.repo_local_root, 301 repo_local_root_source = ?report.path_overrides.repo_local_root_source, 302 subordinate_path_override_source = report.path_overrides.subordinate_path_override_source.as_str(), 303 config_path = %report.config_path.display(), 304 config_path_source = report.config_path_source.as_str(), 305 canonical_config_path = %report.canonical_config_path.display(), 306 logs_dir = %report.logs_dir.display(), 307 logs_dir_source = report.logs_dir_source.as_str(), 308 canonical_logs_dir = %report.canonical_logs_dir.display(), 309 identity_path = %report.identity_path.display(), 310 identity_path_source = report.identity_path_source.as_str(), 311 canonical_identity_path = %report.canonical_identity_path.display(), 312 transport_publish_database_path = %report.transport_publish_database_path.display(), 313 transport_publish_database_path_source = report.transport_publish_database_path_source.as_str(), 314 canonical_transport_publish_database_path = %report.canonical_transport_publish_database_path.display(), 315 default_shared_secret_backend = report.default_shared_secret_backend.as_str(), 316 allowed_shared_secret_backends = ?report.allowed_shared_secret_backends, 317 "radrootsd runtime contract" 318 ); 319 } 320 321 #[cfg_attr(coverage_nightly, coverage(off))] 322 async fn bootstrap_presence( 323 client: &crate::host_nostr::DaemonNostrClient, 324 identity: &DaemonIdentity, 325 profile: &AuthoredProfile, 326 handler_spec: &ApplicationHandlerSpec, 327 ) -> Result<()> { 328 if let Some(result) = take_bootstrap_hook_result() { 329 return result.map_err(anyhow::Error::msg); 330 } 331 332 let (profile_event, handler_event) = 333 build_service_presence_events(identity, profile, handler_spec)?; 334 335 client.connect().await; 336 client.wait_for_connection(Duration::from_secs(5)).await; 337 if !client 338 .relays() 339 .await 340 .into_values() 341 .any(|relay| relay.is_connected()) 342 { 343 bail!("service presence requires at least one connected relay"); 344 } 345 346 publish_presence_event(client, &profile_event, "service Profile").await?; 347 publish_presence_event(client, &handler_event, "NIP-89 application handler").await?; 348 Ok(()) 349 } 350 351 fn build_service_presence_events( 352 identity: &DaemonIdentity, 353 profile: &AuthoredProfile, 354 handler_spec: &ApplicationHandlerSpec, 355 ) -> Result<(nostr::Event, nostr::Event)> { 356 let profile_event = build_profile(profile) 357 .context("build service Profile event")? 358 .sign_with_keys(identity.keys()) 359 .context("sign service Profile event")?; 360 let handler_event = build_application_handler(handler_spec) 361 .context("build NIP-89 application handler event")? 362 .sign_with_keys(identity.keys()) 363 .context("sign NIP-89 application handler event")?; 364 Ok((profile_event, handler_event)) 365 } 366 367 async fn publish_presence_event( 368 client: &crate::host_nostr::DaemonNostrClient, 369 event: &nostr::Event, 370 event_name: &str, 371 ) -> Result<()> { 372 let output = client 373 .send_event(event) 374 .await 375 .with_context(|| format!("publish {event_name}"))?; 376 if output.success.is_empty() { 377 bail!("{event_name} publication did not succeed on any relay"); 378 } 379 Ok(()) 380 } 381 382 #[cfg_attr(coverage_nightly, coverage(off))] 383 async fn publish_service_presence( 384 client: crate::host_nostr::DaemonNostrClient, 385 identity: DaemonIdentity, 386 profile: AuthoredProfile, 387 metadata: crate::host_nostr::Metadata, 388 service_cfg: config::NostrServiceConfig, 389 nip46_config: config::Nip46Config, 390 ) -> Result<()> { 391 let kinds = service_presence_kinds(); 392 let mut handler_spec = ApplicationHandlerSpec::new(kinds) 393 .with_metadata(metadata.clone()) 394 .with_extra_tags(service_cfg.nip89_extra_tags.clone()) 395 .with_relays(service_cfg.relays.clone()); 396 if let Some(identifier) = service_cfg.nip89_identifier.clone() { 397 handler_spec = handler_spec.with_identifier(identifier); 398 } 399 if let Some(url) = nip46_config.nostrconnect_url.clone() { 400 handler_spec = handler_spec.with_nostr_connect_url(url); 401 } 402 bootstrap_presence(&client, &identity, &profile, &handler_spec).await 403 } 404 405 #[cfg_attr(coverage_nightly, coverage(off))] 406 async fn maybe_publish_service_presence( 407 client: crate::host_nostr::DaemonNostrClient, 408 identity: DaemonIdentity, 409 profile: AuthoredProfile, 410 metadata: crate::host_nostr::Metadata, 411 service_cfg: config::NostrServiceConfig, 412 nip46_config: config::Nip46Config, 413 ) { 414 #[cfg(test)] 415 { 416 let result = publish_service_presence( 417 client, 418 identity, 419 profile, 420 metadata, 421 service_cfg, 422 nip46_config, 423 ) 424 .await; 425 if let Err(err) = result { 426 warn!("Failed to publish service presence on startup: {err}"); 427 } else { 428 info!("Published service presence on startup"); 429 } 430 } 431 432 #[cfg(not(test))] 433 tokio::spawn(async move { 434 let result = publish_service_presence( 435 client, 436 identity, 437 profile, 438 metadata, 439 service_cfg, 440 nip46_config, 441 ) 442 .await; 443 if let Err(err) = result { 444 warn!("Failed to publish service presence on startup: {err}"); 445 } else { 446 info!("Published service presence on startup"); 447 } 448 }); 449 } 450 451 #[cfg(not(test))] 452 #[cfg_attr(coverage_nightly, coverage(off))] 453 fn spawn_nip46_listener_io(radrootsd: Radrootsd) { 454 spawn_nip46_listener(radrootsd); 455 } 456 457 #[cfg(test)] 458 fn spawn_nip46_listener_io(_radrootsd: Radrootsd) {} 459 460 #[cfg(test)] 461 async fn start_rpc_io( 462 state: Radrootsd, 463 addr: std::net::SocketAddr, 464 rpc_cfg: &config::RpcConfig, 465 ) -> Result<ServerHandle> { 466 if let Some(result) = take_start_rpc_hook_result() { 467 return result.map_err(anyhow::Error::msg); 468 } 469 jsonrpc::start_rpc(state, addr, rpc_cfg).await 470 } 471 472 #[cfg(not(test))] 473 #[cfg_attr(coverage_nightly, coverage(off))] 474 async fn start_rpc_io( 475 state: Radrootsd, 476 addr: std::net::SocketAddr, 477 rpc_cfg: &config::RpcConfig, 478 ) -> Result<ServerHandle> { 479 jsonrpc::start_rpc(state, addr, rpc_cfg).await 480 } 481 482 #[cfg(test)] 483 async fn wait_for_shutdown_or_stopped(handle: ServerHandle) -> RunWaitOutcome { 484 if let Some(outcome) = take_wait_hook_result() { 485 return outcome; 486 } 487 handle.stopped().await; 488 RunWaitOutcome::Stopped 489 } 490 491 #[cfg(not(test))] 492 #[cfg_attr(coverage_nightly, coverage(off))] 493 async fn wait_for_shutdown_or_stopped(handle: ServerHandle) -> RunWaitOutcome { 494 tokio::select! { 495 _ = shutdown_signal() => RunWaitOutcome::Shutdown, 496 _ = handle.stopped() => RunWaitOutcome::Stopped, 497 } 498 } 499 500 async fn handle_command(command: cli::Command, settings: &config::Settings) -> Result<()> { 501 match command { 502 cli::Command::TransportPublish(command) => match command.command { 503 cli::TransportPublishSubcommand::Principal(command) => match command.command { 504 cli::PrincipalSubcommand::Init(args) => { 505 let token = generate_bearer_token(); 506 let token_hash = hash_bearer_token(token.as_str()); 507 let store = TransportPublishStore::open( 508 settings.config.transport_publish.database_path.clone(), 509 )?; 510 let allowed_target_policies = args 511 .allowed_target_policy 512 .iter() 513 .map(|policy| parse_target_policy(policy.as_str())) 514 .collect::<Result<Vec<_>, _>>()?; 515 let allowed_explicit_transport_kinds = args 516 .allowed_explicit_transport_kind 517 .iter() 518 .map(|transport_kind| { 519 parse_explicit_transport_kind(transport_kind.as_str()) 520 }) 521 .collect::<Result<Vec<_>, _>>()?; 522 let allowed_nostr_source_policies = args 523 .allowed_nostr_source_policy 524 .iter() 525 .map(|policy| parse_nostr_source_policy(policy.as_str())) 526 .collect::<Result<Vec<_>, _>>()?; 527 let principal = store.create_principal(PublishPrincipalInit { 528 label: args.label, 529 token_hash, 530 allowed_pubkeys: args.allowed_pubkey, 531 allowed_kinds: args.allowed_kind, 532 allowed_target_policies, 533 allowed_explicit_transport_kinds, 534 allowed_nostr_source_policies, 535 allow_request_targets: args.allow_request_targets, 536 job_visibility: args.job_visibility.parse()?, 537 expires_at_unix: None, 538 })?; 539 write_token_file(&args.token_file, token.as_str())?; 540 println!( 541 "{}", 542 serde_json::json!({ 543 "principal_id": principal.principal_id, 544 "label": principal.label, 545 "token_file": args.token_file, 546 "database_path": settings.config.transport_publish.database_path, 547 }) 548 ); 549 Ok(()) 550 } 551 }, 552 }, 553 } 554 } 555 556 pub async fn run() -> Result<()> { 557 let Some((args, settings)) = load_args_and_settings()? else { 558 return Ok(()); 559 }; 560 settings.validate()?; 561 let authored_profile = settings.authored_profile()?; 562 563 #[cfg(not(test))] 564 { 565 let contract = paths::runtime_contract_for_process().context("resolve runtime contract")?; 566 let report = runtime_startup_report(&args, &settings, &contract); 567 log_runtime_startup_report(&report); 568 } 569 570 if let Some(command) = args.command.clone() { 571 return handle_command(command, &settings).await; 572 } 573 574 info!("Starting radrootsd"); 575 576 let identity = load_service_identity( 577 args.service.identity.as_deref(), 578 args.service.allow_generate_identity, 579 )?; 580 let radrootsd = Radrootsd::new( 581 identity.clone(), 582 settings.config.transport_publish.clone(), 583 settings.config.nip46.clone(), 584 ); 585 let radrootsd = radrootsd?; 586 587 for relay in settings.config.service.relays.iter() { 588 radrootsd.client.add_relay(relay).await?; 589 } 590 591 if !settings.config.service.relays.is_empty() { 592 maybe_publish_service_presence( 593 radrootsd.client.clone(), 594 identity.clone(), 595 authored_profile, 596 settings.metadata.clone(), 597 settings.config.service.clone(), 598 settings.config.nip46.clone(), 599 ) 600 .await; 601 602 spawn_nip46_listener_io(radrootsd.clone()); 603 } 604 605 let addr: std::net::SocketAddr = settings.config.rpc_addr().parse()?; 606 let handle = start_rpc_io(radrootsd.clone(), addr, &settings.config.rpc).await?; 607 info!("JSON-RPC listening on {addr}"); 608 609 let stop_handle = handle.clone(); 610 611 match wait_for_shutdown_or_stopped(handle).await { 612 RunWaitOutcome::Shutdown => { 613 info!("Shutting down…"); 614 let _ = stop_handle.stop(); 615 } 616 RunWaitOutcome::Stopped => {} 617 } 618 619 Ok(()) 620 } 621 622 fn service_presence_kinds() -> Vec<u32> { 623 let mut kinds = vec![Kind::NostrConnect.as_u16() as u32]; 624 kinds.sort_unstable(); 625 kinds.dedup(); 626 kinds 627 } 628 629 #[cfg(test)] 630 #[cfg_attr(coverage_nightly, coverage(off))] 631 mod tests { 632 use super::{ 633 RadrootsdRuntimeStartupReport, RunWaitOutcome, build_service_presence_events, run, 634 run_bootstrap_hook, run_load_hook, run_start_rpc_hook, run_wait_hook, 635 runtime_startup_report, 636 }; 637 use crate::app::identity_storage::DaemonIdentity; 638 use crate::app::{cli, config, paths}; 639 use crate::core::Radrootsd; 640 use crate::host_nostr::{ApplicationHandlerSpec, Kind, Metadata}; 641 use crate::transport::jsonrpc; 642 use std::path::Path; 643 use std::path::PathBuf; 644 use tokio::sync::{Mutex, MutexGuard}; 645 646 static TEST_LOCK: Mutex<()> = Mutex::const_new(()); 647 648 async fn test_guard() -> MutexGuard<'static, ()> { 649 let guard = TEST_LOCK.lock().await; 650 *run_load_hook() 651 .lock() 652 .unwrap_or_else(std::sync::PoisonError::into_inner) = None; 653 *run_bootstrap_hook() 654 .lock() 655 .unwrap_or_else(std::sync::PoisonError::into_inner) = None; 656 *run_wait_hook() 657 .lock() 658 .unwrap_or_else(std::sync::PoisonError::into_inner) = None; 659 *run_start_rpc_hook() 660 .lock() 661 .unwrap_or_else(std::sync::PoisonError::into_inner) = None; 662 guard 663 } 664 665 fn unique_identity_path(suffix: &str) -> PathBuf { 666 let nanos = std::time::SystemTime::now() 667 .duration_since(std::time::UNIX_EPOCH) 668 .expect("time") 669 .as_nanos(); 670 std::env::temp_dir().join(format!("radrootsd-{suffix}-{nanos}.secret.json")) 671 } 672 673 fn cleanup_identity_artifacts(path: &Path) { 674 let _ = std::fs::remove_file(path); 675 let _ = std::fs::remove_file(crate::app::identity_storage::encrypted_identity_key_path( 676 path, 677 )); 678 } 679 680 fn args_for_identity(path: PathBuf, allow_generate: bool) -> cli::Args { 681 cli::Args { 682 service: cli::ServiceCliArgs { 683 config: Some(PathBuf::from("config.toml")), 684 identity: Some(path), 685 allow_generate_identity: allow_generate, 686 }, 687 command: None, 688 } 689 } 690 691 fn settings_with_relays(relays: Vec<String>) -> config::Settings { 692 let metadata: Metadata = 693 serde_json::from_str(r#"{"name":"radrootsd-test"}"#).expect("metadata"); 694 config::Settings { 695 metadata, 696 config: config::Configuration { 697 service: config::NostrServiceConfig { 698 logs_dir: "logs".to_string(), 699 relays, 700 nip89_identifier: Some("radrootsd".to_string()), 701 nip89_extra_tags: Vec::new(), 702 }, 703 rpc: config::RpcConfig { 704 addr: "127.0.0.1:0".to_string(), 705 ..config::RpcConfig::default() 706 }, 707 rpc_addr: Some("127.0.0.1:0".to_string()), 708 nip46: config::Nip46Config::default(), 709 transport_publish: config::TransportPublishConfig::default(), 710 }, 711 } 712 } 713 714 fn sample_runtime_contract() -> paths::RadrootsdRuntimeContractOutput { 715 paths::RadrootsdRuntimeContractOutput { 716 active_profile: "interactive_user".to_string(), 717 allowed_profiles: vec![ 718 "interactive_user".to_string(), 719 "service_host".to_string(), 720 "repo_local".to_string(), 721 ], 722 path_overrides: paths::RadrootsdRuntimePathOverrideContractOutput { 723 profile_source: "caller".to_string(), 724 root_source: "host_defaults".to_string(), 725 repo_local_root: None, 726 repo_local_root_source: None, 727 subordinate_path_override_source: "config_artifact".to_string(), 728 subordinate_path_override_keys: vec![ 729 "config.service.logs_dir".to_string(), 730 "config.transport_publish.database_path".to_string(), 731 ], 732 }, 733 default_shared_secret_backend: "encrypted_file".to_string(), 734 allowed_shared_secret_backends: vec!["encrypted_file".to_string()], 735 canonical_config_path: PathBuf::from( 736 "/home/treesap/.radroots/config/services/radrootsd/config.toml", 737 ), 738 canonical_logs_dir: PathBuf::from("/home/treesap/.radroots/logs/services/radrootsd"), 739 canonical_identity_path: PathBuf::from( 740 "/home/treesap/.radroots/secrets/services/radrootsd/identity.secret.json", 741 ), 742 canonical_transport_publish_database_path: PathBuf::from( 743 "/home/treesap/.radroots/data/services/radrootsd/transport_publish.sqlite", 744 ), 745 } 746 } 747 748 async fn make_handle(settings: &config::Settings) -> jsonrpsee::server::ServerHandle { 749 let identity = DaemonIdentity::generate(); 750 let state = Radrootsd::new( 751 identity, 752 settings.config.transport_publish.clone(), 753 settings.config.nip46.clone(), 754 ) 755 .expect("state"); 756 jsonrpc::start_rpc( 757 state, 758 "127.0.0.1:0".parse().expect("addr"), 759 &settings.config.rpc, 760 ) 761 .await 762 .expect("rpc handle") 763 } 764 765 #[tokio::test] 766 async fn run_returns_error_when_hook_is_missing() { 767 let _guard = test_guard().await; 768 let err = run().await.expect_err("missing loader hook should error"); 769 let msg = format!("{err:#}"); 770 assert!(msg.contains("run loader hook not set")); 771 } 772 773 #[tokio::test] 774 async fn run_returns_error_when_identity_missing() { 775 let _guard = test_guard().await; 776 let args = args_for_identity(PathBuf::from("/tmp/radrootsd-missing.secret.json"), false); 777 let settings = settings_with_relays(Vec::new()); 778 *run_load_hook() 779 .lock() 780 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok((args, settings))); 781 let err = run().await.expect_err("missing identity should error"); 782 let msg = format!("{err:#}"); 783 assert!(msg.contains("identity")); 784 } 785 786 #[tokio::test] 787 async fn run_covers_shutdown_path_and_presence_success() { 788 let _guard = test_guard().await; 789 let path = unique_identity_path("shutdown"); 790 let args = args_for_identity(path.clone(), true); 791 let settings = settings_with_relays(vec!["wss://relay.example.com".to_string()]); 792 let handle = make_handle(&settings).await; 793 *run_load_hook() 794 .lock() 795 .unwrap_or_else(std::sync::PoisonError::into_inner) = 796 Some(Ok((args, settings.clone()))); 797 *run_start_rpc_hook() 798 .lock() 799 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok(handle)); 800 *run_wait_hook() 801 .lock() 802 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(RunWaitOutcome::Shutdown); 803 *run_bootstrap_hook() 804 .lock() 805 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok(())); 806 assert!(run().await.is_ok()); 807 cleanup_identity_artifacts(&path); 808 } 809 810 #[tokio::test] 811 async fn run_covers_stopped_path_and_presence_failure() { 812 let _guard = test_guard().await; 813 let path = unique_identity_path("stopped"); 814 let args = args_for_identity(path.clone(), true); 815 let settings = settings_with_relays(vec!["wss://relay.example.com".to_string()]); 816 let handle = make_handle(&settings).await; 817 let _ = handle.stop(); 818 *run_load_hook() 819 .lock() 820 .unwrap_or_else(std::sync::PoisonError::into_inner) = 821 Some(Ok((args, settings.clone()))); 822 *run_start_rpc_hook() 823 .lock() 824 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok(handle)); 825 *run_wait_hook() 826 .lock() 827 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(RunWaitOutcome::Stopped); 828 *run_bootstrap_hook() 829 .lock() 830 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Err("boom".to_string())); 831 assert!(run().await.is_ok()); 832 cleanup_identity_artifacts(&path); 833 } 834 835 #[tokio::test] 836 async fn run_skips_presence_when_relays_empty() { 837 let _guard = test_guard().await; 838 let path = unique_identity_path("empty"); 839 let args = args_for_identity(path.clone(), true); 840 let settings = settings_with_relays(Vec::new()); 841 let handle = make_handle(&settings).await; 842 *run_load_hook() 843 .lock() 844 .unwrap_or_else(std::sync::PoisonError::into_inner) = 845 Some(Ok((args, settings.clone()))); 846 *run_start_rpc_hook() 847 .lock() 848 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok(handle)); 849 *run_wait_hook() 850 .lock() 851 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(RunWaitOutcome::Shutdown); 852 assert!(run().await.is_ok()); 853 cleanup_identity_artifacts(&path); 854 } 855 856 #[tokio::test] 857 async fn run_returns_error_when_relay_is_invalid() { 858 let _guard = test_guard().await; 859 let path = unique_identity_path("invalid-relay"); 860 let args = args_for_identity(path.clone(), true); 861 let settings = settings_with_relays(vec!["not-a-relay".to_string()]); 862 *run_load_hook() 863 .lock() 864 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok((args, settings))); 865 let err = run().await.expect_err("invalid relay should error"); 866 let msg = format!("{err:#}"); 867 assert!(!msg.is_empty()); 868 cleanup_identity_artifacts(&path); 869 } 870 871 #[tokio::test] 872 async fn run_returns_error_when_rpc_addr_is_invalid() { 873 let _guard = test_guard().await; 874 let path = unique_identity_path("invalid-rpc-addr"); 875 let args = args_for_identity(path.clone(), true); 876 let mut settings = settings_with_relays(Vec::new()); 877 settings.config.rpc_addr = Some("not-an-addr".to_string()); 878 *run_load_hook() 879 .lock() 880 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok((args, settings))); 881 let err = run().await.expect_err("invalid rpc addr should error"); 882 let msg = format!("{err:#}"); 883 assert!(msg.contains("invalid")); 884 cleanup_identity_artifacts(&path); 885 } 886 887 #[tokio::test] 888 async fn run_returns_error_when_rpc_start_fails() { 889 let _guard = test_guard().await; 890 let path = unique_identity_path("rpc-start-fail"); 891 let args = args_for_identity(path.clone(), true); 892 let settings = settings_with_relays(Vec::new()); 893 *run_load_hook() 894 .lock() 895 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok((args, settings))); 896 *run_start_rpc_hook() 897 .lock() 898 .unwrap_or_else(std::sync::PoisonError::into_inner) = 899 Some(Err("rpc start failed".to_string())); 900 let err = run().await.expect_err("rpc start hook should fail"); 901 let msg = format!("{err:#}"); 902 assert!(msg.contains("rpc start failed")); 903 cleanup_identity_artifacts(&path); 904 } 905 906 #[tokio::test] 907 async fn run_waits_for_stopped_when_wait_hook_is_not_set() { 908 let _guard = test_guard().await; 909 let path = unique_identity_path("wait-no-hook"); 910 let args = args_for_identity(path.clone(), true); 911 let settings = settings_with_relays(Vec::new()); 912 let handle = make_handle(&settings).await; 913 let _ = handle.stop(); 914 *run_load_hook() 915 .lock() 916 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok((args, settings))); 917 *run_start_rpc_hook() 918 .lock() 919 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok(handle)); 920 assert!(run().await.is_ok()); 921 cleanup_identity_artifacts(&path); 922 } 923 924 #[tokio::test] 925 async fn run_starts_rpc_when_start_hook_is_not_set() { 926 let _guard = test_guard().await; 927 let path = unique_identity_path("start-rpc-real"); 928 let args = args_for_identity(path.clone(), true); 929 let settings = settings_with_relays(Vec::new()); 930 *run_load_hook() 931 .lock() 932 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(Ok((args, settings))); 933 *run_wait_hook() 934 .lock() 935 .unwrap_or_else(std::sync::PoisonError::into_inner) = Some(RunWaitOutcome::Shutdown); 936 assert!(run().await.is_ok()); 937 cleanup_identity_artifacts(&path); 938 } 939 940 #[test] 941 fn service_presence_kinds_include_nostr_connect_only() { 942 let kinds = super::service_presence_kinds(); 943 944 assert!(kinds.contains(&(crate::host_nostr::Kind::NostrConnect.as_u16() as u32))); 945 assert_eq!(kinds.len(), 1); 946 } 947 948 #[test] 949 fn service_presence_events_use_strict_profile_and_nip89_contracts() { 950 let identity = DaemonIdentity::generate(); 951 let settings = settings_with_relays(vec!["wss://relay.example.com".to_owned()]); 952 let profile = settings.authored_profile().expect("authored profile"); 953 let handler_spec = ApplicationHandlerSpec::new(super::service_presence_kinds()) 954 .with_identifier("radrootsd") 955 .with_metadata(settings.metadata) 956 .with_relays(settings.config.service.relays); 957 958 let (profile_event, handler_event) = 959 build_service_presence_events(&identity, &profile, &handler_spec) 960 .expect("service presence events"); 961 962 assert_eq!(profile_event.kind, Kind::Metadata); 963 assert!(profile_event.tags.is_empty()); 964 assert_eq!(profile_event.pubkey, identity.public_key()); 965 assert_eq!( 966 serde_json::from_str::<serde_json::Value>(&profile_event.content) 967 .expect("profile JSON"), 968 serde_json::json!({"name": "radrootsd-test"}) 969 ); 970 assert_eq!( 971 handler_event.kind, 972 Kind::Custom(radroots_event::envelope::kind::KIND_APPLICATION_HANDLER as u16) 973 ); 974 assert_eq!(handler_event.pubkey, identity.public_key()); 975 assert!( 976 handler_event.tags.iter().any(|tag| { 977 tag.as_slice() == ["d".to_owned(), "radrootsd".to_owned()].as_slice() 978 }) 979 ); 980 assert!(handler_event.tags.iter().any(|tag| { 981 tag.as_slice() == ["k".to_owned(), Kind::NostrConnect.as_u16().to_string()].as_slice() 982 })); 983 assert!(handler_event.tags.iter().any(|tag| { 984 tag.as_slice() == ["relay".to_owned(), "wss://relay.example.com".to_owned()].as_slice() 985 })); 986 assert!(handler_event.verify().is_ok()); 987 } 988 989 #[tokio::test] 990 async fn bootstrap_presence_fails_closed_without_a_connected_relay() { 991 let _guard = test_guard().await; 992 let identity = DaemonIdentity::generate(); 993 let client = crate::host_nostr::DaemonNostrClient::from_identity(&identity); 994 let settings = settings_with_relays(Vec::new()); 995 let profile = settings.authored_profile().expect("authored profile"); 996 let handler_spec = ApplicationHandlerSpec::new(super::service_presence_kinds()) 997 .with_identifier("radrootsd") 998 .with_metadata(settings.metadata); 999 1000 let error = super::bootstrap_presence(&client, &identity, &profile, &handler_spec) 1001 .await 1002 .expect_err("missing relay connection must fail closed"); 1003 assert!(error.to_string().contains("at least one connected relay")); 1004 } 1005 1006 #[test] 1007 fn runtime_startup_report_prefers_explicit_cli_paths() { 1008 let args = cli::Args { 1009 service: cli::ServiceCliArgs { 1010 config: Some(PathBuf::from("/tmp/radrootsd/config.toml")), 1011 identity: Some(PathBuf::from("/tmp/radrootsd/identity.secret.json")), 1012 allow_generate_identity: false, 1013 }, 1014 command: None, 1015 }; 1016 let mut settings = settings_with_relays(Vec::new()); 1017 settings.config.service.logs_dir = "/tmp/radrootsd/logs".to_string(); 1018 settings.config.transport_publish.database_path = 1019 PathBuf::from("/tmp/radrootsd/transport_publish.sqlite"); 1020 1021 let contract = sample_runtime_contract(); 1022 let report = runtime_startup_report(&args, &settings, &contract); 1023 1024 assert_eq!( 1025 report, 1026 RadrootsdRuntimeStartupReport { 1027 active_profile: "interactive_user".to_string(), 1028 config_path: PathBuf::from("/tmp/radrootsd/config.toml"), 1029 config_path_source: "cli_arg".to_string(), 1030 canonical_config_path: PathBuf::from( 1031 "/home/treesap/.radroots/config/services/radrootsd/config.toml" 1032 ), 1033 logs_dir: PathBuf::from("/tmp/radrootsd/logs"), 1034 logs_dir_source: "config_artifact".to_string(), 1035 canonical_logs_dir: PathBuf::from( 1036 "/home/treesap/.radroots/logs/services/radrootsd" 1037 ), 1038 identity_path: PathBuf::from("/tmp/radrootsd/identity.secret.json"), 1039 identity_path_source: "cli_arg".to_string(), 1040 canonical_identity_path: PathBuf::from( 1041 "/home/treesap/.radroots/secrets/services/radrootsd/identity.secret.json" 1042 ), 1043 transport_publish_database_path: PathBuf::from( 1044 "/tmp/radrootsd/transport_publish.sqlite" 1045 ), 1046 transport_publish_database_path_source: "config_artifact".to_string(), 1047 canonical_transport_publish_database_path: PathBuf::from( 1048 "/home/treesap/.radroots/data/services/radrootsd/transport_publish.sqlite" 1049 ), 1050 path_overrides: sample_runtime_contract().path_overrides, 1051 default_shared_secret_backend: "encrypted_file".to_string(), 1052 allowed_shared_secret_backends: vec!["encrypted_file".to_string()], 1053 } 1054 ); 1055 } 1056 1057 #[test] 1058 fn runtime_startup_report_falls_back_to_canonical_contract_paths() { 1059 let args = cli::Args { 1060 service: cli::ServiceCliArgs { 1061 config: None, 1062 identity: None, 1063 allow_generate_identity: false, 1064 }, 1065 command: None, 1066 }; 1067 let contract = sample_runtime_contract(); 1068 let mut settings = settings_with_relays(Vec::new()); 1069 settings.config.service.logs_dir = contract.canonical_logs_dir.display().to_string(); 1070 settings.config.transport_publish.database_path = 1071 contract.canonical_transport_publish_database_path.clone(); 1072 1073 let report = runtime_startup_report(&args, &settings, &contract); 1074 1075 assert_eq!(report.config_path, contract.canonical_config_path); 1076 assert_eq!(report.config_path_source, "profile_default"); 1077 assert_eq!(report.logs_dir, contract.canonical_logs_dir); 1078 assert_eq!(report.logs_dir_source, "profile_default"); 1079 assert_eq!(report.identity_path, contract.canonical_identity_path); 1080 assert_eq!(report.identity_path_source, "profile_default"); 1081 assert_eq!( 1082 report.transport_publish_database_path, 1083 contract.canonical_transport_publish_database_path 1084 ); 1085 assert_eq!( 1086 report.transport_publish_database_path_source, 1087 "profile_default" 1088 ); 1089 assert_eq!(report.path_overrides, contract.path_overrides); 1090 assert_eq!(report.default_shared_secret_backend, "encrypted_file"); 1091 assert_eq!( 1092 report.allowed_shared_secret_backends, 1093 vec!["encrypted_file".to_string()] 1094 ); 1095 } 1096 }