moth/cmd/mothd/server.go

package main

import (
	"fmt"
	"io"
	"strconv"
	"time"

	"github.com/dirtbags/moth/pkg/award"
)

// Category represents a puzzle category.
type Category struct {
	Name    string
	Puzzles []int
}

// ReadSeekCloser defines a struct that can read, seek, and close.
type ReadSeekCloser interface {
	io.Reader
	io.Seeker
	io.Closer
}

// Configuration stores information about server configuration.
type Configuration struct {
	Devel bool
}

// StateExport is given to clients requesting the current state.
type StateExport struct {
	Config    Configuration
	Messages  string
	TeamNames map[string]string
	PointsLog award.List
	Puzzles   map[string][]int
}

// PuzzleProvider defines what's required to provide puzzles.
type PuzzleProvider interface {
	Open(cat string, points int, path string) (ReadSeekCloser, time.Time, error)
	Inventory() []Category
	CheckAnswer(cat string, points int, answer string) (bool, error)
	Mothball(cat string, w io.Writer) error
	Maintainer
}

// ThemeProvider defines what's required to provide a theme.
type ThemeProvider interface {
	Open(path string) (ReadSeekCloser, time.Time, error)
	Maintainer
}

// StateProvider defines what's required to provide MOTH state.
type StateProvider interface {
	Messages() string
	PointsLog() award.List
	TeamName(teamID string) (string, error)
	SetTeamName(teamID, teamName string) error
	AwardPoints(teamID string, cat string, points int) error
	LogEvent(event, participantID, teamID, cat string, points int, extra ...string)
	Maintainer
}

// Maintainer is something that can be maintained.
type Maintainer interface {
	// Maintain is the maintenance loop.
	// It will only be called once, when execution begins.
	// It's okay to just exit if there's no maintenance to be done.
	Maintain(updateInterval time.Duration)

	// refresh is a shortcut used internally for testing
	refresh()
}

// MothServer gathers together the providers that make up a MOTH server.
type MothServer struct {
	PuzzleProviders []PuzzleProvider
	Theme           ThemeProvider
	State           StateProvider
	Config          Configuration
}

// NewMothServer returns a new MothServer.
func NewMothServer(config Configuration, theme ThemeProvider, state StateProvider, puzzleProviders ...PuzzleProvider) *MothServer {
	return &MothServer{
		Config:          config,
		PuzzleProviders: puzzleProviders,
		Theme:           theme,
		State:           state,
	}
}

// NewHandler returns a new http.RequestHandler for the provided teamID.
func (s *MothServer) NewHandler(participantID, teamID string) MothRequestHandler {
	return MothRequestHandler{
		MothServer:    s,
		participantID: participantID,
		teamID:        teamID,
	}
}

// MothRequestHandler provides http.RequestHandler for a MothServer.
type MothRequestHandler struct {
	*MothServer
	participantID string
	teamID        string
}

// PuzzlesOpen opens a file associated with a puzzle.
// BUG(neale): Multiple providers with the same category name are not detected or handled well.
func (mh *MothRequestHandler) PuzzlesOpen(cat string, points int, path string) (r ReadSeekCloser, ts time.Time, err error) {
	export := mh.exportStateIfRegistered(true)
	found := false
	for _, p := range export.Puzzles[cat] {
		if p == points {
			found = true
		}
	}
	if !found {
		return nil, time.Time{}, fmt.Errorf("puzzle does not exist or is locked")
	}

	// Try every provider until someone doesn't return an error
	for _, provider := range mh.PuzzleProviders {
		r, ts, err = provider.Open(cat, points, path)
		if err != nil {
			return r, ts, err
		}
	}

	// Log puzzle.json loads
	if path == "puzzle.json" {
		mh.State.LogEvent("load", mh.participantID, mh.teamID, cat, points)
	}

	return
}

// CheckAnswer returns an error if answer is not a correct answer for puzzle points in category cat
func (mh *MothRequestHandler) CheckAnswer(cat string, points int, answer string) error {
	correct := false
	for _, provider := range mh.PuzzleProviders {
		if ok, err := provider.CheckAnswer(cat, points, answer); err != nil {
			return err
		} else if ok {
			correct = true
		}
	}
	if !correct {
		mh.State.LogEvent("wrong", mh.participantID, mh.teamID, cat, points)
		return fmt.Errorf("incorrect answer")
	}

	mh.State.LogEvent("correct", mh.participantID, mh.teamID, cat, points)

	if _, err := mh.State.TeamName(mh.teamID); err != nil {
		return fmt.Errorf("invalid team ID")
	}
	if err := mh.State.AwardPoints(mh.teamID, cat, points); err != nil {
		return fmt.Errorf("error awarding points: %s", err)
	}

	return nil
}

// ThemeOpen opens a file from a theme.
func (mh *MothRequestHandler) ThemeOpen(path string) (ReadSeekCloser, time.Time, error) {
	return mh.Theme.Open(path)
}

// Register associates a team name with a team ID.
func (mh *MothRequestHandler) Register(teamName string) error {
	// BUG(neale): Register returns an error if a team is already registered; it may make more sense to return success
	if teamName == "" {
		return fmt.Errorf("empty team name")
	}
	mh.State.LogEvent("register", mh.participantID, mh.teamID, "", 0)
	return mh.State.SetTeamName(mh.teamID, teamName)
}

// ExportState anonymizes team IDs and returns StateExport.
// If a teamID has been specified for this MothRequestHandler,
// the anonymized team name for this teamID has the special value "self".
// If not, the puzzles list is empty.
func (mh *MothRequestHandler) ExportState() *StateExport {
	return mh.exportStateIfRegistered(false)
}

// Export state, replacing the team ID with "self" if the team is registered.
//
// If forceRegistered is true, go ahead and export it anyway
func (mh *MothRequestHandler) exportStateIfRegistered(forceRegistered bool) *StateExport {
	export := StateExport{}
	export.Config = mh.Config

	teamName, err := mh.State.TeamName(mh.teamID)
	registered := forceRegistered || mh.Config.Devel || (err == nil)

	export.Messages = mh.State.Messages()
	export.TeamNames = make(map[string]string)

	// Anonymize team IDs in points log, and write out team names
	pointsLog := mh.State.PointsLog()
	exportIDs := make(map[string]string)
	maxSolved := make(map[string]int)
	export.PointsLog = make(award.List, len(pointsLog))

	if registered {
		export.TeamNames["self"] = teamName
		exportIDs[mh.teamID] = "self"
	}
	for logno, awd := range pointsLog {
		if id, ok := exportIDs[awd.TeamID]; ok {
			awd.TeamID = id
		} else {
			exportID := strconv.Itoa(logno)
			name, _ := mh.State.TeamName(awd.TeamID)
			exportIDs[awd.TeamID] = exportID
			awd.TeamID = exportID
			export.TeamNames[exportID] = name
		}
		export.PointsLog[logno] = awd

		// Record the highest-value unlocked puzzle in each category
		if awd.Points > maxSolved[awd.Category] {
			maxSolved[awd.Category] = awd.Points
		}
	}

	export.Puzzles = make(map[string][]int)
	if registered {
		// We used to hand this out to everyone,
		// but then we got a bad reputation on some secretive blacklist,
		// and now the Navy can't register for events.
		for _, provider := range mh.PuzzleProviders {
			for _, category := range provider.Inventory() {
				// Append sentry (end of puzzles)
				allPuzzles := append(category.Puzzles, 0)

				max := maxSolved[category.Name]

				puzzles := make([]int, 0, len(allPuzzles))
				for i, val := range allPuzzles {
					puzzles = allPuzzles[:i+1]
					if !mh.Config.Devel && (val > max) {
						break
					}
				}
				export.Puzzles[category.Name] = puzzles
			}
		}
	}

	return &export
}

// Mothball generates a mothball for the given category.
func (mh *MothRequestHandler) Mothball(cat string, w io.Writer) error {
	var err error

	if !mh.Config.Devel {
		return fmt.Errorf("cannot mothball in production mode")
	}
	for _, provider := range mh.PuzzleProviders {
		if err = provider.Mothball(cat, w); err == nil {
			return nil
		}
	}
	return err
}