import os
import sys
import time
-#import configparser
-#import importlib.machinery
try:
assert sys.version_info >= (3,1)
import configparser
class PythonCharts(object):
def __init__(self,
- interval=1,
+ interval=None,
modules=[],
modules_path='../python.d/',
- modules_configs='../conf.d/'):
+ modules_configs='../conf.d/',
+ modules_disabled=[]):
self.first_run = True
- self.interval = interval
- # check if plugin directory exists
- if not os.path.isdir(modules_path):
- debug("cannot find charts directory ", modules_path)
- sys.stdout.write("DISABLE\n")
- sys.exit(1)
+ self.default_priority = 90000
+ # set configuration directory
self.configs = modules_configs
- self.modules = []
- if len(modules) > 0:
- for m in modules:
- self.modules.append(
- self.import_plugin(
- modules_path + m + ".chart.py"))
- else:
- self.load_modules(modules_path)
- if len(self.modules) == 0:
- debug("cannot find modules directory", modules_path)
- sys.stdout.write("DISABLE\n")
- sys.exit(1)
+ # load modules
+ modules = self._load_modules(modules_path,modules)
+
+ # check if loaded modules are on disabled modules list
+ self.modules = [ m for m in modules if m.__name__ not in modules_disabled ]
+
+ # load configuration files
+ self._load_configs()
- self.load_configs()
-
- # set last execution and execution frequency dict
+ # set timetable dict (last execution, next execution and frequency)
+ # set priorities
self.timetable = {}
+ freq = 1
for m in self.modules:
try:
- interval = m.update_every
- interval = int(interval)
- except AttributeError:
- interval = self.interval
- except ValueError:
- interval = self.interval
- debug(m.__name__ +
- ": wrong value of 'update_every' setting to " +
- str(self.interval))
- # ensure module update frequency is not less than execution of this program
- if interval < self.interval:
- interval = self.interval
- # charts updates are twice as frequent as user specified
- self.timetable[m.__name__] = [0, interval/2.0]
+ m.priority = int(m.priority)
+ except (AttributeError,ValueError):
+ m.priority = self.default_priority
+
+ if interval is None:
+ try:
+ freq = int(m.update_every)
+ except (AttributeError, ValueError):
+ freq = 1
+
+ now = time.time()
+ self.timetable[m.__name__] = {'last' : now,
+ 'next' : now - (now % freq) + freq,
+ 'freq' : freq}
- def import_plugin(self, path, name=None):
+ def _import_plugin(self, path, name=None):
+ # try to import module using only its path
if name is None:
name = path.split('/')[-1]
if name[-9:] != ".chart.py":
debug(str(e))
return None
- def load_modules(self, path):
- names = os.listdir(path)
- for mod in names:
- m = self.import_plugin(path + mod)
- if m is not None:
- debug("loading chart: '" + path + mod + "'")
- self.modules.append(m)
+ def _load_modules(self, path, modules):
+ # check if plugin directory exists
+ if not os.path.isdir(path):
+ debug("cannot find charts directory ", path)
+ sys.stdout.write("DISABLE\n")
+ sys.exit(1)
+
+ # load modules
+ loaded = []
+ if len(modules) > 0:
+ for m in modules:
+ mod = self._import_plugin(path + m + ".chart.py")
+ if mod is not None:
+ loaded.append(mod)
+ else:
+ # scan directory specified in path and load all modules from there
+ names = os.listdir(path)
+ for mod in names:
+ m = self._import_plugin(path + mod)
+ if m is not None:
+ debug("loading chart: '" + path + mod + "'")
+ loaded.append(m)
+ return loaded
- def load_configs(self):
+ def _load_configs(self):
+ # function modifies every loaded module in self.modules
for m in self.modules:
configfile = self.configs + m.__name__ + ".conf"
if os.path.isfile(configfile):
configfile +
"' not found. Using defaults.")
- def disable_module(self, mod, reason=None):
+ def _disable_module(self, mod, reason=None):
+ # modifies self.modules
self.modules.remove(mod)
del self.timetable[mod.__name__]
if reason is None:
"() function. Disabling it.")
elif reason[:7] == "failed ":
debug("chart '" +
- mod.__name__ +
- reason[3:] +
- "() function. reports failure.")
+ mod.__name__ + "' " +
+ reason[7:] +
+ "() function reports failure.")
elif reason[:13] == "configuration":
debug(mod.__name__,
"configuration file '" +
mod.__name__ +
".conf' not found. Using defaults.")
elif reason[:11] == "misbehaving":
- debug(mod.__name__, "is misbeaving. Disabling it")
+ debug(mod.__name__, "is "+reason)
def check(self):
+ # try to execute check() on every loaded module
for mod in self.modules:
try:
if not mod.check():
- self.disable_module(mod, "failed check")
+ self._disable_module(mod, "failed check")
except AttributeError:
- self.disable_module(mod, "no check")
- except UnboundLocalError:
- self.disable_module(mod, "misbehaving")
+ self._disable_module(mod, "no check")
+ except (UnboundLocalError, Exception) as e:
+ self._disable_module(mod, "misbehaving. Reason: " + str(e))
def create(self):
+ # try to execute create() on every loaded module
for mod in self.modules:
try:
if not mod.create():
- self.disable_module(mod, "failed create")
+ self._disable_module(mod, "failed create")
else:
chart = mod.__name__
sys.stdout.write(
" '' 'Execution time for " +
chart +
" plugin' 'milliseconds / run' python.d netdata.plugin_python area 145000 " +
- str(self.timetable[mod.__name__][1]) +
+ str(self.timetable[mod.__name__]['freq']) +
'\n')
sys.stdout.write("DIMENSION run_time 'run time' absolute 1 1\n\n")
sys.stdout.flush()
except AttributeError:
- self.disable_module(mod, "no create")
- except UnboundLocalError:
- self.disable_module(mod, "misbehaving")
+ self._disable_module(mod, "no create")
+ except (UnboundLocalError, Exception) as e:
+ self._disable_module(mod, "misbehaving. Reason: " + str(e))
- def update_module(self, mod):
- t1 = time.time()
+ def _update_module(self, mod):
+ # try to execute update() on every module and draw run time graph
+ t_start = time.time()
# check if it is time to execute module update() function
- if (t1 - self.timetable[mod.__name__][0]) < self.timetable[mod.__name__][1]:
+ if self.timetable[mod.__name__]['next'] > t_start:
return
try:
- if not self.first_run:
- t = ""
+ if self.first_run:
+ since_last = 0
else:
- t=int((t1- self.timetable[mod.__name__][0]) * 1000000)
- if not mod.update(t):
- self.disable_module(mod, "update failed")
+ since_last = int((t_start - self.timetable[mod.__name__]['last']) * 1000000)
+ if not mod.update(since_last):
+ self._disable_module(mod, "update failed")
return
except AttributeError:
- self.disable_module(mod, "no update")
+ self._disable_module(mod, "no update")
return
- except UnboundLocalError:
- self.disable_module(mod, "misbehaving")
+ except (UnboundLocalError, Exception) as e:
+ self._disable_module(mod, "misbehaving. Reason: " + str(e))
return
- t2 = time.time()
+ t_end = time.time()
+ self.timetable[mod.__name__]['next'] = t_end - (t_end % self.timetable[mod.__name__]['freq']) + self.timetable[mod.__name__]['freq']
+ # draw performance graph
if self.first_run:
- dt = ""
+ dt = 0
else:
- dt = int((t2 - self.timetable[mod.__name__][0]) * 1000000)
- sys.stdout.write("BEGIN netdata.plugin_pythond_"+mod.__name__+" "+str(dt)+'\n')
- sys.stdout.write("SET run_time = " + str(int((t2 - t1) * 1000)) + '\n')
+ dt = int((t_end - self.timetable[mod.__name__]['last']) * 1000000)
+ sys.stdout.write("BEGIN netdata.plugin_pythond_"+mod.__name__+" "+str(since_last)+'\n')
+ sys.stdout.write("SET run_time = " + str(int((t_end - t_start) * 1000)) + '\n')
sys.stdout.write("END\n")
sys.stdout.flush()
- self.timetable[mod.__name__][0] = t1
+ self.timetable[mod.__name__]['last'] = t_start
+ self.first_run = False
def update(self):
+ # run updates (this will stay forever and ever and ever forever and ever it'll be the one...)
+ self.first_run = True
while True:
t_begin = time.time()
+ next_runs = []
for mod in self.modules:
- self.update_module(mod)
- time.sleep((self.interval - (time.time() - t_begin)) / 2)
- self.first_run = False
+ self._update_module(mod)
+ try:
+ next_runs.append(self.timetable[mod.__name__]['next'])
+ except KeyError:
+ pass
+ if len(next_runs) == 0:
+ debug("No plugins loaded")
+ sys.stdout.write("DISABLE\n")
+ sys.exit(1)
+ time.sleep(min(next_runs) - time.time())
def read_config(path):
except IsADirectoryError:
debug(str(path), "is a directory")
return
- config.read_string(config_str)
+ try:
+ config.read_string(config_str)
+ except configparser.ParsingError as e:
+ debug("Malformed configuration file: "+str(e))
+ return
return dict(config.items('config'))
pass
debug("started from", commands[0], "with options:", *commands[1:])
+ if len(mods) == 0 and DEBUG_FLAG is False:
+ interval = None
return {'interval': interval,
'modules': mods}
main_dir = os.getenv('NETDATA_PLUGINS_DIR',
os.path.abspath(__file__).strip("python.d.plugin.py"))
config_dir = os.getenv('NETDATA_CONFIG_DIR', "/etc/netdata/")
- interval = int(os.getenv('NETDATA_UPDATE_EVERY', 1))
+ interval = os.getenv('NETDATA_UPDATE_EVERY', None)
# read configuration file
+ disabled = []
if config_dir[-1] != '/':
- configfile = config_dir + '/' + "python.d.conf"
- else:
- configfile = config_dir + "python.d.conf"
+ config_dir += '/'
+ configfile = config_dir + "python.d.conf"
try:
conf = read_config(configfile)
pass
try:
modules_conf = conf['plugins_config_dir']
- except (KeyError, TypeError):
- modules_conf = config_dir # default configuration directory
+ except (KeyError):
+ modules_conf = config_dir + "python.d/" # default configuration directory
try:
modules_dir = conf['plugins_dir']
- except (KeyError, TypeError):
+ except (KeyError):
modules_dir = main_dir.replace("plugins.d", "python.d")
try:
interval = int(conf['interval'])
except (KeyError, TypeError):
- pass # default interval
+ pass # use default interval from NETDATA_UPDATE_EVERY
try:
DEBUG_FLAG = bool(conf['debug'])
except (KeyError, TypeError):
pass
+ for k, v in conf.items():
+ if k in ("plugins_config_dir", "plugins_dir", "interval", "debug"):
+ continue
+ if v == 'no':
+ disabled.append(k)
except FileNotFoundError:
modules_conf = config_dir
modules_dir = main_dir.replace("plugins.d", "python.d")
modules = out['modules']
if out['interval'] is not None:
interval = out['interval']
-
+
+ # configure environement to run modules
+ sys.path.append(modules_dir+"python_modules") # append path to directory with modules dependencies
+
# run plugins
- charts = PythonCharts(interval, modules, modules_dir, modules_conf)
+ charts = PythonCharts(interval, modules, modules_dir, modules_conf, disabled)
charts.check()
charts.create()
charts.update()
projects / netdata.git / blobdiff