libs/cbi/luasrc/cbi.lua

   1 --[[
   2 LuCI - Configuration Bind Interface
   3
   4 Description:
   5 Offers an interface for binding configuration values to certain
   6 data types. Supports value and range validation and basic dependencies.
   7
   8 FileId:
   9 $Id$
  10
  11 License:
  12 Copyright 2008 Steven Barth <steven@midlink.org>
  13
  14 Licensed under the Apache License, Version 2.0 (the "License");
  15 you may not use this file except in compliance with the License.
  16 You may obtain a copy of the License at
  17
  18         http://www.apache.org/licenses/LICENSE-2.0
  19
  20 Unless required by applicable law or agreed to in writing, software
  21 distributed under the License is distributed on an "AS IS" BASIS,
  22 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  23 See the License for the specific language governing permissions and
  24 limitations under the License.
  25
  26 ]]--
  27 module("luci.cbi", package.seeall)
  28
  29 require("luci.template")
  30 require("luci.util")
  31 require("luci.http")
  32 require("luci.model.uci")
  33
  34 local uci        = luci.model.uci
  35 local class      = luci.util.class
  36 local instanceof = luci.util.instanceof
  37
  38
  39 -- Loads a CBI map from given file, creating an environment and returns it
  40 function load(cbimap)
  41         require("luci.fs")
  42         require("luci.i18n")
  43         require("luci.config")
  44         require("luci.sys")
  45
  46         local cbidir = luci.sys.libpath() .. "/model/cbi/"
  47         local func, err = loadfile(cbidir..cbimap..".lua")
  48
  49         if not func then
  50                 return nil
  51         end
  52
  53         luci.i18n.loadc("cbi")
  54
  55         luci.util.resfenv(func)
  56         luci.util.updfenv(func, luci.cbi)
  57         luci.util.extfenv(func, "translate", luci.i18n.translate)
  58         luci.util.extfenv(func, "translatef", luci.i18n.translatef)
  59
  60         local map = func()
  61
  62         if not instanceof(map, Map) then
  63                 error("CBI map returns no valid map object!")
  64                 return nil
  65         end
  66
  67         return map
  68 end
  69
  70 -- Node pseudo abstract class
  71 Node = class()
  72
  73 function Node.__init__(self, title, description)
  74         self.children = {}
  75         self.title = title or ""
  76         self.description = description or ""
  77         self.template = "cbi/node"
  78 end
  79
  80 -- i18n helper
  81 function Node._i18n(self, config, section, option, title, description)
  82
  83         -- i18n loaded?
  84         if type(luci.i18n) == "table" then
  85
  86                 local key = config:gsub("[^%w]+", "")
  87
  88                 if section then key = key .. "_" .. section:lower():gsub("[^%w]+", "") end
  89                 if option  then key = key .. "_" .. option:lower():gsub("[^%w]+", "")  end
  90
  91                 self.title = title or luci.i18n.translate( key, option or section or config )
  92                 self.description = description or luci.i18n.translate( key .. "_desc", "" )
  93         end
  94 end
  95
  96 -- Append child nodes
  97 function Node.append(self, obj)
  98         table.insert(self.children, obj)
  99 end
 100
 101 -- Parse this node and its children
 102 function Node.parse(self, ...)
 103         for k, child in ipairs(self.children) do
 104                 child:parse(...)
 105         end
 106 end
 107
 108 -- Render this node
 109 function Node.render(self, scope)
 110         scope = scope or {}
 111         scope.self = self
 112
 113         luci.template.render(self.template, scope)
 114 end
 115
 116 -- Render the children
 117 function Node.render_children(self, ...)
 118         for k, node in ipairs(self.children) do
 119                 node:render(...)
 120         end
 121 end
 122
 123
 124 --[[
 125 A simple template element
 126 ]]--
 127 Template = class(Node)
 128
 129 function Template.__init__(self, template)
 130         Node.__init__(self)
 131         self.template = template
 132 end
 133
 134
 135 --[[
 136 Map - A map describing a configuration file
 137 ]]--
 138 Map = class(Node)
 139
 140 function Map.__init__(self, config, ...)
 141         Node.__init__(self, ...)
 142         Node._i18n(self, config, nil, nil, ...)
 143
 144         self.config = config
 145         self.template = "cbi/map"
 146         if not uci.load(self.config) then
 147                 error("Unable to read UCI data: " .. self.config)
 148         end
 149 end
 150
 151 -- Use optimized UCI writing
 152 function Map.parse(self, ...)
 153         Node.parse(self, ...)
 154         uci.save(self.config)
 155         uci.unload(self.config)
 156 end
 157
 158 -- Creates a child section
 159 function Map.section(self, class, ...)
 160         if instanceof(class, AbstractSection) then
 161                 local obj  = class(self, ...)
 162                 self:append(obj)
 163                 return obj
 164         else
 165                 error("class must be a descendent of AbstractSection")
 166         end
 167 end
 168
 169 -- UCI add
 170 function Map.add(self, sectiontype)
 171         return uci.add(self.config, sectiontype)
 172 end
 173
 174 -- UCI set
 175 function Map.set(self, section, option, value)
 176         if option then
 177                 return uci.set(self.config, section, option, value)
 178         else
 179                 return uci.set(self.config, section, value)
 180         end
 181 end
 182
 183 -- UCI del
 184 function Map.del(self, section, option)
 185         if option then
 186                 return uci.delete(self.config, section, option)
 187         else
 188                 return uci.delete(self.config, section)
 189         end
 190 end
 191
 192 -- UCI get
 193 function Map.get(self, section, option)
 194         if not section then
 195                 return uci.get_all(self.config)
 196         elseif option then
 197                 return uci.get(self.config, section, option)
 198         else
 199                 return uci.get_all(self.config, section)
 200         end
 201 end
 202
 203
 204 --[[
 205 AbstractSection
 206 ]]--
 207 AbstractSection = class(Node)
 208
 209 function AbstractSection.__init__(self, map, sectiontype, ...)
 210         Node.__init__(self, ...)
 211         self.sectiontype = sectiontype
 212         self.map = map
 213         self.config = map.config
 214         self.optionals = {}
 215
 216         self.optional = true
 217         self.addremove = false
 218         self.dynamic = false
 219 end
 220
 221 -- Appends a new option
 222 function AbstractSection.option(self, class, option, ...)
 223         if instanceof(class, AbstractValue) then
 224                 local obj  = class(self.map, option, ...)
 225
 226                 Node._i18n(obj, self.config, self.section or self.sectiontype, option, ...)
 227
 228                 self:append(obj)
 229                 return obj
 230         else
 231                 error("class must be a descendent of AbstractValue")
 232         end
 233 end
 234
 235 -- Parse optional options
 236 function AbstractSection.parse_optionals(self, section)
 237         if not self.optional then
 238                 return
 239         end
 240
 241         self.optionals[section] = {}
 242
 243         local field = luci.http.formvalue("cbi.opt."..self.config.."."..section)
 244         for k,v in ipairs(self.children) do
 245                 if v.optional and not v:cfgvalue(section) then
 246                         if field == v.option then
 247                                 field = nil
 248                         else
 249                                 table.insert(self.optionals[section], v)
 250                         end
 251                 end
 252         end
 253
 254         if field and #field > 0 and self.dynamic then
 255                 self:add_dynamic(field)
 256         end
 257 end
 258
 259 -- Add a dynamic option
 260 function AbstractSection.add_dynamic(self, field, optional)
 261         local o = self:option(Value, field, field)
 262         o.optional = optional
 263 end
 264
 265 -- Parse all dynamic options
 266 function AbstractSection.parse_dynamic(self, section)
 267         if not self.dynamic then
 268                 return
 269         end
 270
 271         local arr  = luci.util.clone(self:cfgvalue(section))
 272         local form = luci.http.formvaluetable("cbid."..self.config.."."..section)
 273         for k, v in pairs(form) do
 274                 arr[k] = v
 275         end
 276
 277         for key,val in pairs(arr) do
 278                 local create = true
 279
 280                 for i,c in ipairs(self.children) do
 281                         if c.option == key then
 282                                 create = false
 283                         end
 284                 end
 285
 286                 if create and key:sub(1, 1) ~= "." then
 287                         self:add_dynamic(key, true)
 288                 end
 289         end
 290 end
 291
 292 -- Returns the section's UCI table
 293 function AbstractSection.cfgvalue(self, section)
 294         return self.map:get(section)
 295 end
 296
 297 -- Removes the section
 298 function AbstractSection.remove(self, section)
 299         return self.map:del(section)
 300 end
 301
 302 -- Creates the section
 303 function AbstractSection.create(self, section)
 304         return self.map:set(section, nil, self.sectiontype)
 305 end
 306
 307
 308
 309 --[[
 310 NamedSection - A fixed configuration section defined by its name
 311 ]]--
 312 NamedSection = class(AbstractSection)
 313
 314 function NamedSection.__init__(self, map, section, type, ...)
 315         AbstractSection.__init__(self, map, type, ...)
 316         Node._i18n(self, map.config, section, nil, ...)
 317
 318         self.template = "cbi/nsection"
 319         self.section = section
 320         self.addremove = false
 321 end
 322
 323 function NamedSection.parse(self)
 324         local s = self.section
 325         local active = self:cfgvalue(s)
 326
 327
 328         if self.addremove then
 329                 local path = self.config.."."..s
 330                 if active then -- Remove the section
 331                         if luci.http.formvalue("cbi.rns."..path) and self:remove(s) then
 332                                 return
 333                         end
 334                 else           -- Create and apply default values
 335                         if luci.http.formvalue("cbi.cns."..path) and self:create(s) then
 336                                 for k,v in pairs(self.children) do
 337                                         v:write(s, v.default)
 338                                 end
 339                         end
 340                 end
 341         end
 342
 343         if active then
 344                 AbstractSection.parse_dynamic(self, s)
 345                 if luci.http.formvalue("cbi.submit") then
 346                         Node.parse(self, s)
 347                 end
 348                 AbstractSection.parse_optionals(self, s)
 349         end
 350 end
 351
 352
 353 --[[
 354 TypedSection - A (set of) configuration section(s) defined by the type
 355         addremove:      Defines whether the user can add/remove sections of this type
 356         anonymous:  Allow creating anonymous sections
 357         validate:       a validation function returning nil if the section is invalid
 358 ]]--
 359 TypedSection = class(AbstractSection)
 360
 361 function TypedSection.__init__(self, map, type, ...)
 362         AbstractSection.__init__(self, map, type, ...)
 363         Node._i18n(self, map.config, type, nil, ...)
 364
 365         self.template  = "cbi/tsection"
 366         self.deps = {}
 367         self.excludes = {}
 368
 369         self.anonymous = false
 370 end
 371
 372 -- Return all matching UCI sections for this TypedSection
 373 function TypedSection.cfgsections(self)
 374         local sections = {}
 375         uci.foreach(self.map.config, self.sectiontype,
 376                 function (section)
 377                         if self:checkscope(section[".name"]) then
 378                                 table.insert(sections, section[".name"])
 379                         end
 380                 end)
 381
 382         return sections
 383 end
 384
 385 -- Creates a new section of this type with the given name (or anonymous)
 386 function TypedSection.create(self, name)
 387         if name then
 388                 self.map:set(name, nil, self.sectiontype)
 389         else
 390                 name = self.map:add(self.sectiontype)
 391         end
 392
 393         for k,v in pairs(self.children) do
 394                 if v.default then
 395                         self.map:set(name, v.option, v.default)
 396                 end
 397         end
 398 end
 399
 400 -- Limits scope to sections that have certain option => value pairs
 401 function TypedSection.depends(self, option, value)
 402         table.insert(self.deps, {option=option, value=value})
 403 end
 404
 405 -- Excludes several sections by name
 406 function TypedSection.exclude(self, field)
 407         self.excludes[field] = true
 408 end
 409
 410 function TypedSection.parse(self)
 411         if self.addremove then
 412                 -- Create
 413                 local crval = "cbi.cts." .. self.config .. "." .. self.sectiontype
 414                 local name  = luci.http.formvalue(crval)
 415                 if self.anonymous then
 416                         if name then
 417                                 self:create()
 418                         end
 419                 else
 420                         if name then
 421                                 -- Ignore if it already exists
 422                                 if self:cfgvalue(name) then
 423                                         name = nil;
 424                                 end
 425
 426                                 name = self:checkscope(name)
 427
 428                                 if not name then
 429                                         self.err_invalid = true
 430                                 end
 431
 432                                 if name and name:len() > 0 then
 433                                         self:create(name)
 434                                 end
 435                         end
 436                 end
 437
 438                 -- Remove
 439                 crval = "cbi.rts." .. self.config
 440                 name = luci.http.formvaluetable(crval)
 441                 for k,v in pairs(name) do
 442                         if self:cfgvalue(k) and self:checkscope(k) then
 443                                 self:remove(k)
 444                         end
 445                 end
 446         end
 447
 448         for i, k in ipairs(self:cfgsections()) do
 449                 AbstractSection.parse_dynamic(self, k)
 450                 if luci.http.formvalue("cbi.submit") then
 451                         Node.parse(self, k)
 452                 end
 453                 AbstractSection.parse_optionals(self, k)
 454         end
 455 end
 456
 457 -- Verifies scope of sections
 458 function TypedSection.checkscope(self, section)
 459         -- Check if we are not excluded
 460         if self.excludes[section] then
 461                 return nil
 462         end
 463
 464         -- Check if at least one dependency is met
 465         if #self.deps > 0 and self:cfgvalue(section) then
 466                 local stat = false
 467
 468                 for k, v in ipairs(self.deps) do
 469                         if self:cfgvalue(section)[v.option] == v.value then
 470                                 stat = true
 471                         end
 472                 end
 473
 474                 if not stat then
 475                         return nil
 476                 end
 477         end
 478
 479         return self:validate(section)
 480 end
 481
 482
 483 -- Dummy validate function
 484 function TypedSection.validate(self, section)
 485         return section
 486 end
 487
 488
 489 --[[
 490 AbstractValue - An abstract Value Type
 491         null:           Value can be empty
 492         valid:          A function returning the value if it is valid otherwise nil
 493         depends:        A table of option => value pairs of which one must be true
 494         default:        The default value
 495         size:           The size of the input fields
 496         rmempty:        Unset value if empty
 497         optional:       This value is optional (see AbstractSection.optionals)
 498 ]]--
 499 AbstractValue = class(Node)
 500
 501 function AbstractValue.__init__(self, map, option, ...)
 502         Node.__init__(self, ...)
 503         self.option = option
 504         self.map    = map
 505         self.config = map.config
 506         self.tag_invalid = {}
 507         self.deps = {}
 508
 509         self.rmempty  = false
 510         self.default  = nil
 511         self.size     = nil
 512         self.optional = false
 513 end
 514
 515 -- Add a dependencie to another section field
 516 function AbstractValue.depends(self, field, value)
 517         table.insert(self.deps, {field=field, value=value})
 518 end
 519
 520 -- Return whether this object should be created
 521 function AbstractValue.formcreated(self, section)
 522         local key = "cbi.opt."..self.config.."."..section
 523         return (luci.http.formvalue(key) == self.option)
 524 end
 525
 526 -- Returns the formvalue for this object
 527 function AbstractValue.formvalue(self, section)
 528         local key = "cbid."..self.map.config.."."..section.."."..self.option
 529         return luci.http.formvalue(key)
 530 end
 531
 532 function AbstractValue.parse(self, section)
 533         local fvalue = self:formvalue(section)
 534
 535         if fvalue and fvalue ~= "" then -- If we have a form value, write it to UCI
 536                 fvalue = self:validate(fvalue)
 537                 if not fvalue then
 538                         self.tag_invalid[section] = true
 539                 end
 540                 if fvalue and not (fvalue == self:cfgvalue(section)) then
 541                         self:write(section, fvalue)
 542                 end
 543         else                                                    -- Unset the UCI or error
 544                 if self.rmempty or self.optional then
 545                         self:remove(section)
 546                 end
 547         end
 548 end
 549
 550 -- Render if this value exists or if it is mandatory
 551 function AbstractValue.render(self, s, scope)
 552         if not self.optional or self:cfgvalue(s) or self:formcreated(s) then
 553                 scope = scope or {}
 554                 scope.section = s
 555
 556                 Node.render(self, scope)
 557         end
 558 end
 559
 560 -- Return the UCI value of this object
 561 function AbstractValue.cfgvalue(self, section)
 562         return self.map:get(section, self.option)
 563 end
 564
 565 -- Validate the form value
 566 function AbstractValue.validate(self, value)
 567         return value
 568 end
 569
 570 -- Write to UCI
 571 function AbstractValue.write(self, section, value)
 572         return self.map:set(section, self.option, value)
 573 end
 574
 575 -- Remove from UCI
 576 function AbstractValue.remove(self, section)
 577         return self.map:del(section, self.option)
 578 end
 579
 580
 581
 582
 583 --[[
 584 Value - A one-line value
 585         maxlength:      The maximum length
 586 ]]--
 587 Value = class(AbstractValue)
 588
 589 function Value.__init__(self, ...)
 590         AbstractValue.__init__(self, ...)
 591         self.template  = "cbi/value"
 592
 593         self.maxlength  = nil
 594 end
 595
 596 -- This validation is a bit more complex
 597 function Value.validate(self, val)
 598         if self.maxlength and tostring(val):len() > self.maxlength then
 599                 val = nil
 600         end
 601
 602         return val
 603 end
 604
 605
 606 -- DummyValue - This does nothing except being there
 607 DummyValue = class(AbstractValue)
 608
 609 function DummyValue.__init__(self, map, ...)
 610         AbstractValue.__init__(self, map, ...)
 611         self.template = "cbi/dvalue"
 612         self.value = nil
 613 end
 614
 615 function DummyValue.parse(self)
 616
 617 end
 618
 619 function DummyValue.render(self, s)
 620         luci.template.render(self.template, {self=self, section=s})
 621 end
 622
 623
 624 --[[
 625 Flag - A flag being enabled or disabled
 626 ]]--
 627 Flag = class(AbstractValue)
 628
 629 function Flag.__init__(self, ...)
 630         AbstractValue.__init__(self, ...)
 631         self.template  = "cbi/fvalue"
 632
 633         self.enabled = "1"
 634         self.disabled = "0"
 635 end
 636
 637 -- A flag can only have two states: set or unset
 638 function Flag.parse(self, section)
 639         local fvalue = self:formvalue(section)
 640
 641         if fvalue then
 642                 fvalue = self.enabled
 643         else
 644                 fvalue = self.disabled
 645         end
 646
 647         if fvalue == self.enabled or (not self.optional and not self.rmempty) then
 648                 if not(fvalue == self:cfgvalue(section)) then
 649                         self:write(section, fvalue)
 650                 end
 651         else
 652                 self:remove(section)
 653         end
 654 end
 655
 656
 657
 658 --[[
 659 ListValue - A one-line value predefined in a list
 660         widget: The widget that will be used (select, radio)
 661 ]]--
 662 ListValue = class(AbstractValue)
 663
 664 function ListValue.__init__(self, ...)
 665         AbstractValue.__init__(self, ...)
 666         self.template  = "cbi/lvalue"
 667         self.keylist = {}
 668         self.vallist = {}
 669
 670         self.size   = 1
 671         self.widget = "select"
 672 end
 673
 674 function ListValue.value(self, key, val)
 675         val = val or key
 676         table.insert(self.keylist, tostring(key))
 677         table.insert(self.vallist, tostring(val))
 678 end
 679
 680 function ListValue.validate(self, val)
 681         if luci.util.contains(self.keylist, val) then
 682                 return val
 683         else
 684                 return nil
 685         end
 686 end
 687
 688
 689
 690 --[[
 691 MultiValue - Multiple delimited values
 692         widget: The widget that will be used (select, checkbox)
 693         delimiter: The delimiter that will separate the values (default: " ")
 694 ]]--
 695 MultiValue = class(AbstractValue)
 696
 697 function MultiValue.__init__(self, ...)
 698         AbstractValue.__init__(self, ...)
 699         self.template = "cbi/mvalue"
 700         self.keylist = {}
 701         self.vallist = {}
 702
 703         self.widget = "checkbox"
 704         self.delimiter = " "
 705 end
 706
 707 function MultiValue.render(self, ...)
 708         if self.widget == "select" and not self.size then
 709                 self.size = #self.vallist
 710         end
 711
 712         AbstractValue.render(self, ...)
 713 end
 714
 715 function MultiValue.value(self, key, val)
 716         val = val or key
 717         table.insert(self.keylist, tostring(key))
 718         table.insert(self.vallist, tostring(val))
 719 end
 720
 721 function MultiValue.valuelist(self, section)
 722         local val = self:cfgvalue(section)
 723
 724         if not(type(val) == "string") then
 725                 return {}
 726         end
 727
 728         return luci.util.split(val, self.delimiter)
 729 end
 730
 731 function MultiValue.validate(self, val)
 732         val = (type(val) == "table") and val or {val}
 733
 734         local result
 735
 736         for i, value in ipairs(val) do
 737                 if luci.util.contains(self.keylist, value) then
 738                         result = result and (result .. self.delimiter .. value) or value
 739                 end
 740         end
 741
 742         return result
 743 end