]>
git.proxmox.com Git - mirror_ovs.git/blob - ovsdb/table.c
1 /* Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
24 #include "ovsdb-error.h"
25 #include "ovsdb-parser.h"
26 #include "ovsdb-types.h"
30 add_column(struct ovsdb_table_schema
*ts
, struct ovsdb_column
*column
)
32 ovs_assert(!shash_find(&ts
->columns
, column
->name
));
33 column
->index
= shash_count(&ts
->columns
);
34 shash_add(&ts
->columns
, column
->name
, column
);
37 struct ovsdb_table_schema
*
38 ovsdb_table_schema_create(const char *name
, bool mutable,
39 unsigned int max_rows
, bool is_root
)
41 struct ovsdb_column
*uuid
, *version
;
42 struct ovsdb_table_schema
*ts
;
44 ts
= xzalloc(sizeof *ts
);
45 ts
->name
= xstrdup(name
);
46 ts
->mutable = mutable;
47 shash_init(&ts
->columns
);
48 ts
->max_rows
= max_rows
;
49 ts
->is_root
= is_root
;
51 uuid
= ovsdb_column_create("_uuid", false, true, &ovsdb_type_uuid
);
53 ovs_assert(uuid
->index
== OVSDB_COL_UUID
);
55 version
= ovsdb_column_create("_version", false, false, &ovsdb_type_uuid
);
56 add_column(ts
, version
);
57 ovs_assert(version
->index
== OVSDB_COL_VERSION
);
65 struct ovsdb_table_schema
*
66 ovsdb_table_schema_clone(const struct ovsdb_table_schema
*old
)
68 struct ovsdb_table_schema
*new;
69 struct shash_node
*node
;
72 new = ovsdb_table_schema_create(old
->name
, old
->mutable,
73 old
->max_rows
, old
->is_root
);
74 SHASH_FOR_EACH (node
, &old
->columns
) {
75 const struct ovsdb_column
*column
= node
->data
;
77 if (column
->name
[0] == '_') {
78 /* Added automatically by ovsdb_table_schema_create(). */
82 add_column(new, ovsdb_column_clone(column
));
85 new->n_indexes
= old
->n_indexes
;
86 new->indexes
= xmalloc(new->n_indexes
* sizeof *new->indexes
);
87 for (i
= 0; i
< new->n_indexes
; i
++) {
88 const struct ovsdb_column_set
*old_index
= &old
->indexes
[i
];
89 struct ovsdb_column_set
*new_index
= &new->indexes
[i
];
92 ovsdb_column_set_init(new_index
);
93 for (j
= 0; j
< old_index
->n_columns
; j
++) {
94 const struct ovsdb_column
*old_column
= old_index
->columns
[j
];
95 const struct ovsdb_column
*new_column
;
97 new_column
= ovsdb_table_schema_get_column(new, old_column
->name
);
98 ovsdb_column_set_add(new_index
, new_column
);
106 ovsdb_table_schema_destroy(struct ovsdb_table_schema
*ts
)
108 struct shash_node
*node
;
111 for (i
= 0; i
< ts
->n_indexes
; i
++) {
112 ovsdb_column_set_destroy(&ts
->indexes
[i
]);
116 SHASH_FOR_EACH (node
, &ts
->columns
) {
117 ovsdb_column_destroy(node
->data
);
119 shash_destroy(&ts
->columns
);
125 ovsdb_table_schema_from_json(const struct json
*json
, const char *name
,
126 struct ovsdb_table_schema
**tsp
)
128 struct ovsdb_table_schema
*ts
;
129 const struct json
*columns
, *mutable, *max_rows
, *is_root
, *indexes
;
130 struct shash_node
*node
;
131 struct ovsdb_parser parser
;
132 struct ovsdb_error
*error
;
133 long long int n_max_rows
;
137 ovsdb_parser_init(&parser
, json
, "table schema for table %s", name
);
138 columns
= ovsdb_parser_member(&parser
, "columns", OP_OBJECT
);
139 mutable = ovsdb_parser_member(&parser
, "mutable",
140 OP_TRUE
| OP_FALSE
| OP_OPTIONAL
);
141 max_rows
= ovsdb_parser_member(&parser
, "maxRows",
142 OP_INTEGER
| OP_OPTIONAL
);
143 is_root
= ovsdb_parser_member(&parser
, "isRoot", OP_BOOLEAN
| OP_OPTIONAL
);
144 indexes
= ovsdb_parser_member(&parser
, "indexes", OP_ARRAY
| OP_OPTIONAL
);
145 error
= ovsdb_parser_finish(&parser
);
151 if (json_integer(max_rows
) <= 0) {
152 return ovsdb_syntax_error(json
, NULL
,
153 "maxRows must be at least 1");
155 n_max_rows
= max_rows
->u
.integer
;
157 n_max_rows
= UINT_MAX
;
160 if (shash_is_empty(json_object(columns
))) {
161 return ovsdb_syntax_error(json
, NULL
,
162 "table must have at least one column");
165 ts
= ovsdb_table_schema_create(name
,
166 mutable ? json_boolean(mutable) : true,
167 MIN(n_max_rows
, UINT_MAX
),
168 is_root
? json_boolean(is_root
) : false);
169 SHASH_FOR_EACH (node
, json_object(columns
)) {
170 struct ovsdb_column
*column
;
172 if (node
->name
[0] == '_') {
173 error
= ovsdb_syntax_error(json
, NULL
, "names beginning with "
174 "\"_\" are reserved");
175 } else if (!ovsdb_parser_is_id(node
->name
)) {
176 error
= ovsdb_syntax_error(json
, NULL
, "name must be a valid id");
178 error
= ovsdb_column_from_json(node
->data
, node
->name
, &column
);
184 add_column(ts
, column
);
190 ts
->indexes
= xmalloc(indexes
->u
.array
.n
* sizeof *ts
->indexes
);
191 for (i
= 0; i
< indexes
->u
.array
.n
; i
++) {
192 struct ovsdb_column_set
*index
= &ts
->indexes
[i
];
195 error
= ovsdb_column_set_from_json(indexes
->u
.array
.elems
[i
],
200 if (index
->n_columns
== 0) {
201 error
= ovsdb_syntax_error(json
, NULL
, "index must have "
202 "at least one column");
207 for (j
= 0; j
< index
->n_columns
; j
++) {
208 const struct ovsdb_column
*column
= index
->columns
[j
];
210 if (!column
->persistent
) {
211 error
= ovsdb_syntax_error(json
, NULL
, "ephemeral columns "
212 "(such as %s) may not be "
213 "indexed", column
->name
);
224 ovsdb_table_schema_destroy(ts
);
228 /* Returns table schema 'ts' serialized into JSON.
230 * The "isRoot" member is included in the JSON only if its value would differ
231 * from 'default_is_root'. Ordinarily 'default_is_root' should be false,
232 * because ordinarily a table would be not be part of the root set if its
233 * "isRoot" member is omitted. However, garbage collection was not originally
234 * included in OVSDB, so in older schemas that do not include any "isRoot"
235 * members, every table is implicitly part of the root set. To serialize such
236 * a schema in a way that can be read by older OVSDB tools, specify
237 * 'default_is_root' as true. */
239 ovsdb_table_schema_to_json(const struct ovsdb_table_schema
*ts
,
240 bool default_is_root
)
242 struct json
*json
, *columns
;
243 struct shash_node
*node
;
245 json
= json_object_create();
247 json_object_put(json
, "mutable", json_boolean_create(false));
249 if (default_is_root
!= ts
->is_root
) {
250 json_object_put(json
, "isRoot", json_boolean_create(ts
->is_root
));
253 columns
= json_object_create();
255 SHASH_FOR_EACH (node
, &ts
->columns
) {
256 const struct ovsdb_column
*column
= node
->data
;
257 if (node
->name
[0] != '_') {
258 json_object_put(columns
, column
->name
,
259 ovsdb_column_to_json(column
));
262 json_object_put(json
, "columns", columns
);
263 if (ts
->max_rows
!= UINT_MAX
) {
264 json_object_put(json
, "maxRows", json_integer_create(ts
->max_rows
));
268 struct json
**indexes
;
271 indexes
= xmalloc(ts
->n_indexes
* sizeof *indexes
);
272 for (i
= 0; i
< ts
->n_indexes
; i
++) {
273 indexes
[i
] = ovsdb_column_set_to_json(&ts
->indexes
[i
]);
275 json_object_put(json
, "indexes",
276 json_array_create(indexes
, ts
->n_indexes
));
282 const struct ovsdb_column
*
283 ovsdb_table_schema_get_column(const struct ovsdb_table_schema
*ts
,
286 return shash_find_data(&ts
->columns
, name
);
290 ovsdb_table_create(struct ovsdb_table_schema
*ts
)
292 struct ovsdb_table
*table
;
295 table
= xmalloc(sizeof *table
);
297 table
->txn_table
= NULL
;
298 table
->indexes
= xmalloc(ts
->n_indexes
* sizeof *table
->indexes
);
299 for (i
= 0; i
< ts
->n_indexes
; i
++) {
300 hmap_init(&table
->indexes
[i
]);
302 hmap_init(&table
->rows
);
308 ovsdb_table_destroy(struct ovsdb_table
*table
)
311 struct ovsdb_row
*row
, *next
;
314 HMAP_FOR_EACH_SAFE (row
, next
, hmap_node
, &table
->rows
) {
315 ovsdb_row_destroy(row
);
317 hmap_destroy(&table
->rows
);
319 for (i
= 0; i
< table
->schema
->n_indexes
; i
++) {
320 hmap_destroy(&table
->indexes
[i
]);
322 free(table
->indexes
);
324 ovsdb_table_schema_destroy(table
->schema
);
329 const struct ovsdb_row
*
330 ovsdb_table_get_row(const struct ovsdb_table
*table
, const struct uuid
*uuid
)
332 struct ovsdb_row
*row
;
334 HMAP_FOR_EACH_WITH_HASH (row
, hmap_node
, uuid_hash(uuid
), &table
->rows
) {
335 if (uuid_equals(ovsdb_row_get_uuid(row
), uuid
)) {