LINE1 10 20 30 40 50 60 70 80 90 1001use std::io::IsTerminal;23use std::{4 collections::{BTreeMap, HashMap},5 time::{Duration, Instant},6};78use bollard::models::{9 ContainerCreateBody, EndpointSettings, HostConfig, HostConfigLogConfig, Mount, MountType,10 NetworkingConfig, RestartPolicy, RestartPolicyNameEnum,11};12use rand::{Rng, distributions::Alphanumeric, thread_rng};1314use crate::commands::progress::Spinner;1516use super::{17 backup,18 cli::{KeysResetArgs, KeysSetArgs, SettingsFlags, UpdateArgs},19 error::OnceError,20 model::{21 AppDetail, AppEnvironment, AppSummary, Keys, ONCE_LABEL, RegistrySummary, SERVER_APP_NAME,22 SERVER_LABEL, SmtpSummary, is_reserved_env, reserved_env_names,23 },24 namespace::{Application, Namespace},25 proxy,26};2728#[cfg(all(test, feature = "docker-tests"))]29mod docker_tests;3031fn application<'a>(32 namespace: &'a Namespace,33 host: &str,34) -> Result<&'a super::namespace::Application, OnceError> {35 namespace36 .applications37 .iter()38 .find(|app| app.settings.host == host)39 .ok_or_else(|| OnceError::ApplicationNotFound(host.to_owned()))40}4142pub fn list(namespace: &Namespace) {43 if namespace.applications.is_empty() {44 println!("No applications installed in namespace {}", namespace.name);45 return;46 }47 for app in &namespace.applications {48 let status = if app.running { "running" } else { "stopped" };49 let host = if std::io::stdout().is_terminal() {50 let url = app.url(namespace.proxy_settings.as_ref());51 if url.is_empty() {52 app.settings.host.clone()53 } else {54 format!("\x1b]8;;{url}\x1b\\{}\x1b]8;;\x1b\\", app.settings.host)55 }56 } else {57 app.settings.host.clone()58 };59 println!("{host} ({status})");60 }61}6263pub fn app_summaries(namespace: &Namespace) -> Vec<AppSummary> {64 namespace65 .applications66 .iter()67 .map(|app| app_summary(app, namespace.proxy_settings.as_ref()))68 .collect()69}7071fn app_summary(72 app: &Application,73 proxy_settings: Option<&super::model::ProxySettings>,74) -> AppSummary {75 let url = app.url(proxy_settings);76 AppSummary {77 name: app.settings.name.clone(),78 host: app.settings.host.clone(),79 image: app.settings.image.clone(),80 running: app.running,81 url: (!url.is_empty()).then_some(url),82 is_server: app.is_server,83 }84}8586pub fn app_detail(namespace: &Namespace, host: &str) -> Result<AppDetail, OnceError> {87 let app = application(namespace, host)?;88 let settings = &app.settings;89 Ok(AppDetail {90 summary: app_summary(app, namespace.proxy_settings.as_ref()),91 disable_tls: settings.disable_tls,92 auto_update: settings.auto_update,93 resources: settings.resources.clone(),94 backup: settings.backup.clone(),95 smtp: SmtpSummary {96 server: settings.smtp.server.clone(),97 port: settings.smtp.port.clone(),98 username: settings.smtp.username.clone(),99 from: settings.smtp.from.clone(),100 },101 registry: RegistrySummary {102 host: settings.registry.host.clone(),103 username: settings.registry.username.clone(),104 },105 })106}107108pub fn app_environment(namespace: &Namespace, host: &str) -> Result<AppEnvironment, OnceError> {109 let app = application(namespace, host)?;110 Ok(AppEnvironment {111 env: app.settings.custom_env(app.is_server),112 reserved: reserved_env_names(app.is_server),113 })114}115116pub async fn start(namespace: &Namespace, host: &str) -> Result<(), OnceError> {117 start_inner(namespace, host, true).await118}119120pub async fn start_api(namespace: &Namespace, host: &str) -> Result<(), OnceError> {121 start_inner(namespace, host, false).await122}123124async fn start_inner(125 namespace: &Namespace,126 host: &str,127 print_result: bool,128) -> Result<(), OnceError> {129 let app = application(namespace, host)?;130 let _spinner = print_result.then(|| Spinner::start(format!("Starting {host}")));131 namespace.engine.start_container(&app.container_id).await?;132 if print_result {133 println!("Started {host}");134 }135 Ok(())136}137138pub async fn stop(namespace: &Namespace, host: &str) -> Result<(), OnceError> {139 stop_inner(namespace, host, true).await140}141142pub async fn stop_api(namespace: &Namespace, host: &str) -> Result<(), OnceError> {143 stop_inner(namespace, host, false).await144}145146async fn stop_inner(147 namespace: &Namespace,148 host: &str,149 print_result: bool,150) -> Result<(), OnceError> {151 let app = application(namespace, host)?;152 let _spinner = print_result.then(|| Spinner::start(format!("Stopping {host}")));153 namespace.engine.stop_container(&app.container_id).await?;154 if print_result {155 println!("Stopped {host}");156 }157 Ok(())158}159160pub async fn restart_api(namespace: &Namespace, host: &str) -> Result<(), OnceError> {161 let app = application(namespace, host)?;162 if app.running {163 namespace.engine.stop_container(&app.container_id).await?;164 }165 namespace.engine.start_container(&app.container_id).await?;166 Ok(())167}168169pub async fn backup(170 namespace: &Namespace,171 host: &str,172 filename: &std::path::Path,173) -> Result<(), OnceError> {174 let app = application(namespace, host)?;175 let spinner = Spinner::start(format!("Backing up {host}"));176 let result = backup::create(namespace, app, filename).await;177 drop(spinner);178 if let Ok(mut state) = proxy::load_state(namespace).await {179 let error = result.as_ref().err().map(ToString::to_string);180 state.record_backup(&app.settings.name, error.as_deref());181 let _ = proxy::save_state(namespace, &state).await;182 }183 let filename = result?;184 println!("Backed up {host} to {}", filename.display());185 Ok(())186}187188pub async fn restore(189 namespace: &mut Namespace,190 filename: &std::path::Path,191) -> Result<(), OnceError> {192 let backup = backup::read_metadata(filename)?;193 if namespace194 .applications195 .iter()196 .any(|app| app.settings.host == backup.app.host)197 {198 return Err(OnceError::Io(format!(199 "hostname already in use: {}",200 backup.app.host201 )));202 }203 namespace.setup().await?;204205 let mut settings = backup.app;206 settings.name = unique_app_name(namespace, &image_name(&settings.image));207 if settings.keys == Keys::default() {208 settings.keys = backup.volume_keys;209 }210 if settings.keys == Keys::default() {211 settings.keys.regenerate(true, true);212 }213 let registry = (!settings.registry.username.is_empty()).then_some(&settings.registry);214 {215 let _spinner = Spinner::start(format!("Pulling {}", settings.image));216 namespace217 .engine218 .pull_image_with_credentials(&settings.image, registry)219 .await?;220 }221222 let volume_name = format!("{}-app-{}", namespace.name, settings.name);223 let volume_created = namespace224 .engine225 .ensure_volume(226 &volume_name,227 HashMap::from([(228 ONCE_LABEL.to_owned(),229 serde_json::to_string(&settings.keys)?,230 )]),231 )232 .await?;233234 let spinner = Spinner::start(format!("Restoring data from {}", filename.display()));235 let populate = populate_volume(namespace, &settings, &volume_name, filename).await;236 drop(spinner);237 if let Err(error) = populate {238 if volume_created {239 let _ = namespace.engine.remove_volume(&volume_name).await;240 }241 return Err(error);242 }243 let restore_hook = run_post_restore_hook(namespace, &settings, &volume_name).await;244 if let Err(error) = restore_hook {245 if volume_created {246 let _ = namespace.engine.remove_volume(&volume_name).await;247 }248 return Err(error);249 }250251 deploy_with_volume(252 namespace,253 settings,254 volume_name,255 volume_created,256 None,257 Some("Restored"),258 None,259 )260 .await261}262263async fn populate_volume(264 namespace: &Namespace,265 settings: &super::model::AppSettings,266 volume_name: &str,267 backup_path: &std::path::Path,268) -> Result<(), OnceError> {269 let container_name = format!("{}-restore-temp-{}", namespace.name, random_id());270 let config = ContainerCreateBody {271 image: Some(settings.image.clone()),272 host_config: Some(HostConfig {273 mounts: Some(vec![volume_mount(volume_name, "/data")]),274 ..Default::default()275 }),276 ..Default::default()277 };278 let container_id = namespace279 .engine280 .create_container(&container_name, config)281 .await?;282 let result = async {283 let data_tar = backup::data_archive(backup_path)?;284 namespace285 .engine286 .upload_archive_to_container(&container_id, "/", data_tar)287 .await288 }289 .await;290 let removal = namespace.engine.remove_container(&container_id).await;291 result?;292 removal?;293 Ok(())294}295296async fn run_post_restore_hook(297 namespace: &Namespace,298 settings: &super::model::AppSettings,299 volume_name: &str,300) -> Result<(), OnceError> {301 let container_name = format!("{}-restore-hook-temp-{}", namespace.name, random_id());302 let config = ContainerCreateBody {303 image: Some(settings.image.clone()),304 entrypoint: Some(Vec::new()),305 cmd: Some(vec!["sleep".to_owned(), "infinity".to_owned()]),306 env: Some(settings.build_env(namespace.proxy_settings.as_ref())),307 host_config: Some(HostConfig {308 mounts: Some(vec![309 volume_mount(volume_name, "/storage"),310 volume_mount(volume_name, "/rails/storage"),311 ]),312 ..Default::default()313 }),314 ..Default::default()315 };316 let container_id = namespace317 .engine318 .create_container(&container_name, config)319 .await?;320 let result = async {321 namespace.engine.start_container(&container_id).await?;322 if namespace323 .engine324 .container_path_exists(&container_id, "/hooks/post-restore")325 .await?326 {327 let (code, output) = namespace328 .engine329 .exec_capture(&container_id, &["/hooks/post-restore".to_owned()])330 .await?;331 if code != 0 {332 return Err(OnceError::Docker(format!(333 "post-restore hook failed with status {code}: {output}"334 )));335 }336 }337 Ok::<(), OnceError>(())338 }339 .await;340 let removal = namespace.engine.remove_container(&container_id).await;341 result?;342 removal?;343 Ok(())344}345346pub async fn remove(347 namespace: &mut Namespace,348 host: &str,349 remove_data: bool,350) -> Result<(), OnceError> {351 remove_inner(namespace, host, remove_data, true).await352}353354pub async fn remove_api(355 namespace: &mut Namespace,356 host: &str,357 remove_data: bool,358) -> Result<(), OnceError> {359 remove_inner(namespace, host, remove_data, false).await360}361362async fn remove_inner(363 namespace: &mut Namespace,364 host: &str,365 remove_data: bool,366 print_result: bool,367) -> Result<(), OnceError> {368 let app = application(namespace, host)?.clone();369 let _spinner = print_result.then(|| Spinner::start(format!("Removing {host}")));370 if namespace.proxy_settings.is_some() {371 proxy::remove(namespace, &app.settings.name).await?;372 }373 let prefix = format!("{}-app-{}-", namespace.name, app.settings.name);374 for container in namespace.engine.list_containers().await? {375 if container376 .names377 .iter()378 .any(|name| name.trim_start_matches('/').starts_with(&prefix))379 {380 namespace.engine.remove_container(&container.id).await?;381 }382 }383 if remove_data {384 let volume_name = format!("{}-app-{}", namespace.name, app.settings.name);385 if namespace386 .engine387 .list_volume_names()388 .await?389 .iter()390 .any(|name| name == &volume_name)391 {392 namespace.engine.remove_volume(&volume_name).await?;393 }394 }395 namespace.refresh().await?;396 if print_result {397 println!("Removed {host}");398 }399 Ok(())400}401402pub async fn teardown(namespace: &mut Namespace, remove_data: bool) -> Result<(), OnceError> {403 let app_names = namespace404 .applications405 .iter()406 .map(|app| app.settings.name.clone())407 .collect::<Vec<_>>();408 let _spinner = Spinner::start("Tearing down Ino namespace");409 let containers = namespace.engine.list_containers().await?;410 for app_name in &app_names {411 let prefix = format!("{}-app-{app_name}-", namespace.name);412 for container in &containers {413 if container414 .names415 .iter()416 .any(|name| name.trim_start_matches('/').starts_with(&prefix))417 {418 namespace.engine.remove_container(&container.id).await?;419 }420 }421 }422423 let proxy_name = format!("{}-proxy", namespace.name);424 for container in &containers {425 if container426 .names427 .iter()428 .any(|name| name.trim_start_matches('/') == proxy_name)429 {430 namespace.engine.remove_container(&container.id).await?;431 }432 }433434 let volumes = namespace.engine.list_volume_names().await?;435 for volume in volumes {436 let is_proxy_volume = volume == proxy_name;437 let is_app_data = remove_data438 && app_names439 .iter()440 .any(|app_name| volume == format!("{}-app-{app_name}", namespace.name));441 if is_proxy_volume || is_app_data {442 namespace.engine.remove_volume(&volume).await?;443 }444 }445446 namespace.engine.remove_network(&namespace.name).await?;447 namespace.applications.clear();448 namespace.proxy_settings = None;449 println!("Teardown complete");450 Ok(())451}452453pub async fn exec(454 namespace: &Namespace,455 host: &str,456 arguments: &[String],457) -> Result<(), OnceError> {458 let app = application(namespace, host)?;459 let command = if arguments.first().is_some_and(|arg| arg == "--") {460 &arguments[1..]461 } else {462 arguments463 };464 if command.is_empty() {465 return Err(OnceError::Io("exec requires a command".into()));466 }467468 let exit_code = namespace.engine.exec(&app.container_id, command).await?;469 if exit_code != 0 {470 return Err(OnceError::CommandExit(exit_code));471 }472 Ok(())473}474475pub async fn exec_capture_api(476 namespace: &Namespace,477 host: &str,478 command: &[String],479 max_bytes: usize,480) -> Result<super::docker::CapturedExec, OnceError> {481 let app = application(namespace, host)?;482 if command.is_empty() || command[0].is_empty() {483 return Err(OnceError::Io("exec requires a command".into()));484 }485 namespace486 .engine487 .exec_capture_bounded(&app.container_id, command, max_bytes)488 .await489}490491pub async fn logs_api(492 namespace: &Namespace,493 host: &str,494 tail: u16,495 timestamps: bool,496 max_bytes: usize,497) -> Result<super::docker::BoundedLogs, OnceError> {498 let app = application(namespace, host)?;499 namespace500 .engine501 .logs_bounded(&app.container_id, tail, timestamps, max_bytes)502 .await503}504505pub async fn deploy(506 namespace: &mut Namespace,507 image: &str,508 flags: &SettingsFlags,509) -> Result<(), OnceError> {510 deploy_inner(namespace, image, flags, true).await511}512513pub async fn deploy_api(514 namespace: &mut Namespace,515 image: &str,516 flags: &SettingsFlags,517) -> Result<(), OnceError> {518 deploy_inner(namespace, image, flags, false).await519}520521async fn deploy_inner(522 namespace: &mut Namespace,523 image: &str,524 flags: &SettingsFlags,525 print_result: bool,526) -> Result<(), OnceError> {527 if image.is_empty() {528 return Err(OnceError::Io("image is required".into()));529 }530 namespace.setup().await?;531532 let base_name = image_name(image);533 let name = unique_app_name(namespace, &base_name);534 let host = flags535 .host536 .clone()537 .unwrap_or_else(|| format!("{base_name}.localhost"));538 if namespace539 .applications540 .iter()541 .any(|app| app.settings.host == host)542 {543 return Err(OnceError::HostConflict(host));544 }545546 let mut settings = flags.build_settings(name.clone(), image, host.clone())?;547 settings.keys.regenerate(true, true);548 let registry = (!settings.registry.username.is_empty()).then_some(&settings.registry);549 {550 let _spinner = print_result.then(|| Spinner::start(format!("Pulling {image}")));551 namespace552 .engine553 .pull_image_with_credentials(image, registry)554 .await?;555 }556557 let volume_name = format!("{}-app-{name}", namespace.name);558 let legacy_volume_settings = serde_json::to_string(&settings.keys)?;559 let volume_created = namespace560 .engine561 .ensure_volume(562 &volume_name,563 HashMap::from([(ONCE_LABEL.to_owned(), legacy_volume_settings)]),564 )565 .await?;566567 deploy_with_volume(568 namespace,569 settings,570 volume_name,571 volume_created,572 None,573 print_result.then_some("Deployed"),574 None,575 )576 .await577}578579pub async fn setup_server(580 namespace: &mut Namespace,581 image: &str,582 host: &str,583 port: u16,584 api_key: &str,585) -> Result<(), OnceError> {586 if image.is_empty() || host.is_empty() || port == 0 || api_key.is_empty() {587 return Err(OnceError::Io(588 "server image, host, port, and API key are required".into(),589 ));590 }591 let previous = namespace592 .applications593 .iter()594 .find(|app| app.is_server)595 .cloned();596 if namespace.applications.iter().any(|app| {597 (app.settings.name == SERVER_APP_NAME || app.settings.host == host) && !app.is_server598 }) {599 return Err(OnceError::HostConflict(host.to_owned()));600 }601 namespace.setup().await?;602603 let mut settings = previous.as_ref().map_or_else(604 || super::model::AppSettings {605 name: SERVER_APP_NAME.to_owned(),606 ..Default::default()607 },608 |app| app.settings.clone(),609 );610 SERVER_APP_NAME.clone_into(&mut settings.name);611 settings.image = image.to_owned();612 settings.host = host.to_owned();613 settings.auto_update = false;614 settings.env_vars.remove("INO_API_KEY");615 settings616 .env_vars617 .insert("PORT".to_owned(), port.to_string());618 if settings.keys == Keys::default() {619 settings.keys.regenerate(true, true);620 }621622 if !namespace.engine.image_exists(image).await? {623 namespace.engine.pull_image(image).await?;624 }625 let volume_name = format!("{}-app-{SERVER_APP_NAME}", namespace.name);626 let volume_created = namespace627 .engine628 .ensure_volume(629 &volume_name,630 HashMap::from([(631 ONCE_LABEL.to_owned(),632 serde_json::to_string(&settings.keys)?,633 )]),634 )635 .await?;636 deploy_with_volume(637 namespace,638 settings,639 volume_name,640 volume_created,641 previous,642 Some("Configured server"),643 Some(ServerRuntime {644 api_key: api_key.to_owned(),645 }),646 )647 .await648}649650pub async fn update(651 namespace: &mut Namespace,652 current_host: &str,653 args: &UpdateArgs,654) -> Result<(), OnceError> {655 update_inner(namespace, current_host, args, true).await656}657658pub async fn update_api(659 namespace: &mut Namespace,660 current_host: &str,661 args: &UpdateArgs,662) -> Result<(), OnceError> {663 update_inner(namespace, current_host, args, false).await664}665666async fn update_inner(667 namespace: &mut Namespace,668 current_host: &str,669 args: &UpdateArgs,670 print_result: bool,671) -> Result<(), OnceError> {672 let previous = application(namespace, current_host)?.clone();673 namespace.setup().await?;674 let mut settings = args675 .settings676 .apply_changes(&previous.settings, args.image.as_deref())?;677 if previous.is_server {678 settings.auto_update = false;679 }680 let server_runtime = server_runtime_for(namespace, &previous).await?;681 if namespace.applications.iter().any(|app| {682 app.settings.host == settings.host && app.settings.name != previous.settings.name683 }) {684 return Err(OnceError::HostConflict(settings.host));685 }686687 let registry = (!settings.registry.username.is_empty()).then_some(&settings.registry);688 {689 let _spinner = print_result.then(|| Spinner::start(format!("Pulling {}", settings.image)));690 namespace691 .engine692 .pull_image_with_credentials(&settings.image, registry)693 .await?;694 }695 let volume_name = format!("{}-app-{}", namespace.name, settings.name);696 let volume_created = namespace697 .engine698 .ensure_volume(699 &volume_name,700 HashMap::from([(701 ONCE_LABEL.to_owned(),702 serde_json::to_string(&settings.keys)?,703 )]),704 )705 .await?;706 let app_name = settings.name.clone();707 let result = deploy_with_volume(708 namespace,709 settings,710 volume_name,711 volume_created,712 Some(previous),713 print_result.then_some("Updated"),714 server_runtime,715 )716 .await;717718 if let Ok(mut state) = proxy::load_state(namespace).await {719 let error = result.as_ref().err().map(ToString::to_string);720 state.record_update(&app_name, error.as_deref());721 let _ = proxy::save_state(namespace, &state).await;722 }723 result724}725726727728pub async fn set_env_api(729 namespace: &mut Namespace,730 host: &str,731 env: &BTreeMap<String, String>,732) -> Result<(), OnceError> {733 let previous = application(namespace, host)?.clone();734 if !previous.running {735 return Err(OnceError::ApplicationNotRunning(host.to_owned()));736 }737 if let Some(name) = env738 .keys()739 .find(|name| is_reserved_env(name, previous.is_server))740 {741 return Err(OnceError::ReservedEnvironment(name.clone()));742 }743 namespace.setup().await?;744 let mut settings = previous.settings.clone();745 settings.replace_custom_env(env, previous.is_server);746 let server_runtime = server_runtime_for(namespace, &previous).await?;747 let volume_name = format!("{}-app-{}", namespace.name, settings.name);748 let volume_created = namespace749 .engine750 .ensure_volume(751 &volume_name,752 HashMap::from([(753 ONCE_LABEL.to_owned(),754 serde_json::to_string(&settings.keys)?,755 )]),756 )757 .await?;758 deploy_with_volume(759 namespace,760 settings,761 volume_name,762 volume_created,763 Some(previous),764 None,765 server_runtime,766 )767 .await768}769770pub async fn auto_update(namespace: &mut Namespace, app_name: &str) -> Result<bool, OnceError> {771 let previous = namespace772 .applications773 .iter()774 .find(|app| app.settings.name == app_name)775 .cloned()776 .ok_or_else(|| OnceError::ApplicationNotFound(app_name.to_owned()))?;777 if previous.is_server || !previous.running || !previous.settings.auto_update {778 return Ok(false);779 }780 namespace.setup().await?;781 let registry =782 (!previous.settings.registry.username.is_empty()).then_some(&previous.settings.registry);783 namespace784 .engine785 .pull_image_with_credentials(&previous.settings.image, registry)786 .await?;787 let new_image_id = namespace.engine.image_id(&previous.settings.image).await?;788 let running_image_id = namespace789 .engine790 .container_image_id(&previous.container_id)791 .await?;792 if new_image_id == running_image_id {793 return Ok(false);794 }795796 let volume_name = format!("{}-app-{app_name}", namespace.name);797 let volume_created = namespace798 .engine799 .ensure_volume(800 &volume_name,801 HashMap::from([(802 ONCE_LABEL.to_owned(),803 serde_json::to_string(&previous.settings.keys)?,804 )]),805 )806 .await?;807 deploy_with_volume(808 namespace,809 previous.settings.clone(),810 volume_name,811 volume_created,812 Some(previous),813 Some("Updated"),814 None,815 )816 .await?;817 Ok(true)818}819820pub async fn reset_keys(namespace: &mut Namespace, args: &KeysResetArgs) -> Result<(), OnceError> {821 if !args.secret_key_base && !args.vapid {822 return Err(OnceError::Io(823 "at least one of --secret-key-base or --vapid is required".into(),824 ));825 }826 let app = application(namespace, &args.host)?.clone();827 if !app.running {828 return Err(OnceError::ApplicationNotRunning(args.host.clone()));829 }830 namespace.setup().await?;831 let mut settings = app.settings.clone();832 settings.keys.regenerate(args.secret_key_base, args.vapid);833 redeploy_keys(namespace, app, settings, "Reset keys for").await834}835836pub async fn set_keys(namespace: &mut Namespace, args: &KeysSetArgs) -> Result<(), OnceError> {837 if args.secret_key_base.is_none() && args.vapid.is_none() {838 return Err(OnceError::Io(839 "at least one of --secret-key-base or --vapid is required".into(),840 ));841 }842 if args.secret_key_base.as_deref() == Some("") {843 return Err(OnceError::Io("secret key base must not be empty".into()));844 }845 let app = application(namespace, &args.host)?.clone();846 if !app.running {847 return Err(OnceError::ApplicationNotRunning(args.host.clone()));848 }849 namespace.setup().await?;850 let mut settings = app.settings.clone();851 if let Some(secret_key_base) = &args.secret_key_base {852 settings.keys.secret_key_base = secret_key_base.clone();853 }854 if let Some(vapid) = &args.vapid {855 settings.keys.set_vapid_key(vapid)?;856 }857 redeploy_keys(namespace, app, settings, "Set keys for").await858}859860async fn redeploy_keys(861 namespace: &mut Namespace,862 previous: Application,863 settings: super::model::AppSettings,864 action: &str,865) -> Result<(), OnceError> {866 let volume_name = format!("{}-app-{}", namespace.name, settings.name);867 let volume_created = namespace868 .engine869 .ensure_volume(870 &volume_name,871 HashMap::from([(872 ONCE_LABEL.to_owned(),873 serde_json::to_string(&settings.keys)?,874 )]),875 )876 .await?;877 deploy_with_volume(878 namespace,879 settings,880 volume_name,881 volume_created,882 Some(previous),883 Some(action),884 None,885 )886 .await887}888889async fn deploy_with_volume(890 namespace: &mut Namespace,891 settings: super::model::AppSettings,892 volume_name: String,893 volume_created: bool,894 previous: Option<Application>,895 action: Option<&str>,896 server_runtime: Option<ServerRuntime>,897) -> Result<(), OnceError> {898 let name = settings.name.clone();899 let host = settings.host.clone();900 let container_name = format!("{}-app-{name}-{}", namespace.name, random_id());901 let config = app_container_config(namespace, &settings, &volume_name, server_runtime.as_ref())?;902903 let container_id = match namespace904 .engine905 .create_container(&container_name, config)906 .await907 {908 Ok(id) => id,909 Err(error) => {910 if volume_created {911 let _ = namespace.engine.remove_volume(&volume_name).await;912 }913 return Err(error);914 }915 };916 let app = Application {917 container_id: container_id.clone(),918 settings,919 running: false,920 created: 0,921 is_server: server_runtime.is_some(),922 };923924 925 926 let spinner =927 action.map(|_| Spinner::start(format!("Starting {host} and waiting for it to respond")));928 let deployment = async {929 namespace.engine.start_container(&container_id).await?;930 if app.is_server {931 932 933 let address = proxy::target_address(&app, &container_id);934 verify_readiness(&format!("http://{address}")).await?;935 }936 proxy::deploy(&*namespace, &app, &container_id).await?;937 verify_http(&app, namespace.proxy_settings.as_ref()).await938 }939 .await;940 drop(spinner);941942 if let Err(error) = deployment {943 if let Some(previous) = &previous {944 let _ = proxy::deploy(namespace, previous, &previous.container_id).await;945 } else {946 let _ = proxy::remove(namespace, &name).await;947 }948 let _ = namespace.engine.remove_container(&container_id).await;949 if volume_created {950 let _ = namespace.engine.remove_volume(&volume_name).await;951 }952 return Err(error);953 }954955 956 957 958 if !app.is_server {959 let app_prefix = format!("{}-app-{name}-", namespace.name);960 for old in namespace.engine.list_containers().await? {961 if old.id != container_id962 && old963 .names964 .iter()965 .any(|old_name| old_name.trim_start_matches('/').starts_with(&app_prefix))966 {967 namespace.engine.remove_container(&old.id).await?;968 }969 }970 }971972 namespace.refresh().await?;973 if let Some(action) = action {974 println!("{action} {host}");975 }976 Ok(())977}978979fn app_container_config(980 namespace: &Namespace,981 settings: &super::model::AppSettings,982 volume_name: &str,983 server_runtime: Option<&ServerRuntime>,984) -> Result<ContainerCreateBody, OnceError> {985 let mut log_config = HashMap::new();986 log_config.insert("max-size".to_owned(), "10m".to_owned());987 log_config.insert("max-file".to_owned(), "1".to_owned());988 let mut labels = HashMap::from([(ONCE_LABEL.to_owned(), serde_json::to_string(&settings)?)]);989 let mut env = settings.build_env(namespace.proxy_settings.as_ref());990 let mut mounts = vec![991 volume_mount(volume_name, "/storage"),992 volume_mount(volume_name, "/rails/storage"),993 ];994 if let Some(runtime) = server_runtime {995 labels.insert(SERVER_LABEL.to_owned(), "true".to_owned());996 env.push(format!("INO_API_KEY={}", runtime.api_key));997 mounts.push(Mount {998 typ: Some(MountType::BIND),999 source: Some("/var/run/docker.sock".to_owned()),1000 target: Some("/var/run/docker.sock".to_owned()),1001 ..Default::default()1002 });1003 }1004 let cmd = server_runtime.map(|_| {1005 vec![1006 "ino".to_owned(),1007 "once".to_owned(),1008 "--namespace".to_owned(),1009 namespace.name.clone(),1010 "server".to_owned(),1011 "serve".to_owned(),1012 ]1013 });10141015 Ok(ContainerCreateBody {1016 image: Some(settings.image.clone()),1017 cmd,1018 env: Some(env),1019 labels: Some(labels),1020 host_config: Some(HostConfig {1021 memory: (settings.resources.memory_mb > 0)1022 .then_some(i64::from(settings.resources.memory_mb) * 1024 * 1024),1023 nano_cpus: (settings.resources.cpus > 0)1024 .then_some(i64::from(settings.resources.cpus) * 1_000_000_000),1025 restart_policy: Some(RestartPolicy {1026 name: Some(RestartPolicyNameEnum::ALWAYS),1027 maximum_retry_count: None,1028 }),1029 log_config: Some(HostConfigLogConfig {1030 typ: Some("json-file".to_owned()),1031 config: Some(log_config),1032 }),1033 mounts: Some(mounts),1034 ..Default::default()1035 }),1036 networking_config: Some(NetworkingConfig {1037 endpoints_config: Some(HashMap::from([(1038 namespace.name.clone(),1039 EndpointSettings::default(),1040 )])),1041 }),1042 ..Default::default()1043 })1044}10451046struct ServerRuntime {1047 api_key: String,1048}1049105010511052async fn server_runtime_for(1053 namespace: &Namespace,1054 app: &Application,1055) -> Result<Option<ServerRuntime>, OnceError> {1056 if !app.is_server {1057 return Ok(None);1058 }1059 let key = namespace1060 .engine1061 .container_environment(&app.container_id)1062 .await?1063 .into_iter()1064 .find_map(|entry| entry.strip_prefix("INO_API_KEY=").map(str::to_owned))1065 .filter(|key| !key.is_empty())1066 .ok_or_else(|| OnceError::Io("server runtime API key is unavailable".into()))?;1067 Ok(Some(ServerRuntime { api_key: key }))1068}10691070fn image_name(image: &str) -> String {1071 let without_digest = image.split('@').next().unwrap_or(image);1072 let leaf = without_digest.rsplit('/').next().unwrap_or(without_digest);1073 let name = leaf.split(':').next().unwrap_or(leaf);1074 let name = name1075 .chars()1076 .map(|character| {1077 if character.is_ascii_alphanumeric() {1078 character.to_ascii_lowercase()1079 } else {1080 '-'1081 }1082 })1083 .collect::<String>();1084 name.trim_matches('-').to_owned()1085}10861087fn unique_app_name(namespace: &Namespace, base: &str) -> String {1088 loop {1089 let candidate = format!("{base}.{}", random_id());1090 if !namespace1091 .applications1092 .iter()1093 .any(|app| app.settings.name == candidate)1094 {1095 return candidate;1096 }1097 }1098}10991100fn random_id() -> String {1101 let mut rng = thread_rng();1102 (0..6)1103 .map(|_| rng.sample(Alphanumeric) as char)1104 .collect::<String>()1105 .to_lowercase()1106}11071108fn volume_mount(source: &str, target: &str) -> Mount {1109 Mount {1110 typ: Some(MountType::VOLUME),1111 source: Some(source.to_owned()),1112 target: Some(target.to_owned()),1113 ..Default::default()1114 }1115}11161117async fn verify_http(1118 app: &Application,1119 proxy_settings: Option<&super::model::ProxySettings>,1120) -> Result<(), OnceError> {1121 let url = app.url(proxy_settings);1122 if url.is_empty() {1123 return Ok(());1124 }1125 let response = reqwest::Client::builder()1126 .timeout(Duration::from_secs(30))1127 .build()1128 .map_err(|error| OnceError::Docker(error.to_string()))?1129 .get(format!("{url}/up"))1130 .send()1131 .await1132 .map_err(|error| OnceError::Docker(format!("verification failed: {error}")))?;1133 if !response.status().is_success() {1134 return Err(OnceError::Docker(format!(1135 "verification failed: unexpected HTTP status {} from {url}",1136 response.status()1137 )));1138 }1139 Ok(())1140}114111421143async fn verify_readiness(url: &str) -> Result<(), OnceError> {1144 let client = reqwest::Client::builder()1145 .timeout(Duration::from_secs(5))1146 .build()1147 .map_err(|error| OnceError::Docker(error.to_string()))?;1148 let deadline = Instant::now() + Duration::from_mins(2);11491150 loop {1151 let last_failure = match client.get(format!("{url}/up")).send().await {1152 Ok(response) if response.status().is_success() => return Ok(()),1153 Ok(response) => format!("unexpected HTTP status {}", response.status()),1154 Err(error) => error.to_string(),1155 };1156 if Instant::now() >= deadline {1157 return Err(OnceError::Docker(format!(1158 "server readiness verification failed for {url}: {last_failure}"1159 )));1160 }1161 tokio::time::sleep(Duration::from_millis(500)).await;1162 }1163}11641165#[cfg(test)]1166mod tests {1167 use std::collections::HashMap;11681169 use super::{app_summary, image_name};1170 use crate::commands::once::{1171 model::{AppSettings, Keys, RegistrySettings, SmtpSettings},1172 namespace::Application,1173 };11741175 #[test]1176 fn derives_once_app_base_name_from_image_reference() {1177 assert_eq!(image_name("basecamp/writebook:latest"), "writebook");1178 assert_eq!(image_name("registry.example.test/team/app:v1"), "app");1179 assert_eq!(1180 image_name("registry.example.test/team/my_app@sha256:abc"),1181 "my-app"1182 );1183 }11841185 #[test]1186 fn app_summaries_do_not_expose_application_secrets() {1187 let app = Application {1188 container_id: "container-id".into(),1189 settings: AppSettings {1190 name: "writer".into(),1191 image: "example.test/writer:v1".into(),1192 host: "writer.example.test".into(),1193 env_vars: HashMap::from([("PRIVATE_TOKEN".into(), "env-secret".into())]),1194 smtp: SmtpSettings {1195 password: "smtp-secret".into(),1196 ..Default::default()1197 },1198 keys: Keys {1199 secret_key_base: "once-key-secret".into(),1200 ..Default::default()1201 },1202 registry: RegistrySettings {1203 username: "registry-user".into(),1204 password: "registry-secret".into(),1205 ..Default::default()1206 },1207 ..Default::default()1208 },1209 running: true,1210 created: 1,1211 is_server: false,1212 };12131214 let summary = app_summary(&app, None);1215 let encoded = serde_json::to_string(&summary).unwrap();1216 assert_eq!(summary.host, "writer.example.test");1217 assert_eq!(summary.url.as_deref(), Some("https://writer.example.test"));1218 for secret in [1219 "env-secret",1220 "smtp-secret",1221 "once-key-secret",1222 "registry-secret",1223 ] {1224 assert!(!encoded.contains(secret));1225 }1226 }1227}