The mail test client: every client check in one command (K-L2) #34

Merged
jcoffey-dev merged 2 commits from feat/mail-client into main 2026-11-20 06:48:11 +00:00
6 changed files with 487 additions and 45 deletions

No files matched your search

+7
View File
@@ -34,6 +34,13 @@ and arm64 runners on each Kubernetes minor in `lab/kubernetes.json`, nightly
and on every push (`.github/workflows/e2e.yml`), and each chart branch in
inbuxa-charts calls the same workflow for its own commit.
`lab/chart/mailcheck.sh` is every client check against an installed chart,
in one command: SMTP in, submission, IMAP, JMAP, SMTP out to an outside
server (an SMTP sink in the cluster, `lab/chart/mail-sink.yaml`), CalDAV,
CardDAV, the webmail signing in across both replicas and the console. It's
what `e2e.sh` runs after the install, and what to run after changing the
lab by hand.
`lab/up.sh` is just the cluster: kind, Kyverno and the policies, MetalLB,
and the data layer (CloudNativePG, NATS, Garage). It adds the Helm
repositories it needs; the versions are pinned in `lab/versions.env`.
+121
View File
@@ -0,0 +1,121 @@
# SPDX-FileCopyrightText: 2026 Coffey Labs LLC
# SPDX-License-Identifier: Apache-2.0
#
# The outside world's mail server, for mail going out (K-L2): an SMTP
# server that takes anything and prints each message as one JSON line in
# its log, for mailcheck.py to find. mailcheck.sh routes the domain
# sink.test here (a Relay route), so nothing leaves the cluster.
#
# Plain Python 3.9 in the CloudNativePG PostgreSQL image (IMAGE, from
# versions.env), which the cluster already has, so no new image. Own
# namespace, outside the inbuxa policies, but restricted-shaped anyway.
apiVersion: v1
kind: Namespace
metadata:
name: lab-sink
labels:
pod-security.kubernetes.io/enforce: restricted
---
apiVersion: v1
kind: ConfigMap
metadata: {name: sink, namespace: lab-sink}
data:
sink.py: |
import asyncio, email, email.policy, json, sys, time
def log(rec):
print(json.dumps(rec), flush=True)
async def session(reader, writer):
peer = writer.get_extra_info("peername")
def send(line):
writer.write((line + "\r\n").encode())
send("220 lab-sink ESMTP")
mail_from, rcpts = None, []
try:
while True:
raw = await asyncio.wait_for(reader.readline(), 120)
if not raw:
break
line = raw.decode("utf-8", "replace").rstrip("\r\n")
verb = line[:4].upper()
if verb in ("EHLO", "HELO"):
send("250-lab-sink" if verb == "EHLO" else "250 lab-sink")
if verb == "EHLO":
send("250-8BITMIME")
send("250 SMTPUTF8")
ehlo = line[5:].strip()
elif verb == "MAIL":
mail_from, rcpts = line.split(":", 1)[1].strip().split(" ")[0].strip("<>"), []
send("250 ok")
elif verb == "RCPT":
rcpts.append(line.split(":", 1)[1].strip().split(" ")[0].strip("<>"))
send("250 ok")
elif verb == "DATA":
send("354 go ahead")
await writer.drain()
data = bytearray()
while True:
l = await asyncio.wait_for(reader.readline(), 120)
if l in (b".\r\n", b".\n") or not l:
break
data += l[1:] if l.startswith(b"..") else l
msg = email.message_from_bytes(bytes(data), policy=email.policy.default)
log({"at": time.time(), "peer": peer[0], "ehlo": ehlo, "from": mail_from, "rcpts": rcpts,
"subject": str(msg.get("Subject", "")),
"dkim": [str(h) for h in msg.get_all("DKIM-Signature", [])]})
send("250 queued")
elif verb == "RSET":
mail_from, rcpts = None, []
send("250 ok")
elif verb == "NOOP":
send("250 ok")
elif verb == "QUIT":
send("221 bye")
break
else:
send("502 not here")
await writer.drain()
except (asyncio.TimeoutError, ConnectionError):
pass
finally:
writer.close()
async def main():
server = await asyncio.start_server(session, "0.0.0.0", 2525)
print("lab-sink listening on 2525", flush=True)
async with server:
await server.serve_forever()
asyncio.run(main())
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: sink, namespace: lab-sink}
spec:
replicas: 1
selector: {matchLabels: {app: lab-sink}}
template:
metadata: {labels: {app: lab-sink}}
spec:
automountServiceAccountToken: false
enableServiceLinks: false
securityContext: {runAsNonRoot: true, runAsUser: 2000, runAsGroup: 2000, seccompProfile: {type: RuntimeDefault}}
containers:
- name: sink
image: IMAGE
imagePullPolicy: IfNotPresent
command: [python3, -u, /sink/sink.py]
ports: [{name: smtp, containerPort: 2525}]
readinessProbe: {tcpSocket: {port: smtp}, periodSeconds: 2}
resources: {requests: {cpu: 10m, memory: 32Mi}, limits: {memory: 128Mi}}
securityContext: {allowPrivilegeEscalation: false, readOnlyRootFilesystem: true, capabilities: {drop: [ALL]}}
volumeMounts: [{name: sink, mountPath: /sink}]
volumes: [{name: sink, configMap: {name: sink}}]
---
apiVersion: v1
kind: Service
metadata: {name: sink, namespace: lab-sink}
spec:
selector: {app: lab-sink}
ports: [{name: smtp, port: 25, targetPort: smtp}]
+278
View File
@@ -0,0 +1,278 @@
#!/usr/bin/env python3
# SPDX-FileCopyrightText: 2026 Coffey Labs LLC
# SPDX-License-Identifier: Apache-2.0
"""The mail test client (K-L2): what a mail client and the internet do with
an installed chart, each check named, one table at the end.
KCTX=kind-inbuxa-lab mailcheck.py LB HTTP ALICE_PASSWORD_FILE ADMIN_PASSWORD_FILE
LB is the mail Service's address (25, 465, 993), HTTP the server's http
port (http://127.0.0.1:N through a port-forward). Checks, as [email protected]:
smtp in a message from another domain on 25
submission alice sends on 465 (implicit TLS, AUTH): to herself, and out
imap both arrive, found over IMAPS on 993
jmap both found with Email/query, signed in with OAuth
smtp out the outgoing one reaches the outside server (mail-sink.yaml)
from alice, DKIM-signed for lab.test
caldav an event put, read back and deleted
carddav a contact the same
Mail for sink.test goes to the sink by a Relay route this sets up, as
[email protected], if it isn't there (route "lab-sink" and one line in the
outbound strategy). Exits 1 if any check failed. The lab's certificate is
self-signed, so TLS isn't verified.
"""
import base64, hashlib, http.client as httpc, imaplib, json, os, secrets, smtplib, ssl
import subprocess, sys, time, urllib.parse, uuid
from email.message import EmailMessage
from email.utils import formatdate, make_msgid
lb, http_base, alice_pw_file, admin_pw_file = sys.argv[1:5]
KCTX = os.environ.get("KCTX", "kind-inbuxa-lab")
ALICE = "[email protected]"
alice_pw = open(alice_pw_file).read().strip()
admin_pw = open(admin_pw_file).read().strip()
run = uuid.uuid4().hex[:10]
SINK = "sink.lab-sink.svc.cluster.local"
tls = ssl.create_default_context()
tls.check_hostname = False
tls.verify_mode = ssl.CERT_NONE
results = []
def check(name):
def wrap(fn):
t = time.time()
try:
detail = fn() or ""
results.append((name, True, detail, time.time() - t))
except Exception as e: # each check reports, the rest still run
results.append((name, False, f"{type(e).__name__}: {e}"[:200], time.time() - t))
return fn
return wrap
def web(method, path, body=None, headers=None):
u = urllib.parse.urlsplit(http_base)
c = httpc.HTTPConnection(u.hostname, u.port, timeout=60)
h = {"Host": "mail.lab.test"}
h.update(headers or {})
c.request(method, path, body=body, headers=h)
r = c.getresponse()
d = r.read()
c.close()
return r.status, d
def oauth(account, password):
"""A bearer token, signed in as the console does (its OAuth client)."""
v = secrets.token_urlsafe(48)
ch = base64.urlsafe_b64encode(hashlib.sha256(v.encode()).digest()).rstrip(b"=").decode()
red = "https://admin.lab.test/oauth/callback"
s, d = web("POST", "/api/auth", json.dumps({
"type": "authCode", "accountName": account, "accountSecret": password, "clientId": "inbuxa-admin",
"redirectUri": red, "codeChallenge": ch, "codeChallengeMethod": "S256", "state": "x"}),
{"content-type": "application/json"})
if s != 200:
raise RuntimeError(f"/api/auth for {account}: HTTP {s} {d[:120]!r}")
code = json.loads(d)["client_code"]
s, d = web("POST", "/auth/token", urllib.parse.urlencode({
"grant_type": "authorization_code", "code": code, "redirect_uri": red,
"client_id": "inbuxa-admin", "code_verifier": v}),
{"content-type": "application/x-www-form-urlencoded"})
if s != 200:
raise RuntimeError(f"/auth/token for {account}: HTTP {s}")
return json.loads(d)["access_token"]
def jmap(token, using, calls):
s, d = web("POST", "/jmap", json.dumps({"using": using, "methodCalls": calls}),
{"content-type": "application/json", "authorization": "Bearer " + token})
if s != 200:
raise RuntimeError(f"jmap: HTTP {s} {d[:160]!r}")
out = json.loads(d)["methodResponses"]
for name, args, tag in out:
if name == "error":
raise RuntimeError(f"jmap {tag}: {args}")
return out
def ensure_sink_route():
"""Mail for sink.test to the sink: a Relay route and its strategy line."""
reg = ["urn:ietf:params:jmap:core", "urn:inbuxa:jmap:registry"]
tok = oauth("[email protected]", admin_pw)
routes, strategy = jmap(tok, reg, [["x:MtaRoute/get", {}, "r"],
["x:MtaOutboundStrategy/get", {"ids": ["singleton"]}, "s"]])
if not any(r.get("name") == "lab-sink" for r in routes[1]["list"]):
jmap(tok, reg, [["x:MtaRoute/set", {"create": {"sink": {
"@type": "Relay", "name": "lab-sink", "description": "The lab's outside mail server (mail-sink.yaml)",
"address": SINK, "port": 25, "protocol": "smtp", "implicitTls": False,
"allowInvalidCerts": True}}}, "c"]])
route = strategy[1]["list"][0]["route"]
rule = {"if": "rcpt_domain == 'sink.test'", "then": "'lab-sink'"}
if rule not in route["match"].values():
match = {str(i): m for i, m in enumerate([rule] + list(route["match"].values()))}
jmap(tok, reg, [["x:MtaOutboundStrategy/set", {"update": {"singleton": {
"route": {"match": match, "else": route["else"]}}}}, "u"]])
# The strategy reaches every node by the cluster's config reload
time.sleep(5)
def message(frm, to, subject):
m = EmailMessage()
m["From"], m["To"], m["Subject"] = frm, to, subject
m["Date"] = formatdate()
m["Message-ID"] = make_msgid(domain=frm.split("@")[1])
m.set_content(f"{subject}\n")
return m
SUBJECT = f"mailcheck {run}"
sent = {}
@check("smtp in")
def smtp_in():
# A sender domain of its own: the default throttle allows 25 an hour
# from one sender domain to one recipient
with smtplib.SMTP(lb, 25, timeout=30) as s:
s.send_message(message(f"lab-sender@{run}.sender.test", ALICE, f"{SUBJECT} in"))
sent["in"] = f"{SUBJECT} in"
return "accepted on 25"
@check("submission")
def submission():
ensure_sink_route()
with smtplib.SMTP_SSL(lb, 465, timeout=30, context=tls) as s:
s.login(ALICE, alice_pw)
s.send_message(message(ALICE, ALICE, f"{SUBJECT} self"))
s.send_message(message(ALICE, "[email protected]", f"{SUBJECT} out"))
sent["self"], sent["out"] = f"{SUBJECT} self", f"{SUBJECT} out"
return "accepted on 465 with AUTH: to alice and to [email protected]"
def imap_find():
found = {}
m = imaplib.IMAP4_SSL(lb, 993, ssl_context=tls, timeout=30)
try:
m.login(ALICE, alice_pw)
_, boxes = m.list()
for line in boxes:
name = line.decode().rsplit(' "/" ', 1)[-1].strip()
if m.select(name, readonly=True)[0] != "OK":
continue
for key in ("in", "self"):
if key in sent:
_, data = m.search(None, "SUBJECT", f'"{sent[key]}"')
if data[0].split():
found[key] = name.strip('"')
finally:
m.logout()
return found
@check("imap")
def imap():
want = {k for k in ("in", "self") if k in sent}
if not want:
raise RuntimeError("nothing was sent")
deadline, found = time.time() + 90, {}
while time.time() < deadline:
found = imap_find()
if want <= found.keys():
return ", ".join(f"{k} in {v}" for k, v in sorted(found.items()))
time.sleep(2)
raise RuntimeError(f"not found over IMAPS: {sorted(want - found.keys())}")
@check("jmap")
def jmap_check():
tok = oauth(ALICE, alice_pw)
s, d = web("GET", "/jmap/session", None, {"authorization": "Bearer " + tok})
if s != 200:
raise RuntimeError(f"session: HTTP {s}")
acct = json.loads(d)["primaryAccounts"]["urn:ietf:params:jmap:mail"]
using = ["urn:ietf:params:jmap:core", "urn:ietf:params:jmap:mail"]
deadline = time.time() + 90
while True:
out = jmap(tok, using, [
["Email/query", {"accountId": acct, "filter": {"subject": SUBJECT}}, "q"],
["Email/get", {"accountId": acct, "#ids": {"resultOf": "q", "name": "Email/query", "path": "/ids"},
"properties": ["subject"]}, "g"]])
subjects = sorted(e["subject"] for e in out[1][1]["list"])
want = sorted(sent[k] for k in ("in", "self") if k in sent)
if want and all(w in subjects for w in want):
return f"Email/query found {len(subjects)}"
if time.time() > deadline:
raise RuntimeError(f"Email/query found {subjects}, wanted {want}")
time.sleep(3)
@check("smtp out")
def smtp_out():
if "out" not in sent:
raise RuntimeError("nothing was sent")
deadline = time.time() + 90
while True:
logs = subprocess.run(["kubectl", "--context", KCTX, "-n", "lab-sink", "logs", "deploy/sink"],
capture_output=True, text=True, timeout=30).stdout
for line in logs.splitlines():
if not line.startswith("{"):
continue
rec = json.loads(line)
if rec["subject"] == sent["out"]:
if rec["from"] != ALICE or rec["rcpts"] != ["[email protected]"]:
raise RuntimeError(f"arrived wrong: from {rec['from']} to {rec['rcpts']}")
if not any("d=lab.test" in h.replace(" ", "") for h in rec["dkim"]):
raise RuntimeError("arrived without a DKIM signature for lab.test")
return f"reached the sink from {rec['ehlo'] or '?'}, DKIM d=lab.test"
if time.time() > deadline:
raise RuntimeError("never reached the sink")
time.sleep(3)
BASIC = {"authorization": "Basic " + base64.b64encode(f"{ALICE}:{alice_pw}".encode()).decode()}
def dav_roundtrip(collection, name, ctype, body, marker):
path = f"/dav/{collection}/alice%40lab.test/default/{name}"
s, _ = web("PUT", path, body.encode(), dict(BASIC, **{"content-type": ctype}))
if s not in (201, 204):
raise RuntimeError(f"PUT: HTTP {s}")
s, d = web("GET", path, None, BASIC)
if s != 200 or marker not in d.decode():
raise RuntimeError(f"GET: HTTP {s}, {'with' if marker in d.decode() else 'without'} it")
s, _ = web("DELETE", path, None, BASIC)
if s not in (200, 204):
raise RuntimeError(f"DELETE: HTTP {s}")
s, _ = web("GET", path, None, BASIC)
if s != 404:
raise RuntimeError(f"still there after DELETE: HTTP {s}")
return "put, read back, deleted"
@check("caldav")
def caldav():
uid = f"mailcheck-{run}@lab.test"
stamp = time.strftime("%Y%m%dT%H%M%SZ", time.gmtime())
ics = ("BEGIN:VCALENDAR\r\nVERSION:2.0\r\nPRODID:-//inbuxa lab//mailcheck//EN\r\nBEGIN:VEVENT\r\n"
f"UID:{uid}\r\nDTSTAMP:{stamp}\r\nDTSTART:{stamp}\r\nDURATION:PT30M\r\n"
f"SUMMARY:mailcheck {run}\r\nEND:VEVENT\r\nEND:VCALENDAR\r\n")
return dav_roundtrip("cal", f"{run}.ics", "text/calendar; charset=utf-8", ics, uid)
@check("carddav")
def carddav():
uid = f"mailcheck-{run}"
vcf = (f"BEGIN:VCARD\r\nVERSION:3.0\r\nUID:{uid}\r\nFN:Mailcheck {run}\r\n"
f"EMAIL:probe@{run}.sender.test\r\nEND:VCARD\r\n")
return dav_roundtrip("card", f"{run}.vcf", "text/vcard; charset=utf-8", vcf, uid)
width = max(len(n) for n, *_ in results)
print(f"mailcheck {run}:")
for name, ok, detail, took in results:
print(f" {'ok ' if ok else 'FAIL'} {name:<{width}} {took:5.1f}s {detail}")
sys.exit(0 if all(ok for _, ok, *_ in results) else 1)
+72
View File
@@ -0,0 +1,72 @@
#!/usr/bin/env bash
# SPDX-FileCopyrightText: 2026 Coffey Labs LLC
# SPDX-License-Identifier: Apache-2.0
#
# Every client check against an installed chart, in one command (K-L2):
#
# mailcheck.py SMTP in on 25, submission on 465, IMAPS, JMAP, SMTP out
# to an outside server (mail-sink.yaml), CalDAV, CardDAV
# signin.py the webmail: signing in starting on one replica and
# finishing on the other
# console-signin.py the console: signing in as its browser would
#
# lab/chart/mailcheck.sh
#
# Wants the lab's seeded install with the webmail and the console
# (values-frontends.yaml), and the passwords seed-store.sh or e2e.sh left
# under $STATE. Sets up the sink (namespace lab-sink) if it isn't there.
# PORTS picks four free local ports in a row (default from 18080).
set -euo pipefail
here=$(cd "$(dirname "$0")" && pwd)
. "$here/../versions.env"
KCTX="kind-$KIND_CLUSTER"
K=(kubectl --context "$KCTX" -n inbuxa)
STATE="${STATE:-$HOME/.cache/inbuxa-lab}"
P="${PORTS:-18080}"
PIDS=()
trap 'for p in "${PIDS[@]}"; do kill "$p" 2>/dev/null || true; done' EXIT
fail() { echo "!! $*" >&2; exit 1; }
echo "== the outside mail server"
sed "s|image: IMAGE|image: $PG_IMAGE|" "$here/mail-sink.yaml" | kubectl --context "$KCTX" apply -f - >/dev/null
kubectl --context "$KCTX" -n lab-sink rollout status deploy/sink --timeout=180s >/dev/null
lb=""
for _ in $(seq 1 30); do
lb="$("${K[@]}" get svc inbuxa-mail -o jsonpath='{.status.loadBalancer.ingress[0].ip}')"
[ -n "$lb" ] && break
sleep 2
done
[ -n "$lb" ] || fail "the mail Service has no address"
forward() { # <local port> <target>
# Something else on the port would answer in the forward's place
if ss -ltn "sport = :$1" | grep -q LISTEN; then
fail "port $1 is in use: PORTS=<first of four free ports> $0"
fi
"${K[@]}" port-forward "$2" "$1:8080" >/dev/null 2>&1 &
PIDS+=($!)
}
mapfile -t webmail < <("${K[@]}" get pods -l app.kubernetes.io/component=webmail \
--field-selector status.phase=Running -o name | sort)
[ "${#webmail[@]}" -ge 2 ] || fail "fewer than two webmail pods (values-frontends.yaml?)"
forward "$P" svc/inbuxa-http
forward $((P + 1)) "${webmail[0]}"
forward $((P + 2)) "${webmail[1]}"
forward $((P + 3)) svc/inbuxa-console
sleep 3
echo "== mail, calendars and contacts, as [email protected]"
KCTX="$KCTX" python3 "$here/mailcheck.py" "$lb" "http://127.0.0.1:$P" \
"$STATE/alice.password" "$STATE/admin.password"
echo "== webmail: start on ${webmail[0]#pod/}, finish on ${webmail[1]#pod/}"
python3 "$here/signin.py" "http://127.0.0.1:$((P + 1))" "http://127.0.0.1:$((P + 2))" \
"http://127.0.0.1:$P" [email protected] "$STATE/alice.password"
echo "== console"
python3 "$here/console-signin.py" "http://127.0.0.1:$((P + 3))" "http://127.0.0.1:$P" \
https://admin.lab.test https://mail.lab.test [email protected] "$STATE/admin.password"
echo "== every check passed"
+6 -44
View File
@@ -6,9 +6,9 @@
# layer (up.sh), then the chart with the released images the next chart
# release names (inbuxa-charts release/suite.yaml), seeded, then
#
# 1. mail: in over SMTP, found over IMAPS, through the mail Service
# 2. the webmail: signing in across both replicas
# 3. the console: signing in as its browser would
# every client check, chart/mailcheck.sh: SMTP in, submission, IMAP,
# JMAP, SMTP out to an outside server, CalDAV, CardDAV, the webmail across
# both replicas and the console
#
# and how long each part took. CI runs this on a fresh runner; on the bench
# it builds the lab from scratch too, so take the lab down first
@@ -30,7 +30,6 @@ SUITE="$CHART_REPO/release/suite.yaml"
STATE="${STATE:-$HOME/.cache/inbuxa-lab}"
K=(kubectl --context "kind-$KIND_CLUSTER" -n inbuxa)
P="${PORTS:-18080}"
PIDS=()
t0=$SECONDS
SUMMARY=()
lap() { SUMMARY+=("| $1 | $(( SECONDS - ${2:-$t0} ))s |"); }
@@ -42,7 +41,6 @@ report() {
}
on_exit() {
rc=$?
for p in "${PIDS[@]}"; do kill "$p" 2>/dev/null || true; done
if [ "$rc" != 0 ]; then
SUMMARY+=("| **failed** | after $(( SECONDS - t0 ))s |")
echo "== failed: pods and events"
@@ -94,46 +92,10 @@ helm --kube-context "kind-$KIND_CLUSTER" -n inbuxa upgrade --install inbuxa "$CH
"${K[@]}" get pods --no-headers -o wide | awk '{print " " $1, $3, $7}'
lap "chart install (seed, server, webmail, console)" "$s"
echo "== 1. mail"
echo "== the client checks (chart/mailcheck.sh)"
s=$SECONDS
lb=""
for _ in $(seq 1 30); do
lb="$("${K[@]}" get svc inbuxa-mail -o jsonpath='{.status.loadBalancer.ingress[0].ip}')"
[ -n "$lb" ] && break
sleep 2
done
[ -n "$lb" ] || { echo "!! the mail Service has no address" >&2; exit 1; }
ACCOUNT=[email protected] PASSWORD_FILE="$STATE/alice.password" timeout 150 python3 "$here/chart/mailtest.py" "$lb"
lap "mail: SMTP in, IMAPS found" "$s"
forward() { # <local port> <target>
if ss -ltn "sport = :$1" | grep -q LISTEN; then
echo "!! port $1 is in use: PORTS=<first of four free ports> $0" >&2
exit 1
fi
"${K[@]}" port-forward "$2" "$1:8080" >/dev/null 2>&1 &
PIDS+=($!)
}
mapfile -t webmail < <("${K[@]}" get pods -l app.kubernetes.io/component=webmail \
--field-selector status.phase=Running -o name | sort)
[ "${#webmail[@]}" -ge 2 ] || { echo "!! fewer than two webmail pods" >&2; exit 1; }
forward $((P + 1)) "${webmail[0]}"
forward $((P + 2)) "${webmail[1]}"
forward "$P" svc/inbuxa-http
forward $((P + 3)) svc/inbuxa-console
sleep 3
echo "== 2. webmail: start on ${webmail[0]#pod/}, finish on ${webmail[1]#pod/}"
s=$SECONDS
python3 "$here/chart/signin.py" "http://127.0.0.1:$((P + 1))" "http://127.0.0.1:$((P + 2))" \
"http://127.0.0.1:$P" [email protected] "$STATE/alice.password"
lap "webmail sign-in across replicas" "$s"
echo "== 3. console"
s=$SECONDS
python3 "$here/chart/console-signin.py" "http://127.0.0.1:$((P + 3))" "http://127.0.0.1:$P" \
https://admin.lab.test https://mail.lab.test [email protected] "$STATE/admin.password"
lap "console sign-in" "$s"
PORTS="$P" STATE="$STATE" "$here/chart/mailcheck.sh"
lap "mail (SMTP in, submission, IMAP, JMAP, SMTP out), CalDAV, CardDAV, webmail, console" "$s"
lap "**total**"
echo "== passed in $(( SECONDS - t0 ))s"
+3 -1
View File
@@ -47,5 +47,7 @@ tar -xzf "$WORK/helm.tgz" -C "$WORK" "linux-$ARCH/helm"
install -m 0755 "$WORK/linux-$ARCH/helm" "$DIR/helm"
"$DIR/kind" version
"$DIR/kubectl" version --client | head -1
# sed reads everything: head would leave kubectl writing to a closed pipe
# (SIGPIPE, 141 under pipefail)
"$DIR/kubectl" version --client | sed -n 1p
"$DIR/helm" version --short