Golang程序
|
861行
|
22.77 KB
// Copyright 2017 syzkaller project authors. All rights reserved.
// Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.
package dash
import (
"bytes"
"fmt"
"net/http"
"sort"
"strconv"
"strings"
"time"
"github.com/google/syzkaller/dashboard/dashapi"
"github.com/google/syzkaller/pkg/email"
"golang.org/x/net/context"
"google.golang.org/appengine/datastore"
"google.golang.org/appengine/log"
)
// This file contains web UI http handlers.
func initHTTPHandlers() {
http.Handle("/", handlerWrapper(handleMain))
http.Handle("/bug", handlerWrapper(handleBug))
http.Handle("/text", handlerWrapper(handleText))
http.Handle("/x/.config", handlerWrapper(handleTextX(textKernelConfig)))
http.Handle("/x/log.txt", handlerWrapper(handleTextX(textCrashLog)))
http.Handle("/x/repro.syz", handlerWrapper(handleTextX(textReproSyz)))
http.Handle("/x/repro.c", handlerWrapper(handleTextX(textReproC)))
http.Handle("/x/patch.diff", handlerWrapper(handleTextX(textPatch)))
http.Handle("/x/error.txt", handlerWrapper(handleTextX(textError)))
}
type uiMain struct {
Header *uiHeader
Now time.Time
Log []byte
Managers []*uiManager
Jobs []*uiJob
BugNamespaces []*uiBugNamespace
}
type uiManager struct {
Namespace string
Name string
Link string
CurrentBuild *uiBuild
FailedBuildBugLink string
LastActive time.Time
LastActiveBad bool
CurrentUpTime time.Duration
MaxCorpus int64
MaxCover int64
TotalFuzzingTime time.Duration
TotalCrashes int64
TotalExecs int64
}
type uiBuild struct {
Time time.Time
SyzkallerCommit string
KernelAlias string
KernelCommit string
KernelConfigLink string
}
type uiBugPage struct {
Header *uiHeader
Now time.Time
Bug *uiBug
DupOf *uiBugGroup
Dups *uiBugGroup
Similar *uiBugGroup
SampleReport []byte
Crashes []*uiCrash
}
type uiBugNamespace struct {
Name string
Caption string
CoverLink string
FixedLink string
FixedCount int
Groups []*uiBugGroup
}
type uiBugGroup struct {
Now time.Time
Caption string
Fragment string
Namespace string
ShowNamespace bool
ShowPatch bool
ShowPatched bool
ShowStatus bool
ShowIndex int
Bugs []*uiBug
}
type uiBug struct {
Namespace string
Title string
NumCrashes int64
NumCrashesBad bool
FirstTime time.Time
LastTime time.Time
ReportedTime time.Time
ClosedTime time.Time
ReproLevel dashapi.ReproLevel
ReportingIndex int
Status string
Link string
ExternalLink string
CreditEmail string
Commits string
PatchedOn []string
MissingOn []string
NumManagers int
}
type uiCrash struct {
Manager string
Time time.Time
Maintainers string
LogLink string
ReportLink string
ReproSyzLink string
ReproCLink string
*uiBuild
}
type uiJob struct {
Created time.Time
BugLink string
ExternalLink string
User string
Reporting string
Namespace string
Manager string
BugTitle string
BugID string
KernelAlias string
KernelCommit string
PatchLink string
Attempts int
Started time.Time
Finished time.Time
CrashTitle string
CrashLogLink string
CrashReportLink string
ErrorLink string
Reported bool
}
// handleMain serves main page.
func handleMain(c context.Context, w http.ResponseWriter, r *http.Request) error {
var errorLog []byte
var managers []*uiManager
var jobs []*uiJob
if accessLevel(c, r) == AccessAdmin && r.FormValue("fixed") == "" {
var err error
errorLog, err = fetchErrorLogs(c)
if err != nil {
return err
}
managers, err = loadManagers(c)
if err != nil {
return err
}
jobs, err = loadRecentJobs(c)
if err != nil {
return err
}
}
bugNamespaces, err := fetchBugs(c, r)
if err != nil {
return err
}
data := &uiMain{
Header: commonHeader(c, r),
Now: timeNow(c),
Log: errorLog,
Managers: managers,
Jobs: jobs,
BugNamespaces: bugNamespaces,
}
return serveTemplate(w, "main.html", data)
}
// handleBug serves page about a single bug (which is passed in id argument).
func handleBug(c context.Context, w http.ResponseWriter, r *http.Request) error {
bug := new(Bug)
if id := r.FormValue("id"); id != "" {
bugKey := datastore.NewKey(c, "Bug", id, 0, nil)
if err := datastore.Get(c, bugKey, bug); err != nil {
return err
}
} else if extID := r.FormValue("extid"); extID != "" {
var err error
bug, _, err = findBugByReportingID(c, extID)
if err != nil {
return err
}
} else {
return ErrDontLog(fmt.Errorf("mandatory parameter id/extid is missing"))
}
accessLevel := accessLevel(c, r)
if err := checkAccessLevel(c, r, bug.sanitizeAccess(accessLevel)); err != nil {
return err
}
state, err := loadReportingState(c)
if err != nil {
return err
}
managers, err := managerList(c, bug.Namespace)
if err != nil {
return err
}
var dupOf *uiBugGroup
if bug.DupOf != "" {
dup := new(Bug)
if err := datastore.Get(c, datastore.NewKey(c, "Bug", bug.DupOf, 0, nil), dup); err != nil {
return err
}
if accessLevel >= dup.sanitizeAccess(accessLevel) {
dupOf = &uiBugGroup{
Now: timeNow(c),
Caption: "Duplicate of",
Bugs: []*uiBug{createUIBug(c, dup, state, managers)},
}
}
}
uiBug := createUIBug(c, bug, state, managers)
crashes, sampleReport, err := loadCrashesForBug(c, bug)
if err != nil {
return err
}
dups, err := loadDupsForBug(c, r, bug, state, managers)
if err != nil {
return err
}
similar, err := loadSimilarBugs(c, r, bug, state)
if err != nil {
return err
}
data := &uiBugPage{
Header: commonHeader(c, r),
Now: timeNow(c),
Bug: uiBug,
DupOf: dupOf,
Dups: dups,
Similar: similar,
SampleReport: sampleReport,
Crashes: crashes,
}
return serveTemplate(w, "bug.html", data)
}
// handleText serves plain text blobs (crash logs, reports, reproducers, etc).
func handleTextImpl(c context.Context, w http.ResponseWriter, r *http.Request, tag string) error {
var id int64
if x := r.FormValue("x"); x != "" {
xid, err := strconv.ParseUint(x, 16, 64)
if err != nil || xid == 0 {
return ErrDontLog(fmt.Errorf("failed to parse text id: %v", err))
}
id = int64(xid)
} else {
// Old link support, don't remove.
xid, err := strconv.ParseInt(r.FormValue("id"), 10, 64)
if err != nil || xid == 0 {
return ErrDontLog(fmt.Errorf("failed to parse text id: %v", err))
}
id = xid
}
crash, err := checkTextAccess(c, r, tag, id)
if err != nil {
return err
}
data, ns, err := getText(c, tag, id)
if err != nil {
return err
}
if err := checkAccessLevel(c, r, config.Namespaces[ns].AccessLevel); err != nil {
return err
}
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
// Unfortunately filename does not work in chrome on linux due to:
// https://bugs.chromium.org/p/chromium/issues/detail?id=608342
w.Header().Set("Content-Disposition", "inline; filename="+textFilename(tag))
if tag == textReproSyz {
// Add link to documentation and repro opts for syzkaller reproducers.
w.Write([]byte(syzReproPrefix))
if crash != nil {
fmt.Fprintf(w, "#%s\n", crash.ReproOpts)
}
}
w.Write(data)
return nil
}
func handleText(c context.Context, w http.ResponseWriter, r *http.Request) error {
return handleTextImpl(c, w, r, r.FormValue("tag"))
}
func handleTextX(tag string) contextHandler {
return func(c context.Context, w http.ResponseWriter, r *http.Request) error {
return handleTextImpl(c, w, r, tag)
}
}
func textFilename(tag string) string {
switch tag {
case textKernelConfig:
return ".config"
case textCrashLog:
return "log.txt"
case textCrashReport:
return "report.txt"
case textReproSyz:
return "repro.syz"
case textReproC:
return "repro.c"
case textPatch:
return "patch.diff"
case textError:
return "error.txt"
default:
return "text.txt"
}
}
func fetchBugs(c context.Context, r *http.Request) ([]*uiBugNamespace, error) {
state, err := loadReportingState(c)
if err != nil {
return nil, err
}
accessLevel := accessLevel(c, r)
onlyFixed := r.FormValue("fixed")
var res []*uiBugNamespace
for ns, cfg := range config.Namespaces {
if accessLevel < cfg.AccessLevel {
continue
}
if onlyFixed != "" && onlyFixed != ns {
continue
}
uiNamespace, err := fetchNamespaceBugs(c, accessLevel, ns, state, onlyFixed != "")
if err != nil {
return nil, err
}
res = append(res, uiNamespace)
}
sort.Sort(uiBugNamespaceSorter(res))
return res, nil
}
func fetchNamespaceBugs(c context.Context, accessLevel AccessLevel, ns string,
state *ReportingState, onlyFixed bool) (*uiBugNamespace, error) {
query := datastore.NewQuery("Bug").Filter("Namespace=", ns)
if onlyFixed {
query = query.Filter("Status=", BugStatusFixed)
}
var bugs []*Bug
_, err := query.GetAll(c, &bugs)
if err != nil {
return nil, err
}
managers, err := managerList(c, ns)
if err != nil {
return nil, err
}
fixedCount := 0
groups := make(map[int][]*uiBug)
bugMap := make(map[string]*uiBug)
var dups []*Bug
for _, bug := range bugs {
if bug.Status == BugStatusFixed {
fixedCount++
}
if bug.Status == BugStatusInvalid || bug.Status == BugStatusFixed != onlyFixed {
continue
}
if accessLevel < bug.sanitizeAccess(accessLevel) {
continue
}
if bug.Status == BugStatusDup {
dups = append(dups, bug)
continue
}
uiBug := createUIBug(c, bug, state, managers)
bugMap[bugKeyHash(bug.Namespace, bug.Title, bug.Seq)] = uiBug
id := uiBug.ReportingIndex
if bug.Status == BugStatusFixed {
id = -1
} else if uiBug.Commits != "" {
id = -2
}
groups[id] = append(groups[id], uiBug)
}
for _, dup := range dups {
bug := bugMap[dup.DupOf]
if bug == nil {
continue // this can be an invalid bug which we filtered above
}
mergeUIBug(c, bug, dup)
}
var uiGroups []*uiBugGroup
for index, bugs := range groups {
sort.Sort(uiBugSorter(bugs))
caption, fragment, showPatch, showPatched := "", "", false, false
switch index {
case -1:
caption, showPatch, showPatched = "fixed", true, false
case -2:
caption, showPatch, showPatched = "fix pending", false, true
fragment = ns + "-pending"
case len(config.Namespaces[ns].Reporting) - 1:
caption, showPatch, showPatched = "open", false, false
fragment = ns + "-open"
default:
reporting := &config.Namespaces[ns].Reporting[index]
caption, showPatch, showPatched = reporting.DisplayTitle, false, false
fragment = ns + "-" + reporting.Name
}
uiGroups = append(uiGroups, &uiBugGroup{
Now: timeNow(c),
Caption: fmt.Sprintf("%v (%v)", caption, len(bugs)),
Fragment: fragment,
Namespace: ns,
ShowPatch: showPatch,
ShowPatched: showPatched,
ShowIndex: index,
Bugs: bugs,
})
}
sort.Sort(uiBugGroupSorter(uiGroups))
fixedLink := ""
if !onlyFixed {
fixedLink = fmt.Sprintf("?fixed=%v", ns)
}
cfg := config.Namespaces[ns]
uiNamespace := &uiBugNamespace{
Name: ns,
Caption: cfg.DisplayTitle,
CoverLink: cfg.CoverLink,
FixedCount: fixedCount,
FixedLink: fixedLink,
Groups: uiGroups,
}
return uiNamespace, nil
}
func loadDupsForBug(c context.Context, r *http.Request, bug *Bug, state *ReportingState, managers []string) (
*uiBugGroup, error) {
bugHash := bugKeyHash(bug.Namespace, bug.Title, bug.Seq)
var dups []*Bug
_, err := datastore.NewQuery("Bug").
Filter("Status=", BugStatusDup).
Filter("DupOf=", bugHash).
GetAll(c, &dups)
if err != nil {
return nil, err
}
var results []*uiBug
accessLevel := accessLevel(c, r)
for _, dup := range dups {
if accessLevel < dup.sanitizeAccess(accessLevel) {
continue
}
results = append(results, createUIBug(c, dup, state, managers))
}
group := &uiBugGroup{
Now: timeNow(c),
Caption: "duplicates",
ShowPatched: true,
ShowStatus: true,
Bugs: results,
}
return group, nil
}
func loadSimilarBugs(c context.Context, r *http.Request, bug *Bug, state *ReportingState) (*uiBugGroup, error) {
var similar []*Bug
_, err := datastore.NewQuery("Bug").
Filter("Title=", bug.Title).
GetAll(c, &similar)
if err != nil {
return nil, err
}
managers := make(map[string][]string)
var results []*uiBug
accessLevel := accessLevel(c, r)
for _, similar := range similar {
if accessLevel < similar.sanitizeAccess(accessLevel) {
continue
}
if similar.Namespace == bug.Namespace && similar.Seq == bug.Seq {
continue
}
if managers[similar.Namespace] == nil {
mgrs, err := managerList(c, similar.Namespace)
if err != nil {
return nil, err
}
managers[similar.Namespace] = mgrs
}
results = append(results, createUIBug(c, similar, state, managers[similar.Namespace]))
}
group := &uiBugGroup{
Now: timeNow(c),
Caption: "similar bugs",
ShowNamespace: true,
ShowPatched: true,
ShowStatus: true,
Bugs: results,
}
return group, nil
}
func createUIBug(c context.Context, bug *Bug, state *ReportingState, managers []string) *uiBug {
reportingIdx, status, link := 0, "", ""
var reported time.Time
var err error
if bug.Status == BugStatusOpen {
_, _, _, _, reportingIdx, status, link, err = needReport(c, "", state, bug)
reported = bug.Reporting[reportingIdx].Reported
if err != nil {
status = err.Error()
}
if status == "" {
status = "???"
}
} else {
for i := range bug.Reporting {
bugReporting := &bug.Reporting[i]
if i == len(bug.Reporting)-1 ||
bug.Status == BugStatusInvalid && !bugReporting.Closed.IsZero() &&
bug.Reporting[i+1].Closed.IsZero() ||
(bug.Status == BugStatusFixed || bug.Status == BugStatusDup) &&
bugReporting.Closed.IsZero() {
reportingIdx = i
reported = bugReporting.Reported
link = bugReporting.Link
switch bug.Status {
case BugStatusInvalid:
status = "closed as invalid"
case BugStatusFixed:
status = "fixed"
case BugStatusDup:
status = "closed as dup"
default:
status = fmt.Sprintf("unknown (%v)", bug.Status)
}
status = fmt.Sprintf("%v on %v", status, formatTime(bug.Closed))
break
}
}
}
creditEmail, err := email.AddAddrContext(ownEmail(c), bug.Reporting[reportingIdx].ID)
if err != nil {
log.Errorf(c, "failed to generate credit email: %v", err)
}
id := bugKeyHash(bug.Namespace, bug.Title, bug.Seq)
uiBug := &uiBug{
Namespace: bug.Namespace,
Title: bug.displayTitle(),
NumCrashes: bug.NumCrashes,
FirstTime: bug.FirstTime,
LastTime: bug.LastTime,
ReportedTime: reported,
ClosedTime: bug.Closed,
ReproLevel: bug.ReproLevel,
ReportingIndex: reportingIdx,
Status: status,
Link: bugLink(id),
ExternalLink: link,
CreditEmail: creditEmail,
NumManagers: len(managers),
}
updateBugBadness(c, uiBug)
if len(bug.Commits) != 0 {
uiBug.Commits = bug.Commits[0]
if len(bug.Commits) > 1 {
uiBug.Commits = fmt.Sprintf("%q", bug.Commits)
}
for _, mgr := range managers {
found := false
for _, mgr1 := range bug.PatchedOn {
if mgr == mgr1 {
found = true
break
}
}
if found {
uiBug.PatchedOn = append(uiBug.PatchedOn, mgr)
} else {
uiBug.MissingOn = append(uiBug.MissingOn, mgr)
}
}
sort.Strings(uiBug.PatchedOn)
sort.Strings(uiBug.MissingOn)
}
return uiBug
}
func mergeUIBug(c context.Context, bug *uiBug, dup *Bug) {
bug.NumCrashes += dup.NumCrashes
if bug.LastTime.Before(dup.LastTime) {
bug.LastTime = dup.LastTime
}
if bug.ReproLevel < dup.ReproLevel {
bug.ReproLevel = dup.ReproLevel
}
updateBugBadness(c, bug)
}
func updateBugBadness(c context.Context, bug *uiBug) {
bug.NumCrashesBad = bug.NumCrashes >= 10000 && timeNow(c).Sub(bug.LastTime) < 24*time.Hour
}
func loadCrashesForBug(c context.Context, bug *Bug) ([]*uiCrash, []byte, error) {
bugHash := bugKeyHash(bug.Namespace, bug.Title, bug.Seq)
bugKey := datastore.NewKey(c, "Bug", bugHash, 0, nil)
// We can have more than maxCrashes crashes, if we have lots of reproducers.
crashes, _, err := queryCrashesForBug(c, bugKey, maxCrashes+200)
if err != nil || len(crashes) == 0 {
return nil, nil, err
}
builds := make(map[string]*Build)
var results []*uiCrash
for _, crash := range crashes {
build := builds[crash.BuildID]
if build == nil {
build, err = loadBuild(c, bug.Namespace, crash.BuildID)
if err != nil {
return nil, nil, err
}
builds[crash.BuildID] = build
}
ui := &uiCrash{
Manager: crash.Manager,
Time: crash.Time,
Maintainers: fmt.Sprintf("%q", crash.Maintainers),
LogLink: textLink(textCrashLog, crash.Log),
ReportLink: textLink(textCrashReport, crash.Report),
ReproSyzLink: textLink(textReproSyz, crash.ReproSyz),
ReproCLink: textLink(textReproC, crash.ReproC),
uiBuild: makeUIBuild(build),
}
results = append(results, ui)
}
sampleReport, _, err := getText(c, textCrashReport, crashes[0].Report)
if err != nil {
return nil, nil, err
}
return results, sampleReport, nil
}
func makeUIBuild(build *Build) *uiBuild {
return &uiBuild{
Time: build.Time,
SyzkallerCommit: build.SyzkallerCommit,
KernelAlias: kernelRepoInfo(build).Alias,
KernelCommit: build.KernelCommit,
KernelConfigLink: textLink(textKernelConfig, build.KernelConfig),
}
}
func loadManagers(c context.Context) ([]*uiManager, error) {
now := timeNow(c)
date := timeDate(now)
managers, managerKeys, err := loadAllManagers(c)
if err != nil {
return nil, err
}
var buildKeys []*datastore.Key
var statsKeys []*datastore.Key
for i, mgr := range managers {
if mgr.CurrentBuild != "" {
buildKeys = append(buildKeys, buildKey(c, mgr.Namespace, mgr.CurrentBuild))
}
if timeDate(mgr.LastAlive) == date {
statsKeys = append(statsKeys,
datastore.NewKey(c, "ManagerStats", "", int64(date), managerKeys[i]))
}
}
builds := make([]*Build, len(buildKeys))
if err := datastore.GetMulti(c, buildKeys, builds); err != nil {
return nil, err
}
uiBuilds := make(map[string]*uiBuild)
for _, build := range builds {
uiBuilds[build.Namespace+"|"+build.ID] = makeUIBuild(build)
}
stats := make([]*ManagerStats, len(statsKeys))
if err := datastore.GetMulti(c, statsKeys, stats); err != nil {
return nil, err
}
var fullStats []*ManagerStats
for _, mgr := range managers {
if timeDate(mgr.LastAlive) != date {
fullStats = append(fullStats, &ManagerStats{})
continue
}
fullStats = append(fullStats, stats[0])
stats = stats[1:]
}
var results []*uiManager
for i, mgr := range managers {
stats := fullStats[i]
results = append(results, &uiManager{
Namespace: mgr.Namespace,
Name: mgr.Name,
Link: mgr.Link,
CurrentBuild: uiBuilds[mgr.Namespace+"|"+mgr.CurrentBuild],
FailedBuildBugLink: bugLink(mgr.FailedBuildBug),
LastActive: mgr.LastAlive,
LastActiveBad: now.Sub(mgr.LastAlive) > 12*time.Hour,
CurrentUpTime: mgr.CurrentUpTime,
MaxCorpus: stats.MaxCorpus,
MaxCover: stats.MaxCover,
TotalFuzzingTime: stats.TotalFuzzingTime,
TotalCrashes: stats.TotalCrashes,
TotalExecs: stats.TotalExecs,
})
}
sort.Sort(uiManagerSorter(results))
return results, nil
}
func loadRecentJobs(c context.Context) ([]*uiJob, error) {
var jobs []*Job
keys, err := datastore.NewQuery("Job").
Order("-Created").
Limit(20).
GetAll(c, &jobs)
if err != nil {
return nil, err
}
var results []*uiJob
for i, job := range jobs {
ui := &uiJob{
Created: job.Created,
BugLink: bugLink(keys[i].Parent().StringID()),
ExternalLink: job.Link,
User: job.User,
Reporting: job.Reporting,
Namespace: job.Namespace,
Manager: job.Manager,
BugTitle: job.BugTitle,
KernelAlias: kernelRepoInfoRaw(job.KernelRepo, job.KernelBranch).Alias,
PatchLink: textLink(textPatch, job.Patch),
Attempts: job.Attempts,
Started: job.Started,
Finished: job.Finished,
CrashTitle: job.CrashTitle,
CrashLogLink: textLink(textCrashLog, job.CrashLog),
CrashReportLink: textLink(textCrashReport, job.CrashReport),
ErrorLink: textLink(textError, job.Error),
}
results = append(results, ui)
}
return results, nil
}
func fetchErrorLogs(c context.Context) ([]byte, error) {
const (
minLogLevel = 3
maxLines = 100
maxLineLen = 1000
reportPeriod = 7 * 24 * time.Hour
)
q := &log.Query{
StartTime: time.Now().Add(-reportPeriod),
AppLogs: true,
ApplyMinLevel: true,
MinLevel: minLogLevel,
}
result := q.Run(c)
var lines []string
for i := 0; i < maxLines; i++ {
rec, err := result.Next()
if rec == nil {
break
}
if err != nil {
entry := fmt.Sprintf("ERROR FETCHING LOGS: %v\n", err)
lines = append(lines, entry)
break
}
for _, al := range rec.AppLogs {
if al.Level < minLogLevel {
continue
}
text := strings.Replace(al.Message, "\n", " ", -1)
text = strings.Replace(text, "\r", "", -1)
if len(text) > maxLineLen {
text = text[:maxLineLen]
}
res := ""
if !strings.Contains(rec.Resource, "method=log_error") {
res = fmt.Sprintf(" (%v)", rec.Resource)
}
entry := fmt.Sprintf("%v: %v%v\n", al.Time.Format("Jan 02 15:04"), text, res)
lines = append(lines, entry)
}
}
buf := new(bytes.Buffer)
for i := len(lines) - 1; i >= 0; i-- {
buf.WriteString(lines[i])
}
return buf.Bytes(), nil
}
func bugLink(id string) string {
if id == "" {
return ""
}
return "/bug?id=" + id
}
type uiManagerSorter []*uiManager
func (a uiManagerSorter) Len() int { return len(a) }
func (a uiManagerSorter) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a uiManagerSorter) Less(i, j int) bool {
if a[i].Namespace != a[j].Namespace {
return a[i].Namespace < a[j].Namespace
}
return a[i].Name < a[j].Name
}
type uiBugSorter []*uiBug
func (a uiBugSorter) Len() int { return len(a) }
func (a uiBugSorter) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a uiBugSorter) Less(i, j int) bool {
if a[i].Namespace != a[j].Namespace {
return a[i].Namespace < a[j].Namespace
}
if a[i].ClosedTime != a[j].ClosedTime {
return a[i].ClosedTime.After(a[j].ClosedTime)
}
return a[i].ReportedTime.After(a[j].ReportedTime)
}
type uiBugGroupSorter []*uiBugGroup
func (a uiBugGroupSorter) Len() int { return len(a) }
func (a uiBugGroupSorter) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a uiBugGroupSorter) Less(i, j int) bool { return a[i].ShowIndex > a[j].ShowIndex }
type uiBugNamespaceSorter []*uiBugNamespace
func (a uiBugNamespaceSorter) Len() int { return len(a) }
func (a uiBugNamespaceSorter) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a uiBugNamespaceSorter) Less(i, j int) bool { return a[i].Caption < a[j].Caption }