chiark / gitweb /
sphinx: document Journal class too
[elogind.git] / src / python-systemd / _reader.c
1 /*
2 _reader - Python module that reads systemd journal similar to journalctl
3 Copyright (C) 2012  Steven Hiscocks
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with this library; if not, write to the Free Software
17 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
18 */
19 #include <systemd/sd-journal.h>
20
21 #include <Python.h>
22 #include <structmember.h>
23 #include <datetime.h>
24
25 typedef struct {
26     PyObject_HEAD
27     sd_journal *j;
28 } Journal;
29 static PyTypeObject JournalType;
30
31 static void
32 Journal_dealloc(Journal* self)
33 {
34     sd_journal_close(self->j);
35     Py_TYPE(self)->tp_free((PyObject*)self);
36 }
37
38 PyDoc_STRVAR(Journal__doc__,
39 "Journal([flags][,path]) -> ...\n"
40 "Journal instance\n\n"
41 "Returns instance of Journal, which allows filtering and return\n"
42 "of journal entries.\n"
43 "Argument `flags` sets open flags of the journal, which can be one\n"
44 "of, or ORed combination of constants: LOCAL_ONLY (default) opens\n"
45 "journal on local machine only; RUNTIME_ONLY opens only\n"
46 "volatile journal files; and SYSTEM_ONLY opens only\n"
47 "journal files of system services and the kernel.\n"
48 "Argument `path` is the directory of journal files. Note that\n"
49 "currently flags are ignored when `path` is present as they are\n"
50 " not relevant.");
51 static int
52 Journal_init(Journal *self, PyObject *args, PyObject *keywds)
53 {
54     int flags=SD_JOURNAL_LOCAL_ONLY;
55     char *path=NULL;
56
57     static char *kwlist[] = {"flags", NULL};
58     if (! PyArg_ParseTupleAndKeywords(args, keywds, "|is", kwlist,
59                                       &flags, &path))
60         return 1;
61
62     int r;
63     if (path) {
64         r = sd_journal_open_directory(&self->j, path, 0);
65     }else{
66         Py_BEGIN_ALLOW_THREADS
67         r = sd_journal_open(&self->j, flags);
68         Py_END_ALLOW_THREADS
69     }
70     if (r == -EINVAL) {
71         PyErr_SetString(PyExc_ValueError, "Invalid flags or path");
72         return -1;
73     }else if (r == -ENOMEM) {
74         PyErr_SetString(PyExc_MemoryError, "Not enough memory");
75         return 1;
76     }else if (r < 0) {
77         PyErr_SetString(PyExc_RuntimeError, "Error opening journal");
78         return 1;
79     }
80
81     return 0;
82 }
83
84 PyDoc_STRVAR(Journal_get_next__doc__,
85 "get_next([skip]) -> dict\n\n"
86 "Return dictionary of the next log entry. Optional skip value will\n"
87 "return the `skip`th log entry.");
88 static PyObject *
89 Journal_get_next(Journal *self, PyObject *args)
90 {
91     int64_t skip=1LL;
92     if (! PyArg_ParseTuple(args, "|L", &skip))
93         return NULL;
94
95     int r;
96     if (skip == 1LL) {
97         Py_BEGIN_ALLOW_THREADS
98         r = sd_journal_next(self->j);
99         Py_END_ALLOW_THREADS
100     }else if (skip == -1LL) {
101         Py_BEGIN_ALLOW_THREADS
102         r = sd_journal_previous(self->j);
103         Py_END_ALLOW_THREADS
104     }else if (skip > 1LL) {
105         Py_BEGIN_ALLOW_THREADS
106         r = sd_journal_next_skip(self->j, skip);
107         Py_END_ALLOW_THREADS
108     }else if (skip < -1LL) {
109         Py_BEGIN_ALLOW_THREADS
110         r = sd_journal_previous_skip(self->j, -skip);
111         Py_END_ALLOW_THREADS
112     }else{
113         PyErr_SetString(PyExc_ValueError, "Skip number must positive/negative integer");
114         return NULL;
115     }
116
117     if (r < 0) {
118         PyErr_SetString(PyExc_RuntimeError, "Error getting next message");
119         return NULL;
120     }else if ( r == 0) { //EOF
121         return PyDict_New();
122     }
123
124     PyObject *dict;
125     dict = PyDict_New();
126
127     const void *msg;
128     size_t msg_len;
129     const char *delim_ptr;
130     PyObject *key, *value, *cur_value, *tmp_list;
131
132     SD_JOURNAL_FOREACH_DATA(self->j, msg, msg_len) {
133         delim_ptr = memchr(msg, '=', msg_len);
134 #if PY_MAJOR_VERSION >=3
135         key = PyUnicode_FromStringAndSize(msg, delim_ptr - (const char*) msg);
136 #else
137         key = PyString_FromStringAndSize(msg, delim_ptr - (const char*) msg);
138 #endif
139         value = PyBytes_FromStringAndSize(delim_ptr + 1, (const char*) msg + msg_len - (delim_ptr + 1) );
140         if (PyDict_Contains(dict, key)) {
141             cur_value = PyDict_GetItem(dict, key);
142             if (PyList_CheckExact(cur_value)) {
143                 PyList_Append(cur_value, value);
144             }else{
145                 tmp_list = PyList_New(0);
146                 PyList_Append(tmp_list, cur_value);
147                 PyList_Append(tmp_list, value);
148                 PyDict_SetItem(dict, key, tmp_list);
149                 Py_DECREF(tmp_list);
150             }
151         }else{
152             PyDict_SetItem(dict, key, value);
153         }
154         Py_DECREF(key);
155         Py_DECREF(value);
156     }
157
158     uint64_t realtime;
159     if (sd_journal_get_realtime_usec(self->j, &realtime) == 0) {
160         char realtime_str[20];
161         sprintf(realtime_str, "%llu", (long long unsigned) realtime);
162
163 #if PY_MAJOR_VERSION >=3
164         key = PyUnicode_FromString("__REALTIME_TIMESTAMP");
165 #else
166         key = PyString_FromString("__REALTIME_TIMESTAMP");
167 #endif
168         value = PyBytes_FromString(realtime_str);
169         PyDict_SetItem(dict, key, value);
170         Py_DECREF(key);
171         Py_DECREF(value);
172     }
173
174     sd_id128_t sd_id;
175     uint64_t monotonic;
176     if (sd_journal_get_monotonic_usec(self->j, &monotonic, &sd_id) == 0) {
177         char monotonic_str[20];
178         sprintf(monotonic_str, "%llu", (long long unsigned) monotonic);
179 #if PY_MAJOR_VERSION >=3
180         key = PyUnicode_FromString("__MONOTONIC_TIMESTAMP");
181 #else
182         key = PyString_FromString("__MONOTONIC_TIMESTAMP");
183 #endif
184         value = PyBytes_FromString(monotonic_str);
185
186         PyDict_SetItem(dict, key, value);
187         Py_DECREF(key);
188         Py_DECREF(value);
189     }
190
191     char *cursor;
192     if (sd_journal_get_cursor(self->j, &cursor) > 0) { //Should return 0...
193 #if PY_MAJOR_VERSION >=3
194         key = PyUnicode_FromString("__CURSOR");
195 #else
196         key = PyString_FromString("__CURSOR");
197 #endif
198         value = PyBytes_FromString(cursor);
199         PyDict_SetItem(dict, key, value);
200         free(cursor);
201         Py_DECREF(key);
202         Py_DECREF(value);
203     }
204
205     return dict;
206 }
207
208 PyDoc_STRVAR(Journal_get_previous__doc__,
209 "get_previous([skip]) -> dict\n\n"
210 "Return dictionary of the previous log entry. Optional skip value\n"
211 "will return the -`skip`th log entry. Equivalent to get_next(-skip).");
212 static PyObject *
213 Journal_get_previous(Journal *self, PyObject *args)
214 {
215     int64_t skip=1LL;
216     if (! PyArg_ParseTuple(args, "|L", &skip))
217         return NULL;
218
219     return PyObject_CallMethod((PyObject *)self, "get_next", "L", -skip);
220 }
221
222 PyDoc_STRVAR(Journal_add_match__doc__,
223 "add_match(match, ..., field=value, ...) -> None\n\n"
224 "Add a match to filter journal log entries. All matches of different\n"
225 "field are combined in logical AND, and matches of the same field\n"
226 "are automatically combined in logical OR.\n"
227 "Matches can be passed as strings \"field=value\", or keyword\n"
228 "arguments field=\"value\".");
229 static PyObject *
230 Journal_add_match(Journal *self, PyObject *args, PyObject *keywds)
231 {
232     Py_ssize_t arg_match_len;
233     char *arg_match;
234     int i, r;
235     for (i = 0; i < PySequence_Size(args); i++) {
236 #if PY_MAJOR_VERSION >=3
237         PyObject *arg;
238         arg = PySequence_Fast_GET_ITEM(args, i);
239         if (PyUnicode_Check(arg)) {
240 #if PY_MINOR_VERSION >=3
241             arg_match = PyUnicode_AsUTF8AndSize(arg, &arg_match_len);
242 #else
243             PyObject *temp;
244             temp = PyUnicode_AsUTF8String(arg);
245             PyBytes_AsStringAndSize(temp, &arg_match, &arg_match_len);
246             Py_DECREF(temp);
247 #endif
248         }else if (PyBytes_Check(arg)) {
249             PyBytes_AsStringAndSize(arg, &arg_match, &arg_match_len);
250         }else{
251             PyErr_SetString(PyExc_TypeError, "expected bytes or string");
252         }
253 #else
254         PyString_AsStringAndSize(PySequence_Fast_GET_ITEM(args, i), &arg_match, &arg_match_len);
255 #endif
256         if (PyErr_Occurred())
257             return NULL;
258         r = sd_journal_add_match(self->j, arg_match, arg_match_len);
259         if (r == -EINVAL) {
260             PyErr_SetString(PyExc_ValueError, "Invalid match");
261             return NULL;
262         }else if (r == -ENOMEM) {
263             PyErr_SetString(PyExc_MemoryError, "Not enough memory");
264             return NULL;
265         }else if (r < 0) {
266             PyErr_SetString(PyExc_RuntimeError, "Error adding match");
267             return NULL;
268         }
269     }
270
271     if (! keywds)
272         Py_RETURN_NONE;
273
274     PyObject *key, *value;
275     Py_ssize_t pos=0, match_key_len, match_value_len;
276     int match_len;
277     char *match_key, *match_value;
278     void *match;
279     while (PyDict_Next(keywds, &pos, &key, &value)) {
280 #if PY_MAJOR_VERSION >=3
281         if (PyUnicode_Check(key)) {
282 #if PY_MINOR_VERSION >=3
283             match_key = PyUnicode_AsUTF8AndSize(key, &match_key_len);
284 #else
285             PyObject *temp2;
286             temp2 = PyUnicode_AsUTF8String(key);
287             PyBytes_AsStringAndSize(temp2, &match_key, &match_key_len);
288             Py_DECREF(temp2);
289 #endif
290         }else if (PyBytes_Check(key)) {
291             PyBytes_AsStringAndSize(key, &match_key, &match_key_len);
292         }else{
293             PyErr_SetString(PyExc_TypeError, "expected bytes or string");
294         }
295         if (PyUnicode_Check(value)) {
296 #if PY_MINOR_VERSION >=3
297             match_value = PyUnicode_AsUTF8AndSize(value, &match_value_len);
298 #else
299             PyObject *temp3;
300             temp3 = PyUnicode_AsUTF8String(value);
301             PyBytes_AsStringAndSize(temp3, &match_value, &match_value_len);
302             Py_DECREF(temp3);
303 #endif
304         }else if (PyBytes_Check(value)) {
305             PyBytes_AsStringAndSize(value, &match_value, &match_value_len);
306         }else{
307             PyErr_SetString(PyExc_TypeError, "expected bytes or string");
308         }
309 #else
310         PyString_AsStringAndSize(key, &match_key, &match_key_len);
311         PyString_AsStringAndSize(value, &match_value, &match_value_len);
312 #endif
313         if (PyErr_Occurred())
314             return NULL;
315
316         match_len = match_key_len + 1 + match_value_len;
317         match = malloc(match_len);
318         memcpy(match, match_key, match_key_len);
319         memcpy(match + match_key_len, "=", 1);
320         memcpy(match + match_key_len + 1, match_value, match_value_len);
321
322         r = sd_journal_add_match(self->j, match, match_len);
323         free(match);
324         if (r == -EINVAL) {
325             PyErr_SetString(PyExc_ValueError, "Invalid match");
326             return NULL;
327         }else if (r == -ENOMEM) {
328             PyErr_SetString(PyExc_MemoryError, "Not enough memory");
329             return NULL;
330         }else if (r < 0) {
331             PyErr_SetString(PyExc_RuntimeError, "Error adding match");
332             return NULL;
333         }
334     }
335
336     Py_RETURN_NONE;
337 }
338
339 PyDoc_STRVAR(Journal_add_disjunction__doc__,
340 "add_disjunction() -> None\n\n"
341 "Once called, all matches before and after are combined in logical\n"
342 "OR.");
343 static PyObject *
344 Journal_add_disjunction(Journal *self, PyObject *args)
345 {
346     int r;
347     r = sd_journal_add_disjunction(self->j);
348     if (r == -ENOMEM) {
349         PyErr_SetString(PyExc_MemoryError, "Not enough memory");
350         return NULL;
351     }else if (r < 0) {
352         PyErr_SetString(PyExc_RuntimeError, "Error adding disjunction");
353         return NULL;
354     }
355     Py_RETURN_NONE;
356 }
357
358 PyDoc_STRVAR(Journal_flush_matches__doc__,
359 "flush_matches() -> None\n\n"
360 "Clears all current match filters.");
361 static PyObject *
362 Journal_flush_matches(Journal *self, PyObject *args)
363 {
364     sd_journal_flush_matches(self->j);
365     Py_RETURN_NONE;
366 }
367
368 PyDoc_STRVAR(Journal_seek__doc__,
369 "seek(offset[, whence]) -> None\n\n"
370 "Seek through journal by `offset` number of entries. Argument\n"
371 "`whence` defines what the offset is relative to:\n"
372 "os.SEEK_SET (default) from first match in journal;\n"
373 "os.SEEK_CUR from current position in journal;\n"
374 "and os.SEEK_END is from last match in journal.");
375 static PyObject *
376 Journal_seek(Journal *self, PyObject *args, PyObject *keywds)
377 {
378     int64_t offset;
379     int whence=SEEK_SET;
380     static char *kwlist[] = {"offset", "whence", NULL};
381
382     if (! PyArg_ParseTupleAndKeywords(args, keywds, "L|i", kwlist,
383                                       &offset, &whence))
384         return NULL;
385
386     PyObject *arg;
387     if (whence == SEEK_SET){
388         int r;
389         Py_BEGIN_ALLOW_THREADS
390         r = sd_journal_seek_head(self->j);
391         Py_END_ALLOW_THREADS
392         if (r < 0) {
393             PyErr_SetString(PyExc_RuntimeError, "Error seeking to head");
394             return NULL;
395         }
396         if (offset > 0LL) {
397             Py_DECREF(PyObject_CallMethod((PyObject *)self, "get_next", "L", offset));
398         }
399     }else if (whence == SEEK_CUR){
400         Py_DECREF(PyObject_CallMethod((PyObject *)self, "get_next", "L", offset));
401     }else if (whence == SEEK_END){
402         int r;
403         Py_BEGIN_ALLOW_THREADS
404         r = sd_journal_seek_tail(self->j);
405         Py_END_ALLOW_THREADS
406         if (r < 0) {
407             PyErr_SetString(PyExc_RuntimeError, "Error seeking to tail");
408             return NULL;
409         }
410         Py_DECREF(PyObject_CallMethod((PyObject *)self, "get_next", "L", -1LL));
411         if (offset < 0LL) {
412             Py_DECREF(PyObject_CallMethod((PyObject *)self, "get_next", "L", offset));
413         }
414     }else{
415         PyErr_SetString(PyExc_ValueError, "Invalid value for whence");
416         return NULL;
417     }
418     Py_RETURN_NONE;
419 }
420
421 PyDoc_STRVAR(Journal_seek_realtime__doc__,
422 "seek_realtime(realtime) -> None\n\n"
423 "Seek to nearest matching journal entry to `realtime`. Argument\n"
424 "`realtime` can be an integer unix timestamp in usecs or a "
425 "datetime instance.");
426 static PyObject *
427 Journal_seek_realtime(Journal *self, PyObject *args)
428 {
429     PyObject *arg;
430     if (! PyArg_ParseTuple(args, "O", &arg))
431         return NULL;
432
433     uint64_t timestamp=-1LL;
434     if (PyDateTime_Check(arg)) {
435         PyObject *temp;
436         char *timestamp_str;
437         temp = PyObject_CallMethod(arg, "strftime", "s", "%s%f");
438 #if PY_MAJOR_VERSION >=3
439         PyObject *temp2;
440         temp2 = PyUnicode_AsUTF8String(temp);
441         timestamp_str = PyBytes_AsString(temp2);
442         Py_DECREF(temp2);
443 #else
444         timestamp_str = PyString_AsString(temp);
445 #endif
446         Py_DECREF(temp);
447         timestamp = strtoull(timestamp_str, NULL, 10);
448     }else if (PyLong_Check(arg)) {
449         timestamp = PyLong_AsUnsignedLongLong(arg);
450 #if PY_MAJOR_VERSION <3
451     }else if (PyInt_Check(arg)) {
452         timestamp = PyInt_AsUnsignedLongLongMask(arg);
453 #endif
454     }
455     if ((int64_t) timestamp < 0LL) {
456         PyErr_SetString(PyExc_ValueError, "Time must be positive integer or datetime instance");
457         return NULL;
458     }
459
460     int r;
461     Py_BEGIN_ALLOW_THREADS
462     r = sd_journal_seek_realtime_usec(self->j, timestamp);
463     Py_END_ALLOW_THREADS
464     if (r < 0) {
465         PyErr_SetString(PyExc_RuntimeError, "Error seek to time");
466         return NULL;
467     }
468     Py_RETURN_NONE;
469 }
470
471 PyDoc_STRVAR(Journal_seek_monotonic__doc__,
472 "seek_monotonic(monotonic[, bootid]) -> None\n\n"
473 "Seek to nearest matching journal entry to `monotonic`. Argument\n"
474 "`monotonic` is an timestamp from boot in secs, or a\n"
475 "timedelta instance.\n"
476 "Argument `bootid` is a string representing which boot the\n"
477 "monotonic time is reference to. Defaults to current bootid.");
478 static PyObject *
479 Journal_seek_monotonic(Journal *self, PyObject *args)
480 {
481     PyObject *arg;
482     char *bootid=NULL;
483     if (! PyArg_ParseTuple(args, "O|s", &arg, &bootid))
484         return NULL;
485
486     uint64_t timestamp=-1LL;
487     if PyDelta_Check(arg) {
488         PyObject *temp;
489         temp = PyObject_CallMethod(arg, "total_seconds", NULL);
490         timestamp = (uint64_t) (PyFloat_AsDouble(temp) * 1E6);
491         Py_DECREF(temp);
492     }else if (PyFloat_Check(arg)) {
493         timestamp = (uint64_t) (PyFloat_AsDouble(arg) * 1E6);
494     }else if (PyLong_Check(arg)) {
495         timestamp = PyLong_AsUnsignedLongLong(arg) * (uint64_t) 1E6;
496 #if PY_MAJOR_VERSION <3
497     }else if (PyInt_Check(arg)) {
498         timestamp = PyInt_AsUnsignedLongLongMask(arg) * (uint64_t) 1E6;
499 #endif
500
501     }
502
503     if ((int64_t) timestamp < 0LL) {
504         PyErr_SetString(PyExc_ValueError, "Time must be positive number or timedelta instance");
505         return NULL;
506     }
507
508     sd_id128_t sd_id;
509     int r;
510     if (bootid) {
511         r = sd_id128_from_string(bootid, &sd_id);
512         if (r == -EINVAL) {
513             PyErr_SetString(PyExc_ValueError, "Invalid bootid");
514             return NULL;
515         } else if (r < 0) {
516             PyErr_SetString(PyExc_RuntimeError, "Error processing bootid");
517             return NULL;
518         }
519     }else{
520         r = sd_id128_get_boot(&sd_id);
521         if (r == -EIO) {
522             PyErr_SetString(PyExc_IOError, "Error getting current boot ID");
523             return NULL;
524         } else if (r < 0) {
525             PyErr_SetString(PyExc_RuntimeError, "Error getting current boot ID");
526             return NULL;
527         }
528     }
529
530     Py_BEGIN_ALLOW_THREADS
531     r = sd_journal_seek_monotonic_usec(self->j, sd_id, timestamp);
532     Py_END_ALLOW_THREADS
533     if (r < 0) {
534         PyErr_SetString(PyExc_RuntimeError, "Error seek to time");
535         return NULL;
536     }
537     Py_RETURN_NONE;
538 }
539  
540 PyDoc_STRVAR(Journal_wait__doc__,
541 "wait([timeout]) -> Change state (integer)\n\n"
542 "Waits until there is a change in the journal. Argument `timeout`\n"
543 "is the maximum number of seconds to wait before returning\n"
544 "regardless if journal has changed. If `timeout` is not given or is\n"
545 "0, then it will block forever.\n"
546 "Will return constants: NOP if no change; APPEND if new\n"
547 "entries have been added to the end of the journal; and\n"
548 "INVALIDATE if journal files have been added or removed.");
549 static PyObject *
550 Journal_wait(Journal *self, PyObject *args, PyObject *keywds)
551 {
552     int64_t timeout=0LL;
553     if (! PyArg_ParseTuple(args, "|L", &timeout))
554         return NULL;
555
556     int r;
557     if ( timeout == 0LL) {
558         Py_BEGIN_ALLOW_THREADS
559         r = sd_journal_wait(self->j, (uint64_t) -1);
560         Py_END_ALLOW_THREADS
561     }else{
562         Py_BEGIN_ALLOW_THREADS
563         r = sd_journal_wait(self->j, timeout * 1E6);
564         Py_END_ALLOW_THREADS
565     }
566 #if PY_MAJOR_VERSION >=3
567     return PyLong_FromLong(r);
568 #else
569     return PyInt_FromLong(r);
570 #endif
571 }
572
573 PyDoc_STRVAR(Journal_seek_cursor__doc__,
574 "seek_cursor(cursor) -> None\n\n"
575 "Seeks to journal entry by given unique reference `cursor`.");
576 static PyObject *
577 Journal_seek_cursor(Journal *self, PyObject *args)
578 {
579     const char *cursor;
580     if (! PyArg_ParseTuple(args, "s", &cursor))
581         return NULL;
582
583     int r;
584     Py_BEGIN_ALLOW_THREADS
585     r = sd_journal_seek_cursor(self->j, cursor);
586     Py_END_ALLOW_THREADS
587     if (r == -EINVAL) {
588         PyErr_SetString(PyExc_ValueError, "Invalid cursor");
589         return NULL;
590     }else if (r == -ENOMEM) {
591         PyErr_SetString(PyExc_MemoryError, "Not enough memory");
592         return NULL;
593     }else if (r < 0) {
594         PyErr_SetString(PyExc_RuntimeError, "Error seeking to cursor");
595         return NULL;
596     }
597     Py_RETURN_NONE;
598 }
599
600 static PyObject *
601 Journal_iter(PyObject *self)
602 {
603     Py_INCREF(self);
604     return self;
605 }
606
607 static PyObject *
608 Journal_iternext(PyObject *self)
609 {
610     PyObject *dict, *arg;
611     Py_ssize_t dict_size;
612
613     dict = PyObject_CallMethod(self, "get_next", "");
614     dict_size = PyDict_Size(dict);
615     if ((int64_t) dict_size > 0LL) {
616         return dict;
617     }else{
618         Py_DECREF(dict);
619         PyErr_SetNone(PyExc_StopIteration);
620         return NULL;
621     }
622 }
623
624 #ifdef SD_JOURNAL_FOREACH_UNIQUE
625 PyDoc_STRVAR(Journal_query_unique__doc__,
626 "query_unique(field) -> a set of values\n\n"
627 "Returns a set of unique values in journal for given `field`.\n"
628 "Note this does not respect any journal matches.");
629 static PyObject *
630 Journal_query_unique(Journal *self, PyObject *args)
631 {
632     char *query;
633     if (! PyArg_ParseTuple(args, "s", &query))
634         return NULL;
635
636     int r;
637     Py_BEGIN_ALLOW_THREADS
638     r = sd_journal_query_unique(self->j, query);
639     Py_END_ALLOW_THREADS
640     if (r == -EINVAL) {
641         PyErr_SetString(PyExc_ValueError, "Invalid field name");
642         return NULL;
643     } else if (r == -ENOMEM) {
644         PyErr_SetString(PyExc_MemoryError, "Not enough memory");
645         return NULL;
646     } else if (r < 0) {
647         PyErr_SetString(PyExc_RuntimeError, "Error querying journal");
648         return NULL;
649     }
650
651     const void *uniq;
652     size_t uniq_len;
653     const char *delim_ptr;
654     PyObject *value_set, *key, *value;
655     value_set = PySet_New(0);
656
657 #if PY_MAJOR_VERSION >=3
658     key = PyUnicode_FromString(query);
659 #else
660     key = PyString_FromString(query);
661 #endif
662
663     SD_JOURNAL_FOREACH_UNIQUE(self->j, uniq, uniq_len) {
664         delim_ptr = memchr(uniq, '=', uniq_len);
665         value = PyBytes_FromStringAndSize(delim_ptr + 1, (const char*) uniq + uniq_len - (delim_ptr + 1));
666         PySet_Add(value_set, value);
667         Py_DECREF(value);
668     }
669     Py_DECREF(key);
670     return value_set;
671 }
672 #endif //def SD_JOURNAL_FOREACH_UNIQUE
673
674 PyDoc_STRVAR(Journal_log_level__doc__,
675 "log_level(level) -> None\n\n"
676 "Sets maximum log level by setting matches for PRIORITY.");
677 static PyObject *
678 Journal_log_level(Journal *self, PyObject *args)
679 {
680     int level;
681     if (! PyArg_ParseTuple(args, "i", &level))
682         return NULL;
683
684     if (level < 0 || level > 7) {
685         PyErr_SetString(PyExc_ValueError, "Log level should be 0 <= level <= 7");
686         return NULL;
687     }
688     int i;
689     char level_str[2];
690     PyObject *arg, *keywds;
691     for(i = 0; i <= level; i++) {
692         sprintf(level_str, "%i", i);
693         arg = PyTuple_New(0);
694         keywds = Py_BuildValue("{s:s}", "PRIORITY", level_str);
695         Journal_add_match(self, arg, keywds);
696         Py_DECREF(arg);
697         Py_DECREF(keywds);
698         if (PyErr_Occurred())
699             return NULL;
700     }
701     Py_RETURN_NONE;
702 }
703
704 PyDoc_STRVAR(Journal_this_boot__doc__,
705 "this_boot() -> None\n\n"
706 "Sets match filter for the current _BOOT_ID.");
707 static PyObject *
708 Journal_this_boot(Journal *self, PyObject *args)
709 {
710     sd_id128_t sd_id;
711     int r;
712     r = sd_id128_get_boot(&sd_id);
713     if (r == -EIO) {
714         PyErr_SetString(PyExc_IOError, "Error getting current boot ID");
715         return NULL;
716     } else if (r < 0) {
717         PyErr_SetString(PyExc_RuntimeError, "Error getting current boot ID");
718         return NULL;
719     }
720
721     char bootid[33];
722     sd_id128_to_string(sd_id, bootid);
723
724     PyObject *arg, *keywds;
725     arg = PyTuple_New(0);
726     keywds = Py_BuildValue("{s:s}", "_BOOT_ID", bootid);
727     Journal_add_match(self, arg, keywds);
728     Py_DECREF(arg);
729     Py_DECREF(keywds);
730     if (PyErr_Occurred())
731         return NULL;
732
733     Py_RETURN_NONE;
734 }
735
736 PyDoc_STRVAR(Journal_this_machine__doc__,
737 "this_machine() -> None\n\n"
738 "Sets match filter for the current _MACHINE_ID.");
739 static PyObject *
740 Journal_this_machine(Journal *self, PyObject *args)
741 {
742     sd_id128_t sd_id;
743     int r;
744     r = sd_id128_get_machine(&sd_id);
745     if (r == -EIO) {
746         PyErr_SetString(PyExc_IOError, "Error getting current boot ID");
747         return NULL;
748     } else if (r < 0) {
749         PyErr_SetString(PyExc_RuntimeError, "Error getting current boot ID");
750         return NULL;
751     }
752
753     char machineid[33];
754     sd_id128_to_string(sd_id, machineid);
755
756     PyObject *arg, *keywds;
757     arg = PyTuple_New(0);
758     keywds = Py_BuildValue("{s:s}", "_MACHINE_ID", machineid);
759     Journal_add_match(self, arg, keywds);
760     Py_DECREF(arg);
761     Py_DECREF(keywds);
762     if (PyErr_Occurred())
763         return NULL;
764
765     Py_RETURN_NONE;
766 }
767
768 static PyObject *
769 Journal_get_data_threshold(Journal *self, void *closure)
770 {
771     size_t cvalue;
772     PyObject *value;
773     int r;
774
775     r = sd_journal_get_data_threshold(self->j, &cvalue);
776     if (r < 0){
777         PyErr_SetString(PyExc_RuntimeError, "Error getting data threshold");
778         return NULL;
779     }
780
781 #if PY_MAJOR_VERSION >=3
782     value = PyLong_FromSize_t(cvalue);
783 #else
784     value = PyInt_FromSize_t(cvalue);
785 #endif
786     return value;
787 }
788
789 static int
790 Journal_set_data_threshold(Journal *self, PyObject *value, void *closure)
791 {
792     if (value == NULL) {
793         PyErr_SetString(PyExc_TypeError, "Cannot delete data threshold");
794         return -1;
795     }
796 #if PY_MAJOR_VERSION >=3
797     if (! PyLong_Check(value)){
798 #else
799     if (! PyInt_Check(value)){
800 #endif
801         PyErr_SetString(PyExc_TypeError, "Data threshold must be int");
802         return -1;
803     }
804     int r;
805 #if PY_MAJOR_VERSION >=3
806     r = sd_journal_set_data_threshold(self->j, (size_t) PyLong_AsLong(value));
807 #else
808     r = sd_journal_set_data_threshold(self->j, (size_t) PyInt_AsLong(value));
809 #endif
810     if (r < 0){
811         PyErr_SetString(PyExc_RuntimeError, "Error setting data threshold");
812         return -1;
813     }
814     return 0;
815 }
816
817 static PyGetSetDef Journal_getseters[] = {
818     {"data_threshold",
819     (getter)Journal_get_data_threshold,
820     (setter)Journal_set_data_threshold,
821     "data threshold",
822     NULL},
823     {NULL}
824 };
825
826 static PyMethodDef Journal_methods[] = {
827     {"get_next", (PyCFunction)Journal_get_next, METH_VARARGS,
828     Journal_get_next__doc__},
829     {"get_previous", (PyCFunction)Journal_get_previous, METH_VARARGS,
830     Journal_get_previous__doc__},
831     {"add_match", (PyCFunction)Journal_add_match, METH_VARARGS|METH_KEYWORDS,
832     Journal_add_match__doc__},
833     {"add_disjunction", (PyCFunction)Journal_add_disjunction, METH_NOARGS,
834     Journal_add_disjunction__doc__},
835     {"flush_matches", (PyCFunction)Journal_flush_matches, METH_NOARGS,
836     Journal_flush_matches__doc__},
837     {"seek", (PyCFunction)Journal_seek, METH_VARARGS | METH_KEYWORDS,
838     Journal_seek__doc__},
839     {"seek_realtime", (PyCFunction)Journal_seek_realtime, METH_VARARGS,
840     Journal_seek_realtime__doc__},
841     {"seek_monotonic", (PyCFunction)Journal_seek_monotonic, METH_VARARGS,
842     Journal_seek_monotonic__doc__},
843     {"wait", (PyCFunction)Journal_wait, METH_VARARGS,
844     Journal_wait__doc__},
845     {"seek_cursor", (PyCFunction)Journal_seek_cursor, METH_VARARGS,
846     Journal_seek_cursor__doc__},
847 #ifdef SD_JOURNAL_FOREACH_UNIQUE
848     {"query_unique", (PyCFunction)Journal_query_unique, METH_VARARGS,
849     Journal_query_unique__doc__},
850 #endif
851     {"log_level", (PyCFunction)Journal_log_level, METH_VARARGS,
852     Journal_log_level__doc__},
853     {"this_boot", (PyCFunction)Journal_this_boot, METH_NOARGS,
854     Journal_this_boot__doc__},
855     {"this_machine", (PyCFunction)Journal_this_machine, METH_NOARGS,
856     Journal_this_machine__doc__},
857     {NULL}  /* Sentinel */
858 };
859
860 static PyTypeObject JournalType = {
861     PyVarObject_HEAD_INIT(NULL, 0)
862     "_reader.Journal",           /*tp_name*/
863     sizeof(Journal),                  /*tp_basicsize*/
864     0,                                /*tp_itemsize*/
865     (destructor)Journal_dealloc,      /*tp_dealloc*/
866     0,                                /*tp_print*/
867     0,                                /*tp_getattr*/
868     0,                                /*tp_setattr*/
869     0,                                /*tp_compare*/
870     0,                                /*tp_repr*/
871     0,                                /*tp_as_number*/
872     0,                                /*tp_as_sequence*/
873     0,                                /*tp_as_mapping*/
874     0,                                /*tp_hash */
875     0,                                /*tp_call*/
876     0,                                /*tp_str*/
877     0,                                /*tp_getattro*/
878     0,                                /*tp_setattro*/
879     0,                                /*tp_as_buffer*/
880     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,/*tp_flags*/
881     Journal__doc__,                   /* tp_doc */
882     0,                                /* tp_traverse */
883     0,                                /* tp_clear */
884     0,                                /* tp_richcompare */
885     0,                                /* tp_weaklistoffset */
886     Journal_iter,                     /* tp_iter */
887     Journal_iternext,                 /* tp_iternext */
888     Journal_methods,                  /* tp_methods */
889     0,                                /* tp_members */
890     Journal_getseters,                /* tp_getset */
891     0,                                /* tp_base */
892     0,                                /* tp_dict */
893     0,                                /* tp_descr_get */
894     0,                                /* tp_descr_set */
895     0,                                /* tp_dictoffset */
896     (initproc)Journal_init,           /* tp_init */
897     0,                                /* tp_alloc */
898     PyType_GenericNew,                /* tp_new */
899 };
900
901 #if PY_MAJOR_VERSION >= 3
902 static PyModuleDef _reader_module = {
903     PyModuleDef_HEAD_INIT,
904     "_reader",
905     "Module that reads systemd journal similar to journalctl.",
906     -1,
907     NULL, NULL, NULL, NULL, NULL
908 };
909 #endif
910
911 PyMODINIT_FUNC
912 #if PY_MAJOR_VERSION >= 3
913 PyInit__reader(void)
914 #else
915 init_reader(void) 
916 #endif
917 {
918     PyObject* m;
919
920     PyDateTime_IMPORT;
921
922     if (PyType_Ready(&JournalType) < 0)
923 #if PY_MAJOR_VERSION >= 3
924         return NULL;
925 #else
926         return;
927 #endif
928
929 #if PY_MAJOR_VERSION >= 3
930     m = PyModule_Create(&_reader_module);
931     if (m == NULL)
932         return NULL;
933 #else
934     m = Py_InitModule3("_reader", NULL,
935                    "Module that reads systemd journal similar to journalctl.");
936     if (m == NULL)
937         return;
938 #endif
939
940     Py_INCREF(&JournalType);
941     PyModule_AddObject(m, "_Journal", (PyObject *)&JournalType);
942     PyModule_AddIntConstant(m, "NOP", SD_JOURNAL_NOP);
943     PyModule_AddIntConstant(m, "APPEND", SD_JOURNAL_APPEND);
944     PyModule_AddIntConstant(m, "INVALIDATE", SD_JOURNAL_INVALIDATE);
945     PyModule_AddIntConstant(m, "LOCAL_ONLY", SD_JOURNAL_LOCAL_ONLY);
946     PyModule_AddIntConstant(m, "RUNTIME_ONLY", SD_JOURNAL_RUNTIME_ONLY);
947     PyModule_AddIntConstant(m, "SYSTEM_ONLY", SD_JOURNAL_SYSTEM_ONLY);
948
949 #if PY_MAJOR_VERSION >= 3
950     return m;
951 #endif
952 }