blob: 2b01a72dc6e4fb0df3f45f334eccef33937b130c [file] [log] [blame]
// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
package main
// This server runs along side the karma tests and listens for POST requests
// when any test case reports it has output for Gold. See legacy_test_reporter.js
// for the browser side part.
import (
"bytes"
"crypto/md5"
"encoding/base64"
"encoding/json"
"flag"
"fmt"
"image"
"image/png"
"io/ioutil"
"log"
"net/http"
"os"
"path"
"strings"
"sync"
"go.skia.org/infra/go/util"
"go.skia.org/infra/golden/go/jsonio"
"go.skia.org/infra/golden/go/types"
)
// This allows us to use upload_dm_results.py out of the box
const JSON_FILENAME = "dm.json"
var (
outDir = flag.String("out_dir", "/OUT/", "location to dump the Gold JSON and pngs")
port = flag.String("port", "8081", "Port to listen on.")
browser = flag.String("browser", "Chrome", "Browser Key")
buildBucketID = flag.String("buildbucket_build_id", "", "Buildbucket build id key")
builder = flag.String("builder", "", "Builder, like 'Test-Debian9-EMCC-GCE-CPU-AVX2-wasm-Debug-All-PathKit'")
compiledLanguage = flag.String("compiled_language", "wasm", "wasm or asm.js")
config = flag.String("config", "Release", "Configuration (e.g. Debug/Release) key")
gitHash = flag.String("git_hash", "-", "The git commit hash of the version being tested")
hostOS = flag.String("host_os", "Debian9", "OS Key")
issue = flag.String("issue", "", "ChangelistID (if tryjob)")
patchset = flag.Int("patchset", 0, "patchset (if tryjob)")
sourceType = flag.String("source_type", "pathkit", "Gold Source type, like pathkit,canvaskit")
)
// Received from the JS side.
type reportBody struct {
// e.g. "canvas" or "svg"
OutputType string `json:"output_type"`
// a base64 encoded PNG image.
Data string `json:"data"`
// a name describing the test. Should be unique enough to allow use of grep.
TestName string `json:"test_name"`
}
// The keys to be used at the top level for all Results.
var defaultKeys map[string]string
// contains all the results reported in through report_gold_data
var results []jsonio.Result
var resultsMutex sync.Mutex
func main() {
flag.Parse()
cpuGPU := "CPU"
if strings.Index(*builder, "-GPU-") != -1 {
cpuGPU = "GPU"
}
defaultKeys = map[string]string{
"arch": "WASM",
"browser": *browser,
"compiled_language": *compiledLanguage,
"compiler": "emsdk",
"configuration": *config,
"cpu_or_gpu": cpuGPU,
"cpu_or_gpu_value": "Browser",
"os": *hostOS,
"source_type": *sourceType,
}
results = []jsonio.Result{}
http.HandleFunc("/report_gold_data", reporter)
http.HandleFunc("/dump_json", dumpJSON)
fmt.Printf("Waiting for gold ingestion on port %s\n", *port)
log.Fatal(http.ListenAndServe(":"+*port, nil))
}
// reporter handles when the client reports a test has Gold output.
// It writes the corresponding PNG to disk and appends a Result, assuming
// no errors.
func reporter(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
http.Error(w, "Only POST accepted", 400)
return
}
defer util.Close(r.Body)
body, err := ioutil.ReadAll(r.Body)
if err != nil {
http.Error(w, "Malformed body", 400)
return
}
testOutput := reportBody{}
if err := json.Unmarshal(body, &testOutput); err != nil {
fmt.Println(err)
http.Error(w, "Could not unmarshal JSON", 400)
return
}
hash := ""
if hash, err = writeBase64EncodedPNG(testOutput.Data); err != nil {
fmt.Println(err)
http.Error(w, "Could not write image to disk", 500)
return
}
if _, err := w.Write([]byte("Accepted")); err != nil {
fmt.Printf("Could not write response: %s\n", err)
return
}
resultsMutex.Lock()
defer resultsMutex.Unlock()
results = append(results, jsonio.Result{
Digest: types.Digest(hash),
Key: map[string]string{
"name": testOutput.TestName,
"config": testOutput.OutputType,
},
Options: map[string]string{
"ext": "png",
},
})
}
// createOutputFile creates a file and set permissions correctly.
func createOutputFile(p string) (*os.File, error) {
outputFile, err := os.Create(p)
if err != nil {
return nil, fmt.Errorf("Could not open file %s on disk: %s", p, err)
}
// Make this accessible (and deletable) by all users
if err = outputFile.Chmod(0666); err != nil {
return nil, fmt.Errorf("Could not change permissions of file %s: %s", p, err)
}
return outputFile, nil
}
// dumpJSON writes out a JSON file with all the results, typically at the end of
// all the tests.
func dumpJSON(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
http.Error(w, "Only POST accepted", 400)
return
}
p := path.Join(*outDir, JSON_FILENAME)
outputFile, err := createOutputFile(p)
if err != nil {
fmt.Println(err)
http.Error(w, "Could not open json file on disk", 500)
return
}
defer util.Close(outputFile)
dmresults := jsonio.GoldResults{
GitHash: *gitHash,
Key: defaultKeys,
Results: results,
}
if *patchset > 0 {
dmresults.ChangelistID = *issue
dmresults.PatchsetOrder = *patchset
dmresults.CodeReviewSystem = "gerrit"
dmresults.ContinuousIntegrationSystem = "buildbucket"
dmresults.TryJobID = *buildBucketID
}
enc := json.NewEncoder(outputFile)
enc.SetIndent("", " ") // Make it human readable.
if err := enc.Encode(&dmresults); err != nil {
fmt.Println(err)
http.Error(w, "Could not write json to disk", 500)
return
}
fmt.Println("JSON Written")
}
// writeBase64EncodedPNG writes a PNG to disk and returns the md5 of the
// decoded PNG bytes and any error. This hash is what will be used as
// the gold digest and the file name.
func writeBase64EncodedPNG(data string) (string, error) {
// data starts with something like data:image/png;base64,[data]
// https://en.wikipedia.org/wiki/Data_URI_scheme
start := strings.Index(data, ",")
b := bytes.NewBufferString(data[start+1:])
pngReader := base64.NewDecoder(base64.StdEncoding, b)
pngBytes, err := ioutil.ReadAll(pngReader)
if err != nil {
return "", fmt.Errorf("Could not decode base 64 encoding %s", err)
}
// compute the hash of the pixel values, like DM does
img, err := png.Decode(bytes.NewBuffer(pngBytes))
if err != nil {
return "", fmt.Errorf("Not a valid png: %s", err)
}
hash := ""
switch img.(type) {
case *image.NRGBA:
i := img.(*image.NRGBA)
hash = fmt.Sprintf("%x", md5.Sum(i.Pix))
case *image.RGBA:
i := img.(*image.RGBA)
hash = fmt.Sprintf("%x", md5.Sum(i.Pix))
case *image.RGBA64:
i := img.(*image.RGBA64)
hash = fmt.Sprintf("%x", md5.Sum(i.Pix))
default:
return "", fmt.Errorf("Unknown type of image")
}
p := path.Join(*outDir, hash+".png")
outputFile, err := createOutputFile(p)
if err != nil {
return "", fmt.Errorf("Could not create png file %s: %s", p, err)
}
if _, err = outputFile.Write(pngBytes); err != nil {
util.Close(outputFile)
return "", fmt.Errorf("Could not write to file %s: %s", p, err)
}
return hash, outputFile.Close()
}