Files
jcoffey-dev 1d3bb549ea
ci / test (pull_request) Skipped
github/ci (branch) GitHub Actions
ci / github (pull_request) Successful in 6m31s
ci / announce (pull_request) Skipped
Import upstream v1.0.13
Merges upstream's 1.0.12 and 1.0.13, renamed by scripts/upstream-import.py.

Taken: VacationResponse import and export, --replace-source for the DAV
importers, executable files, IMAP \Noselect parents, bounded JMAP import
memory, bare-CR iCalendar and vCard, parse errors that quote the line, the
EWS bare --auth-bearer fix (reading INBUXA_MIGRATE_API_KEY first, as the
rest of the tool does), Files.Read in the Graph scopes, and --account-name
taking the data account from the principal's accounts (RFC 9670).

Kept ours: email export. Upstream batched it in its own way (blobpool.rs);
ours already batches and uploads in parallel, and predicts failures in a dry
run. Its batching tests are left out with it.

Changed: upstream moved FileNode to draft-ietf-jmap-filenode-18 only, which
inbuxa refuses ("Invalid property" for @type). FileNodes are now read in
either shape, a get asks for both shapes' names, and an export asks the
target once which shape it takes (a query sorted by `type`) and writes that.
A live test sends files into the pinned inbuxa image and reads them back;
with the draft-18 shape forced it fails as above. The read-only layout check
also wants the new executable column.
2026-10-30 16:14:45 -07:00

281 lines
9.8 KiB
Rust

/*
* SPDX-FileCopyrightText: 2026 Coffey Labs LLC <[email protected]>
*
* SPDX-License-Identifier: Apache-2.0 OR MIT
*/
//! An inbuxa server, pinned by digest, set up the way a test needs it:
//! started once in recovery mode to make a domain and an administrator,
//! then again normally on the same data, where the administrator makes an
//! API key. The second start lets HTTP Basic through
//! (`INBUXA_HTTP_BASIC_AUTH=all`) so the test can sign in as the users it
//! checks; the migration itself uses the key.
//!
//! Recovery mode makes no roles, and a server seeds its built-in ones on
//! its first normal start only if it has none, so nothing here creates a
//! role before that start.
use std::net::TcpListener;
use std::process::Command;
use std::time::{Duration, Instant};
use encodify::base64::STANDARD;
use serde_json::{Value, json};
use testcontainers::core::{IntoContainerPort, Mount};
use testcontainers::runners::SyncRunner;
use testcontainers::{Container, GenericImage, ImageExt};
use ureq::Agent;
use super::OWNER_LABEL;
use super::error::{ContainerError, ContainerResult};
/// 27.1-rc.4. `GenericImage` joins name and tag with `:`, so the digest is
/// split across the two.
const IMAGE_NAME: &str = "ghcr.io/inbuxa/inbuxa-server@sha256";
const IMAGE_DIGEST: &str = "f43be9a78d3155eaddae7bd95033d5b833eddd11761bab996c1d80913f48b4a6";
const HTTP_PORT: u16 = 8080;
const CONFIG_PATH: &str = "/etc/inbuxa/config.json";
const CONFIG_JSON: &str = r#"{"@type":"RocksDb","path":"/var/lib/inbuxa"}"#;
const RECOVERY_ADMIN: (&str, &str) = ("admin", "admin");
pub const DOMAIN: &str = "example.org";
pub const ADMIN_EMAIL: &str = "[email protected]";
pub const ADMIN_PASSWORD: &str = "Boss-pass-Xq7v2k9w";
pub struct Inbuxa {
container: Option<Container<GenericImage>>,
volume: String,
pub base_url: String,
/// The administrator's API key.
pub token: String,
}
impl Inbuxa {
pub fn start() -> ContainerResult<Self> {
let port = free_port()?;
let base_url = format!("http://127.0.0.1:{port}");
let nanos = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map_or(0, |d| d.as_nanos());
let volume = format!("inbuxa-migrate-itest-{}-{nanos}", std::process::id());
let recovery = run(&volume, port, &base_url, true)?;
let admin = basic(RECOVERY_ADMIN.0, RECOVERY_ADMIN.1);
let session = wait_ready(&base_url, &admin)?;
let account = registry_account(&session)?;
let created = jmap(
&base_url,
&admin,
json!([["x:Domain/set", {"accountId": account, "create": {"d": {"name": DOMAIN}}}, "0"]]),
)?;
let domain_id = created[0][1]["created"]["d"]["id"]
.as_str()
.ok_or_else(|| ContainerError::Seed(format!("domain not created: {created}")))?
.to_owned();
let created = jmap(
&base_url,
&admin,
json!([["x:Account/set", {"accountId": account, "create": {"boss": {
"@type": "User",
"name": "boss",
"domainId": domain_id,
"credentials": {"0": {"@type": "Password", "secret": ADMIN_PASSWORD}},
"roles": {"@type": "Admin"},
}}}, "0"]]),
)?;
if created[0][1]["created"]["boss"].is_null() {
return Err(ContainerError::Seed(format!(
"administrator not created: {created}"
)));
}
drop(recovery);
let container = run(&volume, port, &base_url, false)?;
let admin = basic(ADMIN_EMAIL, ADMIN_PASSWORD);
let session = wait_ready(&base_url, &admin)?;
let account = registry_account(&session)?;
let created = jmap(
&base_url,
&admin,
json!([["x:ApiKey/set", {"accountId": account, "create": {"k": {
"description": "inbuxa-migrate live test",
"permissions": {"@type": "Inherit"},
}}}, "0"]]),
)?;
let token = created[0][1]["created"]["k"]["secret"]
.as_str()
.ok_or_else(|| ContainerError::Seed(format!("no API key: {created}")))?
.to_owned();
Ok(Inbuxa {
container: Some(container),
volume,
base_url,
token,
})
}
/// The account a user's own session names, signed in as that user.
pub fn account_of(&self, email: &str, password: &str) -> ContainerResult<String> {
let session = session(&self.base_url, &basic(email, password))?;
session["primaryAccounts"]["urn:ietf:params:jmap:mail"]
.as_str()
.map(str::to_owned)
.ok_or_else(|| ContainerError::Protocol(format!("no mail account: {session}")))
}
/// A blob's bytes, signed in as `email`.
pub fn download(
&self,
email: &str,
password: &str,
account: &str,
blob: &str,
) -> ContainerResult<Vec<u8>> {
let auth = basic(email, password);
let template = session(&self.base_url, &auth)?["downloadUrl"]
.as_str()
.unwrap_or_default()
.to_owned();
let url = template
.replace("{accountId}", account)
.replace("{blobId}", blob)
.replace("{name}", "blob")
.replace("{type}", "application/octet-stream");
let mut resp = agent().get(&url).header("Authorization", &auth).call()?;
resp.body_mut()
.read_to_vec()
.map_err(|e| ContainerError::Protocol(format!("download: {e}")))
}
/// Method calls, signed in as `email`.
pub fn call(&self, email: &str, password: &str, calls: Value) -> ContainerResult<Value> {
jmap(&self.base_url, &basic(email, password), calls)
}
}
impl Drop for Inbuxa {
fn drop(&mut self) {
drop(self.container.take());
let _ = Command::new("docker")
.args(["volume", "rm", "-f", &self.volume])
.output();
}
}
fn run(
volume: &str,
port: u16,
base_url: &str,
recovery: bool,
) -> ContainerResult<Container<GenericImage>> {
let mut request = GenericImage::new(IMAGE_NAME, IMAGE_DIGEST)
.with_exposed_port(HTTP_PORT.tcp())
.with_env_var("INBUXA_PUBLIC_URL", base_url)
.with_labels([(OWNER_LABEL, "1")])
.with_copy_to(CONFIG_PATH, CONFIG_JSON.as_bytes().to_vec())
.with_mount(Mount::volume_mount(volume, "/var/lib/inbuxa"))
.with_mapped_port(port, HTTP_PORT.tcp())
.with_startup_timeout(Duration::from_secs(180));
request = if recovery {
request
.with_env_var("INBUXA_RECOVERY_MODE", "1")
.with_env_var(
"INBUXA_RECOVERY_ADMIN",
format!("{}:{}", RECOVERY_ADMIN.0, RECOVERY_ADMIN.1),
)
} else {
request.with_env_var("INBUXA_HTTP_BASIC_AUTH", "all")
};
Ok(request.start()?)
}
fn wait_ready(base_url: &str, auth: &str) -> ContainerResult<Value> {
let deadline = Instant::now() + Duration::from_secs(90);
loop {
match session(base_url, auth) {
Ok(s) if s.get("apiUrl").is_some() => return Ok(s),
Ok(s) if Instant::now() > deadline => {
return Err(ContainerError::Protocol(format!("no session: {s}")));
}
Err(e) if Instant::now() > deadline => return Err(e),
_ => std::thread::sleep(Duration::from_millis(500)),
}
}
}
fn session(base_url: &str, auth: &str) -> ContainerResult<Value> {
let mut resp = agent()
.get(format!("{base_url}/jmap/session"))
.header("Authorization", auth)
.call()?;
let status = resp.status().as_u16();
let text = resp
.body_mut()
.read_to_string()
.map_err(|e| ContainerError::Protocol(format!("body read: {e}")))?;
if status != 200 {
return Err(ContainerError::Protocol(format!(
"session status {status}: {text}"
)));
}
serde_json::from_str(&text).map_err(|e| ContainerError::Protocol(format!("session: {e}")))
}
/// The account that carries the registry: an administrator's own.
fn registry_account(session: &Value) -> ContainerResult<String> {
session["accounts"]
.as_object()
.and_then(|accounts| {
accounts.iter().find(|(_, a)| {
a["accountCapabilities"]
.get("urn:inbuxa:jmap:registry")
.is_some()
})
})
.map(|(id, _)| id.clone())
.ok_or_else(|| ContainerError::Protocol(format!("no registry account: {session}")))
}
fn jmap(base_url: &str, auth: &str, calls: Value) -> ContainerResult<Value> {
let body = json!({
"using": [
"urn:ietf:params:jmap:core",
"urn:ietf:params:jmap:mail",
"urn:ietf:params:jmap:sieve",
"urn:ietf:params:jmap:filenode",
"urn:inbuxa:jmap:registry",
],
"methodCalls": calls,
});
let mut resp = agent()
.post(format!("{base_url}/jmap/"))
.header("Authorization", auth)
.header("Content-Type", "application/json")
.send(body.to_string())?;
let text = resp
.body_mut()
.read_to_string()
.map_err(|e| ContainerError::Protocol(format!("body read: {e}")))?;
let reply: Value = serde_json::from_str(&text)
.map_err(|e| ContainerError::Protocol(format!("reply {text}: {e}")))?;
Ok(reply["methodResponses"].clone())
}
fn free_port() -> ContainerResult<u16> {
Ok(TcpListener::bind("127.0.0.1:0")?.local_addr()?.port())
}
fn agent() -> Agent {
Agent::config_builder()
.http_status_as_error(false)
.build()
.new_agent()
}
pub fn basic(user: &str, password: &str) -> String {
let mut header = String::from("Basic ");
STANDARD.encode_append(format!("{user}:{password}"), &mut header);
header
}