| 1 | module("uci.trigger", package.seeall) |
| 2 | require("posix") |
| 3 | require("uci") |
| 4 | |
| 5 | local path = "/lib/config/trigger" |
| 6 | local triggers = nil |
| 7 | local tmp_cursor = nil |
| 8 | |
| 9 | function load_modules() |
| 10 | if triggers ~= nil then |
| 11 | return |
| 12 | end |
| 13 | triggers = { |
| 14 | list = {}, |
| 15 | uci = {}, |
| 16 | active = {} |
| 17 | } |
| 18 | local modules = posix.glob(path .. "/*.lua") |
| 19 | if modules == nil then |
| 20 | return |
| 21 | end |
| 22 | local oldpath = package.path |
| 23 | package.path = path .. "/?.lua" |
| 24 | for i, v in ipairs(modules) do |
| 25 | pcall(require(string.gsub(v, path .. "/(%w+)%.lua$", "%1"))) |
| 26 | end |
| 27 | package.path = oldpath |
| 28 | end |
| 29 | |
| 30 | function check_table(table, name) |
| 31 | if table[name] == nil then |
| 32 | table[name] = {} |
| 33 | end |
| 34 | return table[name] |
| 35 | end |
| 36 | |
| 37 | function get_table_val(val, vtype) |
| 38 | if type(val) == (vtype or "string") then |
| 39 | return { val } |
| 40 | elseif type(val) == "table" then |
| 41 | return val |
| 42 | end |
| 43 | return nil |
| 44 | end |
| 45 | |
| 46 | function get_name_list(name) |
| 47 | return get_table_val(name or ".all") |
| 48 | end |
| 49 | |
| 50 | function add_trigger_option(list, t) |
| 51 | local name = get_name_list(t.option) |
| 52 | for i, n in ipairs(name) do |
| 53 | option = check_table(list, n) |
| 54 | table.insert(option, t) |
| 55 | end |
| 56 | end |
| 57 | |
| 58 | function add_trigger_section(list, t) |
| 59 | local name = get_name_list(t.section) |
| 60 | for i, n in ipairs(name) do |
| 61 | section = check_table(list, n) |
| 62 | add_trigger_option(section, t) |
| 63 | end |
| 64 | end |
| 65 | |
| 66 | function check_insert_triggers(dest, list, tuple) |
| 67 | if list == nil then |
| 68 | return |
| 69 | end |
| 70 | for i, t in ipairs(list) do |
| 71 | local add = true |
| 72 | if type(t.check) == "function" then |
| 73 | add = t.check(tuple) |
| 74 | end |
| 75 | if add then |
| 76 | dest[t.id] = t |
| 77 | end |
| 78 | end |
| 79 | end |
| 80 | |
| 81 | function find_section_triggers(tlist, pos, tuple) |
| 82 | if pos == nil then |
| 83 | return |
| 84 | end |
| 85 | check_insert_triggers(tlist, pos[".all"], tuple) |
| 86 | if tuple.option then |
| 87 | check_insert_triggers(tlist, pos[tuple.option], tuple) |
| 88 | end |
| 89 | end |
| 90 | |
| 91 | function check_recursion(name, seen) |
| 92 | if seen == nil then |
| 93 | seen = {} |
| 94 | end |
| 95 | if seen[name] then |
| 96 | return nil |
| 97 | end |
| 98 | seen[name] = true |
| 99 | return seen |
| 100 | end |
| 101 | |
| 102 | |
| 103 | function find_recursive_depends(list, name, seen) |
| 104 | seen = check_recursion(name, seen) |
| 105 | if not seen then |
| 106 | return |
| 107 | end |
| 108 | local bt = get_table_val(triggers.list[name].belongs_to) or {} |
| 109 | for i, n in ipairs(bt) do |
| 110 | table.insert(list, n) |
| 111 | find_recursive_depends(list, n, seen) |
| 112 | end |
| 113 | end |
| 114 | |
| 115 | function check_trigger_depth(list, name) |
| 116 | if name == nil then |
| 117 | return |
| 118 | end |
| 119 | |
| 120 | local n = list[name] |
| 121 | if n == nil then |
| 122 | return |
| 123 | end |
| 124 | |
| 125 | list[name] = nil |
| 126 | return check_trigger_depth(list, n) |
| 127 | end |
| 128 | |
| 129 | function find_triggers(tuple) |
| 130 | local pos = triggers.uci[tuple.package] |
| 131 | if pos == nil then |
| 132 | return {} |
| 133 | end |
| 134 | |
| 135 | local tlist = {} |
| 136 | find_section_triggers(tlist, pos[".all"], tuple) |
| 137 | find_section_triggers(tlist, pos[tuple.section[".type"]], tuple) |
| 138 | |
| 139 | for n, t in pairs(tlist) do |
| 140 | local dep = {} |
| 141 | find_recursive_depends(dep, t.id) |
| 142 | for i, depname in ipairs(dep) do |
| 143 | check_trigger_depth(tlist, depname) |
| 144 | end |
| 145 | end |
| 146 | |
| 147 | local nlist = {} |
| 148 | for n, t in pairs(tlist) do |
| 149 | if t then |
| 150 | table.insert(nlist, t) |
| 151 | end |
| 152 | end |
| 153 | |
| 154 | return nlist |
| 155 | end |
| 156 | |
| 157 | function reset_state() |
| 158 | assert(io.open("/var/run/uci_trigger", "w")):close() |
| 159 | if tctx then |
| 160 | tctx:unload("uci_trigger") |
| 161 | end |
| 162 | end |
| 163 | |
| 164 | function load_state() |
| 165 | -- make sure the config file exists before we attempt to load it |
| 166 | -- uci doesn't like loading nonexistent config files |
| 167 | local f = assert(io.open("/var/run/uci_trigger", "a")):close() |
| 168 | |
| 169 | load_modules() |
| 170 | triggers.active = {} |
| 171 | if tctx then |
| 172 | tctx:unload("uci_trigger") |
| 173 | else |
| 174 | tctx = uci.cursor() |
| 175 | end |
| 176 | assert(tctx:load("/var/run/uci_trigger")) |
| 177 | tctx:foreach("uci_trigger", "trigger", |
| 178 | function(section) |
| 179 | trigger = triggers.list[section[".name"]] |
| 180 | if trigger == nil then |
| 181 | return |
| 182 | end |
| 183 | |
| 184 | active = {} |
| 185 | triggers.active[trigger.id] = active |
| 186 | |
| 187 | local s = get_table_val(section["sections"]) or {} |
| 188 | for i, v in ipairs(s) do |
| 189 | active[v] = true |
| 190 | end |
| 191 | end |
| 192 | ) |
| 193 | end |
| 194 | |
| 195 | function get_names(list) |
| 196 | local slist = {} |
| 197 | for name, val in pairs(list) do |
| 198 | if val then |
| 199 | table.insert(slist, name) |
| 200 | end |
| 201 | end |
| 202 | return slist |
| 203 | end |
| 204 | |
| 205 | function check_cancel(name, seen) |
| 206 | local t = triggers.list[name] |
| 207 | local dep = get_table_val(t.belongs_to) |
| 208 | seen = check_recursion(name, seen) |
| 209 | |
| 210 | if not t or not dep or not seen then |
| 211 | return false |
| 212 | end |
| 213 | |
| 214 | for i, v in ipairs(dep) do |
| 215 | -- only cancel triggers for all sections |
| 216 | -- if both the current and the parent trigger |
| 217 | -- are per-section |
| 218 | local section_only = false |
| 219 | if t.section_only then |
| 220 | local tdep = triggers.list[v] |
| 221 | if tdep then |
| 222 | section_only = tdep.section_only |
| 223 | end |
| 224 | end |
| 225 | |
| 226 | if check_cancel(v, seen) then |
| 227 | return true |
| 228 | end |
| 229 | if triggers.active[v] then |
| 230 | if section_only then |
| 231 | for n, active in pairs(triggers.active[v]) do |
| 232 | triggers.active[name][n] = false |
| 233 | end |
| 234 | else |
| 235 | return true |
| 236 | end |
| 237 | end |
| 238 | end |
| 239 | return false |
| 240 | end |
| 241 | |
| 242 | -- trigger api functions |
| 243 | |
| 244 | function add(ts) |
| 245 | for i,t in ipairs(ts) do |
| 246 | triggers.list[t.id] = t |
| 247 | match = {} |
| 248 | if t.package then |
| 249 | local package = check_table(triggers.uci, t.package) |
| 250 | add_trigger_section(package, t) |
| 251 | triggers.list[t.id] = t |
| 252 | end |
| 253 | end |
| 254 | end |
| 255 | |
| 256 | function save_trigger(name) |
| 257 | if triggers.active[name] then |
| 258 | local slist = get_names(triggers.active[name]) |
| 259 | if #slist > 0 then |
| 260 | tctx:set("uci_trigger", name, "sections", slist) |
| 261 | end |
| 262 | else |
| 263 | tctx:delete("uci_trigger", name) |
| 264 | end |
| 265 | end |
| 266 | |
| 267 | function set(data, cursor) |
| 268 | assert(data ~= nil) |
| 269 | if cursor == nil then |
| 270 | cursor = tmp_cursor or uci.cursor() |
| 271 | tmp_cursor = uci.cursor |
| 272 | end |
| 273 | |
| 274 | local tuple = { |
| 275 | package = data[1], |
| 276 | section = data[2], |
| 277 | option = data[3], |
| 278 | value = data[4] |
| 279 | } |
| 280 | assert(cursor:load(tuple.package)) |
| 281 | |
| 282 | load_state() |
| 283 | local section = cursor:get_all(tuple.package, tuple.section) |
| 284 | if (section == nil) then |
| 285 | if option ~= nil then |
| 286 | return |
| 287 | end |
| 288 | section = { |
| 289 | [".type"] = value |
| 290 | } |
| 291 | if tuple.section == nil then |
| 292 | tuple.section = "" |
| 293 | section[".anonymous"] = true |
| 294 | end |
| 295 | section[".name"] = tuple.section |
| 296 | end |
| 297 | tuple.section = section |
| 298 | |
| 299 | local ts = find_triggers(tuple) |
| 300 | for i, t in ipairs(ts) do |
| 301 | local active = triggers.active[t.id] |
| 302 | if not active then |
| 303 | active = {} |
| 304 | triggers.active[t.id] = active |
| 305 | tctx:set("uci_trigger", t.id, "trigger") |
| 306 | end |
| 307 | if section[".name"] then |
| 308 | active[section[".name"]] = true |
| 309 | end |
| 310 | save_trigger(t.id) |
| 311 | end |
| 312 | tctx:save("uci_trigger") |
| 313 | end |
| 314 | |
| 315 | function get_description(trigger, sections) |
| 316 | if not trigger.title then |
| 317 | return trigger.id |
| 318 | end |
| 319 | local desc = trigger.title |
| 320 | if trigger.section_only and sections and #sections > 0 then |
| 321 | desc = desc .. " (" .. table.concat(sections, ", ") .. ")" |
| 322 | end |
| 323 | return desc |
| 324 | end |
| 325 | |
| 326 | function get_active() |
| 327 | local slist = {} |
| 328 | |
| 329 | if triggers == nil then |
| 330 | load_state() |
| 331 | end |
| 332 | for name, val in pairs(triggers.active) do |
| 333 | if val and not check_cancel(name) then |
| 334 | local sections = {} |
| 335 | for name, active in pairs(triggers.active[name]) do |
| 336 | if active then |
| 337 | table.insert(sections, name) |
| 338 | end |
| 339 | end |
| 340 | table.insert(slist, { triggers.list[name], sections }) |
| 341 | end |
| 342 | end |
| 343 | return slist |
| 344 | end |
| 345 | |
| 346 | function set_active(trigger, sections) |
| 347 | if triggers == nil then |
| 348 | load_state() |
| 349 | end |
| 350 | if not triggers.list[trigger] then |
| 351 | return |
| 352 | end |
| 353 | if triggers.active[trigger] == nil then |
| 354 | tctx:set("uci_trigger", trigger, "trigger") |
| 355 | triggers.active[trigger] = {} |
| 356 | end |
| 357 | local active = triggers.active[trigger] |
| 358 | if triggers.list[trigger].section_only or sections ~= nil then |
| 359 | for i, t in ipairs(sections) do |
| 360 | triggers.active[trigger][t] = true |
| 361 | end |
| 362 | end |
| 363 | save_trigger(trigger) |
| 364 | tctx:save("uci_trigger") |
| 365 | end |
| 366 | |
| 367 | function clear_active(trigger, sections) |
| 368 | if triggers == nil then |
| 369 | load_state() |
| 370 | end |
| 371 | if triggers.list[trigger] == nil or triggers.active[trigger] == nil then |
| 372 | return |
| 373 | end |
| 374 | local active = triggers.active[trigger] |
| 375 | if not triggers.list[trigger].section_only or sections == nil then |
| 376 | triggers.active[trigger] = nil |
| 377 | else |
| 378 | for i, t in ipairs(sections) do |
| 379 | triggers.active[trigger][t] = false |
| 380 | end |
| 381 | end |
| 382 | save_trigger(trigger) |
| 383 | tctx:save("uci_trigger") |
| 384 | end |
| 385 | |
| 386 | function run(ts) |
| 387 | if ts == nil then |
| 388 | ts = get_active() |
| 389 | end |
| 390 | for i, t in ipairs(ts) do |
| 391 | local trigger = t[1] |
| 392 | local sections = t[2] |
| 393 | local actions = get_table_val(trigger.action, "function") or {} |
| 394 | for ai, a in ipairs(actions) do |
| 395 | if not trigger.section_only then |
| 396 | sections = { "" } |
| 397 | end |
| 398 | for si, s in ipairs(sections) do |
| 399 | if a(s) then |
| 400 | tctx:delete("uci_trigger", trigger.id) |
| 401 | tctx:save("uci_trigger") |
| 402 | end |
| 403 | end |
| 404 | end |
| 405 | end |
| 406 | end |
| 407 | |
| 408 | -- helper functions |
| 409 | |
| 410 | function system_command(arg) |
| 411 | local cmd = arg |
| 412 | return function(arg) |
| 413 | return os.execute(cmd:format(arg)) == 0 |
| 414 | end |
| 415 | end |
| 416 | |
| 417 | function service_restart(arg) |
| 418 | return system_command("/etc/init.d/" .. arg .. " restart") |
| 419 | end |
| 420 | |
