2009-11-27 01:59:09 +01:00
|
|
|
#!/usr/bin/python
|
|
|
|
#
|
2010-10-27 21:57:51 +02:00
|
|
|
# Low-level QEMU shell on top of QMP.
|
2009-11-27 01:59:09 +01:00
|
|
|
#
|
2010-10-27 21:57:51 +02:00
|
|
|
# Copyright (C) 2009, 2010 Red Hat Inc.
|
2009-11-27 01:59:09 +01:00
|
|
|
#
|
|
|
|
# Authors:
|
|
|
|
# Luiz Capitulino <lcapitulino@redhat.com>
|
|
|
|
#
|
|
|
|
# This work is licensed under the terms of the GNU GPL, version 2. See
|
|
|
|
# the COPYING file in the top-level directory.
|
|
|
|
#
|
|
|
|
# Usage:
|
|
|
|
#
|
|
|
|
# Start QEMU with:
|
|
|
|
#
|
2010-10-27 21:57:51 +02:00
|
|
|
# # qemu [...] -qmp unix:./qmp-sock,server
|
2009-11-27 01:59:09 +01:00
|
|
|
#
|
|
|
|
# Run the shell:
|
|
|
|
#
|
2010-10-27 21:57:51 +02:00
|
|
|
# $ qmp-shell ./qmp-sock
|
2009-11-27 01:59:09 +01:00
|
|
|
#
|
|
|
|
# Commands have the following format:
|
|
|
|
#
|
2010-10-27 21:57:51 +02:00
|
|
|
# < command-name > [ arg-name1=arg1 ] ... [ arg-nameN=argN ]
|
2009-11-27 01:59:09 +01:00
|
|
|
#
|
|
|
|
# For example:
|
|
|
|
#
|
2010-10-27 21:57:51 +02:00
|
|
|
# (QEMU) device_add driver=e1000 id=net1
|
|
|
|
# {u'return': {}}
|
|
|
|
# (QEMU)
|
2015-07-01 20:25:49 +02:00
|
|
|
#
|
|
|
|
# key=value pairs also support Python or JSON object literal subset notations,
|
|
|
|
# without spaces. Dictionaries/objects {} are supported as are arrays [].
|
|
|
|
#
|
|
|
|
# example-command arg-name1={'key':'value','obj'={'prop':"value"}}
|
|
|
|
#
|
|
|
|
# Both JSON and Python formatting should work, including both styles of
|
|
|
|
# string literal quotes. Both paradigms of literal values should work,
|
|
|
|
# including null/true/false for JSON and None/True/False for Python.
|
|
|
|
#
|
|
|
|
#
|
|
|
|
# Transactions have the following multi-line format:
|
|
|
|
#
|
|
|
|
# transaction(
|
|
|
|
# action-name1 [ arg-name1=arg1 ] ... [arg-nameN=argN ]
|
|
|
|
# ...
|
|
|
|
# action-nameN [ arg-name1=arg1 ] ... [arg-nameN=argN ]
|
|
|
|
# )
|
|
|
|
#
|
|
|
|
# One line transactions are also supported:
|
|
|
|
#
|
|
|
|
# transaction( action-name1 ... )
|
|
|
|
#
|
|
|
|
# For example:
|
|
|
|
#
|
|
|
|
# (QEMU) transaction(
|
|
|
|
# TRANS> block-dirty-bitmap-add node=drive0 name=bitmap1
|
|
|
|
# TRANS> block-dirty-bitmap-clear node=drive0 name=bitmap0
|
|
|
|
# TRANS> )
|
|
|
|
# {"return": {}}
|
|
|
|
# (QEMU)
|
|
|
|
#
|
|
|
|
# Use the -v and -p options to activate the verbose and pretty-print options,
|
|
|
|
# which will echo back the properly formatted JSON-compliant QMP that is being
|
|
|
|
# sent to QEMU, which is useful for debugging and documentation generation.
|
2009-11-27 01:59:09 +01:00
|
|
|
|
|
|
|
import qmp
|
2014-01-29 12:17:31 +01:00
|
|
|
import json
|
scripts: qmp-shell: Expand support for QMP expressions
This includes support for [] expressions, single-quotes in
QMP expressions (which is not strictly a part of JSON), and
the ability to use "True", "False" and "None" literals instead
of JSON's equivalent true, false, and null literals.
qmp-shell currently allows you to describe values as
JSON expressions:
key={"key":{"key2":"val"}}
But it does not currently support arrays, which are needed
for serializing and deserializing transactions:
key=[{"type":"drive-backup","data":{...}}]
qmp-shell also only currently accepts doubly quoted strings
as-per JSON spec, but QMP allows single quotes.
Lastly, python allows you to utilize "True" or "False" as
boolean literals, but JSON expects "true" or "false". Expand
qmp-shell to allow the user to type either, converting to the
correct type.
As a consequence of the above, the key=val parsing is also improved
to give better error messages if a key=val token is not provided.
CAVEAT: The parser is still extremely rudimentary and does not
expect to find spaces in {} nor [] expressions. This patch does
not improve this functionality.
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Tested-by: Kashyap Chamarthy <kchamart@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-04-29 21:14:02 +02:00
|
|
|
import ast
|
2009-11-27 01:59:09 +01:00
|
|
|
import readline
|
2010-10-27 21:57:51 +02:00
|
|
|
import sys
|
2017-04-28 00:36:28 +02:00
|
|
|
import os
|
|
|
|
import errno
|
|
|
|
import atexit
|
2009-11-27 01:59:09 +01:00
|
|
|
|
2010-10-27 21:57:51 +02:00
|
|
|
class QMPCompleter(list):
|
|
|
|
def complete(self, text, state):
|
|
|
|
for cmd in self:
|
|
|
|
if cmd.startswith(text):
|
|
|
|
if not state:
|
|
|
|
return cmd
|
|
|
|
else:
|
|
|
|
state -= 1
|
2009-11-27 01:59:09 +01:00
|
|
|
|
2010-10-27 21:57:51 +02:00
|
|
|
class QMPShellError(Exception):
|
|
|
|
pass
|
|
|
|
|
|
|
|
class QMPShellBadPort(QMPShellError):
|
|
|
|
pass
|
|
|
|
|
scripts: qmp-shell: Expand support for QMP expressions
This includes support for [] expressions, single-quotes in
QMP expressions (which is not strictly a part of JSON), and
the ability to use "True", "False" and "None" literals instead
of JSON's equivalent true, false, and null literals.
qmp-shell currently allows you to describe values as
JSON expressions:
key={"key":{"key2":"val"}}
But it does not currently support arrays, which are needed
for serializing and deserializing transactions:
key=[{"type":"drive-backup","data":{...}}]
qmp-shell also only currently accepts doubly quoted strings
as-per JSON spec, but QMP allows single quotes.
Lastly, python allows you to utilize "True" or "False" as
boolean literals, but JSON expects "true" or "false". Expand
qmp-shell to allow the user to type either, converting to the
correct type.
As a consequence of the above, the key=val parsing is also improved
to give better error messages if a key=val token is not provided.
CAVEAT: The parser is still extremely rudimentary and does not
expect to find spaces in {} nor [] expressions. This patch does
not improve this functionality.
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Tested-by: Kashyap Chamarthy <kchamart@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-04-29 21:14:02 +02:00
|
|
|
class FuzzyJSON(ast.NodeTransformer):
|
|
|
|
'''This extension of ast.NodeTransformer filters literal "true/false/null"
|
|
|
|
values in an AST and replaces them by proper "True/False/None" values that
|
|
|
|
Python can properly evaluate.'''
|
|
|
|
def visit_Name(self, node):
|
|
|
|
if node.id == 'true':
|
|
|
|
node.id = 'True'
|
|
|
|
if node.id == 'false':
|
|
|
|
node.id = 'False'
|
|
|
|
if node.id == 'null':
|
|
|
|
node.id = 'None'
|
|
|
|
return node
|
|
|
|
|
2010-10-27 21:57:51 +02:00
|
|
|
# TODO: QMPShell's interface is a bit ugly (eg. _fill_completion() and
|
|
|
|
# _execute_cmd()). Let's design a better one.
|
|
|
|
class QMPShell(qmp.QEMUMonitorProtocol):
|
qmp-shell: fix pretty printing of JSON responses
Pretty printing of JSON responses is important to be able to understand
large responses from query commands in particular. Unfortunately this
was broken during the addition of the verbose flag in
commit 1ceca07e48ead0dd2e41576c81d40e6a91cafefd
Author: John Snow <jsnow@redhat.com>
Date: Wed Apr 29 15:14:04 2015 -0400
scripts: qmp-shell: Add verbose flag
This is because that change turned the python data structure into a
formatted JSON string before the pretty print was given it. So we're
just pretty printing a string, which is a no-op.
The original pretty printer would output python objects.
(QEMU) query-chardev
{ u'return': [ { u'filename': u'vc',
u'frontend-open': False,
u'label': u'parallel0'},
{ u'filename': u'vc',
u'frontend-open': True,
u'label': u'serial0'},
{ u'filename': u'unix:/tmp/qemp,server',
u'frontend-open': True,
u'label': u'compat_monitor0'}]}
This fixes the problem by switching to outputting pretty formatted JSON
text instead. This has the added benefit that the pretty printed output
is now valid JSON text. Due to the way the verbose flag was handled, the
pretty printing now applies to the command sent, as well as its response:
(QEMU) query-chardev
{
"execute": "query-chardev",
"arguments": {}
}
{
"return": [
{
"frontend-open": false,
"label": "parallel0",
"filename": "vc"
},
{
"frontend-open": true,
"label": "serial0",
"filename": "vc"
},
{
"frontend-open": true,
"label": "compat_monitor0",
"filename": "unix:/tmp/qmp,server"
}
]
}
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-Id: <1456224706-1591-1-git-send-email-berrange@redhat.com>
Tested-by: Kashyap Chamarthy <kchamart@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
[Bonus fix: multiple -p now work]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-02-23 11:51:46 +01:00
|
|
|
def __init__(self, address, pretty=False):
|
2010-10-27 21:57:51 +02:00
|
|
|
qmp.QEMUMonitorProtocol.__init__(self, self.__get_address(address))
|
|
|
|
self._greeting = None
|
|
|
|
self._completer = None
|
qmp-shell: fix pretty printing of JSON responses
Pretty printing of JSON responses is important to be able to understand
large responses from query commands in particular. Unfortunately this
was broken during the addition of the verbose flag in
commit 1ceca07e48ead0dd2e41576c81d40e6a91cafefd
Author: John Snow <jsnow@redhat.com>
Date: Wed Apr 29 15:14:04 2015 -0400
scripts: qmp-shell: Add verbose flag
This is because that change turned the python data structure into a
formatted JSON string before the pretty print was given it. So we're
just pretty printing a string, which is a no-op.
The original pretty printer would output python objects.
(QEMU) query-chardev
{ u'return': [ { u'filename': u'vc',
u'frontend-open': False,
u'label': u'parallel0'},
{ u'filename': u'vc',
u'frontend-open': True,
u'label': u'serial0'},
{ u'filename': u'unix:/tmp/qemp,server',
u'frontend-open': True,
u'label': u'compat_monitor0'}]}
This fixes the problem by switching to outputting pretty formatted JSON
text instead. This has the added benefit that the pretty printed output
is now valid JSON text. Due to the way the verbose flag was handled, the
pretty printing now applies to the command sent, as well as its response:
(QEMU) query-chardev
{
"execute": "query-chardev",
"arguments": {}
}
{
"return": [
{
"frontend-open": false,
"label": "parallel0",
"filename": "vc"
},
{
"frontend-open": true,
"label": "serial0",
"filename": "vc"
},
{
"frontend-open": true,
"label": "compat_monitor0",
"filename": "unix:/tmp/qmp,server"
}
]
}
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-Id: <1456224706-1591-1-git-send-email-berrange@redhat.com>
Tested-by: Kashyap Chamarthy <kchamart@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
[Bonus fix: multiple -p now work]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-02-23 11:51:46 +01:00
|
|
|
self._pretty = pretty
|
2015-04-29 21:14:03 +02:00
|
|
|
self._transmode = False
|
|
|
|
self._actions = list()
|
2017-04-28 00:36:28 +02:00
|
|
|
self._histfile = os.path.join(os.path.expanduser('~'),
|
|
|
|
'.qmp-shell_history')
|
2010-10-27 21:57:51 +02:00
|
|
|
|
|
|
|
def __get_address(self, arg):
|
|
|
|
"""
|
|
|
|
Figure out if the argument is in the port:host form, if it's not it's
|
|
|
|
probably a file path.
|
|
|
|
"""
|
|
|
|
addr = arg.split(':')
|
|
|
|
if len(addr) == 2:
|
|
|
|
try:
|
|
|
|
port = int(addr[1])
|
|
|
|
except ValueError:
|
|
|
|
raise QMPShellBadPort
|
|
|
|
return ( addr[0], port )
|
|
|
|
# socket path
|
|
|
|
return arg
|
|
|
|
|
|
|
|
def _fill_completion(self):
|
2017-05-04 14:54:30 +02:00
|
|
|
cmds = self.cmd('query-commands')
|
|
|
|
if cmds.has_key('error'):
|
|
|
|
return
|
|
|
|
for cmd in cmds['return']:
|
2010-10-27 21:57:51 +02:00
|
|
|
self._completer.append(cmd['name'])
|
|
|
|
|
|
|
|
def __completer_setup(self):
|
|
|
|
self._completer = QMPCompleter()
|
|
|
|
self._fill_completion()
|
2017-04-28 00:36:28 +02:00
|
|
|
readline.set_history_length(1024)
|
2010-10-27 21:57:51 +02:00
|
|
|
readline.set_completer(self._completer.complete)
|
|
|
|
readline.parse_and_bind("tab: complete")
|
|
|
|
# XXX: default delimiters conflict with some command names (eg. query-),
|
|
|
|
# clearing everything as it doesn't seem to matter
|
|
|
|
readline.set_completer_delims('')
|
2017-04-28 00:36:28 +02:00
|
|
|
try:
|
|
|
|
readline.read_history_file(self._histfile)
|
|
|
|
except Exception as e:
|
|
|
|
if isinstance(e, IOError) and e.errno == errno.ENOENT:
|
|
|
|
# File not found. No problem.
|
|
|
|
pass
|
|
|
|
else:
|
|
|
|
print "Failed to read history '%s'; %s" % (self._histfile, e)
|
|
|
|
atexit.register(self.__save_history)
|
|
|
|
|
|
|
|
def __save_history(self):
|
|
|
|
try:
|
|
|
|
readline.write_history_file(self._histfile)
|
|
|
|
except Exception as e:
|
|
|
|
print "Failed to save history file '%s'; %s" % (self._histfile, e)
|
2010-10-27 21:57:51 +02:00
|
|
|
|
scripts: qmp-shell: Expand support for QMP expressions
This includes support for [] expressions, single-quotes in
QMP expressions (which is not strictly a part of JSON), and
the ability to use "True", "False" and "None" literals instead
of JSON's equivalent true, false, and null literals.
qmp-shell currently allows you to describe values as
JSON expressions:
key={"key":{"key2":"val"}}
But it does not currently support arrays, which are needed
for serializing and deserializing transactions:
key=[{"type":"drive-backup","data":{...}}]
qmp-shell also only currently accepts doubly quoted strings
as-per JSON spec, but QMP allows single quotes.
Lastly, python allows you to utilize "True" or "False" as
boolean literals, but JSON expects "true" or "false". Expand
qmp-shell to allow the user to type either, converting to the
correct type.
As a consequence of the above, the key=val parsing is also improved
to give better error messages if a key=val token is not provided.
CAVEAT: The parser is still extremely rudimentary and does not
expect to find spaces in {} nor [] expressions. This patch does
not improve this functionality.
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Tested-by: Kashyap Chamarthy <kchamart@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-04-29 21:14:02 +02:00
|
|
|
def __parse_value(self, val):
|
|
|
|
try:
|
|
|
|
return int(val)
|
|
|
|
except ValueError:
|
|
|
|
pass
|
|
|
|
|
|
|
|
if val.lower() == 'true':
|
|
|
|
return True
|
|
|
|
if val.lower() == 'false':
|
|
|
|
return False
|
|
|
|
if val.startswith(('{', '[')):
|
|
|
|
# Try first as pure JSON:
|
2010-10-27 21:57:51 +02:00
|
|
|
try:
|
scripts: qmp-shell: Expand support for QMP expressions
This includes support for [] expressions, single-quotes in
QMP expressions (which is not strictly a part of JSON), and
the ability to use "True", "False" and "None" literals instead
of JSON's equivalent true, false, and null literals.
qmp-shell currently allows you to describe values as
JSON expressions:
key={"key":{"key2":"val"}}
But it does not currently support arrays, which are needed
for serializing and deserializing transactions:
key=[{"type":"drive-backup","data":{...}}]
qmp-shell also only currently accepts doubly quoted strings
as-per JSON spec, but QMP allows single quotes.
Lastly, python allows you to utilize "True" or "False" as
boolean literals, but JSON expects "true" or "false". Expand
qmp-shell to allow the user to type either, converting to the
correct type.
As a consequence of the above, the key=val parsing is also improved
to give better error messages if a key=val token is not provided.
CAVEAT: The parser is still extremely rudimentary and does not
expect to find spaces in {} nor [] expressions. This patch does
not improve this functionality.
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Tested-by: Kashyap Chamarthy <kchamart@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-04-29 21:14:02 +02:00
|
|
|
return json.loads(val)
|
2010-10-27 21:57:51 +02:00
|
|
|
except ValueError:
|
scripts: qmp-shell: Expand support for QMP expressions
This includes support for [] expressions, single-quotes in
QMP expressions (which is not strictly a part of JSON), and
the ability to use "True", "False" and "None" literals instead
of JSON's equivalent true, false, and null literals.
qmp-shell currently allows you to describe values as
JSON expressions:
key={"key":{"key2":"val"}}
But it does not currently support arrays, which are needed
for serializing and deserializing transactions:
key=[{"type":"drive-backup","data":{...}}]
qmp-shell also only currently accepts doubly quoted strings
as-per JSON spec, but QMP allows single quotes.
Lastly, python allows you to utilize "True" or "False" as
boolean literals, but JSON expects "true" or "false". Expand
qmp-shell to allow the user to type either, converting to the
correct type.
As a consequence of the above, the key=val parsing is also improved
to give better error messages if a key=val token is not provided.
CAVEAT: The parser is still extremely rudimentary and does not
expect to find spaces in {} nor [] expressions. This patch does
not improve this functionality.
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Tested-by: Kashyap Chamarthy <kchamart@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-04-29 21:14:02 +02:00
|
|
|
pass
|
|
|
|
# Try once again as FuzzyJSON:
|
|
|
|
try:
|
|
|
|
st = ast.parse(val, mode='eval')
|
|
|
|
return ast.literal_eval(FuzzyJSON().visit(st))
|
|
|
|
except SyntaxError:
|
|
|
|
pass
|
|
|
|
except ValueError:
|
|
|
|
pass
|
|
|
|
return val
|
|
|
|
|
|
|
|
def __cli_expr(self, tokens, parent):
|
|
|
|
for arg in tokens:
|
2017-03-02 13:24:29 +01:00
|
|
|
(key, sep, val) = arg.partition('=')
|
|
|
|
if sep != '=':
|
scripts: qmp-shell: Expand support for QMP expressions
This includes support for [] expressions, single-quotes in
QMP expressions (which is not strictly a part of JSON), and
the ability to use "True", "False" and "None" literals instead
of JSON's equivalent true, false, and null literals.
qmp-shell currently allows you to describe values as
JSON expressions:
key={"key":{"key2":"val"}}
But it does not currently support arrays, which are needed
for serializing and deserializing transactions:
key=[{"type":"drive-backup","data":{...}}]
qmp-shell also only currently accepts doubly quoted strings
as-per JSON spec, but QMP allows single quotes.
Lastly, python allows you to utilize "True" or "False" as
boolean literals, but JSON expects "true" or "false". Expand
qmp-shell to allow the user to type either, converting to the
correct type.
As a consequence of the above, the key=val parsing is also improved
to give better error messages if a key=val token is not provided.
CAVEAT: The parser is still extremely rudimentary and does not
expect to find spaces in {} nor [] expressions. This patch does
not improve this functionality.
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Tested-by: Kashyap Chamarthy <kchamart@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-04-29 21:14:02 +02:00
|
|
|
raise QMPShellError("Expected a key=value pair, got '%s'" % arg)
|
|
|
|
|
|
|
|
value = self.__parse_value(val)
|
|
|
|
optpath = key.split('.')
|
2014-02-12 04:05:13 +01:00
|
|
|
curpath = []
|
|
|
|
for p in optpath[:-1]:
|
|
|
|
curpath.append(p)
|
|
|
|
d = parent.get(p, {})
|
|
|
|
if type(d) is not dict:
|
|
|
|
raise QMPShellError('Cannot use "%s" as both leaf and non-leaf key' % '.'.join(curpath))
|
|
|
|
parent[p] = d
|
|
|
|
parent = d
|
|
|
|
if optpath[-1] in parent:
|
|
|
|
if type(parent[optpath[-1]]) is dict:
|
|
|
|
raise QMPShellError('Cannot use "%s" as both leaf and non-leaf key' % '.'.join(curpath))
|
|
|
|
else:
|
scripts: qmp-shell: Expand support for QMP expressions
This includes support for [] expressions, single-quotes in
QMP expressions (which is not strictly a part of JSON), and
the ability to use "True", "False" and "None" literals instead
of JSON's equivalent true, false, and null literals.
qmp-shell currently allows you to describe values as
JSON expressions:
key={"key":{"key2":"val"}}
But it does not currently support arrays, which are needed
for serializing and deserializing transactions:
key=[{"type":"drive-backup","data":{...}}]
qmp-shell also only currently accepts doubly quoted strings
as-per JSON spec, but QMP allows single quotes.
Lastly, python allows you to utilize "True" or "False" as
boolean literals, but JSON expects "true" or "false". Expand
qmp-shell to allow the user to type either, converting to the
correct type.
As a consequence of the above, the key=val parsing is also improved
to give better error messages if a key=val token is not provided.
CAVEAT: The parser is still extremely rudimentary and does not
expect to find spaces in {} nor [] expressions. This patch does
not improve this functionality.
Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Tested-by: Kashyap Chamarthy <kchamart@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2015-04-29 21:14:02 +02:00
|
|
|
raise QMPShellError('Cannot set "%s" multiple times' % key)
|
2014-02-12 04:05:13 +01:00
|
|
|
parent[optpath[-1]] = value
|
2015-04-29 21:14:01 +02:00
|
|
|
|
|
|
|
def __build_cmd(self, cmdline):
|
|
|
|
"""
|
|
|
|
Build a QMP input object from a user provided command-line in the
|
|
|
|
following format:
|
|
|
|
|
|
|
|
< command-name > [ arg-name1=arg1 ] ... [ arg-nameN=argN ]
|
|
|
|
"""
|
|
|
|
cmdargs = cmdline.split()
|
2015-04-29 21:14:03 +02:00
|
|
|
|
|
|
|
# Transactional CLI entry/exit:
|
|
|
|
if cmdargs[0] == 'transaction(':
|
|
|
|
self._transmode = True
|
|
|
|
cmdargs.pop(0)
|
|
|
|
elif cmdargs[0] == ')' and self._transmode:
|
|
|
|
self._transmode = False
|
|
|
|
if len(cmdargs) > 1:
|
|
|
|
raise QMPShellError("Unexpected input after close of Transaction sub-shell")
|
|
|
|
qmpcmd = { 'execute': 'transaction',
|
|
|
|
'arguments': { 'actions': self._actions } }
|
|
|
|
self._actions = list()
|
|
|
|
return qmpcmd
|
|
|
|
|
|
|
|
# Nothing to process?
|
|
|
|
if not cmdargs:
|
|
|
|
return None
|
|
|
|
|
|
|
|
# Parse and then cache this Transactional Action
|
|
|
|
if self._transmode:
|
|
|
|
finalize = False
|
|
|
|
action = { 'type': cmdargs[0], 'data': {} }
|
|
|
|
if cmdargs[-1] == ')':
|
|
|
|
cmdargs.pop(-1)
|
|
|
|
finalize = True
|
|
|
|
self.__cli_expr(cmdargs[1:], action['data'])
|
|
|
|
self._actions.append(action)
|
|
|
|
return self.__build_cmd(')') if finalize else None
|
|
|
|
|
|
|
|
# Standard command: parse and return it to be executed.
|
2015-04-29 21:14:01 +02:00
|
|
|
qmpcmd = { 'execute': cmdargs[0], 'arguments': {} }
|
|
|
|
self.__cli_expr(cmdargs[1:], qmpcmd['arguments'])
|
2010-10-27 21:57:51 +02:00
|
|
|
return qmpcmd
|
|
|
|
|
2015-04-29 21:14:04 +02:00
|
|
|
def _print(self, qmp):
|
qmp-shell: fix pretty printing of JSON responses
Pretty printing of JSON responses is important to be able to understand
large responses from query commands in particular. Unfortunately this
was broken during the addition of the verbose flag in
commit 1ceca07e48ead0dd2e41576c81d40e6a91cafefd
Author: John Snow <jsnow@redhat.com>
Date: Wed Apr 29 15:14:04 2015 -0400
scripts: qmp-shell: Add verbose flag
This is because that change turned the python data structure into a
formatted JSON string before the pretty print was given it. So we're
just pretty printing a string, which is a no-op.
The original pretty printer would output python objects.
(QEMU) query-chardev
{ u'return': [ { u'filename': u'vc',
u'frontend-open': False,
u'label': u'parallel0'},
{ u'filename': u'vc',
u'frontend-open': True,
u'label': u'serial0'},
{ u'filename': u'unix:/tmp/qemp,server',
u'frontend-open': True,
u'label': u'compat_monitor0'}]}
This fixes the problem by switching to outputting pretty formatted JSON
text instead. This has the added benefit that the pretty printed output
is now valid JSON text. Due to the way the verbose flag was handled, the
pretty printing now applies to the command sent, as well as its response:
(QEMU) query-chardev
{
"execute": "query-chardev",
"arguments": {}
}
{
"return": [
{
"frontend-open": false,
"label": "parallel0",
"filename": "vc"
},
{
"frontend-open": true,
"label": "serial0",
"filename": "vc"
},
{
"frontend-open": true,
"label": "compat_monitor0",
"filename": "unix:/tmp/qmp,server"
}
]
}
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-Id: <1456224706-1591-1-git-send-email-berrange@redhat.com>
Tested-by: Kashyap Chamarthy <kchamart@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
[Bonus fix: multiple -p now work]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-02-23 11:51:46 +01:00
|
|
|
indent = None
|
|
|
|
if self._pretty:
|
|
|
|
indent = 4
|
|
|
|
jsobj = json.dumps(qmp, indent=indent)
|
|
|
|
print str(jsobj)
|
2015-04-29 21:14:04 +02:00
|
|
|
|
2010-10-27 21:57:51 +02:00
|
|
|
def _execute_cmd(self, cmdline):
|
|
|
|
try:
|
|
|
|
qmpcmd = self.__build_cmd(cmdline)
|
2015-12-18 08:52:42 +01:00
|
|
|
except Exception as e:
|
2014-02-12 04:05:13 +01:00
|
|
|
print 'Error while parsing command line: %s' % e
|
2010-10-27 21:57:51 +02:00
|
|
|
print 'command format: <command-name> ',
|
|
|
|
print '[arg-name1=arg1] ... [arg-nameN=argN]'
|
|
|
|
return True
|
2015-04-29 21:14:03 +02:00
|
|
|
# For transaction mode, we may have just cached the action:
|
|
|
|
if qmpcmd is None:
|
|
|
|
return True
|
2015-04-29 21:14:04 +02:00
|
|
|
if self._verbose:
|
|
|
|
self._print(qmpcmd)
|
2010-10-27 21:57:51 +02:00
|
|
|
resp = self.cmd_obj(qmpcmd)
|
|
|
|
if resp is None:
|
|
|
|
print 'Disconnected'
|
|
|
|
return False
|
2015-04-29 21:14:04 +02:00
|
|
|
self._print(resp)
|
2010-10-27 21:57:51 +02:00
|
|
|
return True
|
|
|
|
|
2017-05-04 14:54:29 +02:00
|
|
|
def connect(self, negotiate):
|
|
|
|
self._greeting = qmp.QEMUMonitorProtocol.connect(self, negotiate)
|
2010-10-27 21:57:51 +02:00
|
|
|
self.__completer_setup()
|
2009-11-27 01:59:09 +01:00
|
|
|
|
2010-10-27 21:57:51 +02:00
|
|
|
def show_banner(self, msg='Welcome to the QMP low-level shell!'):
|
|
|
|
print msg
|
2017-05-04 14:54:31 +02:00
|
|
|
if not self._greeting:
|
|
|
|
print 'Connected'
|
|
|
|
return
|
2010-10-27 21:57:51 +02:00
|
|
|
version = self._greeting['QMP']['version']['qemu']
|
|
|
|
print 'Connected to QEMU %d.%d.%d\n' % (version['major'],version['minor'],version['micro'])
|
2009-11-27 01:59:09 +01:00
|
|
|
|
2015-04-29 21:14:03 +02:00
|
|
|
def get_prompt(self):
|
|
|
|
if self._transmode:
|
|
|
|
return "TRANS> "
|
|
|
|
return "(QEMU) "
|
|
|
|
|
2010-10-27 21:57:51 +02:00
|
|
|
def read_exec_command(self, prompt):
|
|
|
|
"""
|
|
|
|
Read and execute a command.
|
2009-11-27 01:59:09 +01:00
|
|
|
|
2010-10-27 21:57:51 +02:00
|
|
|
@return True if execution was ok, return False if disconnected.
|
|
|
|
"""
|
2009-11-27 01:59:09 +01:00
|
|
|
try:
|
2010-10-27 21:57:51 +02:00
|
|
|
cmdline = raw_input(prompt)
|
2009-11-27 01:59:09 +01:00
|
|
|
except EOFError:
|
|
|
|
print
|
2010-10-27 21:57:51 +02:00
|
|
|
return False
|
|
|
|
if cmdline == '':
|
|
|
|
for ev in self.get_events():
|
|
|
|
print ev
|
|
|
|
self.clear_events()
|
|
|
|
return True
|
2009-11-27 01:59:09 +01:00
|
|
|
else:
|
2010-10-27 21:57:51 +02:00
|
|
|
return self._execute_cmd(cmdline)
|
|
|
|
|
2015-04-29 21:14:04 +02:00
|
|
|
def set_verbosity(self, verbose):
|
|
|
|
self._verbose = verbose
|
|
|
|
|
2010-10-28 17:28:37 +02:00
|
|
|
class HMPShell(QMPShell):
|
|
|
|
def __init__(self, address):
|
|
|
|
QMPShell.__init__(self, address)
|
|
|
|
self.__cpu_index = 0
|
|
|
|
|
|
|
|
def __cmd_completion(self):
|
|
|
|
for cmd in self.__cmd_passthrough('help')['return'].split('\r\n'):
|
|
|
|
if cmd and cmd[0] != '[' and cmd[0] != '\t':
|
|
|
|
name = cmd.split()[0] # drop help text
|
|
|
|
if name == 'info':
|
|
|
|
continue
|
|
|
|
if name.find('|') != -1:
|
|
|
|
# Command in the form 'foobar|f' or 'f|foobar', take the
|
|
|
|
# full name
|
|
|
|
opt = name.split('|')
|
|
|
|
if len(opt[0]) == 1:
|
|
|
|
name = opt[1]
|
|
|
|
else:
|
|
|
|
name = opt[0]
|
|
|
|
self._completer.append(name)
|
|
|
|
self._completer.append('help ' + name) # help completion
|
|
|
|
|
|
|
|
def __info_completion(self):
|
|
|
|
for cmd in self.__cmd_passthrough('info')['return'].split('\r\n'):
|
|
|
|
if cmd:
|
|
|
|
self._completer.append('info ' + cmd.split()[1])
|
|
|
|
|
|
|
|
def __other_completion(self):
|
|
|
|
# special cases
|
|
|
|
self._completer.append('help info')
|
|
|
|
|
|
|
|
def _fill_completion(self):
|
|
|
|
self.__cmd_completion()
|
|
|
|
self.__info_completion()
|
|
|
|
self.__other_completion()
|
|
|
|
|
|
|
|
def __cmd_passthrough(self, cmdline, cpu_index = 0):
|
|
|
|
return self.cmd_obj({ 'execute': 'human-monitor-command', 'arguments':
|
|
|
|
{ 'command-line': cmdline,
|
|
|
|
'cpu-index': cpu_index } })
|
|
|
|
|
|
|
|
def _execute_cmd(self, cmdline):
|
|
|
|
if cmdline.split()[0] == "cpu":
|
|
|
|
# trap the cpu command, it requires special setting
|
|
|
|
try:
|
|
|
|
idx = int(cmdline.split()[1])
|
|
|
|
if not 'return' in self.__cmd_passthrough('info version', idx):
|
|
|
|
print 'bad CPU index'
|
|
|
|
return True
|
|
|
|
self.__cpu_index = idx
|
|
|
|
except ValueError:
|
|
|
|
print 'cpu command takes an integer argument'
|
|
|
|
return True
|
|
|
|
resp = self.__cmd_passthrough(cmdline, self.__cpu_index)
|
|
|
|
if resp is None:
|
|
|
|
print 'Disconnected'
|
|
|
|
return False
|
|
|
|
assert 'return' in resp or 'error' in resp
|
|
|
|
if 'return' in resp:
|
|
|
|
# Success
|
|
|
|
if len(resp['return']) > 0:
|
|
|
|
print resp['return'],
|
|
|
|
else:
|
|
|
|
# Error
|
|
|
|
print '%s: %s' % (resp['error']['class'], resp['error']['desc'])
|
|
|
|
return True
|
|
|
|
|
|
|
|
def show_banner(self):
|
|
|
|
QMPShell.show_banner(self, msg='Welcome to the HMP shell!')
|
|
|
|
|
2010-10-27 21:57:51 +02:00
|
|
|
def die(msg):
|
|
|
|
sys.stderr.write('ERROR: %s\n' % msg)
|
|
|
|
sys.exit(1)
|
|
|
|
|
|
|
|
def fail_cmdline(option=None):
|
|
|
|
if option:
|
|
|
|
sys.stderr.write('ERROR: bad command-line option \'%s\'\n' % option)
|
2017-05-04 14:54:32 +02:00
|
|
|
sys.stderr.write('qmp-shell [ -v ] [ -p ] [ -H ] [ -N ] < UNIX socket path> | < TCP address:port >\n')
|
|
|
|
sys.stderr.write(' -v Verbose (echo command sent and received)\n')
|
|
|
|
sys.stderr.write(' -p Pretty-print JSON\n')
|
|
|
|
sys.stderr.write(' -H Use HMP interface\n')
|
|
|
|
sys.stderr.write(' -N Skip negotiate (for qemu-ga)\n')
|
2010-10-27 21:57:51 +02:00
|
|
|
sys.exit(1)
|
|
|
|
|
|
|
|
def main():
|
2010-10-28 17:28:37 +02:00
|
|
|
addr = ''
|
2012-08-15 12:33:47 +02:00
|
|
|
qemu = None
|
|
|
|
hmp = False
|
qmp-shell: fix pretty printing of JSON responses
Pretty printing of JSON responses is important to be able to understand
large responses from query commands in particular. Unfortunately this
was broken during the addition of the verbose flag in
commit 1ceca07e48ead0dd2e41576c81d40e6a91cafefd
Author: John Snow <jsnow@redhat.com>
Date: Wed Apr 29 15:14:04 2015 -0400
scripts: qmp-shell: Add verbose flag
This is because that change turned the python data structure into a
formatted JSON string before the pretty print was given it. So we're
just pretty printing a string, which is a no-op.
The original pretty printer would output python objects.
(QEMU) query-chardev
{ u'return': [ { u'filename': u'vc',
u'frontend-open': False,
u'label': u'parallel0'},
{ u'filename': u'vc',
u'frontend-open': True,
u'label': u'serial0'},
{ u'filename': u'unix:/tmp/qemp,server',
u'frontend-open': True,
u'label': u'compat_monitor0'}]}
This fixes the problem by switching to outputting pretty formatted JSON
text instead. This has the added benefit that the pretty printed output
is now valid JSON text. Due to the way the verbose flag was handled, the
pretty printing now applies to the command sent, as well as its response:
(QEMU) query-chardev
{
"execute": "query-chardev",
"arguments": {}
}
{
"return": [
{
"frontend-open": false,
"label": "parallel0",
"filename": "vc"
},
{
"frontend-open": true,
"label": "serial0",
"filename": "vc"
},
{
"frontend-open": true,
"label": "compat_monitor0",
"filename": "unix:/tmp/qmp,server"
}
]
}
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-Id: <1456224706-1591-1-git-send-email-berrange@redhat.com>
Tested-by: Kashyap Chamarthy <kchamart@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
[Bonus fix: multiple -p now work]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-02-23 11:51:46 +01:00
|
|
|
pretty = False
|
2015-04-29 21:14:04 +02:00
|
|
|
verbose = False
|
2017-05-04 14:54:29 +02:00
|
|
|
negotiate = True
|
2012-08-15 12:33:47 +02:00
|
|
|
|
2010-10-27 21:57:51 +02:00
|
|
|
try:
|
2012-08-15 12:33:47 +02:00
|
|
|
for arg in sys.argv[1:]:
|
|
|
|
if arg == "-H":
|
|
|
|
if qemu is not None:
|
|
|
|
fail_cmdline(arg)
|
|
|
|
hmp = True
|
|
|
|
elif arg == "-p":
|
qmp-shell: fix pretty printing of JSON responses
Pretty printing of JSON responses is important to be able to understand
large responses from query commands in particular. Unfortunately this
was broken during the addition of the verbose flag in
commit 1ceca07e48ead0dd2e41576c81d40e6a91cafefd
Author: John Snow <jsnow@redhat.com>
Date: Wed Apr 29 15:14:04 2015 -0400
scripts: qmp-shell: Add verbose flag
This is because that change turned the python data structure into a
formatted JSON string before the pretty print was given it. So we're
just pretty printing a string, which is a no-op.
The original pretty printer would output python objects.
(QEMU) query-chardev
{ u'return': [ { u'filename': u'vc',
u'frontend-open': False,
u'label': u'parallel0'},
{ u'filename': u'vc',
u'frontend-open': True,
u'label': u'serial0'},
{ u'filename': u'unix:/tmp/qemp,server',
u'frontend-open': True,
u'label': u'compat_monitor0'}]}
This fixes the problem by switching to outputting pretty formatted JSON
text instead. This has the added benefit that the pretty printed output
is now valid JSON text. Due to the way the verbose flag was handled, the
pretty printing now applies to the command sent, as well as its response:
(QEMU) query-chardev
{
"execute": "query-chardev",
"arguments": {}
}
{
"return": [
{
"frontend-open": false,
"label": "parallel0",
"filename": "vc"
},
{
"frontend-open": true,
"label": "serial0",
"filename": "vc"
},
{
"frontend-open": true,
"label": "compat_monitor0",
"filename": "unix:/tmp/qmp,server"
}
]
}
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-Id: <1456224706-1591-1-git-send-email-berrange@redhat.com>
Tested-by: Kashyap Chamarthy <kchamart@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
[Bonus fix: multiple -p now work]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-02-23 11:51:46 +01:00
|
|
|
pretty = True
|
2017-05-04 14:54:29 +02:00
|
|
|
elif arg == "-N":
|
|
|
|
negotiate = False
|
2015-04-29 21:14:04 +02:00
|
|
|
elif arg == "-v":
|
|
|
|
verbose = True
|
2012-08-15 12:33:47 +02:00
|
|
|
else:
|
|
|
|
if qemu is not None:
|
|
|
|
fail_cmdline(arg)
|
|
|
|
if hmp:
|
|
|
|
qemu = HMPShell(arg)
|
|
|
|
else:
|
qmp-shell: fix pretty printing of JSON responses
Pretty printing of JSON responses is important to be able to understand
large responses from query commands in particular. Unfortunately this
was broken during the addition of the verbose flag in
commit 1ceca07e48ead0dd2e41576c81d40e6a91cafefd
Author: John Snow <jsnow@redhat.com>
Date: Wed Apr 29 15:14:04 2015 -0400
scripts: qmp-shell: Add verbose flag
This is because that change turned the python data structure into a
formatted JSON string before the pretty print was given it. So we're
just pretty printing a string, which is a no-op.
The original pretty printer would output python objects.
(QEMU) query-chardev
{ u'return': [ { u'filename': u'vc',
u'frontend-open': False,
u'label': u'parallel0'},
{ u'filename': u'vc',
u'frontend-open': True,
u'label': u'serial0'},
{ u'filename': u'unix:/tmp/qemp,server',
u'frontend-open': True,
u'label': u'compat_monitor0'}]}
This fixes the problem by switching to outputting pretty formatted JSON
text instead. This has the added benefit that the pretty printed output
is now valid JSON text. Due to the way the verbose flag was handled, the
pretty printing now applies to the command sent, as well as its response:
(QEMU) query-chardev
{
"execute": "query-chardev",
"arguments": {}
}
{
"return": [
{
"frontend-open": false,
"label": "parallel0",
"filename": "vc"
},
{
"frontend-open": true,
"label": "serial0",
"filename": "vc"
},
{
"frontend-open": true,
"label": "compat_monitor0",
"filename": "unix:/tmp/qmp,server"
}
]
}
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
Message-Id: <1456224706-1591-1-git-send-email-berrange@redhat.com>
Tested-by: Kashyap Chamarthy <kchamart@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
[Bonus fix: multiple -p now work]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2016-02-23 11:51:46 +01:00
|
|
|
qemu = QMPShell(arg, pretty)
|
2012-08-15 12:33:47 +02:00
|
|
|
addr = arg
|
|
|
|
|
|
|
|
if qemu is None:
|
|
|
|
fail_cmdline()
|
2010-10-27 21:57:51 +02:00
|
|
|
except QMPShellBadPort:
|
|
|
|
die('bad port number in command-line')
|
|
|
|
|
|
|
|
try:
|
2017-05-04 14:54:29 +02:00
|
|
|
qemu.connect(negotiate)
|
2010-10-27 21:57:51 +02:00
|
|
|
except qmp.QMPConnectError:
|
|
|
|
die('Didn\'t get QMP greeting message')
|
|
|
|
except qmp.QMPCapabilitiesError:
|
|
|
|
die('Could not negotiate capabilities')
|
|
|
|
except qemu.error:
|
2010-10-28 17:28:37 +02:00
|
|
|
die('Could not connect to %s' % addr)
|
2010-10-27 21:57:51 +02:00
|
|
|
|
|
|
|
qemu.show_banner()
|
2015-04-29 21:14:04 +02:00
|
|
|
qemu.set_verbosity(verbose)
|
2015-04-29 21:14:03 +02:00
|
|
|
while qemu.read_exec_command(qemu.get_prompt()):
|
2010-10-27 21:57:51 +02:00
|
|
|
pass
|
|
|
|
qemu.close()
|
2009-11-27 01:59:09 +01:00
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
|
|
main()
|