mirror of https://github.com/dirtbags/moth.git
Remove v3 code
This commit is contained in:
Neale Pickett
parent
ab0488ba14
commit
7b353131e4
|
|
@ -1,342 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"log"
|
||||
"net/http"
|
||||
"os"
|
||||
"path"
|
||||
"path/filepath"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
)
|
||||
|
||||
|
||||
|
||||
// hasLine returns true if line appears in r.
|
||||
// The entire line must match.
|
||||
func hasLine(r io.Reader, line string) bool {
|
||||
scanner := bufio.NewScanner(r)
|
||||
for scanner.Scan() {
|
||||
if scanner.Text() == line {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (ctx *Instance) registerHandler(w http.ResponseWriter, req *http.Request) {
|
||||
teamName := req.FormValue("name")
|
||||
teamId := req.FormValue("id")
|
||||
|
||||
if !ctx.ValidTeamId(teamId) {
|
||||
respond(
|
||||
w, req, JSendFail,
|
||||
"Invalid Team ID",
|
||||
"I don't have a record of that team ID. Maybe you used capital letters accidentally?",
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
f, err := os.OpenFile(ctx.StatePath("teams", teamId), os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0644)
|
||||
if err != nil {
|
||||
if os.IsExist(err) {
|
||||
respond(
|
||||
w, req, JSendFail,
|
||||
"Already registered",
|
||||
"This team ID has already been registered.",
|
||||
)
|
||||
} else {
|
||||
log.Print(err)
|
||||
respond(
|
||||
w, req, JSendFail,
|
||||
"Registration failed",
|
||||
"Unable to register. Perhaps a teammate has already registered?",
|
||||
)
|
||||
}
|
||||
return
|
||||
}
|
||||
defer f.Close()
|
||||
|
||||
fmt.Fprintln(f, teamName)
|
||||
respond(
|
||||
w, req, JSendSuccess,
|
||||
"Team registered",
|
||||
"Your team has been named and you may begin using your team ID!",
|
||||
)
|
||||
}
|
||||
|
||||
func (ctx *Instance) answerHandler(w http.ResponseWriter, req *http.Request) {
|
||||
teamId := req.FormValue("id")
|
||||
category := req.FormValue("cat")
|
||||
pointstr := req.FormValue("points")
|
||||
answer := req.FormValue("answer")
|
||||
|
||||
if !ctx.ValidTeamId(teamId) {
|
||||
respond(
|
||||
w, req, JSendFail,
|
||||
"Invalid team ID",
|
||||
"That team ID is not valid for this event.",
|
||||
)
|
||||
return
|
||||
}
|
||||
if ctx.TooFast(teamId) {
|
||||
respond(
|
||||
w, req, JSendFail,
|
||||
"Submitting too quickly",
|
||||
"Your team can only submit one answer every %v", ctx.AttemptInterval,
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
respond(
|
||||
points, err := strconv.Atoi(pointstr)
|
||||
w, req, JSendFail,
|
||||
"Cannot parse point value",
|
||||
"This doesn't look like an integer: %s", pointstr,
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
haystack, err := ctx.OpenCategoryFile(category, "answers.txt")
|
||||
if err != nil {
|
||||
respond(
|
||||
w, req, JSendFail,
|
||||
"Cannot list answers",
|
||||
"Unable to read the list of answers for this category.",
|
||||
)
|
||||
return
|
||||
}
|
||||
defer haystack.Close()
|
||||
|
||||
// Look for the answer
|
||||
needle := fmt.Sprintf("%d %s", points, answer)
|
||||
if !hasLine(haystack, needle) {
|
||||
respond(
|
||||
w, req, JSendFail,
|
||||
"Wrong answer",
|
||||
"That is not the correct answer for %s %d.", category, points,
|
||||
)
|
||||
return
|
||||
}
|
||||
|
||||
if err := ctx.AwardPoints(teamId, category, points); err != nil {
|
||||
respond(
|
||||
w, req, JSendError,
|
||||
"Cannot award points",
|
||||
"The answer is correct, but there was an error awarding points: %v", err.Error(),
|
||||
)
|
||||
return
|
||||
}
|
||||
respond(
|
||||
w, req, JSendSuccess,
|
||||
"Points awarded",
|
||||
fmt.Sprintf("%d points for %s!", points, teamId),
|
||||
)
|
||||
}
|
||||
|
||||
func (ctx *Instance) puzzlesHandler(w http.ResponseWriter, req *http.Request) {
|
||||
teamId := req.FormValue("id")
|
||||
if _, err := ctx.TeamName(teamId); err != nil {
|
||||
http.Error(w, "Must provide team ID", http.StatusUnauthorized)
|
||||
return
|
||||
}
|
||||
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(http.StatusOK)
|
||||
w.Write(ctx.jPuzzleList)
|
||||
}
|
||||
|
||||
func (ctx *Instance) pointsHandler(w http.ResponseWriter, req *http.Request) {
|
||||
teamId, ok := req.URL.Query()["id"]
|
||||
pointsLog := ctx.jPointsLog
|
||||
if ok && len(teamId[0]) > 0 {
|
||||
pointsLog = ctx.generatePointsLog(teamId[0])
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(http.StatusOK)
|
||||
w.Write(pointsLog)
|
||||
}
|
||||
|
||||
func (ctx *Instance) contentHandler(w http.ResponseWriter, req *http.Request) {
|
||||
// Prevent directory traversal
|
||||
if strings.Contains(req.URL.Path, "/.") {
|
||||
http.Error(w, "Not Found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
|
||||
// Be clever: use only the last three parts of the path. This may prove to be a bad idea.
|
||||
parts := strings.Split(req.URL.Path, "/")
|
||||
if len(parts) < 3 {
|
||||
http.Error(w, "Not Found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
|
||||
fileName := parts[len(parts)-1]
|
||||
puzzleId := parts[len(parts)-2]
|
||||
categoryName := parts[len(parts)-3]
|
||||
|
||||
mb, ok := ctx.categories[categoryName]
|
||||
if !ok {
|
||||
http.Error(w, "Not Found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
|
||||
mbFilename := fmt.Sprintf("content/%s/%s", puzzleId, fileName)
|
||||
mf, err := mb.Open(mbFilename)
|
||||
if err != nil {
|
||||
log.Print(err)
|
||||
http.Error(w, "Not Found", http.StatusNotFound)
|
||||
return
|
||||
}
|
||||
defer mf.Close()
|
||||
|
||||
http.ServeContent(w, req, fileName, mf.ModTime(), mf)
|
||||
}
|
||||
|
||||
func (ctx *Instance) staticHandler(w http.ResponseWriter, req *http.Request) {
|
||||
path := req.URL.Path
|
||||
if strings.Contains(path, "..") {
|
||||
http.Error(w, "Invalid URL path", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
if path == "/" {
|
||||
path = "/index.html"
|
||||
}
|
||||
|
||||
f, err := os.Open(ctx.ThemePath(path))
|
||||
if err != nil {
|
||||
http.NotFound(w, req)
|
||||
return
|
||||
}
|
||||
defer f.Close()
|
||||
|
||||
d, err := f.Stat()
|
||||
if err != nil {
|
||||
http.NotFound(w, req)
|
||||
return
|
||||
}
|
||||
|
||||
http.ServeContent(w, req, path, d.ModTime(), f)
|
||||
}
|
||||
|
||||
func (ctx *Instance) manifestHandler(w http.ResponseWriter, req *http.Request) {
|
||||
if !ctx.Runtime.export_manifest {
|
||||
http.Error(w, "Endpoint disabled", http.StatusForbidden)
|
||||
return
|
||||
}
|
||||
|
||||
teamId := req.FormValue("id")
|
||||
if _, err := ctx.TeamName(teamId); err != nil {
|
||||
http.Error(w, "Must provide a valid team ID", http.StatusUnauthorized)
|
||||
return
|
||||
}
|
||||
|
||||
if req.Method == http.MethodHead {
|
||||
w.WriteHeader(http.StatusOK)
|
||||
return
|
||||
}
|
||||
|
||||
manifest := make([]string, 0)
|
||||
manifest = append(manifest, "puzzles.json")
|
||||
manifest = append(manifest, "points.json")
|
||||
|
||||
// Pack up the theme files
|
||||
theme_root_re := regexp.MustCompile(fmt.Sprintf("^%s/", ctx.ThemeDir))
|
||||
filepath.Walk(ctx.ThemeDir, func(path string, info os.FileInfo, err error) error {
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if !info.IsDir() { // Only package up files
|
||||
localized_path := theme_root_re.ReplaceAllLiteralString(path, "")
|
||||
manifest = append(manifest, localized_path)
|
||||
}
|
||||
return nil
|
||||
})
|
||||
|
||||
// Package up files for currently-unlocked puzzles in categories
|
||||
for category_name, category := range ctx.categories {
|
||||
if _, ok := ctx.MaxPointsUnlocked[category_name]; ok { // Check that the category is actually unlocked. This should never fail, probably
|
||||
for _, file := range category.zf.File {
|
||||
parts := strings.Split(file.Name, "/")
|
||||
|
||||
if parts[0] == "content" { // Only pick up content files, not thing like map.txt
|
||||
for _, puzzlemap := range category.puzzlemap { // Figure out which puzzles are currently unlocked
|
||||
if puzzlemap.Path == parts[1] && puzzlemap.Points <= ctx.MaxPointsUnlocked[category_name] {
|
||||
|
||||
manifest = append(manifest, path.Join("content", category_name, path.Join(parts[1:]...)))
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(http.StatusOK)
|
||||
manifest_json, _ := json.Marshal(manifest)
|
||||
w.Write(manifest_json)
|
||||
}
|
||||
|
||||
type FurtiveResponseWriter struct {
|
||||
w http.ResponseWriter
|
||||
statusCode *int
|
||||
}
|
||||
|
||||
func (w FurtiveResponseWriter) WriteHeader(statusCode int) {
|
||||
*w.statusCode = statusCode
|
||||
w.w.WriteHeader(statusCode)
|
||||
}
|
||||
|
||||
func (w FurtiveResponseWriter) Write(buf []byte) (n int, err error) {
|
||||
n, err = w.w.Write(buf)
|
||||
return
|
||||
}
|
||||
|
||||
func (w FurtiveResponseWriter) Header() http.Header {
|
||||
return w.w.Header()
|
||||
}
|
||||
|
||||
// This gives Instances the signature of http.Handler
|
||||
func (ctx *Instance) ServeHTTP(wOrig http.ResponseWriter, r *http.Request) {
|
||||
w := FurtiveResponseWriter{
|
||||
w: wOrig,
|
||||
statusCode: new(int),
|
||||
}
|
||||
|
||||
clientIP := r.RemoteAddr
|
||||
|
||||
if (ctx.UseXForwarded) {
|
||||
forwardedIP := r.Header.Get("X-Forwarded-For")
|
||||
forwardedIP = strings.Split(forwardedIP, ", ")[0]
|
||||
|
||||
if forwardedIP != "" {
|
||||
clientIP = forwardedIP
|
||||
}
|
||||
}
|
||||
|
||||
ctx.mux.ServeHTTP(w, r)
|
||||
log.Printf(
|
||||
"%s %s %s %d\n",
|
||||
clientIP,
|
||||
r.Method,
|
||||
r.URL,
|
||||
*w.statusCode,
|
||||
)
|
||||
}
|
||||
|
||||
func (ctx *Instance) BindHandlers() {
|
||||
ctx.mux.HandleFunc(ctx.Base+"/", ctx.staticHandler)
|
||||
ctx.mux.HandleFunc(ctx.Base+"/register", ctx.registerHandler)
|
||||
ctx.mux.HandleFunc(ctx.Base+"/answer", ctx.answerHandler)
|
||||
ctx.mux.HandleFunc(ctx.Base+"/content/", ctx.contentHandler)
|
||||
ctx.mux.HandleFunc(ctx.Base+"/puzzles.json", ctx.puzzlesHandler)
|
||||
ctx.mux.HandleFunc(ctx.Base+"/points.json", ctx.pointsHandler)
|
||||
ctx.mux.HandleFunc(ctx.Base+"/current_manifest.json", ctx.manifestHandler)
|
||||
}
|
||||
|
|
@ -1,250 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"log"
|
||||
"math/rand"
|
||||
"net/http"
|
||||
"os"
|
||||
"path"
|
||||
"strings"
|
||||
"sync"
|
||||
"time"
|
||||
)
|
||||
|
||||
type RuntimeConfig struct {
|
||||
export_manifest bool
|
||||
}
|
||||
|
||||
type Instance struct {
|
||||
Base string
|
||||
MothballDir string
|
||||
PuzzlesDir string
|
||||
StateDir string
|
||||
ThemeDir string
|
||||
AttemptInterval time.Duration
|
||||
UseXForwarded bool
|
||||
|
||||
Runtime RuntimeConfig
|
||||
|
||||
categories map[string]*Mothball
|
||||
MaxPointsUnlocked map[string]int
|
||||
update chan bool
|
||||
jPuzzleList []byte
|
||||
jPointsLog []byte
|
||||
nextAttempt map[string]time.Time
|
||||
nextAttemptMutex *sync.RWMutex
|
||||
mux *http.ServeMux
|
||||
}
|
||||
|
||||
func (ctx *Instance) Initialize() error {
|
||||
// Roll over and die if directories aren't even set up
|
||||
if _, err := os.Stat(ctx.MothballDir); err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := os.Stat(ctx.StateDir); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
ctx.Base = strings.TrimRight(ctx.Base, "/")
|
||||
ctx.categories = map[string]*Zipfs{}
|
||||
ctx.update = make(chan bool, 10)
|
||||
ctx.nextAttempt = map[string]time.Time{}
|
||||
ctx.nextAttemptMutex = new(sync.RWMutex)
|
||||
ctx.mux = http.NewServeMux()
|
||||
|
||||
ctx.BindHandlers()
|
||||
ctx.MaybeInitialize()
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// Stuff people with mediocre handwriting could write down unambiguously, and can be entered without holding down shift
|
||||
const distinguishableChars = "234678abcdefhijkmnpqrtwxyz="
|
||||
|
||||
func mktoken() string {
|
||||
a := make([]byte, 8)
|
||||
for i := range a {
|
||||
char := rand.Intn(len(distinguishableChars))
|
||||
a[i] = distinguishableChars[char]
|
||||
}
|
||||
return string(a)
|
||||
}
|
||||
|
||||
func (ctx *Instance) MaybeInitialize() {
|
||||
// Only do this if it hasn't already been done
|
||||
if _, err := os.Stat(ctx.StatePath("initialized")); err == nil {
|
||||
return
|
||||
}
|
||||
log.Print("initialized file missing, re-initializing")
|
||||
|
||||
// Remove any extant control and state files
|
||||
os.Remove(ctx.StatePath("until"))
|
||||
os.Remove(ctx.StatePath("disabled"))
|
||||
os.Remove(ctx.StatePath("points.log"))
|
||||
|
||||
os.RemoveAll(ctx.StatePath("points.tmp"))
|
||||
os.RemoveAll(ctx.StatePath("points.new"))
|
||||
os.RemoveAll(ctx.StatePath("teams"))
|
||||
|
||||
// Make sure various subdirectories exist
|
||||
os.Mkdir(ctx.StatePath("points.tmp"), 0755)
|
||||
os.Mkdir(ctx.StatePath("points.new"), 0755)
|
||||
os.Mkdir(ctx.StatePath("teams"), 0755)
|
||||
|
||||
// Preseed available team ids if file doesn't exist
|
||||
if f, err := os.OpenFile(ctx.StatePath("teamids.txt"), os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0644); err == nil {
|
||||
defer f.Close()
|
||||
for i := 0; i <= 100; i += 1 {
|
||||
fmt.Fprintln(f, mktoken())
|
||||
}
|
||||
}
|
||||
|
||||
// Create initialized file that signals whether we're set up
|
||||
f, err := os.OpenFile(ctx.StatePath("initialized"), os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0644)
|
||||
if err != nil {
|
||||
log.Print(err)
|
||||
}
|
||||
defer f.Close()
|
||||
fmt.Fprintln(f, "Remove this file to reinitialize the contest")
|
||||
}
|
||||
|
||||
func pathCleanse(parts []string) string {
|
||||
clean := make([]string, len(parts))
|
||||
for i := range parts {
|
||||
part := parts[i]
|
||||
part = strings.TrimLeft(part, ".")
|
||||
if p := strings.LastIndex(part, "/"); p >= 0 {
|
||||
part = part[p+1:]
|
||||
}
|
||||
clean[i] = part
|
||||
}
|
||||
return path.Join(clean...)
|
||||
}
|
||||
|
||||
func (ctx Instance) MothballPath(parts ...string) string {
|
||||
tail := pathCleanse(parts)
|
||||
return path.Join(ctx.MothballDir, tail)
|
||||
}
|
||||
|
||||
func (ctx *Instance) StatePath(parts ...string) string {
|
||||
tail := pathCleanse(parts)
|
||||
return path.Join(ctx.StateDir, tail)
|
||||
}
|
||||
|
||||
func (ctx *Instance) ThemePath(parts ...string) string {
|
||||
tail := pathCleanse(parts)
|
||||
return path.Join(ctx.ThemeDir, tail)
|
||||
}
|
||||
|
||||
func (ctx *Instance) TooFast(teamId string) bool {
|
||||
now := time.Now()
|
||||
|
||||
ctx.nextAttemptMutex.RLock()
|
||||
next, _ := ctx.nextAttempt[teamId]
|
||||
ctx.nextAttemptMutex.RUnlock()
|
||||
|
||||
ctx.nextAttemptMutex.Lock()
|
||||
ctx.nextAttempt[teamId] = now.Add(ctx.AttemptInterval)
|
||||
ctx.nextAttemptMutex.Unlock()
|
||||
|
||||
return now.Before(next)
|
||||
}
|
||||
|
||||
func (ctx *Instance) PointsLog(teamId string) AwardList {
|
||||
awardlist := AwardList{}
|
||||
|
||||
fn := ctx.StatePath("points.log")
|
||||
|
||||
f, err := os.Open(fn)
|
||||
if err != nil {
|
||||
log.Printf("Unable to open %s: %s", fn, err)
|
||||
return awardlist
|
||||
}
|
||||
defer f.Close()
|
||||
|
||||
scanner := bufio.NewScanner(f)
|
||||
for scanner.Scan() {
|
||||
line := scanner.Text()
|
||||
cur, err := ParseAward(line)
|
||||
if err != nil {
|
||||
log.Printf("Skipping malformed award line %s: %s", line, err)
|
||||
continue
|
||||
}
|
||||
if len(teamId) > 0 && cur.TeamId != teamId {
|
||||
continue
|
||||
}
|
||||
awardlist = append(awardlist, cur)
|
||||
}
|
||||
|
||||
return awardlist
|
||||
}
|
||||
|
||||
// AwardPoints gives points to teamId in category.
|
||||
// It first checks to make sure these are not duplicate points.
|
||||
// This is not a perfect check, you can trigger a race condition here.
|
||||
// It's just a courtesy to the user.
|
||||
// The maintenance task makes sure we never have duplicate points in the log.
|
||||
func (ctx *Instance) AwardPoints(teamId, category string, points int) error {
|
||||
a := Award{
|
||||
When: time.Now(),
|
||||
TeamId: teamId,
|
||||
Category: category,
|
||||
Points: points,
|
||||
}
|
||||
|
||||
_, err := ctx.TeamName(teamId)
|
||||
if err != nil {
|
||||
return fmt.Errorf("No registered team with this hash")
|
||||
}
|
||||
|
||||
for _, e := range ctx.PointsLog("") {
|
||||
if a.Same(e) {
|
||||
return fmt.Errorf("Points already awarded to this team in this category")
|
||||
}
|
||||
}
|
||||
|
||||
fn := fmt.Sprintf("%s-%s-%d", teamId, category, points)
|
||||
tmpfn := ctx.StatePath("points.tmp", fn)
|
||||
newfn := ctx.StatePath("points.new", fn)
|
||||
|
||||
if err := ioutil.WriteFile(tmpfn, []byte(a.String()), 0644); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if err := os.Rename(tmpfn, newfn); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
ctx.update <- true
|
||||
log.Printf("Award %s %s %d", teamId, category, points)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (ctx *Instance) OpenCategoryFile(category string, parts ...string) (io.ReadCloser, error) {
|
||||
mb, ok := ctx.categories[category]
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("No such category: %s", category)
|
||||
}
|
||||
|
||||
filename := path.Join(parts...)
|
||||
f, err := mb.Open(filename)
|
||||
return f, err
|
||||
}
|
||||
|
||||
func (ctx *Instance) ValidTeamId(teamId string) bool {
|
||||
ctx.nextAttemptMutex.RLock()
|
||||
_, ok := ctx.nextAttempt[teamId]
|
||||
ctx.nextAttemptMutex.RUnlock()
|
||||
|
||||
return ok
|
||||
}
|
||||
|
||||
func (ctx *Instance) TeamName(teamId string) (string, error) {
|
||||
teamNameBytes, err := ioutil.ReadFile(ctx.StatePath("teams", teamId))
|
||||
teamName := strings.TrimSpace(string(teamNameBytes))
|
||||
return teamName, err
|
||||
}
|
||||
|
|
@ -1,333 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"log"
|
||||
"os"
|
||||
"sort"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
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() {
|
||||
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 {
|
||||
filtered_puzzlemap := make([]PuzzleMap, 0, 30)
|
||||
completed := true
|
||||
|
||||
for _, pm := range mb.puzzlemap {
|
||||
filtered_puzzlemap = append(filtered_puzzlemap, pm)
|
||||
|
||||
if pm.Points > maxByCategory[catName] {
|
||||
completed = false
|
||||
maxByCategory[catName] = pm.Points
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if completed {
|
||||
filtered_puzzlemap = append(filtered_puzzlemap, PuzzleMap{0, ""})
|
||||
}
|
||||
|
||||
ret[catName] = filtered_puzzlemap
|
||||
}
|
||||
|
||||
// Cache the unlocked points for use in other functions
|
||||
ctx.MaxPointsUnlocked = maxByCategory
|
||||
|
||||
jpl, err := json.Marshal(ret)
|
||||
if err != nil {
|
||||
log.Printf("Marshalling puzzles.js: %v", err)
|
||||
return
|
||||
}
|
||||
ctx.jPuzzleList = jpl
|
||||
}
|
||||
|
||||
func (ctx *Instance) generatePointsLog(teamId string) []byte {
|
||||
var ret struct {
|
||||
Teams map[string]string `json:"teams"`
|
||||
Points []*Award `json:"points"`
|
||||
}
|
||||
ret.Teams = map[string]string{}
|
||||
ret.Points = ctx.PointsLog(teamId)
|
||||
|
||||
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 = "Rodney" // https://en.wikipedia.org/wiki/Rogue_(video_game)#Gameplay
|
||||
}
|
||||
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 {
|
||||
log.Printf("Marshalling points.js: %v", err)
|
||||
return nil
|
||||
}
|
||||
|
||||
if len(teamId) == 0 {
|
||||
ctx.jPointsLog = jpl
|
||||
}
|
||||
return jpl
|
||||
}
|
||||
|
||||
// maintenance runs
|
||||
func (ctx *Instance) tidy() {
|
||||
// Do they want to reset everything?
|
||||
ctx.MaybeInitialize()
|
||||
|
||||
// Check set config
|
||||
ctx.UpdateConfig()
|
||||
|
||||
// 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)
|
||||
}
|
||||
}
|
||||
|
||||
// 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)
|
||||
if !strings.HasSuffix(filename, ".mb") {
|
||||
continue
|
||||
}
|
||||
categoryName := strings.TrimSuffix(filename, ".mb")
|
||||
|
||||
if _, ok := ctx.categories[categoryName]; !ok {
|
||||
mb, err := OpenZipfs(filepath)
|
||||
if err != nil {
|
||||
log.Printf("Error opening %s: %s", filepath, err)
|
||||
continue
|
||||
}
|
||||
log.Printf("New category: %s", filename)
|
||||
ctx.categories[categoryName] = mb
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// readTeams reads in the list of team IDs,
|
||||
// so we can quickly validate them.
|
||||
func (ctx *Instance) readTeams() {
|
||||
filepath := ctx.StatePath("teamids.txt")
|
||||
teamids, err := os.Open(filepath)
|
||||
if err != nil {
|
||||
log.Printf("Error openining %s: %s", filepath, err)
|
||||
return
|
||||
}
|
||||
defer teamids.Close()
|
||||
|
||||
// List out team IDs
|
||||
newList := map[string]bool{}
|
||||
scanner := bufio.NewScanner(teamids)
|
||||
for scanner.Scan() {
|
||||
teamId := scanner.Text()
|
||||
if (teamId == "..") || strings.ContainsAny(teamId, "/") {
|
||||
log.Printf("Dangerous team ID dropped: %s", teamId)
|
||||
continue
|
||||
}
|
||||
newList[scanner.Text()] = true
|
||||
}
|
||||
|
||||
// For any new team IDs, set their next attempt time to right now
|
||||
now := time.Now()
|
||||
added := 0
|
||||
for k, _ := range newList {
|
||||
ctx.nextAttemptMutex.RLock()
|
||||
_, ok := ctx.nextAttempt[k]
|
||||
ctx.nextAttemptMutex.RUnlock()
|
||||
|
||||
if !ok {
|
||||
ctx.nextAttemptMutex.Lock()
|
||||
ctx.nextAttempt[k] = now
|
||||
ctx.nextAttemptMutex.Unlock()
|
||||
|
||||
added += 1
|
||||
}
|
||||
}
|
||||
|
||||
// For any removed team IDs, remove them
|
||||
removed := 0
|
||||
ctx.nextAttemptMutex.Lock() // XXX: This could be less of a cludgel
|
||||
for k, _ := range ctx.nextAttempt {
|
||||
if _, ok := newList[k]; !ok {
|
||||
delete(ctx.nextAttempt, k)
|
||||
}
|
||||
}
|
||||
ctx.nextAttemptMutex.Unlock()
|
||||
|
||||
if (added > 0) || (removed > 0) {
|
||||
log.Printf("Team IDs updated: %d added, %d removed", added, removed)
|
||||
}
|
||||
}
|
||||
|
||||
// collectPoints gathers up files in points.new/ and appends their contents to points.log,
|
||||
// removing each points.new/ file as it goes.
|
||||
func (ctx *Instance) collectPoints() {
|
||||
points := ctx.PointsLog("")
|
||||
|
||||
pointsFilename := ctx.StatePath("points.log")
|
||||
pointsNewFilename := ctx.StatePath("points.log.new")
|
||||
|
||||
// Yo, this is delicate.
|
||||
// If we have to return early, we must remove this file.
|
||||
// If the file's written and we move it successfully,
|
||||
// we need to remove all the little points files that built it.
|
||||
newPoints, err := os.OpenFile(pointsNewFilename, os.O_CREATE|os.O_WRONLY|os.O_EXCL, 0644)
|
||||
if err != nil {
|
||||
log.Printf("Can't append to points log: %s", err)
|
||||
return
|
||||
}
|
||||
|
||||
files, err := ioutil.ReadDir(ctx.StatePath("points.new"))
|
||||
if err != nil {
|
||||
log.Printf("Error reading packages: %s", err)
|
||||
}
|
||||
removearino := make([]string, 0, len(files))
|
||||
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
|
||||
}
|
||||
|
||||
duplicate := false
|
||||
for _, e := range points {
|
||||
if award.Same(e) {
|
||||
duplicate = true
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
if duplicate {
|
||||
log.Printf("Skipping duplicate points: %s", award.String())
|
||||
} else {
|
||||
points = append(points, award)
|
||||
}
|
||||
removearino = append(removearino, filename)
|
||||
}
|
||||
|
||||
sort.Stable(points)
|
||||
for _, point := range points {
|
||||
fmt.Fprintln(newPoints, point.String())
|
||||
}
|
||||
|
||||
newPoints.Close()
|
||||
|
||||
if err := os.Rename(pointsNewFilename, pointsFilename); err != nil {
|
||||
log.Printf("Unable to move %s to %s: %s", pointsFilename, pointsNewFilename, err)
|
||||
if err := os.Remove(pointsNewFilename); err != nil {
|
||||
log.Printf("Also couldn't remove %s: %s", pointsNewFilename, err)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
for _, filename := range removearino {
|
||||
if err := os.Remove(filename); err != nil {
|
||||
log.Printf("Unable to remove %s: %s", filename, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
|
||||
func (ctx *Instance) UpdateConfig() {
|
||||
// Handle export manifest
|
||||
if _, err := os.Stat(ctx.StatePath("export_manifest")); err == nil {
|
||||
if !ctx.Runtime.export_manifest {
|
||||
log.Print("Enabling manifest export")
|
||||
ctx.Runtime.export_manifest = true
|
||||
}
|
||||
} else if ctx.Runtime.export_manifest {
|
||||
log.Print("Disabling manifest export")
|
||||
ctx.Runtime.export_manifest = false
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// maintenance is the goroutine that runs a periodic maintenance task
|
||||
func (ctx *Instance) Maintenance(maintenanceInterval time.Duration) {
|
||||
for {
|
||||
if ctx.isEnabled() {
|
||||
ctx.tidy()
|
||||
ctx.readTeams()
|
||||
ctx.collectPoints()
|
||||
ctx.generatePuzzleList()
|
||||
ctx.generatePointsLog("")
|
||||
}
|
||||
select {
|
||||
case <-ctx.update:
|
||||
// log.Print("Forced update")
|
||||
case <-time.After(maintenanceInterval):
|
||||
// log.Print("Housekeeping...")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,92 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"flag"
|
||||
"log"
|
||||
"math/rand"
|
||||
"mime"
|
||||
"net/http"
|
||||
"time"
|
||||
)
|
||||
|
||||
func setup() error {
|
||||
rand.Seed(time.Now().UnixNano())
|
||||
return nil
|
||||
}
|
||||
|
||||
func main() {
|
||||
ctx := &Instance{}
|
||||
|
||||
flag.StringVar(
|
||||
&ctx.Base,
|
||||
"base",
|
||||
"/",
|
||||
"Base URL of this instance",
|
||||
)
|
||||
flag.StringVar(
|
||||
&ctx.MothballDir,
|
||||
"mothballs",
|
||||
"/mothballs",
|
||||
"Path to read mothballs",
|
||||
)
|
||||
flag.StringVar(
|
||||
&ctx.PuzzlesDir,
|
||||
"puzzles",
|
||||
"",
|
||||
"Path to read puzzle source trees",
|
||||
)
|
||||
flag.StringVar(
|
||||
&ctx.StateDir,
|
||||
"state",
|
||||
"/state",
|
||||
"Path to write state",
|
||||
)
|
||||
flag.StringVar(
|
||||
&ctx.ThemeDir,
|
||||
"theme",
|
||||
"/theme",
|
||||
"Path to static theme resources (HTML, images, css, ...)",
|
||||
)
|
||||
flag.DurationVar(
|
||||
&ctx.AttemptInterval,
|
||||
"attempt",
|
||||
500*time.Millisecond,
|
||||
"Per-team time required between answer attempts",
|
||||
)
|
||||
maintenanceInterval := flag.Duration(
|
||||
"maint",
|
||||
20*time.Second,
|
||||
"Time between maintenance tasks",
|
||||
)
|
||||
flag.BoolVar(
|
||||
&ctx.UseXForwarded,
|
||||
"x-forwarded-for",
|
||||
false,
|
||||
"Emit IPs from the X-Forwarded-For header in logs, when available, instead of the source IP. Use this when running behind a load-balancer or proxy",
|
||||
)
|
||||
listen := flag.String(
|
||||
"listen",
|
||||
":8080",
|
||||
"[host]:port to bind and listen",
|
||||
)
|
||||
flag.Parse()
|
||||
|
||||
if err := setup(); err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
err := ctx.Initialize()
|
||||
if err != nil {
|
||||
log.Fatal(err)
|
||||
}
|
||||
|
||||
// Add some MIME extensions
|
||||
// Doing this avoids decompressing a mothball entry twice per request
|
||||
mime.AddExtensionType(".json", "application/json")
|
||||
mime.AddExtensionType(".zip", "application/zip")
|
||||
|
||||
go ctx.Maintenance(*maintenanceInterval)
|
||||
|
||||
log.Printf("Listening on %s", *listen)
|
||||
log.Fatal(http.ListenAndServe(*listen, ctx))
|
||||
}
|
||||
Loading…
Reference in New Issue