func renderDefenseSelection(w http.ResponseWriter, r *http.Request, errorMessage string) {
template := template.New("").Funcs(templateHelpers)
_, err := template.ParseFiles("templates/setup_defense_selection.html")
if err != nil {
handleWebErr(w, err)
return
}
matches, err := db.GetMatchesByType("elimination")
if err != nil {
handleWebErr(w, err)
return
}
var unplayedMatches []Match
for _, match := range matches {
if match.Status != "complete" {
unplayedMatches = append(unplayedMatches, match)
}
}
data := struct {
*EventSettings
Matches []Match
DefenseNames map[string]string
ErrorMessage string
}{eventSettings, unplayedMatches, defenseNames, errorMessage}
err = template.ExecuteTemplate(w, "setup_defense_selection.html", data)
if err != nil {
handleWebErr(w, err)
return
}
}
// Shows the page to edit the results for a match.
func MatchReviewEditGetHandler(w http.ResponseWriter, r *http.Request) {
if !UserIsAdmin(w, r) {
return
}
match, matchResult, _, err := getMatchResultFromRequest(r)
if err != nil {
handleWebErr(w, err)
return
}
template, err := template.ParseFiles("templates/edit_match_result.html", "templates/base.html")
if err != nil {
handleWebErr(w, err)
return
}
matchResultJson, err := matchResult.serialize()
if err != nil {
handleWebErr(w, err)
return
}
data := struct {
*EventSettings
Match *Match
MatchResultJson *MatchResultDb
}{eventSettings, match, matchResultJson}
err = template.ExecuteTemplate(w, "base", data)
if err != nil {
handleWebErr(w, err)
return
}
}
// Renders the referee interface for assigning fouls.
func RefereeDisplayHandler(w http.ResponseWriter, r *http.Request) {
template := template.New("").Funcs(templateHelpers)
_, err := template.ParseFiles("templates/referee_display.html")
if err != nil {
handleWebErr(w, err)
return
}
match := mainArena.currentMatch
matchType := match.CapitalizedType()
red1 := mainArena.AllianceStations["R1"].team
if red1 == nil {
red1 = &Team{}
}
red2 := mainArena.AllianceStations["R2"].team
if red2 == nil {
red2 = &Team{}
}
red3 := mainArena.AllianceStations["R3"].team
if red3 == nil {
red3 = &Team{}
}
blue1 := mainArena.AllianceStations["B1"].team
if blue1 == nil {
blue1 = &Team{}
}
blue2 := mainArena.AllianceStations["B2"].team
if blue2 == nil {
blue2 = &Team{}
}
blue3 := mainArena.AllianceStations["B3"].team
if blue3 == nil {
blue3 = &Team{}
}
data := struct {
*EventSettings
MatchType string
MatchDisplayName string
Red1 *Team
Red2 *Team
Red3 *Team
Blue1 *Team
Blue2 *Team
Blue3 *Team
RedFouls []Foul
BlueFouls []Foul
RedCards map[string]string
BlueCards map[string]string
Rules []string
EntryEnabled bool
}{eventSettings, matchType, match.DisplayName, red1, red2, red3, blue1, blue2, blue3,
mainArena.redRealtimeScore.Fouls, mainArena.blueRealtimeScore.Fouls, mainArena.redRealtimeScore.Cards,
mainArena.blueRealtimeScore.Cards, rules,
!(mainArena.redRealtimeScore.FoulsCommitted && mainArena.blueRealtimeScore.FoulsCommitted)}
err = template.ExecuteTemplate(w, "referee_display.html", data)
if err != nil {
handleWebErr(w, err)
return
}
}
// Renders the scoring interface which enables input of scores in real-time.
func ScoringDisplayHandler(w http.ResponseWriter, r *http.Request) {
if !UserIsAdmin(w, r) {
return
}
vars := mux.Vars(r)
alliance := vars["alliance"]
if alliance != "red" && alliance != "blue" {
handleWebErr(w, fmt.Errorf("Invalid alliance '%s'.", alliance))
return
}
template, err := template.ParseFiles("templates/scoring_display.html", "templates/base.html")
if err != nil {
handleWebErr(w, err)
return
}
data := struct {
*EventSettings
Alliance string
}{eventSettings, alliance}
err = template.ExecuteTemplate(w, "base", data)
if err != nil {
handleWebErr(w, err)
return
}
}
// Renders the team number and status display shown above each alliance station.
func AllianceStationDisplayHandler(w http.ResponseWriter, r *http.Request) {
if !UserIsReader(w, r) {
return
}
template := template.New("").Funcs(templateHelpers)
_, err := template.ParseFiles("templates/alliance_station_display.html")
if err != nil {
handleWebErr(w, err)
return
}
displayId := ""
if _, ok := r.URL.Query()["displayId"]; ok {
// Register the display in memory by its ID so that it can be configured to a certain station.
displayId = r.URL.Query()["displayId"][0]
}
data := struct {
*EventSettings
DisplayId string
}{eventSettings, displayId}
err = template.ExecuteTemplate(w, "alliance_station_display.html", data)
if err != nil {
handleWebErr(w, err)
return
}
}
func executeTemplate(rootTemplte *template.Template, templateName string, machine datasource.Machine, hostAddr string) (string, error) {
template := rootTemplte.Lookup(templateName)
if template == nil {
return "", fmt.Errorf("template with name=%s wasn't found for root=%s",
templateName, rootTemplte)
}
buf := new(bytes.Buffer)
template.Funcs(map[string]interface{}{
"V": func(key string) string {
flag, err := machine.GetFlag(key)
if err != nil { // TODO excepts Not-Found
logging.Log(templatesDebugTag,
"Error while getting flag key=%s for machine=%s: %s",
key, machine.Name(), err)
return ""
}
return flag
},
"b64": func(text string) string {
return base64.StdEncoding.EncodeToString([]byte(text))
},
"b64template": func(templateName string) string {
text, err := executeTemplate(rootTemplte, templateName, machine, hostAddr)
if err != nil {
logging.Log(templatesDebugTag,
"Error while b64template for templateName=%s machine=%s: %s",
templateName, machine.Name(), err)
return ""
}
return base64.StdEncoding.EncodeToString([]byte(text))
},
})
ip, _ := machine.IP()
data := struct {
Mac string
IP string
Hostname string
Domain string
HostAddr string
}{
machine.Mac().String(),
ip.String(),
machine.Name(),
machine.Domain(),
hostAddr,
}
err := template.ExecuteTemplate(buf, templateName, &data)
if err != nil {
return "", err
}
str := buf.String()
str = strings.Trim(str, "\n")
return str, nil
}
// Shows the match play control interface.
func MatchPlayHandler(w http.ResponseWriter, r *http.Request) {
if !UserIsAdmin(w, r) {
return
}
practiceMatches, err := buildMatchPlayList("practice")
if err != nil {
handleWebErr(w, err)
return
}
qualificationMatches, err := buildMatchPlayList("qualification")
if err != nil {
handleWebErr(w, err)
return
}
eliminationMatches, err := buildMatchPlayList("elimination")
if err != nil {
handleWebErr(w, err)
return
}
template := template.New("").Funcs(templateHelpers)
_, err = template.ParseFiles("templates/match_play.html", "templates/base.html")
if err != nil {
handleWebErr(w, err)
return
}
matchesByType := map[string]MatchPlayList{"practice": practiceMatches,
"qualification": qualificationMatches, "elimination": eliminationMatches}
if currentMatchType == "" {
currentMatchType = "practice"
}
allowSubstitution := mainArena.currentMatch.Type != "qualification"
matchResult, err := db.GetMatchResultForMatch(mainArena.currentMatch.Id)
if err != nil {
handleWebErr(w, err)
return
}
isReplay := matchResult != nil
data := struct {
*EventSettings
MatchesByType map[string]MatchPlayList
CurrentMatchType string
Match *Match
AllowSubstitution bool
IsReplay bool
}{eventSettings, matchesByType, currentMatchType, mainArena.currentMatch, allowSubstitution, isReplay}
err = template.ExecuteTemplate(w, "base", data)
if err != nil {
handleWebErr(w, err)
return
}
}
// Serves the root page of Cheesy Arena.
func IndexHandler(w http.ResponseWriter, r *http.Request) {
template, err := template.ParseFiles("templates/index.html", "templates/base.html")
if err != nil {
handleWebErr(w, err)
return
}
data := struct {
*EventSettings
}{eventSettings}
err = template.ExecuteTemplate(w, "base", data)
if err != nil {
handleWebErr(w, err)
return
}
}
// Renders the announcer display which shows team info and scores for the current match.
func AnnouncerDisplayHandler(w http.ResponseWriter, r *http.Request) {
template := template.New("").Funcs(templateHelpers)
_, err := template.ParseFiles("templates/announcer_display.html", "templates/base.html")
if err != nil {
handleWebErr(w, err)
return
}
data := struct {
*EventSettings
}{eventSettings}
err = template.ExecuteTemplate(w, "base", data)
if err != nil {
handleWebErr(w, err)
return
}
}
// Shows the match review interface.
func MatchReviewHandler(w http.ResponseWriter, r *http.Request) {
if !UserIsReader(w, r) {
return
}
practiceMatches, err := buildMatchReviewList("practice")
if err != nil {
handleWebErr(w, err)
return
}
qualificationMatches, err := buildMatchReviewList("qualification")
if err != nil {
handleWebErr(w, err)
return
}
eliminationMatches, err := buildMatchReviewList("elimination")
if err != nil {
handleWebErr(w, err)
return
}
template, err := template.ParseFiles("templates/match_review.html", "templates/base.html")
if err != nil {
handleWebErr(w, err)
return
}
matchesByType := map[string][]MatchReviewListItem{"practice": practiceMatches,
"qualification": qualificationMatches, "elimination": eliminationMatches}
if currentMatchType == "" {
currentMatchType = "practice"
}
data := struct {
*EventSettings
MatchesByType map[string][]MatchReviewListItem
CurrentMatchType string
}{eventSettings, matchesByType, currentMatchType}
err = template.ExecuteTemplate(w, "base", data)
if err != nil {
handleWebErr(w, err)
return
}
}
// Renders the audience display to be chroma keyed over the video feed.
func AudienceDisplayHandler(w http.ResponseWriter, r *http.Request) {
if !UserIsReader(w, r) {
return
}
template := template.New("").Funcs(templateHelpers)
_, err := template.ParseFiles("templates/audience_display.html")
if err != nil {
handleWebErr(w, err)
return
}
data := struct {
*EventSettings
}{eventSettings}
err = template.ExecuteTemplate(w, "audience_display.html", data)
if err != nil {
handleWebErr(w, err)
return
}
}
// Renders the FTA diagnostic display.
func FtaDisplayHandler(w http.ResponseWriter, r *http.Request) {
if !UserIsAdmin(w, r) {
return
}
// Retrieve the next few matches to show which defenses they will require.
numUpcomingMatches := 3
matches, err := db.GetMatchesByType(mainArena.currentMatch.Type)
if err != nil {
handleWebErr(w, err)
return
}
var upcomingMatches []Match
for _, match := range matches {
if match.Status != "complete" {
upcomingMatches = append(upcomingMatches, match)
if len(upcomingMatches) == numUpcomingMatches {
break
}
}
}
template := template.New("").Funcs(templateHelpers)
_, err = template.ParseFiles("templates/fta_display.html", "templates/base.html")
if err != nil {
handleWebErr(w, err)
return
}
data := struct {
*EventSettings
UpcomingMatches []Match
DefenseNames map[string]string
}{eventSettings, upcomingMatches, defenseNames}
err = template.ExecuteTemplate(w, "base", data)
if err != nil {
handleWebErr(w, err)
return
}
}
func main() {
flag.Parse()
template, err := template.ParseGlob(pattern)
if err != nil {
fmt.Fprintln(os.Stderr, err.Error())
return
}
file, _ := os.Open(jsonFile)
buff := make([]byte, SIZE)
count, _ := file.Read(buff)
jsonData := buff[:count]
data := make(map[string]interface{})
if string(jsonData) != "" {
if err := json.Unmarshal(jsonData, &data); err != nil {
fmt.Fprintln(os.Stderr, err.Error())
return
}
}
template.ExecuteTemplate(os.Stdout, mainTemplate, data)
}
func executeTemplate(rootTemplte *template.Template, templateName string,
ds datasource.DataSource, machineInterface datasource.MachineInterface,
webServerAddr string) (string, error) {
template := rootTemplte.Lookup(templateName)
if template == nil {
return "", fmt.Errorf("template with name=%s wasn't found for root=%v",
templateName, rootTemplte)
}
mac := machineInterface.Mac().String()
buf := new(bytes.Buffer)
template.Funcs(map[string]interface{}{
"V": func(key string) string {
value, err := machineInterface.GetVariable(key)
if err != nil {
log.WithField("where", "templating.executeTemplate").WithError(err).Warn(
"error while GetVariable")
}
return value
},
"b64": func(text string) string {
return base64.StdEncoding.EncodeToString([]byte(text))
},
"b64template": func(templateName string) string {
text, err := executeTemplate(rootTemplte, templateName, ds, machineInterface, webServerAddr)
if err != nil {
log.WithField("where", "templating.executeTemplate").WithError(err).Warnf(
"error while executeTemplate(templateName=%s machine=%s)",
templateName, mac)
return ""
}
return base64.StdEncoding.EncodeToString([]byte(text))
},
})
etcdMembers, _ := ds.EtcdMembers()
machine, err := machineInterface.Machine(false, nil)
if err != nil {
return "", err
}
data := struct {
Mac string
IP string
Hostname string
Domain string
WebServerAddr string
EtcdEndpoints string
}{
mac,
machine.IP.String(),
machineInterface.Hostname(),
ds.ClusterName(),
webServerAddr,
etcdMembers,
}
err = template.ExecuteTemplate(buf, templateName, &data)
if err != nil {
return "", err
}
str := buf.String()
str = strings.Trim(str, "\n")
return str, nil
}
func generateSvg(id string) ([]byte, error) {
template, err := template.New("node").Parse(`{{define "NODE"}}<<table border="0" cellspacing="0">
<tr ><td colspan="2" port="port1" border="1" bgcolor="lightblue">{{.Name}}</td></tr>
<tr ><td colspan="2" port="port2" border="1">{{.Target}}</td></tr>
<tr>
<td port="port2" border="1">{{.Engine}}</td>
<td port="port8" border="1">{{.Artifact}}</td>
</tr>
{{range .Args}}
<tr ><td colspan="2" port="port2" border="1">{{.}}</td></tr>
{{end}}
<tr ><td colspan="2" port="port2" border="1">{{.Outputs}}</td></tr>
</table>>{{end}}`)
// Creates a new graph
g := gographviz.NewGraph()
//g.AddAttr("", "rankdir", "LR")
// Now read the json input
var v orchestrator.Graph
resp, err := http.Get(fmt.Sprintf("%v/%v", OrchestratorUrl, id))
if err != nil {
return nil, err
}
defer resp.Body.Close()
//body, err := ioutil.ReadAll(resp.Body)
dec := json.NewDecoder(resp.Body)
if err := dec.Decode(&v); err != nil {
return nil, err
}
// Now for each node, create a node
g.SetName("Execution")
g.SetDir(true)
m := make(map[int]string)
// Now add every node
// Hack: If node has no Engine and no Artiface, and if sum(row)=sum(col)=0, skip it
for i, _ := range v.Nodes {
sumr := int64(0)
sumc := int64(0)
for r := 0; r < v.Digraph.Dim(); r++ {
sumr = sumr + v.Digraph.At(v.Nodes[i].ID, r)
sumc = sumc + v.Digraph.At(r, v.Nodes[i].ID)
}
if v.Nodes[i].Artifact == "" && sumr == 0 && sumc == 0 {
continue
}
tmp := make([]string, 2)
v.Nodes[i].Name = strings.Replace(v.Nodes[i].Name, "-", "_", -1)
tmp = strings.SplitAfter(v.Nodes[i].Name, ":")
v.Nodes[i].Name = strings.Replace(v.Nodes[i].Name, ":", "_", -1)
if len(tmp) != 2 {
tmp[0] = v.Nodes[i].Name
tmp = append(tmp, "")
}
var out bytes.Buffer
err = template.ExecuteTemplate(&out, "NODE", v.Nodes[i])
g.AddNode("G", v.Nodes[i].Name,
map[string]string{
"id": fmt.Sprintf("\"%v\"", strconv.Itoa(v.Nodes[i].ID)),
//"label": fmt.Sprintf("\"%v|%v\"", tmp[0], tmp[1]),
"label": out.String(),
//"label": fmt.Sprintf("\"%v|%v|%v|%v|%v\"", tmp[0], tmp[1], v.Nodes[i].Engine, v.Nodes[i].Artifact, v.Nodes[i].Args[:]),
"shape": "\"record\"",
"style": "\"rounded\"",
})
m[v.Nodes[i].ID] = v.Nodes[i].Name
}
for r := 0; r < v.Digraph.Dim(); r++ {
for c := 0; c < v.Digraph.Dim(); c++ {
if v.Digraph.At(r, c) != 0 {
//g.AddEdge(fmt.Sprintf("%v:%v", m[r], r), fmt.Sprintf("%v:%v", m[c], c), true, nil)
g.AddEdge(m[r], m[c], true, nil)
}
}
}
// Now add the edges
s := g.String()
d := exec.Command("dot", "-Tsvg")
// Set the stdin stdout and stderr of the dot subprocess
stdinOfDotProcess, err := d.StdinPipe()
if err != nil {
return nil, err
}
defer stdinOfDotProcess.Close() // the doc says subProcess.Wait will close it, but I'm not sure, so I kept this line
readCloser, err := d.StdoutPipe()
if err != nil {
return nil, err
}
d.Stderr = os.Stderr
// Actually run the dot subprocess
if err = d.Start(); err != nil { //Use start, not run
fmt.Println("An error occured: ", err) //replace with logger, or anything you want
}
fmt.Fprintf(stdinOfDotProcess, s)
stdinOfDotProcess.Close()
// Read from stdout and store it in the correct structure
var buf bytes.Buffer
buf.ReadFrom(readCloser)
err = d.Wait()
if err != nil {
fmt.Println(s)
}
return buf.Bytes(), nil
}
func main() {
var pattern string
flag.StringVar(&pattern, "p", "templates/*.html", "template pattern like template/*.html")
template, err := template.ParseGlob(pattern)
if err != nil {
fmt.Fprintln(os.Stderr, err.Error())
}
var mainTemplate string
flag.StringVar(&mainTemplate, "t", "index", "main template like index")
template.ExecuteTemplate(os.Stdout, mainTemplate, nil)
}