X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=python%2Fovs%2Fdb%2Fschema.py;h=bc86232f9c99ad0433a777c3d3015cfac3290d50;hb=ec9f40dce11c7e81bc41d42e3bbfaaf8287165ce;hp=29fe986a254c56a0f47aa9057914f21d21903d8b;hpb=693e5dc7484b15c159cb9f644d28dc759db01b7c;p=sliver-openvswitch.git diff --git a/python/ovs/db/schema.py b/python/ovs/db/schema.py index 29fe986a2..bc86232f9 100644 --- a/python/ovs/db/schema.py +++ b/python/ovs/db/schema.py @@ -1,4 +1,4 @@ -# Copyright (c) 2009, 2010, 2011 Nicira Networks +# Copyright (c) 2009, 2010, 2011 Nicira, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -19,12 +19,14 @@ from ovs.db import error import ovs.db.parser from ovs.db import types + def _check_id(name, json): if name.startswith('_'): raise error.Error('names beginning with "_" are reserved', json) elif not ovs.db.parser.is_identifier(name): raise error.Error("name must be a valid id", json) + class DbSchema(object): """Schema for an OVSDB database.""" @@ -41,16 +43,15 @@ class DbSchema(object): for table in self.tables.itervalues(): table.is_root = True - # Validate that all ref_tables refer to the names of tables - # that exist. + # Find the "ref_table"s referenced by "ref_table_name"s. # # Also force certain columns to be persistent, as explained in # __check_ref_table(). This requires 'is_root' to be known, so this # must follow the loop updating 'is_root' above. for table in self.tables.itervalues(): for column in table.columns.itervalues(): - self.__check_ref_table(column, column.type.key, "key") - self.__check_ref_table(column, column.type.value, "value") + self.__follow_ref_table(column, column.type.key, "key") + self.__follow_ref_table(column, column.type.value, "value") def __root_set_size(self): """Returns the number of tables in the schema's root set.""" @@ -64,8 +65,8 @@ class DbSchema(object): def from_json(json): parser = ovs.db.parser.Parser(json, "database schema") name = parser.get("name", ['id']) - version = parser.get_optional("version", [unicode]) - parser.get_optional("cksum", [unicode]) + version = parser.get_optional("version", [str, unicode]) + parser.get_optional("cksum", [str, unicode]) tablesJson = parser.get("tables", [dict]) parser.finish() @@ -96,17 +97,20 @@ class DbSchema(object): json["version"] = self.version return json - def __check_ref_table(self, column, base, base_name): - if not base or base.type != types.UuidType or not base.ref_table: + def copy(self): + return DbSchema.from_json(self.to_json()) + + def __follow_ref_table(self, column, base, base_name): + if not base or base.type != types.UuidType or not base.ref_table_name: return - ref_table = self.tables.get(base.ref_table) - if not ref_table: + base.ref_table = self.tables.get(base.ref_table_name) + if not base.ref_table: raise error.Error("column %s %s refers to undefined table %s" - % (column.name, base_name, base.ref_table), + % (column.name, base_name, base.ref_table_name), tag="syntax error") - if base.is_strong_ref() and not ref_table.is_root: + if base.is_strong_ref() and not base.ref_table.is_root: # We cannot allow a strong reference to a non-root table to be # ephemeral: if it is the only reference to a row, then replaying # the database log from disk will cause the referenced row to be @@ -116,6 +120,7 @@ class DbSchema(object): # error. column.persistent = True + class IdlSchema(DbSchema): def __init__(self, name, version, tables, idlPrefix, idlHeader): DbSchema.__init__(self, name, version, tables) @@ -125,8 +130,8 @@ class IdlSchema(DbSchema): @staticmethod def from_json(json): parser = ovs.db.parser.Parser(json, "IDL schema") - idlPrefix = parser.get("idlPrefix", [unicode]) - idlHeader = parser.get("idlHeader", [unicode]) + idlPrefix = parser.get("idlPrefix", [str, unicode]) + idlHeader = parser.get("idlHeader", [str, unicode]) subjson = dict(json) del subjson["idlPrefix"] @@ -136,6 +141,7 @@ class IdlSchema(DbSchema): return IdlSchema(schema.name, schema.version, schema.tables, idlPrefix, idlHeader) + def column_set_from_json(json, columns): if json is None: return tuple(columns) @@ -154,6 +160,7 @@ def column_set_from_json(json, columns): raise error.Error("array of distinct column names expected", json) return tuple([columns[column_name] for column_name in json]) + class TableSchema(object): def __init__(self, name, columns, mutable=True, max_rows=sys.maxint, is_root=True, indexes=[]): @@ -210,7 +217,7 @@ class TableSchema(object): differ from 'default_is_root'. Ordinarily 'default_is_root' should be false, because ordinarily a table would be not be part of the root set if its "isRoot" member is omitted. However, garbage collection was not - orginally included in OVSDB, so in older schemas that do not include + originally included in OVSDB, so in older schemas that do not include any "isRoot" members, every table is implicitly part of the root set. To serialize such a schema in a way that can be read by older OVSDB tools, specify 'default_is_root' as True. @@ -236,6 +243,7 @@ class TableSchema(object): return json + class ColumnSchema(object): def __init__(self, name, mutable, persistent, type_): self.name = name @@ -249,10 +257,10 @@ class ColumnSchema(object): parser = ovs.db.parser.Parser(json, "schema for column %s" % name) mutable = parser.get_optional("mutable", [bool], True) ephemeral = parser.get_optional("ephemeral", [bool], False) - type = types.Type.from_json(parser.get("type", [dict, unicode])) + type_ = types.Type.from_json(parser.get("type", [dict, str, unicode])) parser.finish() - return ColumnSchema(name, mutable, not ephemeral, type) + return ColumnSchema(name, mutable, not ephemeral, type_) def to_json(self): json = {"type": self.type.to_json()} @@ -261,4 +269,3 @@ class ColumnSchema(object): if not self.persistent: json["ephemeral"] = True return json -