Add export-directory: a server's accounts, groups, lists and aliases, without secrets #28
No files matched your search
@@ -18,6 +18,11 @@ candidates before a series ships (`27.1-rc.1`). The tag is the version with a
|
||||
archive), flags, keywords where the folder keeps them, and arrival times.
|
||||
Like `export`, it matches what is already there, so running it again
|
||||
writes only what changed.
|
||||
- `export-directory` writes who is on a server: its domains, users, groups,
|
||||
mailing lists, aliases, quotas, tenants and roles, read from the registry
|
||||
with an administrator's login, as `directory.json` and CSV files that
|
||||
another server can be set up from. Credentials, OTP seeds, API keys and
|
||||
DKIM keys are never asked for. `--domain` keeps it to some domains.
|
||||
|
||||
### Changed
|
||||
- `import maildir` reads folder names in modified UTF-7, as Dovecot and
|
||||
|
||||
@@ -19,6 +19,7 @@ contacts, identities, Sieve scripts and files.
|
||||
inbuxa-migrate export … alice.sqlite the archive into inbuxa
|
||||
inbuxa-migrate export-files alice.sqlite out the archive as plain files
|
||||
inbuxa-migrate export-imap … alice.sqlite its mail into any IMAP server
|
||||
inbuxa-migrate export-directory … out a server's accounts, no secrets
|
||||
|
||||
Between the two sides sits an archive: one SQLite file holding one account.
|
||||
`import` fills it from the old server; `export` writes it into the new one.
|
||||
@@ -39,7 +40,9 @@ advertises the types being written. `export-imap` writes the mail into any
|
||||
IMAP server, and `export-files` is the way out to everything else: it writes
|
||||
the archive as a Maildir++ tree, vCard, iCalendar and Sieve files that other
|
||||
servers and mail, calendar and contacts apps open, with no network and no
|
||||
store format in the way. The full command reference is in
|
||||
store format in the way. For a whole server, `export-directory` writes the
|
||||
list of domains, accounts, groups, lists and aliases to set up again
|
||||
elsewhere, without passwords. The full command reference is in
|
||||
[docs/usage.md](docs/usage.md).
|
||||
|
||||
## Sources
|
||||
|
||||
+52
-1
@@ -13,7 +13,7 @@ and how to install it.
|
||||
## Commands and global flags
|
||||
|
||||
```
|
||||
inbuxa-migrate <import|export|export-imap|export-files|inspect> [args...]
|
||||
inbuxa-migrate <import|export|export-imap|export-files|export-directory|inspect> [args...]
|
||||
```
|
||||
|
||||
Every command takes a few global flags -- verbosity, worker pool size, retry
|
||||
@@ -375,6 +375,57 @@ the way to finish it is to run again into an empty directory.
|
||||
type writes all of mail, and the same for contacts and calendars. With
|
||||
`--dry-run` it counts what it would write and creates nothing.
|
||||
|
||||
## Export a directory
|
||||
|
||||
```
|
||||
inbuxa-migrate export-directory \
|
||||
--url <URL> \
|
||||
(--auth-basic <USER> [--auth-password <PASS>] | --auth-bearer [TOKEN]) \
|
||||
[--domain <NAME>]... [--dry-run] \
|
||||
<DIR>
|
||||
```
|
||||
|
||||
Writes who has an address on a server, so the same accounts can be set up
|
||||
on another one: domains, users, groups, mailing lists, their aliases and
|
||||
quotas, and the tenants and roles they belong to. It reads inbuxa's
|
||||
registry, or Stalwart's, so the login must be an administrator's. Mail and
|
||||
the rest of each account's data move with `import` and the exports above.
|
||||
|
||||
Nothing secret is written, because nothing secret is asked for: every read
|
||||
names the fields it wants, and credentials, app passwords, OTP seeds, API
|
||||
keys, encryption keys and DKIM keys are not among them. Each new server
|
||||
sets its own passwords and DKIM keys.
|
||||
|
||||
```
|
||||
DIR/
|
||||
directory.json everything below, exactly, with roles and tenants
|
||||
domains.csv name, enabled, aliases, catch-all, sub-addressing, tenant
|
||||
users.csv address, description, roles, groups, aliases, disk quota
|
||||
groups.csv address, members, aliases, disk quota
|
||||
lists.csv address, recipients, aliases
|
||||
aliases.csv each alias with the address it delivers to
|
||||
```
|
||||
|
||||
- Accounts, groups and lists are named by address, and roles and tenants by
|
||||
name, never by the server's ids. A group lists its members, a user the
|
||||
groups it is in.
|
||||
- Roles are `user`, `admin` or `default`, or the custom roles by name;
|
||||
`permissions` holds what an account adds to its roles (`merge`) or has in
|
||||
their place (`replace`).
|
||||
- Quotas are by name, in bytes or counts (`maxDiskQuota` and the rest); the
|
||||
CSV files show `maxDiskQuota` as `disk_quota`.
|
||||
- In the CSV files, a cell with several values joins them with `;`. The
|
||||
text comes from the server and these files are made to be opened in a
|
||||
spreadsheet, so a cell that one would run as a formula starts with `'`.
|
||||
`directory.json` keeps every value as it is.
|
||||
|
||||
`--domain` keeps the export to the domains named, with what they use:
|
||||
their tenants and the roles their accounts hold. A group's members on
|
||||
other domains are still listed by address. `DIR` must be new or empty, and
|
||||
is made readable by its owner only. `directory.json` is written last, so a
|
||||
directory without one was interrupted. With `--dry-run` it reads the
|
||||
registry and counts what it would write, and creates nothing.
|
||||
|
||||
## Inspect
|
||||
|
||||
```
|
||||
|
||||
+84
@@ -14,6 +14,7 @@ use crate::error::Error;
|
||||
use crate::exchange_ews::oauth::OAuthFlow;
|
||||
use crate::exchange_ews::types::MailboxKind;
|
||||
use crate::exchange_graph::types::{EventBodyFormat, MailboxKind as GraphMailboxKind, Surfaces};
|
||||
use crate::export_directory::ExportDirectoryConfig;
|
||||
use crate::export_files::ExportFilesConfig;
|
||||
use crate::inspect::InspectConfig;
|
||||
use crate::jmap::account::AccountSelector;
|
||||
@@ -61,6 +62,11 @@ enum Command {
|
||||
name = "export-imap"
|
||||
)]
|
||||
ExportImap(Box<ExportImapArgs>),
|
||||
#[command(
|
||||
about = "Write a server's domains, accounts, groups, lists and aliases as JSON and CSV, without secrets",
|
||||
name = "export-directory"
|
||||
)]
|
||||
ExportDirectory(Box<ExportDirectoryArgs>),
|
||||
#[command(about = "Show the contents of a local archive (read-only)")]
|
||||
Inspect(Box<InspectArgs>),
|
||||
}
|
||||
@@ -445,6 +451,64 @@ struct ExportFilesArgs {
|
||||
dir: PathBuf,
|
||||
}
|
||||
|
||||
#[derive(Args)]
|
||||
#[command(group(clap::ArgGroup::new("auth").required(true).args(["auth_basic", "auth_bearer"])))]
|
||||
struct ExportDirectoryArgs {
|
||||
#[arg(long, value_name = "URL", help = "Base URL or full JMAP session URL")]
|
||||
url: String,
|
||||
|
||||
#[arg(long, value_name = "USER", help = "HTTP Basic user (an administrator)")]
|
||||
auth_basic: Option<String>,
|
||||
|
||||
#[arg(
|
||||
long,
|
||||
value_name = "PASS",
|
||||
help = "Basic password (prefer $INBUXA_MIGRATE_PASSWORD or prompt)"
|
||||
)]
|
||||
auth_password: Option<String>,
|
||||
|
||||
#[arg(
|
||||
long,
|
||||
value_name = "TOKEN",
|
||||
num_args = 0..=1,
|
||||
help = "API key or bearer token (value optional: falls back to $INBUXA_MIGRATE_API_KEY or prompt)"
|
||||
)]
|
||||
auth_bearer: Option<Option<String>>,
|
||||
|
||||
#[arg(
|
||||
long,
|
||||
value_name = "NAME",
|
||||
help = "Only this domain (repeatable; default: every domain)"
|
||||
)]
|
||||
domain: Vec<String>,
|
||||
|
||||
#[arg(long, help = "Count what would be written; write nothing")]
|
||||
dry_run: bool,
|
||||
|
||||
#[arg(
|
||||
long,
|
||||
value_name = "N",
|
||||
default_value_t = 5,
|
||||
help = "Max retry attempts per request on transient failures"
|
||||
)]
|
||||
max_retries: u32,
|
||||
|
||||
#[arg(
|
||||
long,
|
||||
help = "Accept an invalid TLS certificate from the --url host only; sign-in endpoints are always verified"
|
||||
)]
|
||||
allow_invalid_certs: bool,
|
||||
|
||||
#[arg(short = 'v', long, action = ArgAction::Count, conflicts_with = "quiet", help = "Increase log verbosity")]
|
||||
verbose: u8,
|
||||
|
||||
#[arg(short = 'q', long, help = "Quiet: warnings and errors only")]
|
||||
quiet: bool,
|
||||
|
||||
#[arg(value_name = "DIR", help = "Directory to write, new or empty")]
|
||||
dir: PathBuf,
|
||||
}
|
||||
|
||||
#[derive(Args)]
|
||||
struct InspectArgs {
|
||||
#[arg(value_name = "ARCHIVE", help = "Local SQLite archive")]
|
||||
@@ -483,6 +547,7 @@ pub enum Action {
|
||||
ImportExchangeGraph(CommonConfig, GraphImportConfig),
|
||||
Export(CommonConfig, ExportConfig),
|
||||
ExportFiles(ExportFilesConfig),
|
||||
ExportDirectory(ExportDirectoryConfig),
|
||||
ExportImap(CommonConfig, ExportImapConfig),
|
||||
Inspect(InspectConfig),
|
||||
}
|
||||
@@ -610,6 +675,7 @@ impl Cli {
|
||||
Command::Import { source } => resolve_import(source),
|
||||
Command::Export(args) => resolve_export(*args),
|
||||
Command::ExportFiles(args) => resolve_export_files(*args),
|
||||
Command::ExportDirectory(args) => resolve_export_directory(*args),
|
||||
Command::ExportImap(args) => resolve_export_imap(*args),
|
||||
Command::Inspect(args) => resolve_inspect(*args),
|
||||
}
|
||||
@@ -1018,6 +1084,24 @@ fn resolve_export_files(args: ExportFilesArgs) -> Result<Action, Error> {
|
||||
}))
|
||||
}
|
||||
|
||||
fn resolve_export_directory(args: ExportDirectoryArgs) -> Result<Action, Error> {
|
||||
let auth = resolve_auth(
|
||||
args.auth_basic.as_deref(),
|
||||
args.auth_password.as_deref(),
|
||||
args.auth_bearer.as_ref(),
|
||||
)?;
|
||||
Ok(Action::ExportDirectory(ExportDirectoryConfig {
|
||||
url: args.url,
|
||||
auth,
|
||||
dir: args.dir,
|
||||
domains: args.domain,
|
||||
dry_run: args.dry_run,
|
||||
max_retries: args.max_retries,
|
||||
allow_invalid_certs: args.allow_invalid_certs,
|
||||
logger: Logger::from_flags(args.quiet, args.verbose),
|
||||
}))
|
||||
}
|
||||
|
||||
fn resolve_inspect(args: InspectArgs) -> Result<Action, Error> {
|
||||
let target = match args.target.as_deref() {
|
||||
Some(token) => Some(ObjectType::parse(token)?),
|
||||
|
||||
@@ -0,0 +1,88 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2026 Coffey Labs LLC <[email protected]>
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
*/
|
||||
|
||||
//! CSV as RFC 4180 writes it: CRLF line ends, and a field quoted when it
|
||||
//! holds a comma, a quote or a line break. The text comes from the server,
|
||||
//! and these files are meant to be opened in a spreadsheet, so a field that
|
||||
//! one would run as a formula is written with a leading `'`.
|
||||
//! `directory.json` keeps every value exactly.
|
||||
|
||||
use std::fs;
|
||||
use std::path::Path;
|
||||
|
||||
use super::model::Table;
|
||||
|
||||
pub fn field(value: &str) -> String {
|
||||
let guarded;
|
||||
let value = if value.starts_with(['=', '+', '-', '@', '\t', '\r']) {
|
||||
guarded = format!("'{value}");
|
||||
guarded.as_str()
|
||||
} else {
|
||||
value
|
||||
};
|
||||
if value.contains([',', '"', '\r', '\n']) {
|
||||
format!("\"{}\"", value.replace('"', "\"\""))
|
||||
} else {
|
||||
value.to_owned()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn render((header, rows): &Table) -> String {
|
||||
let mut out = String::new();
|
||||
let mut line = |cells: &mut dyn Iterator<Item = &str>| {
|
||||
let cells: Vec<String> = cells.map(field).collect();
|
||||
out.push_str(&cells.join(","));
|
||||
out.push_str("\r\n");
|
||||
};
|
||||
line(&mut header.iter().copied());
|
||||
for row in rows {
|
||||
line(&mut row.iter().map(String::as_str));
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
pub fn write(path: &Path, table: &Table) -> std::io::Result<()> {
|
||||
fs::write(path, render(table))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn plain_fields_are_left_alone() {
|
||||
assert_eq!(field("[email protected]"), "[email protected]");
|
||||
assert_eq!(field("Alice Example"), "Alice Example");
|
||||
assert_eq!(field(""), "");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn commas_quotes_and_breaks_are_quoted() {
|
||||
assert_eq!(field("Smith, Jane"), "\"Smith, Jane\"");
|
||||
assert_eq!(field("say \"hi\""), "\"say \"\"hi\"\"\"");
|
||||
assert_eq!(field("two\nlines"), "\"two\nlines\"");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn formulas_are_not_left_to_run() {
|
||||
assert_eq!(field("=HYPERLINK(\"x\")"), "\"'=HYPERLINK(\"\"x\"\")\"");
|
||||
assert_eq!(field("+1"), "'+1");
|
||||
assert_eq!(field("-note"), "'-note");
|
||||
assert_eq!(field("@SUM(A1)"), "'@SUM(A1)");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_table_is_crlf_lines() {
|
||||
let table: Table = (
|
||||
vec!["email", "description"],
|
||||
vec![vec!["[email protected]".to_owned(), "x, y".to_owned()]],
|
||||
);
|
||||
assert_eq!(
|
||||
render(&table),
|
||||
"email,description\r\n[email protected],\"x, y\"\r\n"
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,259 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2026 Coffey Labs LLC <[email protected]>
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
*/
|
||||
|
||||
//! `export-directory`: who has an address on a server, without their
|
||||
//! secrets. Domains, users, groups, mailing lists, aliases, quotas, tenants
|
||||
//! and roles are read from the registry with an administrator's
|
||||
//! credentials and written as `directory.json` and CSV files, so the same
|
||||
//! accounts can be set up on any server. Credentials, OTP seeds, API keys
|
||||
//! and DKIM keys are never asked for, so they can't be written.
|
||||
|
||||
use std::collections::HashSet;
|
||||
use std::fs;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use serde_json::{Value, json};
|
||||
use time::OffsetDateTime;
|
||||
use time::format_description::well_known::Rfc3339;
|
||||
|
||||
use crate::error::Error;
|
||||
use crate::export_files::{check_target, make_private_dir};
|
||||
use crate::jmap::error::JmapError;
|
||||
use crate::jmap::http::{Auth, HttpClient, RetryPolicy};
|
||||
use crate::jmap::request::{Request, URN_INBUXA_REGISTRY, check_method_error};
|
||||
use crate::jmap::session::{Limits, Session};
|
||||
use crate::logging::Logger;
|
||||
use crate::net::CertOverride;
|
||||
use crate::sync::Summary;
|
||||
|
||||
pub mod csv;
|
||||
pub mod model;
|
||||
|
||||
/// The layout this release writes; raised when `directory.json` or a CSV
|
||||
/// changes in a way a reader has to know about.
|
||||
pub const FORMAT_VERSION: u32 = 1;
|
||||
|
||||
// Every property is named, so nothing the registry adds later, and none of
|
||||
// `credentials`, `encryptionAtRest` or the DKIM keys, is ever fetched.
|
||||
const DOMAIN_PROPERTIES: &[&str] = &[
|
||||
"name",
|
||||
"aliases",
|
||||
"isEnabled",
|
||||
"description",
|
||||
"memberTenantId",
|
||||
"catchAllAddress",
|
||||
"subAddressing",
|
||||
];
|
||||
// `@type` tells a user from a group, and is only sent when asked for.
|
||||
const ACCOUNT_PROPERTIES: &[&str] = &[
|
||||
"@type",
|
||||
"name",
|
||||
"domainId",
|
||||
"description",
|
||||
"memberGroupIds",
|
||||
"memberTenantId",
|
||||
"roles",
|
||||
"permissions",
|
||||
"quotas",
|
||||
"aliases",
|
||||
"externalId",
|
||||
"locale",
|
||||
"timeZone",
|
||||
];
|
||||
const LIST_PROPERTIES: &[&str] = &[
|
||||
"name",
|
||||
"domainId",
|
||||
"description",
|
||||
"aliases",
|
||||
"memberTenantId",
|
||||
"recipients",
|
||||
];
|
||||
const TENANT_PROPERTIES: &[&str] = &["name", "quotas"];
|
||||
const ROLE_PROPERTIES: &[&str] = &[
|
||||
"description",
|
||||
"memberTenantId",
|
||||
"roleIds",
|
||||
"enabledPermissions",
|
||||
"disabledPermissions",
|
||||
];
|
||||
|
||||
pub struct ExportDirectoryConfig {
|
||||
pub url: String,
|
||||
pub auth: Auth,
|
||||
pub dir: PathBuf,
|
||||
/// Domains to write, by name; empty for every domain.
|
||||
pub domains: Vec<String>,
|
||||
pub dry_run: bool,
|
||||
pub max_retries: u32,
|
||||
pub allow_invalid_certs: bool,
|
||||
pub logger: Logger,
|
||||
}
|
||||
|
||||
pub fn run(config: ExportDirectoryConfig) -> Result<Summary, Error> {
|
||||
check_target(&config.dir)?;
|
||||
let logger = config.logger;
|
||||
let client = HttpClient::new(
|
||||
config.auth.clone(),
|
||||
RetryPolicy::new(config.max_retries),
|
||||
CertOverride::for_url(config.allow_invalid_certs, &config.url),
|
||||
);
|
||||
client.set_logger(logger);
|
||||
let session = Session::discover(&client, &config.url)?;
|
||||
for mismatch in session.origin_mismatches(&config.url) {
|
||||
logger.warn(&mismatch.to_string());
|
||||
}
|
||||
let limits = session.core_limits()?;
|
||||
client.set_limits(&limits);
|
||||
let (account_id, urn) = session.registry_account().ok_or_else(|| {
|
||||
Error::Account(format!(
|
||||
"this login can't read the server's registry ({URN_INBUXA_REGISTRY}); \
|
||||
export-directory needs an administrator's credentials"
|
||||
))
|
||||
})?;
|
||||
let reader = Reader {
|
||||
client: &client,
|
||||
api_url: &session.api_url,
|
||||
account_id,
|
||||
urn,
|
||||
limits,
|
||||
};
|
||||
let raw = model::Raw {
|
||||
domains: reader.all("x:Domain", DOMAIN_PROPERTIES)?,
|
||||
accounts: reader.all("x:Account", ACCOUNT_PROPERTIES)?,
|
||||
lists: reader.all("x:MailingList", LIST_PROPERTIES)?,
|
||||
tenants: reader.optional("x:Tenant", TENANT_PROPERTIES, logger)?,
|
||||
roles: reader.optional("x:Role", ROLE_PROPERTIES, logger)?,
|
||||
};
|
||||
let directory = model::build(&raw, &config.domains, logger)?;
|
||||
let summary = directory.summary();
|
||||
|
||||
let dir = config.dir.as_path();
|
||||
if config.dry_run {
|
||||
logger.warn(&format!(
|
||||
"dry run: nothing was written; {} would hold what is counted below",
|
||||
dir.display()
|
||||
));
|
||||
return Ok(summary);
|
||||
}
|
||||
make_private_dir(dir)?;
|
||||
write(&directory, dir, &config.url)?;
|
||||
Ok(summary)
|
||||
}
|
||||
|
||||
fn write(directory: &model::Directory, dir: &Path, url: &str) -> Result<(), Error> {
|
||||
csv::write(&dir.join("domains.csv"), &directory.domains_csv())?;
|
||||
csv::write(&dir.join("users.csv"), &directory.users_csv())?;
|
||||
csv::write(&dir.join("groups.csv"), &directory.groups_csv())?;
|
||||
csv::write(&dir.join("lists.csv"), &directory.lists_csv())?;
|
||||
csv::write(&dir.join("aliases.csv"), &directory.aliases_csv())?;
|
||||
let document = json!({
|
||||
"format": "inbuxa-migrate-directory",
|
||||
"formatVersion": FORMAT_VERSION,
|
||||
"createdBy": format!("inbuxa-migrate {}", crate::version::shown()),
|
||||
"created": OffsetDateTime::now_utc().format(&Rfc3339).unwrap_or_default(),
|
||||
"source": { "url": url },
|
||||
"domains": directory.domains,
|
||||
"tenants": directory.tenants,
|
||||
"roles": directory.roles,
|
||||
"users": directory.users,
|
||||
"groups": directory.groups,
|
||||
"lists": directory.lists,
|
||||
});
|
||||
// Written last, so a directory with a directory.json is a finished one.
|
||||
let text = serde_json::to_string_pretty(&document).map_err(std::io::Error::other)?;
|
||||
fs::write(dir.join("directory.json"), text + "\n")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
struct Reader<'a> {
|
||||
client: &'a HttpClient,
|
||||
api_url: &'a str,
|
||||
account_id: &'a str,
|
||||
urn: &'static str,
|
||||
limits: Limits,
|
||||
}
|
||||
|
||||
impl Reader<'_> {
|
||||
/// Every object of one registry type, with only `properties` (and `id`).
|
||||
fn all(&self, ty: &str, properties: &[&str]) -> Result<Vec<Value>, JmapError> {
|
||||
let ids = self.ids(ty)?;
|
||||
let chunk = usize::try_from(self.limits.max_objects_in_get.max(1)).unwrap_or(500);
|
||||
let mut out = Vec::with_capacity(ids.len());
|
||||
for ids in ids.chunks(chunk) {
|
||||
let mut req = Request::new();
|
||||
req.registry(Some(self.urn));
|
||||
req.call(
|
||||
format!("{ty}/get"),
|
||||
json!({ "accountId": self.account_id, "ids": ids, "properties": properties }),
|
||||
"g",
|
||||
);
|
||||
let resp = req.send(self.client, self.api_url)?;
|
||||
let mr = resp.first()?;
|
||||
check_method_error(mr)?;
|
||||
let list = mr
|
||||
.args
|
||||
.get("list")
|
||||
.and_then(Value::as_array)
|
||||
.ok_or_else(|| JmapError::malformed(format!("{ty}/get response has no list")))?;
|
||||
out.extend(list.iter().cloned());
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// As `all`, for a type this login may not be allowed to read, or a
|
||||
/// server may not have: that is a warning and an empty list.
|
||||
fn optional(
|
||||
&self,
|
||||
ty: &str,
|
||||
properties: &[&str],
|
||||
logger: Logger,
|
||||
) -> Result<Vec<Value>, JmapError> {
|
||||
match self.all(ty, properties) {
|
||||
Ok(list) => Ok(list),
|
||||
Err(e @ (JmapError::Method { .. } | JmapError::UnknownMethod)) => {
|
||||
logger.warn(&format!("{ty} can't be read here ({e}); none are written"));
|
||||
Ok(Vec::new())
|
||||
}
|
||||
Err(e) => Err(e),
|
||||
}
|
||||
}
|
||||
|
||||
/// Ids page by page. A server that returns every id at once and ignores
|
||||
/// `position` hands back nothing new on the second page, which ends it.
|
||||
fn ids(&self, ty: &str) -> Result<Vec<String>, JmapError> {
|
||||
let mut ids = Vec::new();
|
||||
let mut seen = HashSet::new();
|
||||
loop {
|
||||
let mut req = Request::new();
|
||||
req.registry(Some(self.urn));
|
||||
req.call(
|
||||
format!("{ty}/query"),
|
||||
json!({ "accountId": self.account_id, "position": ids.len() }),
|
||||
"q",
|
||||
);
|
||||
let resp = req.send(self.client, self.api_url)?;
|
||||
let mr = resp.first()?;
|
||||
check_method_error(mr)?;
|
||||
let page = mr
|
||||
.args
|
||||
.get("ids")
|
||||
.and_then(Value::as_array)
|
||||
.ok_or_else(|| JmapError::malformed(format!("{ty}/query response has no ids")))?;
|
||||
let before = ids.len();
|
||||
for id in page {
|
||||
let id = id.as_str().ok_or_else(|| {
|
||||
JmapError::malformed(format!("{ty}/query id is not a string"))
|
||||
})?;
|
||||
if seen.insert(id.to_owned()) {
|
||||
ids.push(id.to_owned());
|
||||
}
|
||||
}
|
||||
if ids.len() == before {
|
||||
return Ok(ids);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,783 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2026 Coffey Labs LLC <[email protected]>
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
*/
|
||||
|
||||
//! Registry objects as a directory any server can be set up from: ids
|
||||
//! become addresses and names, and only the fields listed here are kept.
|
||||
|
||||
use std::collections::{BTreeSet, HashMap, HashSet};
|
||||
|
||||
use serde_json::{Map, Value, json};
|
||||
|
||||
use crate::error::Error;
|
||||
use crate::logging::Logger;
|
||||
use crate::sync::{Summary, TypeCounts};
|
||||
|
||||
/// What the registry returned, one list per type.
|
||||
#[derive(Default)]
|
||||
pub struct Raw {
|
||||
pub domains: Vec<Value>,
|
||||
pub accounts: Vec<Value>,
|
||||
pub lists: Vec<Value>,
|
||||
pub tenants: Vec<Value>,
|
||||
pub roles: Vec<Value>,
|
||||
}
|
||||
|
||||
/// The directory as `directory.json` holds it, each list sorted by name or
|
||||
/// address.
|
||||
#[derive(Debug, Default)]
|
||||
pub struct Directory {
|
||||
pub domains: Vec<Value>,
|
||||
pub tenants: Vec<Value>,
|
||||
pub roles: Vec<Value>,
|
||||
pub users: Vec<Value>,
|
||||
pub groups: Vec<Value>,
|
||||
pub lists: Vec<Value>,
|
||||
/// Objects left out because they point at something that isn't there.
|
||||
skipped: HashMap<&'static str, u64>,
|
||||
}
|
||||
|
||||
fn str_of<'a>(v: &'a Value, key: &str) -> Option<&'a str> {
|
||||
v.get(key).and_then(Value::as_str)
|
||||
}
|
||||
|
||||
/// A registry set: `{"a": true, "b": true}` (or a plain array), sorted.
|
||||
fn set_of(v: &Value, key: &str) -> Vec<String> {
|
||||
let set: BTreeSet<String> = match v.get(key) {
|
||||
Some(Value::Object(map)) => map
|
||||
.iter()
|
||||
.filter(|(_, on)| on.as_bool() != Some(false))
|
||||
.map(|(k, _)| k.clone())
|
||||
.collect(),
|
||||
Some(Value::Array(items)) => items
|
||||
.iter()
|
||||
.filter_map(Value::as_str)
|
||||
.map(str::to_owned)
|
||||
.collect(),
|
||||
_ => BTreeSet::new(),
|
||||
};
|
||||
set.into_iter().collect()
|
||||
}
|
||||
|
||||
/// A registry list: `{"0": {...}, "1": {...}}` (or a plain array), in order.
|
||||
fn list_of<'a>(v: &'a Value, key: &str) -> Vec<&'a Value> {
|
||||
match v.get(key) {
|
||||
Some(Value::Object(map)) => {
|
||||
let mut items: Vec<(u64, &Value)> = map
|
||||
.iter()
|
||||
.map(|(k, item)| (k.parse().unwrap_or(u64::MAX), item))
|
||||
.collect();
|
||||
items.sort_by_key(|(k, _)| *k);
|
||||
items.into_iter().map(|(_, item)| item).collect()
|
||||
}
|
||||
Some(Value::Array(items)) => items.iter().collect(),
|
||||
_ => Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn opt(v: Option<&str>) -> Value {
|
||||
v.map_or(Value::Null, |s| Value::String(s.to_owned()))
|
||||
}
|
||||
|
||||
/// Quotas are counts and byte sizes by name, `maxDiskQuota` and the rest.
|
||||
fn quotas_of(v: &Value) -> Value {
|
||||
let map: Map<String, Value> = v
|
||||
.get("quotas")
|
||||
.and_then(Value::as_object)
|
||||
.map(|q| {
|
||||
q.iter()
|
||||
.filter(|(_, n)| n.is_u64())
|
||||
.map(|(k, n)| (k.clone(), n.clone()))
|
||||
.collect()
|
||||
})
|
||||
.unwrap_or_default();
|
||||
Value::Object(map)
|
||||
}
|
||||
|
||||
fn type_of(v: &Value) -> &str {
|
||||
str_of(v, "@type").unwrap_or_default()
|
||||
}
|
||||
|
||||
struct Names {
|
||||
domains: HashMap<String, String>,
|
||||
tenants: HashMap<String, String>,
|
||||
roles: HashMap<String, String>,
|
||||
}
|
||||
|
||||
impl Names {
|
||||
fn domain(&self, id: Option<&str>) -> Option<&str> {
|
||||
id.and_then(|id| self.domains.get(id)).map(String::as_str)
|
||||
}
|
||||
|
||||
fn tenant(&self, v: &Value) -> Value {
|
||||
opt(str_of(v, "memberTenantId").and_then(|id| self.tenants.get(id).map(String::as_str)))
|
||||
}
|
||||
|
||||
fn roles(&self, ids: &[String]) -> Vec<String> {
|
||||
ids.iter()
|
||||
.filter_map(|id| self.roles.get(id).cloned())
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// `name@domain`; a name that is already an address is kept.
|
||||
fn address(&self, v: &Value) -> Option<String> {
|
||||
let name = str_of(v, "name")?;
|
||||
if name.contains('@') {
|
||||
return Some(name.to_owned());
|
||||
}
|
||||
Some(format!("{name}@{}", self.domain(str_of(v, "domainId"))?))
|
||||
}
|
||||
|
||||
fn aliases(&self, v: &Value) -> Vec<Value> {
|
||||
let mut out: Vec<Value> = list_of(v, "aliases")
|
||||
.into_iter()
|
||||
.filter_map(|a| {
|
||||
Some(json!({
|
||||
"email": self.address(a)?,
|
||||
"enabled": a.get("enabled").and_then(Value::as_bool).unwrap_or(true),
|
||||
"description": opt(str_of(a, "description")),
|
||||
}))
|
||||
})
|
||||
.collect();
|
||||
out.sort_by(|a, b| str_of(a, "email").cmp(&str_of(b, "email")));
|
||||
out
|
||||
}
|
||||
|
||||
/// `"user"`, `"admin"` or `"default"`, or the custom roles by name.
|
||||
fn role_of(&self, v: &Value) -> Value {
|
||||
let roles = v.get("roles").unwrap_or(&Value::Null);
|
||||
match type_of(roles) {
|
||||
"Custom" => json!({ "custom": self.roles(&set_of(roles, "roleIds")) }),
|
||||
"" => Value::Null,
|
||||
other => Value::String(other.to_ascii_lowercase()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// What an account may do beyond its roles: nothing for `Inherit`, else
|
||||
/// the permissions it adds (`merge`) or has instead (`replace`).
|
||||
fn permissions_of(v: &Value) -> Value {
|
||||
let Some(p) = v.get("permissions") else {
|
||||
return Value::Null;
|
||||
};
|
||||
match type_of(p) {
|
||||
"Merge" | "Replace" => json!({
|
||||
"mode": type_of(p).to_ascii_lowercase(),
|
||||
"enabled": set_of(p, "enabledPermissions"),
|
||||
"disabled": set_of(p, "disabledPermissions"),
|
||||
}),
|
||||
_ => Value::Null,
|
||||
}
|
||||
}
|
||||
|
||||
fn sub_addressing_of(v: &Value) -> Value {
|
||||
let Some(s) = v.get("subAddressing") else {
|
||||
return Value::Null;
|
||||
};
|
||||
match type_of(s) {
|
||||
"Custom" => json!({ "customRule": s.get("customRule").cloned().unwrap_or(Value::Null) }),
|
||||
"" => Value::Null,
|
||||
other => Value::String(other.to_ascii_lowercase()),
|
||||
}
|
||||
}
|
||||
|
||||
fn id_of(v: &Value) -> Option<&str> {
|
||||
str_of(v, "id")
|
||||
}
|
||||
|
||||
pub fn build(raw: &Raw, only: &[String], logger: Logger) -> Result<Directory, Error> {
|
||||
let by_id = |list: &[Value], key: &str| -> HashMap<String, String> {
|
||||
list.iter()
|
||||
.filter_map(|v| Some((id_of(v)?.to_owned(), str_of(v, key)?.to_owned())))
|
||||
.collect()
|
||||
};
|
||||
let names = Names {
|
||||
domains: by_id(&raw.domains, "name"),
|
||||
tenants: by_id(&raw.tenants, "name"),
|
||||
roles: by_id(&raw.roles, "description"),
|
||||
};
|
||||
|
||||
let only: HashSet<String> = only.iter().map(|d| d.to_ascii_lowercase()).collect();
|
||||
for wanted in &only {
|
||||
if !names
|
||||
.domains
|
||||
.values()
|
||||
.any(|d| d.eq_ignore_ascii_case(wanted))
|
||||
{
|
||||
return Err(Error::Usage(format!("the server has no domain {wanted}")));
|
||||
}
|
||||
}
|
||||
let selected = |v: &Value| -> bool {
|
||||
only.is_empty()
|
||||
|| names
|
||||
.domain(str_of(v, "domainId"))
|
||||
.is_some_and(|d| only.contains(&d.to_ascii_lowercase()))
|
||||
};
|
||||
|
||||
let mut dir = Directory::default();
|
||||
let mut tenant_ids: HashSet<String> = HashSet::new();
|
||||
let mut role_ids: Vec<String> = Vec::new();
|
||||
let mut note_refs = |v: &Value| {
|
||||
if let Some(t) = str_of(v, "memberTenantId") {
|
||||
tenant_ids.insert(t.to_owned());
|
||||
}
|
||||
if let Some(r) = v.get("roles") {
|
||||
role_ids.extend(set_of(r, "roleIds"));
|
||||
}
|
||||
};
|
||||
|
||||
for d in &raw.domains {
|
||||
let Some(name) = str_of(d, "name") else {
|
||||
continue;
|
||||
};
|
||||
if !only.is_empty() && !only.contains(&name.to_ascii_lowercase()) {
|
||||
continue;
|
||||
}
|
||||
note_refs(d);
|
||||
dir.domains.push(json!({
|
||||
"name": name,
|
||||
"enabled": d.get("isEnabled").and_then(Value::as_bool).unwrap_or(true),
|
||||
"description": opt(str_of(d, "description")),
|
||||
"aliases": set_of(d, "aliases"),
|
||||
"catchAllAddress": opt(str_of(d, "catchAllAddress")),
|
||||
"subAddressing": sub_addressing_of(d),
|
||||
"tenant": names.tenant(d),
|
||||
}));
|
||||
}
|
||||
|
||||
// Groups are named by address everywhere, so every account's address is
|
||||
// known before any is written, whichever domains are selected.
|
||||
let mut address_of: HashMap<String, String> = HashMap::new();
|
||||
for a in &raw.accounts {
|
||||
match (id_of(a), names.address(a)) {
|
||||
(Some(id), Some(email)) => {
|
||||
address_of.insert(id.to_owned(), email);
|
||||
}
|
||||
_ => {
|
||||
logger.warn(&format!(
|
||||
"account {} has no domain this login can see; left out",
|
||||
str_of(a, "name").unwrap_or("(unnamed)")
|
||||
));
|
||||
*dir.skipped.entry(account_kind(a)).or_default() += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut members: HashMap<&str, BTreeSet<&str>> = HashMap::new();
|
||||
for a in raw.accounts.iter().filter(|a| type_of(a) == "User") {
|
||||
let Some(email) = id_of(a).and_then(|id| address_of.get(id)) else {
|
||||
continue;
|
||||
};
|
||||
for group in set_of(a, "memberGroupIds") {
|
||||
if let Some(group_email) = address_of.get(&group) {
|
||||
members
|
||||
.entry(group_email.as_str())
|
||||
.or_default()
|
||||
.insert(email.as_str());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for a in &raw.accounts {
|
||||
let Some(email) = id_of(a).and_then(|id| address_of.get(id)) else {
|
||||
continue;
|
||||
};
|
||||
if !selected(a) {
|
||||
continue;
|
||||
}
|
||||
note_refs(a);
|
||||
let mut entry = json!({
|
||||
"email": email,
|
||||
"name": str_of(a, "name"),
|
||||
"domain": names.domain(str_of(a, "domainId")),
|
||||
"description": opt(str_of(a, "description")),
|
||||
"roles": names.role_of(a),
|
||||
"permissions": permissions_of(a),
|
||||
"aliases": names.aliases(a),
|
||||
"quotas": quotas_of(a),
|
||||
"tenant": names.tenant(a),
|
||||
"locale": opt(str_of(a, "locale")),
|
||||
"timeZone": opt(str_of(a, "timeZone")),
|
||||
"externalId": opt(str_of(a, "externalId")),
|
||||
});
|
||||
match type_of(a) {
|
||||
"Group" => {
|
||||
let list: Vec<&str> = members
|
||||
.get(email.as_str())
|
||||
.map(|m| m.iter().copied().collect())
|
||||
.unwrap_or_default();
|
||||
entry["members"] = json!(list);
|
||||
dir.groups.push(entry);
|
||||
}
|
||||
_ => {
|
||||
let mut groups: Vec<&String> = set_of(a, "memberGroupIds")
|
||||
.iter()
|
||||
.filter_map(|g| address_of.get(g))
|
||||
.collect();
|
||||
groups.sort();
|
||||
entry["groups"] = json!(groups);
|
||||
dir.users.push(entry);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for l in &raw.lists {
|
||||
if !selected(l) {
|
||||
continue;
|
||||
}
|
||||
let Some(email) = names.address(l) else {
|
||||
*dir.skipped.entry("mailinglist").or_default() += 1;
|
||||
continue;
|
||||
};
|
||||
note_refs(l);
|
||||
dir.lists.push(json!({
|
||||
"email": email,
|
||||
"name": str_of(l, "name"),
|
||||
"domain": names.domain(str_of(l, "domainId")),
|
||||
"description": opt(str_of(l, "description")),
|
||||
"recipients": set_of(l, "recipients"),
|
||||
"aliases": names.aliases(l),
|
||||
"tenant": names.tenant(l),
|
||||
}));
|
||||
}
|
||||
|
||||
// Roles the written accounts hold, and the roles those build on.
|
||||
let roles_by_id: HashMap<&str, &Value> = raw
|
||||
.roles
|
||||
.iter()
|
||||
.filter_map(|r| Some((id_of(r)?, r)))
|
||||
.collect();
|
||||
let mut kept_roles: HashSet<String> = HashSet::new();
|
||||
while let Some(id) = role_ids.pop() {
|
||||
if !kept_roles.insert(id.clone()) {
|
||||
continue;
|
||||
}
|
||||
if let Some(r) = roles_by_id.get(id.as_str()) {
|
||||
role_ids.extend(set_of(r, "roleIds"));
|
||||
}
|
||||
}
|
||||
for r in &raw.roles {
|
||||
let Some(id) = id_of(r) else {
|
||||
continue;
|
||||
};
|
||||
if !only.is_empty() && !kept_roles.contains(id) {
|
||||
continue;
|
||||
}
|
||||
if let Some(t) = str_of(r, "memberTenantId") {
|
||||
tenant_ids.insert(t.to_owned());
|
||||
}
|
||||
dir.roles.push(json!({
|
||||
"name": str_of(r, "description"),
|
||||
"tenant": names.tenant(r),
|
||||
"roles": names.roles(&set_of(r, "roleIds")),
|
||||
"enabledPermissions": set_of(r, "enabledPermissions"),
|
||||
"disabledPermissions": set_of(r, "disabledPermissions"),
|
||||
}));
|
||||
}
|
||||
for t in &raw.tenants {
|
||||
let Some(id) = id_of(t) else {
|
||||
continue;
|
||||
};
|
||||
if !only.is_empty() && !tenant_ids.contains(id) {
|
||||
continue;
|
||||
}
|
||||
dir.tenants.push(json!({
|
||||
"name": str_of(t, "name"),
|
||||
"quotas": quotas_of(t),
|
||||
}));
|
||||
}
|
||||
|
||||
let by = |key: &'static str| {
|
||||
move |a: &Value, b: &Value| {
|
||||
let k = |v: &Value| str_of(v, key).map(str::to_lowercase);
|
||||
k(a).cmp(&k(b))
|
||||
}
|
||||
};
|
||||
dir.domains.sort_by(by("name"));
|
||||
dir.tenants.sort_by(by("name"));
|
||||
dir.roles.sort_by(by("name"));
|
||||
dir.users.sort_by(by("email"));
|
||||
dir.groups.sort_by(by("email"));
|
||||
dir.lists.sort_by(by("email"));
|
||||
Ok(dir)
|
||||
}
|
||||
|
||||
fn account_kind(v: &Value) -> &'static str {
|
||||
if type_of(v) == "Group" {
|
||||
"group"
|
||||
} else {
|
||||
"user"
|
||||
}
|
||||
}
|
||||
|
||||
/// Cells holding more than one value join them with `;`.
|
||||
fn joined<'a>(values: impl IntoIterator<Item = &'a str>) -> String {
|
||||
values.into_iter().collect::<Vec<_>>().join(";")
|
||||
}
|
||||
|
||||
fn cell(v: &Value, key: &str) -> String {
|
||||
match v.get(key) {
|
||||
Some(Value::String(s)) => s.clone(),
|
||||
Some(Value::Bool(b)) => b.to_string(),
|
||||
Some(Value::Number(n)) => n.to_string(),
|
||||
Some(Value::Array(items)) => joined(items.iter().filter_map(Value::as_str)),
|
||||
_ => String::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn roles_cell(v: &Value) -> String {
|
||||
match v.get("roles") {
|
||||
Some(Value::String(s)) => s.clone(),
|
||||
Some(r) => cell(r, "custom"),
|
||||
None => String::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn alias_emails(v: &Value) -> String {
|
||||
joined(
|
||||
v.get("aliases")
|
||||
.and_then(Value::as_array)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
.filter_map(|a| str_of(a, "email")),
|
||||
)
|
||||
}
|
||||
|
||||
fn disk_quota(v: &Value) -> String {
|
||||
v.get("quotas")
|
||||
.and_then(|q| q.get("maxDiskQuota"))
|
||||
.map(Value::to_string)
|
||||
.unwrap_or_default()
|
||||
}
|
||||
|
||||
/// One CSV file: its header, then its rows.
|
||||
pub type Table = (Vec<&'static str>, Vec<Vec<String>>);
|
||||
|
||||
impl Directory {
|
||||
pub fn summary(&self) -> Summary {
|
||||
let mut summary = Summary::default();
|
||||
for (ty, list) in [
|
||||
("domain", &self.domains),
|
||||
("tenant", &self.tenants),
|
||||
("role", &self.roles),
|
||||
("user", &self.users),
|
||||
("group", &self.groups),
|
||||
("mailinglist", &self.lists),
|
||||
] {
|
||||
summary.per_type.push((
|
||||
ty,
|
||||
TypeCounts {
|
||||
created: list.len() as u64,
|
||||
skipped: self.skipped.get(ty).copied().unwrap_or(0),
|
||||
..TypeCounts::default()
|
||||
},
|
||||
));
|
||||
}
|
||||
summary
|
||||
}
|
||||
|
||||
pub fn domains_csv(&self) -> Table {
|
||||
let header = vec![
|
||||
"name",
|
||||
"enabled",
|
||||
"description",
|
||||
"aliases",
|
||||
"catch_all",
|
||||
"sub_addressing",
|
||||
"tenant",
|
||||
];
|
||||
let rows = self
|
||||
.domains
|
||||
.iter()
|
||||
.map(|d| {
|
||||
let sub = match d.get("subAddressing") {
|
||||
Some(Value::String(s)) => s.clone(),
|
||||
Some(Value::Object(_)) => "custom".to_owned(),
|
||||
_ => String::new(),
|
||||
};
|
||||
vec![
|
||||
cell(d, "name"),
|
||||
cell(d, "enabled"),
|
||||
cell(d, "description"),
|
||||
cell(d, "aliases"),
|
||||
cell(d, "catchAllAddress"),
|
||||
sub,
|
||||
cell(d, "tenant"),
|
||||
]
|
||||
})
|
||||
.collect();
|
||||
(header, rows)
|
||||
}
|
||||
|
||||
pub fn users_csv(&self) -> Table {
|
||||
let header = vec![
|
||||
"email",
|
||||
"name",
|
||||
"domain",
|
||||
"description",
|
||||
"roles",
|
||||
"groups",
|
||||
"aliases",
|
||||
"disk_quota",
|
||||
"tenant",
|
||||
"locale",
|
||||
"time_zone",
|
||||
"external_id",
|
||||
];
|
||||
let rows = self
|
||||
.users
|
||||
.iter()
|
||||
.map(|u| {
|
||||
vec![
|
||||
cell(u, "email"),
|
||||
cell(u, "name"),
|
||||
cell(u, "domain"),
|
||||
cell(u, "description"),
|
||||
roles_cell(u),
|
||||
cell(u, "groups"),
|
||||
alias_emails(u),
|
||||
disk_quota(u),
|
||||
cell(u, "tenant"),
|
||||
cell(u, "locale"),
|
||||
cell(u, "timeZone"),
|
||||
cell(u, "externalId"),
|
||||
]
|
||||
})
|
||||
.collect();
|
||||
(header, rows)
|
||||
}
|
||||
|
||||
pub fn groups_csv(&self) -> Table {
|
||||
let header = vec![
|
||||
"email",
|
||||
"name",
|
||||
"domain",
|
||||
"description",
|
||||
"members",
|
||||
"aliases",
|
||||
"disk_quota",
|
||||
"tenant",
|
||||
];
|
||||
let rows = self
|
||||
.groups
|
||||
.iter()
|
||||
.map(|g| {
|
||||
vec![
|
||||
cell(g, "email"),
|
||||
cell(g, "name"),
|
||||
cell(g, "domain"),
|
||||
cell(g, "description"),
|
||||
cell(g, "members"),
|
||||
alias_emails(g),
|
||||
disk_quota(g),
|
||||
cell(g, "tenant"),
|
||||
]
|
||||
})
|
||||
.collect();
|
||||
(header, rows)
|
||||
}
|
||||
|
||||
pub fn lists_csv(&self) -> Table {
|
||||
let header = vec![
|
||||
"email",
|
||||
"name",
|
||||
"domain",
|
||||
"description",
|
||||
"recipients",
|
||||
"aliases",
|
||||
"tenant",
|
||||
];
|
||||
let rows = self
|
||||
.lists
|
||||
.iter()
|
||||
.map(|l| {
|
||||
vec![
|
||||
cell(l, "email"),
|
||||
cell(l, "name"),
|
||||
cell(l, "domain"),
|
||||
cell(l, "description"),
|
||||
cell(l, "recipients"),
|
||||
alias_emails(l),
|
||||
cell(l, "tenant"),
|
||||
]
|
||||
})
|
||||
.collect();
|
||||
(header, rows)
|
||||
}
|
||||
|
||||
/// Every address alias with what it delivers to, one row each.
|
||||
pub fn aliases_csv(&self) -> Table {
|
||||
let header = vec!["alias", "target", "kind", "enabled"];
|
||||
let mut rows = Vec::new();
|
||||
for (kind, list) in [
|
||||
("user", &self.users),
|
||||
("group", &self.groups),
|
||||
("list", &self.lists),
|
||||
] {
|
||||
for owner in list {
|
||||
for alias in owner
|
||||
.get("aliases")
|
||||
.and_then(Value::as_array)
|
||||
.into_iter()
|
||||
.flatten()
|
||||
{
|
||||
rows.push(vec![
|
||||
cell(alias, "email"),
|
||||
cell(owner, "email"),
|
||||
kind.to_owned(),
|
||||
cell(alias, "enabled"),
|
||||
]);
|
||||
}
|
||||
}
|
||||
}
|
||||
rows.sort();
|
||||
(header, rows)
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn raw() -> Raw {
|
||||
Raw {
|
||||
domains: vec![
|
||||
json!({"id": "b", "name": "example.org", "aliases": {"example.net": true},
|
||||
"isEnabled": true, "catchAllAddress": "[email protected]",
|
||||
"subAddressing": {"@type": "Enabled"}, "memberTenantId": "t"}),
|
||||
json!({"id": "c", "name": "other.test", "aliases": {}, "isEnabled": false,
|
||||
"subAddressing": {"@type": "Disabled"}}),
|
||||
],
|
||||
accounts: vec![
|
||||
json!({"id": "b", "@type": "Group", "name": "sales", "domainId": "b",
|
||||
"roles": {"@type": "Default"}, "permissions": {"@type": "Inherit"},
|
||||
"quotas": {}, "aliases": {}}),
|
||||
json!({"id": "c", "@type": "User", "name": "alice", "domainId": "b",
|
||||
"memberGroupIds": {"b": true}, "memberTenantId": "t",
|
||||
"roles": {"@type": "Custom", "roleIds": {"r": true}},
|
||||
"permissions": {"@type": "Merge", "enabledPermissions": {"emailSend": true},
|
||||
"disabledPermissions": {}},
|
||||
"quotas": {"maxDiskQuota": 1073741824},
|
||||
"aliases": {"0": {"enabled": true, "name": "a.example", "domainId": "b"},
|
||||
"1": {"enabled": false, "name": "alice", "domainId": "c"}},
|
||||
"locale": "en-US", "timeZone": "Europe/Paris"}),
|
||||
json!({"id": "d", "@type": "User", "name": "dave", "domainId": "c",
|
||||
"memberGroupIds": {"b": true}, "roles": {"@type": "Admin"},
|
||||
"permissions": {"@type": "Inherit"}, "quotas": {}, "aliases": {}}),
|
||||
json!({"id": "e", "@type": "User", "name": "ghost", "domainId": "zz"}),
|
||||
],
|
||||
lists: vec![json!({"id": "b", "name": "all", "domainId": "b",
|
||||
"recipients": {"[email protected]": true, "[email protected]": true},
|
||||
"aliases": {}})],
|
||||
tenants: vec![
|
||||
json!({"id": "t", "name": "acme", "quotas": {"maxAccounts": 50}}),
|
||||
json!({"id": "u", "name": "unused", "quotas": {}}),
|
||||
],
|
||||
roles: vec![
|
||||
json!({"id": "r", "description": "Helpdesk", "roleIds": {"s": true},
|
||||
"enabledPermissions": {"impersonate": true}, "disabledPermissions": {}}),
|
||||
json!({"id": "s", "description": "Reader", "roleIds": {"r": true},
|
||||
"enabledPermissions": {}, "disabledPermissions": {}}),
|
||||
json!({"id": "x", "description": "Unused", "roleIds": {}}),
|
||||
],
|
||||
}
|
||||
}
|
||||
|
||||
fn emails(list: &[Value]) -> Vec<&str> {
|
||||
list.iter().filter_map(|v| str_of(v, "email")).collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ids_become_addresses_and_names() {
|
||||
let dir = build(&raw(), &[], Logger::new(0)).unwrap();
|
||||
assert_eq!(emails(&dir.users), ["[email protected]", "[email protected]"]);
|
||||
let alice = &dir.users[0];
|
||||
assert_eq!(alice["groups"], json!(["[email protected]"]));
|
||||
assert_eq!(alice["roles"], json!({"custom": ["Helpdesk"]}));
|
||||
assert_eq!(alice["tenant"], "acme");
|
||||
assert_eq!(alice["quotas"], json!({"maxDiskQuota": 1073741824}));
|
||||
assert_eq!(
|
||||
alice["permissions"],
|
||||
json!({"mode": "merge", "enabled": ["emailSend"], "disabled": []})
|
||||
);
|
||||
assert_eq!(
|
||||
alice["aliases"],
|
||||
json!([
|
||||
{"email": "[email protected]", "enabled": true, "description": null},
|
||||
{"email": "[email protected]", "enabled": false, "description": null},
|
||||
])
|
||||
);
|
||||
assert_eq!(dir.users[1]["roles"], "admin");
|
||||
assert_eq!(
|
||||
dir.groups[0]["members"],
|
||||
json!(["[email protected]", "[email protected]"])
|
||||
);
|
||||
assert_eq!(
|
||||
dir.lists[0]["recipients"],
|
||||
json!(["[email protected]", "[email protected]"])
|
||||
);
|
||||
assert_eq!(dir.domains[0]["aliases"], json!(["example.net"]));
|
||||
assert_eq!(dir.domains[0]["subAddressing"], "enabled");
|
||||
assert_eq!(dir.domains[1]["enabled"], false);
|
||||
assert_eq!(dir.tenants.len(), 2);
|
||||
assert_eq!(dir.roles.len(), 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_account_on_an_unknown_domain_is_counted_and_left_out() {
|
||||
let dir = build(&raw(), &[], Logger::new(0)).unwrap();
|
||||
let summary = dir.summary();
|
||||
let users = &summary
|
||||
.per_type
|
||||
.iter()
|
||||
.find(|(t, _)| *t == "user")
|
||||
.unwrap()
|
||||
.1;
|
||||
assert_eq!((users.created, users.skipped), (2, 1));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn one_domain_keeps_only_what_it_uses() {
|
||||
let dir = build(&raw(), &["Example.org".to_owned()], Logger::new(0)).unwrap();
|
||||
assert_eq!(dir.domains.len(), 1);
|
||||
assert_eq!(emails(&dir.users), ["[email protected]"]);
|
||||
// Members elsewhere are still named by address.
|
||||
assert_eq!(
|
||||
dir.groups[0]["members"],
|
||||
json!(["[email protected]", "[email protected]"])
|
||||
);
|
||||
let roles: Vec<&str> = dir.roles.iter().filter_map(|r| str_of(r, "name")).collect();
|
||||
assert_eq!(roles, ["Helpdesk", "Reader"]);
|
||||
let tenants: Vec<&str> = dir
|
||||
.tenants
|
||||
.iter()
|
||||
.filter_map(|t| str_of(t, "name"))
|
||||
.collect();
|
||||
assert_eq!(tenants, ["acme"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn an_unknown_domain_is_a_usage_error() {
|
||||
let err = build(&raw(), &["nope.test".to_owned()], Logger::new(0)).unwrap_err();
|
||||
assert!(matches!(err, Error::Usage(_)), "{err:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn csv_rows_follow_their_headers() {
|
||||
let dir = build(&raw(), &[], Logger::new(0)).unwrap();
|
||||
let (header, rows) = dir.users_csv();
|
||||
assert_eq!(rows[0].len(), header.len());
|
||||
assert_eq!(rows[0][4], "Helpdesk");
|
||||
assert_eq!(rows[0][6], "[email protected];[email protected]");
|
||||
assert_eq!(rows[0][7], "1073741824");
|
||||
let (_, aliases) = dir.aliases_csv();
|
||||
assert_eq!(
|
||||
aliases[0],
|
||||
["[email protected]", "[email protected]", "user", "true"]
|
||||
);
|
||||
let (_, domains) = dir.domains_csv();
|
||||
assert_eq!(domains[0][3], "example.net");
|
||||
assert_eq!(domains[0][4], "[email protected]");
|
||||
}
|
||||
}
|
||||
@@ -128,7 +128,7 @@ pub fn run(config: ExportFilesConfig) -> Result<Summary, Error> {
|
||||
|
||||
/// Only a new or empty directory: what is written must be exactly the
|
||||
/// archive, with nothing of an earlier run mixed in.
|
||||
fn check_target(dir: &Path) -> Result<(), Error> {
|
||||
pub(crate) fn check_target(dir: &Path) -> Result<(), Error> {
|
||||
match fs::read_dir(dir) {
|
||||
Ok(mut entries) => {
|
||||
if entries.next().is_some() {
|
||||
@@ -150,7 +150,7 @@ fn check_target(dir: &Path) -> Result<(), Error> {
|
||||
|
||||
/// Mail, contacts and calendars are as private as the archive they came
|
||||
/// from.
|
||||
fn make_private_dir(dir: &Path) -> Result<(), Error> {
|
||||
pub(crate) fn make_private_dir(dir: &Path) -> Result<(), Error> {
|
||||
fs::create_dir_all(dir)?;
|
||||
#[cfg(unix)]
|
||||
{
|
||||
|
||||
@@ -243,6 +243,25 @@ impl Session {
|
||||
.find(|urn| self.capabilities.contains_key(*urn))
|
||||
}
|
||||
|
||||
/// The account to send registry (`x:`) calls to, with the capability
|
||||
/// to name for them. Servers advertise the registry per account, on the
|
||||
/// accounts whose credentials may administer it; a session-wide one is
|
||||
/// taken with the first account when no account lists it.
|
||||
pub fn registry_account(&self) -> Option<(&str, &'static str)> {
|
||||
for urn in [URN_INBUXA_REGISTRY, URN_STALWART_REGISTRY] {
|
||||
if let Some((id, _)) = self
|
||||
.accounts
|
||||
.iter()
|
||||
.find(|(_, a)| a.account_capabilities.contains_key(urn))
|
||||
{
|
||||
return Some((id.as_str(), urn));
|
||||
}
|
||||
}
|
||||
let urn = self.registry_urn()?;
|
||||
let (id, _) = self.accounts.first()?;
|
||||
Some((id.as_str(), urn))
|
||||
}
|
||||
|
||||
pub fn account(&self, account_id: &str) -> Option<&Account> {
|
||||
self.accounts.get(account_id)
|
||||
}
|
||||
@@ -353,6 +372,26 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn registry_account_is_the_account_that_lists_it() {
|
||||
let mut v: serde_json::Value = serde_json::from_str(raw_session()).unwrap();
|
||||
v["accounts"]["a"] = serde_json::json!({
|
||||
"name": "admin",
|
||||
"accountCapabilities": { URN_INBUXA_REGISTRY: {} }
|
||||
});
|
||||
let session: Session = serde_json::from_value(v).unwrap();
|
||||
assert_eq!(session.registry_account(), Some(("a", URN_INBUXA_REGISTRY)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn registry_account_falls_back_to_a_session_capability() {
|
||||
assert_eq!(
|
||||
session_with(&[URN_STALWART_REGISTRY]).registry_account(),
|
||||
Some(("w", URN_STALWART_REGISTRY))
|
||||
);
|
||||
assert_eq!(session_with(&[]).registry_account(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn registry_urn_is_none_without_either() {
|
||||
assert_eq!(session_with(&[]).registry_urn(), None);
|
||||
|
||||
@@ -12,6 +12,7 @@ pub mod error;
|
||||
pub mod exchange;
|
||||
pub mod exchange_ews;
|
||||
pub mod exchange_graph;
|
||||
pub mod export_directory;
|
||||
pub mod export_files;
|
||||
pub mod imap;
|
||||
pub mod inspect;
|
||||
|
||||
+8
-1
@@ -10,7 +10,7 @@ use clap::Parser;
|
||||
use inbuxa_migrate::cli::{Action, Cli};
|
||||
use inbuxa_migrate::error::Error;
|
||||
use inbuxa_migrate::sync::{self, RunOutcome, Summary};
|
||||
use inbuxa_migrate::{export_files, inspect};
|
||||
use inbuxa_migrate::{export_directory, export_files, inspect};
|
||||
|
||||
fn main() {
|
||||
let code = run();
|
||||
@@ -87,6 +87,13 @@ fn run() -> i32 {
|
||||
let logger = config.logger;
|
||||
(RunOutcome::from_result(export_files::run(config)), logger)
|
||||
}
|
||||
Action::ExportDirectory(config) => {
|
||||
let logger = config.logger;
|
||||
(
|
||||
RunOutcome::from_result(export_directory::run(config)),
|
||||
logger,
|
||||
)
|
||||
}
|
||||
Action::ExportImap(common, config) => {
|
||||
let logger = common.logger;
|
||||
(
|
||||
|
||||
@@ -0,0 +1,273 @@
|
||||
/*
|
||||
* SPDX-FileCopyrightText: 2026 Coffey Labs LLC <[email protected]>
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0 OR MIT
|
||||
*/
|
||||
|
||||
//! `export-directory` against a registry served by a mock: what is asked
|
||||
//! for, what is written, and that no secret reaches the files even from a
|
||||
//! server that sends one unasked.
|
||||
|
||||
use std::collections::BTreeSet;
|
||||
use std::fs;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
use inbuxa_migrate::export_directory::{self, ExportDirectoryConfig};
|
||||
use inbuxa_migrate::jmap::http::Auth;
|
||||
use inbuxa_migrate::logging::Logger;
|
||||
use serde_json::{Value, json};
|
||||
|
||||
const SECRET: &str = "hunter2-never-written";
|
||||
|
||||
fn objects(ty: &str) -> Vec<Value> {
|
||||
match ty {
|
||||
"x:Domain" => vec![
|
||||
json!({"id": "b", "name": "example.org", "aliases": {"example.net": true},
|
||||
"isEnabled": true, "subAddressing": {"@type": "Enabled"},
|
||||
"dkimManagement": {"@type": "Automatic"}, "dnsZoneFile": "example.org. IN MX 10 mx."}),
|
||||
],
|
||||
"x:Account" => vec![
|
||||
json!({"id": "b", "@type": "Group", "name": "sales", "domainId": "b",
|
||||
"roles": {"@type": "Default"}, "quotas": {}, "aliases": {}}),
|
||||
json!({"id": "c", "@type": "User", "name": "alice", "domainId": "b",
|
||||
"description": "Smith, Alice", "memberGroupIds": {"b": true},
|
||||
"roles": {"@type": "User"}, "quotas": {"maxDiskQuota": 5},
|
||||
"aliases": {"0": {"enabled": true, "name": "a", "domainId": "b"}},
|
||||
"credentials": {"0": {"@type": "Password", "secret": SECRET}},
|
||||
"encryptionAtRest": {"@type": "Aes256", "publicKey": SECRET}}),
|
||||
],
|
||||
"x:MailingList" => vec![json!({"id": "b", "name": "all", "domainId": "b",
|
||||
"description": "=cmd|' /C calc'!A0", "recipients": {"[email protected]": true}})],
|
||||
_ => Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn session(base: &str) -> String {
|
||||
json!({
|
||||
"apiUrl": format!("{base}/jmap/api"),
|
||||
"uploadUrl": format!("{base}/jmap/upload/{{accountId}}/"),
|
||||
"downloadUrl": format!("{base}/jmap/dl/{{accountId}}/{{blobId}}/{{type}}/{{name}}"),
|
||||
"capabilities": {
|
||||
"urn:ietf:params:jmap:core": {
|
||||
"maxObjectsInGet": 1, "maxObjectsInSet": 500, "maxCallsInRequest": 16,
|
||||
"maxConcurrentRequests": 4, "maxConcurrentUpload": 4,
|
||||
"maxSizeRequest": 10000000, "maxSizeUpload": 50000000
|
||||
}
|
||||
},
|
||||
"accounts": {
|
||||
"self": { "name": "admin", "accountCapabilities": {} },
|
||||
"adm": { "name": "admin", "accountCapabilities": { "urn:inbuxa:jmap:registry": {} } }
|
||||
}
|
||||
})
|
||||
.to_string()
|
||||
}
|
||||
|
||||
/// Each get as (type, the properties it asked for).
|
||||
type Asked = Arc<Mutex<Vec<(String, Vec<String>)>>>;
|
||||
|
||||
/// A registry that answers `/query` and `/get` from `objects`, records the
|
||||
/// properties each get asked for, and with `honor_properties` off sends
|
||||
/// every field whatever was asked.
|
||||
struct Registry {
|
||||
server: mockito::ServerGuard,
|
||||
asked: Asked,
|
||||
}
|
||||
|
||||
fn registry(honor_properties: bool) -> Registry {
|
||||
let mut server = mockito::Server::new();
|
||||
let base = server.url();
|
||||
server
|
||||
.mock("GET", "/jmap/session")
|
||||
.with_status(200)
|
||||
.with_body(session(&base))
|
||||
.create();
|
||||
let asked: Asked = Arc::new(Mutex::new(Vec::new()));
|
||||
let log = asked.clone();
|
||||
server
|
||||
.mock("POST", "/jmap/api")
|
||||
.with_status(200)
|
||||
.with_body_from_request(move |req| {
|
||||
let body: Value = serde_json::from_slice(req.body().unwrap()).unwrap();
|
||||
assert!(
|
||||
body["using"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.contains(&json!("urn:inbuxa:jmap:registry")),
|
||||
"{body}"
|
||||
);
|
||||
let call = &body["methodCalls"][0];
|
||||
let (method, args) = (call[0].as_str().unwrap(), &call[1]);
|
||||
assert_eq!(args["accountId"], "adm");
|
||||
let (ty, verb) = method.split_once('/').unwrap();
|
||||
let all = objects(ty);
|
||||
let response = match verb {
|
||||
"query" => {
|
||||
let from = args["position"].as_u64().unwrap_or(0) as usize;
|
||||
let ids: Vec<&Value> = all.iter().skip(from).map(|o| &o["id"]).collect();
|
||||
json!({"accountId": "adm", "ids": ids, "position": from})
|
||||
}
|
||||
"get" => {
|
||||
let props: Vec<String> = args["properties"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.map(|p| p.as_str().unwrap().to_owned())
|
||||
.collect();
|
||||
log.lock().unwrap().push((ty.to_owned(), props.clone()));
|
||||
let ids = args["ids"].as_array().unwrap();
|
||||
let list: Vec<Value> = all
|
||||
.into_iter()
|
||||
.filter(|o| ids.contains(&o["id"]))
|
||||
.map(|o| {
|
||||
if !honor_properties {
|
||||
return o;
|
||||
}
|
||||
let mut kept = serde_json::Map::new();
|
||||
for (k, v) in o.as_object().unwrap() {
|
||||
if k == "id" || props.contains(k) {
|
||||
kept.insert(k.clone(), v.clone());
|
||||
}
|
||||
}
|
||||
Value::Object(kept)
|
||||
})
|
||||
.collect();
|
||||
json!({"accountId": "adm", "list": list, "notFound": []})
|
||||
}
|
||||
other => panic!("unexpected {other}"),
|
||||
};
|
||||
json!({"methodResponses": [[method, response, call[2]]]})
|
||||
.to_string()
|
||||
.into_bytes()
|
||||
})
|
||||
.create();
|
||||
Registry { server, asked }
|
||||
}
|
||||
|
||||
fn out_dir(name: &str) -> PathBuf {
|
||||
let dir =
|
||||
std::env::temp_dir().join(format!("inbuxa-migrate-dir-{name}-{}", std::process::id()));
|
||||
let _ = fs::remove_dir_all(&dir);
|
||||
dir
|
||||
}
|
||||
|
||||
fn config(registry: &Registry, dir: &std::path::Path) -> ExportDirectoryConfig {
|
||||
ExportDirectoryConfig {
|
||||
url: format!("{}/jmap/session", registry.server.url()),
|
||||
auth: Auth::Basic {
|
||||
user: "admin".into(),
|
||||
password: "p".into(),
|
||||
},
|
||||
dir: dir.to_path_buf(),
|
||||
domains: Vec::new(),
|
||||
dry_run: false,
|
||||
max_retries: 0,
|
||||
allow_invalid_certs: false,
|
||||
logger: Logger::new(0),
|
||||
}
|
||||
}
|
||||
|
||||
fn every_file(dir: &std::path::Path) -> String {
|
||||
let mut text = String::new();
|
||||
for entry in fs::read_dir(dir).unwrap() {
|
||||
text.push_str(&fs::read_to_string(entry.unwrap().path()).unwrap());
|
||||
}
|
||||
text
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_directory_is_written_without_asking_for_secrets() {
|
||||
let registry = registry(true);
|
||||
let dir = out_dir("asked");
|
||||
export_directory::run(config(®istry, &dir)).expect("export");
|
||||
|
||||
let asked = registry.asked.lock().unwrap();
|
||||
let types: BTreeSet<&str> = asked.iter().map(|(t, _)| t.as_str()).collect();
|
||||
assert_eq!(
|
||||
types,
|
||||
BTreeSet::from(["x:Account", "x:Domain", "x:MailingList"])
|
||||
);
|
||||
// maxObjectsInGet is 1, so the two accounts take two gets.
|
||||
assert_eq!(asked.iter().filter(|(t, _)| t == "x:Account").count(), 2);
|
||||
for (_, props) in asked.iter() {
|
||||
for never in [
|
||||
"credentials",
|
||||
"encryptionAtRest",
|
||||
"dkimManagement",
|
||||
"dnsZoneFile",
|
||||
] {
|
||||
assert!(!props.iter().any(|p| p == never), "{props:?}");
|
||||
}
|
||||
}
|
||||
|
||||
let names: BTreeSet<String> = fs::read_dir(&dir)
|
||||
.unwrap()
|
||||
.map(|e| e.unwrap().file_name().into_string().unwrap())
|
||||
.collect();
|
||||
assert_eq!(
|
||||
names,
|
||||
BTreeSet::from(
|
||||
[
|
||||
"aliases.csv",
|
||||
"directory.json",
|
||||
"domains.csv",
|
||||
"groups.csv",
|
||||
"lists.csv",
|
||||
"users.csv",
|
||||
]
|
||||
.map(str::to_owned)
|
||||
)
|
||||
);
|
||||
let doc: Value =
|
||||
serde_json::from_str(&fs::read_to_string(dir.join("directory.json")).unwrap()).unwrap();
|
||||
assert_eq!(doc["format"], "inbuxa-migrate-directory");
|
||||
assert_eq!(doc["users"][0]["email"], "[email protected]");
|
||||
assert_eq!(doc["users"][0]["groups"], json!(["[email protected]"]));
|
||||
assert_eq!(doc["groups"][0]["members"], json!(["[email protected]"]));
|
||||
assert_eq!(doc["lists"][0]["description"], "=cmd|' /C calc'!A0");
|
||||
|
||||
let users = fs::read_to_string(dir.join("users.csv")).unwrap();
|
||||
assert!(
|
||||
users.contains("[email protected],alice,example.org,\"Smith, Alice\",user,[email protected],[email protected],5,"),
|
||||
"{users}"
|
||||
);
|
||||
let lists = fs::read_to_string(dir.join("lists.csv")).unwrap();
|
||||
assert!(lists.contains(",'=cmd|' /C calc'!A0,"), "{lists}");
|
||||
#[cfg(unix)]
|
||||
{
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
let mode = fs::metadata(&dir).unwrap().permissions().mode();
|
||||
assert_eq!(mode & 0o777, 0o700);
|
||||
}
|
||||
fs::remove_dir_all(&dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_secret_sent_unasked_is_still_not_written() {
|
||||
let registry = registry(false);
|
||||
let dir = out_dir("unasked");
|
||||
export_directory::run(config(®istry, &dir)).expect("export");
|
||||
let text = every_file(&dir);
|
||||
assert!(text.contains("[email protected]"));
|
||||
assert!(!text.contains(SECRET));
|
||||
assert!(!text.contains("credentials"));
|
||||
assert!(!text.contains("IN MX"));
|
||||
fs::remove_dir_all(&dir).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_dry_run_writes_nothing() {
|
||||
let registry = registry(true);
|
||||
let dir = out_dir("dry");
|
||||
let mut config = config(®istry, &dir);
|
||||
config.dry_run = true;
|
||||
let summary = export_directory::run(config).expect("export");
|
||||
let users = &summary
|
||||
.per_type
|
||||
.iter()
|
||||
.find(|(t, _)| *t == "user")
|
||||
.unwrap()
|
||||
.1;
|
||||
assert_eq!(users.created, 1);
|
||||
assert!(!dir.exists());
|
||||
}
|
||||
Reference in new issue
Block a user