upgraded functionality

Author: gbenroscience

main/main.exe

@@ -2,7 +2,6 @@ package main
 
 import (
 	"fmt"
-	"sync"
 	"time"
 
 	"github.com/gbenroscience/scheduled-executor/utils"
@@ -15,17 +14,31 @@ func timeStampMillis() int {
 func main() {
 
 	totalCount := 0
+	const MAX_CYCLES = 5
 
-	var wg *sync.WaitGroup = &sync.WaitGroup{}
+	sc := utils.NewTimedExecutor(2*time.Second, 500*time.Millisecond)
 
-	utils.NewTimedExecutor(2*time.Second, 2*time.Second).Start(func() {
+	sc.Start(func() {
 		totalCount++
 		fmt.Printf("%d.%4stime is %d\n", totalCount, " ", timeStampMillis())
-		wg.Done()
+		if totalCount > MAX_CYCLES {
+			sc.Close()
+		}
 	}, true)
 
-	wg.Add(10)
+}
+
+/*
+func main() {
+
+	totalCount := 0
+
+	utils.NewTimedExecutor(2*time.Second, 2*time.Second).Start(func() {
+		totalCount++
+		fmt.Printf("%d.%4stime is %d\n", totalCount, " ", timeStampMillis())
+	}, true)
 
-	wg.Wait()
+	time.Sleep(time.Minute)
 
 }
+*/

main/main.go

@@ -1,86 +1,82 @@
 package utils
 
 import (
-	"fmt"
+	"context"
 	"os"
 	"os/signal"
 	"syscall"
 	"time"
 )
 
 type ScheduledExecutor struct {
-	delay  time.Duration
-	ticker time.Ticker
-	quit   chan int
+	delay    time.Duration
+	ticker   time.Ticker
+	sigs     chan os.Signal
+	shutdown bool
 }
 
-const SHUT_DOWN = 1
-
 func NewTimedExecutor(initialDelay time.Duration, delay time.Duration) ScheduledExecutor {
 	return ScheduledExecutor{
 		delay:  delay,
 		ticker: *time.NewTicker(initialDelay),
-		quit:   make(chan int),
 	}
 }
 
 // Start .. process() is the function to run periodically , runAsync detects if the function should block the executor when running or not. It blocks when false
-func (se ScheduledExecutor) Start(task func(), runAsync bool) {
+func (se *ScheduledExecutor) Start(task func(), runAsync bool) {
+	// Create a context that can be cancelled
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
 
-	sigs := make(chan os.Signal, 1)
-	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
+	se.shutdown = false
+	se.sigs = make(chan os.Signal, 1)
+	signal.Notify(se.sigs, syscall.SIGINT, syscall.SIGTERM)
 
 	go func() {
-		defer func() {
-			fmt.Println("Scheduler stopping...")
-			se.close()
-			fmt.Println("Scheduler stopped.")
-		}()
-		firstExec := true
-		for {
-			fmt.Println("IN the loop")
-			select {
-			case <-se.ticker.C:
+		<-se.sigs // Block until a signal is received
+		cancel()
+	}()
 
-				if firstExec {
-					se.ticker.Stop()
-					se.ticker = *time.NewTicker(se.delay)
-					firstExec = false
-				}
+	firstExec := true
 
-				if runAsync {
-					go task()
-				} else {
-					task()
-				}
-				fmt.Println("case evaluated, other cases will be ignored for now - 1")
-			case a := <-se.quit:
-				if a == SHUT_DOWN {
-					fmt.Printf("returning here - 2, a= %d\n", a)
-					return
-				}
-				fmt.Println("keep idling sweet golang - 2")
+	defer func() {
+		se.close()
+		close(se.sigs)
+	}()
+	for {
+		if se.shutdown {
+			return
+		}
+		select {
+		case <-se.ticker.C:
 
-			case <-sigs:
-				fmt.Println("AWW AWW AWW - 3")
-				fmt.Println("breaking out of select here - 3")
+			if firstExec {
+				se.ticker.Stop()
+				se.ticker = *time.NewTicker(se.delay)
+				firstExec = false
+			}
+
+			if runAsync {
+				go task()
+			} else {
+				task()
+			}
+		case <-ctx.Done():
+			return
+		default:
+			if se.shutdown {
 				return
 			}
 		}
-		fmt.Println("OUT of the loop - 4")
-
-	}()
-	fmt.Println("OUT of goroutine - 5")
+	}
 
 }
 
 func (se *ScheduledExecutor) Close() error {
-	go func() {
-		fmt.Println("Closing scheduler...")
-		se.quit <- SHUT_DOWN
-	}()
+	se.shutdown = true
 	return nil
 }
+
 func (se *ScheduledExecutor) close() {
 	se.ticker.Stop()
 }