| // Copyright 2015 The Vanadium 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 |
| |
| import ( |
| "encoding/json" |
| "encoding/xml" |
| "fmt" |
| "html" |
| "io/ioutil" |
| "net/http" |
| "net/url" |
| "os" |
| "path/filepath" |
| "regexp" |
| "sort" |
| "strings" |
| "text/template" |
| |
| "v.io/jiri" |
| "v.io/jiri/collect" |
| "v.io/jiri/runutil" |
| "v.io/x/devtools/internal/cache" |
| "v.io/x/devtools/internal/test" |
| "v.io/x/devtools/internal/xunit" |
| ) |
| |
| const ( |
| resultsBucket = "gs://vanadium-test-results" |
| multiPartOutputNote = ` |
| ################################################################################### |
| THIS TEST HAS BEEN DIVIDED INTO MULTIPLE PARTS THAT HAVE BEEN EXECUTED IN PARALLEL. |
| THE OUTPUT BELOW IS THE CONCATENATION OF THOSE OUTPUTS. |
| ################################################################################### |
| ` |
| ) |
| |
| type summaryData struct { |
| Number string |
| OSJobs []osJobs |
| } |
| |
| type osJobs struct { |
| Jobs []job |
| OSName string |
| } |
| |
| type job struct { |
| Name string |
| Arch string |
| PartIndex int |
| HasGo32BitTest bool |
| Result bool |
| FailedTests []failedTest |
| } |
| |
| type failedTest struct { |
| Suite string |
| ClassName string |
| TestCase string |
| PartIndex int |
| } |
| |
| type aggregatedPartsData struct { |
| result bool |
| failedTests []failedTest |
| output string |
| } |
| |
| var go32BitTests = map[string]struct{}{ |
| "vanadium-go-build": struct{}{}, |
| "vanadium-go-test": struct{}{}, |
| } |
| |
| var summaryTemplate = template.Must(template.New("summary").Parse(` |
| {{ $n := .Number }} |
| <!DOCTYPE html> |
| <html> |
| <head> |
| <title>Presubmit #{{ $n }} Summary</title> |
| <link rel="stylesheet" href="/static/dashboard.css"> |
| </head> |
| <body> |
| <h1>Presubmit #{{ $n }} Summary</h1> |
| <ul> |
| {{ range $osJobs := .OSJobs }} |
| <h2 class="os-label">{{ $osJobs.OSName }}</h2> |
| <ul class="job-list"> |
| {{ range $job := .Jobs }} |
| <li> |
| {{ if $job.Result }} |
| <span class="label-pass">PASS</span> |
| {{ else }} |
| <span class="label-fail">FAIL</span> |
| {{ end }} |
| <a target="_blank" href="index.html?type=presubmit&n={{ $n }}&arch={{ $job.Arch }}&os={{ $osJobs.OSName }}&job={{ $job.Name }}">{{ $job.Name }}</a> |
| {{ if $job.HasGo32BitTest }} |
| <span class="label-arch">{{ $job.Arch }}</span> |
| {{ end }} |
| {{ if gt (len $job.FailedTests) 0 }} |
| <ol class="test-list"> |
| {{ range $failedTest := $job.FailedTests }} |
| <li> |
| <a target="_blank" href="index.html?type=presubmit&n={{ $n }}&arch={{ $job.Arch }}&os={{ $osJobs.OSName }}&job={{ $job.Name }}&part={{ $failedTest.PartIndex }}&suite={{ $failedTest.Suite }}&class={{ $failedTest.ClassName }}&test={{ $failedTest.TestCase }}">{{ $failedTest.ClassName }}/{{ $failedTest.TestCase }}</a> |
| </li> |
| {{ end }} |
| </ol> |
| {{ end }} |
| </li> |
| {{ end }} |
| </ul> |
| {{ end }} |
| </ul> |
| </body> |
| </html> |
| `)) |
| |
| type jobData struct { |
| Job string |
| OSName string |
| Arch string |
| PartIndex string |
| Number string |
| Output string |
| Result bool |
| FailedTests []failedTest |
| } |
| |
| var jobTemplate = template.Must(template.New("job").Funcs(templateFuncMap).Parse(` |
| {{ $n := .Number }} |
| {{ $osName := .OSName }} |
| {{ $arch := .Arch }} |
| {{ $jobName := .Job }} |
| <!DOCTYPE html> |
| <html> |
| <head> |
| <title>Presubmit #{{ $n }} Job Details</title> |
| <link rel="stylesheet" href="/static/dashboard.css"> |
| </head> |
| <body> |
| <h1>Presubmit #{{ $n }} Job Details</h1> |
| <table class="param-table"> |
| <tr><th class="param-table-name-col"></th><th></th></tr> |
| <tr><td>OS</td><td>{{ $osName }}</td></tr> |
| <tr><td>Arch</td><td>{{ $arch }}</td></tr> |
| <tr><td>Job</td><td>{{ $jobName }}</td></tr> |
| </table> |
| <br> |
| <a href="index.html?type=presubmit&n={{ $n }}">Back to Summary</a> |
| {{ if .Result }} |
| <h2 class="label-pass-large">PASS</h2> |
| {{ else }} |
| <h2 class="label-fail-large">FAIL</h2> |
| <ol class="test-list2"> |
| {{ range $failedTest := .FailedTests }} |
| <li> |
| <a target="_blank" href="index.html?type=presubmit&n={{ $n }}&arch={{ $arch }}&os={{ $osName }}&job={{ $jobName }}&part={{ $failedTest.PartIndex }}&suite={{ $failedTest.Suite }}&class={{ $failedTest.ClassName }}&test={{ $failedTest.TestCase }}">{{ $failedTest.ClassName }}/{{ $failedTest.TestCase }}</a> |
| </li> |
| {{ end }} |
| </ol> |
| {{ end }} |
| <h2>Console Output:</h2> |
| <pre>{{ colors .Output }}</pre> |
| </body> |
| </html> |
| `)) |
| |
| type testData struct { |
| Job string |
| OSName string |
| Arch string |
| Number string |
| TestCase xunit.TestCase |
| } |
| |
| var testTemplate = template.Must(template.New("test").Funcs(templateFuncMap).Parse(` |
| {{ $n := .Number }} |
| <!DOCTYPE html> |
| <html> |
| <head> |
| <title>Presubmit #{{ $n }} Test Details</title> |
| <link rel="stylesheet" href="/static/dashboard.css"> |
| </head> |
| <body> |
| <h1>Presubmit #{{ $n }} Test Details</h1> |
| <table class="param-table"> |
| <tr><th class="param-table-name-col"></th><th></th></tr> |
| <tr><td>OS</td><td>{{ .OSName }}</td></tr> |
| <tr><td>Arch</td><td>{{ .Arch }}</td></tr> |
| <tr><td>Job</td><td>{{ .Job }}</td></tr> |
| <tr><td>Suite</td><td>{{ .TestCase.Classname }}</td></tr> |
| <tr><td>Test</td><td>{{ .TestCase.Name }}</td></tr> |
| </table> |
| <br> |
| <a href="index.html?type=presubmit&n={{ $n }}">Back to Summary</a> |
| <br> |
| <a target="_blank" href="index.html?type=presubmit&n={{ .Number}}&arch={{ .Arch }}&os={{ .OSName }}&job={{ .Job }}">Console Log</a> |
| {{ if eq (len .TestCase.Failures) 0 }} |
| <h2 class="label-pass-large">PASS</h2> |
| {{ else }} |
| <h2 class="label-fail-large">FAIL</h2> |
| <h2>Failures:</h2> |
| <ul> |
| {{ range $failure := .TestCase.Failures }} |
| {{ if $failure.Message }} |
| <li> {{ $failure.Message }}: <br/> |
| {{ else }} |
| <li> Failure: <br/> |
| {{ end }} |
| <pre>{{ colors $failure.Data }}</pre> |
| </li> |
| {{ end }} |
| </ul> |
| {{ end }} |
| </body> |
| </html> |
| `)) |
| |
| var templateFuncMap = template.FuncMap{ |
| "colors": ansiColorsToHTML, |
| } |
| |
| type ansiColor struct { |
| code string |
| style string |
| } |
| |
| type params struct { |
| arch string |
| job string |
| osName string |
| partIndex string |
| testCase string |
| testClass string |
| testSuite string |
| } |
| |
| var ( |
| ansiColors = []ansiColor{ |
| ansiColor{"30", "color:black"}, |
| ansiColor{"31", "color:red"}, |
| ansiColor{"32", "color:green"}, |
| ansiColor{"33", "color:yellow"}, |
| ansiColor{"34", "color:blue"}, |
| ansiColor{"35", "color:magenta"}, |
| ansiColor{"36", "color:cyan"}, |
| ansiColor{"37", "color:black"}, |
| ansiColor{"40", "background-color:black"}, |
| ansiColor{"41", "background-color:red"}, |
| ansiColor{"42", "background-color:green"}, |
| ansiColor{"43", "background-color:yellow"}, |
| ansiColor{"44", "background-color:blue"}, |
| ansiColor{"45", "background-color:magenta"}, |
| ansiColor{"46", "background-color:cyan"}, |
| ansiColor{"47", "background-color:black"}, |
| } |
| ) |
| |
| func ansiColorsToHTML(text string) (string, error) { |
| escapedText := html.EscapeString(text) |
| for _, ansi := range ansiColors { |
| re, err := regexp.Compile(fmt.Sprintf(`\[0;%sm(.*)\[0m`, ansi.code)) |
| if err != nil { |
| return "", err |
| } |
| escapedText = re.ReplaceAllString(escapedText, fmt.Sprintf(`<font style="%s">$1</font>`, ansi.style)) |
| } |
| return escapedText, nil |
| } |
| |
| func displayPresubmitPage(jirix *jiri.X, w http.ResponseWriter, r *http.Request) (e error) { |
| // Set up the root directory. |
| root := cacheFlag |
| s := jirix.NewSeq() |
| if root == "" { |
| tmpDir, err := s.TempDir("", "") |
| if err != nil { |
| return err |
| } |
| defer collect.Error(func() error { return jirix.NewSeq().RemoveAll(tmpDir).Done() }, &e) |
| root = tmpDir |
| } |
| |
| // Fetch the presubmit test results. |
| // The dir structure is: |
| // <root>/presubmit/<n>/<os>/<arch>/<job>/<part>/... |
| n := r.Form.Get("n") |
| presubmitCacheDir := filepath.Join(root, "presubmit") |
| presubmitTars := filepath.Join(root, "presubmitTarFiles", n) |
| if err := s.MkdirAll(presubmitCacheDir, os.FileMode(0700)). |
| MkdirAll(presubmitTars, os.FileMode(0700)).Done(); err != nil { |
| return err |
| } |
| presubmitResultsDir := filepath.Join(presubmitCacheDir, n) |
| |
| if _, err := s.Stat(presubmitResultsDir); err != nil { |
| // Try downloading the tar file first. |
| tarFile := "results.tar.gz" |
| if _, err := cache.StoreGoogleStorageFile(jirix, presubmitTars, resultsBucketFlag+"/v0/presubmit/"+n, tarFile); err == nil { |
| if err := s. |
| Chdir(presubmitTars). |
| Run("tar", "-zxf", tarFile, "-C", presubmitCacheDir).Done(); err != nil { |
| return err |
| } |
| } else { |
| _, err := cache.StoreGoogleStorageFile(jirix, presubmitCacheDir, resultsBucketFlag+"/v0/presubmit", n) |
| if err != nil { |
| return err |
| } |
| } |
| |
| } |
| |
| params := extractParams(r) |
| switch { |
| case params.arch == "" || params.osName == "" || params.job == "": |
| // Generate the summary page. |
| data, err := params.generateSummaryData(jirix, n, presubmitResultsDir) |
| if err != nil { |
| return err |
| } |
| if err := summaryTemplate.Execute(w, data); err != nil { |
| return fmt.Errorf("Execute() failed: %v", err) |
| } |
| return nil |
| case params.testSuite == "": |
| // Generate the job detail page. |
| path := filepath.Join(presubmitResultsDir, params.osName, params.arch, params.job) |
| data, err := params.generateJobData(jirix, n, path) |
| if err != nil { |
| return err |
| } |
| if err := jobTemplate.Execute(w, data); err != nil { |
| return fmt.Errorf("Execute() failed: %v", err) |
| } |
| case (params.testClass != "" || params.testSuite != "") && params.testCase != "": |
| // Generate the test detail page. |
| path := filepath.Join(presubmitResultsDir, params.osName, params.arch, params.job, params.partIndex) |
| data, err := params.generateTestData(jirix, n, path) |
| if err != nil { |
| return err |
| } |
| if err := testTemplate.Execute(w, data); err != nil { |
| return fmt.Errorf("Execute() failed: %v", err) |
| } |
| default: |
| return fmt.Errorf("invalid combination of parameters") |
| } |
| return nil |
| } |
| |
| func extractParams(r *http.Request) params { |
| return params{ |
| arch: r.Form.Get("arch"), |
| job: r.Form.Get("job"), |
| osName: r.Form.Get("os"), |
| partIndex: r.Form.Get("part"), |
| testCase: r.Form.Get("test"), |
| testClass: r.Form.Get("class"), |
| testSuite: r.Form.Get("suite"), |
| } |
| } |
| |
| func (p params) generateSummaryData(jirix *jiri.X, n, path string) (*summaryData, error) { |
| data := summaryData{n, []osJobs{}} |
| osFileInfos, err := ioutil.ReadDir(path) |
| if err != nil { |
| return nil, fmt.Errorf("ReadDir(%v) failed: %v", path, err) |
| } |
| for _, osFileInfo := range osFileInfos { |
| osName := osFileInfo.Name() |
| osDir := filepath.Join(path, osName) |
| archFileInfos, err := ioutil.ReadDir(osDir) |
| if err != nil { |
| return nil, fmt.Errorf("ReadDir(%v) failed: %v", osDir, err) |
| } |
| o := osJobs{ |
| Jobs: []job{}, |
| OSName: osName, |
| } |
| jobsMap := map[string]job{} |
| jobKeys := []string{} |
| for _, archFileInfo := range archFileInfos { |
| arch := archFileInfo.Name() |
| archDir := filepath.Join(osDir, arch) |
| jobFileInfos, err := ioutil.ReadDir(archDir) |
| if err != nil { |
| return nil, fmt.Errorf("ReadDir(%v) failed: %v", archDir, err) |
| } |
| for _, jobFileInfo := range jobFileInfos { |
| jobName := jobFileInfo.Name() |
| jobDir := filepath.Join(archDir, jobName) |
| |
| // Aggregate job data for all its parts. |
| data, err := aggregateTestParts(jirix, jobDir, false) |
| if err != nil { |
| return nil, err |
| } |
| j := job{ |
| Name: jobName, |
| Arch: arch, |
| HasGo32BitTest: false, |
| Result: data.result, |
| FailedTests: data.failedTests, |
| } |
| if _, ok := go32BitTests[jobName]; ok { |
| j.HasGo32BitTest = true |
| } |
| jobKey := fmt.Sprintf("%s-%s", jobName, arch) |
| jobKeys = append(jobKeys, jobKey) |
| jobsMap[jobKey] = j |
| } |
| } |
| sort.Strings(jobKeys) |
| for _, jobKey := range jobKeys { |
| o.Jobs = append(o.Jobs, jobsMap[jobKey]) |
| } |
| data.OSJobs = append(data.OSJobs, o) |
| } |
| return &data, nil |
| } |
| |
| func (p params) generateJobData(jirix *jiri.X, n, path string) (*jobData, error) { |
| data, err := aggregateTestParts(jirix, path, true) |
| if err != nil { |
| return nil, err |
| } |
| return &jobData{ |
| Job: p.job, |
| OSName: p.osName, |
| Arch: p.arch, |
| Number: n, |
| Result: data.result, |
| FailedTests: data.failedTests, |
| Output: data.output, |
| }, nil |
| } |
| |
| func (p params) generateTestData(jirix *jiri.X, n, path string) (*testData, error) { |
| suitesBytes, err := jirix.NewSeq().ReadFile(filepath.Join(path, "xunit.xml")) |
| if err != nil { |
| return nil, err |
| } |
| var s xunit.TestSuites |
| if err := xml.Unmarshal(suitesBytes, &s); err != nil { |
| return nil, fmt.Errorf("Unmarshal(%v) failed: %v", string(suitesBytes), err) |
| } |
| var test xunit.TestCase |
| found := false |
| outer: |
| for _, ts := range s.Suites { |
| if ts.Name == p.testSuite { |
| for _, tc := range ts.Cases { |
| if tc.Name == p.testCase && tc.Classname == p.testClass { |
| test = tc |
| if test.Classname == "" { |
| test.Classname = ts.Name |
| } |
| found = true |
| break outer |
| } |
| } |
| } |
| } |
| if !found { |
| return nil, fmt.Errorf("failed to find the test %s in test suite %s", p.testCase, p.testSuite) |
| } |
| data := testData{ |
| Job: p.job, |
| OSName: p.osName, |
| Arch: p.arch, |
| Number: n, |
| TestCase: test, |
| } |
| return &data, nil |
| } |
| |
| func aggregateTestParts(jirix *jiri.X, jobDir string, aggregateOutput bool) (*aggregatedPartsData, error) { |
| // Read dirs for parts under the given job dir. |
| partFileInfos, err := ioutil.ReadDir(jobDir) |
| if err != nil { |
| return nil, fmt.Errorf("ReadDir(%v) failed: %v", jobDir, err) |
| } |
| |
| // Aggregate results and failed tests. |
| data := &aggregatedPartsData{ |
| result: true, |
| } |
| outputs := []string{} |
| s := jirix.NewSeq() |
| for index, partFileInfo := range partFileInfos { |
| part := partFileInfo.Name() |
| partDir := filepath.Join(jobDir, part) |
| |
| // Test result. |
| bytes, err := s.ReadFile(filepath.Join(partDir, "results")) |
| if err != nil { |
| return nil, err |
| } |
| var results map[string]test.Result |
| if err := json.Unmarshal(bytes, &results); err != nil { |
| return nil, fmt.Errorf("Unmarshal(%v) failed: %v", string(bytes), err) |
| } |
| // There should be only one test in the "results" file. |
| var r test.Result |
| for _, curResult := range results { |
| r = curResult |
| break |
| } |
| if r.Status != test.Passed { |
| data.result = false |
| } |
| |
| // Failed tests. |
| failedTests, err := parseFailedTests(jirix, partDir, index) |
| if err != nil { |
| return nil, err |
| } |
| data.failedTests = append(data.failedTests, failedTests...) |
| |
| // Console output. |
| if aggregateOutput { |
| outputBytes, err := s.ReadFile(filepath.Join(partDir, "output")) |
| if err != nil { |
| return nil, err |
| } |
| if len(partFileInfos) > 1 { |
| outputs = append(outputs, fmt.Sprintf("#### Part %d ####\n%s", index, string(outputBytes))) |
| } else { |
| outputs = append(outputs, string(outputBytes)) |
| } |
| } |
| } |
| data.output = strings.Join(outputs, "\n") |
| if len(partFileInfos) > 1 { |
| data.output = multiPartOutputNote + data.output |
| } |
| return data, nil |
| } |
| |
| func parseFailedTests(jirix *jiri.X, jobDir string, partIndex int) ([]failedTest, error) { |
| failedTests := []failedTest{} |
| suitesBytes, err := jirix.NewSeq().ReadFile(filepath.Join(jobDir, "xunit.xml")) |
| if runutil.IsNotExist(err) { |
| return failedTests, nil |
| } |
| if err != nil { |
| return nil, err |
| } |
| |
| var s xunit.TestSuites |
| if err := xml.Unmarshal(suitesBytes, &s); err != nil { |
| return nil, fmt.Errorf("Unmarshal(%v) failed: %v", string(suitesBytes), err) |
| } |
| for _, ts := range s.Suites { |
| for _, tc := range ts.Cases { |
| if len(tc.Failures) > 0 || len(tc.Errors) > 0 { |
| failedTests = append(failedTests, failedTest{ |
| Suite: ts.Name, |
| ClassName: tc.Classname, |
| TestCase: tc.Name, |
| PartIndex: partIndex, |
| }) |
| } |
| } |
| } |
| return failedTests, nil |
| } |
| |
| func validateValues(values url.Values) error { |
| ty := values.Get("type") |
| if ty == "presubmit" { |
| paramsToCheck := []string{} |
| if n := values.Get("n"); n == "" { |
| return fmt.Errorf("required parameter 'n' not found") |
| } else { |
| paramsToCheck = append(paramsToCheck, "n") |
| } |
| paramsToCheck = append(paramsToCheck, "job", "os", "arch", "suite", "test") |
| if err := checkPathTraversal(values, paramsToCheck); err != nil { |
| return err |
| } |
| } |
| return nil |
| } |
| |
| func checkPathTraversal(values url.Values, params []string) error { |
| for _, param := range params { |
| value := values.Get(param) |
| traversalCount := strings.Count(value, "..") |
| if traversalCount > 1 || (traversalCount == 1 && !strings.HasSuffix(value, "...")) { |
| return fmt.Errorf("parameter %q is not allowed to contain '..'", param) |
| } |
| } |
| return nil |
| } |
