← 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/memoryinfo.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/memoryinfo.py
 
1
import time
 
2
 
 
3
from landscape.lib.monitor import CoverageMonitor
 
4
from landscape.lib.sysstats import MemoryStats
 
5
 
 
6
from landscape.accumulate import Accumulator
 
7
from landscape.monitor.monitor import MonitorPlugin
 
8
 
 
9
 
 
10
class MemoryInfo(MonitorPlugin):
 
11
    """Plugin captures information about free memory and free swap."""
 
12
 
 
13
    persist_name = "memory-info"
 
14
    # Prevent the Plugin base-class from scheduling looping calls.
 
15
    run_interval = None
 
16
 
 
17
    def __init__(self, interval=15, monitor_interval=60*60,
 
18
                 source_filename="/proc/meminfo", create_time=time.time):
 
19
        self._interval = interval
 
20
        self._monitor_interval = monitor_interval
 
21
        self._source_filename = source_filename
 
22
        self._memory_info = []
 
23
        self._create_time = create_time
 
24
 
 
25
    def register(self, registry):
 
26
        super(MemoryInfo, self).register(registry)
 
27
        self._accumulate = Accumulator(self._persist, self.registry.step_size)
 
28
        self.registry.reactor.call_every(self._interval, self.run)
 
29
        self._monitor = CoverageMonitor(self._interval, 0.8,
 
30
                                        "memory/swap snapshot",
 
31
                                        create_time=self._create_time)
 
32
        self.registry.reactor.call_every(self._monitor_interval,
 
33
                                         self._monitor.log)
 
34
        self.registry.reactor.call_on("stop", self._monitor.log, priority=2000)
 
35
        self.call_on_accepted("memory-info", self.send_message, True)
 
36
 
 
37
    def create_message(self):
 
38
        memory_info = self._memory_info
 
39
        self._memory_info = []
 
40
        return {"type": "memory-info", "memory-info": memory_info}
 
41
 
 
42
    def send_message(self, urgent=False):
 
43
        message = self.create_message()
 
44
        if len(message["memory-info"]):
 
45
            self.registry.broker.send_message(message, urgent=urgent)
 
46
 
 
47
    def exchange(self, urgent=False):
 
48
        self.registry.broker.call_if_accepted("memory-info",
 
49
                                              self.send_message, urgent)
 
50
 
 
51
    def run(self):
 
52
        self._monitor.ping()
 
53
        new_timestamp = int(self._create_time())
 
54
        memstats = MemoryStats(self._source_filename)
 
55
        memory_step_data = self._accumulate(new_timestamp, memstats.free_memory,
 
56
                                            "accumulate-memory")
 
57
        swap_step_data = self._accumulate(new_timestamp, memstats.free_swap,
 
58
                                          "accumulate-swap")
 
59
 
 
60
        if memory_step_data and swap_step_data:
 
61
            timestamp = memory_step_data[0]
 
62
            free_memory = int(memory_step_data[1])
 
63
            free_swap = int(swap_step_data[1])
 
64
            self._memory_info.append((timestamp, free_memory, free_swap))