Start

Author: ehsaniara

cmd/main.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"github.com/ehsaniara/gointerlock"
+	"log"
+	"time"
+)
+
+func myJob() {
+	fmt.Println(time.Now(), " - called")
+}
+
+func main() {
+
+	//test cron
+	var jobTicker = gointerlock.GoInterval{
+		Name:     "MyTestJob",
+		Interval: 2 * time.Second,
+		Arg:      myJob,
+	}
+	err := jobTicker.Run(context.Background())
+	if err != nil {
+		log.Fatalf("Error: %s", err)
+	}
+
+}

go.mod

@@ -0,0 +1,5 @@
+module github.com/ehsaniara/gointerlock
+
+go 1.16
+
+require github.com/go-redis/redis/v8 v8.11.1

goInterval.go

@@ -0,0 +1,78 @@
+package gointerlock
+
+import (
+	"context"
+	"errors"
+	"github.com/go-redis/redis/v8"
+	"log"
+	"time"
+)
+
+type GoInterval struct {
+	Name           string
+	Arg            func()
+	Interval       time.Duration
+	timer          *time.Timer
+	RedisConnector *redis.Client
+}
+
+func (t *GoInterval) Run(ctx context.Context) error {
+
+	if ctx == nil {
+		ctx = context.Background()
+	}
+
+	if t.Interval == 0 {
+		return errors.New("`Time Interval is missing!`")
+	}
+	if t.Arg == nil {
+		return errors.New("`What this timer should to run?`")
+	}
+
+	var locker Locker
+	locker.redisConnector = t.RedisConnector
+
+	if locker.redisConnector == nil && t.Name == "" {
+		return errors.New("`Distributed Jobs should have a unique name!`")
+	}
+
+	t.updateTimer()
+	for {
+		select {
+		case <-ctx.Done():
+			log.Printf("Job %s is terminated", t.Name)
+			return nil
+		default:
+
+			<-t.timer.C
+			//lock
+			locked, errLock := locker.Lock(ctx, t.Name)
+			if errLock != nil {
+				return errLock
+			}
+			if locked {
+				// run the task
+				t.Arg()
+				//unlock
+				errUnlock := locker.Unlock(ctx, t.Name)
+				if errUnlock != nil {
+					return errUnlock
+				}
+			}
+			t.updateTimer()
+		}
+	}
+}
+
+func (t *GoInterval) updateTimer() {
+	nextTick := time.Now()
+	if !nextTick.After(time.Now()) {
+		nextTick = nextTick.Add(t.Interval)
+	}
+	diff := nextTick.Sub(time.Now())
+	if t.timer == nil {
+		t.timer = time.NewTimer(diff)
+	} else {
+		t.timer.Reset(diff)
+	}
+}

goIntervalLock.go

@@ -0,0 +1,31 @@
+package gointerlock
+
+import (
+	"context"
+	"github.com/go-redis/redis/v8"
+	"time"
+)
+
+type Locker struct {
+	redisConnector *redis.Client
+}
+
+func (s *Locker) Lock(ctx context.Context, key string) (success bool, err error) {
+	if s.redisConnector != nil {
+
+		res, err := s.redisConnector.SetNX(ctx, key, time.Now().String(), time.Second*15).Result()
+		if err != nil {
+			return false, err
+		}
+		return res, nil
+	}
+	return true, nil
+}
+
+func (s *Locker) Unlock(ctx context.Context, key string) error {
+	if s.redisConnector != nil {
+		return s.redisConnector.Del(ctx, key).Err()
+	} else {
+		return nil
+	}
+}

goInterval_test.go

@@ -0,0 +1 @@
+package gointerlock