8deb949551
Switch to rpcd based uci apply/rollback workflow which helps to avoid soft- bricking devices by requiring an explicit confirmation call after config apply. When a user now clicks "Save & Apply", LuCI first issues a call to uci apply which commits and reloads configuration, then goes into a polling countdown mode where it repeatedly attempts to call uci confirm. If the committed configuration is sane, the confirm call will go through and cancel rpcd's pending rollback timer. If the configuration change leads to a loss of connectivity (e.g. due to bad firewall rules or similar), the rollback mechanism will kick in after the timeout and revert configuration files and pending changes to the pre-apply state. In order to cover such rare cases where a lost of connectivity is expected and desired, the user is offered an "unchecked" apply option after timing out, which allows committing and applying the changes anyway, without the extra safety checks. As a consequence of this change, the luci-reload mechanism is now completely unsused since rpcd uses ubus config reload signals to reload affected services, which means that only procd-enabled services will receive proper reload treatment with the new workflow. Signed-off-by: Jo-Philipp Wich <jo@mein.io>
490 lines
9.9 KiB
Lua
490 lines
9.9 KiB
Lua
-- Copyright 2008 Steven Barth <steven@midlink.org>
|
|
-- Licensed to the public under the Apache License 2.0.
|
|
|
|
local os = require "os"
|
|
local util = require "luci.util"
|
|
local conf = require "luci.config"
|
|
local table = require "table"
|
|
|
|
|
|
local setmetatable, rawget, rawset = setmetatable, rawget, rawset
|
|
local require, getmetatable, assert = require, getmetatable, assert
|
|
local error, pairs, ipairs = error, pairs, ipairs
|
|
local type, tostring, tonumber, unpack = type, tostring, tonumber, unpack
|
|
|
|
-- The typical workflow for UCI is: Get a cursor instance from the
|
|
-- cursor factory, modify data (via Cursor.add, Cursor.delete, etc.),
|
|
-- save the changes to the staging area via Cursor.save and finally
|
|
-- Cursor.commit the data to the actual config files.
|
|
-- LuCI then needs to Cursor.apply the changes so deamons etc. are
|
|
-- reloaded.
|
|
module "luci.model.uci"
|
|
|
|
local ERRSTR = {
|
|
"Invalid command",
|
|
"Invalid argument",
|
|
"Method not found",
|
|
"Entry not found",
|
|
"No data",
|
|
"Permission denied",
|
|
"Timeout",
|
|
"Not supported",
|
|
"Unknown error",
|
|
"Connection failed"
|
|
}
|
|
|
|
local session_id = nil
|
|
|
|
local function call(cmd, args)
|
|
if type(args) == "table" and session_id then
|
|
args.ubus_rpc_session = session_id
|
|
end
|
|
return util.ubus("uci", cmd, args)
|
|
end
|
|
|
|
|
|
function cursor()
|
|
return _M
|
|
end
|
|
|
|
function cursor_state()
|
|
return _M
|
|
end
|
|
|
|
function substate(self)
|
|
return self
|
|
end
|
|
|
|
|
|
function get_confdir(self)
|
|
return "/etc/config"
|
|
end
|
|
|
|
function get_savedir(self)
|
|
return "/tmp/.uci"
|
|
end
|
|
|
|
function get_session_id(self)
|
|
return session_id
|
|
end
|
|
|
|
function set_confdir(self, directory)
|
|
return false
|
|
end
|
|
|
|
function set_savedir(self, directory)
|
|
return false
|
|
end
|
|
|
|
function set_session_id(self, id)
|
|
session_id = id
|
|
return true
|
|
end
|
|
|
|
|
|
function load(self, config)
|
|
return true
|
|
end
|
|
|
|
function save(self, config)
|
|
return true
|
|
end
|
|
|
|
function unload(self, config)
|
|
return true
|
|
end
|
|
|
|
|
|
function changes(self, config)
|
|
local rv = call("changes", { config = config })
|
|
local res = {}
|
|
|
|
if type(rv) == "table" and type(rv.changes) == "table" then
|
|
local package, changes
|
|
for package, changes in pairs(rv.changes) do
|
|
res[package] = {}
|
|
|
|
local _, change
|
|
for _, change in ipairs(changes) do
|
|
local operation, section, option, value = unpack(change)
|
|
if option and value and operation ~= "add" then
|
|
res[package][section] = res[package][section] or { }
|
|
|
|
if operation == "list-add" then
|
|
local v = res[package][section][option]
|
|
if type(v) == "table" then
|
|
v[#v+1] = value or ""
|
|
elseif v ~= nil then
|
|
res[package][section][option] = { v, value }
|
|
else
|
|
res[package][section][option] = { value }
|
|
end
|
|
else
|
|
res[package][section][option] = value or ""
|
|
end
|
|
else
|
|
res[package][section] = res[package][section] or {}
|
|
res[package][section][".type"] = option or ""
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
return res
|
|
end
|
|
|
|
|
|
function revert(self, config)
|
|
local _, err = call("revert", { config = config })
|
|
return (err == nil), ERRSTR[err]
|
|
end
|
|
|
|
function commit(self, config)
|
|
local _, err = call("commit", { config = config })
|
|
return (err == nil), ERRSTR[err]
|
|
end
|
|
|
|
function apply(self, rollback)
|
|
local _, err
|
|
|
|
if rollback then
|
|
local timeout = tonumber(conf.apply and conf.apply.rollback or "") or 0
|
|
|
|
_, err = call("apply", {
|
|
timeout = (timeout > 30) and timeout or 30,
|
|
rollback = true
|
|
})
|
|
|
|
if not err then
|
|
util.ubus("session", "set", {
|
|
ubus_rpc_session = session_id,
|
|
values = { rollback = os.time() + timeout }
|
|
})
|
|
end
|
|
else
|
|
_, err = call("changes", {})
|
|
|
|
if not err then
|
|
if type(_) == "table" and type(_.changes) == "table" then
|
|
local k, v
|
|
for k, v in pairs(_.changes) do
|
|
_, err = call("commit", { config = k })
|
|
if err then
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
if not err then
|
|
_, err = call("apply", { rollback = false })
|
|
end
|
|
end
|
|
|
|
return (err == nil), ERRSTR[err]
|
|
end
|
|
|
|
function confirm(self)
|
|
local _, err = call("confirm", {})
|
|
if not err then
|
|
util.ubus("session", "set", {
|
|
ubus_rpc_session = session_id,
|
|
values = { rollback = 0 }
|
|
})
|
|
end
|
|
return (err == nil), ERRSTR[err]
|
|
end
|
|
|
|
function rollback(self)
|
|
local _, err = call("rollback", {})
|
|
if not err then
|
|
util.ubus("session", "set", {
|
|
ubus_rpc_session = session_id,
|
|
values = { rollback = 0 }
|
|
})
|
|
end
|
|
return (err == nil), ERRSTR[err]
|
|
end
|
|
|
|
function rollback_pending(self)
|
|
local deadline, err = util.ubus("session", "get", {
|
|
ubus_rpc_session = session_id,
|
|
keys = { "rollback" }
|
|
})
|
|
|
|
if type(deadline) == "table" and
|
|
type(deadline.values) == "table" and
|
|
type(deadline.values.rollback) == "number" and
|
|
deadline.values.rollback > os.time()
|
|
then
|
|
return true, deadline.values.rollback - os.time()
|
|
end
|
|
|
|
return false, ERRSTR[err]
|
|
end
|
|
|
|
|
|
function foreach(self, config, stype, callback)
|
|
if type(callback) == "function" then
|
|
local rv, err = call("get", {
|
|
config = config,
|
|
type = stype
|
|
})
|
|
|
|
if type(rv) == "table" and type(rv.values) == "table" then
|
|
local sections = { }
|
|
local res = false
|
|
local index = 1
|
|
|
|
local _, section
|
|
for _, section in pairs(rv.values) do
|
|
section[".index"] = section[".index"] or index
|
|
sections[index] = section
|
|
index = index + 1
|
|
end
|
|
|
|
table.sort(sections, function(a, b)
|
|
return a[".index"] < b[".index"]
|
|
end)
|
|
|
|
for _, section in ipairs(sections) do
|
|
local continue = callback(section)
|
|
res = true
|
|
if continue == false then
|
|
break
|
|
end
|
|
end
|
|
return res
|
|
else
|
|
return false, ERRSTR[err] or "No data"
|
|
end
|
|
else
|
|
return false, "Invalid argument"
|
|
end
|
|
end
|
|
|
|
local function _get(self, operation, config, section, option)
|
|
if section == nil then
|
|
return nil
|
|
elseif type(option) == "string" and option:byte(1) ~= 46 then
|
|
local rv, err = call(operation, {
|
|
config = config,
|
|
section = section,
|
|
option = option
|
|
})
|
|
|
|
if type(rv) == "table" then
|
|
return rv.value or nil
|
|
elseif err then
|
|
return false, ERRSTR[err]
|
|
else
|
|
return nil
|
|
end
|
|
elseif option == nil then
|
|
local values = self:get_all(config, section)
|
|
if values then
|
|
return values[".type"], values[".name"]
|
|
else
|
|
return nil
|
|
end
|
|
else
|
|
return false, "Invalid argument"
|
|
end
|
|
end
|
|
|
|
function get(self, ...)
|
|
return _get(self, "get", ...)
|
|
end
|
|
|
|
function get_state(self, ...)
|
|
return _get(self, "state", ...)
|
|
end
|
|
|
|
function get_all(self, config, section)
|
|
local rv, err = call("get", {
|
|
config = config,
|
|
section = section
|
|
})
|
|
|
|
if type(rv) == "table" and type(rv.values) == "table" then
|
|
return rv.values
|
|
elseif err then
|
|
return false, ERRSTR[err]
|
|
else
|
|
return nil
|
|
end
|
|
end
|
|
|
|
function get_bool(self, ...)
|
|
local val = self:get(...)
|
|
return (val == "1" or val == "true" or val == "yes" or val == "on")
|
|
end
|
|
|
|
function get_first(self, config, stype, option, default)
|
|
local rv = default
|
|
|
|
self:foreach(config, stype, function(s)
|
|
local val = not option and s[".name"] or s[option]
|
|
|
|
if type(default) == "number" then
|
|
val = tonumber(val)
|
|
elseif type(default) == "boolean" then
|
|
val = (val == "1" or val == "true" or
|
|
val == "yes" or val == "on")
|
|
end
|
|
|
|
if val ~= nil then
|
|
rv = val
|
|
return false
|
|
end
|
|
end)
|
|
|
|
return rv
|
|
end
|
|
|
|
function get_list(self, config, section, option)
|
|
if config and section and option then
|
|
local val = self:get(config, section, option)
|
|
return (type(val) == "table" and val or { val })
|
|
end
|
|
return { }
|
|
end
|
|
|
|
|
|
function section(self, config, stype, name, values)
|
|
local rv, err = call("add", {
|
|
config = config,
|
|
type = stype,
|
|
name = name,
|
|
values = values
|
|
})
|
|
|
|
if type(rv) == "table" then
|
|
return rv.section
|
|
elseif err then
|
|
return false, ERRSTR[err]
|
|
else
|
|
return nil
|
|
end
|
|
end
|
|
|
|
|
|
function add(self, config, stype)
|
|
return self:section(config, stype)
|
|
end
|
|
|
|
function set(self, config, section, option, value)
|
|
if value == nil then
|
|
local sname, err = self:section(config, option, section)
|
|
return (not not sname), err
|
|
else
|
|
local _, err = call("set", {
|
|
config = config,
|
|
section = section,
|
|
values = { [option] = value }
|
|
})
|
|
return (err == nil), ERRSTR[err]
|
|
end
|
|
end
|
|
|
|
function set_list(self, config, section, option, value)
|
|
if section == nil or option == nil then
|
|
return false
|
|
elseif value == nil or (type(value) == "table" and #value == 0) then
|
|
return self:delete(config, section, option)
|
|
elseif type(value) == "table" then
|
|
return self:set(config, section, option, value)
|
|
else
|
|
return self:set(config, section, option, { value })
|
|
end
|
|
end
|
|
|
|
function tset(self, config, section, values)
|
|
local _, err = call("set", {
|
|
config = config,
|
|
section = section,
|
|
values = values
|
|
})
|
|
return (err == nil), ERRSTR[err]
|
|
end
|
|
|
|
function reorder(self, config, section, index)
|
|
local sections
|
|
|
|
if type(section) == "string" and type(index) == "number" then
|
|
local pos = 0
|
|
|
|
sections = { }
|
|
|
|
self:foreach(config, nil, function(s)
|
|
if pos == index then
|
|
pos = pos + 1
|
|
end
|
|
|
|
if s[".name"] ~= section then
|
|
pos = pos + 1
|
|
sections[pos] = s[".name"]
|
|
else
|
|
sections[index + 1] = section
|
|
end
|
|
end)
|
|
elseif type(section) == "table" then
|
|
sections = section
|
|
else
|
|
return false, "Invalid argument"
|
|
end
|
|
|
|
local _, err = call("order", {
|
|
config = config,
|
|
sections = sections
|
|
})
|
|
|
|
return (err == nil), ERRSTR[err]
|
|
end
|
|
|
|
|
|
function delete(self, config, section, option)
|
|
local _, err = call("delete", {
|
|
config = config,
|
|
section = section,
|
|
option = option
|
|
})
|
|
return (err == nil), ERRSTR[err]
|
|
end
|
|
|
|
function delete_all(self, config, stype, comparator)
|
|
local _, err
|
|
if type(comparator) == "table" then
|
|
_, err = call("delete", {
|
|
config = config,
|
|
type = stype,
|
|
match = comparator
|
|
})
|
|
elseif type(comparator) == "function" then
|
|
local rv = call("get", {
|
|
config = config,
|
|
type = stype
|
|
})
|
|
|
|
if type(rv) == "table" and type(rv.values) == "table" then
|
|
local sname, section
|
|
for sname, section in pairs(rv.values) do
|
|
if comparator(section) then
|
|
_, err = call("delete", {
|
|
config = config,
|
|
section = sname
|
|
})
|
|
end
|
|
end
|
|
end
|
|
elseif comparator == nil then
|
|
_, err = call("delete", {
|
|
config = config,
|
|
type = stype
|
|
})
|
|
else
|
|
return false, "Invalid argument"
|
|
end
|
|
|
|
return (err == nil), ERRSTR[err]
|
|
end
|