moth/src/maintenance.go

246 lines
5.4 KiB
Go
Raw Normal View History

2018-09-14 18:24:48 -06:00
package main
import (
2018-09-19 21:44:34 -06:00
"bufio"
"encoding/json"
2018-09-17 17:00:08 -06:00
"fmt"
2018-09-14 18:24:48 -06:00
"io/ioutil"
2018-09-17 17:00:08 -06:00
"log"
2018-09-14 18:24:48 -06:00
"os"
2018-09-19 21:44:34 -06:00
"strconv"
2018-09-14 18:24:48 -06:00
"strings"
2018-09-17 17:00:08 -06:00
"time"
2018-09-14 18:24:48 -06:00
)
2018-09-19 21:44:34 -06:00
type PuzzleMap struct {
Points int
Path string
}
func (pm *PuzzleMap) MarshalJSON() ([]byte, error) {
if pm == nil {
return []byte("null"), nil
}
jPath, err := json.Marshal(pm.Path)
if err != nil {
return nil, err
}
ret := fmt.Sprintf("[%d,%s]", pm.Points, string(jPath))
return []byte(ret), nil
}
func (ctx *Instance) generatePuzzleList() error {
maxByCategory := map[string]int{}
for _, a := range ctx.PointsLog() {
if a.Points > maxByCategory[a.Category] {
maxByCategory[a.Category] = a.Points
}
}
ret := map[string][]PuzzleMap{}
for catName, mb := range ctx.Categories {
mf, err := mb.Open("map.txt")
if err != nil {
return err
}
defer mf.Close()
pm := make([]PuzzleMap, 0, 30)
completed := true
scanner := bufio.NewScanner(mf)
for scanner.Scan() {
line := scanner.Text()
var pointval int
var dir string
n, err := fmt.Sscanf(line, "%d %s", &pointval, &dir)
if err != nil {
return err
} else if n != 2 {
return fmt.Errorf("Parsing map for %s: short read", catName)
}
pm = append(pm, PuzzleMap{pointval, dir})
if pointval > maxByCategory[catName] {
completed = false
break
}
}
if completed {
pm = append(pm, PuzzleMap{0, ""})
}
ret[catName] = pm
}
jpl, err := json.Marshal(ret)
if err == nil {
ctx.jPuzzleList = jpl
}
return err
}
func (ctx *Instance) generatePointsLog() error {
var ret struct {
Teams map[string]string `json:"teams"`
Points []*Award `json:"points"`
}
ret.Teams = map[string]string{}
ret.Points = ctx.PointsLog()
teamNumbersById := map[string]int{}
for nr, a := range ret.Points {
teamNumber, ok := teamNumbersById[a.TeamId]
if !ok {
teamName, err := ctx.TeamName(a.TeamId)
if err != nil {
teamName = "[unregistered]"
}
teamNumber = nr
teamNumbersById[a.TeamId] = teamNumber
ret.Teams[strconv.FormatInt(int64(teamNumber), 16)] = teamName
}
a.TeamId = strconv.FormatInt(int64(teamNumber), 16)
}
jpl, err := json.Marshal(ret)
if err == nil {
ctx.jPointsLog = jpl
}
return err
}
2018-09-14 18:24:48 -06:00
// maintenance runs
2018-09-19 21:44:34 -06:00
func (ctx *Instance) tidy() {
2018-09-17 17:00:08 -06:00
// Do they want to reset everything?
ctx.MaybeInitialize()
2018-09-18 21:29:05 -06:00
// Refresh all current categories
for categoryName, mb := range ctx.Categories {
if err := mb.Refresh(); err != nil {
// Backing file vanished: remove this category
log.Printf("Removing category: %s: %s", categoryName, err)
mb.Close()
delete(ctx.Categories, categoryName)
}
}
2018-09-14 18:24:48 -06:00
// Any new categories?
files, err := ioutil.ReadDir(ctx.MothballPath())
if err != nil {
log.Printf("Error listing mothballs: %s", err)
}
for _, f := range files {
filename := f.Name()
filepath := ctx.MothballPath(filename)
2018-09-17 17:00:08 -06:00
if !strings.HasSuffix(filename, ".mb") {
2018-09-14 18:24:48 -06:00
continue
}
categoryName := strings.TrimSuffix(filename, ".mb")
2018-09-17 17:00:08 -06:00
2018-09-14 18:24:48 -06:00
if _, ok := ctx.Categories[categoryName]; !ok {
mb, err := OpenMothball(filepath)
if err != nil {
log.Printf("Error opening %s: %s", filepath, err)
continue
}
2018-09-17 17:00:08 -06:00
log.Printf("New category: %s", filename)
2018-09-14 18:24:48 -06:00
ctx.Categories[categoryName] = mb
}
}
}
// collectPoints gathers up files in points.new/ and appends their contents to points.log,
// removing each points.new/ file as it goes.
2018-09-19 21:44:34 -06:00
func (ctx *Instance) collectPoints() {
2018-09-14 18:24:48 -06:00
logf, err := os.OpenFile(ctx.StatePath("points.log"), os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
if err != nil {
log.Printf("Can't append to points log: %s", err)
return
}
defer logf.Close()
2018-09-17 17:00:08 -06:00
2018-09-14 18:24:48 -06:00
files, err := ioutil.ReadDir(ctx.StatePath("points.new"))
if err != nil {
log.Printf("Error reading packages: %s", err)
}
for _, f := range files {
filename := ctx.StatePath("points.new", f.Name())
s, err := ioutil.ReadFile(filename)
if err != nil {
log.Printf("Can't read points file %s: %s", filename, err)
continue
}
award, err := ParseAward(string(s))
if err != nil {
log.Printf("Can't parse award file %s: %s", filename, err)
continue
}
2018-09-17 21:32:24 -06:00
2018-09-17 18:02:44 -06:00
duplicate := false
for _, e := range ctx.PointsLog() {
if award.Same(e) {
duplicate = true
break
}
}
2018-09-17 21:32:24 -06:00
2018-09-17 18:02:44 -06:00
if duplicate {
log.Printf("Skipping duplicate points: %s", award.String())
} else {
fmt.Fprintf(logf, "%s\n", award.String())
}
2018-09-14 18:24:48 -06:00
logf.Sync()
if err := os.Remove(filename); err != nil {
log.Printf("Unable to remove %s: %s", filename, err)
}
}
}
2018-09-21 17:45:28 -06:00
func (ctx *Instance) isEnabled() bool {
// Skip if we've been disabled
if _, err := os.Stat(ctx.StatePath("disabled")); err == nil {
log.Print("Suspended: disabled file found")
return false
}
untilspec, err := ioutil.ReadFile(ctx.StatePath("until"))
if err == nil {
untilspecs := strings.TrimSpace(string(untilspec))
until, err := time.Parse(time.RFC3339, untilspecs)
if err != nil {
log.Printf("Suspended: Unparseable until date: %s", untilspec)
return false
}
if until.Before(time.Now()) {
log.Print("Suspended: until time reached, suspending maintenance")
return false
}
}
return true
}
2018-09-14 18:24:48 -06:00
// maintenance is the goroutine that runs a periodic maintenance task
func (ctx *Instance) Maintenance(maintenanceInterval time.Duration) {
2018-09-19 17:56:26 -06:00
for {
2018-09-21 17:45:28 -06:00
if ctx.isEnabled() {
2018-09-20 10:15:34 -06:00
ctx.tidy()
ctx.collectPoints()
ctx.generatePuzzleList()
ctx.generatePointsLog()
}
2018-09-19 17:56:26 -06:00
select {
2018-09-19 21:44:34 -06:00
case <-ctx.update:
// log.Print("Forced update")
case <-time.After(maintenanceInterval):
// log.Print("Housekeeping...")
2018-09-19 17:56:26 -06:00
}
2018-09-14 18:24:48 -06:00
}
}