X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=python%2Fovs%2Fdb%2Fschema.py;h=bc86232f9c99ad0433a777c3d3015cfac3290d50;hb=ec9f40dce11c7e81bc41d42e3bbfaaf8287165ce;hp=e76d6f6737adbd5065cf468bfaef24245abbce54;hpb=f2d8ad13e1819a6553b30ba33a28abf7603f5b9b;p=sliver-openvswitch.git diff --git a/python/ovs/db/schema.py b/python/ovs/db/schema.py index e76d6f673..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,6 +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.""" @@ -35,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.""" @@ -58,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() @@ -70,11 +77,7 @@ class DbSchema(object): tables = {} for tableName, tableJson in tablesJson.iteritems(): - if tableName.startswith('_'): - raise error.Error('names beginning with "_" are reserved', - json) - elif not ovs.db.parser.is_identifier(tableName): - raise error.Error("name must be a valid id", json) + _check_id(tableName, json) tables[tableName] = TableSchema.from_json(tableJson, tableName) return DbSchema(name, version, tables) @@ -94,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 @@ -114,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) @@ -123,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"] @@ -134,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) @@ -152,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=[]): @@ -182,11 +191,7 @@ class TableSchema(object): columns = {} for column_name, column_json in columns_json.iteritems(): - if column_name.startswith('_'): - raise error.Error('names beginning with "_" are reserved', - json) - elif not ovs.db.parser.is_identifier(column_name): - raise error.Error("name must be a valid id", json) + _check_id(column_name, json) columns[column_name] = ColumnSchema.from_json(column_json, column_name) @@ -212,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. @@ -238,12 +243,13 @@ class TableSchema(object): return json + class ColumnSchema(object): - def __init__(self, name, mutable, persistent, type): + def __init__(self, name, mutable, persistent, type_): self.name = name self.mutable = mutable self.persistent = persistent - self.type = type + self.type = type_ self.unique = False @staticmethod @@ -251,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()} @@ -263,4 +269,3 @@ class ColumnSchema(object): if not self.persistent: json["ephemeral"] = True return json -