//! 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(()) }