//! target.json: what a run talks to (staging or prod). Path in SWC_TARGET; tests/targets/prod.json is prod. use std::collections::BTreeMap; use std::path::{Path, PathBuf}; use anyhow::{Context, Result, bail}; use serde::Deserialize; #[derive(Debug, Deserialize)] #[serde(rename_all = "camelCase")] pub struct Target { /// "prod" or "staging" pub name: String, pub plc: String, /// entryway or PDS for app-password sessions of the accounts (staging: the staging PDS) pub pds: String, #[serde(default)] pub relay: Option, #[serde(default)] pub jetstream: Option, pub gateway: Gateway, #[serde(default)] pub atirc: Option, /// the requester binary: "release" (channel stable's version), "release:", "sha:", "local:", "oci:@sha256:", "path:" #[serde(default = "default_requester")] pub requester: String, #[serde(default)] pub bidders: Vec, pub accounts: BTreeMap, /// what an account does in the system tests -> its key in `accounts` (the `role` names). A role the target has /// no account for is left out: a test that asks for it fails #[serde(default)] pub roles: BTreeMap, /// hosts a test may administer as root (staging VMs only: `install requester`, a temporary bidder); ssh destinations #[serde(default)] pub root_hosts: Vec, /// 0003: a restarted invocation's ssh within this many seconds (prod 10) #[serde(default = "default_restart_ssh_max_s")] pub restart_ssh_max_s: f64, /// staging inside one VM: the `dev up --profile market-network` instance every `run request` joins (`--network`) #[serde(default)] pub network: Option, /// a checkout of the requester page repo (atlibs-socialweb-computer-requester): scripts/page-round.mjs (0009) #[serde(default)] pub page_repo: Option, /// a directory of the suite's own tools (a staging VM's, tests/compositions/staging/tools.sh): `deno/deno` and /// `chrome/chrome` drive the OAuth sign-ins (scripts/oauth-signin.ts) instead of the machine's deno and google-chrome #[serde(default)] pub tools: Option, /// atirc agent config (harness, model) for agent VMs; mode 0600, never printed #[serde(default)] pub agent_config: Option, /// a staging network's knotless (dev up --with-knotless) #[serde(default)] pub knotless: Option, /// a market network's XRPC front (status.network.xrpcFront): every named request of the run goes there #[serde(default)] pub xrpc_front: Option, /// the file (0600) holding the shared secret of the read-only operations routes (`ops` of a bidder or the gateway); /// CI writes it from the sealed secret PROD_OPS_READ_SECRET (scripts/ci-prod-target.sh) #[serde(default)] pub ops_secret_file: Option, } /// The network's front (host:port) and the CA bundle (PEM file) its names chain to. #[derive(Debug, Clone, Deserialize)] pub struct XrpcFront { pub address: std::net::SocketAddr, pub ca: String, } #[derive(Debug, Deserialize)] #[serde(rename_all = "camelCase")] pub struct Knotless { /// the gateway's knotless/client.env: the appview, the runner, the PLC, the CA, the egress; no secret pub env: String, /// the published composition the runner's is seeded from (at:///com.fedfork.exec.composition/) pub source: String, /// where its publisher's DID resolves #[serde(default = "default_source_plc")] pub source_plc: String, } fn default_source_plc() -> String { "https://plc.directory".into() } fn default_restart_ssh_max_s() -> f64 { 10.0 } fn default_requester() -> String { "release".into() } #[derive(Debug, Deserialize)] #[serde(rename_all = "camelCase")] pub struct Gateway { /// https://k8s.socialweb.computer pub url: String, /// did:web:k8s.socialweb.computer pub aud: String, /// ssh gateway host (port 22, `ssh -F /dev/null`) pub ssh: String, #[serde(default)] pub ssh_port: Option, /// the ssh gateway's web origin (sign-in, /keys); absent: https://ssh. (prod) #[serde(default)] pub ssh_web: Option, /// the gateway's requester DID (its tenant nodes' VMs on the bidders: 0001 section 6 orphan checks) #[serde(default)] pub requester_did: Option, /// the gateway's own kcp (fault injection, NodeClaim winners); absent on prod unless the lead grants it #[serde(default)] pub kcp: Option, /// the ssh gateway's core log, read over ssh (0002: revoke before release); absent: 0002 does not read it #[serde(default)] pub log: Option, /// the ssh gateway's read-only operations route (com.fedfork.exec.ops.getRequesterLog), in place of `log` over ssh #[serde(default)] pub ops: Option, } /// The read-only operations routes (GET /xrpc/com.fedfork.exec.ops.*) of a bidder or the ssh gateway: the endpoint that /// serves them, exactly one of `url` (an https origin: the gateway's web origin, a bidder's https market endpoint) and /// `iroh` (a bidder's iroh market endpoint, the `endpoint...` ticket of its market.offering record: prod bidders behind /// NAT have no https one). The host reads through them what it otherwise reads with an admin kubeconfig and a shell on /// the host; nothing is written through them. #[derive(Debug, Deserialize, Clone)] #[serde(rename_all = "camelCase")] pub struct OpsRead { #[serde(default)] pub url: Option, #[serde(default)] pub iroh: Option, } impl Gateway { pub fn ssh_web(&self) -> String { match &self.ssh_web { Some(w) => w.trim_end_matches('/').to_string(), None => format!("https://ssh.{}", self.ssh), } } } /// A log file on a host this runner reaches by an ssh alias. #[derive(Debug, Deserialize, Clone)] pub struct GatewayLog { pub host: String, pub path: String, } #[derive(Debug, Deserialize, Clone)] #[serde(rename_all = "camelCase")] pub struct Bidder { pub name: String, pub did: String, pub operator: String, /// the bidder's kcp: host-empty checks, pause, fault injection. Absent: those readings are skipped #[serde(default)] pub kcp: Option, /// its read-only operations routes, when the host has no kcp access to it (prod in CI): reads only, no write #[serde(default)] pub ops: Option, } /// How to reach one kcp: its kubeconfig (credentials, client certs, CA) and a transport. #[derive(Debug, Deserialize, Clone)] #[serde(rename_all = "camelCase")] pub struct KcpEndpoint { pub kubeconfig: String, /// the kcp workspace (root:), put on the kubeconfig's server URL as /clusters/ #[serde(default)] pub workspace: Option, #[serde(default)] pub via: Via, } #[derive(Debug, Deserialize, Clone, Default)] #[serde(rename_all = "camelCase", tag = "kind")] pub enum Via { /// the kubeconfig's server URL as is #[default] Direct, /// the same port on a meshd overlay name (resolved by the overlay's DNS) Overlay { name: String }, /// a dumbpipe ticket that forwards to the kcp front Iroh { ticket: String }, /// an ssh forward through `host` (an ssh alias) to the kubeconfig's host:port (a bidder's front on its loopback) Ssh { host: String }, /// WebRTC: a command that pipes stdin/stdout through a datachannel to the kcp's port, one run per connection. /// Requester::webrtc_proxy builds it (`run requester proxy --contract --tag `: the Go requester's offerer) WebRtc { proxy: Vec }, } #[derive(Debug, Deserialize)] #[serde(rename_all = "camelCase")] pub struct Account { pub handle: String, pub did: String, /// shell file exporting ATPROTO_HANDLE and ATPROTO_PASSWORD; read here only, never printed #[serde(default)] pub creds: String, /// the guest requester R2 of the VM this runs on (knotless CI): `run request --guest-requester`, as the /// renter's contract-scoped agent (its association-ref in /run/socialweb-r2); no creds, no session #[serde(default)] pub guest_requester: bool, /// the oauth-signin.ts --account prefix (ALICE, BOB); none: app password only #[serde(default)] pub oauth_account: Option, /// a host requester associated to this account (plan 0046): `--state-dir --identity `, no password #[serde(default)] pub identity: Option, /// staging throwaway account: tombstoned at teardown #[serde(default)] pub throwaway: bool, } #[derive(Debug, Deserialize, Clone)] #[serde(rename_all = "camelCase")] pub struct AssociatedIdentity { pub name: String, pub state_dir: String, } #[derive(Debug, Deserialize, Clone)] #[serde(rename_all = "camelCase")] pub struct NetworkRef { pub instance: String, /// the instance's --state-dir; a request's state lives under it too (`run request --network` reads its record there) pub state_dir: String, } /// The roles the system tests ask a target for (README.md "Roles"). pub mod role { /// the acceptance requester: rents, signs in at the gateway and the ssh gateway, deletes its own records pub const REQUESTER: &str = "requester"; /// another requester account, vouched as the first is: 0013's long-lived requester under its own account lock pub const SECOND_REQUESTER: &str = "secondRequester"; /// the account the target's bidders are agents of (`bidders[].operator`): 0001's temporary bidder signs in as it pub const BIDDER_OPERATOR: &str = "bidderOperator"; /// an account that is its own atirc root: mints a token (`atirc token`) and reads its owner channel pub const ATIRC_OWNER: &str = "atircOwner"; } pub fn expand(path: &str) -> PathBuf { match path.strip_prefix("~/") { Some(rest) => PathBuf::from(std::env::var("HOME").unwrap_or_default()).join(rest), None => PathBuf::from(path), } } impl Target { pub fn load() -> Result { let path = std::env::var("SWC_TARGET") .context("SWC_TARGET names a target.json (tests/targets/prod.json for prod)")?; let path = expand(&path); let t: Target = serde_json::from_slice( &std::fs::read(&path).with_context(|| path.display().to_string())?, ) .with_context(|| format!("parsing {}", path.display()))?; for (role, name) in &t.roles { if !t.accounts.contains_key(name) { bail!( "{}: role {role} names {name}, not one of its accounts", path.display() ); } } Ok(t) } /// The account that plays `role` (a `role` name) on this target. pub fn role(&self, role: &str) -> Result<&Account> { self.account(self.role_name(role)?) } /// The key in `accounts` of the account that plays `role`. pub fn role_name(&self, role: &str) -> Result<&str> { self.roles .get(role) .map(String::as_str) .with_context(|| format!("the target {} names no {role} account", self.name)) } pub fn account(&self, name: &str) -> Result<&Account> { self.accounts .get(name) .with_context(|| format!("target {} has no account {name}", self.name)) } pub fn bidder_by_did(&self, did: &str) -> Option<&Bidder> { self.bidders.iter().find(|b| b.did == did) } } /// An account's app password, read from its creds file. Debug never shows it. pub struct Secret(String); impl std::fmt::Debug for Secret { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { f.write_str("") } } impl Secret { pub fn expose(&self) -> &str { &self.0 } } impl Account { /// Its DID: the guest requester's, once its first `run request` wrote it, from `/run/socialweb-r2/requester-did`. pub fn did_now(&self) -> String { match self.guest_requester { true => std::fs::read_to_string("/run/socialweb-r2/requester-did") .map(|d| d.trim().to_string()) .unwrap_or_default(), false => self.did.clone(), } } /// The app password: the first variable ending in ATPROTO_PASSWORD. The file must be owner-only. pub fn password(&self) -> Result { let path = expand(&self.creds); check_private(&path)?; let text = std::fs::read_to_string(&path).with_context(|| path.display().to_string())?; for line in text.lines() { let line = line.trim().trim_start_matches("export ").trim(); if let Some((k, v)) = line.split_once('=') && k.ends_with("ATPROTO_PASSWORD") { // one surrounding pair of the same quote is the file's quoting; a quote at one end only is the password's let v = v.trim(); let v = ['"', '\''] .iter() .find_map(|q| v.strip_prefix(*q).and_then(|s| s.strip_suffix(*q))) .unwrap_or(v); return Ok(Secret(v.to_string())); } } bail!("{}: no *ATPROTO_PASSWORD", path.display()) } } pub fn check_private(path: &Path) -> Result<()> { use std::os::unix::fs::PermissionsExt; let mode = std::fs::metadata(path) .with_context(|| path.display().to_string())? .permissions() .mode(); if mode & 0o077 != 0 { bail!( "{} is mode {:o}: chmod 600 it (owner-only)", path.display(), mode & 0o777 ); } Ok(()) }