TOOLS-4237 Convert failpoints to a struct-based interface

Replace the plain-string failpoint identifiers and duplicated
per-build-tag function implementations with a Manager interface (a
real manager backed by a mutex-guarded map, and a noopManager used
when the failpoints build tag isn't set) plus a Failpoint struct that
carries a name, optional string value, and the signaling needed by
failpoints that pause code until externally resumed.

This follows the same shape as mongosync's mongo-go/failpoints package
(Manager interface + Failpoint struct with a resume channel), scaled
down to what mongo-tools actually needs: a single global default
manager rather than per-instance injection, since mongo-tools failpoints
are configured once via a CLI flag rather than per test-created app
context.

Only the tiny "which manager is the default" decision is build-tag
gated now (in manager.go's and noop_manager.go's own init functions);
the Failpoint type and the package-level API (ParseFailpoints, Reset,
Get, Enabled, Lookup) are unconditionally compiled, matching how
mongosync keeps its failpoints package itself untagged and gates only
the wiring layer.

Author: autarch

common/failpoint/failpoint.go

@@ -4,48 +4,111 @@
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 
-//go:build failpoints
-
 // Package failpoint implements triggers for custom debugging behavior.
 package failpoint
 
-import (
-	"strings"
-)
+import "sync"
 
-var values map[string]string
+// Failpoint represents one named failpoint's runtime state: whether it's
+// enabled, its optional string value (from a --failpoints Name=value pair),
+// and — for failpoints that need to pause code until externally resumed —
+// the signaling to coordinate that pause.
+type Failpoint struct {
+	name  Name
+	value string
 
-func init() {
-	values = make(map[string]string)
+	mu            sync.Mutex
+	reachedCh     chan struct{}
+	reachedClosed bool
+	signalCh      chan struct{}
+	signalClosed  bool
 }
 
-func Reset() {
-	values = make(map[string]string)
+func newFailpoint(name Name, value string) *Failpoint {
+	return &Failpoint{
+		name:      name,
+		value:     value,
+		reachedCh: make(chan struct{}),
+		signalCh:  make(chan struct{}),
+	}
+}
+
+func (fp *Failpoint) Name() Name    { return fp.name }
+func (fp *Failpoint) Value() string { return fp.value }
+
+// Wait signals that the caller has reached this pause point (so a concurrent
+// call to Reached returns) and then blocks until Signal is called.
+func (fp *Failpoint) Wait() {
+	fp.mu.Lock()
+	if !fp.reachedClosed {
+		close(fp.reachedCh)
+		fp.reachedClosed = true
+	}
+	fp.mu.Unlock()
+
+	<-fp.signalCh
+}
+
+// Reached blocks until Wait has been called.
+func (fp *Failpoint) Reached() {
+	<-fp.reachedCh
 }
 
+// Signal releases a call blocked in Wait. Safe to call more than once.
+func (fp *Failpoint) Signal() {
+	fp.mu.Lock()
+	defer fp.mu.Unlock()
+	if !fp.signalClosed {
+		close(fp.signalCh)
+		fp.signalClosed = true
+	}
+}
+
+// Manager tracks which failpoints are currently enabled.
+type Manager interface {
+	// Parse enables a comma-separated list of failpoint=value pairs, as
+	// passed to --failpoints.
+	Parse(arg string)
+	// Reset disables every failpoint.
+	Reset()
+	// Get returns the Failpoint registered under name, and true, if it is
+	// currently enabled.
+	Get(name Name) (*Failpoint, bool)
+}
+
+// defaultManager is set by manager.go's or noop_manager.go's init function,
+// depending on whether this binary was built with the failpoints build tag.
+var defaultManager Manager
+
 // ParseFailpoints registers a comma-separated list of failpoint=value pairs.
 func ParseFailpoints(arg string) {
-	args := strings.Split(arg, ",")
-	for _, fp := range args {
-		if sep := strings.Index(fp, "="); sep != -1 {
-			key := fp[:sep]
-			val := fp[sep+1:]
-			values[key] = val
-			continue
-		}
-		values[fp] = ""
-	}
+	defaultManager.Parse(arg)
+}
+
+// Reset disables every failpoint.
+func Reset() {
+	defaultManager.Reset()
 }
 
 // Get returns the value of the given failpoint and true, if it exists, and
 // false otherwise.
-func Get(fp string) (string, bool) {
-	val, ok := values[fp]
-	return val, ok
+func Get(name Name) (string, bool) {
+	fp, ok := defaultManager.Get(name)
+	if !ok {
+		return "", false
+	}
+	return fp.Value(), true
 }
 
 // Enabled returns true iff the given failpoint has been turned on.
-func Enabled(fp string) bool {
-	_, ok := Get(fp)
+func Enabled(name Name) bool {
+	_, ok := defaultManager.Get(name)
 	return ok
 }
+
+// Lookup returns the Failpoint registered under name, and true, if it has
+// been enabled. Callers that need to pause until externally resumed (see
+// Failpoint.Wait) use this instead of Enabled.
+func Lookup(name Name) (*Failpoint, bool) {
+	return defaultManager.Get(name)
+}

common/failpoint/failpoint_disabled.go

@@ -6,8 +6,13 @@
 
 package failpoint
 
-// Supported failpoint names.
+// Name identifies a failpoint that can be turned on via --failpoints.
+type Name string
+
+func (n Name) String() string { return string(n) }
+
+// Supported failpoints.
 const (
-	PauseBeforeDumping = "PauseBeforeDumping"
-	SlowBSONDump       = "SlowBSONDump"
+	PauseBeforeDumping = Name("PauseBeforeDumping")
+	SlowBSONDump       = Name("SlowBSONDump")
 )

common/failpoint/failpoints.go

@@ -0,0 +1,52 @@
+// Copyright (C) MongoDB, Inc. 2014-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+//go:build failpoints
+
+package failpoint
+
+import (
+	"strings"
+	"sync"
+)
+
+// manager is the real Manager implementation, used when this binary is
+// built with the failpoints build tag.
+type manager struct {
+	mu  sync.Mutex
+	fps map[Name]*Failpoint
+}
+
+func newManager() *manager {
+	return &manager{fps: make(map[Name]*Failpoint)}
+}
+
+func (m *manager) Parse(arg string) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	for part := range strings.SplitSeq(arg, ",") {
+		name, value, _ := strings.Cut(part, "=")
+		m.fps[Name(name)] = newFailpoint(Name(name), value)
+	}
+}
+
+func (m *manager) Reset() {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	m.fps = make(map[Name]*Failpoint)
+}
+
+func (m *manager) Get(name Name) (*Failpoint, bool) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+	fp, ok := m.fps[name]
+	return fp, ok
+}
+
+func init() {
+	defaultManager = newManager()
+}

common/failpoint/manager.go

@@ -0,0 +1,29 @@
+// Copyright (C) MongoDB, Inc. 2014-present.
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License. You may obtain
+// a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+//go:build !failpoints
+
+package failpoint
+
+// noopManager is the Manager implementation used when this binary is built
+// without the failpoints build tag: every failpoint is always disabled.
+type noopManager struct{}
+
+func newNoopManager() *noopManager {
+	return &noopManager{}
+}
+
+func (*noopManager) Parse(string) {}
+
+func (*noopManager) Reset() {}
+
+func (*noopManager) Get(Name) (*Failpoint, bool) {
+	return nil, false
+}
+
+func init() {
+	defaultManager = newNoopManager()
+}

common/failpoint/noop_manager.go

@@ -172,7 +172,7 @@ func TestOplogDumpCollModIndexUniqueness(t *testing.T) {
 	require.NoError(t, md.Init())
 
 	// Enable a failpoint so that the test can create oplogs during dump.
-	failpoint.ParseFailpoints(failpoint.PauseBeforeDumping)
+	failpoint.ParseFailpoints(failpoint.PauseBeforeDumping.String())
 	defer failpoint.Reset()
 
 	go func() {
@@ -330,7 +330,7 @@ func TestOplogDumpBypassDocumentValidation(t *testing.T) {
 	require.NoError(t, md.Init())
 
 	// Enable a failpoint so that the test can create oplogs during dump.
-	failpoint.ParseFailpoints(failpoint.PauseBeforeDumping)
+	failpoint.ParseFailpoints(failpoint.PauseBeforeDumping.String())
 	defer failpoint.Reset()
 
 	go func() {
@@ -480,7 +480,7 @@ func TestOplogDumpCollModTTL(t *testing.T) {
 	require.NoError(t, md.Init())
 
 	// Enable a failpoint so that the test can create oplogs during dump.
-	failpoint.ParseFailpoints(failpoint.PauseBeforeDumping)
+	failpoint.ParseFailpoints(failpoint.PauseBeforeDumping.String())
 	defer failpoint.Reset()
 
 	go func() {