github.com/kubeshop/testkube@v1.17.23/pkg/tcl/expressionstcl/utils.go (about)

     1  // Copyright 2024 Testkube.
     2  //
     3  // Licensed as a Testkube Pro file under the Testkube Community
     4  // License (the "License"); you may not use this file except in compliance with
     5  // the License. You may obtain a copy of the License at
     6  //
     7  //     https://github.com/kubeshop/testkube/blob/main/licenses/TCL.txt
     8  
     9  package expressionstcl
    10  
    11  import (
    12  	"fmt"
    13  
    14  	"github.com/pkg/errors"
    15  )
    16  
    17  const maxCallStack = 10_000
    18  
    19  func deepResolve(expr Expression, machines ...Machine) (Expression, error) {
    20  	i := 1
    21  	expr, changed, err := expr.SafeResolve(machines...)
    22  	for changed && err == nil && expr.Static() == nil {
    23  		if i > maxCallStack {
    24  			return expr, fmt.Errorf("maximum call stack exceeded while resolving expression: %s", expr.String())
    25  		}
    26  		expr, changed, err = expr.SafeResolve(machines...)
    27  		i++
    28  	}
    29  	return expr, err
    30  }
    31  
    32  func EvalTemplate(tpl string, machines ...Machine) (string, error) {
    33  	expr, err := CompileTemplate(tpl)
    34  	if err != nil {
    35  		return "", errors.Wrap(err, "compiling")
    36  	}
    37  	expr, err = expr.Resolve(machines...)
    38  	if err != nil {
    39  		return "", errors.Wrap(err, "resolving")
    40  	}
    41  	if expr.Static() == nil {
    42  		return "", fmt.Errorf("template should be static: %s", expr.Template())
    43  	}
    44  	return expr.Static().StringValue()
    45  }
    46  
    47  func EvalExpressionPartial(str string, machines ...Machine) (Expression, error) {
    48  	expr, err := Compile(str)
    49  	if err != nil {
    50  		return nil, errors.Wrap(err, "compiling")
    51  	}
    52  	expr, err = expr.Resolve(machines...)
    53  	if err != nil {
    54  		return nil, errors.Wrap(err, "resolving")
    55  	}
    56  	return expr, err
    57  }
    58  
    59  func EvalExpression(str string, machines ...Machine) (StaticValue, error) {
    60  	expr, err := EvalExpressionPartial(str, machines...)
    61  	if err != nil {
    62  		return nil, err
    63  	}
    64  	if expr.Static() == nil {
    65  		return nil, fmt.Errorf("expression should be static: %s", expr.String())
    66  	}
    67  	return expr.Static(), nil
    68  }
    69  
    70  func Escape(str string) string {
    71  	return NewStringValue(str).Template()
    72  }