ovsdb/OVSDB.py

   1 import re
   2
   3 class Error(Exception):
   4     def __init__(self, msg):
   5         Exception.__init__(self)
   6         self.msg = msg
   7
   8 def getMember(json, name, validTypes, description, default=None):
   9     if name in json:
  10         member = json[name]
  11         if len(validTypes) and type(member) not in validTypes:
  12             raise Error("%s: type mismatch for '%s' member"
  13                         % (description, name))
  14         return member
  15     return default
  16
  17 def mustGetMember(json, name, expectedType, description):
  18     member = getMember(json, name, expectedType, description)
  19     if member == None:
  20         raise Error("%s: missing '%s' member" % (description, name))
  21     return member
  22
  23 class DbSchema:
  24     def __init__(self, name, tables):
  25         self.name = name
  26         self.tables = tables
  27
  28     @staticmethod
  29     def fromJson(json):
  30         name = mustGetMember(json, 'name', [unicode], 'database')
  31         tablesJson = mustGetMember(json, 'tables', [dict], 'database')
  32         tables = {}
  33         for tableName, tableJson in tablesJson.iteritems():
  34             tables[tableName] = TableSchema.fromJson(tableJson,
  35                                                      "%s table" % tableName)
  36         return DbSchema(name, tables)
  37
  38 class IdlSchema(DbSchema):
  39     def __init__(self, name, tables, idlPrefix, idlHeader):
  40         DbSchema.__init__(self, name, tables)
  41         self.idlPrefix = idlPrefix
  42         self.idlHeader = idlHeader
  43
  44     @staticmethod
  45     def fromJson(json):
  46         schema = DbSchema.fromJson(json)
  47         idlPrefix = mustGetMember(json, 'idlPrefix', [unicode], 'database')
  48         idlHeader = mustGetMember(json, 'idlHeader', [unicode], 'database')
  49         return IdlSchema(schema.name, schema.tables, idlPrefix, idlHeader)
  50
  51 class TableSchema:
  52     def __init__(self, columns):
  53         self.columns = columns
  54
  55     @staticmethod
  56     def fromJson(json, description):
  57         columnsJson = mustGetMember(json, 'columns', [dict], description)
  58         columns = {}
  59         for name, json in columnsJson.iteritems():
  60             columns[name] = ColumnSchema.fromJson(
  61                 json, "column %s in %s" % (name, description))
  62         return TableSchema(columns)
  63
  64 class ColumnSchema:
  65     def __init__(self, type, persistent):
  66         self.type = type
  67         self.persistent = persistent
  68
  69     @staticmethod
  70     def fromJson(json, description):
  71         type = Type.fromJson(mustGetMember(json, 'type', [dict, unicode],
  72                                            description),
  73                              'type of %s' % description)
  74         ephemeral = getMember(json, 'ephemeral', [bool], description)
  75         persistent = ephemeral != True
  76         return ColumnSchema(type, persistent)
  77
  78 def escapeCString(src):
  79     dst = ""
  80     for c in src:
  81         if c in "\\\"":
  82             dst += "\\" + c
  83         elif ord(c) < 32:
  84             if c == '\n':
  85                 dst += '\\n'
  86             elif c == '\r':
  87                 dst += '\\r'
  88             elif c == '\a':
  89                 dst += '\\a'
  90             elif c == '\b':
  91                 dst += '\\b'
  92             elif c == '\f':
  93                 dst += '\\f'
  94             elif c == '\t':
  95                 dst += '\\t'
  96             elif c == '\v':
  97                 dst += '\\v'
  98             else:
  99                 dst += '\\%03o' % ord(c)
 100         else:
 101             dst += c
 102     return dst
 103
 104 def returnUnchanged(x):
 105     return x
 106
 107 class UUID:
 108     x = "[0-9a-fA-f]"
 109     uuidRE = re.compile("^(%s{8})-(%s{4})-(%s{4})-(%s{4})-(%s{4})(%s{8})$"
 110                         % (x, x, x, x, x, x))
 111
 112     def __init__(self, value):
 113         self.value = value
 114
 115     @staticmethod
 116     def fromString(s):
 117         if not uuidRE.match(s):
 118             raise Error("%s is not a valid UUID" % s)
 119         return UUID(s)
 120
 121     @staticmethod
 122     def fromJson(json):
 123         if UUID.isValidJson(json):
 124             return UUID(json[1])
 125         else:
 126             raise Error("%s is not valid JSON for a UUID" % json)
 127
 128     @staticmethod
 129     def isValidJson(json):
 130         return len(json) == 2 and json[0] == "uuid" and uuidRE.match(json[1])
 131
 132     def toJson(self):
 133         return ["uuid", self.value]
 134
 135     def cInitUUID(self, var):
 136         m = re.match(self.value)
 137         return ["%s.parts[0] = 0x%s;" % (var, m.group(1)),
 138                 "%s.parts[1] = 0x%s%s;" % (var, m.group(2), m.group(3)),
 139                 "%s.parts[2] = 0x%s%s;" % (var, m.group(4), m.group(5)),
 140                 "%s.parts[3] = 0x%s;" % (var, m.group(6))]
 141
 142 class Atom:
 143     def __init__(self, type, value):
 144         self.type = type
 145         self.value = value
 146
 147     @staticmethod
 148     def fromJson(type_, json):
 149         if ((type_ == 'integer' and type(json) in [int, long])
 150             or (type_ == 'real' and type(json) in [int, long, float])
 151             or (type_ == 'boolean' and json in [True, False])
 152             or (type_ == 'string' and type(json) in [str, unicode])):
 153             return Atom(type_, json)
 154         elif type_ == 'uuid':
 155             return UUID.fromJson(json)
 156         else:
 157             raise Error("%s is not valid JSON for type %s" % (json, type_))
 158
 159     def toJson(self):
 160         if self.type == 'uuid':
 161             return self.value.toString()
 162         else:
 163             return self.value
 164
 165     def cInitAtom(self, var):
 166         if self.type == 'integer':
 167             return ['%s.integer = %d;' % (var, self.value)]
 168         elif self.type == 'real':
 169             return ['%s.real = %.15g;' % (var, self.value)]
 170         elif self.type == 'boolean':
 171             if self.value:
 172                 return ['%s.boolean = true;']
 173             else:
 174                 return ['%s.boolean = false;']
 175         elif self.type == 'string':
 176             return ['%s.string = xstrdup("%s");'
 177                     % (var, escapeCString(self.value))]
 178         elif self.type == 'uuid':
 179             return self.value.cInitUUID(var)
 180
 181     def toEnglish(self, escapeLiteral=returnUnchanged):
 182         if self.type == 'integer':
 183             return '%d' % self.value
 184         elif self.type == 'real':
 185             return '%.15g' % self.value
 186         elif self.type == 'boolean':
 187             if self.value:
 188                 return 'true'
 189             else:
 190                 return 'false'
 191         elif self.type == 'string':
 192             return escapeLiteral(self.value)
 193         elif self.type == 'uuid':
 194             return self.value.value
 195
 196 class BaseType:
 197     def __init__(self, type,
 198                  enum=None,
 199                  refTable=None,
 200                  minInteger=None, maxInteger=None,
 201                  minReal=None, maxReal=None,
 202                  minLength=None, maxLength=None):
 203         self.type = type
 204         self.enum = enum
 205         self.refTable = refTable
 206         self.minInteger = minInteger
 207         self.maxInteger = maxInteger
 208         self.minReal = minReal
 209         self.maxReal = maxReal
 210         self.minLength = minLength
 211         self.maxLength = maxLength
 212
 213     @staticmethod
 214     def fromJson(json, description):
 215         if type(json) == unicode:
 216             return BaseType(json)
 217         else:
 218             atomicType = mustGetMember(json, 'type', [unicode], description)
 219             enum = getMember(json, 'enum', [], description)
 220             if enum:
 221                 enumType = Type(atomicType, None, 0, 'unlimited')
 222                 enum = Datum.fromJson(enumType, enum)
 223             refTable = getMember(json, 'refTable', [unicode], description)
 224             minInteger = getMember(json, 'minInteger', [int, long], description)
 225             maxInteger = getMember(json, 'maxInteger', [int, long], description)
 226             minReal = getMember(json, 'minReal', [int, long, float], description)
 227             maxReal = getMember(json, 'maxReal', [int, long, float], description)
 228             minLength = getMember(json, 'minLength', [int], description)
 229             maxLength = getMember(json, 'minLength', [int], description)
 230             return BaseType(atomicType, enum, refTable, minInteger, maxInteger, minReal, maxReal, minLength, maxLength)
 231
 232     def toEnglish(self, escapeLiteral=returnUnchanged):
 233         if self.type == 'uuid' and self.refTable:
 234             return escapeLiteral(self.refTable)
 235         else:
 236             return self.type
 237
 238     def constraintsToEnglish(self, escapeLiteral=returnUnchanged):
 239         if self.enum:
 240             literals = [value.toEnglish(escapeLiteral)
 241                         for value in self.enum.values]
 242             if len(literals) == 2:
 243                 return 'either %s or %s' % (literals[0], literals[1])
 244             else:
 245                 return 'one of %s, %s, or %s' % (literals[0],
 246                                                  ', '.join(literals[1:-1]),
 247                                                  literals[-1])
 248         elif self.minInteger != None and self.maxInteger != None:
 249             return 'in range [%d,%d]' % (self.minInteger, self.maxInteger)
 250         elif self.minInteger != None:
 251             return 'at least %d' % self.minInteger
 252         elif self.maxInteger != None:
 253             return 'at most %d' % self.maxInteger
 254         elif self.minReal != None and self.maxReal != None:
 255             return 'in range [%g, %g]' % (self.minReal, self.maxReal)
 256         elif self.minReal != None:
 257             return 'at least %g' % self.minReal
 258         elif self.maxReal != None:
 259             return 'at most %g' % self.maxReal
 260         elif self.minLength != None and self.maxLength != None:
 261             if self.minLength == self.maxLength:
 262                 return 'exactly %d characters long' % (self.minLength)
 263             else:
 264                 return 'between %d and %d characters long' % (self.minLength, self.maxLength)
 265         elif self.minLength != None:
 266             return 'at least %d characters long' % self.minLength
 267         elif self.maxLength != None:
 268             return 'at most %d characters long' % self.maxLength
 269         else:
 270             return ''
 271
 272     def toCType(self, prefix):
 273         if self.refTable:
 274             return "struct %s%s *" % (prefix, self.refTable.lower())
 275         else:
 276             return {'integer': 'int64_t ',
 277                     'real': 'double ',
 278                     'uuid': 'struct uuid ',
 279                     'boolean': 'bool ',
 280                     'string': 'char *'}[self.type]
 281
 282     def copyCValue(self, dst, src):
 283         args = {'dst': dst, 'src': src}
 284         if self.refTable:
 285             return ("%(dst)s = %(src)s->header_.uuid;") % args
 286         elif self.type == 'string':
 287             return "%(dst)s = xstrdup(%(src)s);" % args
 288         else:
 289             return "%(dst)s = %(src)s;" % args
 290
 291     def initCDefault(self, var, isOptional):
 292         if self.refTable:
 293             return "%s = NULL;" % var
 294         elif self.type == 'string' and not isOptional:
 295             return "%s = \"\";" % var
 296         else:
 297             return {'integer': '%s = 0;',
 298                     'real': '%s = 0.0;',
 299                     'uuid': 'uuid_zero(&%s);',
 300                     'boolean': '%s = false;',
 301                     'string': '%s = NULL;'}[self.type] % var
 302
 303     def cInitBaseType(self, indent, var):
 304         stmts = []
 305         stmts.append('ovsdb_base_type_init(&%s, OVSDB_TYPE_%s);' % (
 306                 var, self.type.upper()),)
 307         if self.enum:
 308             stmts.append("%s.enum_ = xmalloc(sizeof *%s.enum_);"
 309                          % (var, var))
 310             stmts += self.enum.cInitDatum("%s.enum_" % var)
 311         if self.type == 'integer':
 312             if self.minInteger != None:
 313                 stmts.append('%s.u.integer.min = %d;' % (var, self.minInteger))
 314             if self.maxInteger != None:
 315                 stmts.append('%s.u.integer.max = %d;' % (var, self.maxInteger))
 316         elif self.type == 'real':
 317             if self.minReal != None:
 318                 stmts.append('%s.u.real.min = %d;' % (var, self.minReal))
 319             if self.maxReal != None:
 320                 stmts.append('%s.u.real.max = %d;' % (var, self.maxReal))
 321         elif self.type == 'string':
 322             if self.minLength != None:
 323                 stmts.append('%s.u.string.minLen = %d;' % (var, self.minLength))
 324             if self.maxLength != None:
 325                 stmts.append('%s.u.string.maxLen = %d;' % (var, self.maxLength))
 326         elif self.type == 'uuid':
 327             if self.refTable != None:
 328                 stmts.append('%s.u.uuid.refTableName = "%s";' % (var, escapeCString(self.refTable)))
 329         return '\n'.join([indent + stmt for stmt in stmts])
 330
 331 class Type:
 332     def __init__(self, key, value=None, min=1, max=1):
 333         self.key = key
 334         self.value = value
 335         self.min = min
 336         self.max = max
 337
 338     @staticmethod
 339     def fromJson(json, description):
 340         if type(json) == unicode:
 341             return Type(BaseType(json))
 342         else:
 343             keyJson = mustGetMember(json, 'key', [dict, unicode], description)
 344             key = BaseType.fromJson(keyJson, 'key in %s' % description)
 345
 346             valueJson = getMember(json, 'value', [dict, unicode], description)
 347             if valueJson:
 348                 value = BaseType.fromJson(valueJson,
 349                                           'value in %s' % description)
 350             else:
 351                 value = None
 352
 353             min = getMember(json, 'min', [int], description, 1)
 354             max = getMember(json, 'max', [int, unicode], description, 1)
 355             return Type(key, value, min, max)
 356
 357     def isScalar(self):
 358         return self.min == 1 and self.max == 1 and not self.value
 359
 360     def isOptional(self):
 361         return self.min == 0 and self.max == 1
 362
 363     def isOptionalPointer(self):
 364         return (self.min == 0 and self.max == 1 and not self.value
 365                 and (self.key.type == 'string' or self.key.refTable))
 366
 367     def toEnglish(self, escapeLiteral=returnUnchanged):
 368         keyName = self.key.toEnglish(escapeLiteral)
 369         if self.value:
 370             valueName = self.value.toEnglish(escapeLiteral)
 371
 372         if self.isScalar():
 373             return keyName
 374         elif self.isOptional():
 375             if self.value:
 376                 return "optional %s-%s pair" % (keyName, valueName)
 377             else:
 378                 return "optional %s" % keyName
 379         else:
 380             if self.max == "unlimited":
 381                 if self.min:
 382                     quantity = "%d or more " % self.min
 383                 else:
 384                     quantity = ""
 385             elif self.min:
 386                 quantity = "%d to %d " % (self.min, self.max)
 387             else:
 388                 quantity = "up to %d " % self.max
 389
 390             if self.value:
 391                 return "map of %s%s-%s pairs" % (quantity, keyName, valueName)
 392             else:
 393                 if keyName.endswith('s'):
 394                     plural = keyName + "es"
 395                 else:
 396                     plural = keyName + "s"
 397                 return "set of %s%s" % (quantity, plural)
 398
 399     def constraintsToEnglish(self, escapeLiteral=returnUnchanged):
 400         s = ""
 401
 402         constraints = []
 403         keyConstraints = self.key.constraintsToEnglish(escapeLiteral)
 404         if keyConstraints:
 405             if self.value:
 406                 constraints += ['key ' + keyConstraints]
 407             else:
 408                 constraints += [keyConstraints]
 409
 410         if self.value:
 411             valueConstraints = self.value.constraintsToEnglish(escapeLiteral)
 412             if valueConstraints:
 413                 constraints += ['value ' + valueConstraints]
 414
 415         return ', '.join(constraints)
 416
 417     def cDeclComment(self):
 418         if self.min == 1 and self.max == 1 and self.key.type == "string":
 419             return "\t/* Always nonnull. */"
 420         else:
 421             return ""
 422
 423     def cInitType(self, indent, var):
 424         initKey = self.key.cInitBaseType(indent, "%s.key" % var)
 425         if self.value:
 426             initValue = self.value.cInitBaseType(indent, "%s.value" % var)
 427         else:
 428             initValue = ('%sovsdb_base_type_init(&%s.value, '
 429                          'OVSDB_TYPE_VOID);' % (indent, var))
 430         initMin = "%s%s.n_min = %s;" % (indent, var, self.min)
 431         if self.max == "unlimited":
 432             max = "UINT_MAX"
 433         else:
 434             max = self.max
 435         initMax = "%s%s.n_max = %s;" % (indent, var, max)
 436         return "\n".join((initKey, initValue, initMin, initMax))
 437
 438 class Datum:
 439     def __init__(self, type, values):
 440         self.type = type
 441         self.values = values
 442
 443     @staticmethod
 444     def fromJson(type_, json):
 445         if not type_.value:
 446             if len(json) == 2 and json[0] == "set":
 447                 values = []
 448                 for atomJson in json[1]:
 449                     values += [Atom.fromJson(type_.key, atomJson)]
 450             else:
 451                 values = [Atom.fromJson(type_.key, json)]
 452         else:
 453             if len(json) != 2 or json[0] != "map":
 454                 raise Error("%s is not valid JSON for a map" % json)
 455             values = []
 456             for pairJson in json[1]:
 457                 values += [(Atom.fromJson(type_.key, pairJson[0]),
 458                             Atom.fromJson(type_.value, pairJson[1]))]
 459         return Datum(type_, values)
 460
 461     def cInitDatum(self, var):
 462         if len(self.values) == 0:
 463             return ["ovsdb_datum_init_empty(%s);" % var]
 464
 465         s = ["%s->n = %d;" % (var, len(self.values))]
 466         s += ["%s->keys = xmalloc(%d * sizeof *%s->keys);"
 467               % (var, len(self.values), var)]
 468
 469         for i in range(len(self.values)):
 470             key = self.values[i]
 471             if self.type.value:
 472                 key = key[0]
 473             s += key.cInitAtom("%s->keys[%d]" % (var, i))
 474
 475         if self.type.value:
 476             s += ["%s->values = xmalloc(%d * sizeof *%s->values);"
 477                   % (var, len(self.values), var)]
 478             for i in range(len(self.values)):
 479                 value = self.values[i][1]
 480                 s += key.cInitAtom("%s->values[%d]" % (var, i))
 481         else:
 482             s += ["%s->values = NULL;" % var]
 483
 484         if len(self.values) > 1:
 485             s += ["ovsdb_datum_sort_assert(%s, OVSDB_TYPE_%s);"
 486                   % (var, self.type.key.upper())]
 487
 488         return s