From ddb3c48f1adf3e3202ad904ba9de4027c7e140df Mon Sep 17 00:00:00 2001 From: Jelmer Vernooij Date: Thu, 23 Sep 2010 16:50:36 -0700 Subject: pytevent: Fill in client side fnuctions. --- lib/tevent/pytevent.c | 445 ++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 393 insertions(+), 52 deletions(-) (limited to 'lib') diff --git a/lib/tevent/pytevent.c b/lib/tevent/pytevent.c index 733e6ec36b..b80f232a3b 100644 --- a/lib/tevent/pytevent.c +++ b/lib/tevent/pytevent.c @@ -1,4 +1,4 @@ -/* +/* Unix SMB/CIFS implementation. Python bindings for tevent @@ -30,16 +30,41 @@ typedef struct { struct tevent_context *ev; } TeventContext_Object; +typedef struct { + PyObject_HEAD + struct tevent_queue *queue; +} TeventQueue_Object; + +typedef struct { + PyObject_HEAD + struct tevent_req *req; +} TeventReq_Object; + +typedef struct { + PyObject_HEAD + struct tevent_signal *signal; +} TeventSignal_Object; + +typedef struct { + PyObject_HEAD + struct tevent_timer *timer; +} TeventTimer_Object; + +typedef struct { + PyObject_HEAD + struct tevent_fd *fd; +} TeventFd_Object; + +staticforward PyTypeObject TeventContext_Type; +staticforward PyTypeObject TeventReq_Type; +staticforward PyTypeObject TeventQueue_Type; +staticforward PyTypeObject TeventSignal_Type; +staticforward PyTypeObject TeventTimer_Type; +staticforward PyTypeObject TeventFd_Type; + static int py_context_init(struct tevent_context *ev) { - PyObject *ret, *self; /* FIXME */ - ret = PyObject_CallFunction(self, ""); - if (ret == NULL) { - return -1; - } else { - return 0; - } } static struct tevent_fd *py_add_fd(struct tevent_context *ev, @@ -130,30 +155,83 @@ const static struct tevent_ops py_tevent_ops = { static PyObject *py_register_backend(PyObject *self, PyObject *args) { - /* FIXME */ + PyObject *name, *py_backend; + + if (!PyArg_ParseTuple(args, "O", &py_backend)) + return NULL; + + name = PyObject_GetAttrString(py_backend, "name"); + if (name == NULL) { + PyErr_SetNone(PyExc_AttributeError); + return NULL; + } + + if (!PyString_Check(name)) { + PyErr_SetNone(PyExc_TypeError); + return NULL; + } + + if (!tevent_register_backend(PyString_AsString(name), &py_tevent_ops)) { /* FIXME: What to do with backend */ + PyErr_SetNone(PyExc_RuntimeError); + return NULL; + } + + Py_RETURN_NONE; } -static PyObject *py_tevent_context_reinitialise(PyObject *self) +static PyObject *py_tevent_context_reinitialise(TeventContext_Object *self) { - /* FIXME */ + int ret = tevent_re_initialise(self->ev); + if (ret != 0) { + PyErr_SetNone(PyExc_RuntimeError); + return NULL; + } Py_RETURN_NONE; } -static PyObject *py_tevent_queue_stop(PyObject *self) +static PyObject *py_tevent_queue_stop(TeventQueue_Object *self) { - /* FIXME */ + tevent_queue_stop(self->queue); Py_RETURN_NONE; } -static PyObject *py_tevent_queue_start(PyObject *self) +static PyObject *py_tevent_queue_start(TeventQueue_Object *self) { - /* FIXME */ + tevent_queue_start(self->queue); Py_RETURN_NONE; } -static PyObject *py_tevent_queue_add(PyObject *self, PyObject *args) +static void py_queue_trigger(struct tevent_req *req, void *private_data) { - /* FIXME */ + PyObject *callback, *ret; + + ret = PyObject_CallFunction(private_data, ""); + Py_XDECREF(ret); +} + +static PyObject *py_tevent_queue_add(TeventQueue_Object *self, PyObject *args) +{ + TeventContext_Object *py_ev; + TeventReq_Object *py_req; + PyObject *trigger; + bool ret; + + if (!PyArg_ParseTuple(args, "O!O!O", + &TeventContext_Type, &py_ev, + &TeventReq_Type, &py_req, + &trigger)) + return NULL; + + Py_INCREF(trigger); + + ret = tevent_queue_add(self->queue, py_ev->ev, py_req->req, + py_queue_trigger, trigger); + if (!ret) { + PyErr_SetString(PyExc_RuntimeError, "queue add failed"); + Py_DECREF(trigger); + return NULL; + } + Py_RETURN_NONE; } @@ -170,36 +248,174 @@ static PyMethodDef py_tevent_queue_methods[] = { static PyObject *py_tevent_context_wakeup_send(PyObject *self, PyObject *args) { /* FIXME */ + Py_RETURN_NONE; } -static PyObject *py_tevent_context_loop_wait(PyObject *self) +static PyObject *py_tevent_context_loop_wait(TeventContext_Object *self) { - /* FIXME */ + if (tevent_loop_wait(self->ev) != 0) { + PyErr_SetNone(PyExc_RuntimeError); + return NULL; + } Py_RETURN_NONE; } -static PyObject *py_tevent_context_loop_once(PyObject *self) +static PyObject *py_tevent_context_loop_once(TeventContext_Object *self) { - /* FIXME */ + if (tevent_loop_once(self->ev) != 0) { + PyErr_SetNone(PyExc_RuntimeError); + return NULL; + } Py_RETURN_NONE; } -static PyObject *py_tevent_context_add_signal(PyObject *self, PyObject *args) +static bool py_tevent_finished(PyObject *callback) { - /* FIXME */ - Py_RETURN_NONE; + PyObject *py_ret; + bool ret; + + py_ret = PyObject_CallFunction(callback, ""); + if (py_ret == NULL) + return true; + ret = PyObject_IsTrue(py_ret); + Py_DECREF(py_ret); + return ret; } -static PyObject *py_tevent_context_add_timer(PyObject *self, PyObject *args) +static PyObject *py_tevent_context_loop_until(TeventContext_Object *self, PyObject *args) { - /* FIXME */ + PyObject *callback; + if (!PyArg_ParseTuple(args, "O", &callback)) + return NULL; + + if (tevent_loop_until(self->ev, py_tevent_finished, callback) != 0) { + PyErr_SetNone(PyExc_RuntimeError); + return NULL; + } + + if (PyErr_Occurred()) + return NULL; + Py_RETURN_NONE; } -static PyObject *py_tevent_context_add_fd(PyObject *self, PyObject *args) +static void py_tevent_signal_handler(struct tevent_context *ev, + struct tevent_signal *se, + int signum, + int count, + void *siginfo, + void *private_data) { - /* FIXME */ + PyObject *callback = (PyObject *)private_data, *ret; + + ret = PyObject_CallFunction(callback, "ii", signum, count); + Py_XDECREF(ret); +} + +static PyObject *py_tevent_context_add_signal(TeventContext_Object *self, PyObject *args) +{ + int signum, sa_flags; + PyObject *handler; + struct tevent_signal *sig; + TeventSignal_Object *ret; + + if (!PyArg_ParseTuple(args, "iiO", &signum, &sa_flags, &handler)) + return NULL; + + Py_INCREF(handler); + sig = tevent_add_signal(self->ev, NULL, signum, sa_flags, + py_tevent_signal_handler, handler); + + ret = PyObject_New(TeventSignal_Object, &TeventSignal_Type); + if (ret == NULL) { + PyErr_NoMemory(); + talloc_free(sig); + return NULL; + } + + ret->signal = sig; + + return (PyObject *)ret; +} + +static void py_timer_handler(struct tevent_context *ev, + struct tevent_timer *te, + struct timeval current_time, + void *private_data) +{ + PyObject *callback = private_data, *ret; + ret = PyObject_CallFunction(callback, "l", te); + Py_XDECREF(ret); +} + +static PyObject *py_tevent_context_add_timer(TeventContext_Object *self, PyObject *args) +{ + TeventTimer_Object *ret; + struct timeval next_event; + struct tevent_timer *timer; + PyObject *handler; + if (!PyArg_ParseTuple(args, "lO", &next_event, &handler)) + return NULL; + + timer = tevent_add_timer(self->ev, NULL, next_event, py_timer_handler, + handler); + if (timer == NULL) { + PyExc_SetNone(PyExc_RuntimeError); + return NULL; + } + + ret = PyObject_New(TeventTimer_Object, &TeventTimer_Type); + if (ret == NULL) { + PyErr_NoMemory(); + talloc_free(timer); + return NULL; + } + ret->timer = timer; + + return (PyObject *)ret; +} + +static void py_fd_handler(struct tevent_context *ev, + struct tevent_fd *fde, + uint16_t flags, + void *private_data) +{ + PyObject *callback = private_data, *ret; + + ret = PyObject_CallFunction(callback, "i", flags); + Py_XDECREF(ret); +} + +static PyObject *py_tevent_context_add_fd(TeventContext_Object *self, PyObject *args) +{ + int fd, flags; + PyObject *handler; + struct tevent_fd *tfd; + TeventFd_Object *ret; + + if (!PyArg_ParseTuple(args, "iiO", &fd, &flags, &handler)) + return NULL; + + tfd = tevent_add_fd(self->ev, NULL, fd, flags, py_fd_handler, handler); + if (tfd == NULL) { + PyErr_SetNone(PyExc_RuntimeError); + return NULL; + } + + ret = PyObject_New(TeventFd_Object, &TeventFd_Type); + if (ret == NULL) { + talloc_free(tfd); + return NULL; + } + ret->fd = tfd; + + return (PyObject *)ret; +} + +static PyObject *py_tevent_context_set_allow_nesting(TeventContext_Object *self) +{ + tevent_loop_allow_nesting(self->ev); Py_RETURN_NONE; } @@ -214,12 +430,16 @@ static PyMethodDef py_tevent_context_methods[] = { METH_NOARGS, "S.loop_wait()" }, { "loop_once", (PyCFunction)py_tevent_context_loop_once, METH_NOARGS, "S.loop_once()" }, + { "loop_until", (PyCFunction)py_tevent_context_loop_until, + METH_VARARGS, "S.loop_until(callback)" }, { "add_signal", (PyCFunction)py_tevent_context_add_signal, METH_VARARGS, "S.add_signal(signum, sa_flags, handler) -> signal" }, { "add_timer", (PyCFunction)py_tevent_context_add_timer, METH_VARARGS, "S.add_timer(next_event, handler) -> timer" }, { "add_fd", (PyCFunction)py_tevent_context_add_fd, METH_VARARGS, "S.add_fd(fd, flags, handler) -> fd" }, + { "allow_nesting", (PyCFunction)py_tevent_context_set_allow_nesting, + METH_NOARGS, "Whether to allow nested tevent loops." }, { NULL }, }; @@ -289,9 +509,12 @@ static PyObject *py_tevent_req_set_endtime(PyObject *self, PyObject *args) Py_RETURN_NONE; } -static PyObject *py_tevent_req_cancel(PyObject *self) +static PyObject *py_tevent_req_cancel(TeventReq_Object *self) { - /* FIXME */ + if (!tevent_req_cancel(self->req)) { + PyErr_SetNone(PyExc_RuntimeError); + return NULL; + } Py_RETURN_NONE; } @@ -319,10 +542,23 @@ static PyMethodDef py_tevent_req_methods[] = { { NULL } }; -static PyObject *py_tevent_queue_get_length(PyObject *self) +static void py_tevent_req_dealloc(TeventReq_Object *self) { - /* FIXME */ - Py_RETURN_NONE; + talloc_free(self->req); + PyObject_DEL(self); +} + +static PyTypeObject TeventReq_Type = { + .tp_name = "tevent.Request", + .tp_basicsize = sizeof(TeventReq_Object), + .tp_methods = py_tevent_req_methods, + .tp_dealloc = (destructor)py_tevent_req_dealloc, + /* FIXME: .tp_new = py_tevent_req_new, */ +}; + +static PyObject *py_tevent_queue_get_length(TeventQueue_Object *self) +{ + return PyInt_FromLong(tevent_queue_length(self->queue)); } static PyGetSetDef py_tevent_queue_getsetters[] = { @@ -331,48 +567,116 @@ static PyGetSetDef py_tevent_queue_getsetters[] = { { NULL }, }; -static PyObject *py_tevent_context_signal_support(PyObject *_self) +static void py_tevent_queue_dealloc(TeventQueue_Object *self) { - TeventContext_Object *self = (TeventContext_Object *)_self; - return PyBool_FromLong(tevent_signal_support(self->ev)); + talloc_free(self->queue); + PyObject_Del(self); } -static PyObject *py_tevent_context_get_allow_nesting(PyObject *self) -{ - /* FIXME */ - Py_RETURN_NONE; -} +static PyTypeObject TeventQueue_Type = { + .tp_name = "tevent.Queue", + .tp_basicsize = sizeof(TeventQueue_Object), + .tp_dealloc = (destructor)py_tevent_queue_dealloc, + .tp_flags = Py_TPFLAGS_DEFAULT, + .tp_getset = py_tevent_queue_getsetters, + .tp_methods = py_tevent_queue_methods, +}; -static PyObject *py_tevent_context_set_allow_nesting(PyObject *self, PyObject *value) +static PyObject *py_tevent_context_signal_support(PyObject *_self) { - /* FIXME */ - Py_RETURN_NONE; + TeventContext_Object *self = (TeventContext_Object *)_self; + return PyBool_FromLong(tevent_signal_support(self->ev)); } static PyGetSetDef py_tevent_context_getsetters[] = { - { "allow_nesting", (getter)py_tevent_context_get_allow_nesting, - (setter)py_tevent_context_set_allow_nesting, - "Whether to allow nested tevent loops." }, { "signal_support", (getter)py_tevent_context_signal_support, NULL, "if this platform and tevent context support signal handling" }, { NULL } }; +static void py_tevent_context_dealloc(TeventContext_Object *self) +{ + talloc_free(self->ev); + Py_Object_Del(self); +} + +static PyObject *py_tevent_context_new(PyTypeObject *type, PyObject *args, PyObject *kwargs) +{ + char *kwnames[] = { "name", NULL }; + char *name = NULL; + struct tevent_context *ev; + TeventContext_Object *ret; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|s", kwnames, &name)) + return NULL; + + if (name == NULL) { + ev = tevent_context_init(NULL); + } else { + ev = tevent_context_init_byname(NULL, name); + } + + if (ev == NULL) { + PyErr_SetNone(PyExc_RuntimeError); + return NULL; + } + + ret = PyObject_New(TeventContext_Object, type); + if (ret == NULL) { + PyErr_NoMemory(); + talloc_free(ev); + return NULL; + } + + ret->ev = ev; + return (PyObject *)ret; +} + static PyTypeObject TeventContext_Type = { + .tp_name = "_tevent.Context", + .tp_new = py_tevent_context_new, + .tp_basicsize = sizeof(TeventContext_Object), + .tp_dealloc = (destructor)py_tevent_context_dealloc, .tp_methods = py_tevent_context_methods, .tp_getset = py_tevent_context_getsetters, + .tp_flags = Py_TPFLAGS_DEFAULT, }; static PyObject *py_set_default_backend(PyObject *self, PyObject *args) { - /* FIXME */ + char *backend_name; + if (!PyArg_ParseTuple(args, "s", &backend_name)) + return NULL; + + tevent_set_default_backend(backend_name); + Py_RETURN_NONE; } static PyObject *py_backend_list(PyObject *self) { - /* FIXME */ - Py_RETURN_NONE; + PyObject *ret; + int i; + const char **backends; + + ret = PyList_New(0); + if (ret == NULL) { + return NULL; + } + + backends = tevent_backend_list(NULL); + if (backends == NULL) { + PyErr_SetNone(PyExc_RuntimeError); + Py_DECREF(ret); + return NULL; + } + for (i = 0; backends[i]; i++) { + PyList_Append(ret, PyString_FromString(backends[i])); + } + + talloc_free(backends); + + return ret; } static PyMethodDef tevent_methods[] = { @@ -385,10 +689,47 @@ static PyMethodDef tevent_methods[] = { { NULL }, }; -int inittevent(void) +int init_tevent(void) { PyObject *m; - m = Py_InitModule3("tevent", tevent_methods, "Tevent integration for twisted."); + + if (PyType_Ready(&TeventContext_Type) < 0) + return; + + if (PyType_Ready(&TeventQueue_Type) < 0) + return; + + if (PyType_Ready(&TeventReq_Type) < 0) + return; + + if (PyType_Ready(&TeventSignal_Type) < 0) + return; + + if (PyType_Ready(&TeventTimer_Type) < 0) + return; + + if (PyType_Ready(&TeventFd_Type) < 0) + return; + + m = Py_InitModule3("_tevent", tevent_methods, "Tevent integration for twisted."); if (m == NULL) return; + + Py_INCREF(&TeventContext_Type); + PyModule_AddObject(m, "Context", (PyObject *)&TeventContext_Type); + + Py_INCREF(&TeventQueue_Type); + PyModule_AddObject(m, "Queue", (PyObject *)&TeventQueue_Type); + + Py_INCREF(&TeventReq_Type); + PyModule_AddObject(m, "Request", (PyObject *)&TeventReq_Type); + + Py_INCREF(&TeventSignal_Type); + PyModule_AddObject(m, "Signal", (PyObject *)&TeventSignal_Type); + + Py_INCREF(&TeventTimer_Type); + PyModule_AddObject(m, "Timer", (PyObject *)&TeventTimer_Type); + + Py_INCREF(&TeventFd_Type); + PyModule_AddObject(m, "Fd", (PyObject *)&TeventFd_Type); } -- cgit