fn main_inner()

in sources/updater/updog/src/main.rs [491:588]
87 lines of code
7 McCabe index (conditional complexity)

fn main_inner() -> Result<()> {
    // Parse and store the arguments passed to the program
    let arguments = parse_args(std::env::args());

    // SimpleLogger will send errors to stderr and anything less to stdout.
    SimpleLogger::init(arguments.log_level, LogConfig::default()).context(error::Logger)?;

    let command =
        serde_plain::from_str::<Command>(&arguments.subcommand).unwrap_or_else(|_| usage());

    let config = load_config()?;
    set_https_proxy_environment_variables(&config.https_proxy, &config.no_proxy)?;
    let current_release = BottlerocketRelease::new().context(error::ReleaseVersion)?;
    let variant = arguments.variant.unwrap_or(current_release.variant_id);
    let transport = HttpQueryTransport::new();
    // get a shared pointer to the transport's query_params so we can add metrics information to
    // the transport's HTTP calls.
    let mut query_params = transport.query_params();
    set_common_query_params(&mut query_params, &current_release.version_id, &config)?;
    let repository = load_repository(transport, &config)?;
    let manifest = load_manifest(&repository)?;
    let ignore_waves = arguments.ignore_waves || config.ignore_waves;
    match command {
        Command::CheckUpdate | Command::Whats => {
            if arguments.all {
                return list_updates(
                    &manifest,
                    &variant,
                    arguments.json,
                    ignore_waves,
                    config.seed,
                );
            }

            let update = update_required(
                &manifest,
                &current_release.version_id,
                &variant,
                ignore_waves,
                config.seed,
                &config.version_lock,
                arguments.force_version,
            )?
            .context(error::UpdateNotAvailable)?;

            output(arguments.json, &update, &fmt_full_version(&update))?;
        }
        Command::Update | Command::UpdateImage => {
            if let Some(u) = update_required(
                &manifest,
                &current_release.version_id,
                &variant,
                ignore_waves,
                config.seed,
                &config.version_lock,
                arguments.force_version,
            )? {
                eprintln!("Starting update to {}", u.version);
                query_params.add("target", u.version.to_string());
                retrieve_migrations(
                    &repository,
                    &mut query_params,
                    &manifest,
                    u,
                    &current_release.version_id,
                )?;
                update_image(u, &repository)?;
                if command == Command::Update {
                    update_flags()?;
                    if arguments.reboot {
                        initiate_reboot()?;
                    }
                }
                output(
                    arguments.json,
                    &u,
                    &format!("Update applied: {}", fmt_full_version(&u)),
                )?;
            } else {
                eprintln!("No update required");
            }
        }
        Command::UpdateApply => {
            update_flags()?;
            if arguments.reboot {
                initiate_reboot()?;
            }
        }
        Command::UpdateRevert => {
            revert_update_flags()?;
        }
        Command::Prepare => {
            // TODO unimplemented
        }
    }

    Ok(())
}