diff options
Diffstat (limited to 'src/python-systemd')
| -rw-r--r-- | src/python-systemd/_reader.c | 1163 | ||||
| -rw-r--r-- | src/python-systemd/journal.py | 2 |
2 files changed, 1165 insertions, 0 deletions
diff --git a/src/python-systemd/_reader.c b/src/python-systemd/_reader.c new file mode 100644 index 0000000000..963da11dc6 --- /dev/null +++ b/src/python-systemd/_reader.c @@ -0,0 +1,1163 @@ +/* +_reader - Python module that reads systemd journal similar to journalctl +Copyright (C) 2012 Steven Hiscocks + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +*/ +#include <systemd/sd-journal.h> + +#include <Python.h> +#include <structmember.h> +#include <datetime.h> + +typedef struct { + PyObject_HEAD + sd_journal *j; + PyObject *default_call; + PyObject *call_dict; +} Journal; +static PyTypeObject JournalType; + +static void +Journal_dealloc(Journal* self) +{ + sd_journal_close(self->j); + Py_XDECREF(self->default_call); + Py_XDECREF(self->call_dict); + Py_TYPE(self)->tp_free((PyObject*)self); +} + +static PyObject * +Journal_new(PyTypeObject *type, PyObject *args, PyObject *kwds) +{ + Journal *self; + + self = (Journal *)type->tp_alloc(type, 0); + if (self != NULL) { + PyObject *globals, *temp; + + globals = PyEval_GetBuiltins(); + temp = PyImport_ImportModule("functools"); + PyDict_SetItemString(globals, "functools", temp); + Py_DECREF(temp); + temp = PyImport_ImportModule("datetime"); + PyDict_SetItemString(globals, "datetime", temp); + Py_DECREF(temp); + +#if PY_MAJOR_VERSION >=3 + self->default_call = PyRun_String("functools.partial(str, encoding='utf-8')", Py_eval_input, globals, NULL); +#else + self->default_call = PyRun_String("functools.partial(unicode, encoding='utf-8')", Py_eval_input, globals, NULL); +#endif + + self->call_dict = PyRun_String("{" + "'PRIORITY': int," + "'LEADER': int," + "'SESSION_ID': int," + "'USERSPACE_USEC': int," + "'INITRD_USEC': int," + "'KERNEL_USEC': int," + "'_UID': int," + "'_GID': int," + "'_PID': int," + "'SYSLOG_FACILITY': int," + "'SYSLOG_PID': int," + "'_AUDIT_SESSION': int," + "'_AUDIT_LOGINUID': int," + "'_SYSTEMD_SESSION': int," + "'_SYSTEMD_OWNER_UID': int," + "'CODE_LINE': int," + "'ERRNO': int," + "'EXIT_STATUS': int," + "'_SOURCE_REALTIME_TIMESTAMP': lambda x: datetime.datetime.fromtimestamp(float(x)/1E6)," + "'__REALTIME_TIMESTAMP': lambda x: datetime.datetime.fromtimestamp(float(x)/1E6)," + "'_SOURCE_MONOTONIC_TIMESTAMP': lambda x: datetime.timedelta(microseconds=float(x))," + "'__MONOTONIC_TIMESTAMP': lambda x: datetime.timedelta(microseconds=float(x))," +#if PY_MAJOR_VERSION >=3 + "'COREDUMP': bytes," +#else + "'COREDUMP': str," +#endif + "'COREDUMP_PID': int," + "'COREDUMP_UID': int," + "'COREDUMP_GID': int," + "'COREDUMP_SESSION': int," + "'COREDUMP_SIGNAL': int," + "'COREDUMP_TIMESTAMP': lambda x: datetime.datetime.fromtimestamp(float(x)/1E6)," + "}", Py_eval_input, globals, NULL); + } + + return (PyObject *) self; +} + +PyDoc_STRVAR(Journal__doc__, +"Journal([flags][, default_call][, call_dict][,path]) -> ...\n" +"Journal instance\n\n" +"Returns instance of Journal, which allows filtering and return\n" +"of journal entries.\n" +"Argument `flags` sets open flags of the journal, which can be one\n" +"of, or ORed combination of constants: LOCAL_ONLY (default) opens\n" +"journal on local machine only; RUNTIME_ONLY opens only\n" +"volatile journal files; and SYSTEM_ONLY opens only\n" +"journal files of system services and the kernel.\n" +"Argument `default_call` must be a callable that accepts one\n" +"argument which is string/bytes value of a field and returns\n" +"python object.\n" +"Argument `call_dict` is a dictionary where the key represents\n" +"a field name, and value is a callable as per `default_call`.\n" +"A set of sane defaults for `default_call` and `call_dict` are\n" +"present.\n" +"Argument `path` is the directory of journal files. Note that\n" +"currently flags are ignored when `path` is present as they are\n" +" not relevant."); +static int +Journal_init(Journal *self, PyObject *args, PyObject *keywds) +{ + int flags=SD_JOURNAL_LOCAL_ONLY; + char *path=NULL; + PyObject *default_call=NULL, *call_dict=NULL; + + static char *kwlist[] = {"flags", "default_call", "call_dict", "path", NULL}; + if (! PyArg_ParseTupleAndKeywords(args, keywds, "|iOOs", kwlist, + &flags, &default_call, &call_dict, &path)) + return 1; + + if (default_call) { + if (PyCallable_Check(default_call) || default_call == Py_None) { + Py_DECREF(self->default_call); + self->default_call = default_call; + Py_INCREF(self->default_call); + }else{ + PyErr_SetString(PyExc_TypeError, "Default call not callable"); + return 1; + } + } + + if (call_dict) { + if (PyDict_Check(call_dict)) { + Py_DECREF(self->call_dict); + self->call_dict = call_dict; + Py_INCREF(self->call_dict); + }else if (call_dict == Py_None) { + Py_DECREF(self->call_dict); + self->call_dict = PyDict_New(); + }else{ + PyErr_SetString(PyExc_TypeError, "Call dictionary must be dict type"); + return 1; + } + } + + int r; + if (path) { + r = sd_journal_open_directory(&self->j, path, 0); + }else{ + Py_BEGIN_ALLOW_THREADS + r = sd_journal_open(&self->j, flags); + Py_END_ALLOW_THREADS + } + if (r == -EINVAL) { + PyErr_SetString(PyExc_ValueError, "Invalid flags or path"); + return -1; + }else if (r == -ENOMEM) { + PyErr_SetString(PyExc_MemoryError, "Not enough memory"); + return 1; + }else if (r < 0) { + PyErr_SetString(PyExc_RuntimeError, "Error opening journal"); + return 1; + } + + return 0; +} + +static PyObject * +Journal___process_field(Journal *self, PyObject *key, const void *value, ssize_t value_len) +{ + PyObject *callable=NULL, *return_value=NULL; + if (PyDict_Check(self->call_dict)) + callable = PyDict_GetItem(self->call_dict, key); + + if (PyCallable_Check(callable)) { +#if PY_MAJOR_VERSION >=3 + return_value = PyObject_CallFunction(callable, "y#", value, value_len); +#else + return_value = PyObject_CallFunction(callable, "s#", value, value_len); +#endif + if (!return_value) + PyErr_Clear(); + } + if (!return_value && PyCallable_Check(self->default_call)) +#if PY_MAJOR_VERSION >=3 + return_value = PyObject_CallFunction(self->default_call, "y#", value, value_len); +#else + return_value = PyObject_CallFunction(self->default_call, "s#", value, value_len); +#endif + if (!return_value) { + PyErr_Clear(); +#if PY_MAJOR_VERSION >=3 + return_value = PyBytes_FromStringAndSize(value, value_len); +#else + return_value = PyString_FromStringAndSize(value, value_len); +#endif + } + if (!return_value) { + return_value = Py_None; + } + return return_value; +} + +PyDoc_STRVAR(Journal_get_next__doc__, +"get_next([skip]) -> dict\n\n" +"Return dictionary of the next log entry. Optional skip value will\n" +"return the `skip`th log entry."); +static PyObject * +Journal_get_next(Journal *self, PyObject *args) +{ + int64_t skip=1LL; + if (! PyArg_ParseTuple(args, "|L", &skip)) + return NULL; + + int r; + if (skip == 1LL) { + Py_BEGIN_ALLOW_THREADS + r = sd_journal_next(self->j); + Py_END_ALLOW_THREADS + }else if (skip == -1LL) { + Py_BEGIN_ALLOW_THREADS + r = sd_journal_previous(self->j); + Py_END_ALLOW_THREADS + }else if (skip > 1LL) { + Py_BEGIN_ALLOW_THREADS + r = sd_journal_next_skip(self->j, skip); + Py_END_ALLOW_THREADS + }else if (skip < -1LL) { + Py_BEGIN_ALLOW_THREADS + r = sd_journal_previous_skip(self->j, -skip); + Py_END_ALLOW_THREADS + }else{ + PyErr_SetString(PyExc_ValueError, "Skip number must positive/negative integer"); + return NULL; + } + + if (r < 0) { + PyErr_SetString(PyExc_RuntimeError, "Error getting next message"); + return NULL; + }else if ( r == 0) { //EOF + return PyDict_New(); + } + + PyObject *dict; + dict = PyDict_New(); + + const void *msg; + size_t msg_len; + const char *delim_ptr; + PyObject *key, *value, *cur_value, *tmp_list; + + SD_JOURNAL_FOREACH_DATA(self->j, msg, msg_len) { + delim_ptr = memchr(msg, '=', msg_len); +#if PY_MAJOR_VERSION >=3 + key = PyUnicode_FromStringAndSize(msg, delim_ptr - (const char*) msg); +#else + key = PyString_FromStringAndSize(msg, delim_ptr - (const char*) msg); +#endif + value = Journal___process_field(self, key, delim_ptr + 1, (const char*) msg + msg_len - (delim_ptr + 1) ); + if (PyDict_Contains(dict, key)) { + cur_value = PyDict_GetItem(dict, key); + if (PyList_CheckExact(cur_value) && PyList_Size(cur_value) > 1) { + PyList_Append(cur_value, value); + }else{ + tmp_list = PyList_New(0); + PyList_Append(tmp_list, cur_value); + PyList_Append(tmp_list, value); + PyDict_SetItem(dict, key, tmp_list); + Py_DECREF(tmp_list); + } + }else{ + PyDict_SetItem(dict, key, value); + } + Py_DECREF(key); + Py_DECREF(value); + } + + uint64_t realtime; + if (sd_journal_get_realtime_usec(self->j, &realtime) == 0) { + char realtime_str[20]; + sprintf(realtime_str, "%llu", (long long unsigned) realtime); + +#if PY_MAJOR_VERSION >=3 + key = PyUnicode_FromString("__REALTIME_TIMESTAMP"); +#else + key = PyString_FromString("__REALTIME_TIMESTAMP"); +#endif + value = Journal___process_field(self, key, realtime_str, strlen(realtime_str)); + PyDict_SetItem(dict, key, value); + Py_DECREF(key); + Py_DECREF(value); + } + + sd_id128_t sd_id; + uint64_t monotonic; + if (sd_journal_get_monotonic_usec(self->j, &monotonic, &sd_id) == 0) { + char monotonic_str[20]; + sprintf(monotonic_str, "%llu", (long long unsigned) monotonic); +#if PY_MAJOR_VERSION >=3 + key = PyUnicode_FromString("__MONOTONIC_TIMESTAMP"); +#else + key = PyString_FromString("__MONOTONIC_TIMESTAMP"); +#endif + value = Journal___process_field(self, key, monotonic_str, strlen(monotonic_str)); + + PyDict_SetItem(dict, key, value); + Py_DECREF(key); + Py_DECREF(value); + } + + char *cursor; + if (sd_journal_get_cursor(self->j, &cursor) > 0) { //Should return 0... +#if PY_MAJOR_VERSION >=3 + key = PyUnicode_FromString("__CURSOR"); +#else + key = PyString_FromString("__CURSOR"); +#endif + value = Journal___process_field(self, key, cursor, strlen(cursor)); + PyDict_SetItem(dict, key, value); + free(cursor); + Py_DECREF(key); + Py_DECREF(value); + } + + return dict; +} + +PyDoc_STRVAR(Journal_get_previous__doc__, +"get_previous([skip]) -> dict\n\n" +"Return dictionary of the previous log entry. Optional skip value\n" +"will return the -`skip`th log entry. Equivalent to get_next(-skip)."); +static PyObject * +Journal_get_previous(Journal *self, PyObject *args) +{ + int64_t skip=1LL; + if (! PyArg_ParseTuple(args, "|L", &skip)) + return NULL; + + PyObject *dict, *arg; + arg = Py_BuildValue("(L)", -skip); + dict = Journal_get_next(self, arg); + Py_DECREF(arg); + return dict; +} + +PyDoc_STRVAR(Journal_add_match__doc__, +"add_match(match, ..., field=value, ...) -> None\n\n" +"Add a match to filter journal log entries. All matches of different\n" +"field are combined in logical AND, and matches of the same field\n" +"are automatically combined in logical OR.\n" +"Matches can be passed as strings \"field=value\", or keyword\n" +"arguments field=\"value\"."); +static PyObject * +Journal_add_match(Journal *self, PyObject *args, PyObject *keywds) +{ + Py_ssize_t arg_match_len; + char *arg_match; + int i, r; + for (i = 0; i < PySequence_Size(args); i++) { +#if PY_MAJOR_VERSION >=3 + PyObject *arg; + arg = PySequence_Fast_GET_ITEM(args, i); + if (PyUnicode_Check(arg)) { +#if PY_MINOR_VERSION >=3 + arg_match = PyUnicode_AsUTF8AndSize(arg, &arg_match_len); +#else + PyObject *temp; + temp = PyUnicode_AsUTF8String(arg); + PyBytes_AsStringAndSize(temp, &arg_match, &arg_match_len); + Py_DECREF(temp); +#endif + }else if (PyBytes_Check(arg)) { + PyBytes_AsStringAndSize(arg, &arg_match, &arg_match_len); + }else{ + PyErr_SetString(PyExc_TypeError, "expected bytes or string"); + } +#else + PyString_AsStringAndSize(PySequence_Fast_GET_ITEM(args, i), &arg_match, &arg_match_len); +#endif + if (PyErr_Occurred()) + return NULL; + r = sd_journal_add_match(self->j, arg_match, arg_match_len); + if (r == -EINVAL) { + PyErr_SetString(PyExc_ValueError, "Invalid match"); + return NULL; + }else if (r == -ENOMEM) { + PyErr_SetString(PyExc_MemoryError, "Not enough memory"); + return NULL; + }else if (r < 0) { + PyErr_SetString(PyExc_RuntimeError, "Error adding match"); + return NULL; + } + } + + if (! keywds) + Py_RETURN_NONE; + + PyObject *key, *value; + Py_ssize_t pos=0, match_key_len, match_value_len; + int match_len; + char *match_key, *match_value; + void *match; + while (PyDict_Next(keywds, &pos, &key, &value)) { +#if PY_MAJOR_VERSION >=3 + if (PyUnicode_Check(key)) { +#if PY_MINOR_VERSION >=3 + match_key = PyUnicode_AsUTF8AndSize(key, &match_key_len); +#else + PyObject *temp2; + temp2 = PyUnicode_AsUTF8String(key); + PyBytes_AsStringAndSize(temp2, &match_key, &match_key_len); + Py_DECREF(temp2); +#endif + }else if (PyBytes_Check(key)) { + PyBytes_AsStringAndSize(key, &match_key, &match_key_len); + }else{ + PyErr_SetString(PyExc_TypeError, "expected bytes or string"); + } + if (PyUnicode_Check(value)) { +#if PY_MINOR_VERSION >=3 + match_value = PyUnicode_AsUTF8AndSize(value, &match_value_len); +#else + PyObject *temp3; + temp3 = PyUnicode_AsUTF8String(value); + PyBytes_AsStringAndSize(temp3, &match_value, &match_value_len); + Py_DECREF(temp3); +#endif + }else if (PyBytes_Check(value)) { + PyBytes_AsStringAndSize(value, &match_value, &match_value_len); + }else{ + PyErr_SetString(PyExc_TypeError, "expected bytes or string"); + } +#else + PyString_AsStringAndSize(key, &match_key, &match_key_len); + PyString_AsStringAndSize(value, &match_value, &match_value_len); +#endif + if (PyErr_Occurred()) + return NULL; + + match_len = match_key_len + 1 + match_value_len; + match = malloc(match_len); + memcpy(match, match_key, match_key_len); + memcpy(match + match_key_len, "=", 1); + memcpy(match + match_key_len + 1, match_value, match_value_len); + + r = sd_journal_add_match(self->j, match, match_len); + free(match); + if (r == -EINVAL) { + PyErr_SetString(PyExc_ValueError, "Invalid match"); + return NULL; + }else if (r == -ENOMEM) { + PyErr_SetString(PyExc_MemoryError, "Not enough memory"); + return NULL; + }else if (r < 0) { + PyErr_SetString(PyExc_RuntimeError, "Error adding match"); + return NULL; + } + } + + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Journal_add_disjunction__doc__, +"add_disjunction() -> None\n\n" +"Once called, all matches before and after are combined in logical\n" +"OR."); +static PyObject * +Journal_add_disjunction(Journal *self, PyObject *args) +{ + int r; + r = sd_journal_add_disjunction(self->j); + if (r == -ENOMEM) { + PyErr_SetString(PyExc_MemoryError, "Not enough memory"); + return NULL; + }else if (r < 0) { + PyErr_SetString(PyExc_RuntimeError, "Error adding disjunction"); + return NULL; + } + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Journal_flush_matches__doc__, +"flush_matches() -> None\n\n" +"Clears all current match filters."); +static PyObject * +Journal_flush_matches(Journal *self, PyObject *args) +{ + sd_journal_flush_matches(self->j); + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Journal_seek__doc__, +"seek(offset[, whence]) -> None\n\n" +"Seek through journal by `offset` number of entries. Argument\n" +"`whence` defines what the offset is relative to:\n" +"os.SEEK_SET (default) from first match in journal;\n" +"os.SEEK_CUR from current position in journal;\n" +"and os.SEEK_END is from last match in journal."); +static PyObject * +Journal_seek(Journal *self, PyObject *args, PyObject *keywds) +{ + int64_t offset; + int whence=SEEK_SET; + static char *kwlist[] = {"offset", "whence", NULL}; + + if (! PyArg_ParseTupleAndKeywords(args, keywds, "L|i", kwlist, + &offset, &whence)) + return NULL; + + PyObject *arg; + if (whence == SEEK_SET){ + int r; + Py_BEGIN_ALLOW_THREADS + r = sd_journal_seek_head(self->j); + Py_END_ALLOW_THREADS + if (r < 0) { + PyErr_SetString(PyExc_RuntimeError, "Error seeking to head"); + return NULL; + } + if (offset > 0LL) { + arg = Py_BuildValue("(L)", offset); + Py_DECREF(Journal_get_next(self, arg)); + Py_DECREF(arg); + } + }else if (whence == SEEK_CUR){ + arg = Py_BuildValue("(L)", offset); + Py_DECREF(Journal_get_next(self, arg)); + Py_DECREF(arg); + }else if (whence == SEEK_END){ + int r; + Py_BEGIN_ALLOW_THREADS + r = sd_journal_seek_tail(self->j); + Py_END_ALLOW_THREADS + if (r < 0) { + PyErr_SetString(PyExc_RuntimeError, "Error seeking to tail"); + return NULL; + } + arg = Py_BuildValue("(L)", -1LL); + Py_DECREF(Journal_get_next(self, arg)); + Py_DECREF(arg); + if (offset < 0LL) { + arg = Py_BuildValue("(L)", offset); + Py_DECREF(Journal_get_next(self, arg)); + Py_DECREF(arg); + } + }else{ + PyErr_SetString(PyExc_ValueError, "Invalid value for whence"); + return NULL; + } + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Journal_seek_realtime__doc__, +"seek_realtime(realtime) -> None\n\n" +"Seek to nearest matching journal entry to `realtime`. Argument\n" +"`realtime` can be an integer unix timestamp in usecs or a " +"datetime instance."); +static PyObject * +Journal_seek_realtime(Journal *self, PyObject *args) +{ + PyObject *arg; + if (! PyArg_ParseTuple(args, "O", &arg)) + return NULL; + + uint64_t timestamp=-1LL; + if (PyDateTime_Check(arg)) { + PyObject *temp; + char *timestamp_str; + temp = PyObject_CallMethod(arg, "strftime", "s", "%s%f"); +#if PY_MAJOR_VERSION >=3 + PyObject *temp2; + temp2 = PyUnicode_AsUTF8String(temp); + timestamp_str = PyBytes_AsString(temp2); + Py_DECREF(temp2); +#else + timestamp_str = PyString_AsString(temp); +#endif + Py_DECREF(temp); + timestamp = strtoull(timestamp_str, NULL, 10); + }else if (PyLong_Check(arg)) { + timestamp = PyLong_AsUnsignedLongLong(arg); +#if PY_MAJOR_VERSION <3 + }else if (PyInt_Check(arg)) { + timestamp = PyInt_AsUnsignedLongLongMask(arg); +#endif + } + if ((int64_t) timestamp < 0LL) { + PyErr_SetString(PyExc_ValueError, "Time must be positive integer or datetime instance"); + return NULL; + } + + int r; + Py_BEGIN_ALLOW_THREADS + r = sd_journal_seek_realtime_usec(self->j, timestamp); + Py_END_ALLOW_THREADS + if (r < 0) { + PyErr_SetString(PyExc_RuntimeError, "Error seek to time"); + return NULL; + } + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Journal_seek_monotonic__doc__, +"seek_monotonic(monotonic[, bootid]) -> None\n\n" +"Seek to nearest matching journal entry to `monotonic`. Argument\n" +"`monotonic` is an timestamp from boot in secs, or a\n" +"timedelta instance.\n" +"Argument `bootid` is a string representing which boot the\n" +"monotonic time is reference to. Defaults to current bootid."); +static PyObject * +Journal_seek_monotonic(Journal *self, PyObject *args) +{ + PyObject *arg; + char *bootid=NULL; + if (! PyArg_ParseTuple(args, "O|s", &arg, &bootid)) + return NULL; + + uint64_t timestamp=-1LL; + if PyDelta_Check(arg) { + PyObject *temp; + temp = PyObject_CallMethod(arg, "total_seconds", NULL); + timestamp = (uint64_t) (PyFloat_AsDouble(temp) * 1E6); + Py_DECREF(temp); + }else if (PyFloat_Check(arg)) { + timestamp = (uint64_t) (PyFloat_AsDouble(arg) * 1E6); + }else if (PyLong_Check(arg)) { + timestamp = PyLong_AsUnsignedLongLong(arg) * (uint64_t) 1E6; +#if PY_MAJOR_VERSION <3 + }else if (PyInt_Check(arg)) { + timestamp = PyInt_AsUnsignedLongLongMask(arg) * (uint64_t) 1E6; +#endif + + } + + if ((int64_t) timestamp < 0LL) { + PyErr_SetString(PyExc_ValueError, "Time must be positive number or timedelta instance"); + return NULL; + } + + sd_id128_t sd_id; + int r; + if (bootid) { + r = sd_id128_from_string(bootid, &sd_id); + if (r == -EINVAL) { + PyErr_SetString(PyExc_ValueError, "Invalid bootid"); + return NULL; + } else if (r < 0) { + PyErr_SetString(PyExc_RuntimeError, "Error processing bootid"); + return NULL; + } + }else{ + r = sd_id128_get_boot(&sd_id); + if (r == -EIO) { + PyErr_SetString(PyExc_IOError, "Error getting current boot ID"); + return NULL; + } else if (r < 0) { + PyErr_SetString(PyExc_RuntimeError, "Error getting current boot ID"); + return NULL; + } + } + + Py_BEGIN_ALLOW_THREADS + r = sd_journal_seek_monotonic_usec(self->j, sd_id, timestamp); + Py_END_ALLOW_THREADS + if (r < 0) { + PyErr_SetString(PyExc_RuntimeError, "Error seek to time"); + return NULL; + } + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Journal_wait__doc__, +"wait([timeout]) -> Change state (integer)\n\n" +"Waits until there is a change in the journal. Argument `timeout`\n" +"is the maximum number of seconds to wait before returning\n" +"regardless if journal has changed. If `timeout` is not given or is\n" +"0, then it will block forever.\n" +"Will return constants: NOP if no change; APPEND if new\n" +"entries have been added to the end of the journal; and\n" +"INVALIDATE if journal files have been added or removed."); +static PyObject * +Journal_wait(Journal *self, PyObject *args, PyObject *keywds) +{ + int64_t timeout=0LL; + if (! PyArg_ParseTuple(args, "|L", &timeout)) + return NULL; + + int r; + if ( timeout == 0LL) { + Py_BEGIN_ALLOW_THREADS + r = sd_journal_wait(self->j, (uint64_t) -1); + Py_END_ALLOW_THREADS + }else{ + Py_BEGIN_ALLOW_THREADS + r = sd_journal_wait(self->j, timeout * 1E6); + Py_END_ALLOW_THREADS + } +#if PY_MAJOR_VERSION >=3 + return PyLong_FromLong(r); +#else + return PyInt_FromLong(r); +#endif +} + +PyDoc_STRVAR(Journal_seek_cursor__doc__, +"seek_cursor(cursor) -> None\n\n" +"Seeks to journal entry by given unique reference `cursor`."); +static PyObject * +Journal_seek_cursor(Journal *self, PyObject *args) +{ + const char *cursor; + if (! PyArg_ParseTuple(args, "s", &cursor)) + return NULL; + + int r; + Py_BEGIN_ALLOW_THREADS + r = sd_journal_seek_cursor(self->j, cursor); + Py_END_ALLOW_THREADS + if (r == -EINVAL) { + PyErr_SetString(PyExc_ValueError, "Invalid cursor"); + return NULL; + }else if (r == -ENOMEM) { + PyErr_SetString(PyExc_MemoryError, "Not enough memory"); + return NULL; + }else if (r < 0) { + PyErr_SetString(PyExc_RuntimeError, "Error seeking to cursor"); + return NULL; + } + Py_RETURN_NONE; +} + +static PyObject * +Journal_iter(PyObject *self) +{ + Py_INCREF(self); + return self; +} + +static PyObject * +Journal_iternext(PyObject *self) +{ + Journal *iter = (Journal *)self; + PyObject *dict, *arg; + Py_ssize_t dict_size; + + arg = Py_BuildValue("()"); + dict = Journal_get_next(iter, arg); + Py_DECREF(arg); + dict_size = PyDict_Size(dict); + if ((int64_t) dict_size > 0LL) { + return dict; + }else{ + Py_DECREF(dict); + PyErr_SetNone(PyExc_StopIteration); + return NULL; + } +} + +#ifdef SD_JOURNAL_FOREACH_UNIQUE +PyDoc_STRVAR(Journal_query_unique__doc__, +"query_unique(field) -> a set of values\n\n" +"Returns a set of unique values in journal for given `field`.\n" +"Note this does not respect any journal matches."); +static PyObject * +Journal_query_unique(Journal *self, PyObject *args) +{ + char *query; + if (! PyArg_ParseTuple(args, "s", &query)) + return NULL; + + int r; + Py_BEGIN_ALLOW_THREADS + r = sd_journal_query_unique(self->j, query); + Py_END_ALLOW_THREADS + if (r == -EINVAL) { + PyErr_SetString(PyExc_ValueError, "Invalid field name"); + return NULL; + } else if (r == -ENOMEM) { + PyErr_SetString(PyExc_MemoryError, "Not enough memory"); + return NULL; + } else if (r < 0) { + PyErr_SetString(PyExc_RuntimeError, "Error querying journal"); + return NULL; + } + + const void *uniq; + size_t uniq_len; + const char *delim_ptr; + PyObject *value_set, *key, *value; + value_set = PySet_New(0); + +#if PY_MAJOR_VERSION >=3 + key = PyUnicode_FromString(query); +#else + key = PyString_FromString(query); +#endif + + SD_JOURNAL_FOREACH_UNIQUE(self->j, uniq, uniq_len) { + delim_ptr = memchr(uniq, '=', uniq_len); + value = Journal___process_field(self, key, delim_ptr + 1, (const char*) uniq + uniq_len - (delim_ptr + 1)); + PySet_Add(value_set, value); + Py_DECREF(value); + } + Py_DECREF(key); + return value_set; +} +#endif //def SD_JOURNAL_FOREACH_UNIQUE + +PyDoc_STRVAR(Journal_log_level__doc__, +"log_level(level) -> None\n\n" +"Sets maximum log level by setting matches for PRIORITY."); +static PyObject * +Journal_log_level(Journal *self, PyObject *args) +{ + int level; + if (! PyArg_ParseTuple(args, "i", &level)) + return NULL; + + if (level < 0 || level > 7) { + PyErr_SetString(PyExc_ValueError, "Log level should be 0 <= level <= 7"); + return NULL; + } + int i; + char level_str[2]; + PyObject *arg, *keywds; + for(i = 0; i <= level; i++) { + sprintf(level_str, "%i", i); + arg = PyTuple_New(0); + keywds = Py_BuildValue("{s:s}", "PRIORITY", level_str); + Journal_add_match(self, arg, keywds); + Py_DECREF(arg); + Py_DECREF(keywds); + if (PyErr_Occurred()) + return NULL; + } + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Journal_this_boot__doc__, +"this_boot() -> None\n\n" +"Sets match filter for the current _BOOT_ID."); +static PyObject * +Journal_this_boot(Journal *self, PyObject *args) +{ + sd_id128_t sd_id; + int r; + r = sd_id128_get_boot(&sd_id); + if (r == -EIO) { + PyErr_SetString(PyExc_IOError, "Error getting current boot ID"); + return NULL; + } else if (r < 0) { + PyErr_SetString(PyExc_RuntimeError, "Error getting current boot ID"); + return NULL; + } + + char bootid[33]; + sd_id128_to_string(sd_id, bootid); + + PyObject *arg, *keywds; + arg = PyTuple_New(0); + keywds = Py_BuildValue("{s:s}", "_BOOT_ID", bootid); + Journal_add_match(self, arg, keywds); + Py_DECREF(arg); + Py_DECREF(keywds); + if (PyErr_Occurred()) + return NULL; + + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Journal_this_machine__doc__, +"this_machine() -> None\n\n" +"Sets match filter for the current _MACHINE_ID."); +static PyObject * +Journal_this_machine(Journal *self, PyObject *args) +{ + sd_id128_t sd_id; + int r; + r = sd_id128_get_machine(&sd_id); + if (r == -EIO) { + PyErr_SetString(PyExc_IOError, "Error getting current boot ID"); + return NULL; + } else if (r < 0) { + PyErr_SetString(PyExc_RuntimeError, "Error getting current boot ID"); + return NULL; + } + + char machineid[33]; + sd_id128_to_string(sd_id, machineid); + + PyObject *arg, *keywds; + arg = PyTuple_New(0); + keywds = Py_BuildValue("{s:s}", "_MACHINE_ID", machineid); + Journal_add_match(self, arg, keywds); + Py_DECREF(arg); + Py_DECREF(keywds); + if (PyErr_Occurred()) + return NULL; + + Py_RETURN_NONE; +} + +static PyObject * +Journal_get_default_call(Journal *self, void *closure) +{ + Py_INCREF(self->default_call); + return self->default_call; +} + +static int +Journal_set_default_call(Journal *self, PyObject *value, void *closure) +{ + if (value == NULL) { + PyErr_SetString(PyExc_TypeError, "Cannot delete default_call"); + return -1; + } + if (! PyCallable_Check(value)) { + PyErr_SetString(PyExc_TypeError, "default_call must be callable"); + return -1; + } + Py_DECREF(self->default_call); + Py_INCREF(value); + self->default_call = value; + + return 0; +} + +static PyObject * +Journal_get_call_dict(Journal *self, void *closure) +{ + Py_INCREF(self->call_dict); + return self->call_dict; +} + +static int +Journal_set_call_dict(Journal *self, PyObject *value, void *closure) +{ + if (value == NULL) { + PyErr_SetString(PyExc_TypeError, "Cannot delete call_dict"); + return -1; + } + if (! PyDict_Check(value)) { + PyErr_SetString(PyExc_TypeError, "call_dict must be dict type"); + return -1; + } + Py_DECREF(self->call_dict); + Py_INCREF(value); + self->call_dict = value; + + return 0; +} + +static PyObject * +Journal_get_data_threshold(Journal *self, void *closure) +{ + size_t cvalue; + PyObject *value; + int r; + + r = sd_journal_get_data_threshold(self->j, &cvalue); + if (r < 0){ + PyErr_SetString(PyExc_RuntimeError, "Error getting data threshold"); + return NULL; + } + +#if PY_MAJOR_VERSION >=3 + value = PyLong_FromSize_t(cvalue); +#else + value = PyInt_FromSize_t(cvalue); +#endif + return value; +} + +static int +Journal_set_data_threshold(Journal *self, PyObject *value, void *closure) +{ + if (value == NULL) { + PyErr_SetString(PyExc_TypeError, "Cannot delete data threshold"); + return -1; + } +#if PY_MAJOR_VERSION >=3 + if (! PyLong_Check(value)){ +#else + if (! PyInt_Check(value)){ +#endif + PyErr_SetString(PyExc_TypeError, "Data threshold must be int"); + return -1; + } + int r; +#if PY_MAJOR_VERSION >=3 + r = sd_journal_set_data_threshold(self->j, (size_t) PyLong_AsLong(value)); +#else + r = sd_journal_set_data_threshold(self->j, (size_t) PyInt_AsLong(value)); +#endif + if (r < 0){ + PyErr_SetString(PyExc_RuntimeError, "Error setting data threshold"); + return -1; + } + return 0; +} + +static PyGetSetDef Journal_getseters[] = { + {"data_threshold", + (getter)Journal_get_data_threshold, + (setter)Journal_set_data_threshold, + "data threshold", + NULL}, + {"call_dict", + (getter)Journal_get_call_dict, + (setter)Journal_set_call_dict, + "dictionary of calls for each field", + NULL}, + {"default_call", + (getter)Journal_get_default_call, + (setter)Journal_set_default_call, + "default call for values for fields", + NULL}, + {NULL} +}; + +static PyMethodDef Journal_methods[] = { + {"get_next", (PyCFunction)Journal_get_next, METH_VARARGS, + Journal_get_next__doc__}, + {"get_previous", (PyCFunction)Journal_get_previous, METH_VARARGS, + Journal_get_previous__doc__}, + {"add_match", (PyCFunction)Journal_add_match, METH_VARARGS|METH_KEYWORDS, + Journal_add_match__doc__}, + {"add_disjunction", (PyCFunction)Journal_add_disjunction, METH_NOARGS, + Journal_add_disjunction__doc__}, + {"flush_matches", (PyCFunction)Journal_flush_matches, METH_NOARGS, + Journal_flush_matches__doc__}, + {"seek", (PyCFunction)Journal_seek, METH_VARARGS | METH_KEYWORDS, + Journal_seek__doc__}, + {"seek_realtime", (PyCFunction)Journal_seek_realtime, METH_VARARGS, + Journal_seek_realtime__doc__}, + {"seek_monotonic", (PyCFunction)Journal_seek_monotonic, METH_VARARGS, + Journal_seek_monotonic__doc__}, + {"wait", (PyCFunction)Journal_wait, METH_VARARGS, + Journal_wait__doc__}, + {"seek_cursor", (PyCFunction)Journal_seek_cursor, METH_VARARGS, + Journal_seek_cursor__doc__}, +#ifdef SD_JOURNAL_FOREACH_UNIQUE + {"query_unique", (PyCFunction)Journal_query_unique, METH_VARARGS, + Journal_query_unique__doc__}, +#endif + {"log_level", (PyCFunction)Journal_log_level, METH_VARARGS, + Journal_log_level__doc__}, + {"this_boot", (PyCFunction)Journal_this_boot, METH_NOARGS, + Journal_this_boot__doc__}, + {"this_machine", (PyCFunction)Journal_this_machine, METH_NOARGS, + Journal_this_machine__doc__}, + {NULL} /* Sentinel */ +}; + +static PyTypeObject JournalType = { + PyVarObject_HEAD_INIT(NULL, 0) + "_reader.Journal", /*tp_name*/ + sizeof(Journal), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + (destructor)Journal_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,/*tp_flags*/ + Journal__doc__, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + Journal_iter, /* tp_iter */ + Journal_iternext, /* tp_iternext */ + Journal_methods, /* tp_methods */ + 0, /* tp_members */ + Journal_getseters, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)Journal_init, /* tp_init */ + 0, /* tp_alloc */ + Journal_new, /* tp_new */ +}; + +#if PY_MAJOR_VERSION >= 3 +static PyModuleDef _reader_module = { + PyModuleDef_HEAD_INIT, + "_reader", + "Module that reads systemd journal similar to journalctl.", + -1, + NULL, NULL, NULL, NULL, NULL +}; +#endif + +PyMODINIT_FUNC +#if PY_MAJOR_VERSION >= 3 +PyInit__reader(void) +#else +init_reader(void) +#endif +{ + PyObject* m; + + PyDateTime_IMPORT; + + if (PyType_Ready(&JournalType) < 0) +#if PY_MAJOR_VERSION >= 3 + return NULL; +#else + return; +#endif + +#if PY_MAJOR_VERSION >= 3 + m = PyModule_Create(&_reader_module); + if (m == NULL) + return NULL; +#else + m = Py_InitModule3("_reader", NULL, + "Module that reads systemd journal similar to journalctl."); + if (m == NULL) + return; +#endif + + Py_INCREF(&JournalType); + PyModule_AddObject(m, "Journal", (PyObject *)&JournalType); + PyModule_AddIntConstant(m, "NOP", SD_JOURNAL_NOP); + PyModule_AddIntConstant(m, "APPEND", SD_JOURNAL_APPEND); + PyModule_AddIntConstant(m, "INVALIDATE", SD_JOURNAL_INVALIDATE); + PyModule_AddIntConstant(m, "LOCAL_ONLY", SD_JOURNAL_LOCAL_ONLY); + PyModule_AddIntConstant(m, "RUNTIME_ONLY", SD_JOURNAL_RUNTIME_ONLY); + PyModule_AddIntConstant(m, "SYSTEM_ONLY", SD_JOURNAL_SYSTEM_ONLY); + +#if PY_MAJOR_VERSION >= 3 + return m; +#endif +} diff --git a/src/python-systemd/journal.py b/src/python-systemd/journal.py index 47849a360c..a1543b884e 100644 --- a/src/python-systemd/journal.py +++ b/src/python-systemd/journal.py @@ -25,6 +25,8 @@ import logging as _logging 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) def _make_line(field, value): if isinstance(value, bytes): |