QMP: Revamp the Python class example (1d00a07d) · Commits · SUMMER2020 / students / proj-2021291

QMP/qmp.py

+106 −51

Original line number	Diff line number	Diff line
		# QEMU Monitor Protocol Python class
		#
		# Copyright (C) 2009 Red Hat Inc.
		# Copyright (C) 2009, 2010 Red Hat Inc.
		#
		# Authors:
		# Luiz Capitulino <lcapitulino@redhat.com>
		@@ -8,7 +8,9 @@
		# This work is licensed under the terms of the GNU GPL, version 2. See
		# the COPYING file in the top-level directory.

		import socket, json
		import json
		import errno
		import socket

		class QMPError(Exception):
		pass
		@@ -16,61 +18,114 @@ class QMPError(Exception):
		class QMPConnectError(QMPError):
		pass

		class QMPCapabilitiesError(QMPError):
		pass

		class QEMUMonitorProtocol:
		def connect(self):
		self.sock.connect(self.filename)
		data = self.__json_read()
		if data == None:
		raise QMPConnectError
		if not data.has_key('QMP'):
		raise QMPConnectError
		return data['QMP']['capabilities']
		def __init__(self, address):
		"""
		Create a QEMUMonitorProtocol class.

		def close(self):
		self.sock.close()
		@param address: QEMU address, can be either a unix socket path (string)
		or a tuple in the form ( address, port ) for a TCP
		connection
		@note No connection is established, this is done by the connect() method
		"""
		self.__events = []
		self.__address = address
		self.__sock = self.__get_sock()
		self.__sockfile = self.__sock.makefile()

		def send_raw(self, line):
		self.sock.send(str(line))
		return self.__json_read()
		def __get_sock(self):
		if isinstance(self.__address, tuple):
		family = socket.AF_INET
		else:
		family = socket.AF_UNIX
		return socket.socket(family, socket.SOCK_STREAM)

		def send(self, cmdline):
		cmd = self.__build_cmd(cmdline)
		self.__json_send(cmd)
		resp = self.__json_read()
		if resp == None:
		def __json_read(self):
		while True:
		data = self.__sockfile.readline()
		if not data:
		return
		elif resp.has_key('error'):
		return resp['error']
		else:
		return resp['return']
		resp = json.loads(data)
		if 'event' in resp:
		self.__events.append(resp)
		continue
		return resp

		def __build_cmd(self, cmdline):
		cmdargs = cmdline.split()
		qmpcmd = { 'execute': cmdargs[0], 'arguments': {} }
		for arg in cmdargs[1:]:
		opt = arg.split('=')
		try:
		value = int(opt[1])
		except ValueError:
		value = opt[1]
		qmpcmd['arguments'][opt[0]] = value
		return qmpcmd
		error = socket.error

		def connect(self):
		"""
		Connect to the QMP Monitor and perform capabilities negotiation.

		@return QMP greeting dict
		@raise socket.error on socket connection errors
		@raise QMPConnectError if the greeting is not received
		@raise QMPCapabilitiesError if fails to negotiate capabilities
		"""
		self.__sock.connect(self.__address)
		greeting = self.__json_read()
		if greeting is None or not greeting.has_key('QMP'):
		raise QMPConnectError
		# Greeting seems ok, negotiate capabilities
		resp = self.cmd('qmp_capabilities')
		if "return" in resp:
		return greeting
		raise QMPCapabilitiesError

		def __json_send(self, cmd):
		# XXX: We have to send any additional char, otherwise
		# the Server won't read our input
		self.sock.send(json.dumps(cmd) + ' ')
		def cmd_obj(self, qmp_cmd):
		"""
		Send a QMP command to the QMP Monitor.

		def __json_read(self):
		@param qmp_cmd: QMP command to be sent as a Python dict
		@return QMP response as a Python dict or None if the connection has
		been closed
		"""
		try:
		while True:
		line = json.loads(self.sockfile.readline())
		if not 'event' in line:
		return line
		except ValueError:
		self.__sock.sendall(json.dumps(qmp_cmd))
		except socket.error, err:
		if err[0] == errno.EPIPE:
		return
		raise socket.error(err)
		return self.__json_read()

		def cmd(self, name, args=None, id=None):
		"""
		Build a QMP command and send it to the QMP Monitor.

		def __init__(self, filename):
		self.filename = filename
		self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
		self.sockfile = self.sock.makefile()
		@param name: command name (string)
		@param args: command arguments (dict)
		@param id: command id (dict, list, string or int)
		"""
		qmp_cmd = { 'execute': name }
		if args:
		qmp_cmd['arguments'] = args
		if id:
		qmp_cmd['id'] = id
		return self.cmd_obj(qmp_cmd)

		def get_events(self):
		"""
		Get a list of available QMP events.
		"""
		self.__sock.setblocking(0)
		try:
		self.__json_read()
		except socket.error, err:
		if err[0] == errno.EAGAIN:
		# No data available
		pass
		self.__sock.setblocking(1)
		return self.__events

		def clear_events(self):
		"""
		Clear current list of pending events.
		"""
		self.__events = []

		def close(self):
		self.__sock.close()
		self.__sockfile.close()