server/backend/main.go

package main

import (
	"flag"
	"fmt"
	"io/ioutil"
	"log"
	"math/rand"
	"os"
	"path"
	"strings"
	"time"

	"srs.epita.fr/fic-server/libfic"
	"srs.epita.fr/fic-server/settings"

	"gopkg.in/fsnotify.v1"
)

var TeamsDir string
var SubmissionDir string

func watchsubdir(watcher *fsnotify.Watcher, pathname string) error {
	log.Println("Watch new directory:", pathname)
	if err := watcher.Add(pathname); err != nil {
		return err
	}

	if ds, err := ioutil.ReadDir(pathname); err != nil {
		return err
	} else {
		for _, d := range ds {
			p := path.Join(pathname, d.Name())
			if d.IsDir() {
				if err := watchsubdir(watcher, p); err != nil {
					return err
				}
			} else if d.Mode().IsRegular() {
				go treat(p)
			}
		}
		return nil
	}
}

var lastRegeneration time.Time

func reloadSettings(config settings.FICSettings) {
	if lastRegeneration != config.Generation || fic.PartialValidation != config.PartialValidation || fic.UnlockedChallenges != !config.EnableExerciceDepend || fic.FirstBlood != config.FirstBlood || fic.SubmissionCostBase != config.SubmissionCostBase {
		lastRegeneration = config.Generation

		fic.PartialValidation = config.PartialValidation
		fic.UnlockedChallenges = !config.EnableExerciceDepend

		fic.FirstBlood = config.FirstBlood
		fic.SubmissionCostBase = config.SubmissionCostBase

		log.Println("Generating files...")
		go func() {
			genAll()
			log.Println("Full generation done")
		}()
	} else {
		log.Println("No change found. Skipping regeneration.")
	}
}

func main() {
	var dsn = flag.String("dsn", "fic:fic@/fic", "DSN to connect to the MySQL server")
	flag.StringVar(&SubmissionDir, "./submission", "./submissions", "Base directory where save submissions")
	flag.StringVar(&TeamsDir, "teams", "./TEAMS", "Base directory where save teams JSON files")
	flag.StringVar(&fic.FilesDir, "files", "/files", "Request path prefix to reach files")
	flag.Parse()

	log.SetPrefix("[backend] ")

	SubmissionDir = path.Clean(SubmissionDir)
	TeamsDir = path.Clean(TeamsDir)

	rand.Seed(time.Now().UnixNano())

	log.Println("Creating submission directory...")
	if _, err := os.Stat(SubmissionDir); os.IsNotExist(err) {
		if err := os.MkdirAll(SubmissionDir, 0777); err != nil {
			log.Fatal("Unable to create submission directory: ", err)
		}
	}

	log.Println("Opening DB...")
	if err := fic.DBInit(fmt.Sprintf("%s?parseTime=true", *dsn)); err != nil {
		log.Fatal("Cannot open the database: ", err)
	}
	defer fic.DBClose()

	// Load configuration
	settings.LoadAndWatchSettings(path.Join(TeamsDir, settings.SettingsFile), reloadSettings)

	log.Println("Registering directory events...")
	watcher, err := fsnotify.NewWatcher()
	if err != nil {
		log.Fatal(err)
	}
	defer watcher.Close()

	if err := watchsubdir(watcher, SubmissionDir); err != nil {
		log.Fatal(err)
	}

	for {
		select {
		case ev := <-watcher.Events:
			if ev.Op & fsnotify.Create == fsnotify.Create {
				// Register new subdirectory
				if d, err := os.Stat(ev.Name); err == nil && d.IsDir() {
					if err := watchsubdir(watcher, ev.Name); err != nil {
						log.Println(err)
					}
				}
			} else if ev.Op & fsnotify.Write == fsnotify.Write {
				go treat(ev.Name)
			}
		case err := <-watcher.Errors:
			log.Println("error:", err)
		}
	}
}

func treat(raw_path string) {
	// Extract
	spath := strings.Split(strings.TrimPrefix(raw_path, SubmissionDir), "/")

	if len(spath) == 3 {
		if spath[1] == "_registration" {
			treatRegistration(raw_path)
		} else if team, err := fic.GetTeamByInitialName(spath[1]); err != nil {
			log.Println("[ERR]", err)
		} else if spath[2] == "name" {
			treatRename(raw_path, team)
		} else if spath[2] == "hint" {
			treatOpeningHint(raw_path, team)
		} else {
			treatSubmission(raw_path, team, spath[2])
		}
	} else {
		log.Println("Invalid new file:", raw_path)
	}
}