Merge pull request #1 from anthonycorbacho/feat/update-qol

QOL update

Author: anthonycorbacho

.github/workflows/test.yaml

@@ -0,0 +1,18 @@
+name: Scheduler Unit Test
+on:
+  pull_request:
+    types: [ opened, synchronize ]
+    paths:
+      - "*.go"
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Install Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: 1.20.x
+      - name: Run Test
+        run: go test -v -race -p=6 -cpu=1,4 ./...

README.md

@@ -1,3 +1,42 @@
 ## Scheduler
 
-This is a simple implementation of a FiFo Scheduler.
+**Scheduler** is a simple implementation of a FiFo Scheduler.
+
+Get it:
+```
+go get -u github.com/anthonycorbacho/scheduler
+```
+
+### Quick start
+It is very easy to get started, simply create an instance of the FiFoScheduler and start adding tasks.
+
+```go
+package main
+
+import (
+	"fmt"
+
+	"github.com/anthonycorbacho/scheduler"
+)
+
+func main() {
+	s := NewFIFOScheduler()
+	defer s.Stop()
+	
+	jobCreator := func(i int) Job {
+		return func(ctx context.Context) {
+			fmt.Printf("got a task %d\n", i)
+		}
+	}
+
+	var jobs []Job
+	for i := 0; i < 100; i++ {
+		jobs = append(jobs, jobCreator(i))
+	}
+
+	for _, j := range jobs {
+		_ = s.Schedule(j)
+	}
+}
+```
+

fifoscheduler.go

@@ -6,23 +6,26 @@ import (
 	"sync"
 )
 
-// fifo represent as FIFO scheduler.
-type fifo struct {
-	mu sync.Mutex
-	resume    chan struct{}
-	scheduled int
-	finished  int
-	pendings  []Job
-	ctx    context.Context
-	cancel context.CancelFunc
+// Verify interface compliance
+var _ Scheduler = (*Fifo)(nil)
+
+// Fifo represent as FIFO scheduler.
+type Fifo struct {
+	mu         sync.Mutex
+	resume     chan struct{}
+	scheduled  int
+	finished   int
+	pendings   []Job
+	ctx        context.Context
+	cancel     context.CancelFunc
 	finishCond *sync.Cond
 	donec      chan struct{}
 }
 
 // NewFIFOScheduler returns a Scheduler that schedules jobs in FIFO
 // order sequentially
-func NewFIFOScheduler() Scheduler {
-	f := &fifo{
+func NewFIFOScheduler() *Fifo {
+	f := &Fifo{
 		resume: make(chan struct{}, 1),
 		donec:  make(chan struct{}, 1),
 	}
@@ -32,8 +35,8 @@ func NewFIFOScheduler() Scheduler {
 	return f
 }
 
-// Schedule schedules a job that will be ran in FIFO order sequentially.
-func (f *fifo) Schedule(j Job) error {
+// Schedule schedules a job that will be run in FIFO order sequentially.
+func (f *Fifo) Schedule(j Job) error {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 
@@ -51,25 +54,25 @@ func (f *fifo) Schedule(j Job) error {
 	return nil
 }
 
-func (f *fifo) Pending() int {
+func (f *Fifo) Pending() int {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	return len(f.pendings)
 }
 
-func (f *fifo) Scheduled() int {
+func (f *Fifo) Scheduled() int {
 	f.mu.Lock()
 	defer f.mu.Unlock()
 	return f.scheduled
 }
 
-func (f *fifo) Finished() int {
+func (f *Fifo) Finished() int {
 	f.finishCond.L.Lock()
 	defer f.finishCond.L.Unlock()
 	return f.finished
 }
 
-func (f *fifo) WaitFinish(n int) {
+func (f *Fifo) WaitFinish(n int) {
 	f.finishCond.L.Lock()
 	for f.finished < n || len(f.pendings) != 0 {
 		f.finishCond.Wait()
@@ -78,15 +81,15 @@ func (f *fifo) WaitFinish(n int) {
 }
 
 // Stop stops the scheduler and cancels all pending jobs.
-func (f *fifo) Stop() {
+func (f *Fifo) Stop() {
 	f.mu.Lock()
 	f.cancel()
 	f.cancel = nil
 	f.mu.Unlock()
 	<-f.donec
 }
 
-func (f *fifo) run() {
+func (f *Fifo) run() {
 	// TODO: recover from job panic?
 	defer func() {
 		close(f.donec)
@@ -125,4 +128,4 @@ func (f *fifo) run() {
 			f.finishCond.L.Unlock()
 		}
 	}
-}
+}

go.mod

@@ -1,3 +1,3 @@
 module github.com/anthonycorbacho/scheduler
 
-go 1.15
+go 1.20

scheduler.go

@@ -24,4 +24,4 @@ type Scheduler interface {
 
 	// Stop stops the scheduler.
 	Stop()
-}
+}