3 class Error(Exception):
4 def __init__(self, msg):
5 Exception.__init__(self)
8 def getMember(json, name, validTypes, description, default=None):
11 if len(validTypes) and type(member) not in validTypes:
12 raise Error("%s: type mismatch for '%s' member"
13 % (description, name))
17 def mustGetMember(json, name, expectedType, description):
18 member = getMember(json, name, expectedType, description)
20 raise Error("%s: missing '%s' member" % (description, name))
24 def __init__(self, name, tables):
30 name = mustGetMember(json, 'name', [unicode], 'database')
31 tablesJson = mustGetMember(json, 'tables', [dict], 'database')
33 for tableName, tableJson in tablesJson.iteritems():
34 tables[tableName] = TableSchema.fromJson(tableJson,
35 "%s table" % tableName)
36 return DbSchema(name, tables)
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
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)
52 def __init__(self, columns):
53 self.columns = columns
56 def fromJson(json, description):
57 columnsJson = mustGetMember(json, 'columns', [dict], description)
59 for name, json in columnsJson.iteritems():
60 columns[name] = ColumnSchema.fromJson(
61 json, "column %s in %s" % (name, description))
62 return TableSchema(columns)
65 def __init__(self, type, persistent):
67 self.persistent = persistent
70 def fromJson(json, description):
71 type = Type.fromJson(mustGetMember(json, 'type', [dict, unicode],
73 'type of %s' % description)
74 ephemeral = getMember(json, 'ephemeral', [bool], description)
75 persistent = ephemeral != True
76 return ColumnSchema(type, persistent)
78 def escapeCString(src):
99 dst += '\\%03o' % ord(c)
104 def returnUnchanged(x):
109 uuidRE = re.compile("^(%s{8})-(%s{4})-(%s{4})-(%s{4})-(%s{4})(%s{8})$"
110 % (x, x, x, x, x, x))
112 def __init__(self, value):
117 if not uuidRE.match(s):
118 raise Error("%s is not a valid UUID" % s)
123 if UUID.isValidJson(json):
126 raise Error("%s is not valid JSON for a UUID" % json)
129 def isValidJson(json):
130 return len(json) == 2 and json[0] == "uuid" and uuidRE.match(json[1])
133 return ["uuid", self.value]
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))]
143 def __init__(self, type, value):
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)
157 raise Error("%s is not valid JSON for type %s" % (json, type_))
160 if self.type == 'uuid':
161 return self.value.toString()
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':
172 return ['%s.boolean = true;']
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)
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':
191 elif self.type == 'string':
192 return escapeLiteral(self.value)
193 elif self.type == 'uuid':
194 return self.value.value
197 def __init__(self, type,
200 minInteger=None, maxInteger=None,
201 minReal=None, maxReal=None,
202 minLength=None, maxLength=None):
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
214 def fromJson(json, description):
215 if type(json) == unicode:
216 return BaseType(json)
218 atomicType = mustGetMember(json, 'type', [unicode], description)
219 enum = getMember(json, 'enum', [], description)
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)
232 def toEnglish(self, escapeLiteral=returnUnchanged):
233 if self.type == 'uuid' and self.refTable:
234 return escapeLiteral(self.refTable)
238 def constraintsToEnglish(self, escapeLiteral=returnUnchanged):
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])
245 return 'one of %s, %s, or %s' % (literals[0],
246 ', '.join(literals[1:-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)
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
272 def toCType(self, prefix):
274 return "struct %s%s *" % (prefix, self.refTable.lower())
276 return {'integer': 'int64_t ',
278 'uuid': 'struct uuid ',
280 'string': 'char *'}[self.type]
282 def copyCValue(self, dst, src):
283 args = {'dst': dst, 'src': src}
285 return ("%(dst)s = %(src)s->header_.uuid;") % args
286 elif self.type == 'string':
287 return "%(dst)s = xstrdup(%(src)s);" % args
289 return "%(dst)s = %(src)s;" % args
291 def initCDefault(self, var, isOptional):
293 return "%s = NULL;" % var
294 elif self.type == 'string' and not isOptional:
295 return "%s = \"\";" % var
297 return {'integer': '%s = 0;',
299 'uuid': 'uuid_zero(&%s);',
300 'boolean': '%s = false;',
301 'string': '%s = NULL;'}[self.type] % var
303 def cInitBaseType(self, indent, var):
305 stmts.append('ovsdb_base_type_init(&%s, OVSDB_TYPE_%s);' % (
306 var, self.type.upper()),)
308 stmts.append("%s.enum_ = xmalloc(sizeof *%s.enum_);"
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])
332 def __init__(self, key, value=None, min=1, max=1):
339 def fromJson(json, description):
340 if type(json) == unicode:
341 return Type(BaseType(json))
343 keyJson = mustGetMember(json, 'key', [dict, unicode], description)
344 key = BaseType.fromJson(keyJson, 'key in %s' % description)
346 valueJson = getMember(json, 'value', [dict, unicode], description)
348 value = BaseType.fromJson(valueJson,
349 'value in %s' % description)
353 min = getMember(json, 'min', [int], description, 1)
354 max = getMember(json, 'max', [int, unicode], description, 1)
355 return Type(key, value, min, max)
358 return self.min == 1 and self.max == 1 and not self.value
360 def isOptional(self):
361 return self.min == 0 and self.max == 1
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))
367 def toEnglish(self, escapeLiteral=returnUnchanged):
368 keyName = self.key.toEnglish(escapeLiteral)
370 valueName = self.value.toEnglish(escapeLiteral)
374 elif self.isOptional():
376 return "optional %s-%s pair" % (keyName, valueName)
378 return "optional %s" % keyName
380 if self.max == "unlimited":
382 quantity = "%d or more " % self.min
386 quantity = "%d to %d " % (self.min, self.max)
388 quantity = "up to %d " % self.max
391 return "map of %s%s-%s pairs" % (quantity, keyName, valueName)
393 if keyName.endswith('s'):
394 plural = keyName + "es"
396 plural = keyName + "s"
397 return "set of %s%s" % (quantity, plural)
399 def constraintsToEnglish(self, escapeLiteral=returnUnchanged):
403 keyConstraints = self.key.constraintsToEnglish(escapeLiteral)
406 constraints += ['key ' + keyConstraints]
408 constraints += [keyConstraints]
411 valueConstraints = self.value.constraintsToEnglish(escapeLiteral)
413 constraints += ['value ' + valueConstraints]
415 return ', '.join(constraints)
417 def cDeclComment(self):
418 if self.min == 1 and self.max == 1 and self.key.type == "string":
419 return "\t/* Always nonnull. */"
423 def cInitType(self, indent, var):
424 initKey = self.key.cInitBaseType(indent, "%s.key" % var)
426 initValue = self.value.cInitBaseType(indent, "%s.value" % var)
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":
435 initMax = "%s%s.n_max = %s;" % (indent, var, max)
436 return "\n".join((initKey, initValue, initMin, initMax))
439 def __init__(self, type, values):
444 def fromJson(type_, json):
446 if len(json) == 2 and json[0] == "set":
448 for atomJson in json[1]:
449 values += [Atom.fromJson(type_.key, atomJson)]
451 values = [Atom.fromJson(type_.key, json)]
453 if len(json) != 2 or json[0] != "map":
454 raise Error("%s is not valid JSON for a map" % json)
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)
461 def cInitDatum(self, var):
462 if len(self.values) == 0:
463 return ["ovsdb_datum_init_empty(%s);" % var]
465 s = ["%s->n = %d;" % (var, len(self.values))]
466 s += ["%s->keys = xmalloc(%d * sizeof *%s->keys);"
467 % (var, len(self.values), var)]
469 for i in range(len(self.values)):
473 s += key.cInitAtom("%s->keys[%d]" % (var, i))
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))
482 s += ["%s->values = NULL;" % var]
484 if len(self.values) > 1:
485 s += ["ovsdb_datum_sort_assert(%s, OVSDB_TYPE_%s);"
486 % (var, self.type.key.upper())]