-# 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.
import re
import sys
+import six
+
from ovs.db import error
import ovs.db.parser
-from ovs.db import types
+import ovs.db.types
+
def _check_id(name, json):
if name.startswith('_'):
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."""
# backward compatibility, if the root set is empty then assume that
# every table is in the root set.
if self.__root_set_size() == 0:
- for table in self.tables.itervalues():
+ for table in six.itervalues(self.tables):
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")
+ for table in six.itervalues(self.tables):
+ for column in six.itervalues(table.columns):
+ 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."""
n_root = 0
- for table in self.tables.itervalues():
+ for table in six.itervalues(self.tables):
if table.is_root:
n_root += 1
return n_root
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()
% version)
tables = {}
- for tableName, tableJson in tablesJson.iteritems():
+ for tableName, tableJson in six.iteritems(tablesJson):
_check_id(tableName, json)
tables[tableName] = TableSchema.from_json(tableJson, tableName)
default_is_root = self.__root_set_size() == len(self.tables)
tables = {}
- for table in self.tables.itervalues():
+ for table in six.itervalues(self.tables):
tables[table.name] = table.to_json(default_is_root)
json = {"name": self.name, "tables": tables}
if self.version:
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 != ovs.db.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
# error.
column.persistent = True
+
class IdlSchema(DbSchema):
def __init__(self, name, version, tables, idlPrefix, idlHeader):
DbSchema.__init__(self, name, version, tables)
@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"]
return IdlSchema(schema.name, schema.version, schema.tables,
idlPrefix, idlHeader)
+
def column_set_from_json(json, columns):
if json is None:
return tuple(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=[]):
indexes_json = parser.get_optional("indexes", [list], [])
parser.finish()
- if max_rows == None:
+ if max_rows is None:
max_rows = sys.maxint
elif max_rows <= 0:
raise error.Error("maxRows must be at least 1", json)
raise error.Error("table must have at least one column", json)
columns = {}
- for column_name, column_json in columns_json.iteritems():
+ for column_name, column_json in six.iteritems(columns_json):
_check_id(column_name, json)
columns[column_name] = ColumnSchema.from_json(column_json,
column_name)
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.
json["isRoot"] = self.is_root
json["columns"] = columns = {}
- for column in self.columns.itervalues():
+ for column in six.itervalues(self.columns):
if not column.name.startswith("_"):
columns[column.name] = column.to_json()
return json
+
class ColumnSchema(object):
def __init__(self, name, mutable, persistent, type_):
self.name = name
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_ = ovs.db.types.Type.from_json(parser.get("type",
+ [dict, str, unicode]))
parser.finish()
return ColumnSchema(name, mutable, not ephemeral, type_)
if not self.persistent:
json["ephemeral"] = True
return json
-
projects / cascardo / ovs.git / blobdiff