← Back to branch summary

~ahasenack/landscape-client/landscape-client-1.5.5-0ubuntu0.9.04.0

« back to all changes in this revision

Viewing changes to landscape/monitor/loadaverage.py

  • Committer: Bazaar Package Importer
  • Author(s): Rick Clark
  • Date: 2008-09-08 16:35:57 UTC
  • mto: This revision was merged to the branch mainline in revision 2.
  • Revision ID: james.westby@ubuntu.com-20080908163557-fl0d2oc35hur473w
Tags: upstream-1.0.18
Import upstream version 1.0.18

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/monitor/loadaverage.py
 
1
import os
 
2
import time
 
3
 
 
4
from landscape.accumulate import Accumulator
 
5
from landscape.lib.monitor import CoverageMonitor
 
6
from landscape.monitor.monitor import MonitorPlugin
 
7
 
 
8
 
 
9
class LoadAverage(MonitorPlugin):
 
10
    """Plugin captures information about load average."""
 
11
 
 
12
    persist_name = "load-average"
 
13
    # Prevent the Plugin base-class from scheduling looping calls.
 
14
    run_interval = None
 
15
 
 
16
    def __init__(self, interval=15, monitor_interval=60*60,
 
17
                 create_time=time.time, get_load_average=os.getloadavg):
 
18
        self._interval = interval
 
19
        self._monitor_interval = monitor_interval
 
20
        self._create_time = create_time
 
21
        self._load_averages = []
 
22
        self._get_load_average = get_load_average
 
23
 
 
24
    def register(self, registry):
 
25
        super(LoadAverage, self).register(registry)
 
26
        self._accumulate = Accumulator(self._persist, registry.step_size)
 
27
 
 
28
        self.registry.reactor.call_every(self._interval, self.run)
 
29
 
 
30
        self._monitor = CoverageMonitor(self._interval, 0.8,
 
31
                                        "load average snapshot",
 
32
                                        create_time=self._create_time)
 
33
        self.registry.reactor.call_every(self._monitor_interval,
 
34
                                         self._monitor.log)
 
35
        self.registry.reactor.call_on("stop", self._monitor.log, priority=2000)
 
36
        self.call_on_accepted("load-average", self.send_message, True)
 
37
 
 
38
    def create_message(self):
 
39
        load_averages = self._load_averages
 
40
        self._load_averages = []
 
41
        return {"type": "load-average", "load-averages": load_averages}
 
42
 
 
43
    def exchange(self, urgent=False):
 
44
        self.registry.broker.call_if_accepted("load-average",
 
45
                                              self.send_message, urgent)
 
46
 
 
47
    def send_message(self, urgent=False):
 
48
        message = self.create_message()
 
49
        if len(message["load-averages"]):
 
50
            self.registry.broker.send_message(message, urgent=urgent)
 
51
 
 
52
    def exchange(self):
 
53
        self.registry.broker.call_if_accepted("load-average", self.send_message)
 
54
 
 
55
    def run(self):
 
56
        self._monitor.ping()
 
57
        new_timestamp = int(self._create_time())
 
58
        new_load_average = self._get_load_average()[0]
 
59
        step_data = self._accumulate(new_timestamp, new_load_average,
 
60
                                     "accumulate")
 
61
        if step_data:
 
62
            self._load_averages.append(step_data)