Sky/Moonshark
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: Sky:d6feb408ce8e52b1cca103d499f68c2d8ba0c7e6
Branches Tags
Sky:master
..
compare: Sky:08a532f11a7dded00453926cb292617772270d7c
Branches Tags
Sky:master

No commits in common. "d6feb408ce8e52b1cca103d499f68c2d8ba0c7e6" and "08a532f11a7dded00453926cb292617772270d7c" have entirely different histories.
d6feb408ce ... 08a532f11a

11 changed files with 578 additions and 711 deletions
Show Stats Expand all files Collapse all files

6
core/http/httplogger.go
View File

@ -18,12 +18,12 @@ const (
)
// LogRequest logs an HTTP request with custom formatting
func LogRequest(statusCode int, r *http.Request, duration time.Duration) {
func LogRequest(log *logger.Logger, statusCode int, r *http.Request, duration time.Duration) {
statusColor := getStatusColor(statusCode)
// Use the logger's raw message writer to bypass the standard format
logger.LogRaw("%s%s%s %s%d %s%s %s %s(%v)%s",
colorGray, time.Now().Format(logger.TimeFormat()), colorReset,
log.LogRaw("%s%s%s %s%d %s%s %s %s(%v)%s",
colorGray, time.Now().Format(log.TimeFormat()), colorReset,
statusColor, statusCode, r.Method, colorReset, r.URL.Path, colorGray, duration, colorReset)
}

29
core/http/server.go
View File

@ -19,6 +19,7 @@ type Server struct {
luaRouter *routers.LuaRouter
staticRouter *routers.StaticRouter
luaRunner *runner.LuaRunner
logger *logger.Logger
httpServer *http.Server
loggingEnabled bool
debugMode bool // Controls whether to show error details
@ -27,13 +28,15 @@ type Server struct {
}
// New creates a new HTTP server with optimized connection settings
func New(luaRouter *routers.LuaRouter, staticRouter *routers.StaticRouter, runner *runner.LuaRunner,
func New(luaRouter *routers.LuaRouter, staticRouter *routers.StaticRouter,
runner *runner.LuaRunner, log *logger.Logger,
loggingEnabled bool, debugMode bool, overrideDir string, config *config.Config) *Server {
server := &Server{
luaRouter: luaRouter,
staticRouter: staticRouter,
luaRunner: runner,
logger: log,
httpServer: &http.Server{},
loggingEnabled: loggingEnabled,
debugMode: debugMode,
@ -60,13 +63,13 @@ func New(luaRouter *routers.LuaRouter, staticRouter *routers.StaticRouter, runne
// ListenAndServe starts the server on the given address
func (s *Server) ListenAndServe(addr string) error {
s.httpServer.Addr = addr
logger.Info("Server listening at http://localhost%s", addr)
s.logger.Info("Server listening at http://localhost%s", addr)
return s.httpServer.ListenAndServe()
}
// Shutdown gracefully shuts down the server
func (s *Server) Shutdown(ctx context.Context) error {
logger.Info("Server shutting down...")
s.logger.Info("Server shutting down...")
return s.httpServer.Shutdown(ctx)
}
@ -81,7 +84,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// Calculate and log request duration
duration := time.Since(start)
if s.loggingEnabled {
LogRequest(http.StatusOK, r, duration)
LogRequest(s.logger, http.StatusOK, r, duration)
}
return
}
@ -100,13 +103,13 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// Log the request with our custom format
if s.loggingEnabled {
LogRequest(statusCode, r, duration)
LogRequest(s.logger, statusCode, r, duration)
}
}
// handleRequest processes the actual request
func (s *Server) handleRequest(w http.ResponseWriter, r *http.Request) {
logger.Debug("Processing request %s %s", r.Method, r.URL.Path)
s.logger.Debug("Processing request %s %s", r.Method, r.URL.Path)
// Try Lua routes first
params := &routers.Params{}
@ -123,7 +126,7 @@ func (s *Server) handleRequest(w http.ResponseWriter, r *http.Request) {
errorMsg = node.Error.Error()
}
logger.Error("%s %s - %s", r.Method, r.URL.Path, errorMsg)
s.logger.Error("%s %s - %s", r.Method, r.URL.Path, errorMsg)
// Show error page with the actual error message
w.Header().Set("Content-Type", "text/html; charset=utf-8")
@ -132,7 +135,7 @@ func (s *Server) handleRequest(w http.ResponseWriter, r *http.Request) {
w.Write([]byte(errorHTML))
return
} else if found {
logger.Debug("Found Lua route match for %s %s with %d params", r.Method, r.URL.Path, params.Count)
s.logger.Debug("Found Lua route match for %s %s with %d params", r.Method, r.URL.Path, params.Count)
s.handleLuaRoute(w, r, bytecode, scriptPath, params)
return
}
@ -162,7 +165,7 @@ func (s *Server) handleLuaRoute(w http.ResponseWriter, r *http.Request, bytecode
defer ctx.Release()
// Log bytecode size
logger.Debug("Executing Lua route with %d bytes of bytecode", len(bytecode))
s.logger.Debug("Executing Lua route with %d bytes of bytecode", len(bytecode))
// Add request info directly to context
ctx.Set("method", r.Method)
@ -216,7 +219,7 @@ func (s *Server) handleLuaRoute(w http.ResponseWriter, r *http.Request, bytecode
// Execute Lua script
result, err := s.luaRunner.Run(bytecode, ctx, scriptPath)
if err != nil {
logger.Error("Error executing Lua route: %v", err)
s.logger.Error("Error executing Lua route: %v", err)
// Set content type to HTML
w.Header().Set("Content-Type", "text/html; charset=utf-8")
@ -229,7 +232,7 @@ func (s *Server) handleLuaRoute(w http.ResponseWriter, r *http.Request, bytecode
return
}
writeResponse(w, result)
writeResponse(w, result, s.logger)
}
// Content types for responses
@ -239,7 +242,7 @@ const (
)
// writeResponse writes the Lua result to the HTTP response
func writeResponse(w http.ResponseWriter, result any) {
func writeResponse(w http.ResponseWriter, result any, log *logger.Logger) {
if result == nil {
w.WriteHeader(http.StatusNoContent)
return
@ -280,7 +283,7 @@ func writeResponse(w http.ResponseWriter, result any) {
setContentTypeIfMissing(w, contentTypeJSON)
data, err := json.Marshal(res)
if err != nil {
logger.Error("Failed to marshal response: %v", err)
log.Error("Failed to marshal response: %v", err)
http.Error(w, "Internal Server Error", http.StatusInternalServerError)
return
}

112
core/logger/logger.go
View File

@ -54,20 +54,13 @@ const (
defaultRateLimitTime = 10 * time.Second // How long to pause during rate limiting
)
// Single global logger instance with mutex for safe initialization
var (
globalLogger *Logger
globalLoggerOnce sync.Once
)
// Logger handles logging operations
type Logger struct {
writer io.Writer
level int
useColors bool
timeFormat string
mu sync.Mutex // Mutex for thread-safe writing
debugMode atomic.Bool // Force debug logging regardless of level
mu sync.Mutex // Mutex for thread-safe writing
// Simple rate limiting
logCount atomic.Int64 // Number of logs in current window
@ -78,23 +71,8 @@ type Logger struct {
limitDuration time.Duration // How long to pause logging when rate limited
}
// GetLogger returns the global logger instance, creating it if needed
func GetLogger() *Logger {
globalLoggerOnce.Do(func() {
globalLogger = newLogger(LevelInfo, true)
})
return globalLogger
}
// InitGlobalLogger initializes the global logger with custom settings
func InitGlobalLogger(minLevel int, useColors bool) {
globalLoggerOnce.Do(func() {
globalLogger = newLogger(minLevel, useColors)
})
}
// newLogger creates a new logger instance (internal use)
func newLogger(minLevel int, useColors bool) *Logger {
// New creates a new logger
func New(minLevel int, useColors bool) *Logger {
logger := &Logger{
writer: os.Stdout,
level: minLevel,
@ -110,11 +88,6 @@ func newLogger(minLevel int, useColors bool) *Logger {
return logger
}
// New creates a new logger (deprecated - use GetLogger() instead)
func New(minLevel int, useColors bool) *Logger {
return newLogger(minLevel, useColors)
}
// resetCounters resets the rate limiting counters
func (l *Logger) resetCounters() {
l.logCount.Store(0)
@ -155,21 +128,6 @@ func (l *Logger) DisableColors() {
l.useColors = false
}
// EnableDebug forces debug logs to be shown regardless of level
func (l *Logger) EnableDebug() {
l.debugMode.Store(true)
}
// DisableDebug stops forcing debug logs
func (l *Logger) DisableDebug() {
l.debugMode.Store(false)
}
// IsDebugEnabled returns true if debug mode is enabled
func (l *Logger) IsDebugEnabled() bool {
return l.debugMode.Load()
}
// writeMessage writes a formatted log message directly to the writer
func (l *Logger) writeMessage(level int, message string, rawMode bool) {
var logLine string
@ -259,9 +217,8 @@ func (l *Logger) checkRateLimit(level int) bool {
// log handles the core logging logic with level filtering
func (l *Logger) log(level int, format string, args ...any) {
// Check if we should log this message
// Either level is high enough OR (it's a debug message AND debug mode is enabled)
if level < l.level && !(level == LevelDebug && l.debugMode.Load()) {
// First check normal level filtering
if level < l.level {
return
}
@ -369,69 +326,50 @@ func (l *Logger) Server(format string, args ...any) {
l.log(LevelServer, format, args...)
}
// Global helper functions that use the global logger
// Default global logger
var defaultLogger = New(LevelInfo, true)
// Debug logs a debug message to the global logger
// Debug logs a debug message to the default logger
func Debug(format string, args ...any) {
GetLogger().Debug(format, args...)
defaultLogger.Debug(format, args...)
}
// Info logs an informational message to the global logger
// Info logs an informational message to the default logger
func Info(format string, args ...any) {
GetLogger().Info(format, args...)
defaultLogger.Info(format, args...)
}
// Warning logs a warning message to the global logger
// Warning logs a warning message to the default logger
func Warning(format string, args ...any) {
GetLogger().Warning(format, args...)
defaultLogger.Warning(format, args...)
}
// Error logs an error message to the global logger
// Error logs an error message to the default logger
func Error(format string, args ...any) {
GetLogger().Error(format, args...)
defaultLogger.Error(format, args...)
}
// Fatal logs a fatal error message to the global logger and exits
// Fatal logs a fatal error message to the default logger and exits
func Fatal(format string, args ...any) {
GetLogger().Fatal(format, args...)
defaultLogger.Fatal(format, args...)
}
// Server logs a server message to the global logger
// Server logs a server message to the default logger
func Server(format string, args ...any) {
GetLogger().Server(format, args...)
defaultLogger.Server(format, args...)
}
// LogRaw logs a raw message to the global logger
// LogRaw logs a raw message to the default logger
func LogRaw(format string, args ...any) {
GetLogger().LogRaw(format, args...)
defaultLogger.LogRaw(format, args...)
}
// SetLevel changes the minimum log level of the global logger
// SetLevel changes the minimum log level of the default logger
func SetLevel(level int) {
GetLogger().SetLevel(level)
defaultLogger.SetLevel(level)
}
// SetOutput changes the output destination of the global logger
// SetOutput changes the output destination of the default logger
func SetOutput(w io.Writer) {
GetLogger().SetOutput(w)
}
// TimeFormat returns the current time format of the global logger
func TimeFormat() string {
return GetLogger().TimeFormat()
}
// EnableDebug enables debug messages regardless of log level
func EnableDebug() {
GetLogger().EnableDebug()
}
// DisableDebug disables forced debug messages
func DisableDebug() {
GetLogger().DisableDebug()
}
// IsDebugEnabled returns true if debug mode is enabled
func IsDebugEnabled() bool {
return GetLogger().IsDebugEnabled()
defaultLogger.SetOutput(w)
}

52
core/runner/CoreModules.go
View File

@ -1,38 +1,22 @@
package runner
import (
"fmt"
"strings"
"sync"
luajit "git.sharkk.net/Sky/LuaJIT-to-Go"
"git.sharkk.net/Sky/Moonshark/core/logger"
)
// CoreModuleRegistry manages the initialization and reloading of core modules
type CoreModuleRegistry struct {
modules map[string]StateInitFunc
mu sync.RWMutex
debug bool
}
// NewCoreModuleRegistry creates a new core module registry
func NewCoreModuleRegistry() *CoreModuleRegistry {
return &CoreModuleRegistry{
modules: make(map[string]StateInitFunc),
debug: false,
}
}
// EnableDebug turns on debug logging
func (r *CoreModuleRegistry) EnableDebug() {
r.debug = true
}
// debugLog prints debug messages if enabled
func (r *CoreModuleRegistry) debugLog(format string, args ...interface{}) {
if r.debug {
logger.Debug("[CoreModuleRegistry] "+format, args...)
}
}
@ -41,7 +25,6 @@ func (r *CoreModuleRegistry) Register(name string, initFunc StateInitFunc) {
r.mu.Lock()
defer r.mu.Unlock()
r.modules[name] = initFunc
r.debugLog("Registered module: %s", name)
}
// Initialize initializes all registered modules
@ -49,30 +32,16 @@ func (r *CoreModuleRegistry) Initialize(state *luajit.State) error {
r.mu.RLock()
defer r.mu.RUnlock()
r.debugLog("Initializing all modules...")
// Get all module init functions
initFuncs := r.getInitFuncs()
// Initialize modules one by one to better track issues
for name, initFunc := range initFuncs {
r.debugLog("Initializing module: %s", name)
if err := initFunc(state); err != nil {
r.debugLog("Failed to initialize module %s: %v", name, err)
return fmt.Errorf("failed to initialize module %s: %w", name, err)
}
r.debugLog("Module %s initialized successfully", name)
}
r.debugLog("All modules initialized successfully")
return nil
// Convert to StateInitFunc
initFunc := CombineInitFuncs(r.getInitFuncs()...)
return initFunc(state)
}
// getInitFuncs returns all module init functions
func (r *CoreModuleRegistry) getInitFuncs() map[string]StateInitFunc {
funcs := make(map[string]StateInitFunc, len(r.modules))
for name, initFunc := range r.modules {
funcs[name] = initFunc
func (r *CoreModuleRegistry) getInitFuncs() []StateInitFunc {
funcs := make([]StateInitFunc, 0, len(r.modules))
for _, initFunc := range r.modules {
funcs = append(funcs, initFunc)
}
return funcs
}
@ -84,11 +53,9 @@ func (r *CoreModuleRegistry) InitializeModule(state *luajit.State, name string)
initFunc, ok := r.modules[name]
if !ok {
r.debugLog("Module not found: %s", name)
return nil // Module not found, no error
}
r.debugLog("Reinitializing module: %s", name)
return initFunc(state)
}
@ -129,10 +96,8 @@ var GlobalRegistry = NewCoreModuleRegistry()
// Initialize global registry with core modules
func init() {
GlobalRegistry.EnableDebug() // Enable debugging by default
GlobalRegistry.Register("http", HTTPModuleInitFunc())
GlobalRegistry.Register("cookie", CookieModuleInitFunc())
logger.Debug("[CoreModuleRegistry] Core modules registered in init()")
}
// RegisterCoreModule is a helper to register a core module
@ -140,3 +105,6 @@ func init() {
func RegisterCoreModule(name string, initFunc StateInitFunc) {
GlobalRegistry.Register(name, initFunc)
}
// To add a new module, simply call:
// RegisterCoreModule("new_module_name", NewModuleInitFunc())

411
core/runner/Http.go
View File

@ -12,7 +12,6 @@ import (
"time"
luajit "git.sharkk.net/Sky/LuaJIT-to-Go"
"git.sharkk.net/Sky/Moonshark/core/logger"
)
// HTTPResponse represents an HTTP response from Lua
@ -365,51 +364,217 @@ func httpRequest(state *luajit.State) int {
return 1
}
// LuaHTTPModule is the pure Lua implementation of the HTTP module
const LuaHTTPModule = `
-- Table to store response data
__http_responses = {}
-- HTTP module implementation
local http = {
-- Set HTTP status code
set_status = function(code)
if type(code) ~= "number" then
error("http.set_status: status code must be a number", 2)
end
local resp = __http_responses[1] or {}
resp.status = code
__http_responses[1] = resp
end,
-- Set HTTP header
set_header = function(name, value)
if type(name) ~= "string" or type(value) ~= "string" then
error("http.set_header: name and value must be strings", 2)
end
local resp = __http_responses[1] or {}
resp.headers = resp.headers or {}
resp.headers[name] = value
__http_responses[1] = resp
end,
-- Set content type; set_header helper
set_content_type = function(content_type)
http.set_header("Content-Type", content_type)
end,
-- HTTP client submodule
client = {
-- Generic request function
request = function(method, url, body, options)
if type(method) ~= "string" then
error("http.client.request: method must be a string", 2)
end
if type(url) ~= "string" then
error("http.client.request: url must be a string", 2)
end
-- Call native implementation
return __http_request(method, url, body, options)
end,
-- Simple GET request
get = function(url, options)
return http.client.request("GET", url, nil, options)
end,
-- Simple POST request with automatic content-type
post = function(url, body, options)
options = options or {}
return http.client.request("POST", url, body, options)
end,
-- Simple PUT request with automatic content-type
put = function(url, body, options)
options = options or {}
return http.client.request("PUT", url, body, options)
end,
-- Simple DELETE request
delete = function(url, options)
return http.client.request("DELETE", url, nil, options)
end,
-- Simple PATCH request
patch = function(url, body, options)
options = options or {}
return http.client.request("PATCH", url, body, options)
end,
-- Simple HEAD request
head = function(url, options)
options = options or {}
local old_options = options
options = {headers = old_options.headers, timeout = old_options.timeout, query = old_options.query}
local response = http.client.request("HEAD", url, nil, options)
return response
end,
-- Simple OPTIONS request
options = function(url, options)
return http.client.request("OPTIONS", url, nil, options)
end,
-- Shorthand function to directly get JSON
get_json = function(url, options)
options = options or {}
local response = http.client.get(url, options)
if response.ok and response.json then
return response.json
end
return nil, response
end,
-- Utility to build a URL with query parameters
build_url = function(base_url, params)
if not params or type(params) ~= "table" then
return base_url
end
local query = {}
for k, v in pairs(params) do
if type(v) == "table" then
for _, item in ipairs(v) do
table.insert(query, k .. "=" .. tostring(item))
end
else
table.insert(query, k .. "=" .. tostring(v))
end
end
if #query > 0 then
if base_url:find("?") then
return base_url .. "&" .. table.concat(query, "&")
else
return base_url .. "?" .. table.concat(query, "&")
end
end
return base_url
end
}
}
-- Install HTTP module
_G.http = http
-- Override sandbox executor to clear HTTP responses
local old_execute_sandbox = __execute_sandbox
__execute_sandbox = function(bytecode, ctx)
-- Clear previous response for this thread
__http_responses[1] = nil
-- Execute the original function
local result = old_execute_sandbox(bytecode, ctx)
-- Return the result unchanged
return result
end
-- Make sure the HTTP module is accessible in sandbox
if __env_system and __env_system.base_env then
__env_system.base_env.http = http
end
`
// HTTPModuleInitFunc returns an initializer function for the HTTP module
func HTTPModuleInitFunc() StateInitFunc {
return func(state *luajit.State) error {
// CRITICAL: Register the native Go function first
// This must be done BEFORE any Lua code that references it
// The important fix: register the Go function directly to the global environment
if err := state.RegisterGoFunction(httpRequestFuncName, httpRequest); err != nil {
logger.Error("[HTTP Module] Failed to register __http_request function: %v\n", err)
return err
}
// Set up default HTTP client configuration
setupHTTPClientConfig(state)
// Initialize Lua HTTP module
// Initialize pure Lua HTTP module
if err := state.DoString(LuaHTTPModule); err != nil {
logger.Error("[HTTP Module] Failed to initialize HTTP module Lua code: %v\n", err)
return err
}
// Verify HTTP client functions are available
verifyHTTPClient(state)
// Check for existing config (in sandbox modules)
state.GetGlobal("__sandbox_modules")
if !state.IsNil(-1) && state.IsTable(-1) {
state.PushString("__http_client_config")
state.GetTable(-2)
return nil
if !state.IsNil(-1) && state.IsTable(-1) {
// Use the config from sandbox modules
state.SetGlobal("__http_client_config")
state.Pop(1) // Pop the sandbox modules table
return nil
}
state.Pop(1) // Pop the nil or non-table value
}
state.Pop(1) // Pop the nil or sandbox modules table
// Setup default configuration if no custom config exists
state.NewTable()
state.PushNumber(float64(DefaultHTTPClientConfig.MaxTimeout / time.Second))
state.SetField(-2, "max_timeout")
state.PushNumber(float64(DefaultHTTPClientConfig.DefaultTimeout / time.Second))
state.SetField(-2, "default_timeout")
state.PushNumber(float64(DefaultHTTPClientConfig.MaxResponseSize))
state.SetField(-2, "max_response_size")
state.PushBoolean(DefaultHTTPClientConfig.AllowRemote)
state.SetField(-2, "allow_remote")
state.SetGlobal("__http_client_config")
// Ensure the Go function is registered with the base environment
// This is critical to make it persist across reloads
return state.DoString(`
-- Make the __http_request function available in the base environment
if __env_system and __env_system.base_env then
__env_system.base_env.__http_request = __http_request
end
`)
}
}
// Helper to set up HTTP client config
func setupHTTPClientConfig(state *luajit.State) {
state.NewTable()
state.PushNumber(float64(DefaultHTTPClientConfig.MaxTimeout / time.Second))
state.SetField(-2, "max_timeout")
state.PushNumber(float64(DefaultHTTPClientConfig.DefaultTimeout / time.Second))
state.SetField(-2, "default_timeout")
state.PushNumber(float64(DefaultHTTPClientConfig.MaxResponseSize))
state.SetField(-2, "max_response_size")
state.PushBoolean(DefaultHTTPClientConfig.AllowRemote)
state.SetField(-2, "allow_remote")
state.SetGlobal("__http_client_config")
}
// GetHTTPResponse extracts the HTTP response from Lua state
func GetHTTPResponse(state *luajit.State) (*HTTPResponse, bool) {
response := NewHTTPResponse()
@ -504,187 +669,3 @@ func RestrictHTTPToLocalhost() RunnerOption {
AllowRemote: false,
})
}
// Verify that HTTP client is properly set up
func verifyHTTPClient(state *luajit.State) {
// Get the client table
state.GetGlobal("http")
if !state.IsTable(-1) {
logger.Warning("[HTTP Module] 'http' is not a table\n")
state.Pop(1)
return
}
state.GetField(-1, "client")
if !state.IsTable(-1) {
logger.Warning("[HTTP Module] 'http.client' is not a table\n")
state.Pop(2)
return
}
// Check for get function
state.GetField(-1, "get")
if !state.IsFunction(-1) {
logger.Warning("[HTTP Module] 'http.client.get' is not a function\n")
} else {
logger.Debug("[HTTP Module] 'http.client.get' is properly registered\n")
}
state.Pop(1)
// Check for the request function
state.GetField(-1, "request")
if !state.IsFunction(-1) {
logger.Warning("[HTTP Module] 'http.client.request' is not a function\n")
} else {
logger.Debug("[HTTP Module] 'http.client.request' is properly registered\n")
}
state.Pop(3) // Pop request, client, http
}
const LuaHTTPModule = `
-- Table to store response data
__http_responses = {}
-- HTTP module implementation
local http = {
-- Set HTTP status code
set_status = function(code)
if type(code) ~= "number" then
error("http.set_status: status code must be a number", 2)
end
local resp = __http_responses[1] or {}
resp.status = code
__http_responses[1] = resp
end,
-- Set HTTP header
set_header = function(name, value)
if type(name) ~= "string" or type(value) ~= "string" then
error("http.set_header: name and value must be strings", 2)
end
local resp = __http_responses[1] or {}
resp.headers = resp.headers or {}
resp.headers[name] = value
__http_responses[1] = resp
end,
-- Set content type; set_header helper
set_content_type = function(content_type)
http.set_header("Content-Type", content_type)
end,
-- HTTP client submodule
client = {
-- Generic request function
request = function(method, url, body, options)
if type(method) ~= "string" then
error("http.client.request: method must be a string", 2)
end
if type(url) ~= "string" then
error("http.client.request: url must be a string", 2)
end
-- Call native implementation (this is the critical part)
local result = __http_request(method, url, body, options)
return result
end,
-- Simple GET request
get = function(url, options)
return http.client.request("GET", url, nil, options)
end,
-- Simple POST request with automatic content-type
post = function(url, body, options)
options = options or {}
return http.client.request("POST", url, body, options)
end,
-- Simple PUT request with automatic content-type
put = function(url, body, options)
options = options or {}
return http.client.request("PUT", url, body, options)
end,
-- Simple DELETE request
delete = function(url, options)
return http.client.request("DELETE", url, nil, options)
end,
-- Simple PATCH request
patch = function(url, body, options)
options = options or {}
return http.client.request("PATCH", url, body, options)
end,
-- Simple HEAD request
head = function(url, options)
options = options or {}
local old_options = options
options = {headers = old_options.headers, timeout = old_options.timeout, query = old_options.query}
local response = http.client.request("HEAD", url, nil, options)
return response
end,
-- Simple OPTIONS request
options = function(url, options)
return http.client.request("OPTIONS", url, nil, options)
end,
-- Shorthand function to directly get JSON
get_json = function(url, options)
options = options or {}
local response = http.client.get(url, options)
if response.ok and response.json then
return response.json
end
return nil, response
end,
-- Utility to build a URL with query parameters
build_url = function(base_url, params)
if not params or type(params) ~= "table" then
return base_url
end
local query = {}
for k, v in pairs(params) do
if type(v) == "table" then
for _, item in ipairs(v) do
table.insert(query, k .. "=" .. tostring(item))
end
else
table.insert(query, k .. "=" .. tostring(v))
end
end
if #query > 0 then
if base_url:find("?") then
return base_url .. "&" .. table.concat(query, "&")
else
return base_url .. "?" .. table.concat(query, "&")
end
end
return base_url
end
}
}
-- Install HTTP module
_G.http = http
-- Clear previous responses when executing scripts
local old_execute_script = __execute_script
if old_execute_script then
__execute_script = function(fn, ctx)
-- Clear previous response
__http_responses[1] = nil
-- Execute original function
return old_execute_script(fn, ctx)
end
end
`

199
core/runner/LuaRunner.go
View File

@ -8,7 +8,6 @@ import (
"sync/atomic"
luajit "git.sharkk.net/Sky/LuaJIT-to-Go"
"git.sharkk.net/Sky/Moonshark/core/logger"
)
// Common errors
@ -41,7 +40,6 @@ type LuaRunner struct {
bufferSize int // Size of the job queue buffer
moduleLoader *NativeModuleLoader // Native module loader for require
sandbox *Sandbox // The sandbox environment
debug bool // Enable debug logging
}
// WithBufferSize sets the job queue buffer size
@ -73,20 +71,12 @@ func WithLibDirs(dirs ...string) RunnerOption {
}
}
// WithDebugEnabled enables debug output
func WithDebugEnabled() RunnerOption {
return func(r *LuaRunner) {
r.debug = true
}
}
// NewRunner creates a new LuaRunner
func NewRunner(options ...RunnerOption) (*LuaRunner, error) {
// Default configuration
runner := &LuaRunner{
bufferSize: 10, // Default buffer size
sandbox: NewSandbox(),
debug: false,
}
// Apply options
@ -94,6 +84,13 @@ func NewRunner(options ...RunnerOption) (*LuaRunner, error) {
opt(runner)
}
// Initialize Lua state
state := luajit.New()
if state == nil {
return nil, errors.New("failed to create Lua state")
}
runner.state = state
// Create job queue
runner.jobQueue = make(chan job, runner.bufferSize)
runner.isRunning.Store(true)
@ -107,9 +104,36 @@ func NewRunner(options ...RunnerOption) (*LuaRunner, error) {
runner.moduleLoader = NewNativeModuleLoader(requireConfig)
}
// Initialize Lua state
if err := runner.initState(true); err != nil {
return nil, err
// Set up require paths and mechanism
if err := runner.moduleLoader.SetupRequire(state); err != nil {
state.Close()
return nil, ErrInitFailed
}
// Initialize all core modules from the registry
if err := GlobalRegistry.Initialize(state); err != nil {
state.Close()
return nil, ErrInitFailed
}
// Set up sandbox after core modules are initialized
if err := runner.sandbox.Setup(state); err != nil {
state.Close()
return nil, ErrInitFailed
}
// Preload all modules into package.loaded
if err := runner.moduleLoader.PreloadAllModules(state); err != nil {
state.Close()
return nil, errors.New("failed to preload modules")
}
// Run init function if provided
if runner.initFunc != nil {
if err := runner.initFunc(state); err != nil {
state.Close()
return nil, ErrInitFailed
}
}
// Start the event loop
@ -119,130 +143,10 @@ func NewRunner(options ...RunnerOption) (*LuaRunner, error) {
return runner, nil
}
// debugLog logs a message if debug mode is enabled
func (r *LuaRunner) debugLog(format string, args ...interface{}) {
if r.debug {
logger.Debug("[LuaRunner] "+format, args...)
}
}
// initState initializes or reinitializes the Lua state
func (r *LuaRunner) initState(initial bool) error {
r.debugLog("Initializing Lua state (initial=%v)", initial)
// Clean up existing state if there is one
if r.state != nil {
r.debugLog("Cleaning up existing state")
// Always call Cleanup before Close to properly free function pointers
r.state.Cleanup()
r.state.Close()
r.state = nil
}
// Create fresh state
state := luajit.New()
if state == nil {
return errors.New("failed to create Lua state")
}
r.debugLog("Created new Lua state")
// Set up require paths and mechanism
if err := r.moduleLoader.SetupRequire(state); err != nil {
r.debugLog("Failed to set up require: %v", err)
state.Cleanup()
state.Close()
return ErrInitFailed
}
r.debugLog("Require system initialized")
// Initialize all core modules from the registry
if err := GlobalRegistry.Initialize(state); err != nil {
r.debugLog("Failed to initialize core modules: %v", err)
state.Cleanup()
state.Close()
return ErrInitFailed
}
r.debugLog("Core modules initialized")
// Check if http module is properly registered
testResult, err := state.ExecuteWithResult(`
if type(http) == "table" and type(http.client) == "table" and
type(http.client.get) == "function" then
return true
else
return false
end
`)
if err != nil || testResult != true {
r.debugLog("HTTP module verification failed: %v, result: %v", err, testResult)
} else {
r.debugLog("HTTP module verified OK")
}
// Verify __http_request function
testResult, _ = state.ExecuteWithResult(`return type(__http_request)`)
r.debugLog("__http_request function is of type: %v", testResult)
// Set up sandbox after core modules are initialized
if err := r.sandbox.Setup(state); err != nil {
r.debugLog("Failed to set up sandbox: %v", err)
state.Cleanup()
state.Close()
return ErrInitFailed
}
r.debugLog("Sandbox environment set up")
// Preload all modules into package.loaded
if err := r.moduleLoader.PreloadAllModules(state); err != nil {
r.debugLog("Failed to preload modules: %v", err)
state.Cleanup()
state.Close()
return errors.New("failed to preload modules")
}
r.debugLog("All modules preloaded")
// Run init function if provided
if r.initFunc != nil {
if err := r.initFunc(state); err != nil {
r.debugLog("Custom init function failed: %v", err)
state.Cleanup()
state.Close()
return ErrInitFailed
}
r.debugLog("Custom init function completed")
}
// Test for HTTP module again after full initialization
testResult, err = state.ExecuteWithResult(`
if type(http) == "table" and type(http.client) == "table" and
type(http.client.get) == "function" then
return true
else
return false
end
`)
if err != nil || testResult != true {
r.debugLog("Final HTTP module verification failed: %v, result: %v", err, testResult)
} else {
r.debugLog("Final HTTP module verification OK")
}
r.state = state
r.debugLog("State initialization complete")
return nil
}
// processJobs handles the job queue
func (r *LuaRunner) processJobs() {
defer r.wg.Done()
defer func() {
if r.state != nil {
r.debugLog("Cleaning up Lua state in processJobs")
r.state.Cleanup()
r.state.Close()
r.state = nil
}
}()
defer r.state.Close()
for job := range r.jobQueue {
// Execute the job and send result
@ -271,13 +175,6 @@ func (r *LuaRunner) executeJob(j job) JobResult {
ctx = j.Context.Values
}
r.mu.RLock()
defer r.mu.RUnlock()
if r.state == nil {
return JobResult{nil, errors.New("lua state is not initialized")}
}
// Execute in sandbox
value, err := r.sandbox.Execute(r.state, j.Bytecode, ctx)
return JobResult{value, err}
@ -363,26 +260,15 @@ func (r *LuaRunner) Close() error {
// NotifyFileChanged handles file change notifications from watchers
func (r *LuaRunner) NotifyFileChanged(filePath string) bool {
r.debugLog("File change detected: %s", filePath)
r.mu.Lock()
defer r.mu.Unlock()
// Reset the entire state on file changes
err := r.initState(false)
if err != nil {
r.debugLog("Failed to reinitialize state: %v", err)
return false
if r.moduleLoader != nil {
return r.moduleLoader.NotifyFileChanged(r.state, filePath)
}
r.debugLog("State successfully reinitialized")
return true
return false
}
// ResetModuleCache clears non-core modules from package.loaded
func (r *LuaRunner) ResetModuleCache() {
if r.moduleLoader != nil {
r.debugLog("Resetting module cache")
r.moduleLoader.ResetModules(r.state)
}
}
@ -390,7 +276,6 @@ func (r *LuaRunner) ResetModuleCache() {
// ReloadAllModules reloads all modules into package.loaded
func (r *LuaRunner) ReloadAllModules() error {
if r.moduleLoader != nil {
r.debugLog("Reloading all modules")
return r.moduleLoader.PreloadAllModules(r.state)
}
return nil
@ -399,7 +284,6 @@ func (r *LuaRunner) ReloadAllModules() error {
// RefreshModuleByName invalidates a specific module in package.loaded
func (r *LuaRunner) RefreshModuleByName(modName string) bool {
if r.state != nil {
r.debugLog("Refreshing module: %s", modName)
if err := r.state.DoString(`package.loaded["` + modName + `"] = nil`); err != nil {
return false
}
@ -410,7 +294,6 @@ func (r *LuaRunner) RefreshModuleByName(modName string) bool {
// AddModule adds a module to the sandbox environment
func (r *LuaRunner) AddModule(name string, module any) {
r.debugLog("Adding module: %s", name)
r.sandbox.AddModule(name, module)
}

303
core/runner/Sandbox.go
View File

@ -1,29 +1,23 @@
package runner
import (
"fmt"
luajit "git.sharkk.net/Sky/LuaJIT-to-Go"
"git.sharkk.net/Sky/Moonshark/core/logger"
)
// Sandbox manages a simplified Lua environment
// Sandbox manages a sandboxed Lua environment
type Sandbox struct {
modules map[string]any // Custom modules for environment
debug bool // Enable debug output
modules map[string]any // Custom modules for environment
initialized bool // Whether base environment is initialized
}
// NewSandbox creates a new sandbox
func NewSandbox() *Sandbox {
return &Sandbox{
modules: make(map[string]any),
debug: false,
s := &Sandbox{
modules: make(map[string]any),
initialized: false,
}
}
// EnableDebug turns on debug output
func (s *Sandbox) EnableDebug() {
s.debug = true
return s
}
// AddModule adds a module to the sandbox environment
@ -31,109 +25,228 @@ func (s *Sandbox) AddModule(name string, module any) {
s.modules[name] = module
}
// debugLog prints debug messages if debug is enabled
func (s *Sandbox) debugLog(format string, args ...interface{}) {
if s.debug {
logger.Debug("[Sandbox Debug] "+format, args...)
}
}
// Setup initializes the sandbox in a Lua state
func (s *Sandbox) Setup(state *luajit.State) error {
s.debugLog("Setting up sandbox environment")
// Register modules in the global environment
for name, module := range s.modules {
s.debugLog("Registering module: %s", name)
if err := state.PushValue(module); err != nil {
s.debugLog("Failed to register module %s: %v", name, err)
return err
}
state.SetGlobal(name)
// Register modules
if err := s.registerModules(state); err != nil {
return err
}
// Initialize simple environment setup
err := state.DoString(`
-- Global tables for response handling
__http_responses = __http_responses or {}
// Create high-performance persistent environment
return state.DoString(`
-- Global shared environment (created once)
__env_system = __env_system or {
base_env = nil, -- Template environment
initialized = false, -- Initialization flag
env_pool = {}, -- Pre-allocated environment pool
pool_size = 0, -- Current pool size
max_pool_size = 8 -- Maximum pool size
}
-- Simple environment creation
function __create_env(ctx)
-- Create environment inheriting from _G
local env = setmetatable({}, {__index = _G})
-- Initialize base environment once
if not __env_system.initialized then
-- Create base environment with all standard libraries
local base = {}
-- Add context if provided
if ctx then
env.ctx = ctx
end
-- Safe standard libraries
base.string = string
base.table = table
base.math = math
base.os = {
time = os.time,
date = os.date,
difftime = os.difftime,
clock = os.clock
}
return env
-- Basic functions
base.print = print
base.tonumber = tonumber
base.tostring = tostring
base.type = type
base.pairs = pairs
base.ipairs = ipairs
base.next = next
base.select = select
base.unpack = unpack
base.pcall = pcall
base.xpcall = xpcall
base.error = error
base.assert = assert
-- Package system is shared for performance
base.package = {
loaded = package.loaded,
path = package.path,
preload = package.preload
}
base.http = http
base.cookie = cookie
-- http_client module is now part of http.client
-- Add registered custom modules
if __sandbox_modules then
for name, mod in pairs(__sandbox_modules) do
base[name] = mod
end
end
-- Store base environment
__env_system.base_env = base
__env_system.initialized = true
end
-- Global variable for tracking current environment
__last_env = nil
-- Fast environment creation with pre-allocation
function __get_sandbox_env(ctx)
local env
-- Try to reuse from pool
if __env_system.pool_size > 0 then
env = table.remove(__env_system.env_pool)
__env_system.pool_size = __env_system.pool_size - 1
-- Clear any previous context
env.ctx = ctx or nil
-- Clear any previous response
env._response = nil
else
-- Create new environment with metatable inheritance
env = setmetatable({}, {
__index = __env_system.base_env
})
-- Set context if provided
if ctx then
env.ctx = ctx
end
-- Install the fast require implementation
env.require = function(modname)
return __fast_require(env, modname)
end
-- Install cookie module methods directly into environment
env.cookie = {
get = function(name)
if type(name) ~= "string" then
error("cookie.get: name must be a string", 2)
end
if env.ctx and env.ctx.cookies and env.ctx.cookies[name] then
return tostring(env.ctx.cookies[name])
end
return nil
end,
set = cookie.set,
remove = cookie.remove
}
end
-- Store reference to current environment
__last_env = env
return env
end
-- Execute script with clean environment
function __execute_script(fn, ctx)
-- Clear previous responses
__http_responses[1] = nil
-- Return environment to pool for reuse
function __recycle_env(env)
-- Only recycle if pool isn't full
if __env_system.pool_size < __env_system.max_pool_size then
-- Clear context reference to avoid memory leaks
env.ctx = nil
-- Don't clear response data - we need it for extraction
-- Create environment
local env = __create_env(ctx)
-- Add to pool
table.insert(__env_system.env_pool, env)
__env_system.pool_size = __env_system.pool_size + 1
end
end
-- Set environment for function
setfenv(fn, env)
-- Hyper-optimized sandbox executor
function __execute_sandbox(bytecode, ctx)
-- Get environment (from pool if available)
local env = __get_sandbox_env(ctx)
-- Set environment for bytecode
setfenv(bytecode, env)
-- Execute with protected call
local ok, result = pcall(fn)
if not ok then
local success, result = pcall(bytecode)
-- Recycle environment for future use
__recycle_env(env)
-- Process result
if not success then
error(result, 0)
end
return result
end
`)
if err != nil {
s.debugLog("Failed to set up sandbox: %v", err)
return err
-- Run minimal GC for overall health
collectgarbage("step", 10)
`)
}
// registerModules registers custom modules in the Lua state
func (s *Sandbox) registerModules(state *luajit.State) error {
// Create or get module registry table
state.GetGlobal("__sandbox_modules")
if state.IsNil(-1) {
// Table doesn't exist, create it
state.Pop(1)
state.NewTable()
state.SetGlobal("__sandbox_modules")
state.GetGlobal("__sandbox_modules")
}
s.debugLog("Sandbox setup complete")
// Add modules to registry
for name, module := range s.modules {
state.PushString(name)
if err := state.PushValue(module); err != nil {
state.Pop(2)
return err
}
state.SetTable(-3)
}
// Verify HTTP module is accessible
httpResult, _ := state.ExecuteWithResult(`
if type(http) == "table" and
type(http.client) == "table" and
type(http.client.get) == "function" then
return "HTTP module verified OK"
else
local status = {
http = type(http),
client = type(http) == "table" and type(http.client) or "N/A",
get = type(http) == "table" and type(http.client) == "table" and type(http.client.get) or "N/A"
}
return status
end
`)
s.debugLog("HTTP verification result: %v", httpResult)
// Pop module table
state.Pop(1)
return nil
}
// Execute runs bytecode in the sandbox
func (s *Sandbox) Execute(state *luajit.State, bytecode []byte, ctx map[string]any) (any, error) {
// Update custom modules if needed
if !s.initialized {
if err := s.registerModules(state); err != nil {
return nil, err
}
s.initialized = true
}
// Load bytecode
if err := state.LoadBytecode(bytecode, "script"); err != nil {
s.debugLog("Failed to load bytecode: %v", err)
return nil, err
}
// Prepare context
if ctx != nil {
// Create context table if provided
if len(ctx) > 0 {
// Preallocate table with appropriate size
state.CreateTable(0, len(ctx))
// Add context entries
for k, v := range ctx {
state.PushString(k)
if err := state.PushValue(v); err != nil {
state.Pop(2)
s.debugLog("Failed to push context value %s: %v", k, err)
return nil, err
}
state.SetTable(-3)
@ -142,37 +255,31 @@ func (s *Sandbox) Execute(state *luajit.State, bytecode []byte, ctx map[string]a
state.PushNil() // No context
}
// Get execution function
state.GetGlobal("__execute_script")
if !state.IsFunction(-1) {
state.Pop(2) // Pop nil and non-function
s.debugLog("__execute_script is not a function")
return nil, fmt.Errorf("sandbox execution function not found")
}
// Get optimized sandbox executor
state.GetGlobal("__execute_sandbox")
// Push arguments
state.PushCopy(-3) // bytecode function
state.PushCopy(-3) // context
// Setup call with correct argument order
state.PushCopy(-3) // Copy bytecode function
state.PushCopy(-3) // Copy context
// Clean up stack
state.Remove(-5) // original bytecode
state.Remove(-4) // original context
state.Remove(-5) // Remove original bytecode
state.Remove(-4) // Remove original context
// Call with 2 args, 1 result
// Call optimized sandbox executor
if err := state.Call(2, 1); err != nil {
s.debugLog("Execution failed: %v", err)
return nil, err
}
// Get result
result, err := state.ToValue(-1)
state.Pop(1)
state.Pop(1) // Pop result
// Check for HTTP response
httpResponse, hasResponse := GetHTTPResponse(state)
if hasResponse {
// Check if HTTP response was set
httpResponse, hasHTTPResponse := GetHTTPResponse(state)
if hasHTTPResponse {
httpResponse.Body = result
return httpResponse, nil
return httpResponse, err
}
return result, err

56
core/watchers/api.go
View File

@ -16,9 +16,9 @@ var (
)
// GetWatcherManager returns the global watcher manager, creating it if needed
func GetWatcherManager(adaptive bool) *WatcherManager {
func GetWatcherManager(log *logger.Logger, adaptive bool) *WatcherManager {
globalManagerOnce.Do(func() {
globalManager = NewWatcherManager(adaptive)
globalManager = NewWatcherManager(log, adaptive)
})
return globalManager
}
@ -39,7 +39,7 @@ func WatchDirectory(config DirectoryWatcherConfig, manager *WatcherManager) (*Wa
manager: manager,
}
logger.Debug("Started watching directory: %s", config.Dir)
config.Log.Debug("Started watching directory: %s", config.Dir)
return w, nil
}
@ -56,22 +56,14 @@ func (w *Watcher) Close() error {
return nil
}
// WatchLuaRouter sets up a watcher for a LuaRouter's routes directory; also updates
// the LuaRunner so that the state can be rebuilt
func WatchLuaRouter(router *routers.LuaRouter, runner *runner.LuaRunner, routesDir string) (*Watcher, error) {
manager := GetWatcherManager(true)
runnerRefresh := func() error {
logger.Debug("Refreshing LuaRunner state due to file change")
runner.NotifyFileChanged("")
return nil
}
combinedCallback := combineCallbacks(router.Refresh, runnerRefresh)
// WatchLuaRouter sets up a watcher for a LuaRouter's routes directory
func WatchLuaRouter(router *routers.LuaRouter, routesDir string, log *logger.Logger) (*Watcher, error) {
manager := GetWatcherManager(log, true) // Use adaptive polling
config := DirectoryWatcherConfig{
Dir: routesDir,
Callback: combinedCallback,
Callback: router.Refresh,
Log: log,
Recursive: true,
}
@ -80,17 +72,18 @@ func WatchLuaRouter(router *routers.LuaRouter, runner *runner.LuaRunner, routesD
return nil, err
}
logger.Info("Started watching Lua routes directory: %s", routesDir)
log.Info("Started watching Lua routes directory: %s", routesDir)
return watcher, nil
}
// WatchStaticRouter sets up a watcher for a StaticRouter's root directory
func WatchStaticRouter(router *routers.StaticRouter, staticDir string) (*Watcher, error) {
manager := GetWatcherManager(true)
func WatchStaticRouter(router *routers.StaticRouter, staticDir string, log *logger.Logger) (*Watcher, error) {
manager := GetWatcherManager(log, true) // Use adaptive polling
config := DirectoryWatcherConfig{
Dir: staticDir,
Callback: router.Refresh,
Log: log,
Recursive: true,
}
@ -99,13 +92,13 @@ func WatchStaticRouter(router *routers.StaticRouter, staticDir string) (*Watcher
return nil, err
}
logger.Info("Started watching static files directory: %s", staticDir)
log.Info("Started watching static files directory: %s", staticDir)
return watcher, nil
}
// WatchLuaModules sets up watchers for Lua module directories
func WatchLuaModules(luaRunner *runner.LuaRunner, libDirs []string) ([]*Watcher, error) {
manager := GetWatcherManager(true)
func WatchLuaModules(luaRunner *runner.LuaRunner, libDirs []string, log *logger.Logger) ([]*Watcher, error) {
manager := GetWatcherManager(log, true) // Use adaptive polling
watchers := make([]*Watcher, 0, len(libDirs))
for _, dir := range libDirs {
@ -113,11 +106,11 @@ func WatchLuaModules(luaRunner *runner.LuaRunner, libDirs []string) ([]*Watcher,
dirCopy := dir // Capture for closure
callback := func() error {
logger.Debug("Detected changes in Lua module directory: %s", dirCopy)
log.Debug("Detected changes in Lua module directory: %s", dirCopy)
// Reload modules from this directory
if err := luaRunner.ReloadAllModules(); err != nil {
logger.Warning("Error reloading modules: %v", err)
log.Warning("Error reloading modules: %v", err)
}
return nil
@ -126,6 +119,7 @@ func WatchLuaModules(luaRunner *runner.LuaRunner, libDirs []string) ([]*Watcher,
config := DirectoryWatcherConfig{
Dir: dir,
Callback: callback,
Log: log,
Recursive: true,
}
@ -139,7 +133,7 @@ func WatchLuaModules(luaRunner *runner.LuaRunner, libDirs []string) ([]*Watcher,
}
watchers = append(watchers, watcher)
logger.Info("Started watching Lua modules directory: %s", dir)
log.Info("Started watching Lua modules directory: %s", dir)
}
return watchers, nil
@ -152,15 +146,3 @@ func ShutdownWatcherManager() {
globalManager = nil
}
}
// combineCallbacks creates a single callback function from multiple callbacks
func combineCallbacks(callbacks ...func() error) func() error {
return func() error {
for _, callback := range callbacks {
if err := callback(); err != nil {
return err
}
}
return nil
}
}

11
core/watchers/dir.go
View File

@ -31,6 +31,7 @@ type DirectoryWatcher struct {
// Configuration
callback func() error
log *logger.Logger
debounceTime time.Duration
recursive bool
@ -48,6 +49,9 @@ type DirectoryWatcherConfig struct {
// Callback function to call when changes are detected
Callback func() error
// Logger instance
Log *logger.Logger
// Debounce time (0 means use default)
DebounceTime time.Duration
@ -66,6 +70,7 @@ func NewDirectoryWatcher(config DirectoryWatcherConfig) (*DirectoryWatcher, erro
dir: config.Dir,
files: make(map[string]FileInfo),
callback: config.Callback,
log: config.Log,
debounceTime: debounceTime,
recursive: config.Recursive,
}
@ -212,15 +217,15 @@ func (w *DirectoryWatcher) notifyChange() {
// logDebug logs a debug message with the watcher's directory prefix
func (w *DirectoryWatcher) logDebug(format string, args ...any) {
logger.Debug("[Watcher] [%s] %s", w.dir, fmt.Sprintf(format, args...))
w.log.Debug("[Watcher] [%s] %s", w.dir, fmt.Sprintf(format, args...))
}
// logWarning logs a warning message with the watcher's directory prefix
func (w *DirectoryWatcher) logWarning(format string, args ...any) {
logger.Warning("[Watcher] [%s] %s", w.dir, fmt.Sprintf(format, args...))
w.log.Warning("[Watcher] [%s] %s", w.dir, fmt.Sprintf(format, args...))
}
// logError logs an error message with the watcher's directory prefix
func (w *DirectoryWatcher) logError(format string, args ...any) {
logger.Error("[Watcher] [%s] %s", w.dir, fmt.Sprintf(format, args...))
w.log.Error("[Watcher] [%s] %s", w.dir, fmt.Sprintf(format, args...))
}

16
core/watchers/manager.go
View File

@ -29,18 +29,22 @@ type WatcherManager struct {
done chan struct{}
ticker *time.Ticker
// Logger
log *logger.Logger
// Wait group for shutdown coordination
wg sync.WaitGroup
}
// NewWatcherManager creates a new watcher manager
func NewWatcherManager(adaptive bool) *WatcherManager {
func NewWatcherManager(log *logger.Logger, adaptive bool) *WatcherManager {
manager := &WatcherManager{
watchers: make(map[string]*DirectoryWatcher),
pollInterval: defaultPollInterval,
adaptive: adaptive,
lastActivity: time.Now(),
done: make(chan struct{}),
log: log,
}
// Start the polling loop
@ -67,7 +71,7 @@ func (m *WatcherManager) AddWatcher(watcher *DirectoryWatcher) {
defer m.mu.Unlock()
m.watchers[watcher.dir] = watcher
logger.Debug("[WatcherManager] Added watcher for directory: %s", watcher.dir)
m.log.Debug("[WatcherManager] Added watcher for directory: %s", watcher.dir)
}
// RemoveWatcher unregisters a directory watcher
@ -76,7 +80,7 @@ func (m *WatcherManager) RemoveWatcher(dir string) {
defer m.mu.Unlock()
delete(m.watchers, dir)
logger.Debug("[WatcherManager] Removed watcher for directory: %s", dir)
m.log.Debug("[WatcherManager] Removed watcher for directory: %s", dir)
}
// pollLoop is the main polling loop that checks all watched directories
@ -96,7 +100,7 @@ func (m *WatcherManager) pollLoop() {
if m.pollInterval > defaultPollInterval {
m.pollInterval = defaultPollInterval
m.ticker.Reset(m.pollInterval)
logger.Debug("[WatcherManager] Reset to base polling interval: %v", m.pollInterval)
m.log.Debug("[WatcherManager] Reset to base polling interval: %v", m.pollInterval)
}
} else {
// No activity, consider slowing down polling
@ -104,7 +108,7 @@ func (m *WatcherManager) pollLoop() {
if m.pollInterval == defaultPollInterval && inactiveDuration > inactivityThreshold {
m.pollInterval = extendedPollInterval
m.ticker.Reset(m.pollInterval)
logger.Debug("[WatcherManager] Extended polling interval to: %v after %v of inactivity",
m.log.Debug("[WatcherManager] Extended polling interval to: %v after %v of inactivity",
m.pollInterval, inactiveDuration.Round(time.Minute))
}
}
@ -125,7 +129,7 @@ func (m *WatcherManager) checkAllDirectories() bool {
for _, watcher := range m.watchers {
changed, err := watcher.checkForChanges()
if err != nil {
logger.Error("[WatcherManager] Error checking directory %s: %v", watcher.dir, err)
m.log.Error("[WatcherManager] Error checking directory %s: %v", watcher.dir, err)
continue
}

94
moonshark.go
View File

@ -26,7 +26,7 @@ type WatcherConfig struct {
}
// initRouters sets up the Lua and static routers
func initRouters(routesDir, staticDir string) (*routers.LuaRouter, *routers.StaticRouter, error) {
func initRouters(routesDir, staticDir string, log *logger.Logger) (*routers.LuaRouter, *routers.StaticRouter, error) {
// Ensure directories exist
if err := utils.EnsureDir(routesDir); err != nil {
return nil, nil, fmt.Errorf("routes directory doesn't exist, and could not create it: %v", err)
@ -41,12 +41,12 @@ func initRouters(routesDir, staticDir string) (*routers.LuaRouter, *routers.Stat
// Check if this is a compilation warning or a more serious error
if errors.Is(err, routers.ErrRoutesCompilationErrors) {
// Some routes failed to compile, but router is still usable
logger.Warning("Some Lua routes failed to compile. Check logs for details.")
log.Warning("Some Lua routes failed to compile. Check logs for details.")
// Log details about each failed route
if failedRoutes := luaRouter.ReportFailedRoutes(); len(failedRoutes) > 0 {
for _, re := range failedRoutes {
logger.Error("Route %s %s failed to compile: %v", re.Method, re.Path, re.Err)
log.Error("Route %s %s failed to compile: %v", re.Method, re.Path, re.Err)
}
}
} else {
@ -54,14 +54,14 @@ func initRouters(routesDir, staticDir string) (*routers.LuaRouter, *routers.Stat
return nil, nil, fmt.Errorf("failed to initialize Lua router: %v", err)
}
}
logger.Info("Lua router initialized with routes from %s", routesDir)
log.Info("Lua router initialized with routes from %s", routesDir)
// Initialize static file router
staticRouter, err := routers.NewStaticRouter(staticDir)
staticRouter, err := routers.NewStaticRouterWithLogger(staticDir, log)
if err != nil {
return nil, nil, fmt.Errorf("failed to initialize static router: %v", err)
}
logger.Info("Static router initialized with files from %s", staticDir)
log.Info("Static router initialized with files from %s", staticDir)
staticRouter.EnableDebugLog()
return luaRouter, staticRouter, nil
@ -70,15 +70,15 @@ func initRouters(routesDir, staticDir string) (*routers.LuaRouter, *routers.Stat
// setupWatchers initializes and starts all file watchers
func setupWatchers(luaRouter *routers.LuaRouter, staticRouter *routers.StaticRouter,
luaRunner *runner.LuaRunner, routesDir string, staticDir string,
libDirs []string, config WatcherConfig) ([]func() error, error) {
libDirs []string, log *logger.Logger, config WatcherConfig) ([]func() error, error) {
var cleanupFuncs []func() error
// Set up watcher for Lua routes
if config.Routes {
luaRouterWatcher, err := watchers.WatchLuaRouter(luaRouter, luaRunner, routesDir)
luaRouterWatcher, err := watchers.WatchLuaRouter(luaRouter, routesDir, log)
if err != nil {
logger.Warning("Failed to watch routes directory: %v", err)
log.Warning("Failed to watch routes directory: %v", err)
} else {
cleanupFuncs = append(cleanupFuncs, luaRouterWatcher.Close)
}
@ -86,9 +86,9 @@ func setupWatchers(luaRouter *routers.LuaRouter, staticRouter *routers.StaticRou
// Set up watcher for static files
if config.Static {
staticWatcher, err := watchers.WatchStaticRouter(staticRouter, staticDir)
staticWatcher, err := watchers.WatchStaticRouter(staticRouter, staticDir, log)
if err != nil {
logger.Warning("Failed to watch static directory: %v", err)
log.Warning("Failed to watch static directory: %v", err)
} else {
cleanupFuncs = append(cleanupFuncs, staticWatcher.Close)
}
@ -96,15 +96,15 @@ func setupWatchers(luaRouter *routers.LuaRouter, staticRouter *routers.StaticRou
// Set up watchers for Lua modules libraries
if config.Modules && len(libDirs) > 0 {
moduleWatchers, err := watchers.WatchLuaModules(luaRunner, libDirs)
moduleWatchers, err := watchers.WatchLuaModules(luaRunner, libDirs, log)
if err != nil {
logger.Warning("Failed to watch Lua module directories: %v", err)
log.Warning("Failed to watch Lua module directories: %v", err)
} else {
for _, watcher := range moduleWatchers {
w := watcher // Capture variable for closure
cleanupFuncs = append(cleanupFuncs, w.Close)
}
logger.Info("File watchers active for %d Lua module directories", len(moduleWatchers))
log.Info("File watchers active for %d Lua module directories", len(moduleWatchers))
}
}
@ -112,38 +112,33 @@ func setupWatchers(luaRouter *routers.LuaRouter, staticRouter *routers.StaticRou
}
func main() {
// Initialize global logger with debug level
logger.InitGlobalLogger(logger.LevelDebug, true)
// Initialize logger
log := logger.New(logger.LevelDebug, true)
logger.Server("Starting Moonshark server")
log.Server("Starting Moonshark server")
// Load configuration from config.lua
cfg, err := config.Load("config.lua")
if err != nil {
logger.Warning("Failed to load config.lua: %v", err)
logger.Info("Using default configuration")
log.Warning("Failed to load config.lua: %v", err)
log.Info("Using default configuration")
cfg = config.New()
}
// Set log level from config
switch cfg.GetString("log_level", "info") {
case "debug":
log.SetLevel(logger.LevelDebug)
case "warn":
logger.SetLevel(logger.LevelWarning)
log.SetLevel(logger.LevelWarning)
case "error":
logger.SetLevel(logger.LevelError)
log.SetLevel(logger.LevelError)
case "server":
logger.SetLevel(logger.LevelServer)
log.SetLevel(logger.LevelServer)
case "fatal":
logger.SetLevel(logger.LevelFatal)
log.SetLevel(logger.LevelFatal)
default:
logger.SetLevel(logger.LevelInfo)
}
// Get debug mode setting
debugMode := cfg.GetBool("debug", false)
if debugMode {
logger.EnableDebug() // Force debug logs regardless of level
logger.Debug("Debug mode enabled")
log.SetLevel(logger.LevelInfo)
}
// Get configuration values
@ -154,7 +149,7 @@ func main() {
bufferSize := cfg.GetInt("buffer_size", 20)
if err := utils.EnsureDir(overrideDir); err != nil {
logger.Warning("Override directory doesn't exist, and could not create it: %v", err)
log.Warning("Override directory doesn't exist, and could not create it: %v", err)
overrideDir = "" // Disable overrides if directory can't be created
}
@ -171,26 +166,25 @@ func main() {
// Ensure lib directories exist
for _, dir := range libDirs {
if err := utils.EnsureDir(dir); err != nil {
logger.Warning("Lib directory doesn't exist, and could not create it: %v", err)
log.Warning("Lib directory doesn't exist, and could not create it: %v", err)
}
}
// Initialize routers
luaRouter, staticRouter, err := initRouters(routesDir, staticDir)
luaRouter, staticRouter, err := initRouters(routesDir, staticDir, log)
if err != nil {
logger.Fatal("Router initialization failed: %v", err)
log.Fatal("Router initialization failed: %v", err)
}
// Initialize Lua runner
luaRunner, err := runner.NewRunner(
runner.WithBufferSize(bufferSize),
runner.WithLibDirs(libDirs...),
runner.WithDebugEnabled(),
)
if err != nil {
logger.Fatal("Failed to initialize Lua runner: %v", err)
log.Fatal("Failed to initialize Lua runner: %v", err)
}
logger.Server("Lua runner initialized with buffer size %d", bufferSize)
log.Server("Lua runner initialized with buffer size %d", bufferSize)
defer luaRunner.Close()
// Set up file watchers if enabled
@ -219,29 +213,31 @@ func main() {
// Setup enabled watchers
cleanupFuncs, err = setupWatchers(luaRouter, staticRouter, luaRunner,
routesDir, staticDir, libDirs, watcherConfig)
routesDir, staticDir, libDirs, log, watcherConfig)
if err != nil {
logger.Warning("Error setting up watchers: %v", err)
log.Warning("Error setting up watchers: %v", err)
}
// Register cleanup functions
defer func() {
for _, cleanup := range cleanupFuncs {
if err := cleanup(); err != nil {
logger.Warning("Cleanup error: %v", err)
log.Warning("Cleanup error: %v", err)
}
}
}()
httpLoggingEnabled := cfg.GetBool("http_logging_enabled", true)
if httpLoggingEnabled {
logger.Info("HTTP logging is enabled")
log.Info("HTTP logging is enabled")
} else {
logger.Info("HTTP logging is disabled")
log.Info("HTTP logging is disabled")
}
debugMode := cfg.GetBool("debug", false)
// Create HTTP server
server := http.New(luaRouter, staticRouter, luaRunner, httpLoggingEnabled, debugMode, overrideDir, cfg)
server := http.New(luaRouter, staticRouter, luaRunner, log, httpLoggingEnabled, debugMode, overrideDir, cfg)
// Handle graceful shutdown
stop := make(chan os.Signal, 1)
@ -251,24 +247,24 @@ func main() {
go func() {
if err := server.ListenAndServe(fmt.Sprintf(":%d", port)); err != nil {
if err.Error() != "http: Server closed" {
logger.Error("Server error: %v", err)
log.Error("Server error: %v", err)
}
}
}()
logger.Server("Server started on port %d", port)
log.Server("Server started on port %d", port)
// Wait for interrupt signal
<-stop
logger.Server("Shutdown signal received")
log.Server("Shutdown signal received")
// Gracefully shut down the server
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
if err := server.Shutdown(ctx); err != nil {
logger.Error("Server shutdown error: %v", err)
log.Error("Server shutdown error: %v", err)
}
logger.Server("Server stopped")
log.Server("Server stopped")
}