Merge remote branch 'cros/upstream' into master

client/tests/kvm/kvm_monitor.py

 """
 Interfaces to the QEMU monitor.
 
 @copyright: 2008-2010 Red Hat Inc.
 """
 
 import socket, time, threading, logging, select
 import kvm_utils
 try:
     import json
 except ImportError:
     logging.warning("Could not import json module. "
                     "QMP monitor functionality disabled.")
 
 
 class MonitorError(Exception):
     pass
 
 
 class MonitorConnectError(MonitorError):
     pass
 
 
 class MonitorSocketError(MonitorError):
-    pass
+    def __init__(self, msg, e):
+        Exception.__init__(self, msg, e)
+        self.msg = msg
+        self.e = e
+
+    def __str__(self):
+        return "%s    (%s)" % (self.msg, self.e)
 
 
 class MonitorLockError(MonitorError):
     pass
 
 
 class MonitorProtocolError(MonitorError):
     pass
 
 
 class MonitorNotSupportedError(MonitorError):
     pass
 
 
 class QMPCmdError(MonitorError):
     def __init__(self, cmd, qmp_args, data):
         MonitorError.__init__(self, cmd, qmp_args, data)
         self.cmd = cmd
         self.qmp_args = qmp_args
         self.data = data
 
     def __str__(self):
-        return ("QMP command %r failed (arguments: %r, error message: %r)" %
-                (self.cmd, self.qmp_args, self.data))
+        return ("QMP command %r failed    (arguments: %r,    "
+                "error message: %r)" % (self.cmd, self.qmp_args, self.data))
 
 
 class Monitor:
     """
     Common code for monitor classes.
     """
 
     def __init__(self, name, filename):
         """
         Initialize the instance.
@@ skipping 52 matching lines @@
     def _data_available(self, timeout=0):
         timeout = max(0, timeout)
         return bool(select.select([self._socket], [], [], timeout)[0])
 
 
     def _recvall(self):
         s = ""
         while self._data_available():
             try:
                 data = self._socket.recv(1024)
-            except socket.error, (errno, msg):
-                raise MonitorSocketError("Could not receive data from monitor "
-                                         "(%s)" % msg)
+            except socket.error, e:
+                raise MonitorSocketError("Could not receive data from monitor",
+                                         e)
             if not data:
                 break
             s += data
         return s
 
 
+    def is_responsive(self):
+        """
+        Return True iff the monitor is responsive.
+        """
+        try:
+            self.verify_responsive()
+            return True
+        except MonitorError:
+            return False
+
+
 class HumanMonitor(Monitor):
     """
     Wraps "human monitor" commands.
     """
 
     def __init__(self, name, filename, suppress_exceptions=False):
         """
         Connect to the monitor socket and find the (qemu) prompt.
 
         @param name: Monitor identifier (a string)
@@ skipping 53 matching lines @@
         @raise MonitorLockError: Raised if the lock cannot be acquired
         @raise MonitorSocketError: Raised if a socket error occurs
         """
         if not self._acquire_lock(20):
             raise MonitorLockError("Could not acquire exclusive lock to send "
                                    "monitor command '%s'" % cmd)
 
         try:
             try:
                 self._socket.sendall(cmd + "\n")
-            except socket.error, (errno, msg):
-                raise MonitorSocketError("Could not send monitor command '%s' "
-                                         "(%s)" % (cmd, msg))
+            except socket.error, e:
+                raise MonitorSocketError("Could not send monitor command %r" %
+                                         cmd, e)
 
         finally:
             self._lock.release()
 
 
     # Public methods
 
     def cmd(self, command, timeout=20):
         """
         Send command to the monitor.
@@ skipping 24 matching lines @@
                 return o
             else:
                 msg = ("Could not find (qemu) prompt after command '%s'. "
                        "Output so far: %r" % (command, o))
                 raise MonitorProtocolError(msg)
 
         finally:
             self._lock.release()
 
 
-    def is_responsive(self):
+    def verify_responsive(self):
         """
         Make sure the monitor is responsive by sending a command.
-
-        @return: True if responsive, False otherwise
         """
-        try:
-            self.cmd("info status")
-            return True
-        except MonitorError:
-            return False
+        self.cmd("info status")
 
 
     # Command wrappers
     # Notes:
     # - All of the following commands raise exceptions in a similar manner to
     #   cmd().
     # - A command wrapper should use self._help_str if it requires information
     #   about the monitor's capabilities.
 
     def quit(self):
@@ skipping 30 matching lines @@
     def migrate(self, uri, full_copy=False, incremental_copy=False, wait=False):
         """
         Migrate.
 
         @param uri: destination URI
         @param full_copy: If true, migrate with full disk copy
         @param incremental_copy: If true, migrate with incremental disk copy
         @param wait: If true, wait for completion
         @return: The command's output
         """
-        logging.debug("Migrating to: %s" % uri)
         cmd = "migrate"
         if not wait:
             cmd += " -d"
         if full_copy:
             cmd += " -b"
         if incremental_copy:
             cmd += " -i"
         cmd += " %s" % uri
         return self.cmd(cmd)
 
@@ skipping 150 matching lines @@
 
     def _send(self, data):
         """
         Send raw data without waiting for response.
 
         @param data: Data to send
         @raise MonitorSocketError: Raised if a socket error occurs
         """
         try:
             self._socket.sendall(data)
-        except socket.error, (errno, msg):
-            raise MonitorSocketError("Could not send data: %r (%s)" %
-                                     (data, msg))
+        except socket.error, e:
+            raise MonitorSocketError("Could not send data: %r" % data, e)
 
 
     def _get_response(self, id=None, timeout=20):
         """
         Read a response from the QMP monitor.
 
         @param id: If not None, look for a response with this id
         @param timeout: Time duration to wait for response
         @return: The response dict, or None if none was found
         """
@@ skipping 112 matching lines @@
         @param id:  An id for the command, or None
         @param timeout: Time duration to wait for response
         @return: The response received
         @raise MonitorLockError: Raised if the lock cannot be acquired
         @raise MonitorSocketError: Raised if a socket error occurs
         @raise MonitorProtocolError: Raised if no response is received
         """
         return self.cmd_obj(self._build_cmd(cmd, args, id), timeout)
 
 
-    def is_responsive(self):
+    def verify_responsive(self):
         """
         Make sure the monitor is responsive by sending a command.
-
-        @return: True if responsive, False otherwise
         """
-        try:
-            self.cmd("query-status")
-            return True
-        except MonitorError:
-            return False
+        self.cmd("query-status")
 
 
     def get_events(self):
         """
         Return a list of the asynchronous events received since the last
         clear_events() call.
 
         @return: A list of events (the objects returned have an "event" key)
         @raise MonitorLockError: Raised if the lock cannot be acquired
         """
@@ skipping 93 matching lines @@
 
     def migrate_set_speed(self, value):
         """
         Set maximum speed (in bytes/sec) for migrations.
 
         @param value: Speed in bytes/sec
         @return: The response to the command
         """
         args = {"value": value}
         return self.cmd("migrate_set_speed", args)