mirror of
https://github.com/yannh/kubeconform.git
synced 2026-02-19 09:57:02 +00:00
304 lines
8.5 KiB
Go
304 lines
8.5 KiB
Go
// Copyright 2022 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package fn
|
|
|
|
import (
|
|
"fmt"
|
|
"sort"
|
|
"strings"
|
|
)
|
|
|
|
// Severity indicates the severity of the Result
|
|
type Severity string
|
|
|
|
const (
|
|
// Error indicates the result is an error. Will cause the function to exit non-0.
|
|
Error Severity = "error"
|
|
// Warning indicates the result is a warning
|
|
Warning Severity = "warning"
|
|
// Info indicates the result is an informative message
|
|
Info Severity = "info"
|
|
)
|
|
|
|
// ResourceRef fills the ResourceRef field in Results
|
|
type ResourceRef struct {
|
|
APIVersion string `yaml:"apiVersion,omitempty" json:"apiVersion,omitempty"`
|
|
Kind string `yaml:"kind,omitempty" json:"kind,omitempty"`
|
|
Name string `yaml:"name,omitempty" json:"name,omitempty"`
|
|
Namespace string `yaml:"namespace,omitempty" json:"namespace,omitempty"`
|
|
}
|
|
|
|
// Result defines a validation result
|
|
type Result struct {
|
|
// Message is a human readable message. This field is required.
|
|
Message string `yaml:"message,omitempty" json:"message,omitempty"`
|
|
|
|
// Severity is the severity of this result
|
|
Severity Severity `yaml:"severity,omitempty" json:"severity,omitempty"`
|
|
|
|
// ResourceRef is a reference to a resource.
|
|
// Required fields: apiVersion, kind, name.
|
|
ResourceRef *ResourceRef `yaml:"resourceRef,omitempty" json:"resourceRef,omitempty"`
|
|
|
|
// Field is a reference to the field in a resource this result refers to
|
|
Field *Field `yaml:"field,omitempty" json:"field,omitempty"`
|
|
|
|
// File references a file containing the resource this result refers to
|
|
File *File `yaml:"file,omitempty" json:"file,omitempty"`
|
|
|
|
// Tags is an unstructured key value map stored with a result that may be set
|
|
// by external tools to store and retrieve arbitrary metadata
|
|
Tags map[string]string `yaml:"tags,omitempty" json:"tags,omitempty"`
|
|
}
|
|
|
|
func (i Result) Error() string {
|
|
return (i).String()
|
|
}
|
|
|
|
// String provides a human-readable message for the result item
|
|
func (i Result) String() string {
|
|
identifier := i.ResourceRef
|
|
var idStringList []string
|
|
if identifier != nil {
|
|
if identifier.APIVersion != "" {
|
|
idStringList = append(idStringList, identifier.APIVersion)
|
|
}
|
|
if identifier.Kind != "" {
|
|
idStringList = append(idStringList, identifier.Kind)
|
|
}
|
|
if identifier.Namespace != "" {
|
|
idStringList = append(idStringList, identifier.Namespace)
|
|
}
|
|
if identifier.Name != "" {
|
|
idStringList = append(idStringList, identifier.Name)
|
|
}
|
|
}
|
|
formatString := "[%s]"
|
|
severity := i.Severity
|
|
// We default Severity to Info when converting a result to a message.
|
|
if i.Severity == "" {
|
|
severity = Info
|
|
}
|
|
list := []interface{}{severity}
|
|
if len(idStringList) > 0 {
|
|
formatString += " %s"
|
|
list = append(list, strings.Join(idStringList, "/"))
|
|
}
|
|
if i.Field != nil {
|
|
formatString += " %s"
|
|
list = append(list, i.Field.Path)
|
|
}
|
|
formatString += ": %s"
|
|
list = append(list, i.Message)
|
|
return fmt.Sprintf(formatString, list...)
|
|
}
|
|
|
|
// File references a file containing a resource
|
|
type File struct {
|
|
// Path is relative path to the file containing the resource.
|
|
// This field is required.
|
|
Path string `yaml:"path,omitempty" json:"path,omitempty"`
|
|
|
|
// Index is the index into the file containing the resource
|
|
// (i.e. if there are multiple resources in a single file)
|
|
Index int `yaml:"index,omitempty" json:"index,omitempty"`
|
|
}
|
|
|
|
// Field references a field in a resource
|
|
type Field struct {
|
|
// Path is the field path. This field is required.
|
|
Path string `yaml:"path,omitempty" json:"path,omitempty"`
|
|
|
|
// CurrentValue is the current field value
|
|
CurrentValue interface{} `yaml:"currentValue,omitempty" json:"currentValue,omitempty"`
|
|
|
|
// ProposedValue is the proposed value of the field to fix an issue.
|
|
ProposedValue interface{} `yaml:"proposedValue,omitempty" json:"proposedValue,omitempty"`
|
|
}
|
|
|
|
type Results []*Result
|
|
|
|
// Errorf writes an Error level `result` to the results slice. It accepts arguments according to a format specifier.
|
|
// e.g.
|
|
// results.Errorf("bad kind %v", "invalid")
|
|
func (r *Results) Errorf(format string, a ...any) {
|
|
errResult := &Result{Severity: Error, Message: fmt.Sprintf(format, a...)}
|
|
*r = append(*r, errResult)
|
|
}
|
|
|
|
// ErrorE writes the `error` as an Error level `result` to the results slice.
|
|
// e.g.
|
|
//
|
|
// err := error.New("test)
|
|
// results.ErrorE(err)
|
|
func (r *Results) ErrorE(err error) {
|
|
errResult := &Result{Severity: Error, Message: err.Error()}
|
|
*r = append(*r, errResult)
|
|
}
|
|
|
|
// Infof writes an Info level `result` to the results slice. It accepts arguments according to a format specifier.
|
|
// e.g.
|
|
//
|
|
// results.Infof("update %v %q ", "ConfigMap", "kptfile.kpt.dev")
|
|
func (r *Results) Infof(format string, a ...any) {
|
|
infoResult := &Result{Severity: Info, Message: fmt.Sprintf(format, a...)}
|
|
*r = append(*r, infoResult)
|
|
}
|
|
|
|
// Warningf writes a Warning level `result` to the results slice. It accepts arguments according to a format specifier.
|
|
// e.g.
|
|
//
|
|
// results.Warningf("bad kind %q", "invalid")
|
|
func (r *Results) Warningf(format string, a ...any) {
|
|
warnResult := &Result{Severity: Warning, Message: fmt.Sprintf(format, a...)}
|
|
*r = append(*r, warnResult)
|
|
}
|
|
|
|
// WarningE writes an error as a Warning level `result` to the results slice.
|
|
// Normally this function can be used for cases that need error tolerance.
|
|
func (r *Results) WarningE(err error) {
|
|
warnResult := &Result{Severity: Warning, Message: err.Error()}
|
|
*r = append(*r, warnResult)
|
|
}
|
|
|
|
func (r *Results) String() string {
|
|
var results []string
|
|
for _, result := range *r {
|
|
results = append(results, result.String())
|
|
}
|
|
return strings.Join(results, "\n---\n")
|
|
}
|
|
|
|
// Error enables Results to be returned as an error
|
|
func (r Results) Error() string {
|
|
var msgs []string
|
|
for _, i := range r {
|
|
msgs = append(msgs, i.String())
|
|
}
|
|
return strings.Join(msgs, "\n\n")
|
|
}
|
|
|
|
// ExitCode provides the exit code based on the result's severity
|
|
func (r Results) ExitCode() int {
|
|
for _, i := range r {
|
|
if i.Severity == Error {
|
|
return 1
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// Sort performs an in place stable sort of Results
|
|
func (r Results) Sort() {
|
|
sort.SliceStable(r, func(i, j int) bool {
|
|
if fileLess(r, i, j) != 0 {
|
|
return fileLess(r, i, j) < 0
|
|
}
|
|
if severityLess(r, i, j) != 0 {
|
|
return severityLess(r, i, j) < 0
|
|
}
|
|
return resultToString(*r[i]) < resultToString(*r[j])
|
|
})
|
|
}
|
|
|
|
func severityLess(items Results, i, j int) int {
|
|
severityToNumber := map[Severity]int{
|
|
Error: 0,
|
|
Warning: 1,
|
|
Info: 2,
|
|
}
|
|
|
|
severityLevelI, found := severityToNumber[items[i].Severity]
|
|
if !found {
|
|
severityLevelI = 3
|
|
}
|
|
severityLevelJ, found := severityToNumber[items[j].Severity]
|
|
if !found {
|
|
severityLevelJ = 3
|
|
}
|
|
return severityLevelI - severityLevelJ
|
|
}
|
|
|
|
func fileLess(items Results, i, j int) int {
|
|
var fileI, fileJ File
|
|
if items[i].File == nil {
|
|
fileI = File{}
|
|
} else {
|
|
fileI = *items[i].File
|
|
}
|
|
if items[j].File == nil {
|
|
fileJ = File{}
|
|
} else {
|
|
fileJ = *items[j].File
|
|
}
|
|
if fileI.Path != fileJ.Path {
|
|
if fileI.Path < fileJ.Path {
|
|
return -1
|
|
}
|
|
return 1
|
|
}
|
|
return fileI.Index - fileJ.Index
|
|
}
|
|
|
|
func resultToString(item Result) string {
|
|
return fmt.Sprintf("resource-ref:%s,field:%s,message:%s",
|
|
item.ResourceRef, item.Field, item.Message)
|
|
}
|
|
|
|
func ErrorConfigFileResult(err error, path string) *Result {
|
|
return ConfigFileResult(err.Error(), path, Error)
|
|
}
|
|
|
|
func ConfigFileResult(msg, path string, severity Severity) *Result {
|
|
return &Result{
|
|
Message: msg,
|
|
Severity: severity,
|
|
File: &File{
|
|
Path: path,
|
|
},
|
|
}
|
|
}
|
|
|
|
func ErrorResult(err error) *Result {
|
|
return GeneralResult(err.Error(), Error)
|
|
}
|
|
|
|
func GeneralResult(msg string, severity Severity) *Result {
|
|
return &Result{
|
|
Message: msg,
|
|
Severity: severity,
|
|
}
|
|
}
|
|
|
|
func ErrorConfigObjectResult(err error, obj *KubeObject) *Result {
|
|
return ConfigObjectResult(err.Error(), obj, Error)
|
|
}
|
|
|
|
func ConfigObjectResult(msg string, obj *KubeObject, severity Severity) *Result {
|
|
return &Result{
|
|
Message: msg,
|
|
Severity: severity,
|
|
ResourceRef: &ResourceRef{
|
|
APIVersion: obj.GetAPIVersion(),
|
|
Kind: obj.GetKind(),
|
|
Name: obj.GetName(),
|
|
Namespace: obj.GetNamespace(),
|
|
},
|
|
File: &File{
|
|
Path: obj.PathAnnotation(),
|
|
Index: obj.IndexAnnotation(),
|
|
},
|
|
}
|
|
}
|