systemd-python: cleanup up usec_t handling

[elogind.git] / src / python-systemd / journal.py

diff --git a/src/python-systemd/journal.py b/src/python-systemd/journal.py
index 4d71564c65b8f3444799f1513cd2565b3865cb7b..a522aecc701c9a7c14c1003b0110935424312688 100644 (file)
--- a/src/python-systemd/journal.py
+++ b/src/python-systemd/journal.py
@@ -19,29 +19,53 @@
 #  You should have received a copy of the GNU Lesser General Public License
 #  along with systemd; If not, see <http://www.gnu.org/licenses/>.
 
 #  You should have received a copy of the GNU Lesser General Public License
 #  along with systemd; If not, see <http://www.gnu.org/licenses/>.
 

+from __future__ import division
+

 import sys as _sys
 import datetime as _datetime
 import functools as _functools
 import uuid as _uuid
 import traceback as _traceback
 import os as _os
 import sys as _sys
 import datetime as _datetime
 import functools as _functools
 import uuid as _uuid
 import traceback as _traceback
 import os as _os

-from os import SEEK_SET, SEEK_CUR, SEEK_END

 import logging as _logging
 if _sys.version_info >= (3,):
     from collections import ChainMap as _ChainMap
 from syslog import (LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR,
                     LOG_WARNING, LOG_NOTICE, LOG_INFO, LOG_DEBUG)
 from ._journal import sendv, stream_fd
 import logging as _logging
 if _sys.version_info >= (3,):
     from collections import ChainMap as _ChainMap
 from syslog import (LOG_EMERG, LOG_ALERT, LOG_CRIT, LOG_ERR,
                     LOG_WARNING, LOG_NOTICE, LOG_INFO, LOG_DEBUG)
 from ._journal import sendv, stream_fd

-from ._reader import (_Journal, NOP, APPEND, INVALIDATE,
-                      LOCAL_ONLY, RUNTIME_ONLY, SYSTEM_ONLY)
+from ._reader import (_Reader, NOP, APPEND, INVALIDATE,
+                      LOCAL_ONLY, RUNTIME_ONLY, SYSTEM_ONLY,
+                      get_catalog)

 from . import id128 as _id128
 
 from . import id128 as _id128
 

-_MONOTONIC_CONVERTER = lambda x: _datetime.timedelta(microseconds=float(x))
-_REALTIME_CONVERTER = lambda x: _datetime.datetime.fromtimestamp(float(x)/1E6)
+if _sys.version_info >= (3,):
+    from ._reader import Monotonic
+else:
+    Monotonic = tuple
+
+def _convert_monotonic(m):
+    return Monotonic((_datetime.timedelta(microseconds=m[0]),
+                      _uuid.UUID(bytes=m[1])))
+
+def _convert_source_monotonic(s):
+    return _datetime.timedelta(microseconds=int(s))
+
+def _convert_realtime(t):
+    return _datetime.datetime.fromtimestamp(t / 1000000)
+
+def _convert_timestamp(s):
+    return _datetime.datetime.fromtimestamp(int(s) / 1000000)
+
+if _sys.version_info >= (3,):
+    def _convert_uuid(s):
+        return _uuid.UUID(s.decode())
+else:
+    _convert_uuid = _uuid.UUID
+

 DEFAULT_CONVERTERS = {
 DEFAULT_CONVERTERS = {

-    'MESSAGE_ID': _uuid.UUID,
-    '_MACHINE_ID': _uuid.UUID,
-    '_BOOT_ID': _uuid.UUID,
+    'MESSAGE_ID': _convert_uuid,
+    '_MACHINE_ID': _convert_uuid,
+    '_BOOT_ID': _convert_uuid,

     'PRIORITY': int,
     'LEADER': int,
     'SESSION_ID': int,
     'PRIORITY': int,
     'LEADER': int,
     'SESSION_ID': int,


@@ -60,57 +84,61 @@ DEFAULT_CONVERTERS = {
     'CODE_LINE': int,
     'ERRNO': int,
     'EXIT_STATUS': int,
     'CODE_LINE': int,
     'ERRNO': int,
     'EXIT_STATUS': int,

-    '_SOURCE_REALTIME_TIMESTAMP': _REALTIME_CONVERTER,
-    '__REALTIME_TIMESTAMP': _REALTIME_CONVERTER,
-    '_SOURCE_MONOTONIC_TIMESTAMP': _MONOTONIC_CONVERTER,
-    '__MONOTONIC_TIMESTAMP': _MONOTONIC_CONVERTER,
+    '_SOURCE_REALTIME_TIMESTAMP': _convert_timestamp,
+    '__REALTIME_TIMESTAMP': _convert_realtime,
+    '_SOURCE_MONOTONIC_TIMESTAMP': _convert_source_monotonic,
+    '__MONOTONIC_TIMESTAMP': _convert_monotonic,

     'COREDUMP': bytes,
     'COREDUMP_PID': int,
     'COREDUMP_UID': int,
     'COREDUMP_GID': int,
     'COREDUMP_SESSION': int,
     'COREDUMP_SIGNAL': int,
     'COREDUMP': bytes,
     'COREDUMP_PID': int,
     'COREDUMP_UID': int,
     'COREDUMP_GID': int,
     'COREDUMP_SESSION': int,
     'COREDUMP_SIGNAL': int,

-    'COREDUMP_TIMESTAMP': _REALTIME_CONVERTER,
+    'COREDUMP_TIMESTAMP': _convert_timestamp,

 }
 
 }
 

-if _sys.version_info >= (3,):
-    _convert_unicode = _functools.partial(str, encoding='utf-8')
-else:
-    _convert_unicode = _functools.partial(unicode, encoding='utf-8')
-
-class Journal(_Journal):
-    """Journal allows the access and filtering of systemd journal
+class Reader(_Reader):
+    """Reader allows the access and filtering of systemd journal

     entries. Note that in order to access the system journal, a
     entries. Note that in order to access the system journal, a

-    non-root user must be in the `adm` group.
+    non-root user must be in the `systemd-journal` group.

 
 

-    Example usage to print out all error or higher level messages
-    for systemd-udevd for the boot:
+    Example usage to print out all informational or higher level
+    messages for systemd-udevd for this boot:

 
 

-    >>> myjournal = journal.Journal()
-    >>> myjournal.add_boot_match(journal.CURRENT_BOOT)
-    >>> myjournal.add_loglevel_matches(journal.LOG_ERR)
-    >>> myjournal.add_match(_SYSTEMD_UNIT="systemd-udevd.service")
-    >>> for entry in myjournal:
+    >>> j = journal.Reader()
+    >>> j.this_boot()
+    >>> j.log_level(journal.LOG_INFO)
+    >>> j.add_match(_SYSTEMD_UNIT="systemd-udevd.service")
+    >>> for entry in j:

     ...    print(entry['MESSAGE'])
 
     See systemd.journal-fields(7) for more info on typical fields
     found in the journal.
     """
     ...    print(entry['MESSAGE'])
 
     See systemd.journal-fields(7) for more info on typical fields
     found in the journal.
     """

-    def __init__(self, converters=None, flags=LOCAL_ONLY, path=None):
-        """Creates instance of Journal, which allows filtering and
+    def __init__(self, flags=0, path=None, converters=None):
+        """Create an instance of Reader, which allows filtering and

         return of journal entries.
         return of journal entries.

-        Argument `converters` is a dictionary which updates the
-        DEFAULT_CONVERTERS to convert journal field values.
+

         Argument `flags` sets open flags of the journal, which can be one
         of, or ORed combination of constants: LOCAL_ONLY (default) opens
         journal on local machine only; RUNTIME_ONLY opens only
         volatile journal files; and SYSTEM_ONLY opens only
         journal files of system services and the kernel.
         Argument `flags` sets open flags of the journal, which can be one
         of, or ORed combination of constants: LOCAL_ONLY (default) opens
         journal on local machine only; RUNTIME_ONLY opens only
         volatile journal files; and SYSTEM_ONLY opens only
         journal files of system services and the kernel.

+

         Argument `path` is the directory of journal files. Note that
         Argument `path` is the directory of journal files. Note that

-        currently flags are ignored when `path` is present as they are
-        currently not relevant.
+        `flags` and `path` are exclusive.
+
+        Argument `converters` is a dictionary which updates the
+        DEFAULT_CONVERTERS to convert journal field values. Field
+        names are used as keys into this dictionary. The values must
+        be single argument functions, which take a `bytes` object and
+        return a converted value. When there's no entry for a field
+        name, then the default UTF-8 decoding will be attempted. If
+        the conversion fails with a ValueError, unconverted bytes
+        object will be returned. (Note that ValueEror is a superclass
+        of UnicodeDecodeError).

         """
         """

-        super(Journal, self).__init__(flags, path)
+        super(Reader, self).__init__(flags, path)

         if _sys.version_info >= (3,3):
             self.converters = _ChainMap()
             if converters is not None:
         if _sys.version_info >= (3,3):
             self.converters = _ChainMap()
             if converters is not None:


@@ -122,18 +150,19 @@ class Journal(_Journal):
                 self.converters.update(converters)
 
     def _convert_field(self, key, value):
                 self.converters.update(converters)
 
     def _convert_field(self, key, value):

-        """Convert value based on callable from self.converters
-        based of field/key"""
+        """Convert value using self.converters[key]
+
+        If `key` is not present in self.converters, a standard unicode
+        decoding will be attempted.  If the conversion (either
+        key-specific or the default one) fails with a ValueError, the
+        original bytes object will be returned.
+        """
+        convert = self.converters.get(key, bytes.decode)

         try:
         try:

-            result = self.converters[key](value)
-        except:
-            # Default conversion in unicode
-            try:
-                result = _convert_unicode(value)
-            except UnicodeDecodeError:
-                # Leave in default bytes
-                result = value
-        return result
+            return convert(value)
+        except ValueError:
+            # Leave in default bytes
+            return value

 
     def _convert_entry(self, entry):
         """Convert entire journal entry utilising _covert_field"""
 
     def _convert_entry(self, entry):
         """Convert entire journal entry utilising _covert_field"""


@@ -156,7 +185,7 @@ class Journal(_Journal):
         args = list(args)
         args.extend(_make_line(key, val) for key, val in kwargs.items())
         for arg in args:
         args = list(args)
         args.extend(_make_line(key, val) for key, val in kwargs.items())
         for arg in args:

-            super(Journal, self).add_match(arg)
+            super(Reader, self).add_match(arg)

 
     def get_next(self, skip=1):
         """Return the next log entry as a dictionary of fields.
 
     def get_next(self, skip=1):
         """Return the next log entry as a dictionary of fields.


@@ -164,21 +193,32 @@ class Journal(_Journal):
         Optional skip value will return the `skip`\-th log entry.
 
         Entries will be processed with converters specified during
         Optional skip value will return the `skip`\-th log entry.
 
         Entries will be processed with converters specified during

-        Journal creation.
+        Reader creation.

         """
         return self._convert_entry(
         """
         return self._convert_entry(

-            super(Journal, self).get_next(skip))
+            super(Reader, self).get_next(skip))

 
     def query_unique(self, field):
 
     def query_unique(self, field):

-        """Return unique values appearing in the Journal for given `field`.
+        """Return unique values appearing in the journal for given `field`.

 
         Note this does not respect any journal matches.
 
         Entries will be processed with converters specified during
 
         Note this does not respect any journal matches.
 
         Entries will be processed with converters specified during

-        Journal creation.
+        Reader creation.

         """
         return set(self._convert_field(field, value)
         """
         return set(self._convert_field(field, value)

-            for value in super(Journal, self).query_unique(field))
+            for value in super(Reader, self).query_unique(field))
+
+    def wait(self, timeout=None):
+        """Wait for a change in the journal. `timeout` is the maximum
+        time in seconds to wait, or None, to wait forever.
+
+        Returns one of NOP (no change), APPEND (new entries have been
+        added to the end of the journal), or INVALIDATE (journal files
+        have been added or removed).
+        """
+        us = -1 if timeout is None else int(timeout * 1000000)
+        return super(Reader, self).wait(timeout)

 
     def seek_realtime(self, realtime):
         """Seek to a matching journal entry nearest to `realtime` time.
 
     def seek_realtime(self, realtime):
         """Seek to a matching journal entry nearest to `realtime` time.


@@ -187,8 +227,8 @@ class Journal(_Journal):
         or datetime.datetime instance.
         """
         if isinstance(realtime, _datetime.datetime):
         or datetime.datetime instance.
         """
         if isinstance(realtime, _datetime.datetime):

-            realtime = float(realtime.strftime("%s.%f"))
-        return super(Journal, self).seek_realtime(realtime)
+            realtime = float(realtime.strftime("%s.%f")) * 1000000
+        return super(Reader, self).seek_realtime(int(realtime))

 
     def seek_monotonic(self, monotonic, bootid=None):
         """Seek to a matching journal entry nearest to `monotonic` time.
 
     def seek_monotonic(self, monotonic, bootid=None):
         """Seek to a matching journal entry nearest to `monotonic` time.


@@ -200,16 +240,17 @@ class Journal(_Journal):
         """
         if isinstance(monotonic, _datetime.timedelta):
             monotonic = monotonic.totalseconds()
         """
         if isinstance(monotonic, _datetime.timedelta):
             monotonic = monotonic.totalseconds()

+        monotonic = int(monotonic * 1000000)

         if isinstance(bootid, _uuid.UUID):
             bootid = bootid.get_hex()
         if isinstance(bootid, _uuid.UUID):
             bootid = bootid.get_hex()

-        return super(Journal, self).seek_monotonic(monotonic, bootid)
+        return super(Reader, self).seek_monotonic(monotonic, bootid)

 
     def log_level(self, level):
         """Set maximum log `level` by setting matches for PRIORITY.
         """
         if 0 <= level <= 7:
             for i in range(level+1):
 
     def log_level(self, level):
         """Set maximum log `level` by setting matches for PRIORITY.
         """
         if 0 <= level <= 7:
             for i in range(level+1):

-                self.add_match(PRIORITY="%s" % i)
+                self.add_match(PRIORITY="%d" % i)

         else:
             raise ValueError("Log level must be 0 <= level <= 7")
 
         else:
             raise ValueError("Log level must be 0 <= level <= 7")