150 lines
6.0 KiB
Rust
150 lines
6.0 KiB
Rust
//! Seed empty platform catalogs from the operator's protected distribution
|
|
//! directory during enrollment. Every download still uses the customer's own
|
|
//! catalog, stable-worker pin and verified object store.
|
|
use super::*;
|
|
|
|
#[derive(Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
struct Starter {
|
|
envelope: ReleaseEnvelope,
|
|
worker: Pin,
|
|
}
|
|
|
|
pub(in crate::agent_updates) async fn publish_missing(
|
|
tx: &mut Transaction<'_, Postgres>,
|
|
tenant: Uuid,
|
|
) -> Result<(), Error> {
|
|
let Some(slot) = std::env::var_os("RMM_AGENT_BOOTSTRAP_LINUX_FILE")
|
|
.or_else(|| std::env::var_os("RMM_AGENT_BOOTSTRAP_LINUX_ARM64_FILE"))
|
|
else {
|
|
return Ok(());
|
|
};
|
|
let Some(config_dir) = FsPath::new(&slot).parent() else {
|
|
return Err(invalid());
|
|
};
|
|
let distribution = config_dir.join("customer-starters");
|
|
if !distribution
|
|
.try_exists()
|
|
.map_err(|_| fail("STARTER_CONFIGURATION"))?
|
|
{
|
|
return Ok(());
|
|
}
|
|
for platform in [
|
|
Platform::LinuxX64,
|
|
Platform::LinuxArm64,
|
|
Platform::WindowsGnuX64,
|
|
Platform::WindowsX64,
|
|
] {
|
|
let name = platform_name(platform);
|
|
let exists: bool = sqlx::query_scalar(
|
|
"SELECT EXISTS(SELECT FROM agent_update_releases WHERE platform=$1)",
|
|
)
|
|
.bind(name)
|
|
.fetch_one(&mut **tx)
|
|
.await?;
|
|
if exists {
|
|
continue;
|
|
}
|
|
let path = if official_windows(platform) {
|
|
distribution.join(format!("{name}-official.json"))
|
|
} else {
|
|
distribution.join(format!("{name}.json"))
|
|
};
|
|
if !path
|
|
.try_exists()
|
|
.map_err(|_| fail("STARTER_CONFIGURATION"))?
|
|
{
|
|
continue;
|
|
}
|
|
// Other requests may be publishing the first package for this customer.
|
|
sqlx::query("SELECT pg_advisory_xact_lock(hashtextextended($1, 312))")
|
|
.bind(format!("{tenant}/{name}"))
|
|
.execute(&mut **tx)
|
|
.await?;
|
|
let exists: bool = sqlx::query_scalar(
|
|
"SELECT EXISTS(SELECT FROM agent_update_releases WHERE platform=$1)",
|
|
)
|
|
.bind(name)
|
|
.fetch_one(&mut **tx)
|
|
.await?;
|
|
if exists {
|
|
continue;
|
|
}
|
|
let package: Starter = serde_json::from_slice(&protected_file(&path, 65536)?)?;
|
|
let manifest = verify_envelope(&package.envelope, None)?;
|
|
if manifest.platform != platform {
|
|
return Err(invalid());
|
|
}
|
|
let root =
|
|
std::env::var("RMM_AGENT_UPDATE_ARTIFACT_DIR").map_err(|_| fail("STARTER_STORE"))?;
|
|
if !FsPath::new(&root).is_absolute() {
|
|
return Err(invalid());
|
|
}
|
|
let owner = fs::symlink_metadata(&path)
|
|
.map_err(|_| fail("STARTER_CONFIGURATION"))?
|
|
.uid();
|
|
let src = distribution.clone();
|
|
let mut files: Vec<_> = manifest
|
|
.artifacts
|
|
.iter()
|
|
.map(|a| (a.sha256.clone(), a.bytes))
|
|
.collect();
|
|
files.push((package.worker.sha256.clone(), package.worker.bytes));
|
|
tokio::task::spawn_blocking(move || -> Result<(), Error> {
|
|
let store = UpdateArtifacts::private_directory(root.into(), owner)?;
|
|
for (digest, size) in files {
|
|
let mut staged = store.begin(tenant, &digest, size)?;
|
|
let mut file = fs::OpenOptions::new()
|
|
.read(true)
|
|
.custom_flags(libc::O_NOFOLLOW | libc::O_CLOEXEC)
|
|
.open(src.join(&digest))
|
|
.map_err(|_| fail("STARTER_OBJECT_MISSING"))?;
|
|
let meta = file
|
|
.metadata()
|
|
.map_err(|_| fail("STARTER_OBJECT_METADATA"))?;
|
|
if !meta.is_file()
|
|
|| meta.uid() != owner
|
|
|| meta.mode() & 0o777 != 0o600
|
|
|| meta.len() != size
|
|
{
|
|
return Err(fail("STARTER_OBJECT_METADATA"));
|
|
}
|
|
let mut buffer = [0; 65536];
|
|
loop {
|
|
let n = file
|
|
.read(&mut buffer)
|
|
.map_err(|_| fail("STARTER_OBJECT_READ"))?;
|
|
if n == 0 {
|
|
break;
|
|
}
|
|
staged.append(&buffer[..n])?;
|
|
}
|
|
staged.finish(&store, tenant)?;
|
|
}
|
|
Ok(())
|
|
})
|
|
.await
|
|
.map_err(|_| fail("STARTER_OBJECT_COPY"))??;
|
|
for artifact in &manifest.artifacts {
|
|
sqlx::query("INSERT INTO agent_update_artifacts(tenant_id,artifact_id,sha256,size_bytes) VALUES($1,$2,$3,$4) ON CONFLICT DO NOTHING")
|
|
.bind(tenant).bind(artifact.artifact_id).bind(&artifact.sha256).bind(artifact.bytes as i64).execute(&mut **tx).await?;
|
|
}
|
|
let raw = encode(&package.envelope)?;
|
|
let a = &manifest.artifacts[0];
|
|
let h = &manifest.artifacts[1];
|
|
sqlx::query("INSERT INTO agent_update_releases(tenant_id,release_id,platform,release_sequence,manifest_sha256,envelope_sha256,envelope,agent_artifact_id,agent_sha256,agent_bytes,helper_artifact_id,helper_sha256,helper_bytes) VALUES($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13)")
|
|
.bind(tenant).bind(manifest.release_id).bind(name).bind(i64::try_from(manifest.release_sequence).map_err(|_|invalid())?)
|
|
.bind(hash(&package.envelope.decode().map_err(|_|invalid())?.payload_bytes)).bind(hash(&raw)).bind(raw)
|
|
.bind(a.artifact_id).bind(&a.sha256).bind(a.bytes as i64).bind(h.artifact_id).bind(&h.sha256).bind(h.bytes as i64).execute(&mut **tx).await?;
|
|
sqlx::query("INSERT INTO customer_starter_workers(tenant_id,platform,sha256,size_bytes,official_windows) VALUES($1,$2,$3,$4,$5)")
|
|
.bind(tenant)
|
|
.bind(name)
|
|
.bind(package.worker.sha256)
|
|
.bind(package.worker.bytes as i64)
|
|
.bind(official_windows(platform))
|
|
.execute(&mut **tx)
|
|
.await?;
|
|
}
|
|
Ok(())
|
|
}
|