Files
cozystack/pkg/reservation/evaluator.go
T
Aleksei Sviridkin 4c3a4b42cc style: clear unused code and style findings reported by staticcheck
Remove helpers and constants nothing references, escape format
characters in test literals, and take the simplifications staticcheck
suggests where they read the same. Error strings no longer start with a
capital: they keep their meaning, with the kind or component name moved
out of first position. Callers match errors by type, not text; the one
test that matches text, for Kafka, keeps the phrase it looks for.

Assisted-by: LLM
Signed-off-by: Aleksei Sviridkin <f@lex.la>
2026-11-13 11:37:41 +03:00

454 lines
14 KiB
Go

/*
Copyright 2026 The Cozystack Authors.
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 reservation
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"maps"
"math"
"regexp"
"slices"
"github.com/google/cel-go/cel"
"github.com/google/cel-go/common/functions"
"github.com/google/cel-go/common/types"
"github.com/google/cel-go/common/types/ref"
structuralschema "k8s.io/apiextensions-apiserver/pkg/apiserver/schema"
"k8s.io/apimachinery/pkg/api/resource"
apiservercel "k8s.io/apiserver/pkg/cel"
"k8s.io/apiserver/pkg/cel/library"
"github.com/cozystack/cozystack/pkg/apis/apps/defaulting"
)
// ErrNoDeclaration is returned for a kind whose definition declares neither
// its consumption nor an exemption. Such a kind is refused rather than
// treated as free: for an out-of-tree catalog an omitted declaration would
// otherwise be a quota-escalation vector no in-tree test can reach.
var ErrNoDeclaration = errors.New("the application definition declares neither its consumption nor an exemption")
const (
valuesVar = "values"
instancetypeFunc = "instanceType"
presetFunc = "preset"
// costLimit bounds one expression. Declarations are platform-authored,
// but they run on the admission path, so a runaway comprehension must
// fail rather than stall a write.
costLimit = 1_000_000
)
var bindingName = regexp.MustCompile(`^[a-zA-Z_][a-zA-Z0-9_]*$`)
// Evaluator computes the reservation of one kind's applications. It is built
// once per declaration and is safe for concurrent use.
type Evaluator struct {
exempt bool
schema *structuralschema.Structural
env *cel.Env
lets []compiled
resources []compiled
}
type compiled struct {
name string
ast *cel.Ast
}
// Compile checks decl and prepares it for evaluation. schema is the kind's
// structural OpenAPI schema; stored values are defaulted against it before
// any expression reads them, because the aggregated apiserver persists a
// tenant's spec without its defaults. A nil decl yields ErrNoDeclaration.
func Compile(decl *Declaration, schema *structuralschema.Structural) (*Evaluator, error) {
if decl == nil {
return nil, ErrNoDeclaration
}
if decl.Exempt {
if len(decl.Let) > 0 || len(decl.Resources) > 0 {
return nil, fmt.Errorf("an exempt declaration must not carry let or resources")
}
return &Evaluator{exempt: true}, nil
}
if len(decl.Resources) == 0 {
return nil, ErrNoDeclaration
}
opts := []cel.EnvOption{
cel.Variable(valuesVar, cel.DynType),
library.Quantity(),
cel.Function(instancetypeFunc,
cel.Overload("instanceType_string", []*cel.Type{cel.StringType}, cel.MapType(cel.StringType, cel.DynType),
cel.LateFunctionBinding())),
cel.Function(presetFunc,
cel.Overload("preset_string", []*cel.Type{cel.StringType}, cel.MapType(cel.StringType, cel.DynType),
cel.LateFunctionBinding())),
cel.Function("quantity",
cel.Overload("quantity_int", []*cel.Type{cel.IntType}, apiservercel.QuantityType,
cel.UnaryBinding(func(v ref.Val) ref.Val {
return apiservercel.Quantity{Quantity: resource.NewQuantity(int64(v.(types.Int)), resource.DecimalSI)}
}))),
// The standard _*_ is a singleton dispatching on the left operand's
// traits, so it cannot take a quantity overload; scaling is a method.
cel.Function("mul",
cel.MemberOverload("quantity_mul_int", []*cel.Type{apiservercel.QuantityType, cel.IntType}, apiservercel.QuantityType,
cel.BinaryBinding(mulQuantity))),
}
seen := map[string]bool{valuesVar: true}
for _, b := range decl.Let {
if !bindingName.MatchString(b.Name) {
return nil, fmt.Errorf("let %q: not a valid identifier", b.Name)
}
if seen[b.Name] {
return nil, fmt.Errorf("let %q: name already bound", b.Name)
}
seen[b.Name] = true
opts = append(opts, cel.Variable(b.Name, cel.DynType))
}
env, err := cel.NewEnv(opts...)
if err != nil {
return nil, fmt.Errorf("build CEL environment: %w", err)
}
ev := &Evaluator{schema: schema, env: env}
for _, b := range decl.Let {
ast, iss := env.Compile(b.Expression)
if iss.Err() != nil {
return nil, fmt.Errorf("let %q: %w", b.Name, iss.Err())
}
ev.lets = append(ev.lets, compiled{name: b.Name, ast: ast})
}
for _, key := range slices.Sorted(maps.Keys(decl.Resources)) {
if key == "" {
return nil, fmt.Errorf("resources: empty quota key")
}
ast, iss := env.Compile(decl.Resources[key])
if iss.Err() != nil {
return nil, fmt.Errorf("resources[%q]: %w", key, iss.Err())
}
ev.resources = append(ev.resources, compiled{name: key, ast: ast})
}
return ev, nil
}
// Exempt reports whether the kind declared that it consumes nothing.
func (e *Evaluator) Exempt() bool { return e.exempt }
// EvaluateJSON evaluates the reservation of an application from its values
// as stored, a JSON object.
func (e *Evaluator) EvaluateJSON(raw []byte, env Environment) (ResourceList, error) {
values := map[string]any{}
if len(bytes.TrimSpace(raw)) > 0 {
dec := json.NewDecoder(bytes.NewReader(raw))
dec.UseNumber()
var v any
if err := dec.Decode(&v); err != nil {
return nil, fmt.Errorf("decode values: %w", err)
}
m, ok := v.(map[string]any)
if !ok && v != nil {
return nil, fmt.Errorf("decode values: expected an object, got %T", v)
}
if m != nil {
values = m
}
}
return e.Evaluate(values, env)
}
// Evaluate returns the reservation of an application with the given values.
// The values are defaulted first and are not modified. Anything that cannot
// be resolved — an unknown instance type, a value of the wrong type, a key an
// expression reads without guarding it with has() — is an error, never a
// smaller figure. Keys that evaluate to zero are omitted.
func (e *Evaluator) Evaluate(values map[string]any, env Environment) (ResourceList, error) {
if e.exempt {
return ResourceList{}, nil
}
if env == nil {
return nil, fmt.Errorf("no environment to resolve instance types and presets against")
}
defaulted := normalizeNumbers(values).(map[string]any)
// Defaulting replaces a value of the wrong type with the schema's
// default, which would turn a malformed spec into a smaller one.
if err := checkTypes(defaulted, e.schema, ""); err != nil {
return nil, err
}
if err := defaulting.Apply(&defaulted, e.schema); err != nil {
return nil, fmt.Errorf("default values: %w", err)
}
// The environment differs per call, so instanceType and preset are
// declared with a late binding and bound here, per program; cel.Functions
// is deprecated for declaring functions but is still how cel-go supplies
// a late binding.
bindings := cel.Functions(
&functions.Overload{Operator: "instanceType_string", Unary: lookup(env.Instancetype, instancetypeZeroKeys)},
&functions.Overload{Operator: "preset_string", Unary: lookup(env.Preset, nil)},
)
activation := map[string]any{valuesVar: defaulted}
for _, c := range e.lets {
out, err := e.run(c, bindings, activation)
if err != nil {
return nil, fmt.Errorf("let %q: %w", c.name, err)
}
activation[c.name] = out
}
result := ResourceList{}
for _, c := range e.resources {
out, err := e.run(c, bindings, activation)
if err != nil {
return nil, fmt.Errorf("resources[%q]: %w", c.name, err)
}
q, err := toQuantity(out)
if err != nil {
return nil, fmt.Errorf("resources[%q]: %w", c.name, err)
}
if q.Sign() < 0 {
return nil, fmt.Errorf("resources[%q]: negative reservation %s", c.name, q.String())
}
if q.IsZero() {
continue
}
result[c.name] = q
}
return result, nil
}
func (e *Evaluator) run(c compiled, bindings cel.ProgramOption, activation map[string]any) (ref.Val, error) {
prg, err := e.env.Program(c.ast, bindings, cel.CostLimit(costLimit))
if err != nil {
return nil, err
}
out, _, err := prg.Eval(activation)
if err != nil {
return nil, err
}
return out, nil
}
// instancetypeZeroKeys are present, at zero, in every instanceType() result,
// so that a declaration can read any class of a type without guarding it.
var instancetypeZeroKeys = []string{
KeyCPU, KeyDedicatedCPU, KeyMemory, KeyOvercommittedMemory,
KeyHugepagesPrefix + "2Mi", KeyHugepagesPrefix + "1Gi",
}
func lookup(resolve func(string) (ResourceList, error), zeroKeys []string) functions.UnaryOp {
return func(arg ref.Val) ref.Val {
name, ok := arg.(types.String)
if !ok {
return types.MaybeNoSuchOverloadErr(arg)
}
rl, err := resolve(string(name))
if err != nil {
return types.WrapErr(err)
}
out := make(map[string]any, len(rl)+len(zeroKeys))
for _, k := range zeroKeys {
out[k] = apiservercel.Quantity{Quantity: resource.NewQuantity(0, resource.DecimalSI)}
}
for k, v := range rl {
q := v.DeepCopy()
out[k] = apiservercel.Quantity{Quantity: &q}
}
return types.DefaultTypeAdapter.NativeToValue(out)
}
}
func mulQuantity(q, n ref.Val) ref.Val {
qq, ok := q.(apiservercel.Quantity)
if !ok {
return types.MaybeNoSuchOverloadErr(q)
}
nn, ok := n.(types.Int)
if !ok {
return types.MaybeNoSuchOverloadErr(n)
}
out := qq.DeepCopy()
if !out.Mul(int64(nn)) {
return types.NewErr("quantity %s * %d overflows", qq.String(), int64(nn))
}
return apiservercel.Quantity{Quantity: &out}
}
func toQuantity(v ref.Val) (resource.Quantity, error) {
switch t := v.(type) {
case apiservercel.Quantity:
return t.DeepCopy(), nil
case types.Int:
return *resource.NewQuantity(int64(t), resource.DecimalSI), nil
case types.Uint:
if uint64(t) > math.MaxInt64 {
return resource.Quantity{}, fmt.Errorf("%d overflows a quantity", uint64(t))
}
return *resource.NewQuantity(int64(t), resource.DecimalSI), nil
case types.Double:
f := float64(t)
if math.IsNaN(f) || math.IsInf(f, 0) {
return resource.Quantity{}, fmt.Errorf("not a finite number: %v", f)
}
// Rounding up would carry a negative figure smaller than a milli to
// zero, past the sign check.
if f < 0 {
return resource.Quantity{}, fmt.Errorf("negative reservation %v", f)
}
// float64(math.MaxInt64) rounds up to 2^63, so the bound is
// exclusive; past it the conversion would saturate into a smaller
// figure.
milli := math.Ceil(f * 1000)
if milli >= math.MaxInt64 {
return resource.Quantity{}, fmt.Errorf("%v overflows a quantity", f)
}
return *resource.NewMilliQuantity(int64(milli), resource.DecimalSI), nil
case types.String:
q, err := resource.ParseQuantity(string(t))
if err != nil {
return resource.Quantity{}, fmt.Errorf("parse %q as a quantity: %w", string(t), err)
}
return q, nil
default:
return resource.Quantity{}, fmt.Errorf("expression returned %s, expected an int, a double, a string or a quantity", v.Type().TypeName())
}
}
// checkTypes refuses a value whose JSON type the schema does not allow. It
// runs on normalized values: an integer is an int64, any other number a
// float64. A null is left to defaulting, which treats it as absent.
func checkTypes(v any, s *structuralschema.Structural, path string) error {
if s == nil || v == nil {
return nil
}
if s.XIntOrString {
switch v.(type) {
case int64, string:
return nil
}
return typeError(path, "an integer or a string", v)
}
// An untyped schema is defaulted as the shape its properties or items
// imply, so it is checked as that shape too.
effType := s.Type
if effType == "" {
switch {
case len(s.Properties) > 0 || (s.AdditionalProperties != nil && s.AdditionalProperties.Structural != nil):
effType = "object"
case s.Items != nil:
effType = "array"
}
}
switch effType {
case "object":
m, ok := v.(map[string]any)
if !ok {
return typeError(path, "an object", v)
}
for k, vv := range m {
ps, known := s.Properties[k]
switch {
case known:
if err := checkTypes(vv, &ps, path+"."+k); err != nil {
return err
}
case s.AdditionalProperties != nil && s.AdditionalProperties.Structural != nil:
if err := checkTypes(vv, s.AdditionalProperties.Structural, path+"."+k); err != nil {
return err
}
}
}
case "array":
sl, ok := v.([]any)
if !ok {
return typeError(path, "an array", v)
}
for i, vv := range sl {
if err := checkTypes(vv, s.Items, fmt.Sprintf("%s[%d]", path, i)); err != nil {
return err
}
}
case "string":
if _, ok := v.(string); !ok {
return typeError(path, "a string", v)
}
case "integer":
if _, ok := v.(int64); !ok {
return typeError(path, "an integer", v)
}
case "number":
switch v.(type) {
case int64, float64:
default:
return typeError(path, "a number", v)
}
case "boolean":
if _, ok := v.(bool); !ok {
return typeError(path, "a boolean", v)
}
}
return nil
}
func typeError(path, want string, got any) error {
if path == "" {
path = "."
}
return fmt.Errorf("values%s: expected %s, got %T", path, want, got)
}
// normalizeNumbers returns a copy of v in which every JSON number is an int64
// when it is integral and a float64 otherwise. Without it every number in a
// stored spec reaches CEL as a double, and replicas * quantity(...) would not
// type-check at runtime.
func normalizeNumbers(v any) any {
switch t := v.(type) {
case map[string]any:
out := make(map[string]any, len(t))
for k, vv := range t {
out[k] = normalizeNumbers(vv)
}
return out
case []any:
out := make([]any, len(t))
for i, vv := range t {
out[i] = normalizeNumbers(vv)
}
return out
case json.Number:
if i, err := t.Int64(); err == nil {
return i
}
// 2.0 and 2e0 are integers to the schema validator; spelled that
// way they fail Int64 and are classified as a float64 would be.
f, _ := t.Float64()
return normalizeNumbers(f)
case float64:
if t == math.Trunc(t) && math.Abs(t) < 1<<53 {
return int64(t)
}
return t
case int:
return int64(t)
default:
return v
}
}