Sep 19, 2025 · Sep 22, 2025 · Sep 24, 2025
diff --git a/scaletest/harness/barrier.go b/scaletest/harness/barrier.go
 package harness

 import (
 "sync/atomic"
 )

 type Barrier struct {
 count atomic.Int64
 done  chan struct{}
 }

 // NewBarrier creates a new barrier that will block until `size` calls to Wait
 // or `Cancel` have been made. It's the caller's responsibility to ensure this
 // eventually happens.
 func NewBarrier(size int) *Barrier {
 b := &Barrier{
 done: make(chan struct{}),
 }
 b.count.Store(int64(size))
 return b
 }

 // Wait blocks until the barrier count reaches zero.
 func (b *Barrier) Wait() {
 b.Cancel()
 <-b.done
 }

 // Cancel decrements the barrier count, unblocking other Wait calls if it
 // reaches zero.
 func (b *Barrier) Cancel() {
 if b.count.Add(-1) == 0 {
 close(b.done)
 }
 }
diff --git a/scaletest/harness/barrier_test.go b/scaletest/harness/barrier_test.go
 package harness_test

 import (
 "sync"
 "testing"

 "github.com/coder/coder/v2/scaletest/harness"
 "github.com/coder/coder/v2/testutil"
 )

 func TestBarrier_MultipleRunners(t *testing.T) {
 t.Parallel()
 const numRunners = 3

 ctx := testutil.Context(t, testutil.WaitShort)
 barrier := harness.NewBarrier(numRunners)

 var wg sync.WaitGroup
 wg.Add(numRunners)

 done := make(chan struct{})

 for range numRunners {
 go func() {
 defer wg.Done()
 barrier.Wait()
 }()
 }

 go func() {
 wg.Wait()
 close(done)
 }()

 select {
 case <-done:
 return
 case <-ctx.Done():
 t.Fatal("barrier should have released all runners")
 }
 }

 func TestBarrier_Cancel(t *testing.T) {
 t.Parallel()
 const numRunners = 3

 ctx := testutil.Context(t, testutil.WaitShort)
 barrier := harness.NewBarrier(numRunners)

 var wg sync.WaitGroup
 wg.Add(numRunners - 1)

 done := make(chan struct{})

 for range numRunners - 1 {
 go func() {
 defer wg.Done()
 barrier.Wait()
 }()
 }

 barrier.Cancel()

 go func() {
 wg.Wait()
 close(done)
 }()

 select {
 case <-done:
 return
 case <-ctx.Done():
 t.Fatal("barrier should have released after cancel")
 }
 }
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,35 @@
		package harness

		import (
		"sync/atomic"
		)

		type Barrier struct {
		count atomic.Int64
		done chan struct{}
		}

		// NewBarrier creates a new barrier that will block until `size` calls to Wait
		// or `Cancel` have been made. It's the caller's responsibility to ensure this
		// eventually happens.
		func NewBarrier(size int) *Barrier {
		b := &Barrier{
		done: make(chan struct{}),
		}
		b.count.Store(int64(size))
		return b
		}

		// Wait blocks until the barrier count reaches zero.
		func (b *Barrier) Wait() {
		b.Cancel()
		<-b.done
Copy link MemberAuthor ethanndicksonSep 22, 2025• edited Loading Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. I contemplated having API consumers pass a ctx into`Wait`, and then selecting on that to support individual`Wait` timeouts. I opted against this on the basis that: I already needed to add the`Cancel` function, to handle user creation failure. Other goroutines can just call that`Cancel` function in a defer, such as when their own timeouts fire. The outcome being that this line won't block forever if the API is used properly.
		}

		// Cancel decrements the barrier count, unblocking other Wait calls if it
		// reaches zero.
		func (b *Barrier) Cancel() {
		if b.count.Add(-1) == 0 {
		close(b.done)
		}
		}
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,75 @@
		package harness_test

		import (
		"sync"
		"testing"

		"github.com/coder/coder/v2/scaletest/harness"
		"github.com/coder/coder/v2/testutil"
		)

		func TestBarrier_MultipleRunners(t *testing.T) {
		t.Parallel()
		const numRunners = 3

		ctx := testutil.Context(t, testutil.WaitShort)
		barrier := harness.NewBarrier(numRunners)

		var wg sync.WaitGroup
		wg.Add(numRunners)

		done := make(chan struct{})

		for range numRunners {
		go func() {
		defer wg.Done()
		barrier.Wait()
		}()
		}

		go func() {
		wg.Wait()
		close(done)
		}()

		select {
		case <-done:
		return
		case <-ctx.Done():
		t.Fatal("barrier should have released all runners")
		}
		}

		func TestBarrier_Cancel(t *testing.T) {
		t.Parallel()
		const numRunners = 3

		ctx := testutil.Context(t, testutil.WaitShort)
		barrier := harness.NewBarrier(numRunners)

		var wg sync.WaitGroup
		wg.Add(numRunners - 1)

		done := make(chan struct{})

		for range numRunners - 1 {
		go func() {
		defer wg.Done()
		barrier.Wait()
		}()
		}

		barrier.Cancel()

		go func() {
		wg.Wait()
		close(done)
		}()

		select {
		case <-done:
		return
		case <-ctx.Done():
		t.Fatal("barrier should have released after cancel")
Copy link Contributor spikecurtisSep 24, 2025 Choose a reason for hiding this comment The reason will be displayed to describe this comment to others.Learn more. we have`testutil.RequireReceive()` for this since it comes up all the time.
		}
		}