← 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/temperature.py

  • Committer: Bazaar Package Importer
  • Author(s): Rick Clark
  • Date: 2008-09-08 16:35:57 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20080908163557-l3ixzj5dxz37wnw2
Tags: 1.0.18-0ubuntu1
New upstream release 

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/monitor/temperature.py
 
1
import time
 
2
 
 
3
from landscape.lib.monitor import CoverageMonitor
 
4
from landscape.lib.sysstats import get_thermal_zones
 
5
 
 
6
from landscape.accumulate import Accumulator
 
7
from landscape.monitor.monitor import MonitorPlugin
 
8
 
 
9
 
 
10
class Temperature(MonitorPlugin):
 
11
    """Capture thermal zone temperatures and trip point settings."""
 
12
 
 
13
    persist_name = "temperature"
 
14
    # Prevent the Plugin base-class from scheduling looping calls.
 
15
    run_interval = None
 
16
 
 
17
    def __init__(self, interval=30, monitor_interval=60*60,
 
18
                 thermal_zone_path=None, create_time=time.time):
 
19
        self.thermal_zone_path = thermal_zone_path
 
20
        self._interval = interval
 
21
        self._monitor_interval = monitor_interval
 
22
        self._create_time = create_time
 
23
        self._thermal_zones = []
 
24
        self._temperatures = {}
 
25
 
 
26
        for thermal_zone in get_thermal_zones(self.thermal_zone_path):
 
27
            self._thermal_zones.append(thermal_zone.name)
 
28
            self._temperatures[thermal_zone.name] = []
 
29
 
 
30
    def register(self, registry):
 
31
        super(Temperature, self).register(registry)
 
32
        if self._thermal_zones:
 
33
            self.registry = registry
 
34
            self._accumulate = Accumulator(self._persist,
 
35
                                           self.registry.step_size)
 
36
 
 
37
            registry.reactor.call_every(self._interval, self.run)
 
38
 
 
39
            self._monitor = CoverageMonitor(self._interval, 0.8,
 
40
                                            "temperature snapshot",
 
41
                                            create_time=self._create_time)
 
42
            registry.reactor.call_every(self._monitor_interval,
 
43
                                        self._monitor.log)
 
44
            registry.reactor.call_on("stop", self._monitor.log, priority=2000)
 
45
            self.call_on_accepted("temperature", self.exchange, True)
 
46
 
 
47
    def create_messages(self):
 
48
        messages = []
 
49
        for zone in self._thermal_zones:
 
50
            temperatures = self._temperatures[zone]
 
51
            self._temperatures[zone] = []
 
52
            if not temperatures:
 
53
                continue
 
54
            messages.append({"type": "temperature", "thermal-zone": zone,
 
55
                             "temperatures": temperatures})
 
56
        return messages
 
57
 
 
58
    def send_messages(self, urgent):
 
59
        for message in self.create_messages():
 
60
            self.registry.broker.send_message(message, urgent=urgent)
 
61
 
 
62
    def exchange(self, urgent=False):
 
63
        self.registry.broker.call_if_accepted("temperature",
 
64
                                              self.send_messages, urgent)
 
65
 
 
66
    def run(self):
 
67
        self._monitor.ping()
 
68
        now = int(self._create_time())
 
69
        for zone in get_thermal_zones(self.thermal_zone_path):
 
70
            if zone.temperature_value is not None:
 
71
                key = ("accumulate", zone.name)
 
72
                step_data = self._accumulate(now, zone.temperature_value, key)
 
73
                if step_data:
 
74
                    self._temperatures[zone.name].append(step_data)