X-Git-Url: http://git.annexia.org/?a=blobdiff_plain;f=generator%2Fgenerator_python.ml;h=6d22c18723135849723f004c15af9a579bb60e5d;hb=c649817586e5b4df53b251d1290422f5ef046045;hp=2a6034d491ce43f931ed1680844d7d29d90ef1e5;hpb=04d8209077d2227eb1d42695ba71147f78987050;p=libguestfs.git diff --git a/generator/generator_python.ml b/generator/generator_python.ml index 2a6034d..6d22c18 100644 --- a/generator/generator_python.ml +++ b/generator/generator_python.ml @@ -1,5 +1,5 @@ (* libguestfs - * Copyright (C) 2009-2010 Red Hat Inc. + * Copyright (C) 2009-2011 Red Hat Inc. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -28,57 +28,20 @@ open Generator_optgroups open Generator_actions open Generator_structs open Generator_c +open Generator_events (* Generate Python C module. *) let rec generate_python_c () = generate_header CStyle LGPLv2plus; pr "\ -#define PY_SSIZE_T_CLEAN 1 -#include - -#if PY_VERSION_HEX < 0x02050000 -typedef int Py_ssize_t; -#define PY_SSIZE_T_MAX INT_MAX -#define PY_SSIZE_T_MIN INT_MIN -#endif +#include #include #include #include -#include \"guestfs.h\" - -#ifndef HAVE_PYCAPSULE_NEW -typedef struct { - PyObject_HEAD - guestfs_h *g; -} Pyguestfs_Object; -#endif - -static guestfs_h * -get_handle (PyObject *obj) -{ - assert (obj); - assert (obj != Py_None); -#ifndef HAVE_PYCAPSULE_NEW - return ((Pyguestfs_Object *) obj)->g; -#else - return (guestfs_h*) PyCapsule_GetPointer(obj, \"guestfs_h\"); -#endif -} - -static PyObject * -put_handle (guestfs_h *g) -{ - assert (g); -#ifndef HAVE_PYCAPSULE_NEW - return - PyCObject_FromVoidPtrAndDesc ((void *) g, (char *) \"guestfs_h\", NULL); -#else - return PyCapsule_New ((void *) g, \"guestfs_h\", NULL); -#endif -} +#include \"guestfs-py.h\" /* This list should be freed (but not the strings) after use. */ static char ** @@ -86,6 +49,9 @@ get_string_list (PyObject *obj) { size_t i, len; char **r; +#ifndef HAVE_PYSTRING_ASSTRING + PyObject *bytes; +#endif assert (obj); @@ -106,8 +72,14 @@ get_string_list (PyObject *obj) return NULL; } - for (i = 0; i < len; ++i) + for (i = 0; i < len; ++i) { +#ifdef HAVE_PYSTRING_ASSTRING r[i] = PyString_AsString (PyList_GetItem (obj, i)); +#else + bytes = PyUnicode_AsUTF8String (PyList_GetItem (obj, i)); + r[i] = PyBytes_AS_STRING (bytes); +#endif + } r[len] = NULL; return r; @@ -123,8 +95,13 @@ put_string_list (char * const * const argv) ; list = PyList_New (argc); - for (i = 0; i < argc; ++i) + for (i = 0; i < argc; ++i) { +#ifdef HAVE_PYSTRING_ASSTRING PyList_SetItem (list, i, PyString_FromString (argv[i])); +#else + PyList_SetItem (list, i, PyUnicode_FromString (argv[i])); +#endif + } return list; } @@ -141,8 +118,13 @@ put_table (char * const * const argv) list = PyList_New (argc >> 1); for (i = 0; i < argc; i += 2) { item = PyTuple_New (2); +#ifdef HAVE_PYSTRING_ASSTRING PyTuple_SetItem (item, 0, PyString_FromString (argv[i])); PyTuple_SetItem (item, 1, PyString_FromString (argv[i+1])); +#else + PyTuple_SetItem (item, 0, PyUnicode_FromString (argv[i])); + PyTuple_SetItem (item, 1, PyUnicode_FromString (argv[i+1])); +#endif PyList_SetItem (list, i >> 1, item); } @@ -159,40 +141,6 @@ free_strings (char **argv) free (argv); } -static PyObject * -py_guestfs_create (PyObject *self, PyObject *args) -{ - guestfs_h *g; - - g = guestfs_create (); - if (g == NULL) { - PyErr_SetString (PyExc_RuntimeError, - \"guestfs.create: failed to allocate handle\"); - return NULL; - } - guestfs_set_error_handler (g, NULL, NULL); - /* This can return NULL, but in that case put_handle will have - * set the Python error string. - */ - return put_handle (g); -} - -static PyObject * -py_guestfs_close (PyObject *self, PyObject *args) -{ - PyObject *py_g; - guestfs_h *g; - - if (!PyArg_ParseTuple (args, (char *) \"O:guestfs_close\", &py_g)) - return NULL; - g = get_handle (py_g); - - guestfs_close (g); - - Py_INCREF (Py_None); - return Py_None; -} - "; let emit_put_list_function typ = @@ -223,16 +171,31 @@ py_guestfs_close (PyObject *self, PyObject *args) function | name, FString -> pr " PyDict_SetItemString (dict, \"%s\",\n" name; + pr "#ifdef HAVE_PYSTRING_ASSTRING\n"; pr " PyString_FromString (%s->%s));\n" - typ name + typ name; + pr "#else\n"; + pr " PyUnicode_FromString (%s->%s));\n" + typ name; + pr "#endif\n" | name, FBuffer -> pr " PyDict_SetItemString (dict, \"%s\",\n" name; + pr "#ifdef HAVE_PYSTRING_ASSTRING\n"; pr " PyString_FromStringAndSize (%s->%s, %s->%s_len));\n" - typ name typ name + typ name typ name; + pr "#else\n"; + pr " PyBytes_FromStringAndSize (%s->%s, %s->%s_len));\n" + typ name typ name; + pr "#endif\n" | name, FUUID -> pr " PyDict_SetItemString (dict, \"%s\",\n" name; + pr "#ifdef HAVE_PYSTRING_ASSTRING\n"; pr " PyString_FromStringAndSize (%s->%s, 32));\n" - typ name + typ name; + pr "#else\n"; + pr " PyBytes_FromStringAndSize (%s->%s, 32));\n" + typ name; + pr "#endif\n" | name, (FBytes|FUInt64) -> pr " PyDict_SetItemString (dict, \"%s\",\n" name; pr " PyLong_FromUnsignedLongLong (%s->%s));\n" @@ -259,8 +222,13 @@ py_guestfs_close (PyObject *self, PyObject *args) pr " PyDict_SetItemString (dict, \"%s\", Py_None);\n" name; pr " }\n" | name, FChar -> + pr "#ifdef HAVE_PYSTRING_ASSTRING\n"; pr " PyDict_SetItemString (dict, \"%s\",\n" name; - pr " PyString_FromStringAndSize (&dirent->%s, 1));\n" name + pr " PyString_FromStringAndSize (&dirent->%s, 1));\n" name; + pr "#else\n"; + pr " PyDict_SetItemString (dict, \"%s\",\n" name; + pr " PyUnicode_FromStringAndSize (&dirent->%s, 1));\n" name; + pr "#endif\n" ) cols; pr " return dict;\n"; pr "};\n"; @@ -279,30 +247,35 @@ py_guestfs_close (PyObject *self, PyObject *args) (* Python wrapper functions. *) List.iter ( - fun (name, style, _, _, _, _, _) -> + fun (name, (ret, args, optargs as style), _, _, _, _, _) -> pr "static PyObject *\n"; pr "py_guestfs_%s (PyObject *self, PyObject *args)\n" name; pr "{\n"; + pr " PyThreadState *py_save = NULL;\n"; pr " PyObject *py_g;\n"; pr " guestfs_h *g;\n"; pr " PyObject *py_r;\n"; - let error_code = - match fst style with - | RErr | RInt _ | RBool _ -> pr " int r;\n"; "-1" - | RInt64 _ -> pr " int64_t r;\n"; "-1" - | RConstString _ | RConstOptString _ -> - pr " const char *r;\n"; "NULL" - | RString _ -> pr " char *r;\n"; "NULL" - | RStringList _ | RHashtable _ -> pr " char **r;\n"; "NULL" - | RStruct (_, typ) -> pr " struct guestfs_%s *r;\n" typ; "NULL" - | RStructList (_, typ) -> - pr " struct guestfs_%s_list *r;\n" typ; "NULL" - | RBufferOut _ -> - pr " char *r;\n"; - pr " size_t size;\n"; - "NULL" in + if optargs <> [] then ( + pr " struct guestfs_%s_argv optargs_s;\n" name; + pr " struct guestfs_%s_argv *optargs = &optargs_s;\n" name; + ); + + (match ret with + | RErr | RInt _ | RBool _ -> pr " int r;\n" + | RInt64 _ -> pr " int64_t r;\n" + | RConstString _ | RConstOptString _ -> + pr " const char *r;\n" + | RString _ -> pr " char *r;\n" + | RStringList _ | RHashtable _ -> pr " char **r;\n" + | RStruct (_, typ) -> pr " struct guestfs_%s *r;\n" typ + | RStructList (_, typ) -> + pr " struct guestfs_%s_list *r;\n" typ + | RBufferOut _ -> + pr " char *r;\n"; + pr " size_t size;\n" + ); List.iter ( function @@ -319,11 +292,36 @@ py_guestfs_close (PyObject *self, PyObject *args) | Bool n -> pr " int %s;\n" n | Int n -> pr " int %s;\n" n | Int64 n -> pr " long long %s;\n" n - ) (snd style); + | Pointer (t, n) -> + pr " long long %s_int64;\n" n; + pr " %s %s;\n" t n + ) args; + + if optargs <> [] then ( + (* XXX This is horrible. We have to use sentinel values on the + * Python side to denote values not set. + *) + (* Since we don't know if Python types will exactly match + * structure types, declare some local variables here. + *) + List.iter ( + function + | Bool n + | Int n -> pr " int optargs_t_%s = -1;\n" n + | Int64 n -> pr " long long optargs_t_%s = -1;\n" n + | String n -> pr " const char *optargs_t_%s = NULL;\n" n + | _ -> assert false + ) optargs + ); pr "\n"; - (* Convert the parameters. *) + if optargs <> [] then ( + pr " optargs_s.bitmask = 0;\n"; + pr "\n" + ); + + (* Convert the required parameters. *) pr " if (!PyArg_ParseTuple (args, (char *) \"O"; List.iter ( function @@ -333,11 +331,25 @@ py_guestfs_close (PyObject *self, PyObject *args) | StringList _ | DeviceList _ -> pr "O" | Bool _ -> pr "i" (* XXX Python has booleans? *) | Int _ -> pr "i" - | Int64 _ -> pr "L" (* XXX Whoever thought it was a good idea to - * emulate C's int/long/long long in Python? - *) + | Int64 _ | Pointer _ -> + (* XXX Whoever thought it was a good idea to + * emulate C's int/long/long long in Python? + *) + pr "L" | BufferIn _ -> pr "s#" - ) (snd style); + ) args; + + (* Optional parameters. *) + if optargs <> [] then ( + List.iter ( + function + | Bool _ | Int _ -> pr "i" + | Int64 _ -> pr "L" + | String _ -> pr "z" (* because we use None to mean not set *) + | _ -> assert false + ) optargs; + ); + pr ":guestfs_%s\",\n" name; pr " &py_g"; List.iter ( @@ -349,8 +361,15 @@ py_guestfs_close (PyObject *self, PyObject *args) | Bool n -> pr ", &%s" n | Int n -> pr ", &%s" n | Int64 n -> pr ", &%s" n + | Pointer (_, n) -> pr ", &%s_int64" n | BufferIn n -> pr ", &%s, &%s_size" n n - ) (snd style); + ) args; + + List.iter ( + function + | Bool n | Int n | Int64 n | String n -> pr ", &optargs_t_%s" n + | _ -> assert false + ) optargs; pr "))\n"; pr " return NULL;\n"; @@ -364,46 +383,106 @@ py_guestfs_close (PyObject *self, PyObject *args) | StringList n | DeviceList n -> pr " %s = get_string_list (py_%s);\n" n n; pr " if (!%s) return NULL;\n" n - ) (snd style); + | Pointer (t, n) -> + pr " %s = (%s) (intptr_t) %s_int64;\n" n t n + ) args; pr "\n"; - pr " r = guestfs_%s " name; + if optargs <> [] then ( + let uc_name = String.uppercase name in + List.iter ( + fun argt -> + let n = name_of_argt argt in + let uc_n = String.uppercase n in + pr " if (optargs_t_%s != " n; + (match argt with + | Bool _ | Int _ | Int64 _ -> pr "-1" + | String _ -> pr "NULL" + | _ -> assert false + ); + pr ") {\n"; + pr " optargs_s.%s = optargs_t_%s;\n" n n; + pr " optargs_s.bitmask |= GUESTFS_%s_%s_BITMASK;\n" uc_name uc_n; + pr " }\n" + ) optargs; + pr "\n" + ); + + (* Release Python GIL while running. This code is from + * libvirt/python/typewrappers.h. Thanks to Dan Berrange for + * showing us how to do this properly. + *) + pr " if (PyEval_ThreadsInitialized ())\n"; + pr " py_save = PyEval_SaveThread ();\n"; + pr "\n"; + + if optargs = [] then + pr " r = guestfs_%s " name + else + pr " r = guestfs_%s_argv " name; generate_c_call_args ~handle:"g" style; pr ";\n"; + pr "\n"; + pr " if (PyEval_ThreadsInitialized ())\n"; + pr " PyEval_RestoreThread (py_save);\n"; + pr "\n"; + List.iter ( function | Pathname _ | Device _ | Dev_or_Path _ | String _ | Key _ | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ | Int64 _ - | BufferIn _ -> () + | BufferIn _ | Pointer _ -> () | StringList n | DeviceList n -> pr " free (%s);\n" n - ) (snd style); - - pr " if (r == %s) {\n" error_code; - pr " PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));\n"; - pr " return NULL;\n"; - pr " }\n"; + ) args; + + (match errcode_of_ret ret with + | `CannotReturnError -> () + | `ErrorIsMinusOne -> + pr " if (r == -1) {\n"; + pr " PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));\n"; + pr " return NULL;\n"; + pr " }\n" + | `ErrorIsNULL -> + pr " if (r == NULL) {\n"; + pr " PyErr_SetString (PyExc_RuntimeError, guestfs_last_error (g));\n"; + pr " return NULL;\n"; + pr " }\n" + ); pr "\n"; - (match fst style with + (match ret with | RErr -> pr " Py_INCREF (Py_None);\n"; pr " py_r = Py_None;\n" | RInt _ - | RBool _ -> pr " py_r = PyInt_FromLong ((long) r);\n" + | RBool _ -> pr " py_r = PyLong_FromLong ((long) r);\n" | RInt64 _ -> pr " py_r = PyLong_FromLongLong (r);\n" - | RConstString _ -> pr " py_r = PyString_FromString (r);\n" + | RConstString _ -> + pr "#ifdef HAVE_PYSTRING_ASSTRING\n"; + pr " py_r = PyString_FromString (r);\n"; + pr "#else\n"; + pr " py_r = PyUnicode_FromString (r);\n"; + pr "#endif\n" | RConstOptString _ -> - pr " if (r)\n"; + pr " if (r) {\n"; + pr "#ifdef HAVE_PYSTRING_ASSTRING\n"; pr " py_r = PyString_FromString (r);\n"; - pr " else {\n"; + pr "#else\n"; + pr " py_r = PyUnicode_FromString (r);\n"; + pr "#endif\n"; + pr " } else {\n"; pr " Py_INCREF (Py_None);\n"; pr " py_r = Py_None;\n"; pr " }\n" | RString _ -> + pr "#ifdef HAVE_PYSTRING_ASSTRING\n"; pr " py_r = PyString_FromString (r);\n"; + pr "#else\n"; + pr " py_r = PyUnicode_FromString (r);\n"; + pr "#endif\n"; pr " free (r);\n" | RStringList _ -> pr " py_r = put_string_list (r);\n"; @@ -418,7 +497,11 @@ py_guestfs_close (PyObject *self, PyObject *args) pr " py_r = put_table (r);\n"; pr " free_strings (r);\n" | RBufferOut _ -> + pr "#ifdef HAVE_PYSTRING_ASSTRING\n"; pr " py_r = PyString_FromStringAndSize (r, size);\n"; + pr "#else\n"; + pr " py_r = PyBytes_FromStringAndSize (r, size);\n"; + pr "#endif\n"; pr " free (r);\n" ); @@ -431,6 +514,10 @@ py_guestfs_close (PyObject *self, PyObject *args) pr "static PyMethodDef methods[] = {\n"; pr " { (char *) \"create\", py_guestfs_create, METH_VARARGS, NULL },\n"; pr " { (char *) \"close\", py_guestfs_close, METH_VARARGS, NULL },\n"; + pr " { (char *) \"set_event_callback\",\n"; + pr " py_guestfs_set_event_callback, METH_VARARGS, NULL },\n"; + pr " { (char *) \"delete_event_callback\",\n"; + pr " py_guestfs_delete_event_callback, METH_VARARGS, NULL },\n"; List.iter ( fun (name, _, _, _, _, _, _) -> pr " { (char *) \"%s\", py_guestfs_%s, METH_VARARGS, NULL },\n" @@ -442,15 +529,47 @@ py_guestfs_close (PyObject *self, PyObject *args) (* Init function. *) pr "\ +#if PY_MAJOR_VERSION >= 3 +static struct PyModuleDef moduledef = { + PyModuleDef_HEAD_INIT, + \"libguestfsmod\", /* m_name */ + \"libguestfs module\", /* m_doc */ + -1, /* m_size */ + methods, /* m_methods */ + NULL, /* m_reload */ + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL, /* m_free */ +}; +#endif + +static PyObject * +moduleinit (void) +{ + PyObject *m; + +#if PY_MAJOR_VERSION >= 3 + m = PyModule_Create (&moduledef); +#else + m = Py_InitModule ((char *) \"libguestfsmod\", methods); +#endif + + return m; /* m might be NULL if module init failed */ +} + +#if PY_MAJOR_VERSION >= 3 +PyMODINIT_FUNC +PyInit_libguestfsmod (void) +{ + return moduleinit (); +} +#else void initlibguestfsmod (void) { - static int initialized = 0; - - if (initialized) return; - Py_InitModule ((char *) \"libguestfsmod\", methods); - initialized = 1; + (void) moduleinit (); } +#endif " (* Generate Python module. *) @@ -458,11 +577,11 @@ and generate_python_py () = generate_header HashStyle LGPLv2plus; pr "\ -u\"\"\"Python bindings for libguestfs +\"\"\"Python bindings for libguestfs import guestfs g = guestfs.GuestFS () -g.add_drive (\"guest.img\") +g.add_drive_opts (\"guest.img\", format=\"raw\") g.launch () parts = g.list_partitions () @@ -492,10 +611,10 @@ RuntimeError exceptions. To create a guestfs handle you usually have to perform the following sequence of calls: -# Create the handle, call add_drive at least once, and possibly +# Create the handle, call add_drive* at least once, and possibly # several times if the guest has multiple block devices: g = guestfs.GuestFS () -g.add_drive (\"guest.img\") +g.add_drive_opts (\"guest.img\", format=\"raw\") # Launch the qemu subprocess and wait for it to become ready: g.launch () @@ -507,6 +626,18 @@ logvols = g.lvs () import libguestfsmod +"; + + List.iter ( + fun (name, bitmask) -> + pr "EVENT_%s = 0x%x\n" (String.uppercase name) bitmask + ) events; + pr "\n"; + + pr "\ +class ClosedHandle(ValueError): + pass + class GuestFS: \"\"\"Instances of this class are libguestfs API handles.\"\"\" @@ -515,20 +646,76 @@ class GuestFS: self._o = libguestfsmod.create () def __del__ (self): + if self._o: + libguestfsmod.close (self._o) + + def _check_not_closed (self): + if not self._o: + raise ClosedHandle (\"GuestFS: method called on closed handle\") + + def close (self): + \"\"\"Explicitly close the guestfs handle. + + The handle is closed implicitly when its reference count goes + to zero (eg. when it goes out of scope or the program ends). + + This call is only needed if you want to force the handle to + close now. After calling this, the program must not call + any method on the handle (except the implicit call to + __del__ which happens when the final reference is cleaned up). + \"\"\" + self._check_not_closed () libguestfsmod.close (self._o) + self._o = None + + def set_event_callback (self, cb, event_bitmask): + \"\"\"Register an event callback. + + Register \"cb\" as a callback function for all of the + events in \"event_bitmask\". \"event_bitmask\" should be + one or more \"guestfs.EVENT_*\" flags logically or'd together. + + This function returns an event handle which can be used + to delete the callback (see \"delete_event_callback\"). + + The callback function receives 4 parameters: + + cb (event, event_handle, buf, array) + + \"event\" is one of the \"EVENT_*\" flags. \"buf\" is a + message buffer (only for some types of events). \"array\" + is an array of integers (only for some types of events). + + You should read the documentation for + \"guestfs_set_event_callback\" in guestfs(3) before using + this function. + \"\"\" + self._check_not_closed () + return libguestfsmod.set_event_callback (self._o, cb, event_bitmask) + + def delete_event_callback (self, event_handle): + \"\"\"Delete an event callback.\"\"\" + self._check_not_closed () + libguestfsmod.delete_event_callback (self._o, event_handle) "; List.iter ( - fun (name, style, _, flags, _, _, longdesc) -> - pr " def %s " name; - generate_py_call_args ~handle:"self" (snd style); - pr ":\n"; + fun (name, (ret, args, optargs), _, flags, _, _, longdesc) -> + pr " def %s (self" name; + List.iter (fun arg -> pr ", %s" (name_of_argt arg)) args; + List.iter ( + function + | Bool n | Int n | Int64 n -> pr ", %s=-1" n + | String n -> pr ", %s=None" n + | _ -> assert false + ) optargs; + pr "):\n"; if not (List.mem NotInDocs flags) then ( let doc = replace_str longdesc "C doc @@ -545,26 +732,28 @@ class GuestFS: doc ^ "\n\n" ^ protocol_limit_warning else doc in let doc = - if List.mem DangerWillRobinson flags then - doc ^ "\n\n" ^ danger_will_robinson - else doc in - let doc = match deprecation_notice flags with | None -> doc | Some txt -> doc ^ "\n\n" ^ txt in let doc = pod2text ~width:60 name doc in let doc = List.map (fun line -> replace_str line "\\" "\\\\") doc in let doc = String.concat "\n " doc in - pr " u\"\"\"%s\"\"\"\n" doc; + pr " \"\"\"%s\"\"\"\n" doc; ); - pr " return libguestfsmod.%s " name; - generate_py_call_args ~handle:"self._o" (snd style); - pr "\n"; - pr "\n"; + (* Callers might pass in iterables instead of plain lists; + * convert those to plain lists because the C side of things + * cannot deal with iterables. (RHBZ#693306). + *) + List.iter ( + function + | Pathname _ | Device _ | Dev_or_Path _ | String _ | Key _ + | FileIn _ | FileOut _ | OptString _ | Bool _ | Int _ | Int64 _ + | BufferIn _ | Pointer _ -> () + | StringList n | DeviceList n -> + pr " %s = list (%s)\n" n n + ) args; + pr " self._check_not_closed ()\n"; + pr " return libguestfsmod.%s (self._o" name; + List.iter (fun arg -> pr ", %s" (name_of_argt arg)) (args@optargs); + pr ")\n\n"; ) all_functions - -(* Generate Python call arguments, eg "(handle, foo, bar)" *) -and generate_py_call_args ~handle args = - pr "(%s" handle; - List.iter (fun arg -> pr ", %s" (name_of_argt arg)) args; - pr ")"