pintos-os.org Git - openvswitch/blob - tests/test-ovsdb.py

   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)