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

# Copyright (c) 2009, 2010 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 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):
    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(), 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
  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):
    # Make stdout and stderr UTF-8, even if they are redirected to a file.
    sys.stdout = codecs.getwriter("utf-8")(sys.stdout)
    sys.stderr = codecs.getwriter("utf-8")(sys.stderr)

    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),
                "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
99155935 BP	1	# Copyright (c) 2009, 2010 Nicira Networks
	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:
101	print e
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
124	def do_parse_table(name, table_string):
125	table_json = unbox_json(ovs.json.from_string(table_string))
126	table = ovs.db.schema.TableSchema.from_json(table_json, name)
127	print ovs.json.to_string(table.to_json(), sort_keys=True)
128
129	def do_parse_rows(table_string, *rows):
130	table_json = unbox_json(ovs.json.from_string(table_string))
131	table = ovs.db.schema.TableSchema.from_json(table_json, name)
132
133	def do_parse_schema(schema_string):
134	schema_json = unbox_json(ovs.json.from_string(schema_string))
135	schema = ovs.db.schema.DbSchema.from_json(schema_json)
136	print ovs.json.to_string(schema.to_json(), sort_keys=True)
137
138	def print_idl(idl, step):
139	n = 0
140	for uuid, row in idl.data["simple"].iteritems():
141	s = ("%03d: i=%s r=%s b=%s s=%s u=%s "
142	"ia=%s ra=%s ba=%s sa=%s ua=%s uuid=%s"
143	% (step, row.i, row.r, row.b, row.s, row.u,
144	row.ia, row.ra, row.ba, row.sa, row.ua, uuid))
145	print(re.sub('""\|,', "", s))
146	n += 1
147	if not n:
148	print("%03d: empty" % step)
149
150	def substitute_uuids(json, symtab):
151	if type(json) in [str, unicode]:
152	symbol = symtab.get(json)
153	if symbol:
154	return str(symbol)
155	elif type(json) == list:
156	return [substitute_uuids(element, symtab) for element in json]
157	elif type(json) == dict:
158	d = {}
159	for key, value in json.iteritems():
160	d[key] = substitute_uuids(value, symtab)
161	return d
162	return json
163
164	def parse_uuids(json, symtab):
165	if type(json) in [str, unicode] and ovs.ovsuuid.UUID.is_valid_string(json):
166	name = "#%d#" % len(symtab)
167	sys.stderr.write("%s = %s\n" % (name, json))
168	symtab[name] = json
169	elif type(json) == list:
170	for element in json:
171	parse_uuids(element, symtab)
172	elif type(json) == dict:
173	for value in json.itervalues():
174	parse_uuids(value, symtab)
175
176	def do_idl(remote, *commands):
177	idl = ovs.db.idl.Idl(remote, "idltest")
178
179	if commands:
180	error, stream = ovs.stream.Stream.open_block(
181	ovs.stream.Stream.open(remote))
182	if error:
183	sys.stderr.write("failed to connect to \"%s\"" % remote)
184	sys.exit(1)
185	rpc = ovs.jsonrpc.Connection(stream)
186	else:
187	rpc = None
188
189	symtab = {}
190	seqno = 0
191	step = 0
192	for command in commands:
193	if command.startswith("+"):
194	# The previous transaction didn't change anything.
195	command = command[1:]
196	else:
197	# Wait for update.
198	while idl.get_seqno() == seqno and not idl.run():
199	rpc.run()
200
201	poller = ovs.poller.Poller()
202	idl.wait(poller)
203	rpc.wait(poller)
204	poller.block()
205
206	print_idl(idl, step)
207	step += 1
208
209	seqno = idl.get_seqno()
210
211	if command == "reconnect":
212	print("%03d: reconnect" % step)
213	step += 1
214	idl.force_reconnect()
215	elif not command.startswith("["):
216	idl_set(idl, command, step)
217	step += 1
218	else:
219	json = ovs.json.from_string(command)
220	if type(json) in [str, unicode]:
221	sys.stderr.write("\"%s\": %s\n" % (command, json))
222	sys.exit(1)
223	json = substitute_uuids(json, symtab)
224	request = ovs.jsonrpc.Message.create_request("transact", json)
225	error, reply = rpc.transact_block(request)
226	if error:
227	sys.stderr.write("jsonrpc transaction failed: %s"
228	% os.strerror(error))
229	sys.exit(1)
230	sys.stdout.write("%03d: " % step)
231	sys.stdout.flush()
232	step += 1
233	if reply.result is not None:
234	parse_uuids(reply.result, symtab)
235	reply.id = None
236	sys.stdout.write("%s\n" % ovs.json.to_string(reply.to_json()))
237
238	if rpc:
239	rpc.close()
240	while idl.get_seqno() == seqno and not idl.run():
241	poller = ovs.poller.Poller()
242	idl.wait(poller)
243	poller.block()
244	print_idl(idl, step)
245	step += 1
246	idl.close()
247	print("%03d: done" % step)
248
249	def usage():
250	print """\
251	%(program_name)s: test utility for Open vSwitch database Python bindings
252	usage: %(program_name)s [OPTIONS] COMMAND ARG...
253
254	The following commands are supported:
255	default-atoms
256	test ovsdb_atom_default()
257	default-data
258	test ovsdb_datum_default()
259	parse-atomic-type TYPE
260	parse TYPE as OVSDB atomic type, and re-serialize
261	parse-base-type TYPE
262	parse TYPE as OVSDB base type, and re-serialize
263	parse-type JSON
264	parse JSON as OVSDB type, and re-serialize
265	parse-atoms TYPE ATOM...
266	parse JSON ATOMs as atoms of TYPE, and re-serialize
267	parse-atom-strings TYPE ATOM...
268	parse string ATOMs as atoms of given TYPE, and re-serialize
269	sort-atoms TYPE ATOM...
270	print JSON ATOMs in sorted order
271	parse-data TYPE DATUM...
272	parse JSON DATUMs as data of given TYPE, and re-serialize
273	parse-column NAME OBJECT
274	parse column NAME with info OBJECT, and re-serialize
275	parse-table NAME OBJECT
276	parse table NAME with info OBJECT
277	parse-schema JSON
278	parse JSON as an OVSDB schema, and re-serialize
279	idl SERVER [TRANSACTION...]
280	connect to SERVER and dump the contents of the database
281	as seen initially by the IDL implementation and after
282	executing each TRANSACTION. (Each TRANSACTION must modify
283	the database or this command will hang.)
284
285	The following options are also available:
286	-t, --timeout=SECS give up after SECS seconds
287	-h, --help display this help message\
288	""" % {'program_name': ovs.util.PROGRAM_NAME}
289	sys.exit(0)
290
291	def main(argv):
292	# Make stdout and stderr UTF-8, even if they are redirected to a file.
293	sys.stdout = codecs.getwriter("utf-8")(sys.stdout)
294	sys.stderr = codecs.getwriter("utf-8")(sys.stderr)
295
296	try:
297	options, args = getopt.gnu_getopt(argv[1:], 't:h',
298	['timeout',
299	'help'])
300	except getopt.GetoptError, geo:
301	sys.stderr.write("%s: %s\n" % (ovs.util.PROGRAM_NAME, geo.msg))
302	sys.exit(1)
303
304	for key, value in options:
305	if key in ['-h', '--help']:
306	usage()
307	elif key in ['-t', '--timeout']:
308	try:
309	timeout = int(value)
310	if timeout < 1:
311	raise TypeError
312	except TypeError:
313	raise error.Error("value %s on -t or --timeout is not at "
314	"least 1" % value)
315	signal.alarm(timeout)
316	else:
317	sys.exit(0)
318
319	optKeys = [key for key, value in options]
320
321	if not args:
322	sys.stderr.write("%s: missing command argument "
323	"(use --help for help)\n" % ovs.util.PROGRAM_NAME)
324	sys.exit(1)
325
326	commands = {"default-atoms": (do_default_atoms, 0),
327	"default-data": (do_default_data, 0),
328	"parse-atomic-type": (do_parse_atomic_type, 1),
329	"parse-base-type": (do_parse_base_type, 1),
330	"parse-type": (do_parse_type, 1),
331	"parse-atoms": (do_parse_atoms, (2,)),
332	"parse-data": (do_parse_data, (2,)),
333	"sort-atoms": (do_sort_atoms, 2),
334	"parse-column": (do_parse_column, 2),
335	"parse-table": (do_parse_table, 2),
336	"parse-schema": (do_parse_schema, 1),
337	"idl": (do_idl, (1,))}
338
339	command_name = args[0]
340	args = args[1:]
341	if not command_name in commands:
342	sys.stderr.write("%s: unknown command \"%s\" "
343	"(use --help for help)\n" % (ovs.util.PROGRAM_NAME,
344	command_name))
345	sys.exit(1)
346
347	func, n_args = commands[command_name]
348	if type(n_args) == tuple:
349	if len(args) < n_args[0]:
350	sys.stderr.write("%s: \"%s\" requires at least %d arguments but "
351	"only %d provided\n"
352	% (ovs.util.PROGRAM_NAME, command_name,
353	n_args, len(args)))
354	sys.exit(1)
355	elif type(n_args) == int:
356	if len(args) != n_args:
357	sys.stderr.write("%s: \"%s\" requires %d arguments but %d "
358	"provided\n"
359	% (ovs.util.PROGRAM_NAME, command_name,
360	n_args, len(args)))
361	sys.exit(1)
362	else:
363	assert False
364
365	func(*args)
366
367	if __name__ == '__main__':
368	try:
369	main(sys.argv)
370	except error.Error, e:
371	sys.stderr.write("%s\n" % e)
372	sys.exit(1)