--- /dev/null
+#!/usr/bin/python -u
+import sys,getopt,os
+import libvirt
+import select
+
+mypoll = select.poll()
+TIMEOUT_MS = 1000
+
+# handle globals
+h_fd = 0
+h_events = 0
+h_cb = None
+h_opaque = None
+
+# timeout globals
+t_active = 0
+t_timeout = -1
+t_cb = None
+t_opaque = None
+
+#####################################################
+# Callback Functions
+#####################################################
+def eventToString(event):
+ eventStrings = ( "Added",
+ "Removed",
+ "Started",
+ "Suspended",
+ "Resumed",
+ "Stopped",
+ "Saved",
+ "Restored" );
+ return eventStrings[event];
+
+def myDomainEventCallback1 (conn, dom, event, opaque):
+ print "myDomainEventCallback1 EVENT: Domain %s(%s) %s" % (dom.name(), dom.ID(), eventToString(event))
+
+def myDomainEventCallback2 (conn, dom, event, opaque):
+ print "myDomainEventCallback2 EVENT: Domain %s(%s) %s" % (dom.name(), dom.ID(), eventToString(event))
+
+#####################################################
+# EventImpl Functions
+#####################################################
+def myEventHandleTypeToPollEvent(events):
+ ret = 0
+ if events & libvirt.VIR_EVENT_HANDLE_READABLE:
+ ret |= select.POLLIN
+ if events & libvirt.VIR_EVENT_HANDLE_WRITABLE:
+ ret |= select.POLLOUT
+ if events & libvirt.VIR_EVENT_HANDLE_ERROR:
+ ret |= select.POLLERR;
+ if events & libvirt.VIR_EVENT_HANDLE_HANGUP:
+ ret |= select.POLLHUP;
+ return ret
+
+def myPollEventToEventHandleType(events):
+ ret = 0;
+ if events & select.POLLIN:
+ ret |= libvirt.VIR_EVENT_HANDLE_READABLE;
+ if events & select.POLLOUT:
+ ret |= libvirt.VIR_EVENT_HANDLE_WRITABLE;
+ if events & select.POLLERR:
+ ret |= libvirt.VIR_EVENT_HANDLE_ERROR;
+ if events & select.POLLHUP:
+ ret |= libvirt.VIR_EVENT_HANDLE_HANGUP;
+ return ret;
+
+def myAddHandle(fd, events, cb, opaque):
+ global h_fd, h_events, h_cb, h_opaque
+ #print "Adding Handle %s %s %s %s" % (str(fd), str(events), str(cb), str(opaque))
+ h_fd = fd
+ h_events = events
+ h_cb = cb
+ h_opaque = opaque
+
+ mypoll.register(fd, myEventHandleTypeToPollEvent(events))
+
+def myUpdateHandle(fd, event):
+ global h_fd, h_events
+ #print "Updating Handle %s %s" % (str(fd), str(events))
+ h_fd = fd
+ h_events = event
+ mypoll.unregister(fd)
+ mypoll.register(fd, myEventHandleTypeToPollEvent(event))
+
+def myRemoveHandle(fd):
+ global h_fd
+ #print "Removing Handle %s" % str(fd)
+ h_fd = 0
+ mypoll.unregister(fd)
+
+def myAddTimeout(timeout, cb, opaque):
+ global t_active, t_timeout, t_cb, t_opaque
+ #print "Adding Timeout %s %s %s" % (str(timeout), str(cb), str(opaque))
+ t_active = 1;
+ t_timeout = timeout;
+ t_cb = cb;
+ t_opaque = opaque;
+
+def myUpdateTimeout(timer, timeout):
+ global t_timeout
+ #print "Updating Timeout %s" % (str(timer), str(timeout))
+ t_timeout = timeout;
+
+def myRemoveTimeout(timer):
+ global t_active
+ #print "Removing Timeout %s" % str(timer)
+ t_active = 0;
+
+##########################################
+# Main
+##########################################
+
+def usage():
+ print "usage: "+os.path.basename(sys.argv[0])+" [uri]"
+ print " uri will default to qemu:///system"
+
+def main():
+ try:
+ opts, args = getopt.getopt(sys.argv[1:], "h", ["help"] )
+ except getopt.GetoptError, err:
+ # print help information and exit:
+ print str(err) # will print something like "option -a not recognized"
+ usage()
+ sys.exit(2)
+ for o, a in opts:
+ if o in ("-h", "--help"):
+ usage()
+ sys.exit()
+
+ if len(sys.argv) > 1:
+ uri = sys.argv[1]
+ else:
+ uri = "qemu:///system"
+
+ print "Using uri:" + uri
+
+ libvirt.virEventRegisterImpl( myAddHandle,
+ myUpdateHandle,
+ myRemoveHandle,
+ myAddTimeout,
+ myUpdateTimeout,
+ myRemoveTimeout );
+ vc = libvirt.open(uri)
+
+ #Add 2 callbacks to prove this works with more than just one
+ vc.domainEventRegister(myDomainEventCallback1,None)
+ vc.domainEventRegister(myDomainEventCallback2,None)
+
+ while 1:
+ try:
+ sts = mypoll.poll(TIMEOUT_MS)
+ except select.error, err:
+ if err[0] == errno.EINTR:
+ continue
+ raise
+ except KeyboardInterrupt:
+ print "Keyboard Interrupt caught - exiting cleanly"
+ break
+
+ if not sts:
+ #print "Timed out"
+ continue
+
+ rfd = sts[0][0]
+ revents = sts[0][1]
+
+ if t_active:
+ #print "Invoking Timeout CB"
+ t_cb(t_timeout, t_opaque[0], t_opaque[1])
+
+ if revents & select.POLLHUP:
+ print "Reset by peer";
+ return -1;
+
+ if h_cb != None:
+ #print "Invoking Handle CB"
+ h_cb(h_fd, myPollEventToEventHandleType(revents & h_events),
+ h_opaque[0], h_opaque[1])
+
+ #print "DEBUG EXIT"
+ #break
+
+if __name__ == "__main__":
+ main()
+
return(py_retval);
}
+/*******************************************
+ * Helper functions to avoid importing modules
+ * for every callback
+ *******************************************/
+static PyObject *libvirt_module = NULL;
+static PyObject *libvirt_dict = NULL;
+static PyObject *libvirt_dom_class = NULL;
+static PyObject *
+getLibvirtModuleObject (void) {
+ if(libvirt_module)
+ return libvirt_module;
+
+ // PyImport_ImportModule returns a new reference
+ libvirt_module = PyImport_ImportModule("libvirt");
+ if(!libvirt_module) {
+ printf("%s Error importing libvirt module\n", __FUNCTION__);
+ PyErr_Print();
+ return NULL;
+ }
+
+ return libvirt_module;
+}
+
+static PyObject *
+getLibvirtDictObject (void) {
+ if(libvirt_dict)
+ return libvirt_dict;
+
+ // PyModule_GetDict returns a borrowed reference
+ libvirt_dict = PyModule_GetDict(getLibvirtModuleObject());
+ if(!libvirt_dict) {
+ printf("%s Error importing libvirt dictionary\n", __FUNCTION__);
+ PyErr_Print();
+ return NULL;
+ }
+
+ Py_INCREF(libvirt_dict);
+ return libvirt_dict;
+}
+
+static PyObject *
+getLibvirtDomainClassObject (void) {
+ if(libvirt_dom_class)
+ return libvirt_dom_class;
+
+ // PyDict_GetItemString returns a borrowed reference
+ libvirt_dom_class = PyDict_GetItemString(getLibvirtDictObject(),
+ "virDomain");
+ if(!libvirt_dom_class) {
+ printf("%s Error importing virDomain class\n", __FUNCTION__);
+ PyErr_Print();
+ return NULL;
+ }
+
+ Py_INCREF(libvirt_dom_class);
+ return libvirt_dom_class;
+}
+/*******************************************
+ * Domain Events
+ *******************************************/
+
+static int
+libvirt_virConnectDomainEventCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ int event,
+ void *opaque)
+{
+ PyObject *pyobj_ret;
+
+ PyObject *pyobj_conn_inst = (PyObject*)opaque;
+ PyObject *pyobj_dom = libvirt_virDomainPtrWrap(dom);
+
+ PyObject *pyobj_dom_args;
+ PyObject *pyobj_dom_inst;
+
+ PyObject *dom_class;
+
+ /* Create a python instance of this virDomainPtr */
+ pyobj_dom_args = PyTuple_New(2);
+ if(PyTuple_SetItem(pyobj_dom_args, 0, pyobj_conn_inst)!=0) {
+ printf("%s error creating tuple",__FUNCTION__);
+ return -1;
+ }
+ if(PyTuple_SetItem(pyobj_dom_args, 1, pyobj_dom)!=0) {
+ printf("%s error creating tuple",__FUNCTION__);
+ return -1;
+ }
+ Py_INCREF(pyobj_conn_inst);
+
+ dom_class = getLibvirtDomainClassObject();
+ if(!PyClass_Check(dom_class)) {
+ printf("%s dom_class is not a class!\n", __FUNCTION__);
+ return -1;
+ }
+
+ pyobj_dom_inst = PyInstance_New(dom_class,
+ pyobj_dom_args,
+ NULL);
+
+ Py_DECREF(pyobj_dom_args);
+
+ if(!pyobj_dom_inst) {
+ printf("%s Error creating a python instance of virDomain\n", __FUNCTION__);
+ PyErr_Print();
+ return -1;
+ }
+
+ /* Call the Callback Dispatcher */
+ pyobj_ret = PyObject_CallMethod(pyobj_conn_inst,
+ (char*)"dispatchDomainEventCallbacks",
+ (char*)"Oi",
+ pyobj_dom_inst,
+ event);
+
+ Py_DECREF(pyobj_dom_inst);
+
+ if(!pyobj_ret) {
+ printf("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
+ PyErr_Print();
+ return -1;
+ } else {
+ Py_DECREF(pyobj_ret);
+ return 0;
+ }
+
+}
+
+static PyObject *
+libvirt_virConnectDomainEventRegister(ATTRIBUTE_UNUSED PyObject * self,
+ PyObject * args)
+{
+ PyObject *py_retval; /* return value */
+ PyObject *pyobj_conn; /* virConnectPtr */
+ PyObject *pyobj_conn_inst; /* virConnect Python object */
+
+ virConnectPtr conn;
+ int ret = 0;
+
+ if (!PyArg_ParseTuple
+ (args, (char *) "OO:virConnectDomainEventRegister",
+ &pyobj_conn, &pyobj_conn_inst)) {
+ printf("%s failed parsing tuple\n", __FUNCTION__);
+ return VIR_PY_INT_FAIL;
+ }
+
+#ifdef DEBUG_ERROR
+ printf("libvirt_virConnectDomainEventRegister(%p %p) called\n",
+ pyobj_conn, pyobj_conn_inst);
+#endif
+ conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
+
+ Py_INCREF(pyobj_conn_inst);
+
+ ret = virConnectDomainEventRegister(conn,
+ libvirt_virConnectDomainEventCallback,
+ (void *)pyobj_conn_inst);
+
+ py_retval = libvirt_intWrap(ret);
+ return (py_retval);
+}
+
+static PyObject *
+libvirt_virConnectDomainEventDeregister(ATTRIBUTE_UNUSED PyObject * self,
+ PyObject * args)
+{
+ PyObject *py_retval;
+ PyObject *pyobj_conn;
+ PyObject *pyobj_conn_inst;
+
+ virConnectPtr conn;
+ int ret = 0;
+
+ if (!PyArg_ParseTuple
+ (args, (char *) "OO:virConnectDomainEventDeregister",
+ &pyobj_conn, &pyobj_conn_inst))
+ return (NULL);
+
+#ifdef DEBUG_ERROR
+ printf("libvirt_virConnectDomainEventDeregister(%p) called\n", pyobj_conn);
+#endif
+
+ conn = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
+
+ ret = virConnectDomainEventDeregister(conn, libvirt_virConnectDomainEventCallback);
+
+ Py_DECREF(pyobj_conn_inst);
+ py_retval = libvirt_intWrap(ret);
+ return (py_retval);
+}
+
+/*******************************************
+ * Event Impl
+ *******************************************/
+static PyObject *addHandleObj = NULL;
+static PyObject *updateHandleObj = NULL;
+static PyObject *removeHandleObj = NULL;
+static PyObject *addTimeoutObj = NULL;
+static PyObject *updateTimeoutObj = NULL;
+static PyObject *removeTimeoutObj = NULL;
+
+
+static int
+libvirt_virEventAddHandleFunc (int fd ATTRIBUTE_UNUSED, int event ATTRIBUTE_UNUSED,
+ virEventHandleCallback cb, void *opaque)
+{
+ PyObject *result = NULL;
+ PyObject *python_cb;
+ PyObject *cb_obj;
+ PyObject *opaque_obj;
+ PyObject *cb_args;
+ PyObject *pyobj_args;
+
+ /* Lookup the python callback */
+ python_cb = PyDict_GetItemString(getLibvirtDictObject(),
+ "eventInvokeHandleCallback");
+ if(!python_cb) {
+ printf("%s Error finding eventInvokeHandleCallback\n", __FUNCTION__);
+ PyErr_Print();
+ return -1;
+ }
+ Py_INCREF(python_cb);
+
+ /* create tuple for cb */
+ cb_obj = libvirt_virEventHandleCallbackWrap(cb);
+ opaque_obj = libvirt_virVoidPtrWrap(opaque);
+
+ cb_args = PyTuple_New(2);
+ PyTuple_SetItem(cb_args, 0, cb_obj);
+ PyTuple_SetItem(cb_args, 1, opaque_obj);
+
+ pyobj_args = PyTuple_New(4);
+ PyTuple_SetItem(pyobj_args, 0, libvirt_intWrap(fd));
+ PyTuple_SetItem(pyobj_args, 1, libvirt_intWrap(event));
+ PyTuple_SetItem(pyobj_args, 2, python_cb);
+ PyTuple_SetItem(pyobj_args, 3, cb_args);
+
+ if(addHandleObj && PyCallable_Check(addHandleObj))
+ result = PyEval_CallObject(addHandleObj, pyobj_args);
+
+ Py_XDECREF(result);
+ Py_DECREF(pyobj_args);
+ return 0;
+}
+
+static void
+libvirt_virEventUpdateHandleFunc(int fd, int event)
+{
+ PyObject *result = NULL;
+ PyObject *pyobj_args = PyTuple_New(2);
+ PyTuple_SetItem(pyobj_args, 0, libvirt_intWrap(fd));
+ PyTuple_SetItem(pyobj_args, 1, libvirt_intWrap(event));
+
+ if(updateHandleObj && PyCallable_Check(updateHandleObj))
+ result = PyEval_CallObject(updateHandleObj, pyobj_args);
+
+ Py_XDECREF(result);
+ Py_DECREF(pyobj_args);
+}
+
+static int
+libvirt_virEventRemoveHandleFunc(int fd)
+{
+ PyObject *result = NULL;
+ PyObject *pyobj_args = PyTuple_New(1);
+ PyTuple_SetItem(pyobj_args, 0, libvirt_intWrap(fd));
+
+ if(removeHandleObj && PyCallable_Check(removeHandleObj))
+ result = PyEval_CallObject(removeHandleObj, pyobj_args);
+
+ Py_XDECREF(result);
+ Py_DECREF(pyobj_args);
+ return 0;
+}
+
+static int
+libvirt_virEventAddTimeoutFunc(int timeout, virEventTimeoutCallback cb,
+ void *opaque)
+{
+ PyObject *result = NULL;
+
+ PyObject *python_cb;
+
+ PyObject *cb_obj;
+ PyObject *opaque_obj;
+ PyObject *cb_args;
+ PyObject *pyobj_args;
+
+ /* Lookup the python callback */
+ python_cb = PyDict_GetItemString(getLibvirtDictObject(),
+ "eventInvokeTimeoutCallback");
+ if(!python_cb) {
+ printf("%s Error finding eventInvokeTimeoutCallback\n", __FUNCTION__);
+ PyErr_Print();
+ return -1;
+ }
+ Py_INCREF(python_cb);
+
+ /* create tuple for cb */
+ cb_obj = libvirt_virEventTimeoutCallbackWrap(cb);
+ opaque_obj = libvirt_virVoidPtrWrap(opaque);
+
+ cb_args = PyTuple_New(2);
+ PyTuple_SetItem(cb_args, 0, cb_obj);
+ PyTuple_SetItem(cb_args, 1, opaque_obj);
+
+ pyobj_args = PyTuple_New(3);
+
+ PyTuple_SetItem(pyobj_args, 0, libvirt_intWrap(timeout));
+ PyTuple_SetItem(pyobj_args, 1, python_cb);
+ PyTuple_SetItem(pyobj_args, 2, cb_args);
+
+ if(addTimeoutObj && PyCallable_Check(addTimeoutObj))
+ result = PyEval_CallObject(addTimeoutObj, pyobj_args);
+
+ Py_XDECREF(result);
+ Py_DECREF(pyobj_args);
+ return 0;
+}
+
+static void
+libvirt_virEventUpdateTimeoutFunc(int timer, int timeout)
+{
+ PyObject *result = NULL;
+ PyObject *pyobj_args = PyTuple_New(2);
+ PyTuple_SetItem(pyobj_args, 0, libvirt_intWrap(timer));
+ PyTuple_SetItem(pyobj_args, 1, libvirt_intWrap(timeout));
+
+ if(updateTimeoutObj && PyCallable_Check(updateTimeoutObj))
+ result = PyEval_CallObject(updateTimeoutObj, pyobj_args);
+
+ Py_XDECREF(result);
+ Py_DECREF(pyobj_args);
+}
+
+static int
+libvirt_virEventRemoveTimeoutFunc(int timer)
+{
+ PyObject *result = NULL;
+ PyObject *pyobj_args = PyTuple_New(1);
+ PyTuple_SetItem(pyobj_args, 0, libvirt_intWrap(timer));
+
+ if(updateTimeoutObj && PyCallable_Check(updateTimeoutObj))
+ result = PyEval_CallObject(removeTimeoutObj, pyobj_args);
+
+ Py_XDECREF(result);
+ Py_DECREF(pyobj_args);
+ return 0;
+}
+
+static PyObject *
+libvirt_virEventRegisterImpl(ATTRIBUTE_UNUSED PyObject * self,
+ PyObject * args)
+{
+ Py_XDECREF(addHandleObj);
+ Py_XDECREF(updateHandleObj);
+ Py_XDECREF(removeHandleObj);
+ Py_XDECREF(addTimeoutObj);
+ Py_XDECREF(updateTimeoutObj);
+ Py_XDECREF(removeTimeoutObj);
+
+ if (!PyArg_ParseTuple
+ (args, (char *) "OOOOOO:virEventRegisterImpl",
+ &addHandleObj,
+ &updateHandleObj,
+ &removeHandleObj,
+ &addTimeoutObj,
+ &updateTimeoutObj,
+ &removeTimeoutObj
+ ))
+ return VIR_PY_INT_FAIL;
+
+ Py_INCREF(addHandleObj);
+ Py_INCREF(updateHandleObj);
+ Py_INCREF(removeHandleObj);
+ Py_INCREF(addTimeoutObj);
+ Py_INCREF(updateTimeoutObj);
+ Py_INCREF(removeTimeoutObj);
+
+ virEventRegisterImpl(libvirt_virEventAddHandleFunc,
+ libvirt_virEventUpdateHandleFunc,
+ libvirt_virEventRemoveHandleFunc,
+ libvirt_virEventAddTimeoutFunc,
+ libvirt_virEventUpdateTimeoutFunc,
+ libvirt_virEventRemoveTimeoutFunc);
+
+ return VIR_PY_INT_SUCCESS;
+}
+
+static PyObject *
+libvirt_virEventInvokeHandleCallback(PyObject *self ATTRIBUTE_UNUSED,
+ PyObject *args)
+{
+ int fd, event;
+ PyObject *py_f;
+ PyObject *py_opaque;
+ virEventHandleCallback cb;
+ void *opaque;
+
+ if (!PyArg_ParseTuple
+ (args, (char *) "iiOO:virEventInvokeHandleCallback",
+ &fd, &event, &py_f, &py_opaque
+ ))
+ return VIR_PY_INT_FAIL;
+
+ cb = (virEventHandleCallback) PyvirEventHandleCallback_Get(py_f);
+ opaque = (void *) PyvirVoidPtr_Get(py_opaque);
+
+ if(cb)
+ cb (fd, event, opaque);
+
+ return VIR_PY_INT_SUCCESS;
+}
+
+static PyObject *
+libvirt_virEventInvokeTimeoutCallback(PyObject *self ATTRIBUTE_UNUSED,
+ PyObject *args)
+{
+ int timer;
+ PyObject *py_f;
+ PyObject *py_opaque;
+ virEventTimeoutCallback cb;
+ void *opaque;
+
+ if (!PyArg_ParseTuple
+ (args, (char *) "iOO:virEventInvokeTimeoutCallback",
+ &timer, &py_f, &py_opaque
+ ))
+ return VIR_PY_INT_FAIL;
+
+ cb = (virEventTimeoutCallback) PyvirEventTimeoutCallback_Get(py_f);
+ opaque = (void *) PyvirVoidPtr_Get(py_opaque);
+ if(cb)
+ cb (timer, opaque);
+
+ return VIR_PY_INT_SUCCESS;
+}
/************************************************************************
* *
{(char *) "virConnectOpenAuth", libvirt_virConnectOpenAuth, METH_VARARGS, NULL},
{(char *) "virConnectListDomainsID", libvirt_virConnectListDomainsID, METH_VARARGS, NULL},
{(char *) "virConnectListDefinedDomains", libvirt_virConnectListDefinedDomains, METH_VARARGS, NULL},
+ {(char *) "virConnectDomainEventRegister", libvirt_virConnectDomainEventRegister, METH_VARARGS, NULL},
+ {(char *) "virConnectDomainEventDeregister", libvirt_virConnectDomainEventDeregister, METH_VARARGS, NULL},
{(char *) "virDomainGetInfo", libvirt_virDomainGetInfo, METH_VARARGS, NULL},
{(char *) "virNodeGetInfo", libvirt_virNodeGetInfo, METH_VARARGS, NULL},
{(char *) "virDomainGetUUID", libvirt_virDomainGetUUID, METH_VARARGS, NULL},
{(char *) "virStoragePoolGetUUID", libvirt_virStoragePoolGetUUID, METH_VARARGS, NULL},
{(char *) "virStoragePoolGetUUIDString", libvirt_virStoragePoolGetUUIDString, METH_VARARGS, NULL},
{(char *) "virStoragePoolLookupByUUID", libvirt_virStoragePoolLookupByUUID, METH_VARARGS, NULL},
+ {(char *) "virEventRegisterImpl", libvirt_virEventRegisterImpl, METH_VARARGS, NULL},
+ {(char *) "virEventInvokeHandleCallback", libvirt_virEventInvokeHandleCallback, METH_VARARGS, NULL},
+ {(char *) "virEventInvokeTimeoutCallback", libvirt_virEventInvokeTimeoutCallback, METH_VARARGS, NULL},
{NULL, NULL, 0, NULL}
};
projects / libvirt.git / commitdiff