---

py_linuxtuples.c

Go to the documentation of this file.

/*****************************************************************
 *
 * LinuxTuples - a Linda-esque tuple system for Linux clusters
 * Copyright (c) 2003, Will Ware <wware@alum.mit.edu>
 * All rights reserved.
 * 
 *    Redistribution and use in source and binary forms, with or
 *    without modification, are permitted provided that the following
 *    conditions are met:
 * 
 *    + Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 *    + Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 *
 *    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
 *    CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 *    INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *    MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *    DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 *    CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
 *    USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 *    AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 *    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 *    IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 *    THE POSSIBILITY OF SUCH DAMAGE.
 *
 *****************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <sys/time.h>

#include "Python.h"
#include "tuple.h"


staticforward PyTypeObject CtxType;

typedef struct {
        PyObject_HEAD;
        struct context ctx;
} CtxObject;


static char ctx_put_doc_string[];
static char ctx_get_doc_string[];
static char ctx_read_doc_string[];
static char ctx_get_nb_doc_string[];
static char ctx_read_nb_doc_string[];
static char ctx_dump_doc_string[];
static char ctx_log_doc_string[];
static PyMethodDef linuxtuples_methods[];
static PyMethodDef ctx_methods[];

static PyObject *ctx_getattr(CtxObject *obj, char *name);
static PyObject *new_ctx(PyObject *self, PyObject *args);
static void ctx_dealloc(PyObject *self);
static struct tuple *PyTuple_to_LinuxTuple(PyObject *pytup, int puttable);
static PyObject *LinuxTuple_to_PyTuple(struct tuple *t);
static PyObject *ctx_put_tuple(PyObject *self, PyObject *args);
static PyObject * ctx_get_read(CtxObject *pyctx,
                               PyObject *args,
                               struct tuple * (*func)(struct tuple *,
                                                      struct context *),
                               int blocking);
static PyObject *ctx_get_tuple(PyObject *self, PyObject *args);
static PyObject *ctx_read_tuple(PyObject *self, PyObject *args);
static PyObject *ctx_get_nb_tuple(PyObject *self, PyObject *args);
static PyObject *ctx_read_nb_tuple(PyObject *self, PyObject *args);
static PyObject *ctx_dump_tuple_space(PyObject *self, PyObject *args);
static PyObject *ctx_tuple_server_log(PyObject *self, PyObject *args);

static char py_random_int_doc_string[];
static PyObject *py_random_int(PyObject *self, PyObject *args);

void initlinuxtuples(void);


static char
linuxtuples_doc_string[] =
"This is the Python client API for the linuxtuples tuple server. The\n"
"connect() method returns a connection to the tuple server. The\n"
"random() method returns a 32-bit integer taken from /dev/urandom.";


static char
ctx_doc_string[] =
"This is a connection to a tuple server. Its methods give access to\n"
"tuple space.\n"
"\n"
"The put(tuple) method lets you put a tuple into the tuple space.\n"
"get(template) removes a tuple that matches the template (where None is\n"
"used as a wildcard), blocking until a matching tuple becomes\n"
"available. read(template) is like get(), but it returns a copy of the\n"
"tuple, leaving the original in tuple space.\n"
"\n"
"get_nonblocking() and read_nonblocking() are non-blocking versions of\n"
"get() and read(), which return None if a matching tuple is not\n"
"available.\n"
"\n"
"The dump() method returns a list of the tuples in tuple space. If\n"
"supplied with a list of templates as an argument, it will return a\n"
"list of only those tuples that match at least one template.\n"
"\n"
"The log() method prints a running log of tuple server activity to\n"
"stdout. It should be called in a \"while 1:\" loop.";


static PyMethodDef ctx_methods[] = {
        {"put", ctx_put_tuple, METH_VARARGS,
         ctx_put_doc_string},
        {"get", ctx_get_tuple, METH_VARARGS,
         ctx_get_doc_string},
        {"read", ctx_read_tuple, METH_VARARGS,
         ctx_read_doc_string},
        {"get_nonblocking", ctx_get_nb_tuple, METH_VARARGS,
         ctx_get_nb_doc_string},
        {"read_nonblocking", ctx_read_nb_tuple, METH_VARARGS,
         ctx_read_nb_doc_string},
        {"dump", ctx_dump_tuple_space, METH_VARARGS,
         ctx_dump_doc_string},
        {"log", ctx_tuple_server_log, METH_VARARGS,
         ctx_log_doc_string},
        {NULL, NULL, 0, NULL}           /* sentinel */
};

static PyObject *
ctx_getattr(CtxObject *obj, char *name)
{
        if (strcmp(name, "__doc__") == 0) {
                return PyString_FromString(ctx_doc_string);
        }
        return Py_FindMethod(ctx_methods, (PyObject *)obj, name);
}


#define SETENV_STRING \
"\nUnable to find the environment variables (LINUXTUPLES_HOST,\n" \
"LINUXTUPLES_PORT). Please set them."


static char
new_ctx_doc_string[] =
"conn = connect()\n"
"conn = connect(int)\n"
"Return a connection to the tuple server.";

static PyObject*
new_ctx(PyObject* self, PyObject* args)
{
        CtxObject* pyctx;
        
        if (!PyArg_ParseTuple(args,"")) 
                return NULL;
        
        pyctx = PyObject_New(CtxObject, &CtxType);
        
        if (get_server_portnumber(&pyctx->ctx)) {
                PyErr_SetString(PyExc_ImportError, SETENV_STRING);
                return NULL;
        };

        return (PyObject*)pyctx;
}

static void
ctx_dealloc(PyObject* self)
{
        CtxObject *pyctx = (CtxObject*) self;
        close(pyctx->ctx.sock);
        PyObject_Del(self);
}

static PyTypeObject CtxType = {
        PyObject_HEAD_INIT(NULL)
        0,
        "Ctx",
        sizeof(CtxObject),
        0,
        ctx_dealloc, /*tp_dealloc*/
        0,          /*tp_print*/
        (getattrfunc) ctx_getattr, /*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 */
};



static struct tuple *
PyTuple_to_LinuxTuple(PyObject *pytup, int puttable)
{
        int i, len;
        struct tuple *t;
        len = PyTuple_Size(pytup);
        t = malloc(sizeof(struct tuple));
        if (t == NULL) {
                return (struct tuple*) PyErr_NoMemory();
        }
        t->tag = I_AM_A_TUPLE;
        t->num_elts = len;
        t->elements = malloc(t->num_elts * sizeof(struct element));
        if (t->elements == NULL) {
                return (struct tuple *) PyErr_NoMemory();
        }
        t->string_space = NULL;
        t->string_length = 0;

        for (i = 0; i < len; i++) {
                PyObject *elem;
                elem = PyTuple_GetItem(pytup, i);
                if (elem == Py_None) {
                        if (puttable)
                                goto bad_element;
                        t->elements[i].tag = '?';
                }
                else if (PyInt_Check(elem)) {
                        t->elements[i].tag = 'i';
                        t->elements[i].data.i = PyInt_AsLong(elem);
                }
                else if (PyFloat_Check(elem)) {
                        t->elements[i].tag = 'd';
                        t->elements[i].data.d = PyFloat_AsDouble(elem);
                }
                else if (PyString_Check(elem)) {
                        int n = PyString_Size(elem);
                        t->elements[i].tag = 's';
                        t->elements[i].data.s.ptr = PyString_AsString(elem);
                        t->elements[i].data.s.len = n;
                        t->string_length += n;
                }
                else {
                  bad_element:
                        PyErr_SetString(PyExc_RuntimeError,
                                        "Bad element in LinuxTuples tuple");
                        return NULL;
                }
        }
        return t;
}


static PyObject *
LinuxTuple_to_PyTuple(struct tuple * t)
{
        PyObject *pytup;
        int i;
        /*
         * Unpack the Linuxtuples tuple to a Python tuple.
         */
        pytup = PyTuple_New(t->num_elts);
        if (pytup == NULL)
                return PyErr_NoMemory();
        for (i = 0; i < t->num_elts; i++) {
                PyObject *ob;
                switch (t->elements[i].tag) {
                case '?':
                        Py_INCREF(Py_None);
                        PyTuple_SetItem(pytup, i, Py_None);
                        break;
                case 'i':
                        ob = PyInt_FromLong(t->elements[i].data.i);
                        if (ob == NULL)
                                return PyErr_NoMemory();
                        PyTuple_SetItem(pytup, i, ob);
                        break;
                case 'd':
                        ob = PyFloat_FromDouble(t->elements[i].data.d);
                        if (ob == NULL)
                                return PyErr_NoMemory();
                        PyTuple_SetItem(pytup, i, ob);
                        break;
                case 's':
                        ob = PyString_FromStringAndSize(
                                t->elements[i].data.s.ptr,
                                t->elements[i].data.s.len);
                        if (ob == NULL)
                                return PyErr_NoMemory();
                        PyTuple_SetItem(pytup, i, ob);
                        break;
                }
        }
        return pytup;
}


static char
ctx_put_doc_string[] =
"conn.put(tuple)\n"
"Put a tuple into tuple space.";

static PyObject *
ctx_put_tuple(PyObject *self, PyObject *args)
{
        CtxObject *pyctx = (CtxObject*) self;
        PyObject *pytup;
        struct tuple *t;

        if (!PyArg_ParseTuple(args, "O", &pytup))
                return NULL;
        if (!PyTuple_Check(pytup)) {
                PyErr_SetString(PyExc_TypeError,
                                "argument must be a tuple");
                return NULL;
        }

        t = PyTuple_to_LinuxTuple(pytup, 1);
        if (t == NULL) {
                return NULL;
        }

        /*
         * Put the Linuxtuples tuple in the tuple space.
         */

        if (put_tuple(t, &pyctx->ctx)) {
                PyErr_SetString(PyExc_RuntimeError, "put() failed");
                return NULL;
        }
        destroy_tuple(t);

        Py_INCREF(Py_None);
        return Py_None;
}



static PyObject *
ctx_get_read(CtxObject *pyctx,
             PyObject *args,
             struct tuple * (*func)(struct tuple *,
                                    struct context *),
             int blocking)
{
        PyObject *pytup;
        struct tuple *s, *t;

        if (!PyArg_ParseTuple(args, "O", &pytup))
                return NULL;
        if (!PyTuple_Check(pytup)) {
                PyErr_SetString(PyExc_TypeError,
                                "argument must be a tuple");
                return NULL;
        }

        /*
         * Build a LinuxTuples tuple template.
         */
        s = PyTuple_to_LinuxTuple(pytup, 0);
        if (s == NULL) {
                return NULL;
        }

        /*
         * Get a Linuxtuples tuple from the tuple space.
         */
        t = (*func)(s, &pyctx->ctx);
        destroy_tuple(s);
        if (t == (struct tuple *) -1) {
                goto abject_failure;
        }
        if (!blocking && t == NULL) {
                Py_INCREF(Py_None);
                return Py_None;
        }
        if (t == NULL) {
        abject_failure:
                PyErr_SetString(PyExc_RuntimeError, "get() or read() failed");
                return NULL;
        }

        /*
         * Unpack the Linuxtuples tuple to a Python tuple.
         */
        pytup = LinuxTuple_to_PyTuple(t);
        destroy_tuple(t);
        return pytup;
}


static char
ctx_get_doc_string[] =
"tuple = conn.get(template)\n"
"Get a tuple from tuple space. Items in the returned tuple\n"
"must match any non-None items in the template. Nones are\n"
"wildcards. This call blocks until a matching tuple is found.";

static PyObject *
ctx_get_tuple(PyObject *self, PyObject *args)
{
        return ctx_get_read((CtxObject*)self, args, get_tuple, 1);
}

static char
ctx_read_doc_string[] =
"tuple = conn.read(template)\n"
"Read a copy of a tuple from tuple space. Items in the\n"
"returned tuple must match any non-None items in the template.\n"
"Nones are wildcards. This call blocks until a matching\n"
"tuple is found.";

static PyObject *
ctx_read_tuple(PyObject *self, PyObject *args)
{
        return ctx_get_read((CtxObject*)self, args, read_tuple, 1);
}

static char
ctx_get_nb_doc_string[] =
"tuple = conn.get_nonblocking(template)\n"
"Get a tuple from tuple space. Items in the returned tuple\n"
"must match any non-None items in the template. Nones are\n"
"wildcards. If no matching tuple is found, returns None.";

static PyObject *
ctx_get_nb_tuple(PyObject *self, PyObject *args)
{
        return ctx_get_read((CtxObject*)self, args, get_nb_tuple, 0);
}

static char
ctx_read_nb_doc_string[] =
"tuple = conn.read_nonblocking(template)\n"
"Read a copy of a tuple from tuple space. Items in the\n"
"returned tuple must match any non-None items in the template.\n"
"Nones are wildcards. If no matching tuple is found, returns\n"
"None.";

static PyObject *
ctx_read_nb_tuple(PyObject *self, PyObject *args)
{
        return ctx_get_read((CtxObject*)self, args, read_nb_tuple, 0);
}

static char
ctx_dump_doc_string[] =
"tuple_list = conn.dump( [template_list] )\n"
"Return a list of the tuples in the tuple space. If no template\n"
"list is given, return all the tuples. If there is a template\n"
"list, return only the tuples that match at least one template.";

static PyObject *
ctx_dump_tuple_space(PyObject *self, PyObject *args)
{
        PyObject *pylst = NULL, *pytup;
        CtxObject *pyctx;
        struct tuple_list *slist, *tlist, *x;
        int i, count, listsize;

        pyctx = (CtxObject*)self;
        if (!PyArg_ParseTuple(args, "|O", &pylst))
                return NULL;
        if (pylst != NULL) {
                if (!PyList_Check(pylst)) {
                        PyErr_SetString(PyExc_TypeError,
                                        "argument must be a list");
                        return NULL;
                }
                listsize = PyList_Size(pylst);
        } else {
                listsize = 0;
        }
                        

        /* Assemble a list of templates from the arg.
         */
        slist = NULL;
        for (i = 0; i < listsize; i++) {
                pytup = PyList_GetItem(pylst, i);
                if (!PyTuple_Check(pytup)) {
                        PyErr_SetString(PyExc_TypeError,
                                        "list members must be tuples");
                        return NULL;
                }
                x = malloc(sizeof(struct tuple_list));
                if (x == NULL)
                        return PyErr_NoMemory();
                x->tup = PyTuple_to_LinuxTuple(pytup, 0);
                x->next = slist;
                slist = x;
        }

        x = slist;
        while (x != NULL) {
                x = x->next;
        }

        /* Do a dump request to the server.
         */
        tlist = dump_tuple_space(slist, &pyctx->ctx);
        while (slist) {
                x = slist;
                slist = slist->next;
                free(x);
        }

        count = 0;
        x = tlist;
        while (x != NULL) {
                count++;
                x = x->next;
        }
        pylst = PyList_New(count);
        if (pylst == NULL)
                return PyErr_NoMemory();
        for (i = 0, x = tlist; x != NULL; x = x->next, i++)
                PyList_SetItem(pylst, i,
                               LinuxTuple_to_PyTuple(x->tup));

        while (tlist) {
                x = tlist;
                tlist = tlist->next;
                free(x);
        }

        return pylst;
}

static char
ctx_log_doc_string[] =
"Dump a continuous log of tuple space activity to stdout. Call this\n"
"method in a \"while 1:\" loop. Looping in Python rather than C\n"
"means that you can break out of the loop easily with control-C,\n"
"and you can put other code in the loop.";

static PyObject *
ctx_tuple_server_log(PyObject *self, PyObject *args)
{
        CtxObject *pyctx = (CtxObject*)self;
        if (!PyArg_ParseTuple(args, ""))
                return NULL;
        tuple_server_log(stdout, &pyctx->ctx);
        Py_INCREF(Py_None);
        return Py_None;
}

static char
py_random_int_doc_string[] =
"Return a 32-bit random integer, taken from /dev/urandom.";

static PyObject *
py_random_int(PyObject *self, PyObject *args)
{
        if (!PyArg_ParseTuple(args, ""))
                return NULL;
        return PyInt_FromLong(random_int());
}



static PyMethodDef
linuxtuples_methods[] = {
        {"connect", new_ctx, METH_VARARGS, new_ctx_doc_string},
        {"random", py_random_int, METH_VARARGS, py_random_int_doc_string},
        {NULL, NULL}  /* sentinel */
};


DL_EXPORT(void)
initlinuxtuples()
{
        PyObject *m, *d;

        CtxType.ob_type = &PyType_Type;
        m = Py_InitModule("linuxtuples", linuxtuples_methods);
        d = PyModule_GetDict(m);
        PyDict_SetItemString(d, "__doc__",
                             PyString_FromString(linuxtuples_doc_string));
}

---