applications/luci-app-statistics/luasrc/statistics/datatree.lua

   1 -- Copyright 2008 Freifunk Leipzig / Jo-Philipp Wich <xm@leipzig.freifunk.net>
   2 -- Licensed to the public under the Apache License 2.0.
   3
   4 module("luci.statistics.datatree", package.seeall)
   5
   6 local util = require("luci.util")
   7 local sys  = require("luci.sys")
   8 local fs   = require("nixio.fs")
   9 local uci  = require("luci.model.uci").cursor()
  10 local sections = uci:get_all("luci_statistics")
  11
  12
  13 Instance = util.class()
  14
  15 function Instance.__init__( self, host )
  16         self._host    = host or sections.collectd.Hostname or sys.hostname()
  17         self._libdir  = sections.collectd.PluginDir        or "/usr/lib/collectd"
  18         self._rrddir  = sections.collectd_rrdtool.DataDir  or "/tmp/rrd"
  19
  20         self._libdir  = self._libdir:gsub("/$","")
  21         self._rrddir  = self._rrddir:gsub("/$","")
  22         self._plugins = { }
  23
  24         self:_scan()
  25 end
  26
  27 function Instance._mkpath( self, plugin, pinstance )
  28         local dir = self._rrddir .. "/" .. self._host
  29
  30         if type(plugin) == "string" and plugin:len() > 0 then
  31                 dir = dir .. "/" .. plugin
  32
  33                 if type(pinstance) == "string" and pinstance:len() > 0 then
  34                         dir = dir .. "-" .. pinstance
  35                 end
  36         end
  37
  38         return dir
  39 end
  40
  41 function Instance._ls( self, ... )
  42         local ditr = fs.dir(self:_mkpath(...))
  43         if ditr then
  44                 local dirs = { }
  45                 while true do
  46                         local d = ditr()
  47                         if not d then break end
  48                         dirs[#dirs+1] = d
  49                 end
  50                 return dirs
  51         end
  52 end
  53
  54 function Instance._notzero( self, table )
  55         for k in pairs(table) do
  56                 return true
  57         end
  58
  59         return false
  60 end
  61
  62 function Instance._scan( self )
  63         local dirs = self:_ls()
  64         if not dirs then
  65                 return
  66         end
  67
  68 --      for i, plugin in ipairs( dirs ) do
  69 --              if plugin:match("%w+.so") then
  70 --                      self._plugins[ plugin:gsub("%.so$", "") ] = { }
  71 --              end
  72 --      end
  73
  74         for _, dir in ipairs(dirs) do
  75                 if dir ~= "." and dir ~= ".." and
  76                    fs.stat(self:_mkpath(dir)).type == "dir"
  77                 then
  78                         local plugin = dir:gsub("%-.+$", "")
  79                         if not self._plugins[plugin] then
  80                                 self._plugins[plugin] = { }
  81                         end
  82                 end
  83         end
  84
  85         for plugin, instances in pairs( self._plugins ) do
  86
  87                 local dirs = self:_ls()
  88
  89                 if type(dirs) == "table" then
  90                         for i, dir in ipairs(dirs) do
  91                                 if dir:find( plugin .. "%-" ) or dir == plugin then
  92                                         local instance = ""
  93
  94                                         if dir ~= plugin then
  95                                                 instance = dir:gsub( plugin .. "%-", "", 1 )
  96                                         end
  97
  98                                         instances[instance] = { }
  99                                 end
 100                         end
 101                 end
 102
 103                 for instance, data_instances in pairs( instances ) do
 104
 105                         dirs = self:_ls(plugin, instance)
 106
 107                         if type(dirs) == "table" then
 108                                 for i, file in ipairs(dirs) do
 109                                         if file:find("%.rrd") then
 110                                                 file = file:gsub("%.rrd","")
 111
 112                                                 local data_type
 113                                                 local data_instance
 114
 115                                                 if file:find("%-") then
 116                                                         data_type     = file:gsub( "%-.+","" )
 117                                                         data_instance = file:gsub( "[^%-]-%-", "", 1 )
 118                                                 else
 119                                                         data_type     = file
 120                                                         data_instance = ""
 121                                                 end
 122
 123                                                 if not data_instances[data_type] then
 124                                                         data_instances[data_type] = { data_instance }
 125                                                 else
 126                                                         table.insert( data_instances[data_type], data_instance )
 127                                                 end
 128                                         end
 129                                 end
 130                         end
 131                 end
 132         end
 133 end
 134
 135
 136 function Instance.plugins( self )
 137         local rv = { }
 138
 139         for plugin, val in pairs( self._plugins ) do
 140                 if self:_notzero( val ) then
 141                         table.insert( rv, plugin )
 142                 end
 143         end
 144
 145         return rv
 146 end
 147
 148 function Instance.plugin_instances( self, plugin )
 149         local rv = { }
 150
 151         for instance, val in pairs( self._plugins[plugin] ) do
 152                 table.insert( rv, instance )
 153         end
 154
 155         return rv
 156 end
 157
 158 function Instance.data_types( self, plugin, instance )
 159         local rv = { }
 160         local p  = self._plugins[plugin]
 161
 162         if type(p) == "table" and type(p[instance]) == "table" then
 163                 for type, val in pairs(p[instance]) do
 164                         table.insert( rv, type )
 165                 end
 166         end
 167
 168         return rv
 169 end
 170
 171 function Instance.data_instances( self, plugin, instance, dtype )
 172         local rv = { }
 173         local p  = self._plugins[plugin]
 174
 175         if type(p) == "table" and type(p[instance]) == "table" and type(p[instance][dtype]) == "table" then
 176                 for i, instance in ipairs(p[instance][dtype]) do
 177                         table.insert( rv, instance )
 178                 end
 179         end
 180
 181         return rv
 182 end
 183
 184 function Instance.host_instances( self )
 185         local hosts_path = fs.glob(self._rrddir..'/*')
 186         local hosts = { }
 187
 188         if hosts_path then
 189                 local path
 190                 for path in hosts_path do
 191                         hosts[#hosts+1] = fs.basename(path)
 192                 end
 193         end
 194
 195         return hosts
 196 end
 197