opensnitch/daemon/tasks/scheduler/scheduler.go
Gustavo Iñiguez Goia 442b466b63
tasks: improved scheduler
Restart the daily timers appropiately if the clock has drifted, for
example when the computer is put to sleep.
2026-01-12 00:04:54 +01:00

173 lines
4 KiB
Go

// Copyright 2025 The OpenSnitch Authors. All rights reserved.
// Use of this source code is governed by the GPLv3
// license that can be found in the LICENSE file.
package scheduler
import (
"context"
"sync"
"time"
"github.com/evilsocket/opensnitch/daemon/log"
)
type Config struct {
Time []string `json:"time"`
Weekday []int `json:"weekday"`
Hour []int `json:"hour"`
Minute []int `json:"minute"`
Second []int `json:"second"`
Repeat bool `json:"repeat"`
}
// Scheduler is a general purpose tasks scheduler, to run jobs at
// regular intervals, pretty much like cron, with different syntax.
// Configuration example:
// "schedule": [
// {
// "description": "run this task on Satuday and Sunday, at 9am and 23pm",
// "weekday": [5,6],
// "time": ["09:00:00", "23:00:00"]
// },
// {
// "description": "also run this task on Fridays every 30m",
// "weekday": [4],
// "minute": [30]
// }
// ],
type Scheduler struct {
Ctx context.Context
Cancel context.CancelFunc
Tickers map[int]*time.Ticker
Ticker *time.Ticker
TickChan chan time.Time
ticky chan time.Time
Config Config
mu *sync.RWMutex
}
func New(ctx context.Context, cancel context.CancelFunc, config Config) *Scheduler {
sched := &Scheduler{
Ctx: ctx,
Cancel: cancel,
TickChan: make(chan time.Time),
ticky: make(chan time.Time),
Tickers: make(map[int]*time.Ticker),
Config: config,
mu: &sync.RWMutex{},
}
return sched
}
func (s *Scheduler) Start() {
log.Debug("[tasks-scheduler] Start()")
if len(s.Config.Time) > 0 {
go s.SetupDailyTimers()
}
go func() {
hourMatched := false
minMatched := false
secMatched := false
hasHours := len(s.Config.Hour) > 0
hasMins := len(s.Config.Minute) > 0
hasSeconds := len(s.Config.Second) > 0
resolution := time.Second
// if there're no seconds specified, and minutes are specified,
// minimum timer resolution is every minute
if hasMins && !hasSeconds {
resolution = time.Minute
} else if hasHours && !hasMins && !hasSeconds {
resolution = time.Hour
}
log.Trace("[tasks-scheduler] resolution: %v\n", resolution)
s.Ticker = time.NewTicker(resolution)
defer s.Ticker.Stop()
sch := s.Config
for {
select {
case <-s.Ctx.Done():
goto Exit
case now := <-s.Ticker.C:
isWeekday := false
for _, wd := range sch.Weekday {
if wd == int(now.Weekday()) {
isWeekday = true
}
}
if !isWeekday {
goto Continue
}
if hasHours {
for _, mm := range sch.Hour {
if mm == now.Hour() {
hourMatched = true
break
}
}
}
if hasMins {
for _, mm := range sch.Minute {
if mm == now.Minute() {
minMatched = true
break
}
}
}
if hasSeconds {
for _, ss := range sch.Second {
if ss == now.Second() {
secMatched = true
}
}
}
if // match only hours
(hasHours && !hasMins && !hasSeconds && hourMatched) ||
// only minutes
(!hasHours && hasMins && !hasSeconds && minMatched) ||
// only seconds
(!hasHours && !hasMins && hasSeconds && secMatched) ||
// mins + secs matched
(!hasHours && hasMins && hasSeconds && minMatched && secMatched) ||
(hasHours && hasMins && hasSeconds && hourMatched && minMatched && secMatched) {
s.TickChan <- time.Now()
log.Trace("[tasks-scheduler] scheduling new job, hour: %d, min: %d, sec: %d, hours: %v mins: %v, secs: %v\n", now.Hour(), now.Minute(), now.Second(), hourMatched, minMatched, secMatched)
}
}
Continue:
hourMatched = false
minMatched = false
secMatched = false
}
Exit:
log.Info("[tasks-scheduler] stopped")
}()
}
func (s *Scheduler) Stop() {
if len(s.Tickers) > 0 {
for id, t := range s.Tickers {
if t != nil {
t.Stop()
}
t = nil
delete(s.Tickers, id)
}
s.Tickers = make(map[int]*time.Ticker)
}
if s.Ticker != nil {
s.Ticker.Stop()
}
}
func (s *Scheduler) Tick() <-chan time.Time {
return s.TickChan
}