bestool 1.6.0

BES Deployment tooling
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use std::path::PathBuf;

use binstalk_downloader::download::{Download, PkgFmt};
use clap::Parser;
use detect_targets::get_desired_targets;
use miette::{IntoDiagnostic, Result, bail};
use tracing::{debug, info};

use crate::{
	actions::Context,
	download::{DownloadSource, client},
};

use super::CaddyArgs;

/// Download caddy.
#[derive(Debug, Clone, Parser)]
pub struct DownloadArgs {
	/// Version to download.
	#[arg(value_name = "VERSION", default_value = "latest")]
	pub version: String,

	/// Where to download to.
	#[arg(long)]
	pub path: PathBuf,

	/// Print the URL, don't download.
	///
	/// Useful if you want to download it on a different machine, or with a different tool.
	#[arg(long)]
	pub url_only: bool,

	/// Target to download.
	///
	/// Usually the auto-detected default is fine, in rare cases you may need to override it.
	#[arg(long)]
	pub target: Option<String>,
}

pub async fn run(ctx: Context<CaddyArgs, DownloadArgs>) -> Result<()> {
	let DownloadArgs {
		version,
		path,
		url_only,
		target,
	} = ctx.args_sub;

	let detected_targets = get_desired_targets(target.map(|t| vec![t]));
	let detected_targets = detected_targets.get().await;

	let client = client().await?;

	let host = DownloadSource::Tools.host();

	let mut url = None;
	for target in detected_targets {
		let try_url = host
			.join(&format!(
				"/caddy/{version}/caddy-{target}{ext}?bust={date}",
				ext = if target.contains("windows") {
					".exe"
				} else {
					""
				},
				date = chrono::Utc::now(),
			))
			.into_diagnostic()?;
		debug!(url=%try_url, "trying URL");
		if client
			.remote_gettable(try_url.clone())
			.await
			.into_diagnostic()?
		{
			url.replace((target, try_url));
			break;
		}
	}

	let Some((target, url)) = url else {
		bail!(
			"no valid URL found for caddy {} on {}",
			version,
			detected_targets.join(", ")
		);
	};

	if url_only {
		println!("{}", url);
		return Ok(());
	}

	if !path.exists() {
		debug!(?path, "creating directory");
		std::fs::create_dir_all(&path).into_diagnostic()?;
	}

	let fullpath = path.join(format!(
		"caddy{}",
		if target.contains("windows") {
			".exe"
		} else {
			""
		}
	));

	info!(%url, path=?fullpath, "downloading");
	Download::new(client, url.clone())
		.and_extract(PkgFmt::Bin, &fullpath)
		.await
		.into_diagnostic()?;

	#[cfg(unix)]
	if !target.contains("windows") {
		use std::{
			fs::{Permissions, set_permissions},
			os::unix::fs::PermissionsExt,
		};
		info!(path=?fullpath, "marking as executable");
		set_permissions(&fullpath, Permissions::from_mode(0o755)).into_diagnostic()?;
	}

	Ok(())
}