Merge remote branch 'autotest-upstream/master' into autotest-merge

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
@@ skipping 158 matching lines @@
             self.protocol = "human"
 
             # Find the initial (qemu) prompt
             s, o = self._read_up_to_qemu_prompt(20)
             if not s:
                 raise MonitorProtocolError("Could not find (qemu) prompt "
                                            "after connecting to monitor. "
                                            "Output so far: %r" % o)
 
             # Save the output of 'help' for future use
-            self._help_str = self.cmd("help")
+            self._help_str = self.cmd("help", debug=False)
 
         except MonitorError, e:
             if suppress_exceptions:
                 logging.warn(e)
             else:
                 raise
 
 
     # Private methods
 
@@ skipping 31 matching lines @@
             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):
+    def cmd(self, command, timeout=20, debug=True):
         """
         Send command to the monitor.
 
         @param command: Command to send to the monitor
         @param timeout: Time duration to wait for the (qemu) prompt to return
+        @param debug: Whether to print the commands being sent and responses
         @return: Output received from the monitor
         @raise MonitorLockError: Raised if the lock cannot be acquired
         @raise MonitorSocketError: Raised if a socket error occurs
         @raise MonitorProtocolError: Raised if the (qemu) prompt cannot be
                 found after sending the command
         """
+        if debug:
+            logging.debug("(monitor %s) Sending command '%s'",
+                          self.name, command)
         if not self._acquire_lock(20):
             raise MonitorLockError("Could not acquire exclusive lock to send "
                                    "monitor command '%s'" % command)
 
         try:
             # Read any data that might be available
             self._recvall()
             # Send command
             self._send(command)
             # Read output
             s, o = self._read_up_to_qemu_prompt(timeout)
             # Remove command echo from output
             o = "\n".join(o.splitlines()[1:])
             # Report success/failure
             if s:
+                if debug and o:
+                    logging.debug("(monitor %s) "
+                                  "Response to '%s'", self.name,
+                                  command)
+                    for l in o.splitlines():
+                        logging.debug("(monitor %s)    %s", self.name, l)
                 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 verify_responsive(self):
         """
         Make sure the monitor is responsive by sending a command.
         """
-        self.cmd("info status")
+        self.cmd("info status", debug=False)
 
 
     # 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 10 matching lines @@
         return self.cmd("info %s" % what)
 
 
     def query(self, what):
         """
         Alias for info.
         """
         return self.info(what)
 
 
-    def screendump(self, filename):
+    def screendump(self, filename, debug=True):
         """
         Request a screendump.
 
         @param filename: Location for the screendump
         @return: The command's output
         """
-        return self.cmd("screendump %s" % filename)
+        return self.cmd(command="screendump %s" % filename, debug=debug)
 
 
     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
@@ skipping 186 matching lines @@
             for obj in self._read_objects():
                 if isinstance(obj, dict):
                     if id is not None and obj.get("id") != id:
                         continue
                     if "return" in obj or "error" in obj:
                         return obj
 
 
     # Public methods
 
-    def cmd(self, cmd, args=None, timeout=20):
+    def cmd(self, cmd, args=None, timeout=20, debug=True):
         """
         Send a QMP monitor command and return the response.
 
         Note: an id is automatically assigned to the command and the response
         is checked for the presence of the same id.
 
         @param cmd: Command to send
         @param args: A dict containing command arguments, 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
         @raise QMPCmdError: Raised if the response is an error message
                 (the exception's args are (cmd, args, data) where data is the
                 error data)
         """
+        if debug:
+            logging.debug("(monitor %s) Sending command '%s'",
+                          self.name, cmd)
         if not self._acquire_lock(20):
             raise MonitorLockError("Could not acquire exclusive lock to send "
                                    "QMP command '%s'" % cmd)
 
         try:
             # Read any data that might be available
             self._read_objects()
             # Send command
             id = kvm_utils.generate_random_string(8)
             self._send(json.dumps(self._build_cmd(cmd, args, id)) + "\n")
             # Read response
             r = self._get_response(id, timeout)
             if r is None:
                 raise MonitorProtocolError("Received no response to QMP "
                                            "command '%s', or received a "
                                            "response with an incorrect id"
                                            % cmd)
             if "return" in r:
+                if debug and r["return"]:
+                    logging.debug("(monitor %s) "
+                                  "Response to '%s'", self.name, cmd)
+                    o = str(r["return"])
+                    for l in o.splitlines():
+                        logging.debug("(monitor %s)    %s", self.name, l)
                 return r["return"]
             if "error" in r:
                 raise QMPCmdError(cmd, args, r["error"])
 
         finally:
             self._lock.release()
 
 
     def cmd_raw(self, data, timeout=20):
         """
@@ skipping 58 matching lines @@
         @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 verify_responsive(self):
         """
         Make sure the monitor is responsive by sending a command.
         """
-        self.cmd("query-status")
+        self.cmd(cmd="query-status", debug=False)
 
 
     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 57 matching lines @@
         return self.cmd("query-%s" % what)
 
 
     def query(self, what):
         """
         Alias for info.
         """
         return self.info(what)
 
 
-    def screendump(self, filename):
+    def screendump(self, filename, debug=True):
         """
         Request a screendump.
 
         @param filename: Location for the screendump
         @return: The response to the command
         """
         args = {"filename": filename}
-        return self.cmd("screendump", args)
+        return self.cmd(cmd="screendump", args=args, debug=debug)
 
 
     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 response to the command
         """
         args = {"uri": uri,
                 "blk": full_copy,
                 "inc": incremental_copy}
         return self.cmd("migrate", args)
 
 
     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)