[project/luci.git] / applications / luci-statistics / files / usr / bin / stat-genconfig

#!/usr/bin/lua

--[[

Luci statistics - collectd configuration generator
(c) 2008 Freifunk Leipzig / Jo-Philipp Wich <xm@leipzig.freifunk.net>

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

$Id$

]]--


require("ffluci.model.uci")
require("ffluci.sys.iptparser")
require("ffluci.util")

local ipt = ffluci.sys.iptparser.IptParser()
local uci = ffluci.model.uci.Session()
local sections, names = uci:sections( "luci_statistics" )


function section( plugin )

        local config = sections[ "collectd_" .. plugin ] or sections["general"]

        if type(config) == "table" and ( plugin == "general" or config.enable == "1" ) then

                if plugin ~= "general" then print( "<Plugin " .. plugin .. ">" ) end

                if type( plugins[plugin] ) == "function" then
                        plugins[plugin]( config )
                else
                        config_generic( config, plugins[plugin][1], plugins[plugin][2], plugins[plugin][3], plugin == "general" )
                end

                if plugin ~= "general" then
                        print( "</Plugin>\n" )
                else
                        print( "\n" )
                end

        end
end

function config_generic( c, singles, bools, lists, nopad )

        if type(c) == "table" then

                if type(singles) == "table" then
                        for i, key in ipairs( singles ) do
                                _string( c[key], key, nopad )
                        end
                end

                if type(bools) == "table" then
                        for i, key in ipairs( bools ) do
                                _bool( c[key], key, nopad )
                        end
                end

                if type(lists) == "table" then
                        _list_expand( c, lists, nopad )
                end

        end

end

function config_exec( c )

        for s in pairs(sections) do
                for key, type in pairs({ Exec="collectd_exec_input", NotificationExec="collectd_exec_notify" }) do
                        if sections[s][".type"] == type then

                                cmd   = sections[s].cmdline
                                user  = sections[s].cmduser  or "root"
                                group = sections[s].cmdgroup or "root"

                                print( "\t" .. key .. " " .. user .. ":" .. group .. ' "' .. cmd .. '"' )
                        end
                end
        end
end

function config_iptables( c )

        for s in pairs(sections) do
                if sections[s][".type"] == "collectd_iptables_match" then

                        search = { }

                        for i, k in ipairs( {
                                "table", "chain", "target", "protocol", "source", "destination",
                                "inputif", "outputif", "options"
                        } ) do
                                v = sections[s][k]

                                if type(v) == "string" then
                                        if k == "options" then v = ffluci.util.split( v, "%s+", nil, true ) end
                                        search[k] = v
                                end
                        end

                        for i, rule in ipairs( ipt:find( search ) ) do

                                name = sections[s].name
                                if i > 1 then name = name .. " (" .. i .. ")" end

                                print( "\tChain " .. rule.table .. " " .. rule.chain .. " " .. rule.index .. ' "' .. name .. '"' )

                        end
                end
        end
end

function config_network( c )

        for s in pairs(sections) do
                for key, type in pairs({ Listen="collectd_network_listen", Server="collectd_network_server" }) do
                        if sections[s][".type"] == type then

                                host = sections[s].host
                                port = sections[s].port

                                if host then
                                        if port then
                                                print( "\t" .. key .. " " .. host .. " " .. port )
                                        else
                                                print( "\t" .. key .. " " .. host )
                                        end
                                end
                        end
                end
        end

        _string( c["TimeToLive"], "TimeToLive" )
        _string( c["CacheFlush"], "CacheFlush" )
        _bool(   c["Forward"],    "Forward"    )
end


function _list_expand( c, l, nopad )
        for i, n in ipairs(l) do
                if c[n] then
                        _expand( c[n], n:gsub( "(%w+)s", "%1" ), nopad )
                end
        end
end

function _expand( s, n, nopad )
        if type(s) == "string" then
                for i, v in ipairs( ffluci.util.split( s, "%s+", nil, true ) ) do
                        _string( v, n, nopad )
                end
        end
end

function _bool( s, n, nopad )

        local pad = ""
        if not nopad then pad = "\t" end

        if s and s == "1" then
                print( pad .. n .. " true" )
        else
                print( pad .. n .. " false" )
        end
end

function _string( s, n, nopad )

        local pad = ""
        if not nopad then pad = "\t" end

        if s then
                if not s:find("%d") then
                        if not s:find("%s") then
                                print( pad .. n .. " " .. s )
                        else
                                print( pad .. n .. ' "' .. s '"' )
                        end
                else
                        print( pad .. n .. " " .. s )
                end
        end
end             


plugins = {
        general = {
                { "BaseDir", "Include", "PIDFile", "PluginDir", "TypesDB", "Interval", "ReadThreads" },
                { },
                { }
        },

        csv     = { 
                { "DataDir" },
                { "StoreRates" },
                { }
        },

        df      = {
                { },
                { "IgnoreSelected" },
                { "Devices", "MountPoints", "FSTypes" }
        },

        disk    = {
                { },
                { "IgnoreSelected" },
                { "Disks" }
        },

        dns     = {
                { },
                { },
                { "Interfaces", "IgnoreSources" }
        },

        email   = {
                { "SocketFile", "SocketUser", "SocketPerms", "MaxConns" },
                { },
                { }
        },

        exec    = config_exec,

        interface = {
                { },
                { "IgnoreSelected" },
                { "Interfaces" }
        },

        iptables = config_iptables,

        irq     = {
                { },
                { "IgnoreSelected" },
                { "Irqs" }
        },

        logfile = {
                { "LogLevel", "File" },
                { "Timestamp" },
                { }
        },

        netlink = {
                { },
                { "IgnoreSelected" },
                { "Interfaces", "VerboseInterfaces", "QDiscs", "Classs", "Filters" }
        },

        network = config_network,

        processes = {
                { },
                { },
                { "Processs" }
        },

        tcpconns = {
                { },
                { "ListeningPorts" },
                { "LocalPorts", "RemotePorts" }
        },

        unixsock = {
                { "SocketFile", "SocketUser", "SocketPerms" },
                { },
                { }
        },

}


section("general")

for plugin in pairs(plugins) do
        if plugin ~= "general" then
                section( plugin )
        end
end