Logo Search packages:      
Sourcecode: landscape-client version File versions


import time
from datetime import datetime
import os
import struct

from landscape.lib.timestamp import to_timestamp
from landscape.monitor.monitor import MonitorPlugin

def get_uptime(uptime_file=u"/proc/uptime"):
    This parses a file in /proc/uptime format and returns a floating point
    version of the first value (the actual uptime).
    data = file(uptime_file, "r").readline()
    up, idle = data.split()
    return float(up)

00020 class LoginInfo(object):
    """Information about a login session gathered from wtmp or utmp."""

    # FIXME This format string works fine on my hardware, but *may* be
    # different depending on the values of __WORDSIZE and
    # __WORDSIZE_COMPAT32 defined in /usr/include/bits/utmp.h:68 (in
    # the definition of struct utmp).  Make sure it works
    # everywhere.   -jk
    RAW_FORMAT = "hi32s4s32s256shhiiiiiii20s"

    def __init__(self, raw_data):
        info = struct.unpack(self.RAW_FORMAT, raw_data)
        self.login_type = info[0]
        self.pid = info[1]
        self.tty_device = info[2].strip("\0")
        self.id = info[3].strip("\0")
        self.username = info[4].strip("\0")
        self.hostname = info[5].strip("\0")
        self.termination_status = info[6]
        self.exit_status = info[7]
        self.session_id = info[8]
        self.entry_time = datetime.utcfromtimestamp(info[9])
        # FIXME Convert this to a dotted decimal string. -jk
        self.remote_ip_address = info[11]

00046 class LoginInfoReader(object):
    """Reader parses C{/var/log/wtmp} and/or C{/var/run/utmp} files."""

00049     def __init__(self, file):
        """Initialize the reader with an open file."""
        self._file = file
        self._struct_length = struct.calcsize(LoginInfo.RAW_FORMAT)

00054     def login_info(self):
        """Returns a generator that yields LoginInfo objects."""
        while True:
            info = self.read_next()

            if not info:

            yield info

00064     def read_next(self):
        """Returns login data or None if no login data is available."""
        data = self._file.read(self._struct_length)

        if data and len(data) == self._struct_length:
            return LoginInfo(data)

        return None

class BootTimes(object):
    _last_boot = None
    _last_shutdown = None

    def __init__(self, filename="/var/log/wtmp",
                 boots_newer_than=0, shutdowns_newer_than=0):
        self._filename = filename
        self._boots_newer_than = boots_newer_than
        self._shutdowns_newer_than = shutdowns_newer_than

    def get_times(self):
        reboot_times = []
        shutdown_times = []
        reader = LoginInfoReader(file(self._filename))
        self._last_boot = self._boots_newer_than
        self._last_shutdown = self._shutdowns_newer_than

        for info in reader.login_info():
            if info.tty_device.startswith("~"):
                timestamp = to_timestamp(info.entry_time)
                if (info.username == "reboot"
                    and timestamp > self._last_boot):
                    self._last_boot = timestamp
                elif (info.username == "shutdown"
                      and timestamp > self._last_shutdown):
                    self._last_shutdown = timestamp
        return reboot_times, shutdown_times

    def get_last_boot_time(self):
        if self._last_boot is None:
            self._last_boot = int(time.time() - get_uptime())
        return self._last_boot

00110 class ComputerUptime(MonitorPlugin):
    """Plugin reports information about computer uptime."""

    persist_name = "computer-uptime"

00115     def __init__(self, wtmp_file="/var/log/wtmp"):
        """Initialize the plugin."""
        self._first_run = True
        self._wtmp_file = wtmp_file

00120     def register(self, registry):
        """Register this plugin with the specified plugin manager."""
        super(ComputerUptime, self).register(registry)
        registry.reactor.call_on("run", self.run)
        self.call_on_accepted("computer-uptime", self.run, True)

00126     def run(self, urgent=False):
        """Create a message and put it on the message queue.

        The last logrotated file, if it exists, will be checked the
        first time the plugin runs.  This behaviour ensures we don't
        accidentally miss a reboot/shutdown event if the machine is
        rebooted and wtmp is logrotated before the client starts.
        broker = self.registry.broker
        if self._first_run:
            self_first_run = False
            filename = self._wtmp_file + ".1"
            if os.path.isfile(filename):
                                        self.send_message, filename, urgent)

        if os.path.isfile(self._wtmp_file):
            broker.call_if_accepted("computer-uptime", self.send_message,
                                    self._wtmp_file, urgent)

    def send_message(self, filename, urgent=False):
        message = self._create_message(filename)
        if "shutdown-times" in message or "startup-times" in message:
            message["type"] = "computer-uptime"
            self.registry.broker.send_message(message, urgent=urgent)

00152     def _create_message(self, filename):
        """Generate a message with new startup and shutdown times."""
        message = {}
        startup_times = []
        shutdown_times = []

        last_startup_time = self._persist.get("last-startup-time", 0)
        last_shutdown_time = self._persist.get("last-shutdown-time", 0)

        times = BootTimes(filename,

        startup_times, shutdown_times = times.get_times()

        if startup_times:
            self._persist.set("last-startup-time", startup_times[-1])
            message["startup-times"] = startup_times

        if shutdown_times:
            self._persist.set("last-shutdown-time", shutdown_times[-1])
            message["shutdown-times"] = shutdown_times

        return message

Generated by  Doxygen 1.6.0   Back to index