AdGuardHome/internal/schedule/schedule.go

361 lines
9.5 KiB
Go

// Package schedule provides types for scheduling.
package schedule
import (
"encoding/json"
"fmt"
"time"
"github.com/AdguardTeam/AdGuardHome/internal/aghhttp"
"github.com/AdguardTeam/golibs/errors"
"github.com/AdguardTeam/golibs/timeutil"
"gopkg.in/yaml.v3"
)
// Weekly is a schedule for one week. Each day of the week has one range with
// a beginning and an end.
type Weekly struct {
// location is used to calculate the offsets of the day ranges.
location *time.Location
// days are the day ranges of this schedule. The indexes of this array are
// the [time.Weekday] values.
days [7]dayRange
}
// EmptyWeekly creates empty weekly schedule with local time zone.
func EmptyWeekly() (w *Weekly) {
return &Weekly{
location: time.Local,
}
}
// FullWeekly creates full weekly schedule with local time zone.
//
// TODO(s.chzhen): Consider moving into tests.
func FullWeekly() (w *Weekly) {
fullDay := dayRange{start: 0, end: maxDayRange}
return &Weekly{
location: time.Local,
days: [7]dayRange{
time.Sunday: fullDay,
time.Monday: fullDay,
time.Tuesday: fullDay,
time.Wednesday: fullDay,
time.Thursday: fullDay,
time.Friday: fullDay,
time.Saturday: fullDay,
},
}
}
// Clone returns a deep copy of a weekly.
func (w *Weekly) Clone() (c *Weekly) {
if w == nil {
return nil
}
// NOTE: Do not use time.LoadLocation, because the results will be
// different on time zone database update.
return &Weekly{
location: w.location,
days: w.days,
}
}
// Contains returns true if t is within the corresponding day range of the
// schedule in the schedule's time zone.
func (w *Weekly) Contains(t time.Time) (ok bool) {
t = t.In(w.location)
wd := t.Weekday()
dr := w.days[wd]
// Calculate the offset of the day range.
//
// NOTE: Do not use [time.Truncate] since it requires UTC time zone.
y, m, d := t.Date()
day := time.Date(y, m, d, 0, 0, 0, 0, w.location)
offset := t.Sub(day)
return dr.contains(offset)
}
// type check
var _ json.Unmarshaler = (*Weekly)(nil)
// UnmarshalJSON implements the [json.Unmarshaler] interface for *Weekly.
func (w *Weekly) UnmarshalJSON(data []byte) (err error) {
conf := &weeklyConfigJSON{}
err = json.Unmarshal(data, conf)
if err != nil {
return err
}
weekly := Weekly{}
weekly.location, err = time.LoadLocation(conf.TimeZone)
if err != nil {
return err
}
days := []*dayConfigJSON{
time.Sunday: conf.Sunday,
time.Monday: conf.Monday,
time.Tuesday: conf.Tuesday,
time.Wednesday: conf.Wednesday,
time.Thursday: conf.Thursday,
time.Friday: conf.Friday,
time.Saturday: conf.Saturday,
}
for i, d := range days {
var r dayRange
if d != nil {
r = dayRange{
start: time.Duration(d.Start),
end: time.Duration(d.End),
}
}
err = w.validate(r)
if err != nil {
return fmt.Errorf("weekday %s: %w", time.Weekday(i), err)
}
weekly.days[i] = r
}
*w = weekly
return nil
}
// type check
var _ yaml.Unmarshaler = (*Weekly)(nil)
// UnmarshalYAML implements the [yaml.Unmarshaler] interface for *Weekly.
func (w *Weekly) UnmarshalYAML(value *yaml.Node) (err error) {
conf := &weeklyConfigYAML{}
err = value.Decode(conf)
if err != nil {
// Don't wrap the error since it's informative enough as is.
return err
}
weekly := Weekly{}
weekly.location, err = time.LoadLocation(conf.TimeZone)
if err != nil {
// Don't wrap the error since it's informative enough as is.
return err
}
days := []dayConfigYAML{
time.Sunday: conf.Sunday,
time.Monday: conf.Monday,
time.Tuesday: conf.Tuesday,
time.Wednesday: conf.Wednesday,
time.Thursday: conf.Thursday,
time.Friday: conf.Friday,
time.Saturday: conf.Saturday,
}
for i, d := range days {
r := dayRange{
start: time.Duration(d.Start),
end: time.Duration(d.End),
}
err = w.validate(r)
if err != nil {
return fmt.Errorf("weekday %s: %w", time.Weekday(i), err)
}
weekly.days[i] = r
}
*w = weekly
return nil
}
// weeklyConfigYAML is the YAML configuration structure of Weekly.
type weeklyConfigYAML struct {
// TimeZone is the local time zone.
TimeZone string `yaml:"time_zone"`
// Days of the week.
Sunday dayConfigYAML `yaml:"sun,omitempty"`
Monday dayConfigYAML `yaml:"mon,omitempty"`
Tuesday dayConfigYAML `yaml:"tue,omitempty"`
Wednesday dayConfigYAML `yaml:"wed,omitempty"`
Thursday dayConfigYAML `yaml:"thu,omitempty"`
Friday dayConfigYAML `yaml:"fri,omitempty"`
Saturday dayConfigYAML `yaml:"sat,omitempty"`
}
// dayConfigYAML is the YAML configuration structure of dayRange.
type dayConfigYAML struct {
Start timeutil.Duration `yaml:"start"`
End timeutil.Duration `yaml:"end"`
}
// maxDayRange is the maximum value for day range end.
const maxDayRange = 24 * time.Hour
// validate returns the day range rounding errors, if any.
func (w *Weekly) validate(r dayRange) (err error) {
defer func() { err = errors.Annotate(err, "bad day range: %w") }()
err = r.validate()
if err != nil {
// Don't wrap the error since it's informative enough as is.
return err
}
start := r.start.Truncate(time.Minute)
end := r.end.Truncate(time.Minute)
switch {
case start != r.start:
return fmt.Errorf("start %s isn't rounded to minutes", r.start)
case end != r.end:
return fmt.Errorf("end %s isn't rounded to minutes", r.end)
default:
return nil
}
}
// type check
var _ json.Marshaler = (*Weekly)(nil)
// MarshalJSON implements the [json.Marshaler] interface for *Weekly.
func (w *Weekly) MarshalJSON() (data []byte, err error) {
c := &weeklyConfigJSON{
TimeZone: w.location.String(),
Sunday: w.days[time.Sunday].toDayConfigJSON(),
Monday: w.days[time.Monday].toDayConfigJSON(),
Tuesday: w.days[time.Tuesday].toDayConfigJSON(),
Wednesday: w.days[time.Wednesday].toDayConfigJSON(),
Thursday: w.days[time.Thursday].toDayConfigJSON(),
Friday: w.days[time.Friday].toDayConfigJSON(),
Saturday: w.days[time.Saturday].toDayConfigJSON(),
}
return json.Marshal(c)
}
// type check
var _ yaml.Marshaler = (*Weekly)(nil)
// MarshalYAML implements the [yaml.Marshaler] interface for *Weekly.
func (w *Weekly) MarshalYAML() (v any, err error) {
return weeklyConfigYAML{
TimeZone: w.location.String(),
Sunday: dayConfigYAML{
Start: timeutil.Duration(w.days[time.Sunday].start),
End: timeutil.Duration(w.days[time.Sunday].end),
},
Monday: dayConfigYAML{
Start: timeutil.Duration(w.days[time.Monday].start),
End: timeutil.Duration(w.days[time.Monday].end),
},
Tuesday: dayConfigYAML{
Start: timeutil.Duration(w.days[time.Tuesday].start),
End: timeutil.Duration(w.days[time.Tuesday].end),
},
Wednesday: dayConfigYAML{
Start: timeutil.Duration(w.days[time.Wednesday].start),
End: timeutil.Duration(w.days[time.Wednesday].end),
},
Thursday: dayConfigYAML{
Start: timeutil.Duration(w.days[time.Thursday].start),
End: timeutil.Duration(w.days[time.Thursday].end),
},
Friday: dayConfigYAML{
Start: timeutil.Duration(w.days[time.Friday].start),
End: timeutil.Duration(w.days[time.Friday].end),
},
Saturday: dayConfigYAML{
Start: timeutil.Duration(w.days[time.Saturday].start),
End: timeutil.Duration(w.days[time.Saturday].end),
},
}, nil
}
// dayRange represents a single interval within a day. The interval begins at
// start and ends before end. That is, it contains a time point T if start <=
// T < end.
type dayRange struct {
// start is an offset from the beginning of the day. It must be greater
// than or equal to zero and less than 24h.
start time.Duration
// end is an offset from the beginning of the day. It must be greater than
// or equal to zero and less than or equal to 24h.
end time.Duration
}
// validate returns the day range validation errors, if any.
func (r dayRange) validate() (err error) {
switch {
case r == dayRange{}:
return nil
case r.start < 0:
return fmt.Errorf("start %s is negative", r.start)
case r.end < 0:
return fmt.Errorf("end %s is negative", r.end)
case r.start >= r.end:
return fmt.Errorf("start %s is greater or equal to end %s", r.start, r.end)
case r.start >= maxDayRange:
return fmt.Errorf("start %s is greater or equal to %s", r.start, maxDayRange)
case r.end > maxDayRange:
return fmt.Errorf("end %s is greater than %s", r.end, maxDayRange)
default:
return nil
}
}
// contains returns true if start <= offset < end, where offset is the time
// duration from the beginning of the day.
func (r *dayRange) contains(offset time.Duration) (ok bool) {
return r.start <= offset && offset < r.end
}
// toDayConfigJSON returns nil if the day range is empty, otherwise returns
// initialized JSON configuration of the day range.
func (r dayRange) toDayConfigJSON() (j *dayConfigJSON) {
if (r == dayRange{}) {
return nil
}
return &dayConfigJSON{
Start: aghhttp.JSONDuration(r.start),
End: aghhttp.JSONDuration(r.end),
}
}
// weeklyConfigJSON is the JSON configuration structure of Weekly.
type weeklyConfigJSON struct {
// Days of the week.
Sunday *dayConfigJSON `json:"sun,omitempty"`
Monday *dayConfigJSON `json:"mon,omitempty"`
Tuesday *dayConfigJSON `json:"tue,omitempty"`
Wednesday *dayConfigJSON `json:"wed,omitempty"`
Thursday *dayConfigJSON `json:"thu,omitempty"`
Friday *dayConfigJSON `json:"fri,omitempty"`
Saturday *dayConfigJSON `json:"sat,omitempty"`
// TimeZone is the local time zone.
TimeZone string `json:"time_zone"`
}
// dayConfigJSON is the JSON configuration structure of dayRange.
type dayConfigJSON struct {
Start aghhttp.JSONDuration `json:"start"`
End aghhttp.JSONDuration `json:"end"`
}