Hello community, here is the log from the commit of package python-libvirt-python for openSUSE:Factory checked in at 2018-10-12 13:10:39 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-libvirt-python (Old) and /work/SRC/openSUSE:Factory/.python-libvirt-python.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-libvirt-python" Fri Oct 12 13:10:39 2018 rev:16 rq:641144 version:4.8.0 Changes: -------- --- /work/SRC/openSUSE:Factory/python-libvirt-python/python-libvirt-python.changes 2018-10-02 19:47:47.781807631 +0200 +++ /work/SRC/openSUSE:Factory/.python-libvirt-python.new/python-libvirt-python.changes 2018-10-12 13:10:41.611299793 +0200 @@ -1,0 +2,6 @@ +Tue Oct 2 20:14:44 UTC 2018 - jfeh...@suse.com + +- Update to 4.8.0 + - Add all new APIs and constants in libvirt 4.8.0 + +------------------------------------------------------------------- Old: ---- libvirt-python-4.7.0.tar.gz libvirt-python-4.7.0.tar.gz.asc New: ---- libvirt-python-4.8.0.tar.gz libvirt-python-4.8.0.tar.gz.asc ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-libvirt-python.spec ++++++ --- /var/tmp/diff_new_pack.Y7Kd5p/_old 2018-10-12 13:10:42.307298804 +0200 +++ /var/tmp/diff_new_pack.Y7Kd5p/_new 2018-10-12 13:10:42.311298798 +0200 @@ -12,7 +12,7 @@ # license that conforms to the Open Source Definition (Version 1.9) # published by the Open Source Initiative. -# Please submit bugfixes or comments via https://bugs.opensuse.org/ +# Please submit bugfixes or comments via http://bugs.opensuse.org/ # @@ -20,7 +20,7 @@ %define srcname libvirt-python Name: python-libvirt-python Url: https://libvirt.org/ -Version: 4.7.0 +Version: 4.8.0 Release: 0 Summary: Library providing a virtualization API License: LGPL-2.1-or-later ++++++ libvirt-python-4.7.0.tar.gz -> libvirt-python-4.8.0.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libvirt-python-4.7.0/ChangeLog new/libvirt-python-4.8.0/ChangeLog --- old/libvirt-python-4.7.0/ChangeLog 2018-09-03 19:24:37.000000000 +0200 +++ new/libvirt-python-4.8.0/ChangeLog 2018-10-01 17:29:59.000000000 +0200 @@ -1,3 +1,206 @@ +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Fix blanks + Closer to pep8 + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Convert CONNECTION events + to use new Description class + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Convert SECRET events + to use new Description class + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Convert DEVICE events + to use new Description class + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Convert STORAGE events + to use new Description class + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Convert NETWORK events + to use new Description class + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Convert TRAY events + to use new Description class + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Convert DISK events + to use new Description class + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Convert GRAPHICS events + to use new Description class + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Convert AGENT events + to use new Description class + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Convert ERROR events + to use new Description class + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Convert WATCHDOG events + to use new Description class + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Convert BLOCKJOB events + to use new Description class + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Convert LIVECYCLE events + to use new Description class + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Add class for event descriptions + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Simplify event ID lists + by directly building the list with the IDs instead of appending them + explicitly. + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Merge livecycle callbacks + Registering the same function twice using the old domainEventRegister() + interface would not work, as the function reference is used for + un-registering. + + But it is not a problem with the new interface domainEventRegisterAny(), + as that returns a unique ID. + + While at it also demonstrate the 'opaque' mechanism. + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Use __file__ + instead of sys.argv[0] + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Add missing globale statement + to fix loop termination on exit. + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Remove dead assignment + variable is unused + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Remove extra parenthesis + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Handle closed connection + If libvirtd terminates while event-test.py has an open connection to it, + it will crash with the following traceback: + + > myConnectionCloseCallback: qemu:///session: Error + > Exception in thread libvirtEventLoop: + > Traceback (most recent call last): + > File "/usr/lib/python2.7/threading.py", line 801, in __bootstrap_inner + > self.run() + > File "/usr/lib/python2.7/threading.py", line 754, in run + > self.__target(*self.__args, **self.__kwargs) + > File "examples/event-test.py", line 424, in virEventLoopPollRun + > eventLoop.run_loop() + > File "examples/event-test.py", line 242, in run_loop + > self.run_once() + > File "examples/event-test.py", line 187, in run_once + > libvirt.virEventInvokeFreeCallback(opaque) + > AttributeError: 'module' object has no attribute 'virEventInvokeFreeCallback' + > + > libvirt: XML-RPC error : internal error: client socket is closed + > Traceback (most recent call last): + > File "examples/event-test.py", line 872, in <module> + > main() + > File "examples/event-test.py", line 854, in main + > vc.secretEventDeregisterAny(id) + > File "/usr/lib/python2.7/dist-packages/libvirt.py", line 4987, in secretEventDeregisterAny + > if ret == -1: raise libvirtError ('virConnectSecretEventDeregisterAny() failed', conn=self) + > libvirt.libvirtError: internal error: client socket is closed + > Closing qemu:///session + + Skip unregistering the event callbacks and closing the connection if the + connection is already broken / closed. + + + +2018-09-24 Philipp Hahn <h...@univention.de> + + event-test.py: Sync list of domain lifecycle events + Add new events to prevent crash: + > Traceback (most recent call last): + > File "/usr/lib/python2.7/dist-packages/libvirt.py", line 4601, in _dispatchDomainEventCallbacks + > cb(self, virDomain(self, _obj=dom), event, detail, opaque) + > File "libvirt-python/examples/event-test.py", line 505, in myDomainEventCallback1 + > domDetailToString(event, detail))) + > File "libvirt-python/examples/event-test.py", line 484, in domDetailToString + > return domEventStrings[event][detail] + > IndexError: tuple index out of range + + + 2018-09-03 Daniel Veillard <veill...@redhat.com> Release of libvirt-python=4.7.0 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libvirt-python-4.7.0/PKG-INFO new/libvirt-python-4.8.0/PKG-INFO --- old/libvirt-python-4.7.0/PKG-INFO 2018-09-03 19:24:37.000000000 +0200 +++ new/libvirt-python-4.8.0/PKG-INFO 2018-10-01 17:30:00.000000000 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 1.1 Name: libvirt-python -Version: 4.7.0 +Version: 4.8.0 Summary: The libvirt virtualization API python binding Home-page: http://www.libvirt.org Author: Libvirt Maintainers diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libvirt-python-4.7.0/examples/event-test.py new/libvirt-python-4.8.0/examples/event-test.py --- old/libvirt-python-4.7.0/examples/event-test.py 2018-07-02 22:22:37.000000000 +0200 +++ new/libvirt-python-4.8.0/examples/event-test.py 2018-10-01 17:00:19.000000000 +0200 @@ -30,11 +30,14 @@ event_impl = "poll" do_debug = False + + def debug(msg): global do_debug if do_debug: print(msg) + # # This general purpose event loop will support waiting for file handle # I/O and errors events, as well as scheduling repeatable timers with @@ -100,7 +103,6 @@ self.cb(self.timer, self.opaque) - def __init__(self): self.poll = select.poll() self.pipetrick = os.pipe() @@ -126,10 +128,9 @@ # with the event loop for input events. When we need to force # the main thread out of a poll() sleep, we simple write a # single byte of data to the other end of the pipe. - debug("Self pipe watch %d write %d" %(self.pipetrick[0], self.pipetrick[1])) + debug("Self pipe watch %d write %d" % (self.pipetrick[0], self.pipetrick[1])) self.poll.register(self.pipetrick[0], select.POLLIN) - # Calculate when the next timeout is due to occur, returning # the absolute timestamp for the next timeout, or 0 if there is # no timeout due @@ -159,7 +160,6 @@ return h return None - # This is the heart of the event loop, performing one single # iteration. It asks when the next timeout is due, and then # calculates the maximum amount of time it is able to sleep @@ -207,7 +207,7 @@ # the data just continue if fd == self.pipetrick[0]: self.pendingWakeup = False - data = os.read(fd, 1) + os.read(fd, 1) continue h = self.get_handle_by_fd(fd) @@ -224,7 +224,7 @@ want = t.get_last_fired() + interval # Deduct 20ms, since scheduler timeslice # means we could be ever so slightly early - if now >= (want-20): + if now >= want - 20: debug("Dispatch timer %d now %s want %s" % (t.get_id(), str(now), str(want))) t.set_last_fired(now) t.dispatch() @@ -235,7 +235,6 @@ finally: self.runningPoll = False - # Actually run the event loop forever def run_loop(self): self.quit = False @@ -247,7 +246,6 @@ self.pendingWakeup = True os.write(self.pipetrick[1], 'c'.encode("UTF-8")) - # Registers a new file handle 'fd', monitoring for 'events' (libvirt # event constants), firing the callback cb() when an event occurs. # Returns a unique integer identier for this handle, that should be @@ -301,7 +299,7 @@ h.set_interval(interval) self.interrupt() - debug("Update timer %d interval %d" % (timerID, interval)) + debug("Update timer %d interval %d" % (timerID, interval)) break # Stop monitoring for events on the file handle @@ -383,26 +381,32 @@ global eventLoop return eventLoop.add_handle(fd, events, cb, opaque) + def virEventUpdateHandleImpl(handleID, events): global eventLoop return eventLoop.update_handle(handleID, events) + def virEventRemoveHandleImpl(handleID): global eventLoop return eventLoop.remove_handle(handleID) + def virEventAddTimerImpl(interval, cb, opaque): global eventLoop return eventLoop.add_timer(interval, cb, opaque) + def virEventUpdateTimerImpl(timerID, interval): global eventLoop return eventLoop.update_timer(timerID, interval) + def virEventRemoveTimerImpl(timerID): global eventLoop return eventLoop.remove_timer(timerID) + # This tells libvirt what event loop implementation it # should use def virEventLoopPollRegister(): @@ -413,20 +417,24 @@ virEventUpdateTimerImpl, virEventRemoveTimerImpl) + # Directly run the event loop in the current thread def virEventLoopPollRun(): global eventLoop eventLoop.run_loop() + def virEventLoopAIORun(loop): import asyncio asyncio.set_event_loop(loop) loop.run_forever() + def virEventLoopNativeRun(): while True: libvirt.virEventRunDefaultImpl() + # Spawn a background thread to run the event loop def virEventLoopPollStart(): global eventLoopThread @@ -435,6 +443,7 @@ eventLoopThread.setDaemon(True) eventLoopThread.start() + def virEventLoopAIOStart(): global eventLoopThread import libvirtaio @@ -445,6 +454,7 @@ eventLoopThread.setDaemon(True) eventLoopThread.start() + def virEventLoopNativeStart(): global eventLoopThread libvirt.virEventRegisterDefaultImpl() @@ -456,229 +466,282 @@ ########################################################################## # Everything that now follows is a simple demo of domain lifecycle events ########################################################################## -def domEventToString(event): - domEventStrings = ( "Defined", - "Undefined", - "Started", - "Suspended", - "Resumed", - "Stopped", - "Shutdown", - "PMSuspended", - "Crashed", - ) - return domEventStrings[event] - -def domDetailToString(event, detail): - domEventStrings = ( - ( "Added", "Updated" ), - ( "Removed", ), - ( "Booted", "Migrated", "Restored", "Snapshot", "Wakeup" ), - ( "Paused", "Migrated", "IOError", "Watchdog", "Restored", "Snapshot", "API error" ), - ( "Unpaused", "Migrated", "Snapshot" ), - ( "Shutdown", "Destroyed", "Crashed", "Migrated", "Saved", "Failed", "Snapshot"), - ( "Finished", "On guest request", "On host request"), - ( "Memory", "Disk" ), - ( "Panicked", ), - ) - return domEventStrings[event][detail] - -def blockJobTypeToString(type): - blockJobTypes = ( "unknown", "Pull", "Copy", "Commit", "ActiveCommit", ) - return blockJobTypes[type] - -def blockJobStatusToString(status): - blockJobStatus = ( "Completed", "Failed", "Canceled", "Ready", ) - return blockJobStatus[status] - -def agentLifecycleStateToString(state): - agentStates = ( "unknown", "connected", "disconnected", ) - return agentStates[state] - -def agentLifecycleReasonToString(reason): - agentReasons = ( "unknown", "domain started", "channel event", ) - return agentReasons[reason] - -def myDomainEventCallback1 (conn, dom, event, detail, opaque): - print("myDomainEventCallback1 EVENT: Domain %s(%s) %s %s" % (dom.name(), dom.ID(), - domEventToString(event), - domDetailToString(event, detail))) - -def myDomainEventCallback2 (conn, dom, event, detail, opaque): - print("myDomainEventCallback2 EVENT: Domain %s(%s) %s %s" % (dom.name(), dom.ID(), - domEventToString(event), - domDetailToString(event, detail))) +class Description(object): + __slots__ = ('desc', 'args') + + def __init__(self, *args, **kwargs): + self.desc = kwargs.get('desc') + self.args = args + + def __str__(self): # type: () -> str + return self.desc + + def __getitem__(self, item): # type: (int) -> str + try: + data = self.args[item] + except IndexError: + return self.__class__(desc=str(item)) + + if isinstance(data, str): + return self.__class__(desc=data) + elif isinstance(data, (list, tuple)): + desc, args = data + return self.__class__(*args, desc=desc) + + raise TypeError(args) + + +DOM_EVENTS = Description( + ("Defined", ("Added", "Updated", "Renamed", "Snapshot")), + ("Undefined", ("Removed", "Renamed")), + ("Started", ("Booted", "Migrated", "Restored", "Snapshot", "Wakeup")), + ("Suspended", ("Paused", "Migrated", "IOError", "Watchdog", "Restored", "Snapshot", "API error", "Postcopy", "Postcopy failed")), + ("Resumed", ("Unpaused", "Migrated", "Snapshot", "Postcopy")), + ("Stopped", ("Shutdown", "Destroyed", "Crashed", "Migrated", "Saved", "Failed", "Snapshot")), + ("Shutdown", ("Finished", "On guest request", "On host request")), + ("PMSuspended", ("Memory", "Disk")), + ("Crashed", ("Panicked",)), +) +BLOCK_JOB_TYPES = Description("unknown", "Pull", "Copy", "Commit", "ActiveCommit") +BLOCK_JOB_STATUS = Description("Completed", "Failed", "Canceled", "Ready") +WATCHDOG_ACTIONS = Description("none", "Pause", "Reset", "Poweroff", "Shutdown", "Debug", "Inject NMI") +ERROR_EVENTS = Description("None", "Pause", "Report") +AGENT_STATES = Description("unknown", "connected", "disconnected") +AGENT_REASONS = Description("unknown", "domain started", "channel event") +GRAPHICS_PHASES = Description("Connect", "Initialize", "Disconnect") +DISK_EVENTS = Description("Change missing on start", "Drop missing on start") +TRAY_EVENTS = Description("Opened", "Closed") + + +def myDomainEventCallback(conn, dom, event, detail, opaque): + print("myDomainEventCallback%s EVENT: Domain %s(%s) %s %s" % ( + opaque, dom.name(), dom.ID(), DOM_EVENTS[event], DOM_EVENTS[event][detail])) + def myDomainEventRebootCallback(conn, dom, opaque): - print("myDomainEventRebootCallback: Domain %s(%s)" % (dom.name(), dom.ID())) + print("myDomainEventRebootCallback: Domain %s(%s)" % ( + dom.name(), dom.ID())) + def myDomainEventRTCChangeCallback(conn, dom, utcoffset, opaque): - print("myDomainEventRTCChangeCallback: Domain %s(%s) %d" % (dom.name(), dom.ID(), utcoffset)) + print("myDomainEventRTCChangeCallback: Domain %s(%s) %d" % ( + dom.name(), dom.ID(), utcoffset)) + def myDomainEventWatchdogCallback(conn, dom, action, opaque): - print("myDomainEventWatchdogCallback: Domain %s(%s) %d" % (dom.name(), dom.ID(), action)) + print("myDomainEventWatchdogCallback: Domain %s(%s) %s" % ( + dom.name(), dom.ID(), WATCHDOG_ACTIONS[action])) + def myDomainEventIOErrorCallback(conn, dom, srcpath, devalias, action, opaque): - print("myDomainEventIOErrorCallback: Domain %s(%s) %s %s %d" % (dom.name(), dom.ID(), srcpath, devalias, action)) + print("myDomainEventIOErrorCallback: Domain %s(%s) %s %s %d" % ( + dom.name(), dom.ID(), srcpath, devalias, action)) + + def myDomainEventIOErrorReasonCallback(conn, dom, srcpath, devalias, action, reason, opaque): - print("myDomainEventIOErrorReasonCallback: Domain %s(%s) %s %s %d %s" % (dom.name(), dom.ID(), srcpath, devalias, action, reason)) + print("myDomainEventIOErrorReasonCallback: Domain %s(%s) %s %s %d %s" % ( + dom.name(), dom.ID(), srcpath, devalias, action, ERROR_EVENTS[reason])) + + def myDomainEventGraphicsCallback(conn, dom, phase, localAddr, remoteAddr, authScheme, subject, opaque): - print("myDomainEventGraphicsCallback: Domain %s(%s) %d %s" % (dom.name(), dom.ID(), phase, authScheme)) + print("myDomainEventGraphicsCallback: Domain %s(%s) %s %s" % ( + dom.name(), dom.ID(), GRAPHICS_PHASES[phase], authScheme)) + + def myDomainEventControlErrorCallback(conn, dom, opaque): - print("myDomainEventControlErrorCallback: Domain %s(%s)" % (dom.name(), dom.ID())) + print("myDomainEventControlErrorCallback: Domain %s(%s)" % ( + dom.name(), dom.ID())) + + def myDomainEventBlockJobCallback(conn, dom, disk, type, status, opaque): - print("myDomainEventBlockJobCallback: Domain %s(%s) %s on disk %s %s" % (dom.name(), dom.ID(), blockJobTypeToString(type), disk, blockJobStatusToString(status))) + print("myDomainEventBlockJobCallback: Domain %s(%s) %s on disk %s %s" % ( + dom.name(), dom.ID(), BLOCK_JOB_TYPES[type], disk, BLOCK_JOB_STATUS[status])) + + def myDomainEventDiskChangeCallback(conn, dom, oldSrcPath, newSrcPath, devAlias, reason, opaque): print("myDomainEventDiskChangeCallback: Domain %s(%s) disk change oldSrcPath: %s newSrcPath: %s devAlias: %s reason: %s" % ( - dom.name(), dom.ID(), oldSrcPath, newSrcPath, devAlias, reason)) + dom.name(), dom.ID(), oldSrcPath, newSrcPath, devAlias, DISK_EVENTS[reason])) + + def myDomainEventTrayChangeCallback(conn, dom, devAlias, reason, opaque): print("myDomainEventTrayChangeCallback: Domain %s(%s) tray change devAlias: %s reason: %s" % ( - dom.name(), dom.ID(), devAlias, reason)) + dom.name(), dom.ID(), devAlias, TRAY_EVENTS[reason])) + + def myDomainEventPMWakeupCallback(conn, dom, reason, opaque): print("myDomainEventPMWakeupCallback: Domain %s(%s) system pmwakeup" % ( - dom.name(), dom.ID())) + dom.name(), dom.ID())) + + def myDomainEventPMSuspendCallback(conn, dom, reason, opaque): print("myDomainEventPMSuspendCallback: Domain %s(%s) system pmsuspend" % ( - dom.name(), dom.ID())) + dom.name(), dom.ID())) + + def myDomainEventBalloonChangeCallback(conn, dom, actual, opaque): - print("myDomainEventBalloonChangeCallback: Domain %s(%s) %d" % (dom.name(), dom.ID(), actual)) + print("myDomainEventBalloonChangeCallback: Domain %s(%s) %d" % ( + dom.name(), dom.ID(), actual)) + + def myDomainEventPMSuspendDiskCallback(conn, dom, reason, opaque): print("myDomainEventPMSuspendDiskCallback: Domain %s(%s) system pmsuspend_disk" % ( - dom.name(), dom.ID())) + dom.name(), dom.ID())) + + def myDomainEventDeviceRemovedCallback(conn, dom, dev, opaque): print("myDomainEventDeviceRemovedCallback: Domain %s(%s) device removed: %s" % ( - dom.name(), dom.ID(), dev)) + dom.name(), dom.ID(), dev)) + + def myDomainEventBlockJob2Callback(conn, dom, disk, type, status, opaque): - print("myDomainEventBlockJob2Callback: Domain %s(%s) %s on disk %s %s" % (dom.name(), dom.ID(), blockJobTypeToString(type), disk, blockJobStatusToString(status))) + print("myDomainEventBlockJob2Callback: Domain %s(%s) %s on disk %s %s" % ( + dom.name(), dom.ID(), BLOCK_JOB_TYPES[type], disk, BLOCK_JOB_STATUS[status])) + + def myDomainEventTunableCallback(conn, dom, params, opaque): - print("myDomainEventTunableCallback: Domain %s(%s) %s" % (dom.name(), dom.ID(), params)) + print("myDomainEventTunableCallback: Domain %s(%s) %s" % ( + dom.name(), dom.ID(), params)) + + def myDomainEventAgentLifecycleCallback(conn, dom, state, reason, opaque): - print("myDomainEventAgentLifecycleCallback: Domain %s(%s) %s %s" % (dom.name(), dom.ID(), agentLifecycleStateToString(state), agentLifecycleReasonToString(reason))) + print("myDomainEventAgentLifecycleCallback: Domain %s(%s) %s %s" % ( + dom.name(), dom.ID(), AGENT_STATES[state], AGENT_REASONS[reason])) + + def myDomainEventDeviceAddedCallback(conn, dom, dev, opaque): print("myDomainEventDeviceAddedCallback: Domain %s(%s) device added: %s" % ( - dom.name(), dom.ID(), dev)) + dom.name(), dom.ID(), dev)) + + def myDomainEventMigrationIteration(conn, dom, iteration, opaque): print("myDomainEventMigrationIteration: Domain %s(%s) started migration iteration %d" % ( - dom.name(), dom.ID(), iteration)) + dom.name(), dom.ID(), iteration)) + + def myDomainEventJobCompletedCallback(conn, dom, params, opaque): - print("myDomainEventJobCompletedCallback: Domain %s(%s) %s" % (dom.name(), dom.ID(), params)) + print("myDomainEventJobCompletedCallback: Domain %s(%s) %s" % ( + dom.name(), dom.ID(), params)) + + def myDomainEventDeviceRemovalFailedCallback(conn, dom, dev, opaque): print("myDomainEventDeviceRemovalFailedCallback: Domain %s(%s) failed to remove device: %s" % ( - dom.name(), dom.ID(), dev)) + dom.name(), dom.ID(), dev)) + + def myDomainEventMetadataChangeCallback(conn, dom, mtype, nsuri, opaque): print("myDomainEventMetadataChangeCallback: Domain %s(%s) changed metadata mtype=%d nsuri=%s" % ( - dom.name(), dom.ID(), mtype, nsuri)) + dom.name(), dom.ID(), mtype, nsuri)) + + def myDomainEventBlockThresholdCallback(conn, dom, dev, path, threshold, excess, opaque): print("myDomainEventBlockThresholdCallback: Domain %s(%s) block device %s(%s) threshold %d exceeded by %d" % ( - dom.name(), dom.ID(), dev, path, threshold, excess)) + dom.name(), dom.ID(), dev, path, threshold, excess)) + ########################################################################## # Network events ########################################################################## -def netEventToString(event): - netEventStrings = ( "Defined", - "Undefined", - "Started", - "Stopped", - ) - return netEventStrings[event] - -def netDetailToString(event, detail): - netEventStrings = ( - ( "Added", ), - ( "Removed", ), - ( "Started", ), - ( "Stopped", ), - ) - return netEventStrings[event][detail] +NET_EVENTS = Description( + ("Defined", ("Added",)), + ("Undefined", ("Removed",)), + ("Started", ("Started",)), + ("Stopped", ("Stopped",)), +) + def myNetworkEventLifecycleCallback(conn, net, event, detail, opaque): - print("myNetworkEventLifecycleCallback: Network %s %s %s" % (net.name(), - netEventToString(event), - netDetailToString(event, detail))) + print("myNetworkEventLifecycleCallback: Network %s %s %s" % ( + net.name(), NET_EVENTS[event], NET_EVENTS[event][detail])) + ########################################################################## # Storage pool events ########################################################################## -def storageEventToString(event): - storageEventStrings = ( "Defined", - "Undefined", - "Started", - "Stopped", - "Created", - "Deleted", - ) - return storageEventStrings[event] +STORAGE_EVENTS = Description( + ("Defined", ()), + ("Undefined", ()), + ("Started", ()), + ("Stopped", ()), + ("Created", ()), + ("Deleted", ()), +) + def myStoragePoolEventLifecycleCallback(conn, pool, event, detail, opaque): - print("myStoragePoolEventLifecycleCallback: Storage pool %s %s %d" % (pool.name(), - storageEventToString(event), - detail)) + print("myStoragePoolEventLifecycleCallback: Storage pool %s %s %s" % ( + pool.name(), STORAGE_EVENTS[event], STORAGE_EVENTS[event][detail])) + def myStoragePoolEventRefreshCallback(conn, pool, opaque): print("myStoragePoolEventRefreshCallback: Storage pool %s" % pool.name()) + ########################################################################## # Node device events ########################################################################## -def nodeDeviceEventToString(event): - nodeDeviceEventStrings = ( "Created", - "Deleted", - ) - return nodeDeviceEventStrings[event] +DEVICE_EVENTS = Description( + ("Created", ()), + ("Deleted", ()), +) + def myNodeDeviceEventLifecycleCallback(conn, dev, event, detail, opaque): - print("myNodeDeviceEventLifecycleCallback: Node device %s %s %d" % (dev.name(), - nodeDeviceEventToString(event), - detail)) + print("myNodeDeviceEventLifecycleCallback: Node device %s %s %s" % ( + dev.name(), DEVICE_EVENTS[event], DEVICE_EVENTS[event][detail])) + def myNodeDeviceEventUpdateCallback(conn, dev, opaque): print("myNodeDeviceEventUpdateCallback: Node device %s" % dev.name()) + ########################################################################## # Secret events ########################################################################## -def secretEventToString(event): - secretEventStrings = ( "Defined", - "Undefined", - ) - return secretEventStrings[event] +SECRET_EVENTS = Description( + ("Defined", ()), + ("Undefined", ()), +) + def mySecretEventLifecycleCallback(conn, secret, event, detail, opaque): - print("mySecretEventLifecycleCallback: Secret %s %s %d" % (secret.UUIDString(), - secretEventToString(event), - detail)) + print("mySecretEventLifecycleCallback: Secret %s %s %s" % ( + secret.UUIDString(), SECRET_EVENTS[event], SECRET_EVENTS[event][detail])) + def mySecretEventValueChanged(conn, secret, opaque): print("mySecretEventValueChanged: Secret %s" % secret.UUIDString()) + ########################################################################## # Set up and run the program ########################################################################## run = True +CONNECTION_EVENTS = Description("Error", "End-of-file", "Keepalive", "Client") + def myConnectionCloseCallback(conn, reason, opaque): - reasonStrings = ( - "Error", "End-of-file", "Keepalive", "Client", - ) - print("myConnectionCloseCallback: %s: %s" % (conn.getURI(), reasonStrings[reason])) + print("myConnectionCloseCallback: %s: %s" % ( + conn.getURI(), CONNECTION_EVENTS[reason])) + global run run = False + def usage(): - print("usage: "+os.path.basename(sys.argv[0])+" [-hdl] [uri]") + print("usage: %s [-hdl] [uri]" % (os.path.basename(__file__),)) print(" uri will default to qemu:///system") print(" --help, -h Print this help message") print(" --debug, -d Print debug output") print(" --loop=TYPE, -l Choose event-loop-implementation (native, poll, asyncio)") print(" --timeout=SECS Quit after SECS seconds running") + def main(): try: opts, args = getopt.getopt(sys.argv[1:], "hdl:", ["help", "debug", "loop=", "timeout="]) except getopt.GetoptError as err: # print help information and exit: - print(str(err)) # will print something like "option -a not recognized" + print(str(err)) # will print something like "option -a not recognized" usage() sys.exit(2) timeout = None @@ -714,57 +777,66 @@ # Close connection on exit (to test cleanup paths) old_exitfunc = getattr(sys, 'exitfunc', None) + def exit(): print("Closing " + vc.getURI()) - vc.close() - if (old_exitfunc): old_exitfunc() + if run: + vc.close() + if (old_exitfunc): + old_exitfunc() + sys.exitfunc = exit vc.registerCloseCallback(myConnectionCloseCallback, None) - #Add 2 lifecycle callbacks to prove this works with more than just one - vc.domainEventRegister(myDomainEventCallback1,None) - domcallbacks = [] - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_LIFECYCLE, myDomainEventCallback2, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_REBOOT, myDomainEventRebootCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_RTC_CHANGE, myDomainEventRTCChangeCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_WATCHDOG, myDomainEventWatchdogCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_IO_ERROR, myDomainEventIOErrorCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_GRAPHICS, myDomainEventGraphicsCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON, myDomainEventIOErrorReasonCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_CONTROL_ERROR, myDomainEventControlErrorCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_BLOCK_JOB, myDomainEventBlockJobCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_DISK_CHANGE, myDomainEventDiskChangeCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_TRAY_CHANGE, myDomainEventTrayChangeCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_PMWAKEUP, myDomainEventPMWakeupCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_PMSUSPEND, myDomainEventPMSuspendCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE, myDomainEventBalloonChangeCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK, myDomainEventPMSuspendDiskCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED, myDomainEventDeviceRemovedCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2, myDomainEventBlockJob2Callback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_TUNABLE, myDomainEventTunableCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE, myDomainEventAgentLifecycleCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_DEVICE_ADDED, myDomainEventDeviceAddedCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION, myDomainEventMigrationIteration, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_JOB_COMPLETED, myDomainEventJobCompletedCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_DEVICE_REMOVAL_FAILED, myDomainEventDeviceRemovalFailedCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_METADATA_CHANGE, myDomainEventMetadataChangeCallback, None)) - domcallbacks.append(vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_BLOCK_THRESHOLD, myDomainEventBlockThresholdCallback, None)) - - netcallbacks = [] - netcallbacks.append(vc.networkEventRegisterAny(None, libvirt.VIR_NETWORK_EVENT_ID_LIFECYCLE, myNetworkEventLifecycleCallback, None)) - - poolcallbacks = [] - poolcallbacks.append(vc.storagePoolEventRegisterAny(None, libvirt.VIR_STORAGE_POOL_EVENT_ID_LIFECYCLE, myStoragePoolEventLifecycleCallback, None)) - poolcallbacks.append(vc.storagePoolEventRegisterAny(None, libvirt.VIR_STORAGE_POOL_EVENT_ID_REFRESH, myStoragePoolEventRefreshCallback, None)) - - devcallbacks = [] - devcallbacks.append(vc.nodeDeviceEventRegisterAny(None, libvirt.VIR_NODE_DEVICE_EVENT_ID_LIFECYCLE, myNodeDeviceEventLifecycleCallback, None)) - devcallbacks.append(vc.nodeDeviceEventRegisterAny(None, libvirt.VIR_NODE_DEVICE_EVENT_ID_UPDATE, myNodeDeviceEventUpdateCallback, None)) - - seccallbacks = [] - seccallbacks.append(vc.secretEventRegisterAny(None, libvirt.VIR_SECRET_EVENT_ID_LIFECYCLE, mySecretEventLifecycleCallback, None)) - seccallbacks.append(vc.secretEventRegisterAny(None, libvirt.VIR_SECRET_EVENT_ID_VALUE_CHANGED, mySecretEventValueChanged, None)) + # Add 2 lifecycle callbacks to prove this works with more than just one + vc.domainEventRegister(myDomainEventCallback, 1) + domcallbacks = [ + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_LIFECYCLE, myDomainEventCallback, 2), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_REBOOT, myDomainEventRebootCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_RTC_CHANGE, myDomainEventRTCChangeCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_WATCHDOG, myDomainEventWatchdogCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_IO_ERROR, myDomainEventIOErrorCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_GRAPHICS, myDomainEventGraphicsCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_IO_ERROR_REASON, myDomainEventIOErrorReasonCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_CONTROL_ERROR, myDomainEventControlErrorCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_BLOCK_JOB, myDomainEventBlockJobCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_DISK_CHANGE, myDomainEventDiskChangeCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_TRAY_CHANGE, myDomainEventTrayChangeCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_PMWAKEUP, myDomainEventPMWakeupCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_PMSUSPEND, myDomainEventPMSuspendCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE, myDomainEventBalloonChangeCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK, myDomainEventPMSuspendDiskCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED, myDomainEventDeviceRemovedCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_BLOCK_JOB_2, myDomainEventBlockJob2Callback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_TUNABLE, myDomainEventTunableCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE, myDomainEventAgentLifecycleCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_DEVICE_ADDED, myDomainEventDeviceAddedCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION, myDomainEventMigrationIteration, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_JOB_COMPLETED, myDomainEventJobCompletedCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_DEVICE_REMOVAL_FAILED, myDomainEventDeviceRemovalFailedCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_METADATA_CHANGE, myDomainEventMetadataChangeCallback, None), + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_BLOCK_THRESHOLD, myDomainEventBlockThresholdCallback, None), + ] + + netcallbacks = [ + vc.networkEventRegisterAny(None, libvirt.VIR_NETWORK_EVENT_ID_LIFECYCLE, myNetworkEventLifecycleCallback, None), + ] + + poolcallbacks = [ + vc.storagePoolEventRegisterAny(None, libvirt.VIR_STORAGE_POOL_EVENT_ID_LIFECYCLE, myStoragePoolEventLifecycleCallback, None), + vc.storagePoolEventRegisterAny(None, libvirt.VIR_STORAGE_POOL_EVENT_ID_REFRESH, myStoragePoolEventRefreshCallback, None), + ] + + devcallbacks = [ + vc.nodeDeviceEventRegisterAny(None, libvirt.VIR_NODE_DEVICE_EVENT_ID_LIFECYCLE, myNodeDeviceEventLifecycleCallback, None), + vc.nodeDeviceEventRegisterAny(None, libvirt.VIR_NODE_DEVICE_EVENT_ID_UPDATE, myNodeDeviceEventUpdateCallback, None), + ] + + seccallbacks = [ + vc.secretEventRegisterAny(None, libvirt.VIR_SECRET_EVENT_ID_LIFECYCLE, mySecretEventLifecycleCallback, None), + vc.secretEventRegisterAny(None, libvirt.VIR_SECRET_EVENT_ID_VALUE_CHANGED, mySecretEventValueChanged, None), + ] vc.setKeepAlive(5, 3) @@ -777,7 +849,12 @@ count = count + 1 time.sleep(1) - vc.domainEventDeregister(myDomainEventCallback1) + # If the connection was closed, we cannot unregister anything. + # Just abort now. + if not run: + return + + vc.domainEventDeregister(myDomainEventCallback) for id in seccallbacks: vc.secretEventDeregisterAny(id) @@ -796,5 +873,6 @@ # Allow delayed event loop cleanup to run, just for sake of testing time.sleep(2) + if __name__ == "__main__": main() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libvirt-python-4.7.0/libvirt-python.spec new/libvirt-python-4.8.0/libvirt-python.spec --- old/libvirt-python-4.7.0/libvirt-python.spec 2018-09-03 19:24:37.000000000 +0200 +++ new/libvirt-python-4.8.0/libvirt-python.spec 2018-10-01 17:29:59.000000000 +0200 @@ -33,7 +33,7 @@ Summary: The libvirt virtualization API python2 binding Name: libvirt-python -Version: 4.7.0 +Version: 4.8.0 Release: 1%{?dist}%{?extra_release} Source0: http://libvirt.org/sources/python/%{name}-%{version}.tar.gz Url: http://libvirt.org diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/libvirt-python-4.7.0/setup.py new/libvirt-python-4.8.0/setup.py --- old/libvirt-python-4.7.0/setup.py 2018-09-03 19:23:12.000000000 +0200 +++ new/libvirt-python-4.8.0/setup.py 2018-10-01 17:00:49.000000000 +0200 @@ -334,7 +334,7 @@ _c_modules, _py_modules = get_module_lists() setup(name = 'libvirt-python', - version = '4.7.0', + version = '4.8.0', url = 'http://www.libvirt.org', maintainer = 'Libvirt Maintainers', maintainer_email = 'libvir-l...@redhat.com',