f33711f49f
User can now use -p <key>=<value> to pass configuration parameters to modules. For this, the module gets a "parameter()" method. Parameter keys are in the format <name>.<key> where <name> is the name of the loaded module. This is either the name of the module itself (e.g. "cpu") or its alias, if the user specified it, for example: bumblebee-status -m cpu -p cpu.warning=90 vs. bumblebee-status -m cpu:test -p test.warning=90 see #23
108 lines
3.3 KiB
Python
108 lines
3.3 KiB
Python
"""Core application engine"""
|
|
|
|
import os
|
|
import time
|
|
import pkgutil
|
|
import importlib
|
|
import bumblebee.error
|
|
import bumblebee.modules
|
|
|
|
def modules():
|
|
"""Return a list of available modules"""
|
|
result = []
|
|
path = os.path.dirname(bumblebee.modules.__file__)
|
|
for mod in [name for _, name, _ in pkgutil.iter_modules([path])]:
|
|
result.append({
|
|
"name": mod
|
|
})
|
|
return result
|
|
|
|
class Module(object):
|
|
"""Module instance base class
|
|
|
|
Objects of this type represent the modules that
|
|
the user configures. Concrete module implementations
|
|
(e.g. CPU utilization, disk usage, etc.) derive from
|
|
this base class.
|
|
"""
|
|
def __init__(self, engine, widgets):
|
|
self.name = self.__module__.split(".")[-1]
|
|
self._widgets = []
|
|
if widgets:
|
|
self._widgets = widgets if isinstance(widgets, list) else [widgets]
|
|
|
|
def widgets(self):
|
|
"""Return the widgets to draw for this module"""
|
|
return self._widgets
|
|
|
|
def update(self, widgets):
|
|
"""By default, update() is a NOP"""
|
|
pass
|
|
|
|
def parameter(self, name, default=None):
|
|
"""Return the config parameter 'name' for this module"""
|
|
name = "{}.{}".format(self._config_name, name)
|
|
return self._config.get(name, default)
|
|
|
|
def set_config(self, config, name):
|
|
"""Set the config for this module"""
|
|
self._config = config
|
|
self._config_name = name
|
|
|
|
class Engine(object):
|
|
"""Engine for driving the application
|
|
|
|
This class connects input/output, instantiates all
|
|
required modules and drives the "event loop"
|
|
"""
|
|
def __init__(self, config, output=None):
|
|
self._output = output
|
|
self._config = config
|
|
self._running = True
|
|
self._modules = []
|
|
self.load_modules(config.modules())
|
|
|
|
def load_modules(self, modules):
|
|
"""Load specified modules and return them as list"""
|
|
for module in modules:
|
|
self._modules.append(self.load_module(module["module"], module["name"]))
|
|
return self._modules
|
|
|
|
def load_module(self, module_name, config_name=None):
|
|
"""Load specified module and return it as object"""
|
|
if config_name == None:
|
|
config_name = module_name
|
|
try:
|
|
module = importlib.import_module("bumblebee.modules.{}".format(module_name))
|
|
except ImportError as error:
|
|
raise bumblebee.error.ModuleLoadError(error)
|
|
res = getattr(module, "Module")(self)
|
|
res.set_config(self._config, config_name)
|
|
return res
|
|
|
|
def running(self):
|
|
"""Check whether the event loop is running"""
|
|
return self._running
|
|
|
|
def stop(self):
|
|
"""Stop the event loop"""
|
|
self._running = False
|
|
|
|
def run(self):
|
|
"""Start the event loop"""
|
|
self._output.start()
|
|
while self.running():
|
|
self._output.begin()
|
|
for module in self._modules:
|
|
module.update(module.widgets())
|
|
for widget in module.widgets():
|
|
widget.set_module(module)
|
|
self._output.draw(widget=widget, engine=self)
|
|
self._output.flush()
|
|
self._output.end()
|
|
if self.running():
|
|
time.sleep(1)
|
|
|
|
self._output.stop()
|
|
|
|
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|