10430f0b7f
This starts the work of having a `NodeProvider` which is responsible for providing node details. It splits the responsibilities of node management off to a new controller. The primary change here is to add the framework pieces for node management and move the VK CLI to use this new controller. It also adds support for node leases where available. This can be enabled via the command line (disabled by default), but may fall back if we find that leaess aren't supported on the cluster.
101 lines
2.5 KiB
Go
101 lines
2.5 KiB
Go
package cmp
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"go/ast"
|
|
"text/template"
|
|
|
|
"gotest.tools/internal/source"
|
|
)
|
|
|
|
// A Result of a Comparison.
|
|
type Result interface {
|
|
Success() bool
|
|
}
|
|
|
|
// StringResult is an implementation of Result that reports the error message
|
|
// string verbatim and does not provide any templating or formatting of the
|
|
// message.
|
|
type StringResult struct {
|
|
success bool
|
|
message string
|
|
}
|
|
|
|
// Success returns true if the comparison was successful.
|
|
func (r StringResult) Success() bool {
|
|
return r.success
|
|
}
|
|
|
|
// FailureMessage returns the message used to provide additional information
|
|
// about the failure.
|
|
func (r StringResult) FailureMessage() string {
|
|
return r.message
|
|
}
|
|
|
|
// ResultSuccess is a constant which is returned by a ComparisonWithResult to
|
|
// indicate success.
|
|
var ResultSuccess = StringResult{success: true}
|
|
|
|
// ResultFailure returns a failed Result with a failure message.
|
|
func ResultFailure(message string) StringResult {
|
|
return StringResult{message: message}
|
|
}
|
|
|
|
// ResultFromError returns ResultSuccess if err is nil. Otherwise ResultFailure
|
|
// is returned with the error message as the failure message.
|
|
func ResultFromError(err error) Result {
|
|
if err == nil {
|
|
return ResultSuccess
|
|
}
|
|
return ResultFailure(err.Error())
|
|
}
|
|
|
|
type templatedResult struct {
|
|
success bool
|
|
template string
|
|
data map[string]interface{}
|
|
}
|
|
|
|
func (r templatedResult) Success() bool {
|
|
return r.success
|
|
}
|
|
|
|
func (r templatedResult) FailureMessage(args []ast.Expr) string {
|
|
msg, err := renderMessage(r, args)
|
|
if err != nil {
|
|
return fmt.Sprintf("failed to render failure message: %s", err)
|
|
}
|
|
return msg
|
|
}
|
|
|
|
// ResultFailureTemplate returns a Result with a template string and data which
|
|
// can be used to format a failure message. The template may access data from .Data,
|
|
// the comparison args with the callArg function, and the formatNode function may
|
|
// be used to format the call args.
|
|
func ResultFailureTemplate(template string, data map[string]interface{}) Result {
|
|
return templatedResult{template: template, data: data}
|
|
}
|
|
|
|
func renderMessage(result templatedResult, args []ast.Expr) (string, error) {
|
|
tmpl := template.New("failure").Funcs(template.FuncMap{
|
|
"formatNode": source.FormatNode,
|
|
"callArg": func(index int) ast.Expr {
|
|
if index >= len(args) {
|
|
return nil
|
|
}
|
|
return args[index]
|
|
},
|
|
})
|
|
var err error
|
|
tmpl, err = tmpl.Parse(result.template)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
buf := new(bytes.Buffer)
|
|
err = tmpl.Execute(buf, map[string]interface{}{
|
|
"Data": result.data,
|
|
})
|
|
return buf.String(), err
|
|
}
|