from __future__ import division
+import datetime
import logging
import math
import os
import rrdtool
+import tempfile
import threading
import time
# the data from this data source.
templates = []
- # The schema of the RRD database.
- rrd_schema = None
-
- # RRA properties.
- rra_types = ["AVERAGE", "MIN", "MAX"]
- rra_timespans = [3600, 86400, 604800, 2678400, 31622400]
- rra_rows = 2880
-
- # The default interval of this plugin.
- default_interval = 60
+ # The default interval for all plugins
+ interval = 60
# Automatically register all providers.
class __metaclass__(type):
# Check if this plugin was configured correctly.
assert self.name, "Name of the plugin is not set: %s" % self.name
assert self.description, "Description of the plugin is not set: %s" % self.description
- assert self.rrd_schema
# Initialize the logger.
self.log = logging.getLogger("collecty.plugins.%s" % self.name)
# Run some custom initialization.
self.init(**kwargs)
- # Create the database file.
- self.create()
-
# Keepalive options
self.running = True
self.timer = Timer(self.interval)
- self.log.info(_("Successfully initialized (%s).") % self.id)
-
- def __repr__(self):
- return "<%s %s>" % (self.__class__.__name__, self.id)
+ self.log.info(_("Successfully initialized %s") % self.__class__.__name__)
@property
- def id(self):
+ def path(self):
"""
- A unique ID of the plugin instance.
+ Returns the name of the sub directory in which all RRD files
+ for this plugin should be stored in.
"""
return self.name
- @property
- def interval(self):
+ ### Basic methods
+
+ def init(self, **kwargs):
"""
- Returns the interval in milliseconds, when the read method
- should be called again.
+ Do some custom initialization stuff here.
"""
- # XXX read this from the settings
+ pass
+
+ def collect(self):
+ """
+ Gathers the statistical data, this plugin collects.
+ """
+ time_start = time.time()
+
+ # Run through all objects of this plugin and call the collect method.
+ for o in self.objects:
+ now = datetime.datetime.utcnow()
+ try:
+ result = o.collect()
+ except:
+ self.log.warning(_("Unhandled exception in %s.collect()") % o, exc_info=True)
+ continue
+
+ if not result:
+ self.log.warning(_("Received empty result: %s") % o)
+ continue
+
+ self.log.debug(_("Collected %s: %s") % (o, result))
+
+ # Add the object to the write queue so that the data is written
+ # to the databases later.
+ self.collecty.write_queue.add(o, now, result)
+
+ # Returns the time this function took to complete.
+ return (time.time() - time_start)
+
+ def run(self):
+ self.log.debug(_("%s plugin has started") % self.name)
+
+ # Initially collect everything
+ self.collect()
+
+ while self.running:
+ # Reset the timer.
+ self.timer.reset()
+
+ # Wait until the timer has successfully elapsed.
+ if self.timer.wait():
+ delay = self.collect()
+ self.timer.reset(delay)
+
+ self.log.debug(_("%s plugin has stopped") % self.name)
+
+ def shutdown(self):
+ self.log.debug(_("Received shutdown signal."))
+ self.running = False
- # Otherwise return the default.
- return self.default_interval
+ # Kill any running timers.
+ if self.timer:
+ self.timer.cancel()
+
+ def get_object(self, id):
+ for object in self.objects:
+ if not object.id == id:
+ continue
+
+ return object
+
+ def get_template(self, template_name):
+ for template in self.templates:
+ if not template.name == template_name:
+ continue
+
+ return template(self)
+
+ def generate_graph(self, template_name, object_id="default", **kwargs):
+ template = self.get_template(template_name)
+ if not template:
+ raise RuntimeError("Could not find template %s" % template_name)
+
+ time_start = time.time()
+
+ graph = template.generate_graph(object_id=object_id, **kwargs)
+
+ duration = time.time() - time_start
+ self.log.info(_("Generated graph %s in %.1fms") \
+ % (template, duration * 1000))
+
+ return graph
+
+
+class Object(object):
+ # The schema of the RRD database.
+ rrd_schema = None
+
+ # RRA properties.
+ rra_types = ["AVERAGE", "MIN", "MAX"]
+ rra_timespans = [3600, 86400, 604800, 2678400, 31622400]
+ rra_rows = 2880
+
+ def __init__(self, plugin, *args, **kwargs):
+ self.plugin = plugin
+
+ # Indicates if this object has collected its data
+ self.collected = False
+
+ # Initialise this object
+ self.init(*args, **kwargs)
+
+ # Create the database file.
+ self.create()
+
+ def __repr__(self):
+ return "<%s>" % self.__class__.__name__
@property
- def stepsize(self):
- return self.interval
+ def collecty(self):
+ return self.plugin.collecty
@property
- def heartbeat(self):
- return self.stepsize * 2
+ def log(self):
+ return self.plugin.log
+
+ @property
+ def id(self):
+ """
+ Returns a UNIQUE identifier for this object. As this is incorporated
+ into the path of RRD file, it must only contain ASCII characters.
+ """
+ raise NotImplementedError
@property
def file(self):
"""
The absolute path to the RRD file of this plugin.
"""
- return os.path.join(DATABASE_DIR, "%s.rrd" % self.id)
+ return os.path.join(DATABASE_DIR, self.plugin.path, "%s.rrd" % self.id)
+
+ ### Basic methods
+
+ def init(self, *args, **kwargs):
+ """
+ Do some custom initialization stuff here.
+ """
+ pass
def create(self):
"""
for arg in args:
self.log.debug(" %s" % arg)
+ def info(self):
+ return rrdtool.info(self.file)
+
+ @property
+ def stepsize(self):
+ return self.plugin.interval
+
+ @property
+ def heartbeat(self):
+ return self.stepsize * 2
+
def get_rrd_schema(self):
schema = [
"--step", "%s" % self.stepsize,
return schema
- def info(self):
- return rrdtool.info(self.file)
+ def execute(self):
+ if self.collected:
+ raise RuntimeError("This object has already collected its data")
- ### Basic methods
+ self.collected = True
+ self.now = datetime.datetime.utcnow()
- def init(self, **kwargs):
- """
- Do some custom initialization stuff here.
- """
- pass
+ # Call the collect
+ result = self.collect()
- def read(self):
+ def commit(self):
"""
- Gathers the statistical data, this plugin collects.
+ Will commit the collected data to the database.
"""
- raise NotImplementedError
-
- def submit(self):
- """
- Flushes the read data to disk.
- """
- # Do nothing in case there is no data to submit.
- if not self.data:
- return
-
- self.log.debug(_("Submitting data to database. %d entries.") % len(self.data))
- for data in self.data:
- self.log.debug(" %s" % data)
-
- # Create the RRD files (if they don't exist yet or
- # have vanished for some reason).
+ # Make sure that the RRD database has been created
self.create()
- rrdtool.update(self.file, *self.data)
- self.data = []
- def _read(self, *args, **kwargs):
- """
- This method catches errors from the read() method and logs them.
- """
- start_time = time.time()
+class GraphTemplate(object):
+ # A unique name to identify this graph template.
+ name = None
- try:
- data = self.read(*args, **kwargs)
- if data is None:
- self.log.warning(_("Received empty data."))
- else:
- self.data.append("%d:%s" % (start_time, data))
+ # Instructions how to create the graph.
+ rrd_graph = None
- # Catch any exceptions, so collecty does not crash.
- except Exception, e:
- self.log.critical(_("Unhandled exception in read()!"), exc_info=True)
+ # Extra arguments passed to rrdgraph.
+ rrd_graph_args = []
- # Return the elapsed time since _read() has been called.
- return (time.time() - start_time)
+ intervals = {
+ None : "-3h",
+ "hour" : "-1h",
+ "day" : "-25h",
+ "week" : "-360h",
+ "year" : "-365d",
+ }
- def _submit(self, *args, **kwargs):
- """
- This method catches errors from the submit() method and logs them.
- """
- try:
- return self.submit(*args, **kwargs)
+ # Default dimensions for this graph
+ height = GRAPH_DEFAULT_HEIGHT
+ width = GRAPH_DEFAULT_WIDTH
- # Catch any exceptions, so collecty does not crash.
- except Exception, e:
- self.log.critical(_("Unhandled exception in submit()!"), exc_info=True)
+ def __init__(self, plugin):
+ self.plugin = plugin
- def run(self):
- self.log.debug(_("Started."))
+ def __repr__(self):
+ return "<%s>" % self.__class__.__name__
- while self.running:
- # Reset the timer.
- self.timer.reset()
+ @property
+ def collecty(self):
+ return self.plugin.collecty
- # Wait until the timer has successfully elapsed.
- if self.timer.wait():
- self.log.debug(_("Collecting..."))
- delay = self._read()
+ @property
+ def log(self):
+ return self.plugin.log
- self.timer.reset(delay)
+ def _make_command_line(self, interval, format=DEFAULT_IMAGE_FORMAT,
+ width=None, height=None):
+ args = []
- self._submit()
- self.log.debug(_("Stopped."))
+ args += GRAPH_DEFAULT_ARGUMENTS
- def shutdown(self):
- self.log.debug(_("Received shutdown signal."))
- self.running = False
+ args += [
+ "--imgformat", format,
+ "--height", "%s" % (height or self.height),
+ "--width", "%s" % (width or self.width),
+ ]
- # Kill any running timers.
- if self.timer:
- self.timer.cancel()
+ args += self.rrd_graph_args
+ # Add interval
+ args.append("--start")
-class GraphTemplate(object):
- # A unique name to identify this graph template.
- name = None
+ try:
+ args.append(self.intervals[interval])
+ except KeyError:
+ args.append(str(interval))
- # Instructions how to create the graph.
- rrd_graph = None
+ return args
- # Extra arguments passed to rrdgraph.
- rrd_graph_args = []
+ def get_object_table(self, object_id):
+ return {
+ "file" : self.plugin.get_object(object_id),
+ }
- def __init__(self, ds):
- self.ds = ds
+ def get_object_files(self, object_id):
+ files = {}
- @property
- def collecty(self):
- return self.ds.collecty
+ for id, obj in self.get_object_table(object_id).items():
+ files[id] = obj.file
- def graph(self, file, interval=None,
- width=GRAPH_DEFAULT_WIDTH, height=GRAPH_DEFAULT_HEIGHT):
- args = [
- "--width", "%d" % width,
- "--height", "%d" % height,
- ]
- args += self.collecty.graph_default_arguments
- args += self.rrd_graph_args
+ return files
- intervals = {
- None : "-3h",
- "hour" : "-1h",
- "day" : "-25h",
- "week" : "-360h",
- "year" : "-365d",
- }
+ def generate_graph(self, object_id, interval=None, **kwargs):
+ args = self._make_command_line(interval, **kwargs)
- args.append("--start")
- try:
- args.append(intervals[interval])
- except KeyError:
- args.append(interval)
+ self.log.info(_("Generating graph %s") % self)
+ self.log.debug(" args: %s" % args)
+
+ object_files = self.get_object_files(object_id)
- info = { "file" : self.ds.file }
for item in self.rrd_graph:
try:
- args.append(item % info)
+ args.append(item % object_files)
except TypeError:
args.append(item)
- rrdtool.graph(file, *args)
+ return self.write_graph(*args)
+
+ def write_graph(self, *args):
+ # Convert all arguments to string
+ args = [str(e) for e in args]
+
+ with tempfile.NamedTemporaryFile() as f:
+ rrdtool.graph(f.name, *args)
+
+ # Get back to the beginning of the file
+ f.seek(0)
+
+ # Return all the content
+ return f.read()
projects / collecty.git / blobdiff