471 lines
14 KiB
Bash
Executable file
471 lines
14 KiB
Bash
Executable file
#!/usr/bin/env bash
|
|
# Phase zero-pay: public-template pays (CHF:0 stickers / TESTPAYSAN shop).
|
|
# Same path as e2e_one_pay_public_template. Never run-until-done.
|
|
# Wrapper: pay_talersticker_zero.sh (COUNT default 100).
|
|
#
|
|
# Env: COUNT (phase default 1) GAP_S PARALLEL MERCHANT INST TEMPLATE AMOUNT
|
|
# EXCHANGE ZERO_PAY_POST=amount|empty HANDLE_SECS SETTLE_TRIES SETTLE_SLEEP
|
|
#
|
|
set -euo pipefail
|
|
|
|
ROOT=$(cd "$(dirname "$0")" && pwd)
|
|
# shellcheck source=lib.sh
|
|
source "$ROOT/lib.sh"
|
|
# shellcheck source=metrics.sh
|
|
source "$ROOT/metrics.sh"
|
|
set_area zero-pay
|
|
|
|
# Homebrew python3 (>=3.11) must beat /usr/bin/python3 3.9 — taler-helper-sqlite3.
|
|
export PATH="/opt/homebrew/bin:${HOME}/.local/bin:/usr/local/bin:/usr/bin:/bin:${PATH:-}"
|
|
|
|
die() { echo "ERROR: $*" >&2; fail "zero-pay" "$*" 2>/dev/null || true; exit 1; }
|
|
|
|
COUNT="${COUNT:-${ZERO_PAY_COUNT:-1}}"
|
|
GAP_S="${GAP_S:-0}"
|
|
PARALLEL="${PARALLEL:-1}"
|
|
MERCHANT="${MERCHANT:-${MERCHANT_PUBLIC:-https://stage.my.taler-ops.ch}}"
|
|
MERCHANT="${MERCHANT%/}"
|
|
CUR="${EXPECT_CURRENCY:-${CUR:-}}"
|
|
if [ "$CUR" = "TESTPAYSAN" ]; then
|
|
INST="${INST:-${ZERO_PAY_INST:-jardin-du-creux}}"
|
|
TEMPLATE="${TEMPLATE:-${ZERO_PAY_TEMPLATE:-oeufs-6}}"
|
|
AMOUNT="${AMOUNT:-${ZERO_PAY_AMOUNT:-TESTPAYSAN:5}}"
|
|
EXCHANGE="${EXCHANGE:-${EXCHANGE_PUBLIC:-https://stage.exchange.lefrancpaysan.ch/}}"
|
|
ZERO_PAY_POST="${ZERO_PAY_POST:-empty}"
|
|
else
|
|
INST="${INST:-${ZERO_PAY_INST:-admin}}"
|
|
TEMPLATE="${TEMPLATE:-${ZERO_PAY_TEMPLATE:-stickers}}"
|
|
AMOUNT="${AMOUNT:-${ZERO_PAY_AMOUNT:-CHF:0}}"
|
|
EXCHANGE="${EXCHANGE:-${EXCHANGE_PUBLIC:-https://exchange.stage.taler-ops.ch/}}"
|
|
ZERO_PAY_POST="${ZERO_PAY_POST:-amount}"
|
|
fi
|
|
EXCHANGE="${EXCHANGE%/}/"
|
|
HANDLE_SECS="${HANDLE_SECS:-25}"
|
|
SETTLE_TRIES="${SETTLE_TRIES:-40}"
|
|
SETTLE_SLEEP="${SETTLE_SLEEP:-0.15}"
|
|
case "$GAP_S" in
|
|
''|*[!0-9.]*|*.*.*) die "GAP_S must be a non-negative number (got $GAP_S)" ;;
|
|
esac
|
|
case "$COUNT" in
|
|
''|*[!0-9]*) die "COUNT must be a positive integer (got $COUNT)" ;;
|
|
esac
|
|
[ "$COUNT" -ge 1 ] || die "COUNT must be >= 1"
|
|
case "$PARALLEL" in
|
|
all|ALL) PARALLEL="$COUNT" ;;
|
|
''|*[!0-9]*) die "PARALLEL must be a positive integer or all (got $PARALLEL)" ;;
|
|
esac
|
|
[ "$PARALLEL" -ge 1 ] || die "PARALLEL must be >= 1"
|
|
if [ "$PARALLEL" -gt "$COUNT" ]; then
|
|
PARALLEL="$COUNT"
|
|
fi
|
|
|
|
OUTDIR="${OUTDIR:-/tmp/talersticker-zero-$(date +%Y%m%d-%H%M%S)}"
|
|
mkdir -p "$OUTDIR"
|
|
TSV="$OUTDIR/results.tsv"
|
|
LOG="$OUTDIR/run.log"
|
|
SCRATCH="$OUTDIR/scratch"
|
|
mkdir -p "$SCRATCH"
|
|
SERVE_PIDFILE="$OUTDIR/serve.pids"
|
|
|
|
if [ -z "${TALER_MON_STATE:-}" ]; then
|
|
exec > >(tee -a "$LOG") 2>&1
|
|
fi
|
|
|
|
now_ms() { python3 -c 'import time; print(int(time.time()*1000))'; }
|
|
|
|
if [ -n "${WALLET_DB:-}" ] && [ "$PARALLEL" -gt 1 ]; then
|
|
die "--wallet-db / WALLET_DB needs PARALLEL=1"
|
|
fi
|
|
slot_db() {
|
|
if [ -n "${WALLET_DB:-}" ] && [ "$1" = "0" ]; then
|
|
taler_mon_resolve_wallet_db "$OUTDIR/wallet-0.sqlite3" || exit 2
|
|
else
|
|
echo "$OUTDIR/wallet-$1.sqlite3"
|
|
fi
|
|
}
|
|
slot_sock() { echo "$OUTDIR/wallet-$1.sock"; }
|
|
slot_log() { echo "$OUTDIR/wallet-serve-$1.log"; }
|
|
|
|
stop_wallet_serve() {
|
|
if [ -f "$SERVE_PIDFILE" ]; then
|
|
while read -r pid; do
|
|
[ -n "$pid" ] || continue
|
|
kill "$pid" 2>/dev/null || true
|
|
wait "$pid" 2>/dev/null || true
|
|
done <"$SERVE_PIDFILE"
|
|
rm -f "$SERVE_PIDFILE"
|
|
fi
|
|
rm -f "$OUTDIR"/wallet-*.sock 2>/dev/null || true
|
|
}
|
|
trap 'stop_wallet_serve' EXIT
|
|
|
|
_wcli_exec() {
|
|
local cap="$1"
|
|
shift
|
|
local -a cmd
|
|
cmd=( "$NODE_BIN" "$WALLET_CLI" "$@" )
|
|
if command -v timeout >/dev/null 2>&1; then
|
|
timeout -k 2 "$cap" "${cmd[@]}"
|
|
elif command -v gtimeout >/dev/null 2>&1; then
|
|
gtimeout --kill-after=2 "$cap" "${cmd[@]}"
|
|
else
|
|
perl -e 'alarm shift; exec @ARGV' "$cap" "${cmd[@]}"
|
|
fi
|
|
}
|
|
|
|
wcli_slot() {
|
|
local slot="$1"
|
|
local cap="$2"
|
|
shift 2
|
|
local sock db
|
|
sock=$(slot_sock "$slot")
|
|
db=$(slot_db "$slot")
|
|
if [ -S "$sock" ]; then
|
|
_wcli_exec "$cap" --wallet-connection="$sock" --no-throttle "$@"
|
|
else
|
|
_wcli_exec "$cap" --wallet-db="$db" --no-throttle --skip-defaults "$@"
|
|
fi
|
|
}
|
|
|
|
start_wallet_slot() {
|
|
local slot="$1"
|
|
local sock db log
|
|
sock=$(slot_sock "$slot")
|
|
db=$(slot_db "$slot")
|
|
log=$(slot_log "$slot")
|
|
rm -f "$sock"
|
|
"$NODE_BIN" "$WALLET_CLI" --wallet-db="$db" --no-throttle --skip-defaults \
|
|
advanced serve --unix-path "$sock" \
|
|
>"$log" 2>&1 &
|
|
local pid=$!
|
|
echo "$pid" >>"$SERVE_PIDFILE"
|
|
local i
|
|
for i in $(seq 1 50); do
|
|
if [ -S "$sock" ] && kill -0 "$pid" 2>/dev/null; then
|
|
info "wallet serve slot=$slot pid=$pid"
|
|
return 0
|
|
fi
|
|
sleep 0.1
|
|
done
|
|
echo "WARN: wallet serve slot=$slot socket not ready"
|
|
return 1
|
|
}
|
|
|
|
find_wallet_cli() {
|
|
if [ -n "${WALLET_CLI:-}" ] && [ -f "$WALLET_CLI" ]; then
|
|
printf '%s\n' "$WALLET_CLI"
|
|
return 0
|
|
fi
|
|
local c
|
|
for c in \
|
|
"${HOME}/src/llm-qwythos/taler/taler-typescript-core/packages/taler-wallet-cli/bin/taler-wallet-cli.mjs" \
|
|
"${HOME}/src/taler/taler-typescript-core/packages/taler-wallet-cli/bin/taler-wallet-cli.mjs" \
|
|
"${HOME}/.local/bin/taler-wallet-cli.mjs" \
|
|
"${HOME}/src/llm-qwythos/taler/taler-typescript-core/packages/taler-wallet-cli/dist/taler-wallet-cli-bundled.cjs"
|
|
do
|
|
[ -f "$c" ] && { printf '%s\n' "$c"; return 0; }
|
|
done
|
|
return 1
|
|
}
|
|
|
|
NODE_BIN=$(command -v node) || die "node not found"
|
|
python3 - <<'PY' || die "python3 >= 3.11 required (taler-helper-sqlite3)"
|
|
import sys
|
|
raise SystemExit(0 if sys.version_info >= (3, 11) else 1)
|
|
PY
|
|
command -v taler-helper-sqlite3 >/dev/null || die "taler-helper-sqlite3 not on PATH"
|
|
WALLET_CLI=$(find_wallet_cli) || die "taler-wallet-cli .mjs not found (set WALLET_CLI=)"
|
|
|
|
json_get() {
|
|
python3 -c 'import json,sys
|
|
p,k=sys.argv[1],sys.argv[2]
|
|
try:
|
|
d=json.load(open(p))
|
|
v=d
|
|
for part in k.split("."):
|
|
if isinstance(v, dict):
|
|
v=v.get(part)
|
|
else:
|
|
v=None
|
|
break
|
|
print("" if v is None else v)
|
|
except Exception:
|
|
print("")
|
|
' "$@"
|
|
}
|
|
|
|
create_template_order() {
|
|
local summary="$1" out="$2"
|
|
local body url
|
|
if [ "${ZERO_PAY_POST}" = "empty" ]; then
|
|
body='{}'
|
|
else
|
|
body=$(python3 -c 'import json,sys; print(json.dumps({"amount":sys.argv[1],"summary":sys.argv[2]}))' "$AMOUNT" "$summary")
|
|
fi
|
|
url="${MERCHANT}/instances/${INST}/templates/${TEMPLATE}"
|
|
if [ "$INST" = "admin" ] || [ "$INST" = "default" ] || [ -z "$INST" ]; then
|
|
url="${MERCHANT}/templates/${TEMPLATE}"
|
|
fi
|
|
curl -sS -m 20 -X POST -H "Content-Type: application/json" -d "$body" "$url" >"$out"
|
|
}
|
|
|
|
order_public() {
|
|
local oid="$1" tok="$2" out="$3"
|
|
local qoid qtok base
|
|
qoid=$(python3 -c 'import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1], safe=""))' "$oid")
|
|
qtok=$(python3 -c 'import urllib.parse,sys; print(urllib.parse.quote(sys.argv[1], safe=""))' "$tok")
|
|
if [ "$INST" = "admin" ] || [ "$INST" = "default" ] || [ -z "$INST" ]; then
|
|
base="${MERCHANT}/orders/${qoid}?token=${qtok}"
|
|
else
|
|
base="${MERCHANT}/instances/${INST}/orders/${qoid}?token=${qtok}"
|
|
fi
|
|
curl -sS -m 12 "$base" >"$out"
|
|
}
|
|
|
|
order_is_paid() {
|
|
merchant_order_json_is_paid "$1"
|
|
}
|
|
|
|
wallet_handle_done() {
|
|
grep -q "Finished with status .done." "$1" 2>/dev/null
|
|
}
|
|
|
|
write_row() {
|
|
# n oid create handle settle total status payuri
|
|
printf '%s\t%s\t%s\t%s\t%s\t%s\t%s\t%s\n' "$@"
|
|
}
|
|
|
|
# One payment. Args: n slot. Always writes scratch/row.N.tsv and scratch/msg.N.txt.
|
|
do_one_pay() {
|
|
local n="$1" slot="$2"
|
|
local tag
|
|
tag=$(printf '%03d' "$n")
|
|
local nonce summary create_f status_f pay_f row_f msg_f
|
|
nonce="${n}-$(date +%s)-$RANDOM"
|
|
summary="taler-monitoring zero-pay #${n} ${nonce}"
|
|
create_f="$SCRATCH/ord-$tag.json"
|
|
status_f="$SCRATCH/st-$tag.json"
|
|
pay_f="$SCRATCH/pay-$tag.out"
|
|
row_f="$SCRATCH/row.$n.tsv"
|
|
msg_f="$SCRATCH/msg.$n.txt"
|
|
|
|
local t0 t1 t_create t_h0 t_h1 t_s0 t_s1
|
|
local create_ms handle_ms settle_ms total_ms
|
|
local oid tok payuri hint hc status
|
|
local settled merchant_paid i fail_tail
|
|
|
|
t0=$(now_ms)
|
|
if ! create_template_order "$summary" "$create_f"; then
|
|
t1=$(now_ms)
|
|
create_ms=$((t1-t0))
|
|
write_row "$n" "" "$create_ms" "" "" "$create_ms" "CREATE_HTTP_FAIL" "" >"$row_f"
|
|
echo "[$tag] CREATE_HTTP_FAIL ${create_ms}ms slot=$slot" >"$msg_f"
|
|
return 0
|
|
fi
|
|
oid=$(json_get "$create_f" order_id)
|
|
tok=$(json_get "$create_f" token)
|
|
t_create=$(now_ms)
|
|
create_ms=$((t_create-t0))
|
|
if [ -z "$oid" ] || [ -z "$tok" ]; then
|
|
hint=$(json_get "$create_f" hint)
|
|
write_row "$n" "" "$create_ms" "" "" "$create_ms" "CREATE_FAIL" "" >"$row_f"
|
|
echo "[$tag] CREATE_FAIL ${create_ms}ms hint=${hint} slot=$slot" >"$msg_f"
|
|
return 0
|
|
fi
|
|
|
|
order_public "$oid" "$tok" "$status_f" || true
|
|
payuri=$(json_get "$status_f" taler_pay_uri)
|
|
if [ -z "$payuri" ]; then
|
|
local mh
|
|
mh=$(python3 -c 'from urllib.parse import urlparse; print(urlparse("'"$MERCHANT"'").hostname or "")')
|
|
payuri="taler://pay/${mh}/instances/${INST}/${oid}/?c=${tok}"
|
|
fi
|
|
payuri=$(printf '%s' "$payuri" | sed 's/:443\//\//g; s/:443?/?/g')
|
|
|
|
t_h0=$(now_ms)
|
|
set +e
|
|
wcli_slot "$slot" "$HANDLE_SECS" handle-uri --yes --non-interactive "$payuri" >"$pay_f" 2>&1
|
|
hc=$?
|
|
set -e
|
|
t_h1=$(now_ms)
|
|
handle_ms=$((t_h1-t_h0))
|
|
if grep -q "Payment failed" "$pay_f" 2>/dev/null; then
|
|
hc=1
|
|
fi
|
|
|
|
settled=0
|
|
merchant_paid=0
|
|
t_s0=$(now_ms)
|
|
i=1
|
|
while [ "$i" -le "$SETTLE_TRIES" ]; do
|
|
order_public "$oid" "$tok" "$status_f" || true
|
|
if order_is_paid "$status_f"; then
|
|
merchant_paid=1
|
|
settled=1
|
|
break
|
|
fi
|
|
if wallet_handle_done "$pay_f"; then
|
|
settled=1
|
|
fi
|
|
if [ "$settled" = "1" ] && [ "$i" -ge 3 ]; then
|
|
break
|
|
fi
|
|
sleep "$SETTLE_SLEEP"
|
|
i=$((i+1))
|
|
done
|
|
t_s1=$(now_ms)
|
|
settle_ms=$((t_s1-t_s0))
|
|
total_ms=$((t_s1-t0))
|
|
|
|
if [ "$merchant_paid" = "1" ] || [ "$settled" = "1" ]; then
|
|
status=PAID
|
|
elif [ "$hc" = "0" ]; then
|
|
status=HANDLE_OK_UNSETTLED
|
|
else
|
|
status=HANDLE_FAIL
|
|
fi
|
|
write_row "$n" "$oid" "$create_ms" "$handle_ms" "$settle_ms" "$total_ms" "$status" "$payuri" >"$row_f"
|
|
echo "[$tag] $status oid=$oid create=${create_ms}ms handle=${handle_ms}ms settle=${settle_ms}ms total=${total_ms}ms slot=$slot" >"$msg_f"
|
|
if [ "$status" != "PAID" ]; then
|
|
fail_tail=$(tail -c 180 "$pay_f" | tr '\n' ' ')
|
|
echo " handle-exit=${hc} tail=${fail_tail}" >>"$msg_f"
|
|
fi
|
|
}
|
|
|
|
prep_slot_exchange() {
|
|
local slot="$1"
|
|
wcli_slot "$slot" 40 exchanges add "$EXCHANGE" >"$OUTDIR/exchanges-add-$slot.out" 2>&1 || true
|
|
wcli_slot "$slot" 40 exchanges tos "$EXCHANGE" >"$OUTDIR/exchanges-tos-$slot.out" 2>&1 || true
|
|
wcli_slot "$slot" 40 exchanges accept-tos "$EXCHANGE" >"$OUTDIR/exchanges-accept-tos-$slot.out" 2>&1 || true
|
|
}
|
|
|
|
section "zero-pay · ${AMOUNT} x ${COUNT} · ${INST}/${TEMPLATE}"
|
|
info "merchant $MERCHANT"
|
|
info "instance $INST"
|
|
info "template $TEMPLATE amount=$AMOUNT"
|
|
info "wallet $WALLET_CLI"
|
|
info "python $(command -v python3) $(python3 -c 'import sys; print(".".join(map(str,sys.version_info[:3])))')"
|
|
info "helper $(command -v taler-helper-sqlite3)"
|
|
info "outdir $OUTDIR"
|
|
info "gap ${GAP_S}s between blocks (not in total_ms)"
|
|
info "parallel $PARALLEL per block (own wallet serve per slot)"
|
|
if [ "$PARALLEL" -gt 20 ]; then
|
|
echo "WARN: PARALLEL=$PARALLEL starts that many wallet-cli node processes"
|
|
fi
|
|
|
|
wcli_slot 0 25 version >"$OUTDIR/wallet-version.txt" 2>&1 || true
|
|
info "wallet-cli $(head -1 "$OUTDIR/wallet-version.txt" 2>/dev/null || echo '?')"
|
|
|
|
: >"$SERVE_PIDFILE"
|
|
slot=0
|
|
while [ "$slot" -lt "$PARALLEL" ]; do
|
|
start_wallet_slot "$slot" || true
|
|
prep_slot_exchange "$slot"
|
|
slot=$((slot+1))
|
|
done
|
|
|
|
wcli_slot 0 20 balance >"$OUTDIR/balance-before.txt" 2>&1 || true
|
|
info "balance before: $(tr '\n' ' ' < "$OUTDIR/balance-before.txt" | tail -c 200)"
|
|
|
|
printf 'n\torder_id\tcreate_ms\thandle_ms\tsettle_ms\ttotal_ms\tstatus\tpay_uri\n' >"$TSV"
|
|
|
|
ok_n=0
|
|
fail_n=0
|
|
RUN_START_MS=$(now_ms)
|
|
|
|
n=1
|
|
while [ "$n" -le "$COUNT" ]; do
|
|
block_end=$((n + PARALLEL - 1))
|
|
if [ "$block_end" -gt "$COUNT" ]; then
|
|
block_end="$COUNT"
|
|
fi
|
|
slot=0
|
|
k="$n"
|
|
pay_pids=""
|
|
while [ "$k" -le "$block_end" ]; do
|
|
do_one_pay "$k" "$slot" &
|
|
pay_pids="$pay_pids $!"
|
|
slot=$((slot+1))
|
|
k=$((k+1))
|
|
done
|
|
set +e
|
|
for pid in $pay_pids; do
|
|
wait "$pid"
|
|
done
|
|
set -e
|
|
k="$n"
|
|
while [ "$k" -le "$block_end" ]; do
|
|
if [ -f "$SCRATCH/msg.$k.txt" ]; then
|
|
cat "$SCRATCH/msg.$k.txt"
|
|
else
|
|
echo "[$(printf '%03d' "$k")] MISSING (worker died)"
|
|
fi
|
|
if [ -f "$SCRATCH/row.$k.tsv" ]; then
|
|
cat "$SCRATCH/row.$k.tsv" >>"$TSV"
|
|
else
|
|
write_row "$k" "" "" "" "" "" "WORKER_DIED" "" >>"$TSV"
|
|
fi
|
|
k=$((k+1))
|
|
done
|
|
n=$((block_end + 1))
|
|
if [ "$n" -le "$COUNT" ]; then
|
|
case "$GAP_S" in
|
|
0|0.0|0.00) ;;
|
|
*) sleep "$GAP_S" ;;
|
|
esac
|
|
fi
|
|
done
|
|
|
|
RUN_END_MS=$(now_ms)
|
|
wall_ms=$((RUN_END_MS-RUN_START_MS))
|
|
|
|
ok_n=$(awk -F'\t' 'NR>1 && $7=="PAID" {c++} END {print c+0}' "$TSV")
|
|
fail_n=$((COUNT - ok_n))
|
|
|
|
section "zero-pay · summary"
|
|
info "ok=$ok_n fail=$fail_n count=$COUNT parallel=$PARALLEL gap_s=$GAP_S wall_ms=$wall_ms out=$TSV"
|
|
python3 - "$TSV" "$ok_n" "$fail_n" "$COUNT" "$wall_ms" "$OUTDIR/summary.txt" "$GAP_S" "$PARALLEL" <<'PY'
|
|
import sys
|
|
tsv, ok, fail, count, wall, outp, gap_s, parallel = sys.argv[1:]
|
|
ok, fail, count, wall = int(ok), int(fail), int(count), int(wall)
|
|
rows=[]
|
|
with open(tsv) as f:
|
|
next(f)
|
|
for line in f:
|
|
p=line.rstrip('\n').split('\t')
|
|
if len(p)<7: continue
|
|
rows.append(p)
|
|
paid=[r for r in rows if r[6]=='PAID']
|
|
def nums(idx, rs):
|
|
xs=[int(r[idx]) for r in rs if r[idx].isdigit()]
|
|
return xs
|
|
def fmt(xs):
|
|
if not xs: return "n/a"
|
|
xs=sorted(xs)
|
|
med=xs[len(xs)//2]
|
|
return "n=%d min=%d med=%d max=%d mean=%.1f" % (len(xs), xs[0], med, xs[-1], sum(xs)/len(xs))
|
|
lines=[]
|
|
lines.append("ok=%d fail=%d count=%d parallel=%s wall_ms=%d wall_s=%.1f gap_s=%s" % (
|
|
ok, fail, count, parallel, wall, wall/1000.0, gap_s))
|
|
lines.append("create_ms " + fmt(nums(2, paid)))
|
|
lines.append("handle_ms " + fmt(nums(3, paid)))
|
|
lines.append("settle_ms " + fmt(nums(4, paid)))
|
|
lines.append("total_ms " + fmt(nums(5, paid)))
|
|
if paid:
|
|
lines.append("first_paid_oid=%s last_paid_oid=%s" % (paid[0][1], paid[-1][1]))
|
|
text="\n".join(lines)+"\n"
|
|
open(outp,"w").write(text)
|
|
print(text)
|
|
PY
|
|
|
|
wcli_slot 0 20 balance >"$OUTDIR/balance-after.txt" 2>&1 || true
|
|
info "balance after: $(tr '\n' ' ' < "$OUTDIR/balance-after.txt" | tail -c 200)"
|
|
|
|
if [ "$ok_n" -lt "$COUNT" ]; then
|
|
fail "zero-pay" "ok=$ok_n fail=$fail_n count=$COUNT out=$TSV"
|
|
summary
|
|
exit 1
|
|
fi
|
|
ok "zero-pay" "ok=$ok_n count=$COUNT wall_ms=$wall_ms out=$TSV"
|
|
summary
|
|
exit 0
|