sync: move closer to separate file (#6015)

Closes: #6013

libs/sync/closer.go

@@ -0,0 +1,31 @@
+package sync
+
+import "sync"
+
+// Closer implements a primitive to close a channel that signals process
+// termination while allowing a caller to call Close multiple times safely. It
+// should be used in cases where guarantees cannot be made about when and how
+// many times closure is executed.
+type Closer struct {
+	closeOnce sync.Once
+	doneCh    chan struct{}
+}
+
+// NewCloser returns a reference to a new Closer.
+func NewCloser() *Closer {
+	return &Closer{doneCh: make(chan struct{})}
+}
+
+// Done returns the internal done channel allowing the caller either block or wait
+// for the Closer to be terminated/closed.
+func (c *Closer) Done() <-chan struct{} {
+	return c.doneCh
+}
+
+// Close gracefully closes the Closer. A caller should only call Close once, but
+// it is safe to call it successive times.
+func (c *Closer) Close() {
+	c.closeOnce.Do(func() {
+		close(c.doneCh)
+	})
+}

libs/sync/closer_test.go

@@ -0,0 +1,28 @@
+package sync_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+	tmsync "github.com/tendermint/tendermint/libs/sync"
+)
+
+func TestCloser(t *testing.T) {
+	closer := tmsync.NewCloser()
+
+	var timeout bool
+
+	select {
+	case <-closer.Done():
+	case <-time.After(time.Second):
+		timeout = true
+	}
+
+	for i := 0; i < 10; i++ {
+		closer.Close()
+	}
+
+	require.True(t, timeout)
+	<-closer.Done()
+}

libs/sync/deadlock.go

@@ -15,31 +15,3 @@ type Mutex struct {
 type RWMutex struct {
 	deadlock.RWMutex
 }
-
-// Closer implements a primitive to close a channel that signals process
-// termination while allowing a caller to call Close multiple times safely. It
-// should be used in cases where guarantees cannot be made about when and how
-// many times closure is executed.
-type Closer struct {
-	closeOnce deadlock.Once
-	doneCh    chan struct{}
-}
-
-// NewCloser returns a reference to a new Closer.
-func NewCloser() *Closer {
-	return &Closer{doneCh: make(chan struct{})}
-}
-
-// Done returns the internal done channel allowing the caller either block or wait
-// for the Closer to be terminated/closed.
-func (c *Closer) Done() <-chan struct{} {
-	return c.doneCh
-}
-
-// Close gracefully closes the Closer. A caller should only call Close once, but
-// it is safe to call it successive times.
-func (c *Closer) Close() {
-	c.closeOnce.Do(func() {
-		close(c.doneCh)
-	})
-}

libs/sync/sync.go

@@ -13,31 +13,3 @@ type Mutex struct {
 type RWMutex struct {
 	sync.RWMutex
 }
-
-// Closer implements a primitive to close a channel that signals process
-// termination while allowing a caller to call Close multiple times safely. It
-// should be used in cases where guarantees cannot be made about when and how
-// many times closure is executed.
-type Closer struct {
-	closeOnce sync.Once
-	doneCh    chan struct{}
-}
-
-// NewCloser returns a reference to a new Closer.
-func NewCloser() *Closer {
-	return &Closer{doneCh: make(chan struct{})}
-}
-
-// Done returns the internal done channel allowing the caller either block or wait
-// for the Closer to be terminated/closed.
-func (c *Closer) Done() <-chan struct{} {
-	return c.doneCh
-}
-
-// Close gracefully closes the Closer. A caller should only call Close once, but
-// it is safe to call it successive times.
-func (c *Closer) Close() {
-	c.closeOnce.Do(func() {
-		close(c.doneCh)
-	})
-}