luajitos

Scheduler.lua (12951B)

---

 #!/usr/bin/env luajit
 -- Task Scheduler Module
 -- Provides cron-like scheduling and startup task management
 
 local scheduler = {}
 
 -- Storage for scheduled tasks
 local scheduled_tasks = {
     next_startup = nil,       -- Single task to run on next startup
     every_startup = {},       -- List of tasks to run on every startup
     cron = {}                 -- Named cron-style scheduled tasks
 }
 
 -- Task storage file path
 local SCHEDULER_FILE = "/tmp/scheduler_tasks.lua"
 
 -- Special constant for removing next startup task
 scheduler.NEXT_START_UP = "NEXT_START_UP"
 
 --- Parse cron expression: "sec min hour dayOfMonth month dayOfWeek year millisec"
 --- Format: "1 1 0 * * * * *" means every year at 00:01:01
 --- Returns table with parsed fields or nil if invalid
 local function parse_cron(expression)
     if type(expression) ~= "string" then
         return nil
     end
 
     local parts = {}
     for part in string.gmatch(expression, "%S+") do
         table.insert(parts, part)
     end
 
     -- Expect 8 fields: sec min hour dayOfMonth month dayOfWeek year millisec
     if #parts ~= 8 then
         return nil
     end
 
     return {
         second = parts[1],
         minute = parts[2],
         hour = parts[3],
         day_of_month = parts[4],
         month = parts[5],
         day_of_week = parts[6],
         year = parts[7],
         millisecond = parts[8]
     }
 end
 
 --- Check if a cron field matches the current time value
 --- field: cron field value (e.g., "*", "1", "1-5", "*/2")
 --- value: current time value to match against
 local function cron_field_matches(field, value)
     if field == "*" then
         return true
     end
 
     -- Check for exact match
     if tonumber(field) == value then
         return true
     end
 
     -- Check for range (e.g., "1-5")
     local range_start, range_end = string.match(field, "^(%d+)%-(%d+)$")
     if range_start and range_end then
         range_start = tonumber(range_start)
         range_end = tonumber(range_end)
         if value >= range_start and value <= range_end then
             return true
         end
     end
 
     -- Check for step values (e.g., "*/5")
     local step = string.match(field, "^%*%/(%d+)$")
     if step then
         step = tonumber(step)
         if value % step == 0 then
             return true
         end
     end
 
     return false
 end
 
 --- Check if a cron expression matches the current time
 --- cron: parsed cron table
 --- current_time: table with {year, month, day, hour, min, sec, wday}
 local function cron_matches(cron, current_time)
     if not cron or not current_time then
         return false
     end
 
     -- Match each field (ignore milliseconds for now)
     return cron_field_matches(cron.second, current_time.sec) and
            cron_field_matches(cron.minute, current_time.min) and
            cron_field_matches(cron.hour, current_time.hour) and
            cron_field_matches(cron.day_of_month, current_time.day) and
            cron_field_matches(cron.month, current_time.month) and
            cron_field_matches(cron.day_of_week, current_time.wday) and
            cron_field_matches(cron.year, current_time.year)
 end
 
 --- Save scheduled tasks to persistent storage
 local function save_tasks()
     local file, err = io.open(SCHEDULER_FILE, "w")
     if not file then
         if osprint then
             osprint("Scheduler: Failed to save tasks: " .. tostring(err) .. "\n")
         end
         return false
     end
 
     -- Serialize the tasks table
     file:write("return {\n")
 
     -- Save next_startup
     if scheduled_tasks.next_startup then
         file:write("  next_startup = " .. string.format("%q", scheduled_tasks.next_startup) .. ",\n")
     end
 
     -- Save every_startup
     file:write("  every_startup = {\n")
     for _, task in ipairs(scheduled_tasks.every_startup) do
         file:write("    " .. string.format("%q", task) .. ",\n")
     end
     file:write("  },\n")
 
     -- Save cron tasks
     file:write("  cron = {\n")
     for name, task in pairs(scheduled_tasks.cron) do
         file:write("    [" .. string.format("%q", name) .. "] = {\n")
         file:write("      expression = " .. string.format("%q", task.expression) .. ",\n")
         file:write("      app_path = " .. string.format("%q", task.app_path) .. ",\n")
         file:write("    },\n")
     end
     file:write("  },\n")
 
     file:write("}\n")
     file:close()
 
     return true
 end
 
 --- Load scheduled tasks from persistent storage
 local function load_tasks()
     local file, err = io.open(SCHEDULER_FILE, "r")
     if not file then
         -- File doesn't exist yet, that's okay
         return true
     end
 
     local content = file:read("*all")
     file:close()
 
     if not content or content == "" then
         return true
     end
 
     -- Load the tasks
     local loaded_tasks, load_err = loadstring(content)
     if not loaded_tasks then
         if osprint then
             osprint("Scheduler: Failed to load tasks: " .. tostring(load_err) .. "\n")
         end
         return false
     end
 
     local success, result = pcall(loaded_tasks)
     if success and type(result) == "table" then
         scheduled_tasks = result
         if osprint then
             osprint("Scheduler: Loaded scheduled tasks\n")
         end
         return true
     else
         if osprint then
             osprint("Scheduler: Failed to parse tasks: " .. tostring(result) .. "\n")
         end
         return false
     end
 end
 
 --- Initialize the scheduler
 function scheduler.init()
     if osprint then
         osprint("Scheduler: Initializing...\n")
     end
 
     -- Load existing tasks
     load_tasks()
 
     -- Ensure tables exist
     scheduled_tasks.next_startup = scheduled_tasks.next_startup or nil
     scheduled_tasks.every_startup = scheduled_tasks.every_startup or {}
     scheduled_tasks.cron = scheduled_tasks.cron or {}
 
     if osprint then
         osprint("Scheduler: Initialized\n")
     end
 
     return true
 end
 
 --- Run startup tasks
 function scheduler.run_startup_tasks()
     if osprint then
         osprint("Scheduler: Running startup tasks...\n")
     end
 
     -- Run next_startup task if it exists
     if scheduled_tasks.next_startup then
         local app_path = scheduled_tasks.next_startup
         if osprint then
             osprint("Scheduler: Running next_startup task: " .. app_path .. "\n")
         end
 
         -- Run the app using run module
         if run and run.execute then
             local success, err = pcall(run.execute, app_path)
             if not success then
                 if osprint then
                     osprint("Scheduler: Failed to run next_startup task: " .. tostring(err) .. "\n")
                 end
             end
         end
 
         -- Clear next_startup after running
         scheduled_tasks.next_startup = nil
         save_tasks()
     end
 
     -- Run every_startup tasks
     if #scheduled_tasks.every_startup > 0 then
         for _, app_path in ipairs(scheduled_tasks.every_startup) do
             if osprint then
                 osprint("Scheduler: Running every_startup task: " .. app_path .. "\n")
             end
 
             if run and run.execute then
                 local success, err = pcall(run.execute, app_path)
                 if not success then
                     if osprint then
                         osprint("Scheduler: Failed to run every_startup task: " .. tostring(err) .. "\n")
                     end
                 end
             end
         end
     end
 
     if osprint then
         osprint("Scheduler: Startup tasks complete\n")
     end
 end
 
 --- Check and run cron tasks (should be called periodically)
 function scheduler.check_cron_tasks(current_time)
     -- current_time should be a table: {year, month, day, hour, min, sec, wday}
     if not current_time then
         return
     end
 
     for name, task in pairs(scheduled_tasks.cron) do
         local cron = parse_cron(task.expression)
         if cron and cron_matches(cron, current_time) then
             if osprint then
                 osprint("Scheduler: Running cron task '" .. name .. "': " .. task.app_path .. "\n")
             end
 
             if run and run.execute then
                 local success, err = pcall(run.execute, task.app_path)
                 if not success then
                     if osprint then
                         osprint("Scheduler: Failed to run cron task: " .. tostring(err) .. "\n")
                     end
                 end
             end
         end
     end
 end
 
 --- Create os.schedule API for applications
 --- app_context: the application context to add os.schedule to
 --- app_permissions: the application's permissions table
 function scheduler.create_api(app_context, app_permissions)
     -- Check if app has scheduling permission
     if not app_permissions or not app_permissions.scheduling then
         -- No scheduling permission, return nil
         return nil
     end
 
     local api = {}
 
     --- Schedule app to run on next startup
     --- app_path: path to the application to run (optional, defaults to current app)
     function api.onNextStartUp(app_path)
         -- If no app_path provided, use the current app's path
         if not app_path then
             app_path = app_context._app_path or error("No app path specified")
         end
 
         scheduled_tasks.next_startup = app_path
         save_tasks()
 
         if osprint then
             osprint("Scheduler: Scheduled '" .. app_path .. "' for next startup\n")
         end
 
         return true
     end
 
     --- Schedule app to run on every startup
     --- app_path: path to the application to run (optional, defaults to current app)
     function api.onEveryStartUp(app_path)
         -- If no app_path provided, use the current app's path
         if not app_path then
             app_path = app_context._app_path or error("No app path specified")
         end
 
         -- Check if already scheduled
         for _, existing_path in ipairs(scheduled_tasks.every_startup) do
             if existing_path == app_path then
                 -- Already scheduled
                 return true
             end
         end
 
         table.insert(scheduled_tasks.every_startup, app_path)
         save_tasks()
 
         if osprint then
             osprint("Scheduler: Scheduled '" .. app_path .. "' for every startup\n")
         end
 
         return true
     end
 
     --- Schedule app to run on a cron-like schedule
     --- expression: cron expression string (8 fields)
     --- name: optional name for this scheduled task (defaults to app path)
     --- app_path: path to the application to run (optional, defaults to current app)
     function api.onEvery(expression, name, app_path)
         -- If no app_path provided, use the current app's path
         if not app_path then
             app_path = app_context._app_path or error("No app path specified")
         end
 
         -- If no name provided, use the app path
         if not name or name == "" then
             name = app_path
         end
 
         -- Validate cron expression
         local cron = parse_cron(expression)
         if not cron then
             error("Invalid cron expression: " .. tostring(expression))
         end
 
         -- Store the scheduled task
         scheduled_tasks.cron[name] = {
             expression = expression,
             app_path = app_path
         }
 
         save_tasks()
 
         if osprint then
             osprint("Scheduler: Scheduled '" .. app_path .. "' with cron '" .. expression .. "' as '" .. name .. "'\n")
         end
 
         return true
     end
 
     --- Remove a scheduled task
     --- name: either scheduler.NEXT_START_UP or the name of a cron task
     function api.remove(name)
         if name == scheduler.NEXT_START_UP then
             -- Remove next_startup task
             if scheduled_tasks.next_startup then
                 scheduled_tasks.next_startup = nil
                 save_tasks()
                 if osprint then
                     osprint("Scheduler: Removed next_startup task\n")
                 end
                 return true
             else
                 return false
             end
         else
             -- Remove cron task by name
             if scheduled_tasks.cron[name] then
                 scheduled_tasks.cron[name] = nil
                 save_tasks()
                 if osprint then
                     osprint("Scheduler: Removed cron task '" .. name .. "'\n")
                 end
                 return true
             else
                 -- Try to remove from every_startup
                 for i, app_path in ipairs(scheduled_tasks.every_startup) do
                     if app_path == name then
                         table.remove(scheduled_tasks.every_startup, i)
                         save_tasks()
                         if osprint then
                             osprint("Scheduler: Removed every_startup task '" .. name .. "'\n")
                         end
                         return true
                     end
                 end
                 return false
             end
         end
     end
 
     return api
 end
 
 return scheduler