libs/uci/luasrc/model/uci.lua

   1 --[[
   2 LuCI - UCI model
   3
   4 Description:
   5 Generalized UCI model
   6
   7 FileId:
   8 $Id$
   9
  10 License:
  11 Copyright 2008 Steven Barth <steven@midlink.org>
  12
  13 Licensed under the Apache License, Version 2.0 (the "License");
  14 you may not use this file except in compliance with the License.
  15 You may obtain a copy of the License at
  16
  17         http://www.apache.org/licenses/LICENSE-2.0
  18
  19 Unless required by applicable law or agreed to in writing, software
  20 distributed under the License is distributed on an "AS IS" BASIS,
  21 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  22 See the License for the specific language governing permissions and
  23 limitations under the License.
  24
  25 ]]--
  26 local os    = require "os"
  27 local uci   = require "uci"
  28 local util  = require "luci.util"
  29 local table = require "table"
  30
  31
  32 local setmetatable, rawget, rawset = setmetatable, rawget, rawset
  33 local error, pairs, ipairs, tostring = error, pairs, ipairs, tostring
  34 local require, getmetatable, type = require, getmetatable, type
  35
  36 --- LuCI UCI model library.
  37 -- @cstyle      instance
  38 module "luci.model.uci"
  39
  40 --- Create a new UCI-Cursor.
  41 -- @class function
  42 -- @name cursor
  43 -- @return      UCI-Cursor
  44 cursor = uci.cursor
  45
  46 APIVERSION = uci.APIVERSION
  47
  48 --- Create a new Cursor initialized to the state directory.
  49 -- @return UCI cursor
  50 function cursor_state()
  51         return cursor(nil, "/var/state")
  52 end
  53
  54
  55 local Cursor = getmetatable(cursor())
  56
  57 --- Applies UCI configuration changes
  58 -- @param configlist            List of UCI configurations
  59 -- @param command                       Don't apply only return the command
  60 function Cursor.apply(self, configlist, command)
  61         configlist = self:_affected(configlist)
  62         local reloadcmd = "/sbin/luci-reload " .. table.concat(configlist, " ")
  63
  64         return command and reloadcmd or os.execute(reloadcmd .. " >/dev/null 2>&1")
  65 end
  66
  67
  68 --- Delete all sections of a given type that match certain criteria.
  69 -- @param config                UCI config
  70 -- @param type                  UCI section type
  71 -- @param comparator    Function that will be called for each section and
  72 -- returns a boolean whether to delete the current section (optional)
  73 function Cursor.delete_all(self, config, stype, comparator)
  74         local del = {}
  75
  76         if type(comparator) == "table" then
  77                 local tbl = comparator
  78                 comparator = function(section)
  79                         for k, v in pairs(tbl) do
  80                                 if section[k] ~= v then
  81                                         return false
  82                                 end
  83                         end
  84                         return true
  85                 end
  86         end
  87
  88         local function helper (section)
  89
  90                 if not comparator or comparator(section) then
  91                         del[#del+1] = section[".name"]
  92                 end
  93         end
  94
  95         self:foreach(config, stype, helper)
  96
  97         for i, j in ipairs(del) do
  98                 self:delete(config, j)
  99         end
 100 end
 101
 102 --- Create a new section and initialize it with data.
 103 -- @param config        UCI config
 104 -- @param type          UCI section type
 105 -- @param name          UCI section name (optional)
 106 -- @param values        Table of key - value pairs to initialize the section with
 107 -- @return                      Name of created section
 108 function Cursor.section(self, config, type, name, values)
 109         local stat = true
 110         if name then
 111                 stat = self:set(config, name, type)
 112         else
 113                 name = self:add(config, type)
 114                 stat = name and true
 115         end
 116
 117         if stat and values then
 118                 stat = self:tset(config, name, values)
 119         end
 120
 121         return stat and name
 122 end
 123
 124 --- Updated the data of a section using data from a table.
 125 -- @param config        UCI config
 126 -- @param section       UCI section name (optional)
 127 -- @param values        Table of key - value pairs to update the section with
 128 function Cursor.tset(self, config, section, values)
 129         local stat = true
 130         for k, v in pairs(values) do
 131                 if k:sub(1, 1) ~= "." then
 132                         stat = stat and self:set(config, section, k, v)
 133                 end
 134         end
 135         return stat
 136 end
 137
 138 --- Get an option or list and return values as table.
 139 -- @param config        UCI config
 140 -- @param section       UCI section name
 141 -- @param option        UCI option
 142 -- @return                      UCI value
 143 function Cursor.get_list(self, config, section, option)
 144         if config and section and option then
 145                 local val = self:get(config, section, option)
 146                 return ( type(val) == "table" and val or { val } )
 147         end
 148         return nil
 149 end
 150
 151 --- Set given values as list.
 152 -- @param config        UCI config
 153 -- @param section       UCI section name
 154 -- @param option        UCI option
 155 -- @param value         UCI value
 156 -- @return                      Boolean whether operation succeeded
 157 function Cursor.set_list(self, config, section, option, value)
 158         if config and section and option then
 159                 return self:set(
 160                         config, section, option,
 161                         ( type(value) == "table" and value or { value } )
 162                 )
 163         end
 164         return false
 165 end
 166
 167 -- Return a list of initscripts affected by configuration changes.
 168 function Cursor._affected(self, configlist)
 169         configlist = type(configlist) == "table" and configlist or {configlist}
 170
 171         local c = cursor()
 172         c:load("ucitrack")
 173
 174         -- Resolve dependencies
 175         local reloadlist = {}
 176
 177         local function _resolve_deps(name)
 178                 local reload = {name}
 179                 local deps = {}
 180
 181                 c:foreach("ucitrack", name,
 182                         function(section)
 183                                 if section.affects then
 184                                         for i, aff in ipairs(section.affects) do
 185                                                 deps[#deps+1] = aff
 186                                         end
 187                                 end
 188                         end)
 189
 190                 for i, dep in ipairs(deps) do
 191                         for j, add in ipairs(_resolve_deps(dep)) do
 192                                 reload[#reload+1] = add
 193                         end
 194                 end
 195
 196                 return reload
 197         end
 198
 199         -- Collect initscripts
 200         for j, config in ipairs(configlist) do
 201                 for i, e in ipairs(_resolve_deps(config)) do
 202                         if not util.contains(reloadlist, e) then
 203                                 reloadlist[#reloadlist+1] = e
 204                         end
 205                 end
 206         end
 207
 208         return reloadlist
 209 end
 210
 211
 212 --- Add an anonymous section.
 213 -- @class function
 214 -- @name Cursor.add
 215 -- @param config        UCI config
 216 -- @param type          UCI section type
 217 -- @return                      Name of created section
 218
 219 --- Get a table of unsaved changes.
 220 -- @class function
 221 -- @name Cursor.changes
 222 -- @param config        UCI config
 223 -- @return                      Table of changes
 224
 225 --- Commit unsaved changes.
 226 -- @class function
 227 -- @name Cursor.commit
 228 -- @param config        UCI config
 229 -- @return                      Boolean whether operation succeeded
 230 -- @see Cursor.revert
 231
 232 --- Deletes a section or an option.
 233 -- @class function
 234 -- @name Cursor.delete
 235 -- @param config        UCI config
 236 -- @param section       UCI section name
 237 -- @param option        UCI option (optional)
 238 -- @return                      Boolean whether operation succeeded
 239
 240 --- Call a function for every section of a certain type.
 241 -- @class function
 242 -- @name Cursor.foreach
 243 -- @param config        UCI config
 244 -- @param type          UCI section type
 245 -- @param callback      Function to be called
 246 -- @return                      Boolean whether operation succeeded
 247
 248 --- Get a section type or an option
 249 -- @class function
 250 -- @name Cursor.get
 251 -- @param config        UCI config
 252 -- @param section       UCI section name
 253 -- @param option        UCI option (optional)
 254 -- @return                      UCI value
 255
 256 --- Get all sections of a config or all values of a section.
 257 -- @class function
 258 -- @name Cursor.get_all
 259 -- @param config        UCI config
 260 -- @param section       UCI section name (optional)
 261 -- @return                      Table of UCI sections or table of UCI values
 262
 263 --- Manually load a config.
 264 -- @class function
 265 -- @name Cursor.load
 266 -- @param config        UCI config
 267 -- @return                      Boolean whether operation succeeded
 268 -- @see Cursor.save
 269 -- @see Cursor.unload
 270
 271 --- Revert unsaved changes.
 272 -- @class function
 273 -- @name Cursor.revert
 274 -- @param config        UCI config
 275 -- @return                      Boolean whether operation succeeded
 276 -- @see Cursor.commit
 277
 278 --- Saves changes made to a config to make them committable.
 279 -- @class function
 280 -- @name Cursor.save
 281 -- @param config        UCI config
 282 -- @return                      Boolean whether operation succeeded
 283 -- @see Cursor.load
 284 -- @see Cursor.unload
 285
 286 --- Set a value or create a named section.
 287 -- @class function
 288 -- @name Cursor.set
 289 -- @param config        UCI config
 290 -- @param section       UCI section name
 291 -- @param option        UCI option or UCI section type
 292 -- @param value         UCI value or nil if you want to create a section
 293 -- @return                      Boolean whether operation succeeded
 294
 295 --- Get the configuration directory.
 296 -- @class function
 297 -- @name Cursor.get_confdir
 298 -- @return                      Configuration directory
 299
 300 --- Get the directory for uncomitted changes.
 301 -- @class function
 302 -- @name Cursor.get_savedir
 303 -- @return                      Save directory
 304
 305 --- Set the configuration directory.
 306 -- @class function
 307 -- @name Cursor.set_confdir
 308 -- @param directory     UCI configuration directory
 309 -- @return                      Boolean whether operation succeeded
 310
 311 --- Set the directory for uncommited changes.
 312 -- @class function
 313 -- @name Cursor.set_savedir
 314 -- @param directory     UCI changes directory
 315 -- @return                      Boolean whether operation succeeded
 316
 317 --- Discard changes made to a config.
 318 -- @class function
 319 -- @name Cursor.unload
 320 -- @param config        UCI config
 321 -- @return                      Boolean whether operation succeeded
 322 -- @see Cursor.load
 323 -- @see Cursor.save