Prevent adding to an eventloop when reserve was for a previous start

This basically fixes promises or reservations from previous iterations
to be executed in next ones, most likely across scenarios.

This probably need a better solution and some better notification apart
from the context getting canceled but that seems at least currently to
be way more involved

js/eventloop.go

@@ -30,6 +30,7 @@ import (
 type eventLoop struct {
 	queueLock     sync.Mutex
 	queue         []func()
+	started       int
 	wakeupCh      chan struct{} // maybe use sync.Cond ?
 	reservedCount int
 }
@@ -60,10 +61,15 @@ func (e *eventLoop) RunOnLoop(f func()) {
 func (e *eventLoop) Reserve() func(func()) {
 	e.queueLock.Lock()
 	e.reservedCount++
+	started := e.started
 	e.queueLock.Unlock()
 
 	return func(f func()) {
 		e.queueLock.Lock()
+		if started != e.started {
+			e.queueLock.Unlock()
+			return
+		}
 		e.queue = append(e.queue, f)
 		e.reservedCount--
 		e.queueLock.Unlock()
@@ -78,6 +84,10 @@ func (e *eventLoop) Reserve() func(func()) {
 // or the context is done
 //nolint:cyclop
 func (e *eventLoop) Start(ctx context.Context) {
+	e.queueLock.Lock()
+	e.started++
+	e.reservedCount = 0
+	e.queueLock.Unlock()
 	done := ctx.Done()
 	for {
 		select { // check if done

js/eventloop_test.go

@@ -36,15 +36,15 @@ func TestBasicEventLoop(t *testing.T) {
 	defer cancel()
 	loop.RunOnLoop(func() { ran++ })
 	loop.Start(ctx)
-	require.Equal(t, ran, 1)
+	require.Equal(t, 1, ran)
 	loop.RunOnLoop(func() { ran++ })
 	loop.RunOnLoop(func() { ran++ })
 	loop.Start(ctx)
-	require.Equal(t, ran, 3)
+	require.Equal(t, 3, ran)
 	loop.RunOnLoop(func() { ran++; cancel() })
 	loop.RunOnLoop(func() { ran++ })
 	loop.Start(ctx)
-	require.Equal(t, ran, 4)
+	require.Equal(t, 4, ran)
 }
 
 func TestEventLoopReserve(t *testing.T) {
@@ -66,6 +66,46 @@ func TestEventLoopReserve(t *testing.T) {
 	start := time.Now()
 	loop.Start(ctx)
 	took := time.Since(start)
-	require.Equal(t, ran, 2)
-	require.Greater(t, took, time.Second)
+	require.Equal(t, 2, ran)
+	require.Less(t, time.Second, took)
+	require.Greater(t, time.Second+time.Millisecond*100, took)
+}
+
+func TestEventLoopReserveStopBetweenStarts(t *testing.T) {
+	t.Parallel()
+	loop := newEventLoop()
+	var ran int
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	loop.RunOnLoop(func() {
+		ran++
+		r := loop.Reserve()
+		go func() {
+			time.Sleep(time.Second)
+			r(func() {
+				ran++
+			})
+		}()
+	})
+	go func() {
+		time.Sleep(200 * time.Millisecond)
+		cancel()
+	}()
+	loop.Start(ctx)
+	require.Equal(t, 1, ran)
+
+	ctx, cancel = context.WithCancel(context.Background())
+	defer cancel()
+	loop.RunOnLoop(func() {
+		ran++
+		r := loop.Reserve()
+		go func() {
+			time.Sleep(time.Second)
+			r(func() {
+				ran++
+			})
+		}()
+	})
+	loop.Start(ctx)
+	require.Equal(t, 3, ran)
 }