v1.0.0

common/task/common.go

@@ -0,0 +1,10 @@
+package task
+
+import "github.com/xtls/xray-core/v1/common"
+
+// Close returns a func() that closes v.
+func Close(v interface{}) func() error {
+	return func() error {
+		return common.Close(v)
+	}
+}

common/task/periodic.go

@@ -0,0 +1,85 @@
+package task
+
+import (
+	"sync"
+	"time"
+)
+
+// Periodic is a task that runs periodically.
+type Periodic struct {
+	// Interval of the task being run
+	Interval time.Duration
+	// Execute is the task function
+	Execute func() error
+
+	access  sync.Mutex
+	timer   *time.Timer
+	running bool
+}
+
+func (t *Periodic) hasClosed() bool {
+	t.access.Lock()
+	defer t.access.Unlock()
+
+	return !t.running
+}
+
+func (t *Periodic) checkedExecute() error {
+	if t.hasClosed() {
+		return nil
+	}
+
+	if err := t.Execute(); err != nil {
+		t.access.Lock()
+		t.running = false
+		t.access.Unlock()
+		return err
+	}
+
+	t.access.Lock()
+	defer t.access.Unlock()
+
+	if !t.running {
+		return nil
+	}
+
+	t.timer = time.AfterFunc(t.Interval, func() {
+		t.checkedExecute()
+	})
+
+	return nil
+}
+
+// Start implements common.Runnable.
+func (t *Periodic) Start() error {
+	t.access.Lock()
+	if t.running {
+		t.access.Unlock()
+		return nil
+	}
+	t.running = true
+	t.access.Unlock()
+
+	if err := t.checkedExecute(); err != nil {
+		t.access.Lock()
+		t.running = false
+		t.access.Unlock()
+		return err
+	}
+
+	return nil
+}
+
+// Close implements common.Closable.
+func (t *Periodic) Close() error {
+	t.access.Lock()
+	defer t.access.Unlock()
+
+	t.running = false
+	if t.timer != nil {
+		t.timer.Stop()
+		t.timer = nil
+	}
+
+	return nil
+}

common/task/periodic_test.go

@@ -0,0 +1,36 @@
+package task_test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/xtls/xray-core/v1/common"
+	. "github.com/xtls/xray-core/v1/common/task"
+)
+
+func TestPeriodicTaskStop(t *testing.T) {
+	value := 0
+	task := &Periodic{
+		Interval: time.Second * 2,
+		Execute: func() error {
+			value++
+			return nil
+		},
+	}
+	common.Must(task.Start())
+	time.Sleep(time.Second * 5)
+	common.Must(task.Close())
+	if value != 3 {
+		t.Fatal("expected 3, but got ", value)
+	}
+	time.Sleep(time.Second * 4)
+	if value != 3 {
+		t.Fatal("expected 3, but got ", value)
+	}
+	common.Must(task.Start())
+	time.Sleep(time.Second * 3)
+	if value != 5 {
+		t.Fatal("Expected 5, but ", value)
+	}
+	common.Must(task.Close())
+}

common/task/task.go

@@ -0,0 +1,52 @@
+package task
+
+import (
+	"context"
+
+	"github.com/xtls/xray-core/v1/common/signal/semaphore"
+)
+
+// OnSuccess executes g() after f() returns nil.
+func OnSuccess(f func() error, g func() error) func() error {
+	return func() error {
+		if err := f(); err != nil {
+			return err
+		}
+		return g()
+	}
+}
+
+// Run executes a list of tasks in parallel, returns the first error encountered or nil if all tasks pass.
+func Run(ctx context.Context, tasks ...func() error) error {
+	n := len(tasks)
+	s := semaphore.New(n)
+	done := make(chan error, 1)
+
+	for _, task := range tasks {
+		<-s.Wait()
+		go func(f func() error) {
+			err := f()
+			if err == nil {
+				s.Signal()
+				return
+			}
+
+			select {
+			case done <- err:
+			default:
+			}
+		}(task)
+	}
+
+	for i := 0; i < n; i++ {
+		select {
+		case err := <-done:
+			return err
+		case <-ctx.Done():
+			return ctx.Err()
+		case <-s.Wait():
+		}
+	}
+
+	return nil
+}

common/task/task_test.go

@@ -0,0 +1,66 @@
+package task_test
+
+import (
+	"context"
+	"errors"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/google/go-cmp/cmp"
+
+	"github.com/xtls/xray-core/v1/common"
+	. "github.com/xtls/xray-core/v1/common/task"
+)
+
+func TestExecuteParallel(t *testing.T) {
+	err := Run(context.Background(),
+		func() error {
+			time.Sleep(time.Millisecond * 200)
+			return errors.New("test")
+		}, func() error {
+			time.Sleep(time.Millisecond * 500)
+			return errors.New("test2")
+		})
+
+	if r := cmp.Diff(err.Error(), "test"); r != "" {
+		t.Error(r)
+	}
+}
+
+func TestExecuteParallelContextCancel(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	err := Run(ctx, func() error {
+		time.Sleep(time.Millisecond * 2000)
+		return errors.New("test")
+	}, func() error {
+		time.Sleep(time.Millisecond * 5000)
+		return errors.New("test2")
+	}, func() error {
+		cancel()
+		return nil
+	})
+
+	errStr := err.Error()
+	if !strings.Contains(errStr, "canceled") {
+		t.Error("expected error string to contain 'canceled', but actually not: ", errStr)
+	}
+}
+
+func BenchmarkExecuteOne(b *testing.B) {
+	noop := func() error {
+		return nil
+	}
+	for i := 0; i < b.N; i++ {
+		common.Must(Run(context.Background(), noop))
+	}
+}
+
+func BenchmarkExecuteTwo(b *testing.B) {
+	noop := func() error {
+		return nil
+	}
+	for i := 0; i < b.N; i++ {
+		common.Must(Run(context.Background(), noop, noop))
+	}
+}