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, refType="strong",
 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.refType = refType
 207         self.minInteger = minInteger
 208         self.maxInteger = maxInteger
 209         self.minReal = minReal
 210         self.maxReal = maxReal
 211         self.minLength = minLength
 212         self.maxLength = maxLength
 213
 214     @staticmethod
 215     def fromJson(json, description):
 216         if type(json) == unicode:
 217             return BaseType(json)
 218         else:
 219             atomicType = mustGetMember(json, 'type', [unicode], description)
 220             enum = getMember(json, 'enum', [], description)
 221             if enum:
 222                 enumType = Type(atomicType, None, 0, 'unlimited')
 223                 enum = Datum.fromJson(enumType, enum)
 224             refTable = getMember(json, 'refTable', [unicode], description)
 225             refType = getMember(json, 'refType', [unicode], description)
 226             if refType == None:
 227                 refType = "strong"
 228             minInteger = getMember(json, 'minInteger', [int, long], description)
 229             maxInteger = getMember(json, 'maxInteger', [int, long], description)
 230             minReal = getMember(json, 'minReal', [int, long, float], description)
 231             maxReal = getMember(json, 'maxReal', [int, long, float], description)
 232             minLength = getMember(json, 'minLength', [int], description)
 233             maxLength = getMember(json, 'minLength', [int], description)
 234             return BaseType(atomicType, enum, refTable, refType, minInteger, maxInteger, minReal, maxReal, minLength, maxLength)
 235
 236     def toEnglish(self, escapeLiteral=returnUnchanged):
 237         if self.type == 'uuid' and self.refTable:
 238             s = escapeLiteral(self.refTable)
 239             if self.refType == 'weak':
 240                 s = "weak reference to " + s
 241             return s
 242         else:
 243             return self.type
 244
 245     def constraintsToEnglish(self, escapeLiteral=returnUnchanged):
 246         if self.enum:
 247             literals = [value.toEnglish(escapeLiteral)
 248                         for value in self.enum.values]
 249             if len(literals) == 2:
 250                 return 'either %s or %s' % (literals[0], literals[1])
 251             else:
 252                 return 'one of %s, %s, or %s' % (literals[0],
 253                                                  ', '.join(literals[1:-1]),
 254                                                  literals[-1])
 255         elif self.minInteger != None and self.maxInteger != None:
 256             return 'in range [%d,%d]' % (self.minInteger, self.maxInteger)
 257         elif self.minInteger != None:
 258             return 'at least %d' % self.minInteger
 259         elif self.maxInteger != None:
 260             return 'at most %d' % self.maxInteger
 261         elif self.minReal != None and self.maxReal != None:
 262             return 'in range [%g, %g]' % (self.minReal, self.maxReal)
 263         elif self.minReal != None:
 264             return 'at least %g' % self.minReal
 265         elif self.maxReal != None:
 266             return 'at most %g' % self.maxReal
 267         elif self.minLength != None and self.maxLength != None:
 268             if self.minLength == self.maxLength:
 269                 return 'exactly %d characters long' % (self.minLength)
 270             else:
 271                 return 'between %d and %d characters long' % (self.minLength, self.maxLength)
 272         elif self.minLength != None:
 273             return 'at least %d characters long' % self.minLength
 274         elif self.maxLength != None:
 275             return 'at most %d characters long' % self.maxLength
 276         else:
 277             return ''
 278
 279     def toCType(self, prefix):
 280         if self.refTable:
 281             return "struct %s%s *" % (prefix, self.refTable.lower())
 282         else:
 283             return {'integer': 'int64_t ',
 284                     'real': 'double ',
 285                     'uuid': 'struct uuid ',
 286                     'boolean': 'bool ',
 287                     'string': 'char *'}[self.type]
 288
 289     def copyCValue(self, dst, src):
 290         args = {'dst': dst, 'src': src}
 291         if self.refTable:
 292             return ("%(dst)s = %(src)s->header_.uuid;") % args
 293         elif self.type == 'string':
 294             return "%(dst)s = xstrdup(%(src)s);" % args
 295         else:
 296             return "%(dst)s = %(src)s;" % args
 297
 298     def initCDefault(self, var, isOptional):
 299         if self.refTable:
 300             return "%s = NULL;" % var
 301         elif self.type == 'string' and not isOptional:
 302             return "%s = \"\";" % var
 303         else:
 304             return {'integer': '%s = 0;',
 305                     'real': '%s = 0.0;',
 306                     'uuid': 'uuid_zero(&%s);',
 307                     'boolean': '%s = false;',
 308                     'string': '%s = NULL;'}[self.type] % var
 309
 310     def cInitBaseType(self, indent, var):
 311         stmts = []
 312         stmts.append('ovsdb_base_type_init(&%s, OVSDB_TYPE_%s);' % (
 313                 var, self.type.upper()),)
 314         if self.enum:
 315             stmts.append("%s.enum_ = xmalloc(sizeof *%s.enum_);"
 316                          % (var, var))
 317             stmts += self.enum.cInitDatum("%s.enum_" % var)
 318         if self.type == 'integer':
 319             if self.minInteger != None:
 320                 stmts.append('%s.u.integer.min = %d;' % (var, self.minInteger))
 321             if self.maxInteger != None:
 322                 stmts.append('%s.u.integer.max = %d;' % (var, self.maxInteger))
 323         elif self.type == 'real':
 324             if self.minReal != None:
 325                 stmts.append('%s.u.real.min = %d;' % (var, self.minReal))
 326             if self.maxReal != None:
 327                 stmts.append('%s.u.real.max = %d;' % (var, self.maxReal))
 328         elif self.type == 'string':
 329             if self.minLength != None:
 330                 stmts.append('%s.u.string.minLen = %d;' % (var, self.minLength))
 331             if self.maxLength != None:
 332                 stmts.append('%s.u.string.maxLen = %d;' % (var, self.maxLength))
 333         elif self.type == 'uuid':
 334             if self.refTable != None:
 335                 stmts.append('%s.u.uuid.refTableName = "%s";' % (var, escapeCString(self.refTable)))
 336         return '\n'.join([indent + stmt for stmt in stmts])
 337
 338 class Type:
 339     def __init__(self, key, value=None, min=1, max=1):
 340         self.key = key
 341         self.value = value
 342         self.min = min
 343         self.max = max
 344
 345     @staticmethod
 346     def fromJson(json, description):
 347         if type(json) == unicode:
 348             return Type(BaseType(json))
 349         else:
 350             keyJson = mustGetMember(json, 'key', [dict, unicode], description)
 351             key = BaseType.fromJson(keyJson, 'key in %s' % description)
 352
 353             valueJson = getMember(json, 'value', [dict, unicode], description)
 354             if valueJson:
 355                 value = BaseType.fromJson(valueJson,
 356                                           'value in %s' % description)
 357             else:
 358                 value = None
 359
 360             min = getMember(json, 'min', [int], description, 1)
 361             max = getMember(json, 'max', [int, unicode], description, 1)
 362             return Type(key, value, min, max)
 363
 364     def isScalar(self):
 365         return self.min == 1 and self.max == 1 and not self.value
 366
 367     def isOptional(self):
 368         return self.min == 0 and self.max == 1
 369
 370     def isOptionalPointer(self):
 371         return (self.min == 0 and self.max == 1 and not self.value
 372                 and (self.key.type == 'string' or self.key.refTable))
 373
 374     def toEnglish(self, escapeLiteral=returnUnchanged):
 375         keyName = self.key.toEnglish(escapeLiteral)
 376         if self.value:
 377             valueName = self.value.toEnglish(escapeLiteral)
 378
 379         if self.isScalar():
 380             return keyName
 381         elif self.isOptional():
 382             if self.value:
 383                 return "optional %s-%s pair" % (keyName, valueName)
 384             else:
 385                 return "optional %s" % keyName
 386         else:
 387             if self.max == "unlimited":
 388                 if self.min:
 389                     quantity = "%d or more " % self.min
 390                 else:
 391                     quantity = ""
 392             elif self.min:
 393                 quantity = "%d to %d " % (self.min, self.max)
 394             else:
 395                 quantity = "up to %d " % self.max
 396
 397             if self.value:
 398                 return "map of %s%s-%s pairs" % (quantity, keyName, valueName)
 399             else:
 400                 if keyName.endswith('s'):
 401                     plural = keyName + "es"
 402                 else:
 403                     plural = keyName + "s"
 404                 return "set of %s%s" % (quantity, plural)
 405
 406     def constraintsToEnglish(self, escapeLiteral=returnUnchanged):
 407         s = ""
 408
 409         constraints = []
 410         keyConstraints = self.key.constraintsToEnglish(escapeLiteral)
 411         if keyConstraints:
 412             if self.value:
 413                 constraints += ['key ' + keyConstraints]
 414             else:
 415                 constraints += [keyConstraints]
 416
 417         if self.value:
 418             valueConstraints = self.value.constraintsToEnglish(escapeLiteral)
 419             if valueConstraints:
 420                 constraints += ['value ' + valueConstraints]
 421
 422         return ', '.join(constraints)
 423
 424     def cDeclComment(self):
 425         if self.min == 1 and self.max == 1 and self.key.type == "string":
 426             return "\t/* Always nonnull. */"
 427         else:
 428             return ""
 429
 430     def cInitType(self, indent, var):
 431         initKey = self.key.cInitBaseType(indent, "%s.key" % var)
 432         if self.value:
 433             initValue = self.value.cInitBaseType(indent, "%s.value" % var)
 434         else:
 435             initValue = ('%sovsdb_base_type_init(&%s.value, '
 436                          'OVSDB_TYPE_VOID);' % (indent, var))
 437         initMin = "%s%s.n_min = %s;" % (indent, var, self.min)
 438         if self.max == "unlimited":
 439             max = "UINT_MAX"
 440         else:
 441             max = self.max
 442         initMax = "%s%s.n_max = %s;" % (indent, var, max)
 443         return "\n".join((initKey, initValue, initMin, initMax))
 444
 445 class Datum:
 446     def __init__(self, type, values):
 447         self.type = type
 448         self.values = values
 449
 450     @staticmethod
 451     def fromJson(type_, json):
 452         if not type_.value:
 453             if len(json) == 2 and json[0] == "set":
 454                 values = []
 455                 for atomJson in json[1]:
 456                     values += [Atom.fromJson(type_.key, atomJson)]
 457             else:
 458                 values = [Atom.fromJson(type_.key, json)]
 459         else:
 460             if len(json) != 2 or json[0] != "map":
 461                 raise Error("%s is not valid JSON for a map" % json)
 462             values = []
 463             for pairJson in json[1]:
 464                 values += [(Atom.fromJson(type_.key, pairJson[0]),
 465                             Atom.fromJson(type_.value, pairJson[1]))]
 466         return Datum(type_, values)
 467
 468     def cInitDatum(self, var):
 469         if len(self.values) == 0:
 470             return ["ovsdb_datum_init_empty(%s);" % var]
 471
 472         s = ["%s->n = %d;" % (var, len(self.values))]
 473         s += ["%s->keys = xmalloc(%d * sizeof *%s->keys);"
 474               % (var, len(self.values), var)]
 475
 476         for i in range(len(self.values)):
 477             key = self.values[i]
 478             if self.type.value:
 479                 key = key[0]
 480             s += key.cInitAtom("%s->keys[%d]" % (var, i))
 481
 482         if self.type.value:
 483             s += ["%s->values = xmalloc(%d * sizeof *%s->values);"
 484                   % (var, len(self.values), var)]
 485             for i in range(len(self.values)):
 486                 value = self.values[i][1]
 487                 s += key.cInitAtom("%s->values[%d]" % (var, i))
 488         else:
 489             s += ["%s->values = NULL;" % var]
 490
 491         if len(self.values) > 1:
 492             s += ["ovsdb_datum_sort_assert(%s, OVSDB_TYPE_%s);"
 493                   % (var, self.type.key.upper())]
 494
 495         return s