@terascope/scripts 2.25.0 → 2.26.0

package/docker/ceph/README.md

@@ -0,0 +1,111 @@
+# Ceph test service
+
+A single-node Ceph cluster (1 mon, 1 mgr, 1 OSD, 1 RGW) providing an
+S3-compatible endpoint for tests. The OSD is a BlueStore store on a sparse file,
+so there are no loop devices, no `--privileged`, and nothing touching the host's
+disks.
+
+## Under `ts-scripts test`
+
+The `opensearch` suite runs Ceph. Any other package opts in by setting
+`TEST_CEPH='true'` in its `test` script.
+
+`ensureCeph()` (`src/helpers/test-runner/services.ts`) generates the `.env` file
+in this directory from `src/helpers/config.ts`, runs `up -d`, waits for the
+`setup` script to exit 0, and runs `down -v` on teardown. Tests read
+`CEPH_HOST`, `CEPH_ACCESS_KEY`, and `CEPH_SECRET_KEY` from the environment.
+
+It also generates `docker-compose.osds.yml`, an override holding an `osd1`,
+`osd2`... service per `CEPH_OSD_COUNT`, each cloned from the `osd0` block, and
+runs compose with both files. `CEPH_OSD_COUNT=1` (the default) deletes the
+override and runs the base file alone, so there is nothing to generate for the
+common case. Edit `osd0` to change what every OSD gets.
+
+**No bucket is pre-created.** The stack gives you an S3 user; every test makes
+whatever buckets it needs and cleans them up.
+
+Every `CEPH_*` key in `config.ts` is overridable by an env var of the same name,
+except `CEPH_HOST` and `CEPH_PROTOCOL`, which are derived — set `CEPH_HOSTNAME`
+and `CEPH_PORT` instead.
+
+## Standalone
+
+```sh
+cp .env.example .env
+docker compose up -d
+docker compose run --rm toolbox   # a shell with ceph / radosgw-admin / rados
+docker compose down -v
+```
+
+Use **path-style** S3 addressing — virtual-host style needs wildcard DNS.
+
+## How addressing works
+
+Nothing here pins an IP or a subnet. `mon.sh` reads the monitor's own address
+off its interface at runtime, writes it into `ceph.conf` and the monmap, and
+every other daemon finds the monitor through that shared `ceph.conf`. Docker is
+therefore free to allocate whatever range is available, and this stack can never
+collide with an existing network.
+
+If docker hands out a different address on a later `up`, `mon.sh` notices that
+the stored monmap disagrees, rewrites it in place (preserving the fsid and map
+epoch) and carries on.
+
+The one case this does not cover is the docker daemon reassigning addresses
+underneath containers that keep running — the monitor recovers, but an OSD that
+was never restarted will still be pointed at the old address. Restart the stack.
+
+## Things to be aware of when using this docker compose
+
+**`down` without `-v` keeps the cluster.** The named volumes hold the fsid,
+keyrings, monmap, and OSD stores, and every script is idempotent, so a plain
+`down`/`up` deliberately reuses the existing cluster. A config that gets applied at
+creation time, like `osd_pool_default_size` set by `OSD_COUNT`, will not change
+until you `down -v`.
+
+**Changing `OSD_COUNT` requires `down -v`.** `osd.sh` skips provisioning when it
+finds a `ready` marker, so going 3→1 on existing volumes leaves osd.1 and osd.2
+in the osdmap with no daemons behind them — degraded forever. Under
+`ts-scripts test` that is covered: `ensureCeph()` runs `down -v` before every
+`up`.
+
+**The count is structural in the YAML.** `rgw.sh` blocks until `OSD_COUNT` OSDs
+are up, and compose can't template a service, so the service blocks have to
+exist. `ts-scripts test` generates them (see above); standalone, add matching
+`osd1`, `osd2`... blocks yourself. Each OSD provisions itself, so such a block
+is a copy of `osd0` with a different `OSD_ID` and `hostname`.
+
+**No `container_name:` keys.** Container names are globally unique in Docker, so
+hardcoding them would stop two stacks coexisting even under different project
+names. Containers are `<project>-<service>-1`, and in-network addressing uses
+the compose service name (`rgw`, `mon`).
+
+**Export `CEPH_*`, never the container-side names.** Compose's precedence is
+`environment:` > shell env (for `${VAR}` interpolation only) > `env_file`, and
+the scripts inside the containers read their values from `env_file` — so a
+shell export reaches interpolation but not the containers.
+
+Under `ts-scripts test` that is already handled: the `CEPH_*` vars go through
+`config.ts`, which writes both sides of the `.env` file, so `CEPH_PORT=9000
+ts-scripts test` publishes *and* binds 9000. Exporting the container-side name
+is what breaks — `.env` is regenerated on every run, so `RGW_PORT=9000` is
+overwritten in the file while your shell value still wins for interpolation,
+publishing one port while RGW listens on another.
+
+Standalone, there is no generator, so change the `.env` file rather than your
+shell.
+
+**Readiness is `setup` exiting, not the containers starting.** `up -d` already
+blocks on the `depends_on` chain, so it returns with the cluster healthy and RGW
+serving; the only thing still outstanding is `setup`, which creates the S3 user.
+`up --wait` doesn't cover it — `setup` has no healthcheck and nothing depends on
+it, so `--wait` only requires that it started — and `docker compose wait setup`
+errors with "no containers for project" once that container has exited. Use
+`docker compose ps -a setup` instead, which keeps listing it after it exits.
+
+## Planned Improvements
+
+TLS on the RGW endpoint. `rgw.sh` starts a plain beast frontend; beast supports
+`ssl_port=`/`ssl_certificate=`, but it needs a cert minted for the hostname
+clients actually connect on. MinIO still covers the encrypted e2e target until
+then.

package/docker/ceph/docker-compose.yml

@@ -0,0 +1,104 @@
+# Default project name for standalone `docker compose up`. ts-scripts overrides
+# it with COMPOSE_PROJECT_NAME, which takes precedence over this key.
+name: ceph
+
+# A single-node Ceph cluster (1 mon, 1 mgr, 1 OSD, 1 RGW) for local testing.
+# The OSD is a BlueStore store on a sparse file, so no loop devices, no
+# privileged containers, and nothing touching the host's disks.
+#
+# Under `ts-scripts test` the .env file used is generated from
+# packages/scripts/src/helpers/config.ts -- see ensureCeph() in
+# src/helpers/test-runner/services.ts. Edits to it are overwritten on every run.
+# Standalone: `cp .env.example .env` first.
+
+x-ceph: &ceph
+  image: ${CEPH_IMAGE:-quay.io/ceph/ceph:v19.2.6}
+  env_file: .env
+  volumes:
+    - ./scripts:/scripts:ro
+    - ceph-etc:/etc/ceph
+    - ceph-lib:/var/lib/ceph
+  networks: [ceph]
+  # Ceph daemons want a decent number of threads/fds.
+  ulimits:
+    nofile: 65536
+    nproc: 65536
+
+services:
+  # Also creates the cluster on first run: fsid, ceph.conf, keyrings, monmap.
+  mon:
+    <<: *ceph
+    hostname: ceph-mon
+    command: ["bash", "/scripts/mon.sh"]
+    healthcheck:
+      test: ["CMD", "ceph", "--connect-timeout", "5", "quorum_status"]
+      interval: 5s
+      timeout: 10s
+      retries: 30
+      start_period: 10s
+    restart: unless-stopped
+
+  mgr:
+    <<: *ceph
+    hostname: ceph-mgr
+    command: ["bash", "/scripts/mgr.sh"]
+    depends_on:
+      mon:
+        condition: service_healthy
+    restart: unless-stopped
+
+  # Provisions its own BlueStore store on first run. Under `ts-scripts test`
+  # this block is the template CEPH_OSD_COUNT > 1 clones into osd1, osd2... in
+  # the generated docker-compose.osds.yml override. Standalone, copy it by
+  # hand, bump OSD_ID, and raise OSD_COUNT in the env file.
+  osd0:
+    <<: *ceph
+    hostname: ceph-osd0
+    command: ["bash", "/scripts/osd.sh"]
+    environment:
+      OSD_ID: 0
+    depends_on:
+      mon:
+        condition: service_healthy
+    restart: unless-stopped
+
+  rgw:
+    <<: *ceph
+    hostname: ceph-rgw
+    command: ["bash", "/scripts/rgw.sh"]
+    ports:
+      # Same port inside and out, so RGW never hands back an unreachable URL.
+      - "${RGW_PORT:-8000}:${RGW_PORT:-8000}"
+    depends_on:
+      osd0: {condition: service_started}
+    healthcheck:
+      test: ["CMD-SHELL", "curl -fsS -o /dev/null http://localhost:${RGW_PORT:-8000}/"]
+      interval: 5s
+      timeout: 5s
+      retries: 40
+      start_period: 20s
+    restart: unless-stopped
+
+  setup:
+    <<: *ceph
+    command: ["bash", "/scripts/setup.sh"]
+    depends_on:
+      rgw:
+        condition: service_healthy
+    restart: "no"
+
+  # ---- opt-in: `docker compose run --rm toolbox` for a ceph/radosgw-admin shell
+  toolbox:
+    <<: *ceph
+    profiles: [tools]
+    command: ["bash"]
+    stdin_open: true
+    tty: true
+    restart: "no"
+
+volumes:
+  ceph-etc:
+  ceph-lib:
+
+networks:
+  ceph:

package/docker/ceph/scripts/common.sh

@@ -0,0 +1,78 @@
+#!/usr/bin/env bash
+# Shared helpers for the Ceph role scripts.
+
+set -euo pipefail
+
+CEPH_CONF=/etc/ceph/ceph.conf
+
+log() { echo "[$(date -u '+%H:%M:%S')] [${ROLE:-ceph}] $*" >&2; }
+
+die() { log "FATAL: $*"; exit 1; }
+
+# This container's own IPv4 address on the docker network, read at runtime.
+own_addr() {
+  local addr
+  addr=$(hostname -i | tr ' ' '\n' | grep -v ':' | head -1)
+  [ -n "$addr" ] || die "could not determine this container's IPv4 address"
+  echo "$addr"
+}
+
+# Block until the monitor has written the shared ceph.conf.
+wait_for_conf() {
+  local tries=${1:-120}
+  while [ ! -s "$CEPH_CONF" ]; do
+    tries=$((tries - 1))
+    [ "$tries" -le 0 ] && die "timed out waiting for $CEPH_CONF"
+    sleep 1
+  done
+}
+
+# Block until the monitor forms a quorum and answers.
+wait_for_mon() {
+  local tries=${1:-120}
+  log "waiting for monitor quorum ..."
+  until ceph --connect-timeout 5 quorum_status >/dev/null 2>&1; do
+    tries=$((tries - 1))
+    [ "$tries" -le 0 ] && die "timed out waiting for monitor quorum"
+    sleep 2
+  done
+  log "monitor quorum reached"
+}
+
+# Block until at least $1 OSDs report "up".
+wait_for_osds() {
+  local want=$1 tries=${2:-180} up=0
+  log "waiting for $want OSD(s) to come up ..."
+  while :; do
+    up=$(ceph osd stat -f json 2>/dev/null \
+      | python3 -c 'import sys,json; print(json.load(sys.stdin)["num_up_osds"])' 2>/dev/null || echo 0)
+    [ "$up" -ge "$want" ] && break
+    tries=$((tries - 1))
+    [ "$tries" -le 0 ] && die "timed out waiting for OSDs (only $up/$want up)"
+    sleep 2
+  done
+  log "$up OSD(s) up"
+}
+
+# Block until the cluster reports HEALTH_OK (HEALTH_WARN is tolerated after a
+# grace period -- a fresh cluster warns while PGs are still peering).
+wait_for_health() {
+  local tries=${1:-120} status=""
+  log "waiting for cluster health ..."
+  while :; do
+    status=$(ceph health 2>/dev/null | awk '{print $1}' || true)
+    [ "$status" = "HEALTH_OK" ] && break
+    tries=$((tries - 1))
+    if [ "$tries" -le 0 ]; then
+      log "cluster is $status, continuing anyway:"
+      ceph -s >&2 || true
+      return 0
+    fi
+    sleep 2
+  done
+  log "cluster is HEALTH_OK"
+}
+
+fix_perms() {
+  chown -R ceph:ceph "$@" 2>/dev/null || true
+}

package/docker/ceph/scripts/mgr.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+ROLE=mgr
+source /scripts/common.sh
+
+MGR_ID=${MGR_ID:-x}
+MGR_DATA=/var/lib/ceph/mgr/ceph-${MGR_ID}
+
+wait_for_conf
+wait_for_mon
+
+mkdir -p "$MGR_DATA"
+if [ ! -s "${MGR_DATA}/keyring" ]; then
+  log "creating keyring for mgr.${MGR_ID}"
+  ceph auth get-or-create "mgr.${MGR_ID}" \
+    mon 'allow profile mgr' osd 'allow *' mds 'allow *' \
+    -o "${MGR_DATA}/keyring"
+fi
+fix_perms "$MGR_DATA"
+
+log "starting ceph-mgr id=${MGR_ID}"
+exec ceph-mgr -f -i "$MGR_ID" --setuser ceph --setgroup ceph

package/docker/ceph/scripts/mon.sh

@@ -0,0 +1,131 @@
+#!/usr/bin/env bash
+# Creates the cluster on first run -- fsid, ceph.conf, keyrings, monmap, and the
+# monitor's data store -- and then runs the monitor.
+ROLE=mon
+source /scripts/common.sh
+
+MON_ID=${MON_ID:-mon0}
+MON_DATA=/var/lib/ceph/mon/ceph-${MON_ID}
+MON_ADDR=$(own_addr)
+
+# Replicate only as widely as there are OSDs to replicate across. With one OSD
+# and size=2 every PG sits active+undersized+degraded forever: writes still
+# succeed via min_size=1, but the cluster never reaches HEALTH_OK.
+OSD_COUNT=${OSD_COUNT:-1}
+POOL_SIZE=$(( OSD_COUNT >= 2 ? 2 : 1 ))
+
+mkdir -p /etc/ceph /var/lib/ceph/mon /var/lib/ceph/bootstrap-osd /var/lib/ceph/mgr
+
+# Keep the fsid across restarts; only mint one for a genuinely new cluster.
+FSID=$(awk '/^fsid/ {print $3}' "$CEPH_CONF" 2>/dev/null || true)
+if [ -z "$FSID" ]; then
+  FSID=$(uuidgen)
+  log "creating new cluster, fsid=${FSID}"
+else
+  log "reusing existing cluster, fsid=${FSID}"
+fi
+
+# ceph.conf is entirely generated, so rewrite it on every start rather than
+# patching it. That is what keeps mon_host correct when docker hands out a
+# different address after a `down` that kept the volumes.
+cat > "$CEPH_CONF" <<EOF
+# Generated by scripts/mon.sh -- single-node Ceph for local testing.
+# Rewritten on every monitor start. Not a production configuration.
+[global]
+fsid = ${FSID}
+mon_initial_members = ${MON_ID}
+mon_host = [v2:${MON_ADDR}:3300,v1:${MON_ADDR}:6789]
+
+# Deliberately no public_network/cluster_network: these containers have a single
+# interface, so Ceph binds to the right address on its own, and hardcoding a
+# range here would put back the pinned-subnet problem this layout removes.
+
+auth_cluster_required = cephx
+auth_service_required = cephx
+auth_client_required = cephx
+
+# One host: replicate across OSDs rather than across hosts.
+osd_crush_chooseleaf_type = 0
+osd_pool_default_size = ${POOL_SIZE}
+osd_pool_default_min_size = 1
+# Deliberately no osd_pool_default_pg_num/pgp_num here: the autoscaler starts
+# new pools at pg_num=1, and a pinned pgp_num above that makes every librados
+# pool_create (i.e. every pool RGW creates for itself) fail with ERANGE.
+
+# Cache ceiling per OSD. Only approached under sustained write load -- idle RSS
+# is well under 100 MiB. Keeps a heavy test from ballooning inside Docker's VM.
+osd_memory_target = 939524096
+
+# Log to stderr so "docker compose logs" actually shows something. The upstream
+# images default to journald, which no one is running inside these containers.
+log_to_stderr = true
+err_to_stderr = true
+log_to_file = false
+log_to_journald = false
+mon_cluster_log_to_stderr = true
+mon_cluster_log_to_file = false
+mon_cluster_log_to_journald = false
+
+# Warnings that are noise on a disposable single-node cluster.
+mon_warn_on_insecure_global_id_reclaim = false
+mon_warn_on_insecure_global_id_reclaim_allowed = false
+mon_warn_on_pool_no_redundancy = false
+auth_allow_insecure_global_id_reclaim = true
+mon_data_avail_warn = 2
+mon_data_avail_crit = 1
+
+[mon]
+mon_allow_pool_delete = true
+
+[osd]
+osd_max_pg_per_osd_hard_ratio = 10
+EOF
+
+if [ ! -f "${MON_DATA}/keyring" ]; then
+  log "bootstrapping monitor at ${MON_ADDR}"
+
+  # Monitor keyring.
+  ceph-authtool --create-keyring /tmp/ceph.mon.keyring \
+    --gen-key -n mon. --cap mon 'allow *'
+
+  # Admin keyring -- this is what the toolbox and every script authenticates as.
+  ceph-authtool --create-keyring /etc/ceph/ceph.client.admin.keyring \
+    --gen-key -n client.admin \
+    --cap mon 'allow *' --cap osd 'allow *' --cap mds 'allow *' --cap mgr 'allow *'
+
+  # OSD bootstrap keyring.
+  ceph-authtool --create-keyring /var/lib/ceph/bootstrap-osd/ceph.keyring \
+    --gen-key -n client.bootstrap-osd \
+    --cap mon 'profile bootstrap-osd' --cap mgr 'allow r'
+
+  ceph-authtool /tmp/ceph.mon.keyring --import-keyring /etc/ceph/ceph.client.admin.keyring
+  ceph-authtool /tmp/ceph.mon.keyring --import-keyring /var/lib/ceph/bootstrap-osd/ceph.keyring
+
+  monmaptool --create \
+    --addv "${MON_ID}" "[v2:${MON_ADDR}:3300,v1:${MON_ADDR}:6789]" \
+    --fsid "${FSID}" /tmp/monmap
+
+  mkdir -p "$MON_DATA"
+  ceph-mon --mkfs -i "$MON_ID" --monmap /tmp/monmap --keyring /tmp/ceph.mon.keyring
+else
+  # The store already holds a monmap naming whatever address this container had
+  # last time. Reconcile it before starting, or the monitor fails to bind.
+  # Modify the stored map rather than creating a fresh one so the fsid and the
+  # map epoch survive.
+  ceph-mon -i "$MON_ID" --extract-monmap /tmp/monmap >/dev/null 2>&1 \
+    || die "could not read the existing monmap from ${MON_DATA}"
+
+  if monmaptool --print /tmp/monmap 2>/dev/null | grep -q "v1:${MON_ADDR}:6789"; then
+    log "monmap already lists ${MON_ADDR}"
+  else
+    log "monitor address changed, rewriting monmap to ${MON_ADDR}"
+    monmaptool --rm "$MON_ID" /tmp/monmap >/dev/null
+    monmaptool --addv "${MON_ID}" "[v2:${MON_ADDR}:3300,v1:${MON_ADDR}:6789]" /tmp/monmap >/dev/null
+    ceph-mon -i "$MON_ID" --inject-monmap /tmp/monmap
+  fi
+fi
+
+fix_perms /etc/ceph /var/lib/ceph
+
+log "starting ceph-mon id=${MON_ID} at ${MON_ADDR}"
+exec ceph-mon -f -i "$MON_ID" --setuser ceph --setgroup ceph

package/docker/ceph/scripts/osd.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+# Registers this OSD with the monitor and lays down its BlueStore store on a
+# sparse file, then runs it. Idempotent: a store that is already provisioned is
+# reused as-is.
+#
+# Each OSD provisions itself rather than sharing a single osd-init container, so
+# adding a second OSD is a copy of the osd0 service block with a different
+# OSD_ID and nothing else has to change.
+ROLE=osd.${OSD_ID:-?}
+source /scripts/common.sh
+
+OSD_ID=${OSD_ID:?OSD_ID must be set}
+OSD_SIZE=${OSD_SIZE:-10G}
+OSD_DATA=/var/lib/ceph/osd/ceph-${OSD_ID}
+
+wait_for_conf
+wait_for_mon
+
+if [ ! -f "${OSD_DATA}/ready" ]; then
+  # A half-built store from an interrupted run would confuse --mkfs.
+  rm -rf "$OSD_DATA"
+  mkdir -p "$OSD_DATA"
+
+  uuid=$(uuidgen)
+  secret=$(ceph-authtool --gen-print-key)
+
+  log "registering osd.${OSD_ID} (uuid ${uuid})"
+  assigned=$(echo "{\"cephx_secret\": \"${secret}\"}" \
+    | ceph osd new "$uuid" "$OSD_ID" -i - -n client.admin)
+  [ "$assigned" = "$OSD_ID" ] || die "monitor assigned osd.${assigned}, expected osd.${OSD_ID}"
+
+  log "creating ${OSD_SIZE} sparse BlueStore device for osd.${OSD_ID}"
+  truncate -s "$OSD_SIZE" "${OSD_DATA}/block"
+
+  ceph-authtool --create-keyring "${OSD_DATA}/keyring" \
+    --name "osd.${OSD_ID}" --add-key "$secret"
+
+  fix_perms "$OSD_DATA"
+  ceph-osd -i "$OSD_ID" --mkfs --osd-uuid "$uuid" --setuser ceph --setgroup ceph
+
+  touch "${OSD_DATA}/ready"
+  log "osd.${OSD_ID} provisioned"
+fi
+
+fix_perms /etc/ceph "$OSD_DATA"
+
+log "starting ceph-osd id=${OSD_ID}"
+exec ceph-osd -f -i "$OSD_ID" --setuser ceph --setgroup ceph

package/docker/ceph/scripts/rgw.sh

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+ROLE=rgw
+source /scripts/common.sh
+
+RGW_ID=${RGW_ID:-test}
+RGW_PORT=${RGW_PORT:-8000}
+OSD_COUNT=${OSD_COUNT:-1}
+NAME="client.rgw.${RGW_ID}"
+KEYRING="/etc/ceph/ceph.${NAME}.keyring"
+
+wait_for_conf
+wait_for_mon
+# RGW creates its pools on startup, which needs OSDs to actually accept writes.
+wait_for_osds "$OSD_COUNT"
+
+if [ ! -s "$KEYRING" ]; then
+  log "creating keyring for ${NAME}"
+  ceph auth get-or-create "$NAME" \
+    mon 'allow rw' osd 'allow rwx' mgr 'allow rw' \
+    -o "$KEYRING"
+fi
+fix_perms "$KEYRING"
+
+log "starting radosgw ${NAME} on port ${RGW_PORT}"
+exec radosgw -f -n "$NAME" -k "$KEYRING" \
+  --setuser ceph --setgroup ceph \
+  --rgw-frontends="beast port=${RGW_PORT}" \
+  --rgw-run-sync-thread=false \
+  --rgw-relaxed-s3-bucket-names=true

package/docker/ceph/scripts/setup.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# Creates the S3 user.
+
+ROLE=setup
+source /scripts/common.sh
+
+S3_USER=${S3_USER:-test}
+S3_ACCESS_KEY=${S3_ACCESS_KEY:?}
+S3_SECRET_KEY=${S3_SECRET_KEY:?}
+RGW_PORT=${RGW_PORT:-8000}
+# The compose service name, not a container_name
+export S3_ENDPOINT=${S3_ENDPOINT:-http://rgw:${RGW_PORT}}
+export S3_ACCESS_KEY S3_SECRET_KEY
+
+wait_for_conf
+wait_for_mon
+
+log "waiting for the RGW endpoint at ${S3_ENDPOINT} ..."
+tries=90
+until curl -fsS -o /dev/null "${S3_ENDPOINT}"; do
+  tries=$((tries - 1))
+  [ "$tries" -le 0 ] && die "RGW never became reachable"
+  sleep 2
+done
+
+if radosgw-admin user info --uid="$S3_USER" >/dev/null 2>&1; then
+  log "S3 user '${S3_USER}' already exists"
+else
+  log "creating S3 user '${S3_USER}'"
+  radosgw-admin user create \
+    --uid="$S3_USER" \
+    --display-name="Local test user" \
+    --access-key="$S3_ACCESS_KEY" \
+    --secret-key="$S3_SECRET_KEY" >/dev/null
+fi
+
+wait_for_health 60
+
+cat >&2 <<EOF
+
+  ------------------------------------------------------------------
+  Ceph is up. S3 endpoint ready.
+
+    Endpoint (from host)  http://localhost:${RGW_PORT}
+    Endpoint (in-network) http://rgw:${RGW_PORT}
+    Region                us-east-1
+    Access key            ${S3_ACCESS_KEY}
+    Secret key            ${S3_SECRET_KEY}
+
+  Use path-style addressing; virtual-host style needs DNS wildcards.
+  ------------------------------------------------------------------
+
+EOF
+
+ceph -s >&2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@terascope/scripts",
   "displayName": "Scripts",
-  "version": "2.25.0",
+  "version": "2.26.0",
   "description": "A collection of terascope monorepo scripts",
   "homepage": "https://github.com/terascope/teraslice/tree/master/packages/scripts#readme",
   "bugs": {
@@ -45,7 +45,8 @@
     "typedoc-plugin-markdown": "~4.13.0",
     "yaml": "~2.9.0",
     "yargs": "~18.1.0",
-    "@terascope/core-utils": "~2.17.1"
+    "@terascope/core-utils": "~2.18.0",
+    "@terascope/docker-compose-js": "~2.2.0"
   },
   "devDependencies": {
     "@jest/globals": "^30.4.1",
@@ -59,7 +60,7 @@
     "@types/yargs": "~17.0.35",
     "jest-extended": "~7.0.0",
     "typescript": "~6.0.3",
-    "@terascope/types": "~2.16.0"
+    "@terascope/types": "~2.17.0"
   },
   "peerDependencies": {
     "typescript": "~6.0.3"