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 - [email protected]
+
+- 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 <[email protected]>
+
+ event-test.py: Fix blanks
+ Closer to pep8
+
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ event-test.py: Convert CONNECTION events
+ to use new Description class
+
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ event-test.py: Convert SECRET events
+ to use new Description class
+
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ event-test.py: Convert DEVICE events
+ to use new Description class
+
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ event-test.py: Convert STORAGE events
+ to use new Description class
+
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ event-test.py: Convert NETWORK events
+ to use new Description class
+
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ event-test.py: Convert TRAY events
+ to use new Description class
+
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ event-test.py: Convert DISK events
+ to use new Description class
+
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ event-test.py: Convert GRAPHICS events
+ to use new Description class
+
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ event-test.py: Convert AGENT events
+ to use new Description class
+
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ event-test.py: Convert ERROR events
+ to use new Description class
+
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ event-test.py: Convert WATCHDOG events
+ to use new Description class
+
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ event-test.py: Convert BLOCKJOB events
+ to use new Description class
+
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ event-test.py: Convert LIVECYCLE events
+ to use new Description class
+
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ event-test.py: Add class for event descriptions
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ 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 <[email protected]>
+
+ 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 <[email protected]>
+
+ event-test.py: Use __file__
+ instead of sys.argv[0]
+
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ event-test.py: Add missing globale statement
+ to fix loop termination on exit.
+
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ event-test.py: Remove dead assignment
+ variable is unused
+
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ event-test.py: Remove extra parenthesis
+
+
+2018-09-24 Philipp Hahn <[email protected]>
+
+ 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 <[email protected]>
+
+ 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 <[email protected]>
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 = '[email protected]',
