0
0
package main
import (
"bufio"
"fmt"
"go/ast"
"go/parser"
"go/token"
"io/fs"
"os"
"path/filepath"
"sort"
"strings"
)
type site struct {
owner string
name string
class string
kind string
at string
}
func (c *checker) scanSites() []site {
var out []site
for _, top := range []string{"internal", "cmd"} {
_ = filepath.WalkDir(filepath.Join(c.root, top), func(p string, d fs.DirEntry, err error) error {
if err != nil || d.IsDir() || !strings.HasSuffix(p, ".go") || strings.HasSuffix(p, "_test.go") {
return nil
}
fset := token.NewFileSet()
f, err := parser.ParseFile(fset, p, nil, 0)
if err != nil {
return nil
}
rel, _ := filepath.Rel(c.root, p)
owner, base := filepath.Dir(rel), filepath.Base(rel)
for _, decl := range f.Decls {
name := declName(decl)
ast.Inspect(decl, func(n ast.Node) bool {
kind := siteKind(n)
if kind == "" {
return true
}
class := "requeue"
if strings.HasPrefix(kind, "time.") {
class = "ticker"
}
out = append(out, site{owner: owner, name: base + ":" + name, class: class, kind: kind,
at: fmt.Sprintf("%s:%d", rel, fset.Position(n.Pos()).Line)})
return true
})
}
return nil
})
}
return out
}
func siteKind(n ast.Node) string {
switch x := n.(type) {
case *ast.CallExpr:
if sel, ok := x.Fun.(*ast.SelectorExpr); ok {
if id, ok := sel.X.(*ast.Ident); ok && id.Name == "time" && (sel.Sel.Name == "NewTicker" || sel.Sel.Name == "Tick") {
return "time." + sel.Sel.Name
}
if sel.Sel.Name == "RefreshAfter" {
return "RefreshAfter"
}
}
case *ast.KeyValueExpr:
if k, ok := x.Key.(*ast.Ident); ok && k.Name == "RequeueAfter" && periodic(x.Value) {
return "RequeueAfter"
}
case *ast.AssignStmt:
for i, l := range x.Lhs {
if sel, ok := l.(*ast.SelectorExpr); ok && sel.Sel.Name == "RequeueAfter" && i < len(x.Rhs) && periodic(x.Rhs[i]) {
return "RequeueAfter"
}
}
}
return ""
}
func periodic(e ast.Expr) bool {
switch v := e.(type) {
case *ast.BasicLit:
return v.Value != "0"
case *ast.SelectorExpr:
return v.Sel.Name != "RequeueAfter"
}
return true
}
func declName(d ast.Decl) string {
switch x := d.(type) {
case *ast.FuncDecl:
if x.Recv != nil && len(x.Recv.List) > 0 {
t := x.Recv.List[0].Type
if s, ok := t.(*ast.StarExpr); ok {
t = s.X
}
if ix, ok := t.(*ast.IndexExpr); ok {
t = ix.X
}
if ix, ok := t.(*ast.IndexListExpr); ok {
t = ix.X
}
if id, ok := t.(*ast.Ident); ok {
return id.Name + "." + x.Name.Name
}
}
return x.Name.Name
case *ast.GenDecl:
for _, s := range x.Specs {
if v, ok := s.(*ast.ValueSpec); ok && len(v.Names) > 0 {
return v.Names[0].Name
}
}
}
return "_"
}
var listedClass = map[string]string{"ticker": "ticker", "requeue": "requeue", "deadline": "requeue"}
const obligationsFile = "deploy/obligations.txt"
func (c *checker) obligations() {
f, err := os.Open(filepath.Join(c.root, obligationsFile))
if err != nil {
c.fail("obligations", obligationsFile, "%v", err)
return
}
defer f.Close()
type key struct{ owner, name, class string }
listed := map[key][]int{}
scanner := bufio.NewScanner(f)
n := 0
for scanner.Scan() {
n++
line := scanner.Text()
if strings.HasPrefix(line, "#") || strings.TrimSpace(line) == "" || strings.HasPrefix(line, "owner\t") {
continue
}
cols := strings.Split(line, "\t")
if len(cols) < 5 {
c.fail("obligations", fmt.Sprintf("%s:%d", obligationsFile, n), "a line has owner, site, kind, period and reason")
continue
}
class, scanned := listedClass[cols[2]]
if !scanned {
continue
}
k := key{cols[0], cols[1], class}
listed[k] = append(listed[k], n)
}
found := map[key][]site{}
for _, s := range c.scanSites() {
k := key{s.owner, s.name, s.class}
found[k] = append(found[k], s)
}
for k, sites := range found {
for i := len(listed[k]); i < len(sites); i++ {
s := sites[i]
c.fail("obligations", s.at, "%s site %s\t%s is not listed in %s as %s", s.kind, s.owner, s.name, obligationsFile, kindsOf(k.class))
}
}
for k, lines := range listed {
for i := len(found[k]); i < len(lines); i++ {
c.fail("obligations", fmt.Sprintf("%s:%d", obligationsFile, lines[i]), "lists %s\t%s (%s) but the tree has no such site", k.owner, k.name, kindsOf(k.class))
}
}
}
func kindsOf(class string) string {
var out []string
for k, v := range listedClass {
if v == class {
out = append(out, k)
}
}
sort.Strings(out)
return strings.Join(out, " or ")
}