[mirror_ovs.git] / tests / test-ovsdb.py

# Copyright (c) 2009, 2010, 2011 Nicira Networks
#
# Licensed under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import codecs
import getopt
import re
import os
import signal
import sys

from ovs.db import error
import ovs.db.idl
import ovs.db.schema
from ovs.db import data
from ovs.db import types
import ovs.ovsuuid
import ovs.poller
import ovs.util

def unbox_json(json):
    if type(json) == list and len(json) == 1:
        return json[0]
    else:
        return json

def do_default_atoms():
    for type in types.ATOMIC_TYPES:
        if type == types.VoidType:
            continue

        sys.stdout.write("%s: " % type.to_string())

        atom = data.Atom.default(type)
        if atom != data.Atom.default(type):
            sys.stdout.write("wrong\n")
            sys.exit(1)

        sys.stdout.write("OK\n")

def do_default_data():
    any_errors = False
    for n_min in 0, 1:
        for key in types.ATOMIC_TYPES:
            if key == types.VoidType:
                continue
            for value in types.ATOMIC_TYPES:
                if value == types.VoidType:
                    valueBase = None
                else:
                    valueBase = types.BaseType(value)
                type = types.Type(types.BaseType(key), valueBase, n_min, 1)
                assert type.is_valid()

                sys.stdout.write("key %s, value %s, n_min %d: "
                                 % (key.to_string(), value.to_string(), n_min))

                datum = data.Datum.default(type)
                if datum != data.Datum.default(type):
                    sys.stdout.write("wrong\n")
                    any_errors = True
                else:
                    sys.stdout.write("OK\n")
    if any_errors:
        sys.exit(1)

def do_parse_atomic_type(type_string):
    type_json = unbox_json(ovs.json.from_string(type_string))
    atomic_type = types.AtomicType.from_json(type_json)
    print ovs.json.to_string(atomic_type.to_json(), sort_keys=True)

def do_parse_base_type(type_string):
    type_json = unbox_json(ovs.json.from_string(type_string))
    base_type = types.BaseType.from_json(type_json)
    print ovs.json.to_string(base_type.to_json(), sort_keys=True)

def do_parse_type(type_string):
    type_json = unbox_json(ovs.json.from_string(type_string))
    type = types.Type.from_json(type_json)
    print ovs.json.to_string(type.to_json(), sort_keys=True)

def do_parse_atoms(type_string, *atom_strings):
    type_json = unbox_json(ovs.json.from_string(type_string))
    base = types.BaseType.from_json(type_json)
    for atom_string in atom_strings:
        atom_json = unbox_json(ovs.json.from_string(atom_string))
        try:
            atom = data.Atom.from_json(base, atom_json)
            print ovs.json.to_string(atom.to_json())
        except error.Error, e:
            print unicode(e)

def do_parse_data(type_string, *data_strings):
    type_json = unbox_json(ovs.json.from_string(type_string))
    type = types.Type.from_json(type_json)
    for datum_string in data_strings:
        datum_json = unbox_json(ovs.json.from_string(datum_string))
        datum = data.Datum.from_json(type, datum_json)
        print ovs.json.to_string(datum.to_json())

def do_sort_atoms(type_string, atom_strings):
    type_json = unbox_json(ovs.json.from_string(type_string))
    base = types.BaseType.from_json(type_json)
    atoms = [data.Atom.from_json(base, atom_json)
             for atom_json in unbox_json(ovs.json.from_string(atom_strings))]
    print ovs.json.to_string([data.Atom.to_json(atom)
                              for atom in sorted(atoms)])

def do_parse_column(name, column_string):
    column_json = unbox_json(ovs.json.from_string(column_string))
    column = ovs.db.schema.ColumnSchema.from_json(column_json, name)
    print ovs.json.to_string(column.to_json(), sort_keys=True)

def do_parse_table(name, table_string, default_is_root_string='false'):
    default_is_root = default_is_root_string == 'true'
    table_json = unbox_json(ovs.json.from_string(table_string))
    table = ovs.db.schema.TableSchema.from_json(table_json, name)
    print ovs.json.to_string(table.to_json(default_is_root), sort_keys=True)

def do_parse_rows(table_string, *rows):
    table_json = unbox_json(ovs.json.from_string(table_string))
    table = ovs.db.schema.TableSchema.from_json(table_json, name)

def do_parse_schema(schema_string):
    schema_json = unbox_json(ovs.json.from_string(schema_string))
    schema = ovs.db.schema.DbSchema.from_json(schema_json)
    print ovs.json.to_string(schema.to_json(), sort_keys=True)

def print_idl(idl, step):
    n = 0
    for uuid, row in idl.data["simple"].iteritems():
        s = ("%03d: i=%s r=%s b=%s s=%s u=%s "
             "ia=%s ra=%s ba=%s sa=%s ua=%s uuid=%s"
             % (step, row.i, row.r, row.b, row.s, row.u,
                row.ia, row.ra, row.ba, row.sa, row.ua, uuid))
        print(re.sub('""|,', "", s))
        n += 1
    if not n:
        print("%03d: empty" % step)

def substitute_uuids(json, symtab):
    if type(json) in [str, unicode]:
        symbol = symtab.get(json)
        if symbol:
            return str(symbol)
    elif type(json) == list:
        return [substitute_uuids(element, symtab) for element in json]
    elif type(json) == dict:
        d = {}
        for key, value in json.iteritems():
            d[key] = substitute_uuids(value, symtab)
        return d
    return json

def parse_uuids(json, symtab):
    if type(json) in [str, unicode] and ovs.ovsuuid.UUID.is_valid_string(json):
        name = "#%d#" % len(symtab)
        sys.stderr.write("%s = %s\n" % (name, json))
        symtab[name] = json
    elif type(json) == list:
        for element in json:
            parse_uuids(element, symtab)
    elif type(json) == dict:
        for value in json.itervalues():
            parse_uuids(value, symtab)

def do_idl(remote, *commands):
    idl = ovs.db.idl.Idl(remote, "idltest")

    if commands:
        error, stream = ovs.stream.Stream.open_block(
            ovs.stream.Stream.open(remote))
        if error:
            sys.stderr.write("failed to connect to \"%s\"" % remote)
            sys.exit(1)
        rpc = ovs.jsonrpc.Connection(stream)
    else:
        rpc = None

    symtab = {}
    seqno = 0
    step = 0
    for command in commands:
        if command.startswith("+"):
            # The previous transaction didn't change anything.
            command = command[1:]
        else:
            # Wait for update.
            while idl.get_seqno() == seqno and not idl.run():
                rpc.run()

                poller = ovs.poller.Poller()
                idl.wait(poller)
                rpc.wait(poller)
                poller.block()
                
            print_idl(idl, step)
            step += 1

        seqno = idl.get_seqno()

        if command == "reconnect":
            print("%03d: reconnect" % step)
            step += 1
            idl.force_reconnect()
        elif not command.startswith("["):
            idl_set(idl, command, step)
            step += 1
        else:
            json = ovs.json.from_string(command)
            if type(json) in [str, unicode]:
                sys.stderr.write("\"%s\": %s\n" % (command, json))
                sys.exit(1)
            json = substitute_uuids(json, symtab)
            request = ovs.jsonrpc.Message.create_request("transact", json)
            error, reply = rpc.transact_block(request)
            if error:
                sys.stderr.write("jsonrpc transaction failed: %s"
                                 % os.strerror(error))
                sys.exit(1)
            sys.stdout.write("%03d: " % step)
            sys.stdout.flush()
            step += 1
            if reply.result is not None:
                parse_uuids(reply.result, symtab)
            reply.id = None
            sys.stdout.write("%s\n" % ovs.json.to_string(reply.to_json()))

    if rpc:
        rpc.close()
    while idl.get_seqno() == seqno and not idl.run():
        poller = ovs.poller.Poller()
        idl.wait(poller)
        poller.block()
    print_idl(idl, step)
    step += 1
    idl.close()
    print("%03d: done" % step)

def usage():
    print """\
%(program_name)s: test utility for Open vSwitch database Python bindings
usage: %(program_name)s [OPTIONS] COMMAND ARG...

The following commands are supported:
default-atoms
  test ovsdb_atom_default()
default-data
  test ovsdb_datum_default()
parse-atomic-type TYPE
  parse TYPE as OVSDB atomic type, and re-serialize
parse-base-type TYPE
  parse TYPE as OVSDB base type, and re-serialize
parse-type JSON
  parse JSON as OVSDB type, and re-serialize
parse-atoms TYPE ATOM...
  parse JSON ATOMs as atoms of TYPE, and re-serialize
parse-atom-strings TYPE ATOM...
  parse string ATOMs as atoms of given TYPE, and re-serialize
sort-atoms TYPE ATOM...
  print JSON ATOMs in sorted order
parse-data TYPE DATUM...
  parse JSON DATUMs as data of given TYPE, and re-serialize
parse-column NAME OBJECT
  parse column NAME with info OBJECT, and re-serialize
parse-table NAME OBJECT [DEFAULT-IS-ROOT]
  parse table NAME with info OBJECT
parse-schema JSON
  parse JSON as an OVSDB schema, and re-serialize
idl SERVER [TRANSACTION...]
  connect to SERVER and dump the contents of the database
  as seen initially by the IDL implementation and after
  executing each TRANSACTION.  (Each TRANSACTION must modify
  the database or this command will hang.)

The following options are also available:
  -t, --timeout=SECS          give up after SECS seconds
  -h, --help                  display this help message\
""" % {'program_name': ovs.util.PROGRAM_NAME}
    sys.exit(0)

def main(argv):
    try:
        options, args = getopt.gnu_getopt(argv[1:], 't:h',
                                          ['timeout',
                                           'help'])
    except getopt.GetoptError, geo:
        sys.stderr.write("%s: %s\n" % (ovs.util.PROGRAM_NAME, geo.msg))
        sys.exit(1)

    for key, value in options:
        if key in ['-h', '--help']:
            usage()
        elif key in ['-t', '--timeout']:
            try:
                timeout = int(value)
                if timeout < 1:
                    raise TypeError
            except TypeError:
                raise error.Error("value %s on -t or --timeout is not at "
                                  "least 1" % value)
            signal.alarm(timeout)
        else:
            sys.exit(0)

    optKeys = [key for key, value in options]

    if not args:
        sys.stderr.write("%s: missing command argument "
                         "(use --help for help)\n" % ovs.util.PROGRAM_NAME)
        sys.exit(1)

    commands = {"default-atoms": (do_default_atoms, 0),
                "default-data": (do_default_data, 0),
                "parse-atomic-type": (do_parse_atomic_type, 1),
                "parse-base-type": (do_parse_base_type, 1),
                "parse-type": (do_parse_type, 1),
                "parse-atoms": (do_parse_atoms, (2,)),
                "parse-data": (do_parse_data, (2,)),
                "sort-atoms": (do_sort_atoms, 2),
                "parse-column": (do_parse_column, 2),
                "parse-table": (do_parse_table, (2, 3)),
                "parse-schema": (do_parse_schema, 1),
                "idl": (do_idl, (1,))}

    command_name = args[0]
    args = args[1:]
    if not command_name in commands:
        sys.stderr.write("%s: unknown command \"%s\" "
                         "(use --help for help)\n" % (ovs.util.PROGRAM_NAME,
                                                      command_name))
        sys.exit(1)

    func, n_args = commands[command_name]
    if type(n_args) == tuple:
        if len(args) < n_args[0]:
            sys.stderr.write("%s: \"%s\" requires at least %d arguments but "
                             "only %d provided\n"
                             % (ovs.util.PROGRAM_NAME, command_name,
                                n_args, len(args)))
            sys.exit(1)
    elif type(n_args) == int:
        if len(args) != n_args:
            sys.stderr.write("%s: \"%s\" requires %d arguments but %d "
                             "provided\n"
                             % (ovs.util.PROGRAM_NAME, command_name,
                                n_args, len(args)))
            sys.exit(1)
    else:
        assert False

    func(*args)

if __name__ == '__main__':
    try:
        main(sys.argv)
    except error.Error, e:
        sys.stderr.write("%s\n" % e)
        sys.exit(1)
Commit	Line	Data
c5f341ab	1	# Copyright (c) 2009, 2010, 2011 Nicira Networks
99155935 BP	2	#
	3	# Licensed under the Apache License, Version 2.0 (the "License");
	4	# you may not use this file except in compliance with the License.
	5	# You may obtain a copy of the License at:
	6	#
	7	# http://www.apache.org/licenses/LICENSE-2.0
	8	#
	9	# Unless required by applicable law or agreed to in writing, software
	10	# distributed under the License is distributed on an "AS IS" BASIS,
	11	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	12	# See the License for the specific language governing permissions and
	13	# limitations under the License.
	14
	15	import codecs
	16	import getopt
	17	import re
	18	import os
	19	import signal
	20	import sys
	21
	22	from ovs.db import error
	23	import ovs.db.idl
	24	import ovs.db.schema
	25	from ovs.db import data
	26	from ovs.db import types
	27	import ovs.ovsuuid
	28	import ovs.poller
	29	import ovs.util
	30
	31	def unbox_json(json):
	32	if type(json) == list and len(json) == 1:
	33	return json[0]
	34	else:
	35	return json
	36
	37	def do_default_atoms():
	38	for type in types.ATOMIC_TYPES:
	39	if type == types.VoidType:
	40	continue
	41
	42	sys.stdout.write("%s: " % type.to_string())
	43
	44	atom = data.Atom.default(type)
	45	if atom != data.Atom.default(type):
	46	sys.stdout.write("wrong\n")
	47	sys.exit(1)
	48
	49	sys.stdout.write("OK\n")
	50
	51	def do_default_data():
	52	any_errors = False
	53	for n_min in 0, 1:
	54	for key in types.ATOMIC_TYPES:
	55	if key == types.VoidType:
	56	continue
	57	for value in types.ATOMIC_TYPES:
	58	if value == types.VoidType:
	59	valueBase = None
	60	else:
	61	valueBase = types.BaseType(value)
	62	type = types.Type(types.BaseType(key), valueBase, n_min, 1)
	63	assert type.is_valid()
	64
	65	sys.stdout.write("key %s, value %s, n_min %d: "
66	% (key.to_string(), value.to_string(), n_min))
67
68	datum = data.Datum.default(type)
69	if datum != data.Datum.default(type):
70	sys.stdout.write("wrong\n")
71	any_errors = True
72	else:
73	sys.stdout.write("OK\n")
74	if any_errors:
75	sys.exit(1)
76
77	def do_parse_atomic_type(type_string):
78	type_json = unbox_json(ovs.json.from_string(type_string))
79	atomic_type = types.AtomicType.from_json(type_json)
80	print ovs.json.to_string(atomic_type.to_json(), sort_keys=True)
81
82	def do_parse_base_type(type_string):
83	type_json = unbox_json(ovs.json.from_string(type_string))
84	base_type = types.BaseType.from_json(type_json)
85	print ovs.json.to_string(base_type.to_json(), sort_keys=True)
86
87	def do_parse_type(type_string):
88	type_json = unbox_json(ovs.json.from_string(type_string))
89	type = types.Type.from_json(type_json)
90	print ovs.json.to_string(type.to_json(), sort_keys=True)
91
92	def do_parse_atoms(type_string, *atom_strings):
93	type_json = unbox_json(ovs.json.from_string(type_string))
94	base = types.BaseType.from_json(type_json)
95	for atom_string in atom_strings:
96	atom_json = unbox_json(ovs.json.from_string(atom_string))
97	try:
98	atom = data.Atom.from_json(base, atom_json)
99	print ovs.json.to_string(atom.to_json())
100	except error.Error, e:
be44585c	101	print unicode(e)
99155935 BP	102
	103	def do_parse_data(type_string, *data_strings):
	104	type_json = unbox_json(ovs.json.from_string(type_string))
	105	type = types.Type.from_json(type_json)
	106	for datum_string in data_strings:
	107	datum_json = unbox_json(ovs.json.from_string(datum_string))
	108	datum = data.Datum.from_json(type, datum_json)
	109	print ovs.json.to_string(datum.to_json())
	110
	111	def do_sort_atoms(type_string, atom_strings):
	112	type_json = unbox_json(ovs.json.from_string(type_string))
	113	base = types.BaseType.from_json(type_json)
	114	atoms = [data.Atom.from_json(base, atom_json)
	115	for atom_json in unbox_json(ovs.json.from_string(atom_strings))]
	116	print ovs.json.to_string([data.Atom.to_json(atom)
	117	for atom in sorted(atoms)])
	118
	119	def do_parse_column(name, column_string):
	120	column_json = unbox_json(ovs.json.from_string(column_string))
	121	column = ovs.db.schema.ColumnSchema.from_json(column_json, name)
	122	print ovs.json.to_string(column.to_json(), sort_keys=True)
	123
c5f341ab BP	124	def do_parse_table(name, table_string, default_is_root_string='false'):
c5f341ab BP	125	default_is_root = default_is_root_string == 'true'
99155935 BP	126	table_json = unbox_json(ovs.json.from_string(table_string))
99155935 BP	127	table = ovs.db.schema.TableSchema.from_json(table_json, name)
c5f341ab	128	print ovs.json.to_string(table.to_json(default_is_root), sort_keys=True)
99155935 BP	129
	130	def do_parse_rows(table_string, *rows):
	131	table_json = unbox_json(ovs.json.from_string(table_string))
	132	table = ovs.db.schema.TableSchema.from_json(table_json, name)
	133
	134	def do_parse_schema(schema_string):
	135	schema_json = unbox_json(ovs.json.from_string(schema_string))
	136	schema = ovs.db.schema.DbSchema.from_json(schema_json)
	137	print ovs.json.to_string(schema.to_json(), sort_keys=True)
	138
	139	def print_idl(idl, step):
	140	n = 0
	141	for uuid, row in idl.data["simple"].iteritems():
	142	s = ("%03d: i=%s r=%s b=%s s=%s u=%s "
	143	"ia=%s ra=%s ba=%s sa=%s ua=%s uuid=%s"
	144	% (step, row.i, row.r, row.b, row.s, row.u,
	145	row.ia, row.ra, row.ba, row.sa, row.ua, uuid))
	146	print(re.sub('""\|,', "", s))
	147	n += 1
	148	if not n:
	149	print("%03d: empty" % step)
	150
	151	def substitute_uuids(json, symtab):
	152	if type(json) in [str, unicode]:
	153	symbol = symtab.get(json)
	154	if symbol:
	155	return str(symbol)
	156	elif type(json) == list:
	157	return [substitute_uuids(element, symtab) for element in json]
	158	elif type(json) == dict:
	159	d = {}
	160	for key, value in json.iteritems():
	161	d[key] = substitute_uuids(value, symtab)
	162	return d
	163	return json
	164
	165	def parse_uuids(json, symtab):
	166	if type(json) in [str, unicode] and ovs.ovsuuid.UUID.is_valid_string(json):
	167	name = "#%d#" % len(symtab)
	168	sys.stderr.write("%s = %s\n" % (name, json))
	169	symtab[name] = json
	170	elif type(json) == list:
	171	for element in json:
	172	parse_uuids(element, symtab)
	173	elif type(json) == dict:
	174	for value in json.itervalues():
	175	parse_uuids(value, symtab)
	176
	177	def do_idl(remote, *commands):
	178	idl = ovs.db.idl.Idl(remote, "idltest")
	179
	180	if commands:
	181	error, stream = ovs.stream.Stream.open_block(
	182	ovs.stream.Stream.open(remote))
	183	if error:
	184	sys.stderr.write("failed to connect to \"%s\"" % remote)
	185	sys.exit(1)
	186	rpc = ovs.jsonrpc.Connection(stream)
	187	else:
	188	rpc = None
	189
	190	symtab = {}
	191	seqno = 0
	192	step = 0
193	for command in commands:
194	if command.startswith("+"):
195	# The previous transaction didn't change anything.
196	command = command[1:]
197	else:
198	# Wait for update.
199	while idl.get_seqno() == seqno and not idl.run():
200	rpc.run()
201
202	poller = ovs.poller.Poller()
203	idl.wait(poller)
204	rpc.wait(poller)
205	poller.block()
206
207	print_idl(idl, step)
208	step += 1
209
210	seqno = idl.get_seqno()
211
212	if command == "reconnect":
213	print("%03d: reconnect" % step)
214	step += 1
215	idl.force_reconnect()
216	elif not command.startswith("["):
217	idl_set(idl, command, step)
218	step += 1
219	else:
220	json = ovs.json.from_string(command)
221	if type(json) in [str, unicode]:
222	sys.stderr.write("\"%s\": %s\n" % (command, json))
223	sys.exit(1)
224	json = substitute_uuids(json, symtab)
225	request = ovs.jsonrpc.Message.create_request("transact", json)
226	error, reply = rpc.transact_block(request)
227	if error:
228	sys.stderr.write("jsonrpc transaction failed: %s"
229	% os.strerror(error))
230	sys.exit(1)
231	sys.stdout.write("%03d: " % step)
232	sys.stdout.flush()
233	step += 1
234	if reply.result is not None:
235	parse_uuids(reply.result, symtab)
236	reply.id = None
237	sys.stdout.write("%s\n" % ovs.json.to_string(reply.to_json()))
238
239	if rpc:
240	rpc.close()
241	while idl.get_seqno() == seqno and not idl.run():
242	poller = ovs.poller.Poller()
243	idl.wait(poller)
244	poller.block()
245	print_idl(idl, step)
246	step += 1
247	idl.close()
248	print("%03d: done" % step)
249
250	def usage():
251	print """\
252	%(program_name)s: test utility for Open vSwitch database Python bindings
253	usage: %(program_name)s [OPTIONS] COMMAND ARG...
254
255	The following commands are supported:
256	default-atoms
257	test ovsdb_atom_default()
258	default-data
259	test ovsdb_datum_default()
260	parse-atomic-type TYPE
261	parse TYPE as OVSDB atomic type, and re-serialize
262	parse-base-type TYPE
263	parse TYPE as OVSDB base type, and re-serialize
264	parse-type JSON
265	parse JSON as OVSDB type, and re-serialize
266	parse-atoms TYPE ATOM...
267	parse JSON ATOMs as atoms of TYPE, and re-serialize
268	parse-atom-strings TYPE ATOM...
269	parse string ATOMs as atoms of given TYPE, and re-serialize
270	sort-atoms TYPE ATOM...
271	print JSON ATOMs in sorted order
272	parse-data TYPE DATUM...
273	parse JSON DATUMs as data of given TYPE, and re-serialize
274	parse-column NAME OBJECT
275	parse column NAME with info OBJECT, and re-serialize
c5f341ab	276	parse-table NAME OBJECT [DEFAULT-IS-ROOT]
99155935 BP	277	parse table NAME with info OBJECT
	278	parse-schema JSON
	279	parse JSON as an OVSDB schema, and re-serialize
	280	idl SERVER [TRANSACTION...]
	281	connect to SERVER and dump the contents of the database
	282	as seen initially by the IDL implementation and after
	283	executing each TRANSACTION. (Each TRANSACTION must modify
	284	the database or this command will hang.)
	285
	286	The following options are also available:
	287	-t, --timeout=SECS give up after SECS seconds
	288	-h, --help display this help message\
	289	""" % {'program_name': ovs.util.PROGRAM_NAME}
	290	sys.exit(0)
	291
	292	def main(argv):
99155935 BP	293	try:
	294	options, args = getopt.gnu_getopt(argv[1:], 't:h',
	295	['timeout',
	296	'help'])
	297	except getopt.GetoptError, geo:
	298	sys.stderr.write("%s: %s\n" % (ovs.util.PROGRAM_NAME, geo.msg))
	299	sys.exit(1)
	300
	301	for key, value in options:
	302	if key in ['-h', '--help']:
	303	usage()
	304	elif key in ['-t', '--timeout']:
	305	try:
	306	timeout = int(value)
	307	if timeout < 1:
	308	raise TypeError
	309	except TypeError:
	310	raise error.Error("value %s on -t or --timeout is not at "
	311	"least 1" % value)
	312	signal.alarm(timeout)
	313	else:
	314	sys.exit(0)
	315
	316	optKeys = [key for key, value in options]
	317
	318	if not args:
	319	sys.stderr.write("%s: missing command argument "
	320	"(use --help for help)\n" % ovs.util.PROGRAM_NAME)
	321	sys.exit(1)
	322
	323	commands = {"default-atoms": (do_default_atoms, 0),
	324	"default-data": (do_default_data, 0),
	325	"parse-atomic-type": (do_parse_atomic_type, 1),
	326	"parse-base-type": (do_parse_base_type, 1),
	327	"parse-type": (do_parse_type, 1),
	328	"parse-atoms": (do_parse_atoms, (2,)),
	329	"parse-data": (do_parse_data, (2,)),
	330	"sort-atoms": (do_sort_atoms, 2),
	331	"parse-column": (do_parse_column, 2),
c5f341ab	332	"parse-table": (do_parse_table, (2, 3)),
99155935 BP	333	"parse-schema": (do_parse_schema, 1),
	334	"idl": (do_idl, (1,))}
	335
	336	command_name = args[0]
	337	args = args[1:]
	338	if not command_name in commands:
	339	sys.stderr.write("%s: unknown command \"%s\" "
	340	"(use --help for help)\n" % (ovs.util.PROGRAM_NAME,
	341	command_name))
	342	sys.exit(1)
	343
	344	func, n_args = commands[command_name]
	345	if type(n_args) == tuple:
	346	if len(args) < n_args[0]:
	347	sys.stderr.write("%s: \"%s\" requires at least %d arguments but "
	348	"only %d provided\n"
	349	% (ovs.util.PROGRAM_NAME, command_name,
	350	n_args, len(args)))
	351	sys.exit(1)
	352	elif type(n_args) == int:
	353	if len(args) != n_args:
	354	sys.stderr.write("%s: \"%s\" requires %d arguments but %d "
	355	"provided\n"
	356	% (ovs.util.PROGRAM_NAME, command_name,
	357	n_args, len(args)))
	358	sys.exit(1)
	359	else:
	360	assert False
	361
	362	func(*args)
	363
	364	if __name__ == '__main__':
	365	try:
	366	main(sys.argv)
	367	except error.Error, e:
	368	sys.stderr.write("%s\n" % e)
	369	sys.exit(1)