applications/luci-statistics/root/usr/bin/stat-genconfig

   1 #!/usr/bin/lua
   2
   3 --[[
   4
   5 Luci statistics - collectd configuration generator
   6 (c) 2008 Freifunk Leipzig / Jo-Philipp Wich <xm@leipzig.freifunk.net>
   7
   8 Licensed under the Apache License, Version 2.0 (the "License");
   9 you may not use this file except in compliance with the License.
  10 You may obtain a copy of the License at
  11
  12                 http://www.apache.org/licenses/LICENSE-2.0
  13
  14 $Id$
  15
  16 ]]--
  17
  18
  19 require("luci.model.uci")
  20 require("luci.sys.iptparser")
  21 require("luci.util")
  22
  23 local ipt = luci.sys.iptparser.IptParser()
  24 local uci = luci.model.uci.cursor()
  25 local sections = uci:get_all( "luci_statistics" )
  26
  27
  28 function print(...)
  29         nixio.stdout:write(...)
  30         nixio.stdout:write("\n")
  31 end
  32
  33 function section( plugin )
  34
  35         local config = sections[ "collectd_" .. plugin ] or sections["collectd"]
  36
  37         if type(config) == "table" and ( plugin == "collectd" or config.enable == "1" ) then
  38
  39                 local params = ""
  40
  41                 if type( plugins[plugin] ) == "function" then
  42                         params = plugins[plugin]( config )
  43                 else
  44                         params = config_generic( config, plugins[plugin][1], plugins[plugin][2], plugins[plugin][3], plugin == "collectd" )
  45                 end
  46
  47
  48                 if plugin ~= "collectd" then
  49                         print( "LoadPlugin " .. plugin )
  50
  51                         if params:len() > 0 then
  52                                 print( "<Plugin " .. plugin .. ">\n" .. params .. "</Plugin>\n" )
  53                         else
  54                                 print( "" )
  55                         end
  56                 else
  57                         print( params .. "\n" )
  58                 end
  59         end
  60 end
  61
  62 function config_generic( c, singles, bools, lists, nopad )
  63         local str = ""
  64
  65         if type(c) == "table" then
  66
  67                 if type(singles) == "table" then
  68                         for i, key in ipairs( singles ) do
  69                                 if preprocess[key] then
  70                                         c[key] = preprocess[key](c[key])
  71                                 end
  72
  73                                 str = str .. _string( c[key], key, nopad )
  74                         end
  75                 end
  76
  77                 if type(bools) == "table" then
  78                         for i, key in ipairs( bools ) do
  79                                 if preprocess[key] then
  80                                         c[key] = preprocess[key](c[key])
  81                                 end
  82
  83                                 str = str .. _bool( c[key], key, nopad )
  84                         end
  85                 end
  86
  87                 if type(lists) == "table" then
  88                         str = str .. _list_expand( c, lists, nopad )
  89                 end
  90         end
  91
  92         return str
  93 end
  94
  95 function config_exec( c )
  96         local str = ""
  97
  98         for s in pairs(sections) do
  99                 for key, type in pairs({ Exec="collectd_exec_input", NotificationExec="collectd_exec_notify" }) do
 100                         if sections[s][".type"] == type then
 101
 102                                 cmd = sections[s].cmdline
 103
 104                                 if cmd then
 105                                         cmd   = cmd:gsub("^%s+", ""):gsub("%s+$", "")
 106                                         user  = sections[s].cmduser  or "nobody"
 107                                         group = sections[s].cmdgroup
 108
 109                                         str = str .. "\t" .. key .. ' "' ..
 110                                                 user .. ( group and ":" .. group or "" ) .. '" "' ..
 111                                                 cmd:gsub('%s+', '" "') .. '"\n'
 112                                 end
 113                         end
 114                 end
 115         end
 116
 117         return str
 118 end
 119
 120 function config_iptables( c )
 121         local str = ""
 122
 123         for s in pairs(sections) do
 124                 if sections[s][".type"] == "collectd_iptables_match" then
 125
 126                         search = { }
 127
 128                         for i, k in ipairs( {
 129                                 "table", "chain", "target", "protocol", "source", "destination",
 130                                 "inputif", "outputif", "options"
 131                         } ) do
 132                                 v = sections[s][k]
 133
 134                                 if type(v) == "string" then
 135                                         if k == "options" then v = luci.util.split( v, "%s+", nil, true ) end
 136                                         search[k] = v
 137                                 end
 138                         end
 139
 140                         for i, rule in ipairs( ipt:find( search ) ) do
 141
 142                                 name = sections[s].name:gsub( "%s+", "_" )
 143                                 if i > 1 then name = name .. "_(" .. i .. ")" end
 144
 145                                 str = str .. "\tChain " .. rule.table .. " " .. rule.chain .. " " .. rule.index .. ' "' .. name .. "\"\n"
 146                         end
 147                 end
 148         end
 149
 150         return str
 151 end
 152
 153 function config_network( c )
 154         local str = ""
 155
 156         for s in pairs(sections) do
 157                 for key, type in pairs({ Listen="collectd_network_listen", Server="collectd_network_server" }) do
 158                         if sections[s][".type"] == type then
 159
 160                                 host = sections[s].host
 161                                 port = sections[s].port
 162
 163                                 if host then
 164                                         if port then
 165                                                 str = str .. "\t" .. key .. " \"" .. host .. "\" \"" .. port .. "\"\n"
 166                                         else
 167                                                 str = str .. "\t" .. key .. " \"" .. host .. "\"\n"
 168                                         end
 169                                 end
 170                                                 end
 171                                 end
 172                 end
 173
 174         return str .. _string( c["TimeToLive"], "TimeToLive" )
 175                    .. _string( c["CacheFlush"], "CacheFlush" )
 176                    .. _bool(   c["Forward"],    "Forward"    )
 177 end
 178
 179
 180 function _list_expand( c, l, nopad )
 181         local str = ""
 182
 183         for i, n in ipairs(l) do
 184                 if c[n] then
 185                         if preprocess[n] then
 186                                 c[n] = preprocess[n](c[n])
 187                         end
 188
 189                         if n:find("(%w+)ses") then
 190                                 k = n:gsub("(%w+)ses", "%1s")
 191                         else
 192                                 k = n:gsub("(%w+)s", "%1")
 193                         end
 194
 195                         str = str .. _expand( c[n], k, nopad )
 196                 end
 197         end
 198
 199         return str
 200 end
 201
 202 function _expand( s, n, nopad )
 203         if type(s) == "string" then
 204                 local str = ""
 205
 206                 for i, v in ipairs( luci.util.split( s, "%s+", nil, true ) ) do
 207                         str = str .. _string( v, n, nopad )
 208                 end
 209
 210                 return str
 211
 212         elseif type(s) == "table" then
 213                 local str = ""
 214
 215                 for i, v in ipairs(s) do
 216                         str = str .. _string( v, n, nopad )
 217                 end
 218         end
 219 end
 220
 221 function _bool( s, n, nopad )
 222
 223         local str = ""
 224         local pad = ""
 225         if not nopad then pad = "\t" end
 226
 227         if s and s == "1" then
 228                 str = pad .. n .. " true"
 229         else
 230                 str = pad .. n .. " false"
 231         end
 232
 233         return str .. "\n"
 234 end
 235
 236 function _string( s, n, nopad )
 237
 238         local str = ""
 239         local pad = ""
 240         if not nopad then pad = "\t" end
 241
 242         if s then
 243                 if s:find("[^%d]") or n == "Port" then
 244                         if not s:find("[^%w]") and n ~= "Port" then
 245                                 str = pad .. n .. " " .. luci.util.trim(s)
 246                         else
 247                                 str = pad .. n .. ' "' .. luci.util.trim(s) .. '"'
 248                         end
 249                 else
 250                         str = pad .. n .. " " .. luci.util.trim(s)
 251                 end
 252
 253                 str = str .. "\n"
 254         end
 255
 256         return str
 257 end
 258
 259
 260 plugins = {
 261         collectd = {
 262                 { "BaseDir", "Include", "PIDFile", "PluginDir", "TypesDB", "Interval", "ReadThreads", "Hostname" },
 263                 { },
 264                 { }
 265         },
 266
 267         conntrack = {
 268                 { },
 269                 { },
 270                 { }
 271         },
 272
 273         cpu     = {
 274                 { },
 275                 { },
 276                 { }
 277         },
 278
 279         csv     = {
 280                 { "DataDir" },
 281                 { "StoreRates" },
 282                 { }
 283         },
 284
 285         df      = {
 286                 { },
 287                 { "IgnoreSelected" },
 288                 { "Devices", "MountPoints", "FSTypes" }
 289         },
 290
 291         disk    = {
 292                 { },
 293                 { "IgnoreSelected" },
 294                 { "Disks" }
 295         },
 296
 297         dns     = {
 298                 { },
 299                 { },
 300                 { "Interfaces", "IgnoreSources" }
 301         },
 302
 303         email   = {
 304                 { "SocketFile", "SocketGroup", "SocketPerms", "MaxConns" },
 305                 { },
 306                 { }
 307         },
 308
 309         exec    = config_exec,
 310
 311         interface = {
 312                 { },
 313                 { "IgnoreSelected" },
 314                 { "Interfaces" }
 315         },
 316
 317         iptables = config_iptables,
 318
 319         irq     = {
 320                 { },
 321                 { "IgnoreSelected" },
 322                 { "Irqs" }
 323         },
 324
 325         iwinfo = {
 326                 { },
 327                 { "IgnoreSelected" },
 328                 { "Interfaces" }
 329         },
 330
 331         load    = {
 332                 { },
 333                 { },
 334                 { }
 335         },
 336
 337         logfile = {
 338                 { "LogLevel", "File" },
 339                 { "Timestamp" },
 340                 { }
 341         },
 342
 343         madwifi = {
 344                 { "WatchSet" },
 345                 { },
 346                 { "Interfaces", "WatchAdds" }
 347         },
 348
 349         memory = {
 350                 { },
 351                 { },
 352                 { }
 353         },
 354
 355         netlink = {
 356                 { },
 357                 { "IgnoreSelected" },
 358                 { "Interfaces", "VerboseInterfaces", "QDiscs", "Classes", "Filters" }
 359         },
 360
 361         network = config_network,
 362
 363         olsrd = {
 364                 { "Host", "Port", "CollectLinks","CollectRoutes","CollectTopology"},
 365                 { },
 366                 { }
 367         },
 368
 369         ping    = {
 370                 { "TTL", "Interval" },
 371                 { },
 372                 { "Hosts" }
 373         },
 374
 375         processes = {
 376                 { },
 377                 { },
 378                 { "Processes" }
 379         },
 380
 381         rrdtool = {
 382                 { "DataDir", "StepSize", "HeartBeat", "RRARows", "XFF", "CacheFlush", "CacheTimeout" },
 383                 { "RRASingle" },
 384                 { "RRATimespans" }
 385         },
 386
 387         tcpconns = {
 388                 { },
 389                 { "ListeningPorts" },
 390                 { "LocalPorts", "RemotePorts" }
 391         },
 392
 393         unixsock = {
 394                 { "SocketFile", "SocketGroup", "SocketPerms" },
 395                 { },
 396                 { }
 397         },
 398
 399         wireless = {
 400                 { },
 401                 { },
 402                 { }
 403         },
 404 }
 405
 406 preprocess = {
 407         RRATimespans = function(val)
 408                 local rv = { }
 409                 for time in val:gmatch("[^%s]+") do
 410                         table.insert( rv, luci.util.parse_units(time) )
 411                 end
 412                 return table.concat(rv, " ")
 413         end
 414 }
 415
 416
 417 section("collectd")
 418
 419 for plugin in pairs(plugins) do
 420         if plugin ~= "collectd" then
 421                 section( plugin )
 422         end
 423 end