ofp-util: Work on decoding OF1.1 flow_mods.
[openvswitch] / ovsdb / table.c
1 /* Copyright (c) 2009, 2010, 2011 Nicira, Inc.
2  *
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:
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
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.
14  */
15
16 #include <config.h>
17
18 #include "table.h"
19
20 #include <assert.h>
21 #include <limits.h>
22
23 #include "json.h"
24 #include "column.h"
25 #include "ovsdb-error.h"
26 #include "ovsdb-parser.h"
27 #include "ovsdb-types.h"
28 #include "row.h"
29
30 static void
31 add_column(struct ovsdb_table_schema *ts, struct ovsdb_column *column)
32 {
33     assert(!shash_find(&ts->columns, column->name));
34     column->index = shash_count(&ts->columns);
35     shash_add(&ts->columns, column->name, column);
36 }
37
38 struct ovsdb_table_schema *
39 ovsdb_table_schema_create(const char *name, bool mutable,
40                           unsigned int max_rows, bool is_root)
41 {
42     struct ovsdb_column *uuid, *version;
43     struct ovsdb_table_schema *ts;
44
45     ts = xzalloc(sizeof *ts);
46     ts->name = xstrdup(name);
47     ts->mutable = mutable;
48     shash_init(&ts->columns);
49     ts->max_rows = max_rows;
50     ts->is_root = is_root;
51
52     uuid = ovsdb_column_create("_uuid", false, true, &ovsdb_type_uuid);
53     add_column(ts, uuid);
54     assert(uuid->index == OVSDB_COL_UUID);
55
56     version = ovsdb_column_create("_version", false, false, &ovsdb_type_uuid);
57     add_column(ts, version);
58     assert(version->index == OVSDB_COL_VERSION);
59
60     ts->n_indexes = 0;
61     ts->indexes = NULL;
62
63     return ts;
64 }
65
66 struct ovsdb_table_schema *
67 ovsdb_table_schema_clone(const struct ovsdb_table_schema *old)
68 {
69     struct ovsdb_table_schema *new;
70     struct shash_node *node;
71     size_t i;
72
73     new = ovsdb_table_schema_create(old->name, old->mutable,
74                                     old->max_rows, old->is_root);
75     SHASH_FOR_EACH (node, &old->columns) {
76         const struct ovsdb_column *column = node->data;
77
78         if (column->name[0] == '_') {
79             /* Added automatically by ovsdb_table_schema_create(). */
80             continue;
81         }
82
83         add_column(new, ovsdb_column_clone(column));
84     }
85
86     new->n_indexes = old->n_indexes;
87     new->indexes = xmalloc(new->n_indexes * sizeof *new->indexes);
88     for (i = 0; i < new->n_indexes; i++) {
89         const struct ovsdb_column_set *old_index = &old->indexes[i];
90         struct ovsdb_column_set *new_index = &new->indexes[i];
91         size_t j;
92
93         ovsdb_column_set_init(new_index);
94         for (j = 0; j < old_index->n_columns; j++) {
95             const struct ovsdb_column *old_column = old_index->columns[j];
96             const struct ovsdb_column *new_column;
97
98             new_column = ovsdb_table_schema_get_column(new, old_column->name);
99             ovsdb_column_set_add(new_index, new_column);
100         }
101     }
102
103     return new;
104 }
105
106 void
107 ovsdb_table_schema_destroy(struct ovsdb_table_schema *ts)
108 {
109     struct shash_node *node;
110     size_t i;
111
112     for (i = 0; i < ts->n_indexes; i++) {
113         ovsdb_column_set_destroy(&ts->indexes[i]);
114     }
115     free(ts->indexes);
116
117     SHASH_FOR_EACH (node, &ts->columns) {
118         ovsdb_column_destroy(node->data);
119     }
120     shash_destroy(&ts->columns);
121     free(ts->name);
122     free(ts);
123 }
124
125 struct ovsdb_error *
126 ovsdb_table_schema_from_json(const struct json *json, const char *name,
127                              struct ovsdb_table_schema **tsp)
128 {
129     struct ovsdb_table_schema *ts;
130     const struct json *columns, *mutable, *max_rows, *is_root, *indexes;
131     struct shash_node *node;
132     struct ovsdb_parser parser;
133     struct ovsdb_error *error;
134     long long int n_max_rows;
135
136     *tsp = NULL;
137
138     ovsdb_parser_init(&parser, json, "table schema for table %s", name);
139     columns = ovsdb_parser_member(&parser, "columns", OP_OBJECT);
140     mutable = ovsdb_parser_member(&parser, "mutable",
141                                   OP_TRUE | OP_FALSE | OP_OPTIONAL);
142     max_rows = ovsdb_parser_member(&parser, "maxRows",
143                                    OP_INTEGER | OP_OPTIONAL);
144     is_root = ovsdb_parser_member(&parser, "isRoot", OP_BOOLEAN | OP_OPTIONAL);
145     indexes = ovsdb_parser_member(&parser, "indexes", OP_ARRAY | OP_OPTIONAL);
146     error = ovsdb_parser_finish(&parser);
147     if (error) {
148         return error;
149     }
150
151     if (max_rows) {
152         if (json_integer(max_rows) <= 0) {
153             return ovsdb_syntax_error(json, NULL,
154                                       "maxRows must be at least 1");
155         }
156         n_max_rows = max_rows->u.integer;
157     } else {
158         n_max_rows = UINT_MAX;
159     }
160
161     if (shash_is_empty(json_object(columns))) {
162         return ovsdb_syntax_error(json, NULL,
163                                   "table must have at least one column");
164     }
165
166     ts = ovsdb_table_schema_create(name,
167                                    mutable ? json_boolean(mutable) : true,
168                                    MIN(n_max_rows, UINT_MAX),
169                                    is_root ? json_boolean(is_root) : false);
170     SHASH_FOR_EACH (node, json_object(columns)) {
171         struct ovsdb_column *column;
172
173         if (node->name[0] == '_') {
174             error = ovsdb_syntax_error(json, NULL, "names beginning with "
175                                        "\"_\" are reserved");
176         } else if (!ovsdb_parser_is_id(node->name)) {
177             error = ovsdb_syntax_error(json, NULL, "name must be a valid id");
178         } else {
179             error = ovsdb_column_from_json(node->data, node->name, &column);
180         }
181         if (error) {
182             goto error;
183         }
184
185         add_column(ts, column);
186     }
187
188     if (indexes) {
189         size_t i;
190
191         ts->indexes = xmalloc(indexes->u.array.n * sizeof *ts->indexes);
192         for (i = 0; i < indexes->u.array.n; i++) {
193             struct ovsdb_column_set *index = &ts->indexes[i];
194             size_t j;
195
196             error = ovsdb_column_set_from_json(indexes->u.array.elems[i],
197                                                ts, index);
198             if (error) {
199                 goto error;
200             }
201             if (index->n_columns == 0) {
202                 error = ovsdb_syntax_error(json, NULL, "index must have "
203                                            "at least one column");
204                 goto error;
205             }
206             ts->n_indexes++;
207
208             for (j = 0; j < index->n_columns; j++) {
209                 const struct ovsdb_column *column = index->columns[j];
210
211                 if (!column->persistent) {
212                     error = ovsdb_syntax_error(json, NULL, "ephemeral columns "
213                                                "(such as %s) may not be "
214                                                "indexed", column->name);
215                     goto error;
216                 }
217             }
218         }
219     }
220
221     *tsp = ts;
222     return NULL;
223
224 error:
225     ovsdb_table_schema_destroy(ts);
226     return error;
227 }
228
229 /* Returns table schema 'ts' serialized into JSON.
230  *
231  * The "isRoot" member is included in the JSON only if its value would differ
232  * from 'default_is_root'.  Ordinarily 'default_is_root' should be false,
233  * because ordinarily a table would be not be part of the root set if its
234  * "isRoot" member is omitted.  However, garbage collection was not orginally
235  * included in OVSDB, so in older schemas that do not include any "isRoot"
236  * members, every table is implicitly part of the root set.  To serialize such
237  * a schema in a way that can be read by older OVSDB tools, specify
238  * 'default_is_root' as true. */
239 struct json *
240 ovsdb_table_schema_to_json(const struct ovsdb_table_schema *ts,
241                            bool default_is_root)
242 {
243     struct json *json, *columns;
244     struct shash_node *node;
245
246     json = json_object_create();
247     if (!ts->mutable) {
248         json_object_put(json, "mutable", json_boolean_create(false));
249     }
250     if (default_is_root != ts->is_root) {
251         json_object_put(json, "isRoot", json_boolean_create(ts->is_root));
252     }
253
254     columns = json_object_create();
255
256     SHASH_FOR_EACH (node, &ts->columns) {
257         const struct ovsdb_column *column = node->data;
258         if (node->name[0] != '_') {
259             json_object_put(columns, column->name,
260                             ovsdb_column_to_json(column));
261         }
262     }
263     json_object_put(json, "columns", columns);
264     if (ts->max_rows != UINT_MAX) {
265         json_object_put(json, "maxRows", json_integer_create(ts->max_rows));
266     }
267
268     if (ts->n_indexes) {
269         struct json **indexes;
270         size_t i;
271
272         indexes = xmalloc(ts->n_indexes * sizeof *indexes);
273         for (i = 0; i < ts->n_indexes; i++) {
274             indexes[i] = ovsdb_column_set_to_json(&ts->indexes[i]);
275         }
276         json_object_put(json, "indexes",
277                         json_array_create(indexes, ts->n_indexes));
278     }
279
280     return json;
281 }
282
283 const struct ovsdb_column *
284 ovsdb_table_schema_get_column(const struct ovsdb_table_schema *ts,
285                               const char *name)
286 {
287     return shash_find_data(&ts->columns, name);
288 }
289 \f
290 struct ovsdb_table *
291 ovsdb_table_create(struct ovsdb_table_schema *ts)
292 {
293     struct ovsdb_table *table;
294     size_t i;
295
296     table = xmalloc(sizeof *table);
297     table->schema = ts;
298     table->txn_table = NULL;
299     table->indexes = xmalloc(ts->n_indexes * sizeof *table->indexes);
300     for (i = 0; i < ts->n_indexes; i++) {
301         hmap_init(&table->indexes[i]);
302     }
303     hmap_init(&table->rows);
304
305     return table;
306 }
307
308 void
309 ovsdb_table_destroy(struct ovsdb_table *table)
310 {
311     if (table) {
312         struct ovsdb_row *row, *next;
313         size_t i;
314
315         HMAP_FOR_EACH_SAFE (row, next, hmap_node, &table->rows) {
316             ovsdb_row_destroy(row);
317         }
318         hmap_destroy(&table->rows);
319
320         for (i = 0; i < table->schema->n_indexes; i++) {
321             hmap_destroy(&table->indexes[i]);
322         }
323         free(table->indexes);
324
325         ovsdb_table_schema_destroy(table->schema);
326         free(table);
327     }
328 }
329
330 const struct ovsdb_row *
331 ovsdb_table_get_row(const struct ovsdb_table *table, const struct uuid *uuid)
332 {
333     struct ovsdb_row *row;
334
335     HMAP_FOR_EACH_WITH_HASH (row, hmap_node, uuid_hash(uuid), &table->rows) {
336         if (uuid_equals(ovsdb_row_get_uuid(row), uuid)) {
337             return row;
338         }
339     }
340
341     return NULL;
342 }