492 lines
16 KiB
Go
492 lines
16 KiB
Go
package processor
|
|
|
|
import (
|
|
_ "embed"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"regexp"
|
|
"strings"
|
|
|
|
"cook/utils"
|
|
|
|
logger "git.site.quack-lab.dev/dave/cylogger"
|
|
lua "github.com/yuin/gopher-lua"
|
|
)
|
|
|
|
//go:embed luahelper.lua
|
|
var helperScript string
|
|
|
|
// processorLogger is a scoped logger for the processor package.
|
|
var processorLogger = logger.Default.WithPrefix("processor")
|
|
|
|
// Maybe we make this an interface again for the shits and giggles
|
|
// We will see, it could easily be...
|
|
|
|
var globalVariables = map[string]interface{}{}
|
|
|
|
func SetVariables(vars map[string]interface{}) {
|
|
for k, v := range vars {
|
|
globalVariables[k] = v
|
|
}
|
|
}
|
|
|
|
func NewLuaState() (*lua.LState, error) {
|
|
newLStateLogger := processorLogger.WithPrefix("NewLuaState")
|
|
newLStateLogger.Debug("Creating new Lua state")
|
|
L := lua.NewState()
|
|
// defer L.Close()
|
|
|
|
// Load math library
|
|
newLStateLogger.Debug("Loading Lua math library")
|
|
L.Push(L.GetGlobal("require"))
|
|
L.Push(lua.LString("math"))
|
|
if err := L.PCall(1, 1, nil); err != nil {
|
|
newLStateLogger.Error("Failed to load Lua math library: %v", err)
|
|
return nil, fmt.Errorf("error loading Lua math library: %v", err)
|
|
}
|
|
newLStateLogger.Debug("Lua math library loaded")
|
|
|
|
// Initialize helper functions
|
|
newLStateLogger.Debug("Initializing Lua helper functions")
|
|
if err := InitLuaHelpers(L); err != nil {
|
|
newLStateLogger.Error("Failed to initialize Lua helper functions: %v", err)
|
|
return nil, err
|
|
}
|
|
newLStateLogger.Debug("Lua helper functions initialized")
|
|
|
|
// Inject global variables
|
|
if len(globalVariables) > 0 {
|
|
newLStateLogger.Debug("Injecting %d global variables into Lua state", len(globalVariables))
|
|
for k, v := range globalVariables {
|
|
switch val := v.(type) {
|
|
case int:
|
|
L.SetGlobal(k, lua.LNumber(float64(val)))
|
|
case int64:
|
|
L.SetGlobal(k, lua.LNumber(float64(val)))
|
|
case float32:
|
|
L.SetGlobal(k, lua.LNumber(float64(val)))
|
|
case float64:
|
|
L.SetGlobal(k, lua.LNumber(val))
|
|
case string:
|
|
L.SetGlobal(k, lua.LString(val))
|
|
case bool:
|
|
if val {
|
|
L.SetGlobal(k, lua.LTrue)
|
|
} else {
|
|
L.SetGlobal(k, lua.LFalse)
|
|
}
|
|
default:
|
|
// Fallback to string representation
|
|
L.SetGlobal(k, lua.LString(fmt.Sprintf("%v", val)))
|
|
}
|
|
}
|
|
}
|
|
|
|
newLStateLogger.Debug("New Lua state created successfully")
|
|
return L, nil
|
|
}
|
|
|
|
// FromLua converts a Lua table to a struct or map recursively
|
|
func FromLua(L *lua.LState, luaValue lua.LValue) (interface{}, error) {
|
|
fromLuaLogger := processorLogger.WithPrefix("FromLua").WithField("luaType", luaValue.Type().String())
|
|
fromLuaLogger.Debug("Converting Lua value to Go interface")
|
|
switch v := luaValue.(type) {
|
|
case *lua.LTable:
|
|
fromLuaLogger.Debug("Processing Lua table")
|
|
isArray, err := IsLuaTableArray(L, v)
|
|
if err != nil {
|
|
fromLuaLogger.Error("Failed to determine if Lua table is array: %v", err)
|
|
return nil, err
|
|
}
|
|
fromLuaLogger.Debug("Lua table is array: %t", isArray)
|
|
if isArray {
|
|
fromLuaLogger.Debug("Converting Lua table to Go array")
|
|
result := make([]interface{}, 0)
|
|
v.ForEach(func(key lua.LValue, value lua.LValue) {
|
|
converted, _ := FromLua(L, value)
|
|
result = append(result, converted)
|
|
})
|
|
fromLuaLogger.Trace("Converted Go array: %v", result)
|
|
return result, nil
|
|
} else {
|
|
fromLuaLogger.Debug("Converting Lua table to Go map")
|
|
result := make(map[string]interface{})
|
|
v.ForEach(func(key lua.LValue, value lua.LValue) {
|
|
converted, _ := FromLua(L, value)
|
|
result[key.String()] = converted
|
|
})
|
|
fromLuaLogger.Trace("Converted Go map: %v", result)
|
|
return result, nil
|
|
}
|
|
case lua.LString:
|
|
fromLuaLogger.Debug("Converting Lua string to Go string")
|
|
fromLuaLogger.Trace("Lua string: %q", string(v))
|
|
return string(v), nil
|
|
case lua.LBool:
|
|
fromLuaLogger.Debug("Converting Lua boolean to Go boolean")
|
|
fromLuaLogger.Trace("Lua boolean: %t", bool(v))
|
|
return bool(v), nil
|
|
case lua.LNumber:
|
|
fromLuaLogger.Debug("Converting Lua number to Go float64")
|
|
fromLuaLogger.Trace("Lua number: %f", float64(v))
|
|
return float64(v), nil
|
|
default:
|
|
fromLuaLogger.Debug("Unsupported Lua type, returning nil")
|
|
return nil, nil
|
|
}
|
|
}
|
|
|
|
func IsLuaTableArray(L *lua.LState, v *lua.LTable) (bool, error) {
|
|
isLuaTableArrayLogger := processorLogger.WithPrefix("IsLuaTableArray")
|
|
isLuaTableArrayLogger.Debug("Checking if Lua table is an array")
|
|
isLuaTableArrayLogger.Trace("Lua table input: %v", v)
|
|
L.SetGlobal("table_to_check", v)
|
|
|
|
// Use our predefined helper function from InitLuaHelpers
|
|
err := L.DoString(`is_array = isArray(table_to_check)`)
|
|
if err != nil {
|
|
isLuaTableArrayLogger.Error("Error determining if table is an array: %v", err)
|
|
return false, fmt.Errorf("error determining if table is array: %w", err)
|
|
}
|
|
|
|
// Check the result of our Lua function
|
|
isArray := L.GetGlobal("is_array")
|
|
// LVIsFalse returns true if a given LValue is a nil or false otherwise false.
|
|
result := !lua.LVIsFalse(isArray)
|
|
isLuaTableArrayLogger.Debug("Lua table is array: %t", result)
|
|
isLuaTableArrayLogger.Trace("isArray result Lua value: %v", isArray)
|
|
return result, nil
|
|
}
|
|
|
|
// InitLuaHelpers initializes common Lua helper functions
|
|
func InitLuaHelpers(L *lua.LState) error {
|
|
initLuaHelpersLogger := processorLogger.WithPrefix("InitLuaHelpers")
|
|
initLuaHelpersLogger.Debug("Loading Lua helper functions")
|
|
|
|
if err := L.DoString(helperScript); err != nil {
|
|
initLuaHelpersLogger.Error("Failed to load Lua helper functions: %v", err)
|
|
return fmt.Errorf("error loading helper functions: %v", err)
|
|
}
|
|
initLuaHelpersLogger.Debug("Lua helper functions loaded")
|
|
|
|
initLuaHelpersLogger.Debug("Setting up Lua print function to Go")
|
|
L.SetGlobal("print", L.NewFunction(printToGo))
|
|
L.SetGlobal("fetch", L.NewFunction(fetch))
|
|
L.SetGlobal("re", L.NewFunction(EvalRegex))
|
|
initLuaHelpersLogger.Debug("Lua print and fetch functions bound to Go")
|
|
return nil
|
|
}
|
|
|
|
func PrependLuaAssignment(luaExpr string) string {
|
|
prependLuaAssignmentLogger := processorLogger.WithPrefix("PrependLuaAssignment").WithField("originalLuaExpr", luaExpr)
|
|
prependLuaAssignmentLogger.Debug("Prepending Lua assignment if necessary")
|
|
// Auto-prepend v1 for expressions starting with operators
|
|
if strings.HasPrefix(luaExpr, "*") ||
|
|
strings.HasPrefix(luaExpr, "/") ||
|
|
strings.HasPrefix(luaExpr, "+") ||
|
|
strings.HasPrefix(luaExpr, "-") ||
|
|
strings.HasPrefix(luaExpr, "^") ||
|
|
strings.HasPrefix(luaExpr, "%") {
|
|
luaExpr = "v1 = v1" + luaExpr
|
|
prependLuaAssignmentLogger.Debug("Prepended 'v1 = v1' due to operator prefix")
|
|
} else if strings.HasPrefix(luaExpr, "=") {
|
|
// Handle direct assignment with = operator
|
|
luaExpr = "v1 " + luaExpr
|
|
prependLuaAssignmentLogger.Debug("Prepended 'v1' due to direct assignment operator")
|
|
}
|
|
|
|
// Add assignment if needed
|
|
if !strings.Contains(luaExpr, "=") {
|
|
luaExpr = "v1 = " + luaExpr
|
|
prependLuaAssignmentLogger.Debug("Prepended 'v1 =' as no assignment was found")
|
|
}
|
|
prependLuaAssignmentLogger.Trace("Final Lua expression after prepending: %q", luaExpr)
|
|
return luaExpr
|
|
}
|
|
|
|
// BuildLuaScript prepares a Lua expression from shorthand notation
|
|
func BuildLuaScript(luaExpr string) string {
|
|
buildLuaScriptLogger := processorLogger.WithPrefix("BuildLuaScript").WithField("inputLuaExpr", luaExpr)
|
|
buildLuaScriptLogger.Debug("Building full Lua script from expression")
|
|
|
|
// Perform $var substitutions from globalVariables
|
|
luaExpr = replaceVariables(luaExpr)
|
|
|
|
luaExpr = PrependLuaAssignment(luaExpr)
|
|
|
|
fullScript := fmt.Sprintf(`
|
|
function run()
|
|
%s
|
|
end
|
|
local res = run()
|
|
modified = res == nil or res
|
|
`, luaExpr)
|
|
buildLuaScriptLogger.Trace("Generated full Lua script: %q", utils.LimitString(fullScript, 200))
|
|
|
|
return fullScript
|
|
}
|
|
|
|
// BuildJSONLuaScript prepares a Lua expression for JSON mode
|
|
func BuildJSONLuaScript(luaExpr string) string {
|
|
buildJsonLuaScriptLogger := processorLogger.WithPrefix("BuildJSONLuaScript").WithField("inputLuaExpr", luaExpr)
|
|
buildJsonLuaScriptLogger.Debug("Building full Lua script for JSON mode from expression")
|
|
|
|
// Perform $var substitutions from globalVariables
|
|
luaExpr = replaceVariables(luaExpr)
|
|
|
|
fullScript := fmt.Sprintf(`
|
|
function run()
|
|
%s
|
|
end
|
|
local res = run()
|
|
modified = res == nil or res
|
|
`, luaExpr)
|
|
buildJsonLuaScriptLogger.Trace("Generated full JSON Lua script: %q", utils.LimitString(fullScript, 200))
|
|
|
|
return fullScript
|
|
}
|
|
|
|
func replaceVariables(expr string) string {
|
|
// $varName -> literal value
|
|
varNameRe := regexp.MustCompile(`\$(\w+)`)
|
|
return varNameRe.ReplaceAllStringFunc(expr, func(m string) string {
|
|
name := varNameRe.FindStringSubmatch(m)[1]
|
|
if v, ok := globalVariables[name]; ok {
|
|
switch val := v.(type) {
|
|
case int, int64, float32, float64:
|
|
return fmt.Sprintf("%v", val)
|
|
case bool:
|
|
if val {
|
|
return "true"
|
|
} else {
|
|
return "false"
|
|
}
|
|
case string:
|
|
// Quote strings for Lua literal
|
|
return fmt.Sprintf("%q", val)
|
|
default:
|
|
return fmt.Sprintf("%q", fmt.Sprintf("%v", val))
|
|
}
|
|
}
|
|
return m
|
|
})
|
|
}
|
|
|
|
func printToGo(L *lua.LState) int {
|
|
printToGoLogger := processorLogger.WithPrefix("printToGo")
|
|
printToGoLogger.Debug("Lua print function called, redirecting to Go logger")
|
|
top := L.GetTop()
|
|
|
|
args := make([]interface{}, top)
|
|
for i := 1; i <= top; i++ {
|
|
args[i-1] = L.Get(i)
|
|
}
|
|
|
|
// Format the message with proper spacing between arguments
|
|
var parts []string
|
|
for _, arg := range args {
|
|
parts = append(parts, fmt.Sprintf("%v", arg))
|
|
}
|
|
message := strings.Join(parts, " ")
|
|
printToGoLogger.Trace("Lua print message: %q", message)
|
|
|
|
// Use the LUA log level with a script tag
|
|
logger.Lua("%s", message)
|
|
printToGoLogger.Debug("Message logged from Lua")
|
|
return 0
|
|
}
|
|
|
|
func fetch(L *lua.LState) int {
|
|
fetchLogger := processorLogger.WithPrefix("fetch")
|
|
fetchLogger.Debug("Lua fetch function called")
|
|
// Get URL from first argument
|
|
url := L.ToString(1)
|
|
if url == "" {
|
|
fetchLogger.Error("Fetch failed: URL is required")
|
|
L.Push(lua.LNil)
|
|
L.Push(lua.LString("URL is required"))
|
|
return 2
|
|
}
|
|
fetchLogger.Debug("Fetching URL: %q", url)
|
|
|
|
// Get options from second argument if provided
|
|
var method = "GET"
|
|
var headers = make(map[string]string)
|
|
var body = ""
|
|
|
|
if L.GetTop() > 1 {
|
|
options := L.ToTable(2)
|
|
if options != nil {
|
|
fetchLogger.Debug("Processing fetch options")
|
|
// Get method
|
|
if methodVal := options.RawGetString("method"); methodVal != lua.LNil {
|
|
method = methodVal.String()
|
|
fetchLogger.Trace("Method from options: %q", method)
|
|
}
|
|
|
|
// Get headers
|
|
if headersVal := options.RawGetString("headers"); headersVal != lua.LNil {
|
|
if headersTable, ok := headersVal.(*lua.LTable); ok {
|
|
fetchLogger.Trace("Processing headers table")
|
|
headersTable.ForEach(func(key lua.LValue, value lua.LValue) {
|
|
headers[key.String()] = value.String()
|
|
fetchLogger.Trace("Header: %q = %q", key.String(), value.String())
|
|
})
|
|
}
|
|
fetchLogger.Trace("All headers: %v", headers)
|
|
}
|
|
|
|
// Get body
|
|
if bodyVal := options.RawGetString("body"); bodyVal != lua.LNil {
|
|
body = bodyVal.String()
|
|
fetchLogger.Trace("Body from options: %q", utils.LimitString(body, 100))
|
|
}
|
|
}
|
|
}
|
|
fetchLogger.Debug("Fetch request details: Method=%q, URL=%q, BodyLength=%d, Headers=%v", method, url, len(body), headers)
|
|
|
|
// Create HTTP request
|
|
req, err := http.NewRequest(method, url, strings.NewReader(body))
|
|
if err != nil {
|
|
fetchLogger.Error("Error creating HTTP request: %v", err)
|
|
L.Push(lua.LNil)
|
|
L.Push(lua.LString(fmt.Sprintf("Error creating request: %v", err)))
|
|
return 2
|
|
}
|
|
|
|
// Set headers
|
|
for key, value := range headers {
|
|
req.Header.Set(key, value)
|
|
}
|
|
fetchLogger.Debug("HTTP request created and headers set")
|
|
fetchLogger.Trace("HTTP Request: %+v", req)
|
|
|
|
// Make request
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
fetchLogger.Error("Error making HTTP request: %v", err)
|
|
L.Push(lua.LNil)
|
|
L.Push(lua.LString(fmt.Sprintf("Error making request: %v", err)))
|
|
return 2
|
|
}
|
|
defer func() {
|
|
fetchLogger.Debug("Closing HTTP response body")
|
|
resp.Body.Close()
|
|
}()
|
|
fetchLogger.Debug("HTTP request executed. Status Code: %d", resp.StatusCode)
|
|
|
|
// Read response body
|
|
bodyBytes, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
fetchLogger.Error("Error reading response body: %v", err)
|
|
L.Push(lua.LNil)
|
|
L.Push(lua.LString(fmt.Sprintf("Error reading response: %v", err)))
|
|
return 2
|
|
}
|
|
fetchLogger.Trace("Response body length: %d", len(bodyBytes))
|
|
|
|
// Create response table
|
|
responseTable := L.NewTable()
|
|
responseTable.RawSetString("status", lua.LNumber(resp.StatusCode))
|
|
responseTable.RawSetString("statusText", lua.LString(resp.Status))
|
|
responseTable.RawSetString("ok", lua.LBool(resp.StatusCode >= 200 && resp.StatusCode < 300))
|
|
responseTable.RawSetString("body", lua.LString(string(bodyBytes)))
|
|
fetchLogger.Debug("Created Lua response table")
|
|
|
|
// Set headers in response
|
|
headersTable := L.NewTable()
|
|
for key, values := range resp.Header {
|
|
headersTable.RawSetString(key, lua.LString(values[0]))
|
|
fetchLogger.Trace("Response header: %q = %q", key, values[0])
|
|
}
|
|
responseTable.RawSetString("headers", headersTable)
|
|
fetchLogger.Trace("Full response table: %v", responseTable)
|
|
|
|
L.Push(responseTable)
|
|
fetchLogger.Debug("Pushed response table to Lua stack")
|
|
return 1
|
|
}
|
|
|
|
func EvalRegex(L *lua.LState) int {
|
|
evalRegexLogger := processorLogger.WithPrefix("evalRegex")
|
|
evalRegexLogger.Debug("Lua evalRegex function called")
|
|
|
|
pattern := L.ToString(1)
|
|
input := L.ToString(2)
|
|
|
|
evalRegexLogger.Debug("Pattern: %q, Input: %q", pattern, input)
|
|
|
|
re := regexp.MustCompile(pattern)
|
|
matches := re.FindStringSubmatch(input)
|
|
|
|
evalRegexLogger.Debug("Go regex matches: %v (count: %d)", matches, len(matches))
|
|
evalRegexLogger.Debug("Matches is nil: %t", matches == nil)
|
|
|
|
if len(matches) > 0 {
|
|
matchesTable := L.NewTable()
|
|
for i, match := range matches {
|
|
matchesTable.RawSetInt(i+1, lua.LString(match))
|
|
evalRegexLogger.Debug("Set table[%d] = %q", i+1, match)
|
|
}
|
|
L.Push(matchesTable)
|
|
} else {
|
|
L.Push(lua.LNil)
|
|
}
|
|
|
|
evalRegexLogger.Debug("Pushed matches table to Lua stack")
|
|
|
|
return 1
|
|
}
|
|
|
|
// GetLuaFunctionsHelp returns a comprehensive help string for all available Lua functions
|
|
func GetLuaFunctionsHelp() string {
|
|
return `Lua Functions Available in Global Environment:
|
|
|
|
MATH FUNCTIONS:
|
|
min(a, b) - Returns the minimum of two numbers
|
|
max(a, b) - Returns the maximum of two numbers
|
|
round(x, n) - Rounds x to n decimal places (default 0)
|
|
floor(x) - Returns the floor of x
|
|
ceil(x) - Returns the ceiling of x
|
|
|
|
STRING FUNCTIONS:
|
|
upper(s) - Converts string to uppercase
|
|
lower(s) - Converts string to lowercase
|
|
format(s, ...) - Formats string using Lua string.format
|
|
trim(s) - Removes leading/trailing whitespace
|
|
strsplit(inputstr, sep) - Splits string by separator (default: whitespace)
|
|
fromCSV(csv, delimiter, hasHeaders) - Parses CSV text into rows of fields (delimiter defaults to ",", hasHeaders defaults to false)
|
|
toCSV(rows, delimiter) - Converts table of rows to CSV text format (delimiter defaults to ",")
|
|
num(str) - Converts string to number (returns 0 if invalid)
|
|
str(num) - Converts number to string
|
|
is_number(str) - Returns true if string is numeric
|
|
|
|
TABLE FUNCTIONS:
|
|
dump(table, depth) - Prints table structure recursively
|
|
isArray(t) - Returns true if table is a sequential array
|
|
|
|
HTTP FUNCTIONS:
|
|
fetch(url, options) - Makes HTTP request, returns response table
|
|
options: {method="GET", headers={}, body=""}
|
|
returns: {status, statusText, ok, body, headers}
|
|
|
|
REGEX FUNCTIONS:
|
|
re(pattern, input) - Applies regex pattern to input string
|
|
returns: table with matches (index 0 = full match, 1+ = groups)
|
|
|
|
UTILITY FUNCTIONS:
|
|
print(...) - Prints arguments to Go logger
|
|
|
|
EXAMPLES:
|
|
round(3.14159, 2) -> 3.14
|
|
strsplit("a,b,c", ",") -> {"a", "b", "c"}
|
|
upper("hello") -> "HELLO"
|
|
min(5, 3) -> 3
|
|
num("123") -> 123
|
|
is_number("abc") -> false
|
|
fetch("https://api.example.com/data")
|
|
re("(\\w+)@(\\w+)", "user@domain.com") -> {"user@domain.com", "user", "domain.com"}`
|
|
}
|