@mark1russell7/harness 0.4.1 → 0.6.0

package/image/go-http/Dockerfile

@@ -0,0 +1,14 @@
+# The Go HTTP client of the harness: the http.Transport of Go 1.27.2 at its defaults, with the
+# settings of a cell over them. It runs as a container in the client's network namespace, as the
+# harness's own TCP client does, and prints the same JSON lines. The program uses the standard
+# library only, thus the digest of the builder pins all of its code.
+# lab.ts stages the build context: this folder, under harness/image/go-http.
+FROM golang:1.27.2-alpine@sha256:f92b6ef800e499660581efdabdf25d9d817a9d124eaf900924f0504e7e27e12d AS build
+WORKDIR /src
+COPY harness/image/go-http/go.mod harness/image/go-http/main.go ./
+# the format and the vet of the source come first, as the cargo test of the harness image does
+RUN test -z "$(gofmt -l .)" || { gofmt -d .; exit 1; }
+RUN CGO_ENABLED=0 go vet ./... && CGO_ENABLED=0 go build -trimpath -o /client-go .
+
+FROM alpine:3.22@sha256:5291449c3df73caf6ed85e649dec1b9e818b39a5d8c871e97afc13e9cd5e8fa8
+COPY --from=build /client-go /opt/harness/client-go

package/image/go-http/go.mod

@@ -0,0 +1,3 @@
+module client-go
+
+go 1.27

package/image/go-http/main.go

@@ -0,0 +1,324 @@
+// Command client-go is the Go client of the HTTP cells: the http.Transport of Go 1.27.2 at its
+// defaults, with each setting that a cell gives over them. Each event is a JSON line with `ev` and
+// `t`, the CLOCK_MONOTONIC time in nanoseconds, as the TCP client of the harness writes them.
+//
+//	client-go HOST PORT --mode idle|inflight|gap [--gap-ms N] [--method GET|POST] [--hold-ms N]
+//	          [--bytes N] [--go PATH] [--max-s N] [--linger-ms N]
+//	          [--idle-conn-timeout-ms N] [--max-idle-per-host N] [--dial-timeout-ms N]
+//	          [--keepalive-ms N] [--keepalive-interval-ms N] [--keepalive-count N] [--timeout-ms N]
+//
+// The first request is GET /, and the end of its reply is the ready line. Then the client holds
+// the connection idle (idle), sends the second request when the file --go appears (inflight), or
+// sends it after the gap (gap).
+//
+// A wrapper on each connection writes what the read loop of the transport reads: an end of file,
+// or an error. The trace of the transport writes which connection each request goes on, whether
+// the transport reused it, and each new try of a request on a new connection.
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/http/httptrace"
+	"os"
+	"runtime"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+var out sync.Mutex
+
+// now gives the time on CLOCK_MONOTONIC in nanoseconds: the clock of the prober.
+func now() int64 {
+	var ts syscall.Timespec
+	syscall.Syscall(syscall.SYS_CLOCK_GETTIME, 1, uintptr(unsafe.Pointer(&ts)), 0)
+	return ts.Nano()
+}
+
+// emitAt writes one line with the time t.
+func emitAt(ev string, t int64, fields map[string]any) {
+	line := map[string]any{"ev": ev, "t": t}
+	for key, value := range fields {
+		line[key] = value
+	}
+	bytes, _ := json.Marshal(line)
+	out.Lock()
+	os.Stdout.Write(append(bytes, '\n'))
+	out.Unlock()
+}
+
+// emit writes one line with the time now.
+func emit(ev string, fields map[string]any) { emitAt(ev, now(), fields) }
+
+var names = map[syscall.Errno]string{
+	syscall.ECONNRESET:   "ECONNRESET",
+	syscall.ECONNREFUSED: "ECONNREFUSED",
+	syscall.ETIMEDOUT:    "ETIMEDOUT",
+	syscall.EHOSTUNREACH: "EHOSTUNREACH",
+	syscall.ENETUNREACH:  "ENETUNREACH",
+	syscall.EPIPE:        "EPIPE",
+	syscall.ECONNABORTED: "ECONNABORTED",
+}
+
+// errnoOf gives the name of the error of a socket, EOF for an end of file, or TIMEOUT for a
+// deadline of Go.
+func errnoOf(err error) string {
+	var errno syscall.Errno
+	if errors.As(err, &errno) {
+		if name, ok := names[errno]; ok {
+			return name
+		}
+		return fmt.Sprintf("E%d", int(errno))
+	}
+	if errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) {
+		return "EOF"
+	}
+	var timeout interface{ Timeout() bool }
+	if errors.As(err, &timeout) && timeout.Timeout() {
+		return "TIMEOUT"
+	}
+	return "ERROR"
+}
+
+// traced is a connection that writes what its reads end with, and its close.
+type traced struct {
+	net.Conn
+	local  string
+	mu     sync.Mutex
+	closed bool
+}
+
+func (c *traced) Read(p []byte) (int, error) {
+	n, err := c.Conn.Read(p)
+	if err != nil {
+		c.mu.Lock()
+		closed := c.closed
+		c.mu.Unlock()
+		// a read after the close of the client itself is not an event of the peer
+		if !closed {
+			if errors.Is(err, io.EOF) {
+				emit("eof", map[string]any{"local": c.local})
+			} else {
+				emit("conn-error", map[string]any{"local": c.local, "errno": errnoOf(err), "message": err.Error()})
+			}
+		}
+	}
+	return n, err
+}
+
+func (c *traced) Close() error {
+	c.mu.Lock()
+	first := !c.closed
+	c.closed = true
+	c.mu.Unlock()
+	if first {
+		emit("closed", map[string]any{"local": c.local})
+	}
+	return c.Conn.Close()
+}
+
+// dial gives the DialContext of the transport: the dialer, and a wrapper on each connection.
+func dial(d *net.Dialer) func(ctx context.Context, network, addr string) (net.Conn, error) {
+	var mu sync.Mutex
+	count := 0
+	return func(ctx context.Context, network, addr string) (net.Conn, error) {
+		start := now()
+		conn, err := d.DialContext(ctx, network, addr)
+		if err != nil {
+			emit("dial-error", map[string]any{"errno": errnoOf(err), "message": err.Error(), "ns": now() - start})
+			return nil, err
+		}
+		mu.Lock()
+		count++
+		n := count
+		mu.Unlock()
+		local := conn.LocalAddr().String()
+		emit("conn", map[string]any{"n": n, "local": local})
+		if n == 1 {
+			emit("connected", map[string]any{"local": local})
+		}
+		return &traced{Conn: conn, local: local}, nil
+	}
+}
+
+// request sends request i and waits for its outcome. It tells whether a reply came.
+func request(client *http.Client, base string, i int, method, path string) bool {
+	attempts := 0
+	trace := &httptrace.ClientTrace{
+		GotConn: func(info httptrace.GotConnInfo) {
+			attempts++
+			ev := "request"
+			if attempts > 1 {
+				ev = "retry"
+			}
+			emit(ev, map[string]any{
+				"i":       i,
+				"local":   info.Conn.LocalAddr().String(),
+				"reused":  info.Reused,
+				"idle_ns": info.IdleTime.Nanoseconds(),
+			})
+		},
+		WroteRequest: func(info httptrace.WroteRequestInfo) {
+			fields := map[string]any{"i": i}
+			if info.Err != nil {
+				fields["errno"] = errnoOf(info.Err)
+			}
+			emit("wrote", fields)
+		},
+		GotFirstResponseByte: func() { emit("first-byte", map[string]any{"i": i}) },
+	}
+	var body io.Reader
+	if method == "POST" {
+		body = strings.NewReader("x")
+	}
+	req, err := http.NewRequestWithContext(httptrace.WithClientTrace(context.Background(), trace), method, base+path, body)
+	if err != nil {
+		emit("fail", map[string]any{"why": err.Error()})
+		os.Exit(1)
+	}
+	// the stamp comes before the call: the transport writes the request after it
+	at := now()
+	emitAt("sent", at, map[string]any{"i": i})
+	resp, err := client.Do(req)
+	if err != nil {
+		emit("error", map[string]any{"i": i, "errno": errnoOf(err), "message": err.Error()})
+		return false
+	}
+	emit("response", map[string]any{"i": i, "status": resp.StatusCode})
+	n, err := io.Copy(io.Discard, resp.Body)
+	resp.Body.Close()
+	if err != nil {
+		emit("error", map[string]any{"i": i, "errno": errnoOf(err), "message": err.Error()})
+		return false
+	}
+	if i == 1 {
+		emit("ready", map[string]any{"reply": resp.Status})
+	} else {
+		emit("data", map[string]any{"i": i, "n": n})
+		emit("replied", map[string]any{"i": i, "n": map[string]any{"value": n, "unit": "B"}})
+	}
+	return true
+}
+
+func milliseconds(ms float64) time.Duration { return time.Duration(ms * float64(time.Millisecond)) }
+
+func main() {
+	usage := "client-go HOST PORT --mode idle|inflight|gap"
+	if len(os.Args) < 3 {
+		emit("fail", map[string]any{"why": usage})
+		os.Exit(1)
+	}
+	host, port := os.Args[1], os.Args[2]
+	flags := flag.NewFlagSet("client-go", flag.ExitOnError)
+	mode := flags.String("mode", "", "idle, inflight or gap")
+	gapMs := flags.Float64("gap-ms", 0, "the gap after the first reply, in gap mode")
+	method := flags.String("method", "GET", "the method of the second request")
+	holdMs := flags.Int("hold-ms", 0, "the second request asks the server to hold its reply")
+	size := flags.Int("bytes", 0, "the second request asks for a body of this length")
+	goPath := flags.String("go", "/tmp/go", "the file that starts the second request, in inflight mode")
+	maxS := flags.Float64("max-s", 60, "the deadline of the client")
+	lingerMs := flags.Float64("linger-ms", 500, "the wait after the second request, before the exit")
+	idleMs := flags.Float64("idle-conn-timeout-ms", 0, "Transport.IdleConnTimeout")
+	maxIdle := flags.Int("max-idle-per-host", 0, "Transport.MaxIdleConnsPerHost")
+	dialMs := flags.Float64("dial-timeout-ms", 0, "Dialer.Timeout")
+	keepAliveMs := flags.Float64("keepalive-ms", 0, "Dialer.KeepAlive, negative for off")
+	intervalMs := flags.Float64("keepalive-interval-ms", 0, "KeepAliveConfig.Interval")
+	probes := flags.Int("keepalive-count", 0, "KeepAliveConfig.Count")
+	timeoutMs := flags.Float64("timeout-ms", 0, "Client.Timeout")
+	flags.Parse(os.Args[3:])
+	given := map[string]bool{}
+	flags.Visit(func(f *flag.Flag) { given[f.Name] = true })
+	if *mode != "idle" && *mode != "inflight" && *mode != "gap" {
+		emit("fail", map[string]any{"why": usage})
+		os.Exit(1)
+	}
+
+	// the dialer of http.DefaultTransport (src/net/http/transport.go:47-53), with the settings of the cell
+	dialer := &net.Dialer{Timeout: 30 * time.Second, KeepAlive: 30 * time.Second}
+	if given["dial-timeout-ms"] {
+		dialer.Timeout = milliseconds(*dialMs)
+	}
+	if given["keepalive-ms"] {
+		dialer.KeepAlive = milliseconds(*keepAliveMs)
+	}
+	if given["keepalive-interval-ms"] || given["keepalive-count"] {
+		dialer.KeepAliveConfig = net.KeepAliveConfig{
+			Enable:   dialer.KeepAlive >= 0,
+			Idle:     dialer.KeepAlive,
+			Interval: milliseconds(*intervalMs),
+			Count:    *probes,
+		}
+	}
+	transport := http.DefaultTransport.(*http.Transport).Clone()
+	transport.DialContext = dial(dialer)
+	if given["idle-conn-timeout-ms"] {
+		transport.IdleConnTimeout = milliseconds(*idleMs)
+	}
+	if given["max-idle-per-host"] {
+		transport.MaxIdleConnsPerHost = *maxIdle
+	}
+	client := &http.Client{Transport: transport}
+	if given["timeout-ms"] {
+		client.Timeout = milliseconds(*timeoutMs)
+	}
+
+	bootID, _ := os.ReadFile("/proc/sys/kernel/random/boot_id")
+	settings := map[string]any{}
+	settings["IdleConnTimeout_ms"] = transport.IdleConnTimeout.Milliseconds()
+	settings["MaxIdleConnsPerHost"] = transport.MaxIdleConnsPerHost
+	settings["DialTimeout_ms"] = dialer.Timeout.Milliseconds()
+	settings["KeepAlive_ms"] = dialer.KeepAlive.Milliseconds()
+	settings["KeepAliveInterval_ms"] = dialer.KeepAliveConfig.Interval.Milliseconds()
+	settings["KeepAliveCount"] = dialer.KeepAliveConfig.Count
+	settings["ClientTimeout_ms"] = client.Timeout.Milliseconds()
+	start := map[string]any{}
+	start["boot_id"] = strings.TrimSpace(string(bootID))
+	start["mode"] = *mode
+	start["client"] = "go-nethttp"
+	start["go"] = runtime.Version()
+	start["settings"] = settings
+	emit("start", start)
+	go func() {
+		time.Sleep(time.Duration(*maxS * float64(time.Second)))
+		emit("deadline", nil)
+		os.Exit(0)
+	}()
+
+	base := "http://" + net.JoinHostPort(host, port)
+	second := "/"
+	if *holdMs > 0 {
+		second = fmt.Sprintf("/hold?ms=%d", *holdMs)
+	} else if *size > 0 {
+		second = fmt.Sprintf("/big?bytes=%d", *size)
+	}
+	if !request(client, base, 1, "GET", "/") {
+		os.Exit(1)
+	}
+	switch *mode {
+	case "idle":
+		// the connection stays in the pool until it ends, or until the deadline
+		select {}
+	case "inflight":
+		for {
+			if _, err := os.Stat(*goPath); err == nil {
+				break
+			}
+			time.Sleep(2 * time.Millisecond)
+		}
+	case "gap":
+		time.Sleep(milliseconds(*gapMs))
+	}
+	request(client, base, 2, *method, second)
+	emit("done", map[string]any{"i": 2})
+	time.Sleep(milliseconds(*lingerMs))
+	os.Exit(0)
+}

package/image/native/src/bin/inject.rs

@@ -27,6 +27,17 @@
 //!   toxic of Toxiproxy. The stamps bracket the request and its answer, after the connect, so the
 //!   commit of the toxic is known on the same clock as the kernel's records.
 //!
+//! - `signal NAME SIGNAL`: SIGNAL (KILL, STOP, CONT or TERM) to each process whose name is NAME,
+//!   in the process namespace this sidecar shares with a member of a group. STOP and CONT freeze
+//!   a server and thaw it while its kernel stays up; KILL stops it, and its kernel closes its
+//!   sockets. The stamps bracket the kill(2) calls.
+//! - `resp ADDR:PORT ARG...`: one command to a Redis-protocol server, for example
+//!   `SENTINEL FAILOVER mymaster` to a Sentinel. The stamps bracket the write of the command and
+//!   the first line of its reply, so a planned failover starts at a known instant.
+//!
+//! A filter rule's PEER can be a list, `A,B,C`: the rules for each peer go in the same commit, so
+//! a part of a group loses all of its peers at one instant.
+//!
 //! `--at NS` holds the commit until that instant on CLOCK_MONOTONIC, the clock every stamp is on.
 //! A stall's end is timed that way, from inside the VM: the exec only has to arrive before it, and
 //! its 190 ms never reach the stall's length.
@@ -234,12 +245,139 @@ fn http(args: &[String]) -> Result<(), Box<dyn Error>> {
     Ok(())
 }
 
+/// the number of a signal that `signal` sends, by its name
+fn signal_number(name: &str) -> Result<libc::c_int, Box<dyn Error>> {
+    Ok(match name {
+        "KILL" => libc::SIGKILL,
+        "STOP" => libc::SIGSTOP,
+        "CONT" => libc::SIGCONT,
+        "TERM" => libc::SIGTERM,
+        other => return Err(format!("not a signal this injector sends: {other}").into()),
+    })
+}
+
+/// a process name: letters, digits, dots, dashes and underscores, as /proc/PID/comm holds it
+fn process_name(name: &str) -> Result<&str, Box<dyn Error>> {
+    if !name.is_empty()
+        && name.len() <= 15
+        && name.chars().all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_'))
+    {
+        Ok(name)
+    } else {
+        Err(format!("not a process name: {name}").into())
+    }
+}
+
+/// tells if a line of /proc/PID/stat is a zombie's: its state, after the name in parentheses, is Z
+fn zombie(stat: &str) -> bool {
+    stat.rfind(')').and_then(|end| stat[end + 1..].split_whitespace().next()) == Some("Z")
+}
+
+/// the processes of this process namespace whose name is `name`
+fn processes(name: &str) -> Result<Vec<libc::pid_t>, Box<dyn Error>> {
+    let mut found = Vec::new();
+    for entry in std::fs::read_dir("/proc")? {
+        let entry = entry?;
+        let Some(pid) = entry.file_name().to_str().and_then(|text| text.parse::<libc::pid_t>().ok()) else {
+            continue;
+        };
+        // a process can end between the listing and the read. A zombie keeps its name until its
+        // parent reaps it: a server that a fin killed is one, and no signal reaches it
+        let Ok(comm) = std::fs::read_to_string(entry.path().join("comm")) else { continue };
+        let Ok(stat) = std::fs::read_to_string(entry.path().join("stat")) else { continue };
+        if comm.trim_end() == name && !zombie(&stat) {
+            found.push(pid);
+        }
+    }
+    found.sort_unstable();
+    Ok(found)
+}
+
+/// `signal NAME SIGNAL [--at NS]`: the signal to each process of that name, bracketed by stamps
+fn signal(args: &[String]) -> Result<(), Box<dyn Error>> {
+    let name = process_name(args.get(1).ok_or("signal NAME SIGNAL [--at NS]")?)?;
+    let sig = signal_number(args.get(2).ok_or("and the signal: KILL, STOP, CONT or TERM")?)?;
+    let opts = options(&args[3..])?;
+    let pids = processes(name)?;
+    if pids.is_empty() {
+        return Err(format!("no process {name} in this process namespace").into());
+    }
+    if let Some(at) = opts.at {
+        until(at)?;
+    }
+    let t0 = monotonic_ns();
+    for pid in &pids {
+        // SAFETY: kill(2) with a pid that this namespace listed, and a signal from the table above
+        if unsafe { libc::kill(*pid, sig) } != 0 {
+            return Err(format!("kill {pid} failed: {}", std::io::Error::last_os_error()).into());
+        }
+    }
+    let t1 = monotonic_ns();
+    println!("{}", json!({ "action": "signal", "name": name, "signal": args[2], "pids": pids, "t0": t0, "t1": t1 }));
+    Ok(())
+}
+
+/// a command in the Redis protocol: an array of bulk strings
+fn resp_command(args: &[String]) -> Vec<u8> {
+    let mut out = format!("*{}\r\n", args.len()).into_bytes();
+    for arg in args {
+        out.extend_from_slice(format!("${}\r\n", arg.len()).as_bytes());
+        out.extend_from_slice(arg.as_bytes());
+        out.extend_from_slice(b"\r\n");
+    }
+    out
+}
+
+/// `resp ADDR:PORT ARG...`: one command, and the first line of its reply, bracketed by stamps
+fn resp(args: &[String]) -> Result<(), Box<dyn Error>> {
+    use std::io::Read;
+    use std::net::{SocketAddrV4, TcpStream};
+    let addr: SocketAddrV4 = args.get(1).ok_or("resp ADDR:PORT ARG...")?.parse()?;
+    let command = &args[2..];
+    if command.is_empty() {
+        return Err("and the command".into());
+    }
+    let mut stream = TcpStream::connect(addr)?;
+    let t0 = monotonic_ns();
+    stream.write_all(&resp_command(command))?;
+    let mut line = Vec::new();
+    let mut byte = [0u8; 1];
+    while !line.ends_with(b"\r\n") {
+        if stream.read(&mut byte)? == 0 {
+            return Err("the server closed before its reply".into());
+        }
+        line.push(byte[0]);
+    }
+    let t1 = monotonic_ns();
+    let reply = String::from_utf8_lossy(&line[..line.len() - 2]).to_string();
+    if reply.starts_with('-') {
+        return Err(format!("{} answered {reply}", command.join(" ")).into());
+    }
+    println!("{}", json!({ "action": "resp", "command": command, "reply": reply, "t0": t0, "t1": t1 }));
+    Ok(())
+}
+
+/// the peers of a filter rule: one address, or a list `A,B,C`
+fn peers(text: &str) -> Result<Vec<Ipv4Addr>, Box<dyn Error>> {
+    let list: Vec<Ipv4Addr> = text.split(',').map(str::parse).collect::<Result<_, _>>()?;
+    if list.is_empty() {
+        return Err("no peer".into());
+    }
+    Ok(list)
+}
+
 fn run() -> Result<(), Box<dyn Error>> {
     let args: Vec<String> = std::env::args().skip(1).collect();
     let action = args.first().ok_or("say an action: blackhole, clear, rst, reject, mtu, netem, offload, http …")?.as_str();
     if action == "http" {
         return http(&args);
     }
+    if action == "signal" {
+        return signal(&args);
+    }
+    if action == "resp" {
+        return resp(&args);
+    }
     match action {
         "netem" | "clear-netem" | "offload" => {
             let dev = device(args.get(1).ok_or("and a device")?)?;
@@ -279,10 +417,14 @@ fn run() -> Result<(), Box<dyn Error>> {
             Ok(())
         }
         _ => {
-            // parsed, never pasted: only an address reaches the rules
-            let peer: Ipv4Addr = args.get(1).ok_or("and the peer's address")?.parse()?;
+            // parsed, never pasted: only addresses reach the rules
+            let list = peers(args.get(1).ok_or("and the peer's address")?)?;
             let opts = options(&args[2..])?;
-            let script = format!("*filter\n{}COMMIT\n", rules(action, peer, &opts)?);
+            let mut body = String::new();
+            for peer in &list {
+                body.push_str(&rules(action, *peer, &opts)?);
+            }
+            let script = format!("*filter\n{body}COMMIT\n");
             if let Some(at) = opts.at {
                 until(at)?;
             }
@@ -295,7 +437,8 @@ fn run() -> Result<(), Box<dyn Error>> {
             if !status.success() {
                 return Err(format!("iptables-restore exited {status}").into());
             }
-            println!("{}", json!({ "action": action, "peer": peer.to_string(), "t0": t0, "t1": t1 }));
+            let named: Vec<String> = list.iter().map(ToString::to_string).collect();
+            println!("{}", json!({ "action": action, "peer": named.join(","), "t0": t0, "t1": t1 }));
             Ok(())
         }
     }
@@ -365,6 +508,41 @@ mod tests {
         assert_eq!(options(&["--via".into(), "eth1".into()]).unwrap().via.as_deref(), Some("eth1"));
     }
 
+    #[test]
+    fn a_list_of_peers_is_addresses_only() {
+        assert_eq!(peers("10.0.0.2").unwrap().len(), 1);
+        assert_eq!(peers("10.0.0.2,10.0.0.3,10.0.0.4").unwrap()[2].to_string(), "10.0.0.4");
+        for text in ["", "10.0.0.2,", "10.0.0.2;x", "a,b", "10.0.0.2 10.0.0.3"] {
+            assert!(peers(text).is_err(), "{text}");
+        }
+    }
+
+    #[test]
+    fn signals_and_process_names_come_from_a_short_list() {
+        assert_eq!(signal_number("STOP").unwrap(), libc::SIGSTOP);
+        assert_eq!(signal_number("CONT").unwrap(), libc::SIGCONT);
+        assert_eq!(signal_number("KILL").unwrap(), libc::SIGKILL);
+        assert!(signal_number("HUP").is_err());
+        assert!(process_name("valkey-server").is_ok());
+        assert!(process_name("valkey-sentinel").is_ok());
+        for name in ["", "a b", "x;y", "much-too-long-a-name"] {
+            assert!(process_name(name).is_err(), "{name}");
+        }
+        // the state is the field after the name, whose parentheses can hold spaces
+        assert!(zombie("812 (valkey-server) Z 1 812 812 0 -1"));
+        assert!(!zombie("813 (valkey-server) S 1 813 813 0 -1"));
+        assert!(!zombie("814 (a) Z) S 1"));
+    }
+
+    #[test]
+    fn a_resp_command_is_an_array_of_bulk_strings() {
+        let args: Vec<String> = ["SENTINEL", "FAILOVER", "mymaster"].iter().map(|a| a.to_string()).collect();
+        assert_eq!(
+            resp_command(&args),
+            b"*3\r\n$8\r\nSENTINEL\r\n$8\r\nFAILOVER\r\n$8\r\nmymaster\r\n".to_vec()
+        );
+    }
+
     #[test]
     fn http_requests_take_only_a_method_a_path_and_a_length() {
         assert!(http_path("/proxies/redis/toxics").is_ok());

package/image/node/Dockerfile

@@ -1,6 +1,7 @@
 # The harness's Node client: ioredis 6.0.0 on Node 24.21.0, the releases the corpus's claims about
 # ioredis and Node's keepalive name. It runs as a container in the client's
-# network namespace, as the harness's own TCP client does, and prints the same JSON lines.
+# network namespace, as the harness's own TCP client does, and prints the same JSON lines. The same
+# image holds a group's client in Sentinel mode and the observer of its Sentinels.
 # lab.ts stages the build context: this folder, under harness/image/node. The lockfile is
 # npm-lock.json here, because npm leaves each package-lock.json out of a published tarball.
 FROM node:24.21.0-alpine@sha256:ebfe2f90462722a7a4de65e91990e97fe0d401c70e0e762c5b53302f905ec1c1
@@ -8,4 +9,4 @@ WORKDIR /opt/harness/node
 COPY harness/image/node/package.json ./
 COPY harness/image/node/npm-lock.json ./package-lock.json
 RUN npm ci --omit=dev --ignore-scripts --no-audit --no-fund
-COPY harness/image/node/client-ioredis.mjs ./
+COPY harness/image/node/client-ioredis.mjs harness/image/node/client-sentinel.mjs harness/image/node/observer.mjs ./