Skip to content
1        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}725726/// Replaces the user-owned environment of a running app and redeploys it from its727/// current image. Reserved names are kept, and the image is not pulled again.728pub 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    // Only the CLI passes an action. The API path must not write to the925    // server's output.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            // The public URL still routes to the current server, which is the932            // process running this update, so check the new container directly.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    // A server app's previous container is the process handling this update, so956    // it cannot be removed from here without losing the response. The new957    // server removes superseded containers when it starts (see `server::serve`).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}10491050/// The server app keeps its API key in the container environment rather than in1051/// settings, so a replacement container must be given the key again.1052async 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}11411142/// Polls `{url}/up` until it succeeds or two minutes pass.1143async 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}