fic
/
server
2
0
Fork 0
Code Issues Pull Requests 10 Releases Wiki Activity

remote-challenge-sync-airbus: WIP

This commit is contained in:
nemunaire 2022-06-07 16:06:36 +02:00
parent 6d9fd1ff12
commit 367e686e8a
5 changed files with 272 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
remote/challenge-sync-airbus/api.go
View File

@ -12,7 +12,7 @@ import (
type AirbusAPI struct {
BaseURL string
Token string
SessionID uint64
SessionID int64
}
func (a *AirbusAPI) request(method, endpoint string, data []byte, out interface{}) error {
@ -52,6 +52,11 @@ func (a *AirbusAPI) request(method, endpoint string, data []byte, out interface{
type AirbusUserId int64
func NewAirbusUserId(externalid string) AirbusUserId {
v, _ := strconv.ParseInt(externalid, 10, 64)
return AirbusUserId(v)
}
func (aui AirbusUserId) String() string {
return strconv.FormatInt(int64(aui), 10)
}
@ -112,8 +117,8 @@ func (a *AirbusAPI) GetChallengeFromName(name string) (*AirbusChallenge, error)
return nil, fmt.Errorf("unable to find challenge %q", name)
}
func (a *AirbusAPI) ValidateChallengeFromUser(user *AirbusUser, challenge *AirbusChallenge) (err error) {
err = a.request("GET", fmt.Sprintf("/sessions/%d/%s/%s/validate", a.SessionID, challenge.Id.String(), user.Id.String()), nil, nil)
func (a *AirbusAPI) ValidateChallengeFromUser(userId AirbusUserId, challengeId AirbusChallengeId) (err error) {
err = a.request("GET", fmt.Sprintf("/sessions/%d/%s/%s/validate", a.SessionID, challengeId.String(), userId.String()), nil, nil)
return
}
@ -123,9 +128,9 @@ type AirbusUserAwards struct {
Value int64 `json:"value"`
}
func (a *AirbusAPI) AwardUser(user *AirbusUser, value int64, message string) (err error) {
func (a *AirbusAPI) AwardUser(userId AirbusUserId, value int64, message string) (err error) {
awards := AirbusUserAwards{
UserId: user.Id,
UserId: userId,
Message: message,
Value: value,
}
@ -147,6 +152,18 @@ type AirbusStatsData struct {
BySessions []AirbusStatsSession `json:"by_sessions"`
}
func (s AirbusStatsData) GetSession(sessionId AirbusUUID) *AirbusStatsSession {
for _, session := range s.BySessions {
if session.UUID == sessionId {
return &session
}
}
return nil
}
type AirbusUUID string
type AirbusStatsSession struct {
UUID AirbusUUID `json:"uuid"`
Name string `json:"name"`
@ -154,6 +171,16 @@ type AirbusStatsSession struct {
TeamStats []AirbusTeamStats `json:"team_stats"`
}
func (s AirbusStatsSession) GetTeam(teamId AirbusUUID) *AirbusTeamStats {
for _, team := range s.TeamStats {
if team.UUID == teamId {
return &team
}
}
return nil
}
type AirbusTeamStats struct {
UUID AirbusUUID `json:"uuid"`
Name string `json:"name"`

39
remote/challenge-sync-airbus/bindings.go Normal file
View File

@ -0,0 +1,39 @@
package main
import (
"encoding/json"
"io/ioutil"
"os"
"srs.epita.fr/fic-server/libfic"
)
type AirbusExercicesBindings map[int64]AirbusChallengeId
func ReadExercicesBindings(ebpath string) (AirbusExercicesBindings, error) {
fd, err := os.Open(ebpath)
if err != nil {
return nil, err
}
defer fd.Close()
jdec := json.NewDecoder(fd)
var aeb AirbusExercicesBindings
err = jdec.Decode(&aeb)
return aeb, err
}
func getTeams(pathname string) (teams map[string]fic.ExportedTeam, err error) {
var cnt_raw []byte
if cnt_raw, err = ioutil.ReadFile(pathname); err != nil {
return
}
if err = json.Unmarshal(cnt_raw, &teams); err != nil {
return
}
return
}

87
remote/challenge-sync-airbus/main.go
View File

@ -4,12 +4,10 @@ import (
"flag"
"log"
"os"
"os/signal"
"path"
"path/filepath"
"strconv"
"syscall"
"gopkg.in/fsnotify.v1"
"time"
)
var (
@ -19,8 +17,12 @@ var (
func main() {
flag.StringVar(&TeamsDir, "teams", "./TEAMS", "Base directory where save teams JSON files")
var debugINotify = flag.Bool("debuginotify", false, "Show skipped inotofy events")
//var debugINotify = flag.Bool("debuginotify", false, "Show skipped inotofy events")
flag.BoolVar(&skipInitialSync, "skipinitialsync", skipInitialSync, "Skip the initial synchronization")
//watcher := flag.Bool("watch", false, "Enable daemon mode by watching the directory")
tspath := flag.String("timestamp-file", "./REMOTE/timestamp", "Path to the file storing the last timestamp")
exercicespath := flag.String("exercices-file", "./REMOTE/exercices-bindings.json", "Path to the file containing the ID bindings")
coeff := flag.Float64("global-coeff", 10.0, "Coefficient to use to multiply all scores before passing them to the other platform")
flag.Parse()
api := AirbusAPI{
@ -35,7 +37,7 @@ func main() {
}
if v, exists := os.LookupEnv("AIRBUS_SESSIONID"); exists {
var err error
api.SessionID, err = strconv.ParseUint(v, 10, 64)
api.SessionID, err = strconv.ParseInt(v, 10, 64)
if err != nil {
log.Fatal("AIRBUS_SESSIONID is invalid: ", err.Error())
}
@ -45,54 +47,43 @@ func main() {
TeamsDir = path.Clean(TeamsDir)
log.Println("Registering directory events...")
watcher, err := fsnotify.NewWatcher()
// Load the timestamp
ts, err := loadTS(*tspath)
if err != nil {
log.Fatal(err)
}
defer watcher.Close()
if err := watcher.Add(TeamsDir); err != nil {
log.Fatal(err)
log.Fatal("Unable to open timestamp file: ", err.Error())
}
if !skipInitialSync {
if _, err := os.Stat(path.Join(TeamsDir, "teams.json")); err == nil {
treatAll(path.Join(TeamsDir, "teams.json"))
}
// Load exercices bindings
exbindings, err := ReadExercicesBindings(*exercicespath)
if err != nil {
log.Fatal("Unable to open exercices bindings file: ", err.Error())
}
// Register SIGUSR1, SIGUSR2
interrupt := make(chan os.Signal, 1)
signal.Notify(interrupt, syscall.SIGHUP)
// Load teams.json
teamsbindings, err := getTeams(filepath.Join(TeamsDir, "teams.json"))
if err != nil {
log.Fatal("Unable to open teams bindings file: ", err.Error())
}
watchedNotify := fsnotify.Create
w := Walker{
LastSync: *ts,
Exercices: exbindings,
Teams: teamsbindings,
API: api,
Coeff: *coeff,
}
for {
select {
case <-interrupt:
log.Println("SIGHUP received, resyncing all teams' score...")
treatAll(path.Join(TeamsDir, "teams.json"))
log.Println("SIGHUP treated.")
case ev := <-watcher.Events:
if path.Base(ev.Name) == "teams.json" {
if ev.Op&watchedNotify == watchedNotify {
if *debugINotify {
log.Println("Treating event:", ev, "for", ev.Name)
}
go treatDiff(ev.Name)
} else if ev.Op&fsnotify.Write == fsnotify.Write {
log.Println("FSNOTIFY WRITE SEEN. Prefer looking at them, as it appears files are not atomically moved.")
watchedNotify = fsnotify.Write
go treatDiff(ev.Name)
} else if *debugINotify {
log.Println("Skipped teams.json event:", ev)
}
} else if *debugINotify {
log.Println("Skipped NON teams.json event:", ev, "for", ev.Name)
}
case err := <-watcher.Errors:
log.Println("error:", err)
}
// Iterate over teams scores
err = filepath.WalkDir(TeamsDir, w.WalkScore)
if err != nil {
log.Printf("Something goes wrong during walking")
}
// Update timestamp for the next time
w.LastSync = time.Now()
err = saveTS(*tspath, &w.LastSync)
if err != nil {
log.Fatal("Unable to save timestamp file: ", err.Error())
}
}

50
remote/challenge-sync-airbus/timestamp.go Normal file
View File

@ -0,0 +1,50 @@
package main
import (
"fmt"
"os"
"time"
)
func loadTS(tspath string) (timestamp *time.Time, err error) {
if _, err = os.Stat(tspath); os.IsNotExist(err) {
init := time.Unix(0, 0)
timestamp = &init
err = saveTS(tspath, timestamp)
return
}
var fd *os.File
fd, err = os.Open(tspath)
if err != nil {
return
}
defer fd.Close()
var init int64
_, err = fmt.Fscanf(fd, "%d", &init)
if err != nil {
return
}
tmp := time.Unix(init, 0)
timestamp = &tmp
return
}
func saveTS(tspath string, ts *time.Time) error {
fd, err := os.Create(tspath)
if err != nil {
return err
}
defer fd.Close()
_, err = fmt.Fprintf(fd, "%d", ts.Unix())
if err != nil {
return err
}
return nil
}

112
remote/challenge-sync-airbus/treat.go Normal file
View File

@ -0,0 +1,112 @@
package main
import (
"fmt"
"os"
"path/filepath"
"time"
"srs.epita.fr/fic-server/libfic"
)
type Walker struct {
LastSync time.Time
Exercices AirbusExercicesBindings
Teams map[string]fic.ExportedTeam
API AirbusAPI
Coeff float64
}
func (w *Walker) WalkScore(path string, d os.DirEntry, err error) error {
if filepath.Base(path) == "scores.json" {
mypath := filepath.Join(filepath.Dir(path), "my.json")
if _, err := os.Stat(mypath); !os.IsNotExist(err) {
// Read team ID
fdmy, err := os.Open(mypath)
if err != nil {
return err
}
defer fdmy.Close()
teammy, err := fic.ReadMyJSON(fdmy)
if err != nil {
return err
}
airbusTeamId := NewAirbusUserId(w.Teams[fmt.Sprintf("%d", teammy.Id)].ExternalId)
// Treat score grid
err = w.TreatScoreGrid(path, airbusTeamId)
if err != nil {
return err
}
// Balance scores
err = w.BalanceScore(int64(float64(teammy.Points)*w.Coeff), airbusTeamId)
if err != nil {
return err
}
}
}
return nil
}
func (w *Walker) TreatScoreGrid(path string, airbusTeamId AirbusUserId) error {
// Read score grid
fdscores, err := os.Open(path)
if err != nil {
return err
}
defer fdscores.Close()
teamscores, err := fic.ReadScoreGrid(fdscores)
if err != nil {
return err
}
// Found all new entries
for _, row := range teamscores {
if row.Time.After(w.LastSync) {
if row.Reason == "Validation" {
err = w.API.ValidateChallengeFromUser(airbusTeamId, w.Exercices[row.IdExercice])
} else {
err = w.API.AwardUser(airbusTeamId, int64(row.Points*row.Coeff*w.Coeff), row.Reason)
}
if err != nil {
return err
}
}
}
return nil
}
func (w *Walker) BalanceScore(score int64, airbusTeamId AirbusUserId) error {
// Read current score on other platform
stats, err := w.API.GetCurrentStats()
if err != nil {
fmt.Errorf("unable to retrieve current stats: %w", err)
}
my_session := stats.Data.GetSession(AirbusUUID(w.API.SessionID))
if my_session == nil {
return fmt.Errorf("session not found")
}
other_team := my_session.GetTeam(AirbusUUID(airbusTeamId))
if other_team == nil {
return fmt.Errorf("team %q not found", airbusTeamId)
}
other_score := other_team.Score
// Send diff to the platform
if other_score != score {
diff := score - other_score
return w.API.AwardUser(airbusTeamId, diff, "Équilibrage")
}
return nil
}