619 lines
21 KiB
Python
Executable File
619 lines
21 KiB
Python
Executable File
#!/usr/bin/env python
|
|
|
|
# The contents of this file are subject to the Mozilla Public License
|
|
# Version 1.1 (the "License"); you may not use this file except in
|
|
# compliance with the License. You may obtain a copy of the License at
|
|
# http://www.mozilla.org/MPL/
|
|
#
|
|
# Software distributed under the License is distributed on an "AS IS"
|
|
# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing rights and limitations
|
|
# under the License.
|
|
#
|
|
# The Original Code is RabbitMQ Management Plugin.
|
|
#
|
|
# The Initial Developer of the Original Code is VMware, Inc.
|
|
# Copyright (c) 2007-2010 VMware, Inc. All rights reserved.
|
|
|
|
from optparse import OptionParser
|
|
import sys
|
|
import httplib
|
|
import urllib
|
|
import base64
|
|
import json
|
|
import os
|
|
import socket
|
|
|
|
LISTABLE = ['connections', 'channels', 'exchanges', 'queues', 'bindings',
|
|
'users', 'vhosts', 'permissions', 'nodes']
|
|
|
|
SHOWABLE = ['overview']
|
|
|
|
PROMOTE_COLUMNS = ['vhost', 'name', 'type',
|
|
'source', 'destination', 'destination_type', 'routing_key']
|
|
|
|
URIS = {
|
|
'exchange': '/exchanges/{vhost}/{name}',
|
|
'queue': '/queues/{vhost}/{name}',
|
|
'binding': '/bindings/{vhost}/e/{source}/{destination_char}/{destination}',
|
|
'binding_del':'/bindings/{vhost}/e/{source}/{destination_char}/{destination}/{properties_key}',
|
|
'vhost': '/vhosts/{name}',
|
|
'user': '/users/{name}',
|
|
'permission': '/permissions/{vhost}/{user}'
|
|
}
|
|
|
|
DECLARABLE = {
|
|
'exchange': {'mandatory': ['name', 'type'],
|
|
'optional': {'auto_delete': 'false', 'durable': 'true',
|
|
'internal': 'false'}},
|
|
'queue': {'mandatory': ['name'],
|
|
'optional': {'auto_delete': 'false', 'durable': 'true'}},
|
|
'binding': {'mandatory': ['source', 'destination_type', 'destination',
|
|
'routing_key'],
|
|
'optional': {}},
|
|
'vhost': {'mandatory': ['name'],
|
|
'optional': {}},
|
|
'user': {'mandatory': ['name', 'password', 'administrator'],
|
|
'optional': {}},
|
|
'permission': {'mandatory': ['vhost', 'user', 'configure', 'write', 'read'],
|
|
'optional': {}}
|
|
}
|
|
|
|
DELETABLE = {
|
|
'exchange': {'mandatory': ['name']},
|
|
'queue': {'mandatory': ['name']},
|
|
'binding': {'mandatory': ['source', 'destination_type', 'destination',
|
|
'properties_key']},
|
|
'vhost': {'mandatory': ['name']},
|
|
'user': {'mandatory': ['name']},
|
|
'permission': {'mandatory': ['vhost', 'user']}
|
|
}
|
|
|
|
CLOSABLE = {
|
|
'connection': {'mandatory': ['name'],
|
|
'optional': {},
|
|
'uri': '/connections/{name}'}
|
|
}
|
|
|
|
PURGABLE = {
|
|
'queue': {'mandatory': ['name'],
|
|
'optional': {},
|
|
'uri': '/queues/{vhost}/{name}/contents'}
|
|
}
|
|
|
|
EXTRA_VERBS = {
|
|
'publish': {'mandatory': ['routing_key', 'payload'],
|
|
'optional': {'exchange': 'amq.default',
|
|
'payload_encoding': 'string'},
|
|
'uri': '/exchanges/{vhost}/{exchange}/publish'},
|
|
'get': {'mandatory': ['queue'],
|
|
'optional': {'count': '1', 'requeue': 'true'},
|
|
'uri': '/queues/{vhost}/{queue}/get'}
|
|
}
|
|
|
|
for k in DECLARABLE:
|
|
DECLARABLE[k]['uri'] = URIS[k]
|
|
|
|
for k in DELETABLE:
|
|
DELETABLE[k]['uri'] = URIS[k]
|
|
DELETABLE[k]['optional'] = {}
|
|
DELETABLE['binding']['uri'] = URIS['binding_del']
|
|
|
|
def make_usage():
|
|
usage = """usage: %prog [options] cmd
|
|
where cmd is one of:
|
|
|
|
"""
|
|
for l in LISTABLE:
|
|
usage += " list {0} [<column>...]\n".format(l)
|
|
for s in SHOWABLE:
|
|
usage += " show {0} [<column>...]\n".format(s)
|
|
usage += fmt_usage_stanza(DECLARABLE, 'declare')
|
|
usage += fmt_usage_stanza(DELETABLE, 'delete')
|
|
usage += fmt_usage_stanza(CLOSABLE, 'close')
|
|
usage += fmt_usage_stanza(PURGABLE, 'purge')
|
|
usage += fmt_usage_stanza(EXTRA_VERBS, '')
|
|
usage += """
|
|
export <file>
|
|
import <file>"""
|
|
return usage
|
|
|
|
def fmt_usage_stanza(root, verb):
|
|
def fmt_args(args):
|
|
res = " ".join(["{0}=...".format(a) for a in args['mandatory']])
|
|
opts = " ".join("{0}=...".format(o) for o in args['optional'].keys())
|
|
if opts != "":
|
|
res += " [{0}]".format(opts)
|
|
return res
|
|
|
|
text = "\n"
|
|
if verb != "":
|
|
verb = " " + verb
|
|
for k in root.keys():
|
|
text += " {0} {1} {2}\n".format(verb, k, fmt_args(root[k]))
|
|
return text
|
|
|
|
parser = OptionParser(usage=make_usage())
|
|
|
|
def make_parser():
|
|
parser.add_option("-H", "--host", dest="hostname", default="localhost",
|
|
help="connect to host HOST [default: %default]",
|
|
metavar="HOST")
|
|
parser.add_option("-P", "--port", dest="port", default="55672",
|
|
help="connect to port PORT [default: %default]",
|
|
metavar="PORT")
|
|
parser.add_option("-V", "--vhost", dest="vhost",
|
|
help="connect to vhost VHOST [default: all vhosts for list, '/' for declare]",
|
|
metavar="VHOST")
|
|
parser.add_option("-u", "--username", dest="username", default="guest",
|
|
help="connect using username USERNAME [default: %default]",
|
|
metavar="USERNAME")
|
|
parser.add_option("-p", "--password", dest="password", default="guest",
|
|
help="connect using password PASSWORD [default: %default]",
|
|
metavar="PASSWORD")
|
|
parser.add_option("-q", "--quiet", action="store_false", dest="verbose",
|
|
default=True, help="suppress status messages")
|
|
parser.add_option("-f", "--format", dest="format", default="table",
|
|
help="format for listing commands - one of [" + ", ".join(FORMATS.keys()) + "] [default: %default]")
|
|
parser.add_option("-d", "--depth", dest="depth", default="1",
|
|
help="maximum depth to recurse for listing tables [default: %default]")
|
|
parser.add_option("--bash-completion", action="store_true",
|
|
dest="bash_completion", default=False,
|
|
help="Print bash completion script")
|
|
|
|
def assert_usage(expr, error):
|
|
if not expr:
|
|
print "\nERROR: {0}\n".format(error)
|
|
print "{0} --help for help\n".format(os.path.basename(sys.argv[0]))
|
|
sys.exit(1)
|
|
|
|
def column_sort_key(col):
|
|
if col in PROMOTE_COLUMNS:
|
|
return (1, PROMOTE_COLUMNS.index(col))
|
|
else:
|
|
return (2, col)
|
|
|
|
def main():
|
|
make_parser()
|
|
(options, args) = parser.parse_args()
|
|
if options.bash_completion:
|
|
print_bash_completion()
|
|
exit(0)
|
|
assert_usage(len(args) > 0, 'Action not specified')
|
|
mgmt = Management(options, args[1:])
|
|
mode = "invoke_" + args[0]
|
|
assert_usage(hasattr(mgmt, mode),
|
|
'Action {0} not understood'.format(args[0]))
|
|
method = getattr(mgmt, "invoke_%s" % args[0])
|
|
method()
|
|
|
|
def die(str):
|
|
sys.stderr.write("*** {0}".format(str))
|
|
exit(1)
|
|
|
|
class Management:
|
|
def __init__(self, options, args):
|
|
self.options = options
|
|
self.args = args
|
|
|
|
def get(self, path):
|
|
return self.http("GET", path, "")
|
|
|
|
def put(self, path, body):
|
|
return self.http("PUT", path, body)
|
|
|
|
def post(self, path, body):
|
|
return self.http("POST", path, body)
|
|
|
|
def delete(self, path):
|
|
return self.http("DELETE", path, "")
|
|
|
|
def http(self, method, path, body):
|
|
conn = httplib.HTTPConnection(self.options.hostname, self.options.port)
|
|
headers = {"Authorization":
|
|
"Basic " + base64.b64encode(self.options.username + ":" +
|
|
self.options.password)}
|
|
if body != "":
|
|
headers["Content-Type"] = "application/json"
|
|
try:
|
|
conn.request(method, "/api%s" % path, body, headers)
|
|
except socket.error as e:
|
|
die("Could not connect: {0}".format(e))
|
|
resp = conn.getresponse()
|
|
if resp.status == 400:
|
|
die(json.loads(resp.read())['reason'])
|
|
if resp.status == 401:
|
|
die("Access refused: {0}".format(path))
|
|
if resp.status == 404:
|
|
die("Not found: {0}".format(path))
|
|
if resp.status < 200 or resp.status > 400:
|
|
raise Exception("Received %d %s for path %s\n%s"
|
|
% (resp.status, resp.reason, path, resp.read()))
|
|
return resp.read()
|
|
|
|
def verbose(self, string):
|
|
if self.options.verbose:
|
|
print string
|
|
|
|
def get_arg(self):
|
|
assert_usage(len(self.args) == 1, 'Exactly one argument required')
|
|
return self.args[0]
|
|
|
|
def invoke_publish(self):
|
|
(uri, payload) = self.parse_args(self.args, EXTRA_VERBS['publish'])
|
|
payload['properties'] = {} # TODO do we care here?
|
|
resp = json.loads(self.post(uri, json.dumps(payload)))
|
|
if resp['routed']:
|
|
self.verbose("Message published")
|
|
else:
|
|
self.verbose("Message published but NOT routed")
|
|
|
|
def invoke_get(self):
|
|
(uri, payload) = self.parse_args(self.args, EXTRA_VERBS['get'])
|
|
format_list(self.post(uri, json.dumps(payload)), [], self.options)
|
|
|
|
def invoke_export(self):
|
|
path = self.get_arg()
|
|
config = self.get("/all-configuration")
|
|
with open(path, 'w') as f:
|
|
f.write(config)
|
|
self.verbose("Exported configuration for %s to \"%s\""
|
|
% (self.options.hostname, path))
|
|
|
|
def invoke_import(self):
|
|
path = self.get_arg()
|
|
with open(path, 'r') as f:
|
|
config = f.read()
|
|
self.post("/all-configuration", config)
|
|
self.verbose("Imported configuration for %s from \"%s\""
|
|
% (self.options.hostname, path))
|
|
|
|
def invoke_list(self):
|
|
uri = self.list_show_uri(LISTABLE, 'list')
|
|
format_list(self.get(uri), self.args[1:], self.options)
|
|
|
|
def invoke_show(self):
|
|
uri = self.list_show_uri(SHOWABLE, 'show')
|
|
format_list('[{0}]'.format(self.get(uri)), self.args[1:], self.options)
|
|
|
|
def list_show_uri(self, obj_types, verb):
|
|
obj_type = self.args[0]
|
|
assert_usage(obj_type in obj_types,
|
|
"Don't know how to {0} {1}".format(verb, obj_type))
|
|
uri = "/%s" % obj_type
|
|
if self.options.vhost:
|
|
uri += "/%s" % urllib.quote_plus(self.options.vhost)
|
|
return uri
|
|
|
|
def invoke_declare(self):
|
|
(obj_type, uri, payload) = self.declare_delete_parse(DECLARABLE)
|
|
if obj_type == 'binding':
|
|
self.post(uri, json.dumps(payload))
|
|
else:
|
|
self.put(uri, json.dumps(payload))
|
|
self.verbose("{0} declared".format(obj_type))
|
|
|
|
def invoke_delete(self):
|
|
(obj_type, uri, payload) = self.declare_delete_parse(DELETABLE)
|
|
self.delete(uri)
|
|
self.verbose("{0} deleted".format(obj_type))
|
|
|
|
def invoke_close(self):
|
|
(obj_type, uri, payload) = self.declare_delete_parse(CLOSABLE)
|
|
self.delete(uri)
|
|
self.verbose("{0} closed".format(obj_type))
|
|
|
|
def invoke_purge(self):
|
|
(obj_type, uri, payload) = self.declare_delete_parse(PURGABLE)
|
|
self.delete(uri)
|
|
self.verbose("{0} purged".format(obj_type))
|
|
|
|
def declare_delete_parse(self, root):
|
|
assert_usage(len(self.args) > 0, 'Type not specified')
|
|
obj_type = self.args[0]
|
|
assert_usage(obj_type in root,
|
|
'Type {0} not recognised'.format(obj_type))
|
|
obj = root[obj_type]
|
|
(uri, payload) = self.parse_args(self.args[1:], obj)
|
|
return (obj_type, uri, payload)
|
|
|
|
def parse_args(self, args, obj):
|
|
mandatory = obj['mandatory']
|
|
optional = obj['optional']
|
|
uri_template = obj['uri']
|
|
payload = {}
|
|
for k in optional.keys():
|
|
payload[k] = optional[k]
|
|
for arg in args:
|
|
assert_usage("=" in arg,
|
|
'Argument "{0}" not in format name=value'.format(arg))
|
|
(name, value) = arg.split("=", 1)
|
|
assert_usage(name in mandatory or name in optional.keys(),
|
|
'Argument "{0}" not recognised'.format(name))
|
|
payload[name] = value
|
|
for m in mandatory:
|
|
assert_usage(m in payload.keys(),
|
|
'mandatory argument "{0}" required'.format(m))
|
|
payload['arguments'] = {}
|
|
payload['vhost'] = self.options.vhost or '/'
|
|
uri_args = {}
|
|
for k in payload:
|
|
uri_args[k] = urllib.quote_plus(payload[k])
|
|
if k == 'destination_type':
|
|
uri_args['destination_char'] = payload[k][0]
|
|
uri = uri_template.format(**uri_args)
|
|
return (uri, payload)
|
|
|
|
def format_list(json_list, columns, options):
|
|
format = options.format
|
|
formatter = None
|
|
if format == "raw_json":
|
|
print json_list
|
|
return
|
|
elif format == "pretty_json":
|
|
enc = json.JSONEncoder(False, False, True, True, True, 2)
|
|
print enc.encode(json.loads(json_list))
|
|
return
|
|
else:
|
|
formatter = FORMATS[format]
|
|
assert_usage(formatter != None,
|
|
"Format {0} not recognised".format(format))
|
|
formatter_instance = formatter(columns, options)
|
|
formatter_instance.display(json_list)
|
|
|
|
class Lister:
|
|
def verbose(self, string):
|
|
if self.options.verbose:
|
|
print string
|
|
|
|
def display(self, json_list):
|
|
depth = sys.maxint
|
|
if len(self.columns) == 0:
|
|
depth = int(self.options.depth)
|
|
(columns, table) = self.list_to_table(json.loads(json_list), depth)
|
|
if len(table) > 0:
|
|
self.display_list(columns, table)
|
|
else:
|
|
self.verbose("No items")
|
|
|
|
def list_to_table(self, items, max_depth):
|
|
columns = {}
|
|
column_ix = {}
|
|
row = None
|
|
table = []
|
|
|
|
def add(prefix, depth, item, fun):
|
|
for key in item:
|
|
column = prefix == '' and key or (prefix + '_' + key)
|
|
if type(item[key]) == dict:
|
|
if depth < max_depth:
|
|
add(column, depth + 1, item[key], fun)
|
|
elif type(item[key]) == list:
|
|
# TODO - ATM this is only applications inside nodes. Not
|
|
# sure how to handle this sensibly.
|
|
pass
|
|
else:
|
|
fun(column, item[key])
|
|
|
|
def add_to_columns(col, val):
|
|
columns[col] = True
|
|
|
|
def add_to_row(col, val):
|
|
if col in column_ix:
|
|
row[column_ix[col]] = str(val)
|
|
|
|
if len(self.columns) == 0:
|
|
for item in items:
|
|
add('', 1, item, add_to_columns)
|
|
columns = columns.keys()
|
|
columns.sort(key=column_sort_key)
|
|
else:
|
|
columns = self.columns
|
|
|
|
for i in xrange(0, len(columns)):
|
|
column_ix[columns[i]] = i
|
|
for item in items:
|
|
row = len(columns) * ['']
|
|
add('', 1, item, add_to_row)
|
|
table.append(row)
|
|
|
|
return (columns, table)
|
|
|
|
class TSVList(Lister):
|
|
def __init__(self, columns, options):
|
|
self.columns = columns
|
|
self.options = options
|
|
|
|
def display_list(self, columns, table):
|
|
head = ""
|
|
for col in columns:
|
|
head += col + "\t"
|
|
self.verbose(head)
|
|
|
|
for row in table:
|
|
line = ""
|
|
for cell in row:
|
|
line += cell + "\t"
|
|
print line
|
|
|
|
class LongList(Lister):
|
|
def __init__(self, columns, options):
|
|
self.columns = columns
|
|
self.options = options
|
|
|
|
def display_list(self, columns, table):
|
|
sep = "\n" + "-" * 80 + "\n"
|
|
max_width = 0
|
|
for col in columns:
|
|
max_width = max(max_width, len(col))
|
|
fmt = "{0:>" + str(max_width) + "}: {1}"
|
|
print sep
|
|
for i in xrange(0, len(table)):
|
|
for j in xrange(0, len(columns)):
|
|
print fmt.format(columns[j], table[i][j])
|
|
print sep
|
|
|
|
class TableList(Lister):
|
|
def __init__(self, columns, options):
|
|
self.columns = columns
|
|
self.options = options
|
|
|
|
def display_list(self, columns, table):
|
|
total = [columns]
|
|
total.extend(table)
|
|
self.ascii_table(total)
|
|
|
|
def ascii_table(self, rows):
|
|
table = ""
|
|
col_widths = [0] * len(rows[0])
|
|
for i in xrange(0, len(rows[0])):
|
|
for j in xrange(0, len(rows)):
|
|
col_widths[i] = max(col_widths[i], len(rows[j][i]))
|
|
self.ascii_bar(col_widths)
|
|
self.ascii_row(col_widths, rows[0], "^")
|
|
self.ascii_bar(col_widths)
|
|
for row in rows[1:]:
|
|
self.ascii_row(col_widths, row, "<")
|
|
self.ascii_bar(col_widths)
|
|
|
|
def ascii_row(self, col_widths, row, align):
|
|
txt = "|"
|
|
for i in xrange(0, len(col_widths)):
|
|
fmt = " {0:" + align + str(col_widths[i]) + "} "
|
|
txt += fmt.format(row[i]) + "|"
|
|
print txt
|
|
|
|
def ascii_bar(self, col_widths):
|
|
txt = "+"
|
|
for w in col_widths:
|
|
txt += ("-" * (w + 2)) + "+"
|
|
print txt
|
|
|
|
class KeyValueList(Lister):
|
|
def __init__(self, columns, options):
|
|
self.columns = columns
|
|
self.options = options
|
|
|
|
def display_list(self, columns, table):
|
|
for i in xrange(0, len(table)):
|
|
row = []
|
|
for j in xrange(0, len(columns)):
|
|
row.append("{0}=\"{1}\"".format(columns[j], table[i][j]))
|
|
print " ".join(row)
|
|
|
|
# TODO handle spaces etc in completable names
|
|
class BashList(Lister):
|
|
def __init__(self, columns, options):
|
|
self.columns = columns
|
|
self.options = options
|
|
|
|
def display_list(self, columns, table):
|
|
ix = None
|
|
for i in xrange(0, len(columns)):
|
|
if columns[i] == 'name':
|
|
ix = i
|
|
if ix is not None:
|
|
res = []
|
|
for row in table:
|
|
res.append(row[ix])
|
|
print " ".join(res)
|
|
|
|
FORMATS = {
|
|
'raw_json' : None, # Special cased
|
|
'pretty_json' : None, # Ditto
|
|
'tsv' : TSVList,
|
|
'long' : LongList,
|
|
'table' : TableList,
|
|
'kvp' : KeyValueList,
|
|
'bash' : BashList
|
|
}
|
|
|
|
def print_bash_completion():
|
|
script = """# This is a bash completion script for rabbitmqadmin.
|
|
# Redirect it to a file, then source it or copy it to /etc/bash_completion.d
|
|
# to get tab completion. rabbitmqadmin must be on your PATH for this to work.
|
|
_rabbitmqadmin()
|
|
{
|
|
local cur prev opts base
|
|
COMPREPLY=()
|
|
cur="${COMP_WORDS[COMP_CWORD]}"
|
|
prev="${COMP_WORDS[COMP_CWORD-1]}"
|
|
|
|
opts="list show declare delete close purge import export get publish"
|
|
fargs="--help --host --port --vhost --username --password --format --depth"
|
|
|
|
case "${prev}" in
|
|
list)
|
|
COMPREPLY=( $(compgen -W '""" + " ".join(LISTABLE) + """' -- ${cur}) )
|
|
return 0
|
|
;;
|
|
show)
|
|
COMPREPLY=( $(compgen -W '""" + " ".join(SHOWABLE) + """' -- ${cur}) )
|
|
return 0
|
|
;;
|
|
declare)
|
|
COMPREPLY=( $(compgen -W '""" + " ".join(DECLARABLE.keys()) + """' -- ${cur}) )
|
|
return 0
|
|
;;
|
|
delete)
|
|
COMPREPLY=( $(compgen -W '""" + " ".join(DELETABLE.keys()) + """' -- ${cur}) )
|
|
return 0
|
|
;;
|
|
close)
|
|
COMPREPLY=( $(compgen -W '""" + " ".join(CLOSABLE.keys()) + """' -- ${cur}) )
|
|
return 0
|
|
;;
|
|
purge)
|
|
COMPREPLY=( $(compgen -W '""" + " ".join(PURGABLE.keys()) + """' -- ${cur}) )
|
|
return 0
|
|
;;
|
|
export)
|
|
COMPREPLY=( $(compgen -f ${cur}) )
|
|
return 0
|
|
;;
|
|
import)
|
|
COMPREPLY=( $(compgen -f ${cur}) )
|
|
return 0
|
|
;;
|
|
--host)
|
|
COMPREPLY=( $(compgen -A hostname ${cur}) )
|
|
return 0
|
|
;;
|
|
--vhost)
|
|
opts="$(rabbitmqadmin -q -f bash list vhosts)"
|
|
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
|
|
return 0
|
|
;;
|
|
--username)
|
|
opts="$(rabbitmqadmin -q -f bash list users)"
|
|
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
|
|
return 0
|
|
;;
|
|
--format)
|
|
COMPREPLY=( $(compgen -W \"""" + " ".join(FORMATS.keys()) + """\" -- ${cur}) )
|
|
return 0
|
|
;;
|
|
|
|
"""
|
|
for l in LISTABLE:
|
|
key = l[0:len(l) - 1]
|
|
script += " " + key + """)
|
|
opts="$(rabbitmqadmin -q -f bash list """ + l + """)"
|
|
COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
|
|
return 0
|
|
;;
|
|
"""
|
|
script += """ *)
|
|
;;
|
|
esac
|
|
|
|
COMPREPLY=($(compgen -W "${opts} ${fargs}" -- ${cur}))
|
|
return 0
|
|
}
|
|
complete -F _rabbitmqadmin rabbitmqadmin
|
|
"""
|
|
print script
|
|
|
|
if __name__ == "__main__":
|
|
main()
|