projects / project / luci.git / blob
? search:


c318e64b8e3ffe03792fc606fd3385e64922a355
[project/luci.git] / 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 local util = require("luci.util")
31 require("luci.http")
32 require("luci.uvl")
33
34
35 --local event = require "luci.sys.event"
36 local fs = require("nixio.fs")
37 local uci = require("luci.model.uci")
38 local class = util.class
39 local instanceof = util.instanceof
40
41 FORM_NODATA = 0
42 FORM_PROCEED = 0
43 FORM_VALID = 1
44 FORM_DONE = 1
45 FORM_INVALID = -1
46 FORM_CHANGED = 2
47 FORM_SKIP = 4
48
49 AUTO = true
50
51 CREATE_PREFIX = "cbi.cts."
52 REMOVE_PREFIX = "cbi.rts."
53
54 -- Loads a CBI map from given file, creating an environment and returns it
55 function load(cbimap, ...)
56 local fs = require "nixio.fs"
57 local i18n = require "luci.i18n"
58 require("luci.config")
59 require("luci.util")
60
61 local upldir = "/lib/uci/upload/"
62 local cbidir = luci.util.libpath() .. "/model/cbi/"
63 local func, err
64
65 if fs.access(cbimap) then
66 func, err = loadfile(cbimap)
67 elseif fs.access(cbidir..cbimap..".lua") then
68 func, err = loadfile(cbidir..cbimap..".lua")
69 elseif fs.access(cbidir..cbimap..".lua.gz") then
70 func, err = loadfile(cbidir..cbimap..".lua.gz")
71 else
72 func, err = nil, "Model '" .. cbimap .. "' not found!"
73 end
74
75 assert(func, err)
76
77 luci.i18n.loadc("base")
78
79 local env = {
80 translate=i18n.translate,
81 translatef=i18n.translatef,
82 arg={...}
83 }
84
85 setfenv(func, setmetatable(env, {__index =
86 function(tbl, key)
87 return rawget(tbl, key) or _M[key] or _G[key]
88 end}))
89
90 local maps = { func() }
91 local uploads = { }
92 local has_upload = false
93
94 for i, map in ipairs(maps) do
95 if not instanceof(map, Node) then
96 error("CBI map returns no valid map object!")
97 return nil
98 else
99 map:prepare()
100 if map.upload_fields then
101 has_upload = true
102 for _, field in ipairs(map.upload_fields) do
103 uploads[
104 field.config .. '.' ..
105 field.section.sectiontype .. '.' ..
106 field.option
107 ] = true
108 end
109 end
110 end
111 end
112
113 if has_upload then
114 local uci = luci.model.uci.cursor()
115 local prm = luci.http.context.request.message.params
116 local fd, cbid
117
118 luci.http.setfilehandler(
119 function( field, chunk, eof )
120 if not field then return end
121 if field.name and not cbid then
122 local c, s, o = field.name:gmatch(
123 "cbid%.([^%.]+)%.([^%.]+)%.([^%.]+)"
124 )()
125
126 if c and s and o then
127 local t = uci:get( c, s )
128 if t and uploads[c.."."..t.."."..o] then
129 local path = upldir .. field.name
130 fd = io.open(path, "w")
131 if fd then
132 cbid = field.name
133 prm[cbid] = path
134 end
135 end
136 end
137 end
138
139 if field.name == cbid and fd then
140 fd:write(chunk)
141 end
142
143 if eof and fd then
144 fd:close()
145 fd = nil
146 cbid = nil
147 end
148 end
149 )
150 end
151
152 return maps
153 end
154
155 local function _uvl_validate_section(node, name)
156 local co = node.map:get()
157
158 luci.uvl.STRICT_UNKNOWN_OPTIONS = false
159 luci.uvl.STRICT_UNKNOWN_SECTIONS = false
160
161 local function tag_fields(e)
162 if e.option and node.fields[e.option] then
163 if node.fields[e.option].error then
164 node.fields[e.option].error[name] = e
165 else
166 node.fields[e.option].error = { [name] = e }
167 end
168 elseif e.childs then
169 for _, c in ipairs(e.childs) do tag_fields(c) end
170 end
171 end
172
173 local function tag_section(e)
174 local s = { }
175 for _, c in ipairs(e.childs or { e }) do
176 if c.childs and not c:is(luci.uvl.errors.ERR_DEPENDENCY) then
177 table.insert( s, c.childs[1]:string() )
178 else
179 table.insert( s, c:string() )
180 end
181 end
182 if #s > 0 then
183 if node.error then
184 node.error[name] = s
185 else
186 node.error = { [name] = s }
187 end
188 end
189 end
190
191 local stat, err = node.map.validator:validate_section(node.config, name, co)
192 if err then
193 node.map.save = false
194 tag_fields(err)
195 tag_section(err)
196 end
197
198 end
199
200 local function _uvl_strip_remote_dependencies(deps)
201 local clean = {}
202
203 for k, v in pairs(deps) do
204 k = k:gsub("%$config%.%$section%.", "")
205 if k:match("^[%w_]+$") and type(v) == "string" then
206 clean[k] = v
207 end
208 end
209
210 return clean
211 end
212
213
214 -- Node pseudo abstract class
215 Node = class()
216
217 function Node.__init__(self, title, description)
218 self.children = {}
219 self.title = title or ""
220 self.description = description or ""
221 self.template = "cbi/node"
222 end
223
224 -- hook helper
225 function Node._run_hook(self, hook)
226 if type(self[hook]) == "function" then
227 return self[hook](self)
228 end
229 end
230
231 function Node._run_hooks(self, ...)
232 local f
233 local r = false
234 for _, f in ipairs(arg) do
235 if type(self[f]) == "function" then
236 self[f](self)
237 r = true
238 end
239 end
240 return r
241 end
242
243 -- Prepare nodes
244 function Node.prepare(self, ...)
245 for k, child in ipairs(self.children) do
246 child:prepare(...)
247 end
248 end
249
250 -- Append child nodes
251 function Node.append(self, obj)
252 table.insert(self.children, obj)
253 end
254
255 -- Parse this node and its children
256 function Node.parse(self, ...)
257 for k, child in ipairs(self.children) do
258 child:parse(...)
259 end
260 end
261
262 -- Render this node
263 function Node.render(self, scope)
264 scope = scope or {}
265 scope.self = self
266
267 luci.template.render(self.template, scope)
268 end
269
270 -- Render the children
271 function Node.render_children(self, ...)
272 for k, node in ipairs(self.children) do
273 node:render(...)
274 end
275 end
276
277
278 --[[
279 A simple template element
280 ]]--
281 Template = class(Node)
282
283 function Template.__init__(self, template)
284 Node.__init__(self)
285 self.template = template
286 end
287
288 function Template.render(self)
289 luci.template.render(self.template, {self=self})
290 end
291
292 function Template.parse(self, readinput)
293 self.readinput = (readinput ~= false)
294 return Map.formvalue(self, "cbi.submit") and FORM_DONE or FORM_NODATA
295 end
296
297
298 --[[
299 Map - A map describing a configuration file
300 ]]--
301 Map = class(Node)
302
303 function Map.__init__(self, config, ...)
304 Node.__init__(self, ...)
305
306 self.config = config
307 self.parsechain = {self.config}
308 self.template = "cbi/map"
309 self.apply_on_parse = nil
310 self.readinput = true
311 self.proceed = false
312 self.flow = {}
313
314 self.uci = uci.cursor()
315 self.save = true
316
317 self.changed = false
318
319 if not self.uci:load(self.config) then
320 error("Unable to read UCI data: " .. self.config)
321 end
322
323 self.validator = luci.uvl.UVL()
324 self.scheme = self.validator:get_scheme(self.config)
325 end
326
327 function Map.formvalue(self, key)
328 return self.readinput and luci.http.formvalue(key)
329 end
330
331 function Map.formvaluetable(self, key)
332 return self.readinput and luci.http.formvaluetable(key) or {}
333 end
334
335 function Map.get_scheme(self, sectiontype, option)
336 if not option then
337 return self.scheme and self.scheme.sections[sectiontype]
338 else
339 return self.scheme and self.scheme.variables[sectiontype]
340 and self.scheme.variables[sectiontype][option]
341 end
342 end
343
344 function Map.submitstate(self)
345 return self:formvalue("cbi.submit")
346 end
347
348 -- Chain foreign config
349 function Map.chain(self, config)
350 table.insert(self.parsechain, config)
351 end
352
353 function Map.state_handler(self, state)
354 return state
355 end
356
357 -- Use optimized UCI writing
358 function Map.parse(self, readinput, ...)
359 self.readinput = (readinput ~= false)
360 self:_run_hooks("on_parse")
361
362 if self:formvalue("cbi.skip") then
363 self.state = FORM_SKIP
364 return self:state_handler(self.state)
365 end
366
367 Node.parse(self, ...)
368
369 if self.save then
370 for i, config in ipairs(self.parsechain) do
371 self.uci:save(config)
372 end
373 if self:submitstate() and ((not self.proceed and self.flow.autoapply) or luci.http.formvalue("cbi.apply")) then
374 self:_run_hooks("on_before_commit")
375 for i, config in ipairs(self.parsechain) do
376 self.uci:commit(config)
377
378 -- Refresh data because commit changes section names
379 self.uci:load(config)
380 end
381 self:_run_hooks("on_commit", "on_after_commit", "on_before_apply")
382 if self.apply_on_parse then
383 self.uci:apply(self.parsechain)
384 self:_run_hooks("on_apply", "on_after_apply")
385 else
386 self._apply = function()
387 local cmd = self.uci:apply(self.parsechain, true)
388 return io.popen(cmd)
389 end
390 end
391
392 -- Reparse sections
393 Node.parse(self, true)
394
395 end
396 for i, config in ipairs(self.parsechain) do
397 self.uci:unload(config)
398 end
399 if type(self.commit_handler) == "function" then
400 self:commit_handler(self:submitstate())
401 end
402 end
403
404 if self:submitstate() then
405 if not self.save then
406 self.state = FORM_INVALID
407 elseif self.proceed then
408 self.state = FORM_PROCEED
409 else
410 self.state = self.changed and FORM_CHANGED or FORM_VALID
411 end
412 else
413 self.state = FORM_NODATA
414 end
415
416 return self:state_handler(self.state)
417 end
418
419 function Map.render(self, ...)
420 self:_run_hooks("on_init")
421 Node.render(self, ...)
422 if self._apply then
423 local fp = self._apply()
424 fp:read("*a")
425 fp:close()
426 self:_run_hooks("on_apply")
427 end
428 end
429
430 -- Creates a child section
431 function Map.section(self, class, ...)
432 if instanceof(class, AbstractSection) then
433 local obj = class(self, ...)
434 self:append(obj)
435 return obj
436 else
437 error("class must be a descendent of AbstractSection")
438 end
439 end
440
441 -- UCI add
442 function Map.add(self, sectiontype)
443 return self.uci:add(self.config, sectiontype)
444 end
445
446 -- UCI set
447 function Map.set(self, section, option, value)
448 if option then
449 return self.uci:set(self.config, section, option, value)
450 else
451 return self.uci:set(self.config, section, value)
452 end
453 end
454
455 -- UCI del
456 function Map.del(self, section, option)
457 if option then
458 return self.uci:delete(self.config, section, option)
459 else
460 return self.uci:delete(self.config, section)
461 end
462 end
463
464 -- UCI get
465 function Map.get(self, section, option)
466 if not section then
467 return self.uci:get_all(self.config)
468 elseif option then
469 return self.uci:get(self.config, section, option)
470 else
471 return self.uci:get_all(self.config, section)
472 end
473 end
474
475 --[[
476 Compound - Container
477 ]]--
478 Compound = class(Node)
479
480 function Compound.__init__(self, ...)
481 Node.__init__(self)
482 self.template = "cbi/compound"
483 self.children = {...}
484 end
485
486 function Compound.populate_delegator(self, delegator)
487 for _, v in ipairs(self.children) do
488 v.delegator = delegator
489 end
490 end
491
492 function Compound.parse(self, ...)
493 local cstate, state = 0
494
495 for k, child in ipairs(self.children) do
496 cstate = child:parse(...)
497 state = (not state or cstate < state) and cstate or state
498 end
499
500 return state
501 end
502
503
504 --[[
505 Delegator - Node controller
506 ]]--
507 Delegator = class(Node)
508 function Delegator.__init__(self, ...)
509 Node.__init__(self, ...)
510 self.nodes = {}
511 self.defaultpath = {}
512 self.pageaction = false
513 self.readinput = true
514 self.allow_reset = false
515 self.allow_cancel = false
516 self.allow_back = false
517 self.allow_finish = false
518 self.template = "cbi/delegator"
519 end
520
521 function Delegator.set(self, name, node)
522 assert(not self.nodes[name], "Duplicate entry")
523
524 self.nodes[name] = node
525 end
526
527 function Delegator.add(self, name, node)
528 node = self:set(name, node)
529 self.defaultpath[#self.defaultpath+1] = name
530 end
531
532 function Delegator.insert_after(self, name, after)
533 local n = #self.chain + 1
534 for k, v in ipairs(self.chain) do
535 if v == after then
536 n = k + 1
537 break
538 end
539 end
540 table.insert(self.chain, n, name)
541 end
542
543 function Delegator.set_route(self, ...)
544 local n, chain, route = 0, self.chain, {...}
545 for i = 1, #chain do
546 if chain[i] == self.current then
547 n = i
548 break
549 end
550 end
551 for i = 1, #route do
552 n = n + 1
553 chain[n] = route[i]
554 end
555 for i = n + 1, #chain do
556 chain[i] = nil
557 end
558 end
559
560 function Delegator.get(self, name)
561 local node = self.nodes[name]
562
563 if type(node) == "string" then
564 node = load(node)
565 end
566
567 if type(node) == "table" and getmetatable(node) == nil then
568 node = Compound(unpack(node))
569 end
570
571 return node
572 end
573
574 function Delegator.parse(self, ...)
575 if self.allow_cancel and Map.formvalue(self, "cbi.cancel") then
576 if self:_run_hooks("on_cancel") then
577 return FORM_DONE
578 end
579 end
580
581 if not Map.formvalue(self, "cbi.delg.current") then
582 self:_run_hooks("on_init")
583 end
584
585 local newcurrent
586 self.chain = self.chain or self:get_chain()
587 self.current = self.current or self:get_active()
588 self.active = self.active or self:get(self.current)
589 assert(self.active, "Invalid state")
590
591 local stat = FORM_DONE
592 if type(self.active) ~= "function" then
593 self.active:populate_delegator(self)
594 stat = self.active:parse()
595 else
596 self:active()
597 end
598
599 if stat > FORM_PROCEED then
600 if Map.formvalue(self, "cbi.delg.back") then
601 newcurrent = self:get_prev(self.current)
602 else
603 newcurrent = self:get_next(self.current)
604 end
605 elseif stat < FORM_PROCEED then
606 return stat
607 end
608
609
610 if not Map.formvalue(self, "cbi.submit") then
611 return FORM_NODATA
612 elseif stat > FORM_PROCEED
613 and (not newcurrent or not self:get(newcurrent)) then
614 return self:_run_hook("on_done") or FORM_DONE
615 else
616 self.current = newcurrent or self.current
617 self.active = self:get(self.current)
618 if type(self.active) ~= "function" then
619 self.active:populate_delegator(self)
620 local stat = self.active:parse(false)
621 if stat == FORM_SKIP then
622 return self:parse(...)
623 else
624 return FORM_PROCEED
625 end
626 else
627 return self:parse(...)
628 end
629 end
630 end
631
632 function Delegator.get_next(self, state)
633 for k, v in ipairs(self.chain) do
634 if v == state then
635 return self.chain[k+1]
636 end
637 end
638 end
639
640 function Delegator.get_prev(self, state)
641 for k, v in ipairs(self.chain) do
642 if v == state then
643 return self.chain[k-1]
644 end
645 end
646 end
647
648 function Delegator.get_chain(self)
649 local x = Map.formvalue(self, "cbi.delg.path") or self.defaultpath
650 return type(x) == "table" and x or {x}
651 end
652
653 function Delegator.get_active(self)
654 return Map.formvalue(self, "cbi.delg.current") or self.chain[1]
655 end
656
657 --[[
658 Page - A simple node
659 ]]--
660
661 Page = class(Node)
662 Page.__init__ = Node.__init__
663 Page.parse = function() end
664
665
666 --[[
667 SimpleForm - A Simple non-UCI form
668 ]]--
669 SimpleForm = class(Node)
670
671 function SimpleForm.__init__(self, config, title, description, data)
672 Node.__init__(self, title, description)
673 self.config = config
674 self.data = data or {}
675 self.template = "cbi/simpleform"
676 self.dorender = true
677 self.pageaction = false
678 self.readinput = true
679 end
680
681 SimpleForm.formvalue = Map.formvalue
682 SimpleForm.formvaluetable = Map.formvaluetable
683
684 function SimpleForm.parse(self, readinput, ...)
685 self.readinput = (readinput ~= false)
686
687 if self:formvalue("cbi.skip") then
688 return FORM_SKIP
689 end
690
691 if self:formvalue("cbi.cancel") and self:_run_hooks("on_cancel") then
692 return FORM_DONE
693 end
694
695 if self:submitstate() then
696 Node.parse(self, 1, ...)
697 end
698
699 local valid = true
700 for k, j in ipairs(self.children) do
701 for i, v in ipairs(j.children) do
702 valid = valid
703 and (not v.tag_missing or not v.tag_missing[1])
704 and (not v.tag_invalid or not v.tag_invalid[1])
705 and (not v.error)
706 end
707 end
708
709 local state =
710 not self:submitstate() and FORM_NODATA
711 or valid and FORM_VALID
712 or FORM_INVALID
713
714 self.dorender = not self.handle
715 if self.handle then
716 local nrender, nstate = self:handle(state, self.data)
717 self.dorender = self.dorender or (nrender ~= false)
718 state = nstate or state
719 end
720 return state
721 end
722
723 function SimpleForm.render(self, ...)
724 if self.dorender then
725 Node.render(self, ...)
726 end
727 end
728
729 function SimpleForm.submitstate(self)
730 return self:formvalue("cbi.submit")
731 end
732
733 function SimpleForm.section(self, class, ...)
734 if instanceof(class, AbstractSection) then
735 local obj = class(self, ...)
736 self:append(obj)
737 return obj
738 else
739 error("class must be a descendent of AbstractSection")
740 end
741 end
742
743 -- Creates a child field
744 function SimpleForm.field(self, class, ...)
745 local section
746 for k, v in ipairs(self.children) do
747 if instanceof(v, SimpleSection) then
748 section = v
749 break
750 end
751 end
752 if not section then
753 section = self:section(SimpleSection)
754 end
755
756 if instanceof(class, AbstractValue) then
757 local obj = class(self, section, ...)
758 obj.track_missing = true
759 section:append(obj)
760 return obj
761 else
762 error("class must be a descendent of AbstractValue")
763 end
764 end
765
766 function SimpleForm.set(self, section, option, value)
767 self.data[option] = value
768 end
769
770
771 function SimpleForm.del(self, section, option)
772 self.data[option] = nil
773 end
774
775
776 function SimpleForm.get(self, section, option)
777 return self.data[option]
778 end
779
780
781 function SimpleForm.get_scheme()
782 return nil
783 end
784
785
786 Form = class(SimpleForm)
787
788 function Form.__init__(self, ...)
789 SimpleForm.__init__(self, ...)
790 self.embedded = true
791 end
792
793
794 --[[
795 AbstractSection
796 ]]--
797 AbstractSection = class(Node)
798
799 function AbstractSection.__init__(self, map, sectiontype, ...)
800 Node.__init__(self, ...)
801 self.sectiontype = sectiontype
802 self.map = map
803 self.config = map.config
804 self.optionals = {}
805 self.defaults = {}
806 self.fields = {}
807 self.tag_error = {}
808 self.tag_invalid = {}
809 self.tag_deperror = {}
810 self.changed = false
811
812 self.optional = true
813 self.addremove = false
814 self.dynamic = false
815 end
816
817 -- Define a tab for the section
818 function AbstractSection.tab(self, tab, title, desc)
819 self.tabs = self.tabs or { }
820 self.tab_names = self.tab_names or { }
821
822 self.tab_names[#self.tab_names+1] = tab
823 self.tabs[tab] = {
824 title = title,
825 description = desc,
826 childs = { }
827 }
828 end
829
830 -- Appends a new option
831 function AbstractSection.option(self, class, option, ...)
832 -- Autodetect from UVL
833 if class == true and self.map:get_scheme(self.sectiontype, option) then
834 local vs = self.map:get_scheme(self.sectiontype, option)
835 if vs.type == "boolean" then
836 class = Flag
837 elseif vs.type == "list" then
838 class = DynamicList
839 elseif vs.type == "enum" or vs.type == "reference" then
840 class = ListValue
841 else
842 class = Value
843 end
844 end
845
846 if instanceof(class, AbstractValue) then
847 local obj = class(self.map, self, option, ...)
848 self:append(obj)
849 self.fields[option] = obj
850 return obj
851 elseif class == true then
852 error("No valid class was given and autodetection failed.")
853 else
854 error("class must be a descendant of AbstractValue")
855 end
856 end
857
858 -- Appends a new tabbed option
859 function AbstractSection.taboption(self, tab, ...)
860
861 assert(tab and self.tabs and self.tabs[tab],
862 "Cannot assign option to not existing tab %q" % tostring(tab))
863
864 local l = self.tabs[tab].childs
865 local o = AbstractSection.option(self, ...)
866
867 if o then l[#l+1] = o end
868
869 return o
870 end
871
872 -- Render a single tab
873 function AbstractSection.render_tab(self, tab, ...)
874
875 assert(tab and self.tabs and self.tabs[tab],
876 "Cannot render not existing tab %q" % tostring(tab))
877
878 for _, node in ipairs(self.tabs[tab].childs) do
879 node:render(...)
880 end
881 end
882
883 -- Parse optional options
884 function AbstractSection.parse_optionals(self, section)
885 if not self.optional then
886 return
887 end
888
889 self.optionals[section] = {}
890
891 local field = self.map:formvalue("cbi.opt."..self.config.."."..section)
892 for k,v in ipairs(self.children) do
893 if v.optional and not v:cfgvalue(section) then
894 if field == v.option then
895 field = nil
896 self.map.proceed = true
897 else
898 table.insert(self.optionals[section], v)
899 end
900 end
901 end
902
903 if field and #field > 0 and self.dynamic then
904 self:add_dynamic(field)
905 end
906 end
907
908 -- Add a dynamic option
909 function AbstractSection.add_dynamic(self, field, optional)
910 local o = self:option(Value, field, field)
911 o.optional = optional
912 end
913
914 -- Parse all dynamic options
915 function AbstractSection.parse_dynamic(self, section)
916 if not self.dynamic then
917 return
918 end
919
920 local arr = luci.util.clone(self:cfgvalue(section))
921 local form = self.map:formvaluetable("cbid."..self.config.."."..section)
922 for k, v in pairs(form) do
923 arr[k] = v
924 end
925
926 for key,val in pairs(arr) do
927 local create = true
928
929 for i,c in ipairs(self.children) do
930 if c.option == key then
931 create = false
932 end
933 end
934
935 if create and key:sub(1, 1) ~= "." then
936 self.map.proceed = true
937 self:add_dynamic(key, true)
938 end
939 end
940 end
941
942 -- Returns the section's UCI table
943 function AbstractSection.cfgvalue(self, section)
944 return self.map:get(section)
945 end
946
947 -- Push events
948 function AbstractSection.push_events(self)
949 --luci.util.append(self.map.events, self.events)
950 self.map.changed = true
951 end
952
953 -- Removes the section
954 function AbstractSection.remove(self, section)
955 self.map.proceed = true
956 return self.map:del(section)
957 end
958
959 -- Creates the section
960 function AbstractSection.create(self, section)
961 local stat
962
963 if section then
964 stat = section:match("^[%w_]+$") and self.map:set(section, nil, self.sectiontype)
965 else
966 section = self.map:add(self.sectiontype)
967 stat = section
968 end
969
970 if stat then
971 for k,v in pairs(self.children) do
972 if v.default then
973 self.map:set(section, v.option, v.default)
974 end
975 end
976
977 for k,v in pairs(self.defaults) do
978 self.map:set(section, k, v)
979 end
980 end
981
982 self.map.proceed = true
983
984 return stat
985 end
986
987
988 SimpleSection = class(AbstractSection)
989
990 function SimpleSection.__init__(self, form, ...)
991 AbstractSection.__init__(self, form, nil, ...)
992 self.template = "cbi/nullsection"
993 end
994
995
996 Table = class(AbstractSection)
997
998 function Table.__init__(self, form, data, ...)
999 local datasource = {}
1000 local tself = self
1001 datasource.config = "table"
1002 self.data = data or {}
1003
1004 datasource.formvalue = Map.formvalue
1005 datasource.formvaluetable = Map.formvaluetable
1006 datasource.readinput = true
1007
1008 function datasource.get(self, section, option)
1009 return tself.data[section] and tself.data[section][option]
1010 end
1011
1012 function datasource.submitstate(self)
1013 return Map.formvalue(self, "cbi.submit")
1014 end
1015
1016 function datasource.del(...)
1017 return true
1018 end
1019
1020 function datasource.get_scheme()
1021 return nil
1022 end
1023
1024 AbstractSection.__init__(self, datasource, "table", ...)
1025 self.template = "cbi/tblsection"
1026 self.rowcolors = true
1027 self.anonymous = true
1028 end
1029
1030 function Table.parse(self, readinput)
1031 self.map.readinput = (readinput ~= false)
1032 for i, k in ipairs(self:cfgsections()) do
1033 if self.map:submitstate() then
1034 Node.parse(self, k)
1035 end
1036 end
1037 end
1038
1039 function Table.cfgsections(self)
1040 local sections = {}
1041
1042 for i, v in luci.util.kspairs(self.data) do
1043 table.insert(sections, i)
1044 end
1045
1046 return sections
1047 end
1048
1049 function Table.update(self, data)
1050 self.data = data
1051 end
1052
1053
1054
1055 --[[
1056 NamedSection - A fixed configuration section defined by its name
1057 ]]--
1058 NamedSection = class(AbstractSection)
1059
1060 function NamedSection.__init__(self, map, section, stype, ...)
1061 AbstractSection.__init__(self, map, stype, ...)
1062
1063 -- Defaults
1064 self.addremove = false
1065
1066 -- Use defaults from UVL
1067 if not self.override_scheme and self.map:get_scheme(self.sectiontype) then
1068 local vs = self.map:get_scheme(self.sectiontype)
1069 self.addremove = not vs.unique and not vs.required
1070 self.dynamic = vs.dynamic
1071 self.title = self.title or vs.title
1072 self.description = self.description or vs.descr
1073 end
1074
1075 self.template = "cbi/nsection"
1076 self.section = section
1077 end
1078
1079 function NamedSection.parse(self, novld)
1080 local s = self.section
1081 local active = self:cfgvalue(s)
1082
1083 if self.addremove then
1084 local path = self.config.."."..s
1085 if active then -- Remove the section
1086 if self.map:formvalue("cbi.rns."..path) and self:remove(s) then
1087 self:push_events()
1088 return
1089 end
1090 else -- Create and apply default values
1091 if self.map:formvalue("cbi.cns."..path) then
1092 self:create(s)
1093 return
1094 end
1095 end
1096 end
1097
1098 if active then
1099 AbstractSection.parse_dynamic(self, s)
1100 if self.map:submitstate() then
1101 Node.parse(self, s)
1102
1103 if not novld and not self.override_scheme and self.map.scheme then
1104 _uvl_validate_section(self, s)
1105 end
1106 end
1107 AbstractSection.parse_optionals(self, s)
1108
1109 if self.changed then
1110 self:push_events()
1111 end
1112 end
1113 end
1114
1115
1116 --[[
1117 TypedSection - A (set of) configuration section(s) defined by the type
1118 addremove: Defines whether the user can add/remove sections of this type
1119 anonymous: Allow creating anonymous sections
1120 validate: a validation function returning nil if the section is invalid
1121 ]]--
1122 TypedSection = class(AbstractSection)
1123
1124 function TypedSection.__init__(self, map, type, ...)
1125 AbstractSection.__init__(self, map, type, ...)
1126
1127 self.template = "cbi/tsection"
1128 self.deps = {}
1129 self.anonymous = false
1130
1131 -- Use defaults from UVL
1132 if not self.override_scheme and self.map:get_scheme(self.sectiontype) then
1133 local vs = self.map:get_scheme(self.sectiontype)
1134 self.addremove = not vs.unique and not vs.required
1135 self.dynamic = vs.dynamic
1136 self.anonymous = not vs.named
1137 self.title = self.title or vs.title
1138 self.description = self.description or vs.descr
1139 end
1140 end
1141
1142 -- Return all matching UCI sections for this TypedSection
1143 function TypedSection.cfgsections(self)
1144 local sections = {}
1145 self.map.uci:foreach(self.map.config, self.sectiontype,
1146 function (section)
1147 if self:checkscope(section[".name"]) then
1148 table.insert(sections, section[".name"])
1149 end
1150 end)
1151
1152 return sections
1153 end
1154
1155 -- Limits scope to sections that have certain option => value pairs
1156 function TypedSection.depends(self, option, value)
1157 table.insert(self.deps, {option=option, value=value})
1158 end
1159
1160 function TypedSection.parse(self, novld)
1161 if self.addremove then
1162 -- Remove
1163 local crval = REMOVE_PREFIX .. self.config
1164 local name = self.map:formvaluetable(crval)
1165 for k,v in pairs(name) do
1166 if k:sub(-2) == ".x" then
1167 k = k:sub(1, #k - 2)
1168 end
1169 if self:cfgvalue(k) and self:checkscope(k) then
1170 self:remove(k)
1171 end
1172 end
1173 end
1174
1175 local co
1176 for i, k in ipairs(self:cfgsections()) do
1177 AbstractSection.parse_dynamic(self, k)
1178 if self.map:submitstate() then
1179 Node.parse(self, k, novld)
1180
1181 if not novld and not self.override_scheme and self.map.scheme then
1182 _uvl_validate_section(self, k)
1183 end
1184 end
1185 AbstractSection.parse_optionals(self, k)
1186 end
1187
1188 if self.addremove then
1189 -- Create
1190 local created
1191 local crval = CREATE_PREFIX .. self.config .. "." .. self.sectiontype
1192 local name = self.map:formvalue(crval)
1193 if self.anonymous then
1194 if name then
1195 created = self:create()
1196 end
1197 else
1198 if name then
1199 -- Ignore if it already exists
1200 if self:cfgvalue(name) then
1201 name = nil;
1202 end
1203
1204 name = self:checkscope(name)
1205
1206 if not name then
1207 self.err_invalid = true
1208 end
1209
1210 if name and #name > 0 then
1211 created = self:create(name) and name
1212 if not created then
1213 self.invalid_cts = true
1214 end
1215 end
1216 end
1217 end
1218
1219 if created then
1220 AbstractSection.parse_optionals(self, created)
1221 end
1222 end
1223
1224 if created or self.changed then
1225 self:push_events()
1226 end
1227 end
1228
1229 -- Verifies scope of sections
1230 function TypedSection.checkscope(self, section)
1231 -- Check if we are not excluded
1232 if self.filter and not self:filter(section) then
1233 return nil
1234 end
1235
1236 -- Check if at least one dependency is met
1237 if #self.deps > 0 and self:cfgvalue(section) then
1238 local stat = false
1239
1240 for k, v in ipairs(self.deps) do
1241 if self:cfgvalue(section)[v.option] == v.value then
1242 stat = true
1243 end
1244 end
1245
1246 if not stat then
1247 return nil
1248 end
1249 end
1250
1251 return self:validate(section)
1252 end
1253
1254
1255 -- Dummy validate function
1256 function TypedSection.validate(self, section)
1257 return section
1258 end
1259
1260
1261 --[[
1262 AbstractValue - An abstract Value Type
1263 null: Value can be empty
1264 valid: A function returning the value if it is valid otherwise nil
1265 depends: A table of option => value pairs of which one must be true
1266 default: The default value
1267 size: The size of the input fields
1268 rmempty: Unset value if empty
1269 optional: This value is optional (see AbstractSection.optionals)
1270 ]]--
1271 AbstractValue = class(Node)
1272
1273 function AbstractValue.__init__(self, map, section, option, ...)
1274 Node.__init__(self, ...)
1275 self.section = section
1276 self.option = option
1277 self.map = map
1278 self.config = map.config
1279 self.tag_invalid = {}
1280 self.tag_missing = {}
1281 self.tag_reqerror = {}
1282 self.tag_error = {}
1283 self.deps = {}
1284 self.subdeps = {}
1285 --self.cast = "string"
1286
1287 self.track_missing = false
1288 self.rmempty = true
1289 self.default = nil
1290 self.size = nil
1291 self.optional = false
1292 end
1293
1294 function AbstractValue.prepare(self)
1295 -- Use defaults from UVL
1296 if not self.override_scheme
1297 and self.map:get_scheme(self.section.sectiontype, self.option) then
1298 local vs = self.map:get_scheme(self.section.sectiontype, self.option)
1299 if self.cast == nil then
1300 self.cast = (vs.type == "list") and "list" or "string"
1301 end
1302 self.title = self.title or vs.title
1303 self.description = self.description or vs.descr
1304 if self.default == nil then
1305 self.default = vs.default
1306 end
1307
1308 if vs.depends and not self.override_dependencies then
1309 for i, deps in ipairs(vs.depends) do
1310 deps = _uvl_strip_remote_dependencies(deps)
1311 if next(deps) then
1312 self:depends(deps)
1313 end
1314 end
1315 end
1316 end
1317
1318 self.cast = self.cast or "string"
1319 end
1320
1321 -- Add a dependencie to another section field
1322 function AbstractValue.depends(self, field, value)
1323 local deps
1324 if type(field) == "string" then
1325 deps = {}
1326 deps[field] = value
1327 else
1328 deps = field
1329 end
1330
1331 table.insert(self.deps, {deps=deps, add=""})
1332 end
1333
1334 -- Generates the unique CBID
1335 function AbstractValue.cbid(self, section)
1336 return "cbid."..self.map.config.."."..section.."."..self.option
1337 end
1338
1339 -- Return whether this object should be created
1340 function AbstractValue.formcreated(self, section)
1341 local key = "cbi.opt."..self.config.."."..section
1342 return (self.map:formvalue(key) == self.option)
1343 end
1344
1345 -- Returns the formvalue for this object
1346 function AbstractValue.formvalue(self, section)
1347 return self.map:formvalue(self:cbid(section))
1348 end
1349
1350 function AbstractValue.additional(self, value)
1351 self.optional = value
1352 end
1353
1354 function AbstractValue.mandatory(self, value)
1355 self.rmempty = not value
1356 end
1357
1358 function AbstractValue.parse(self, section, novld)
1359 local fvalue = self:formvalue(section)
1360 local cvalue = self:cfgvalue(section)
1361
1362 -- If favlue and cvalue are both tables and have the same content
1363 -- make them identical
1364 if type(fvalue) == "table" and type(cvalue) == "table" then
1365 local equal = #fvalue == #cvalue
1366 if equal then
1367 for i=1, #fvalue do
1368 if cvalue[i] ~= fvalue[i] then
1369 equal = false
1370 end
1371 end
1372 end
1373 if equal then
1374 fvalue = cvalue
1375 end
1376 end
1377
1378 if fvalue and #fvalue > 0 then -- If we have a form value, write it to UCI
1379 fvalue = self:transform(self:validate(fvalue, section))
1380 if not fvalue and not novld then
1381 if self.error then
1382 self.error[section] = "invalid"
1383 else
1384 self.error = { [section] = "invalid" }
1385 end
1386 if self.section.error then
1387 table.insert(self.section.error[section], "invalid")
1388 else
1389 self.section.error = {[section] = {"invalid"}}
1390 end
1391 self.map.save = false
1392 end
1393 if fvalue and not (fvalue == cvalue) then
1394 if self:write(section, fvalue) then
1395 -- Push events
1396 self.section.changed = true
1397 --luci.util.append(self.map.events, self.events)
1398 end
1399 end
1400 else -- Unset the UCI or error
1401 if self.rmempty or self.optional then
1402 if self:remove(section) then
1403 -- Push events
1404 self.section.changed = true
1405 --luci.util.append(self.map.events, self.events)
1406 end
1407 elseif cvalue ~= fvalue and not novld then
1408 self:write(section, fvalue or "")
1409 if self.error then
1410 self.error[section] = "missing"
1411 else
1412 self.error = { [section] = "missing" }
1413 end
1414 self.map.save = false
1415 end
1416 end
1417 end
1418
1419 -- Render if this value exists or if it is mandatory
1420 function AbstractValue.render(self, s, scope)
1421 if not self.optional or self:cfgvalue(s) or self:formcreated(s) then
1422 scope = scope or {}
1423 scope.section = s
1424 scope.cbid = self:cbid(s)
1425 scope.striptags = luci.util.striptags
1426 scope.pcdata = luci.util.pcdata
1427
1428 scope.ifattr = function(cond,key,val)
1429 if cond then
1430 return string.format(
1431 ' %s="%s"', tostring(key),
1432 luci.util.pcdata(tostring( val
1433 or scope[key]
1434 or (type(self[key]) ~= "function" and self[key])
1435 or "" ))
1436 )
1437 else
1438 return ''
1439 end
1440 end
1441
1442 scope.attr = function(...)
1443 return scope.ifattr( true, ... )
1444 end
1445
1446 Node.render(self, scope)
1447 end
1448 end
1449
1450 -- Return the UCI value of this object
1451 function AbstractValue.cfgvalue(self, section)
1452 local value = self.map:get(section, self.option)
1453 if not value then
1454 return nil
1455 elseif not self.cast or self.cast == type(value) then
1456 return value
1457 elseif self.cast == "string" then
1458 if type(value) == "table" then
1459 return value[1]
1460 end
1461 elseif self.cast == "table" then
1462 return luci.util.split(value, "%s+", nil, true)
1463 end
1464 end
1465
1466 -- Validate the form value
1467 function AbstractValue.validate(self, value)
1468 return value
1469 end
1470
1471 AbstractValue.transform = AbstractValue.validate
1472
1473
1474 -- Write to UCI
1475 function AbstractValue.write(self, section, value)
1476 return self.map:set(section, self.option, value)
1477 end
1478
1479 -- Remove from UCI
1480 function AbstractValue.remove(self, section)
1481 return self.map:del(section, self.option)
1482 end
1483
1484
1485
1486
1487 --[[
1488 Value - A one-line value
1489 maxlength: The maximum length
1490 ]]--
1491 Value = class(AbstractValue)
1492
1493 function Value.__init__(self, ...)
1494 AbstractValue.__init__(self, ...)
1495 self.template = "cbi/value"
1496 self.keylist = {}
1497 self.vallist = {}
1498 end
1499
1500 function Value.value(self, key, val)
1501 val = val or key
1502 table.insert(self.keylist, tostring(key))
1503 table.insert(self.vallist, tostring(val))
1504 end
1505
1506
1507 -- DummyValue - This does nothing except being there
1508 DummyValue = class(AbstractValue)
1509
1510 function DummyValue.__init__(self, ...)
1511 AbstractValue.__init__(self, ...)
1512 self.template = "cbi/dvalue"
1513 self.value = nil
1514 end
1515
1516 function DummyValue.cfgvalue(self, section)
1517 local value
1518 if self.value then
1519 if type(self.value) == "function" then
1520 value = self:value(section)
1521 else
1522 value = self.value
1523 end
1524 else
1525 value = AbstractValue.cfgvalue(self, section)
1526 end
1527 return value
1528 end
1529
1530 function DummyValue.parse(self)
1531
1532 end
1533
1534
1535 --[[
1536 Flag - A flag being enabled or disabled
1537 ]]--
1538 Flag = class(AbstractValue)
1539
1540 function Flag.__init__(self, ...)
1541 AbstractValue.__init__(self, ...)
1542 self.template = "cbi/fvalue"
1543
1544 self.enabled = "1"
1545 self.disabled = "0"
1546 end
1547
1548 -- A flag can only have two states: set or unset
1549 function Flag.parse(self, section)
1550 local fvalue = self:formvalue(section)
1551
1552 if fvalue then
1553 fvalue = self.enabled
1554 else
1555 fvalue = self.disabled
1556 end
1557
1558 if fvalue == self.enabled or (not self.optional and not self.rmempty) then
1559 if not(fvalue == self:cfgvalue(section)) then
1560 self:write(section, fvalue)
1561 end
1562 else
1563 self:remove(section)
1564 end
1565 end
1566
1567
1568
1569 --[[
1570 ListValue - A one-line value predefined in a list
1571 widget: The widget that will be used (select, radio)
1572 ]]--
1573 ListValue = class(AbstractValue)
1574
1575 function ListValue.__init__(self, ...)
1576 AbstractValue.__init__(self, ...)
1577 self.template = "cbi/lvalue"
1578
1579 self.keylist = {}
1580 self.vallist = {}
1581 self.size = 1
1582 self.widget = "select"
1583 end
1584
1585 function ListValue.prepare(self, ...)
1586 AbstractValue.prepare(self, ...)
1587 if not self.override_scheme
1588 and self.map:get_scheme(self.section.sectiontype, self.option) then
1589 local vs = self.map:get_scheme(self.section.sectiontype, self.option)
1590 if self.value and vs.valuelist and not self.override_values then
1591 for k, v in ipairs(vs.valuelist) do
1592 local deps = {}
1593 if not self.override_dependencies
1594 and vs.enum_depends and vs.enum_depends[v.value] then
1595 for i, dep in ipairs(vs.enum_depends[v.value]) do
1596 table.insert(deps, _uvl_strip_remote_dependencies(dep))
1597 end
1598 end
1599 self:value(v.value, v.title or v.value, unpack(deps))
1600 end
1601 end
1602 end
1603 end
1604
1605 function ListValue.value(self, key, val, ...)
1606 if luci.util.contains(self.keylist, key) then
1607 return
1608 end
1609
1610 val = val or key
1611 table.insert(self.keylist, tostring(key))
1612 table.insert(self.vallist, tostring(val))
1613
1614 for i, deps in ipairs({...}) do
1615 self.subdeps[#self.subdeps + 1] = {add = "-"..key, deps=deps}
1616 end
1617 end
1618
1619 function ListValue.validate(self, val)
1620 if luci.util.contains(self.keylist, val) then
1621 return val
1622 else
1623 return nil
1624 end
1625 end
1626
1627
1628
1629 --[[
1630 MultiValue - Multiple delimited values
1631 widget: The widget that will be used (select, checkbox)
1632 delimiter: The delimiter that will separate the values (default: " ")
1633 ]]--
1634 MultiValue = class(AbstractValue)
1635
1636 function MultiValue.__init__(self, ...)
1637 AbstractValue.__init__(self, ...)
1638 self.template = "cbi/mvalue"
1639
1640 self.keylist = {}
1641 self.vallist = {}
1642
1643 self.widget = "checkbox"
1644 self.delimiter = " "
1645 end
1646
1647 function MultiValue.render(self, ...)
1648 if self.widget == "select" and not self.size then
1649 self.size = #self.vallist
1650 end
1651
1652 AbstractValue.render(self, ...)
1653 end
1654
1655 function MultiValue.value(self, key, val)
1656 if luci.util.contains(self.keylist, key) then
1657 return
1658 end
1659
1660 val = val or key
1661 table.insert(self.keylist, tostring(key))
1662 table.insert(self.vallist, tostring(val))
1663 end
1664
1665 function MultiValue.valuelist(self, section)
1666 local val = self:cfgvalue(section)
1667
1668 if not(type(val) == "string") then
1669 return {}
1670 end
1671
1672 return luci.util.split(val, self.delimiter)
1673 end
1674
1675 function MultiValue.validate(self, val)
1676 val = (type(val) == "table") and val or {val}
1677
1678 local result
1679
1680 for i, value in ipairs(val) do
1681 if luci.util.contains(self.keylist, value) then
1682 result = result and (result .. self.delimiter .. value) or value
1683 end
1684 end
1685
1686 return result
1687 end
1688
1689
1690 StaticList = class(MultiValue)
1691
1692 function StaticList.__init__(self, ...)
1693 MultiValue.__init__(self, ...)
1694 self.cast = "table"
1695 self.valuelist = self.cfgvalue
1696
1697 if not self.override_scheme
1698 and self.map:get_scheme(self.section.sectiontype, self.option) then
1699 local vs = self.map:get_scheme(self.section.sectiontype, self.option)
1700 if self.value and vs.values and not self.override_values then
1701 for k, v in pairs(vs.values) do
1702 self:value(k, v)
1703 end
1704 end
1705 end
1706 end
1707
1708 function StaticList.validate(self, value)
1709 value = (type(value) == "table") and value or {value}
1710
1711 local valid = {}
1712 for i, v in ipairs(value) do
1713 if luci.util.contains(self.keylist, v) then
1714 table.insert(valid, v)
1715 end
1716 end
1717 return valid
1718 end
1719
1720
1721 DynamicList = class(AbstractValue)
1722
1723 function DynamicList.__init__(self, ...)
1724 AbstractValue.__init__(self, ...)
1725 self.template = "cbi/dynlist"
1726 self.cast = "table"
1727 self.keylist = {}
1728 self.vallist = {}
1729 end
1730
1731 function DynamicList.value(self, key, val)
1732 val = val or key
1733 table.insert(self.keylist, tostring(key))
1734 table.insert(self.vallist, tostring(val))
1735 end
1736
1737 function DynamicList.write(self, ...)
1738 self.map.proceed = true
1739 return AbstractValue.write(self, ...)
1740 end
1741
1742 function DynamicList.formvalue(self, section)
1743 local value = AbstractValue.formvalue(self, section)
1744 value = (type(value) == "table") and value or {value}
1745
1746 local valid = {}
1747 for i, v in ipairs(value) do
1748 if v and #v > 0
1749 and not self.map:formvalue("cbi.rle."..section.."."..self.option.."."..i)
1750 and not self.map:formvalue("cbi.rle."..section.."."..self.option.."."..i..".x") then
1751 table.insert(valid, v)
1752 end
1753 end
1754
1755 return valid
1756 end
1757
1758
1759 --[[
1760 TextValue - A multi-line value
1761 rows: Rows
1762 ]]--
1763 TextValue = class(AbstractValue)
1764
1765 function TextValue.__init__(self, ...)
1766 AbstractValue.__init__(self, ...)
1767 self.template = "cbi/tvalue"
1768 end
1769
1770 --[[
1771 Button
1772 ]]--
1773 Button = class(AbstractValue)
1774
1775 function Button.__init__(self, ...)
1776 AbstractValue.__init__(self, ...)
1777 self.template = "cbi/button"
1778 self.inputstyle = nil
1779 self.rmempty = true
1780 end
1781
1782
1783 FileUpload = class(AbstractValue)
1784
1785 function FileUpload.__init__(self, ...)
1786 AbstractValue.__init__(self, ...)
1787 self.template = "cbi/upload"
1788 if not self.map.upload_fields then
1789 self.map.upload_fields = { self }
1790 else
1791 self.map.upload_fields[#self.map.upload_fields+1] = self
1792 end
1793 end
1794
1795 function FileUpload.formcreated(self, section)
1796 return AbstractValue.formcreated(self, section) or
1797 self.map:formvalue("cbi.rlf."..section.."."..self.option) or
1798 self.map:formvalue("cbi.rlf."..section.."."..self.option..".x")
1799 end
1800
1801 function FileUpload.cfgvalue(self, section)
1802 local val = AbstractValue.cfgvalue(self, section)
1803 if val and fs.access(val) then
1804 return val
1805 end
1806 return nil
1807 end
1808
1809 function FileUpload.formvalue(self, section)
1810 local val = AbstractValue.formvalue(self, section)
1811 if val then
1812 if not self.map:formvalue("cbi.rlf."..section.."."..self.option) and
1813 not self.map:formvalue("cbi.rlf."..section.."."..self.option..".x")
1814 then
1815 return val
1816 end
1817 fs.unlink(val)
1818 self.value = nil
1819 end
1820 return nil
1821 end
1822
1823 function FileUpload.remove(self, section)
1824 local val = AbstractValue.formvalue(self, section)
1825 if val and fs.access(val) then fs.unlink(val) end
1826 return AbstractValue.remove(self, section)
1827 end
1828
1829
1830 FileBrowser = class(AbstractValue)
1831
1832 function FileBrowser.__init__(self, ...)
1833 AbstractValue.__init__(self, ...)
1834 self.template = "cbi/browser"
1835 end
Lua Configuration Interface (mirror)