docker_build/remote/build_envs_remote.sh

#!/usr/bin/env bash
# Domestic-server pipeline:
#   1. Read configs/<env>/env.yml
#   2. mamba env create -n <env> -f env.yml (uses ~/.condarc mirrors)
#   3. If editable.txt non-empty: pip install -e <path> for each entry (source must be present)
#   4. conda-pack the new env into out/<env>.tar.gz (matches local pipeline)
#
# Idempotent: skips envs whose tarball already exists. Failure-tolerant.
# Parallel via xargs -P. Per-env status in state.tsv, failures in failed.txt.
#
# Required env vars:
#   CONFIGS_DIR    e.g. /home/user/mmsci/configs
#   OUT_DIR        e.g. /home/user/mmsci/conda_packs
#   EDITABLE_SRC   e.g. /home/user/mmsci/editable_sources   (root containing editable source trees; optional)
#   MAMBA_BIN      e.g. /opt/conda/bin/mamba                (default: 'mamba' on PATH)
#   CONDA_PACK     e.g. /opt/conda/bin/conda-pack           (default: 'conda-pack' on PATH)
#   JOBS           parallel envs (default 4)
#   LIST           optional file of env names; default = all dirs under CONFIGS_DIR

set -uo pipefail

: "${CONFIGS_DIR:?CONFIGS_DIR required}"
: "${OUT_DIR:?OUT_DIR required}"
EDITABLE_SRC="${EDITABLE_SRC:-}"
MAMBA_BIN="${MAMBA_BIN:-mamba}"
CONDA_PACK="${CONDA_PACK:-conda-pack}"
JOBS="${JOBS:-4}"
LIST_FILE="${LIST:-}"

LOG_DIR="$OUT_DIR/_logs"
STATE="$OUT_DIR/build.state.tsv"
FAILED="$OUT_DIR/build.failed.txt"

mkdir -p "$OUT_DIR" "$LOG_DIR"
[[ -s "$STATE" ]] || printf "env\tstatus\tphase\tseconds\tsize_bytes\n" > "$STATE"

if [[ -z "$LIST_FILE" ]]; then
    LIST_FILE="$OUT_DIR/_envs.txt"
    find "$CONFIGS_DIR" -mindepth 1 -maxdepth 1 -type d -printf '%f\n' | sort > "$LIST_FILE"
fi
total=$(wc -l < "$LIST_FILE")
echo "[$(date +%T)] building $total envs, JOBS=$JOBS"
echo "  configs: $CONFIGS_DIR"
echo "  out:     $OUT_DIR"
echo "  mamba:   $MAMBA_BIN"
echo "  pack:    $CONDA_PACK"
echo "  editable_src: ${EDITABLE_SRC:-(none)}"

export CONFIGS_DIR OUT_DIR EDITABLE_SRC MAMBA_BIN CONDA_PACK LOG_DIR STATE FAILED

build_one() {
    local env="$1"
    local conf="$CONFIGS_DIR/$env"
    local yml="$conf/env.yml"
    local edit="$conf/editable.txt"
    local meta="$conf/meta.json"
    local dst="$OUT_DIR/$env.tar.gz"
    local log="$LOG_DIR/$env.log"
    : > "$log"

    if [[ -s "$dst" ]]; then
        echo "[skip] $env already packed"
        printf "%s\tskip\t-\t0\t%s\n" "$env" "$(stat -c %s "$dst")" >> "$STATE"
        return 0
    fi
    if [[ ! -s "$yml" ]]; then
        echo "[missing-yml] $env"
        printf "%s\tfail\tmissing_yml\t0\t0\n" "$env" >> "$STATE"
        echo "$env  missing_yml" >> "$FAILED"
        return 1
    fi

    local t0=$(date +%s)
    echo "[create] $env" | tee -a "$log"
    if ! "$MAMBA_BIN" env create -n "$env" -f "$yml" -y >>"$log" 2>&1; then
        local dt=$(( $(date +%s) - t0 ))
        echo "[FAIL create] $env after ${dt}s (see $log)"
        printf "%s\tfail\tcreate\t%s\t0\n" "$env" "$dt" >> "$STATE"
        echo "$env  create" >> "$FAILED"
        return 1
    fi

    # editable installs (pip install -e <path>)
    if [[ -s "$edit" && -n "$EDITABLE_SRC" ]]; then
        while IFS=$'\t' read -r egg_name src_path; do
            [[ -z "$src_path" ]] && continue
            # remap original path -> EDITABLE_SRC/<env>/<basename>
            local remap="$EDITABLE_SRC/$env/$(basename "$src_path")"
            if [[ ! -d "$remap" ]]; then
                echo "[editable-missing] $env: $remap" | tee -a "$log"
                continue
            fi
            echo "[editable] $env: pip install -e $remap" | tee -a "$log"
            if ! "$MAMBA_BIN" run -n "$env" pip install -e "$remap" >>"$log" 2>&1; then
                echo "[FAIL editable] $env: $remap" | tee -a "$log"
            fi
        done < "$edit"
    fi

    # pack
    echo "[pack] $env" | tee -a "$log"
    if ! "$CONDA_PACK" -n "$env" -o "$dst" --compress-level=4 -j 8 \
            --ignore-missing-files --ignore-editable-packages --force >>"$log" 2>&1; then
        local dt=$(( $(date +%s) - t0 ))
        echo "[FAIL pack] $env after ${dt}s"
        printf "%s\tfail\tpack\t%s\t0\n" "$env" "$dt" >> "$STATE"
        echo "$env  pack" >> "$FAILED"
        rm -f "$dst"
        return 1
    fi

    local dt=$(( $(date +%s) - t0 ))
    local sz=$(stat -c %s "$dst")
    echo "[done] $env -> $(numfmt --to=iec "$sz") in ${dt}s"
    printf "%s\tdone\t-\t%s\t%s\n" "$env" "$dt" "$sz" >> "$STATE"
}
export -f build_one

cat "$LIST_FILE" | xargs -n1 -P "$JOBS" -I{} bash -c 'build_one "$@"' _ {}

echo "[$(date +%T)] all done"
echo "summary:"
awk -F'\t' 'NR>1{c[$2]++} END{for(k in c)printf "  %-8s %4d\n",k,c[k]}' "$STATE"
echo "total tarballs:  $(ls "$OUT_DIR"/*.tar.gz 2>/dev/null | wc -l)"
echo "total size:      $(du -shc "$OUT_DIR"/*.tar.gz 2>/dev/null | tail -1 | cut -f1)"