(* 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
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 <Python.h>
-
-#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 <stdio.h>
#include <stdlib.h>
#include <assert.h>
-#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 **
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 =
(* 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
| 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
| 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 (
| 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";
| 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";
+ 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";
- pr " r = guestfs_%s " name;
+ 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"
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"
import guestfs
g = guestfs.GuestFS ()
-g.add_drive (\"guest.img\")
+g.add_drive_opts (\"guest.img\", format=\"raw\")
g.launch ()
parts = g.list_partitions ()
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 ()
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.\"\"\"
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):
+ u\"\"\"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):
+ u\"\"\"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):
+ u\"\"\"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<guestfs_" "C<g." in
let doc =
- match fst style with
+ match ret with
| RErr | RInt _ | RInt64 _ | RBool _
| RConstOptString _ | RConstString _
| RString _ | RBufferOut _ -> doc
let doc = String.concat "\n " doc in
pr " u\"\"\"%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 ")"
git.annexia.org / libguestfs.git / blobdiff