netdev-vport: Don't create port when ovs-monitor-ipsec not running.
[openvswitch] / ovsdb / table.c
1 /* Copyright (c) 2009, 2010, 2011 Nicira Networks
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     return ts;
61 }
62
63 struct ovsdb_table_schema *
64 ovsdb_table_schema_clone(const struct ovsdb_table_schema *old)
65 {
66     struct ovsdb_table_schema *new;
67     struct shash_node *node;
68
69     new = ovsdb_table_schema_create(old->name, old->mutable,
70                                     old->max_rows, old->is_root);
71     SHASH_FOR_EACH (node, &old->columns) {
72         const struct ovsdb_column *column = node->data;
73
74         if (column->name[0] == '_') {
75             /* Added automatically by ovsdb_table_schema_create(). */
76             continue;
77         }
78
79         add_column(new, ovsdb_column_clone(column));
80     }
81     return new;
82 }
83
84 void
85 ovsdb_table_schema_destroy(struct ovsdb_table_schema *ts)
86 {
87     struct shash_node *node;
88
89     SHASH_FOR_EACH (node, &ts->columns) {
90         ovsdb_column_destroy(node->data);
91     }
92     shash_destroy(&ts->columns);
93     free(ts->name);
94     free(ts);
95 }
96
97 struct ovsdb_error *
98 ovsdb_table_schema_from_json(const struct json *json, const char *name,
99                              struct ovsdb_table_schema **tsp)
100 {
101     struct ovsdb_table_schema *ts;
102     const struct json *columns, *mutable, *max_rows, *is_root;
103     struct shash_node *node;
104     struct ovsdb_parser parser;
105     struct ovsdb_error *error;
106     long long int n_max_rows;
107
108     *tsp = NULL;
109
110     ovsdb_parser_init(&parser, json, "table schema for table %s", name);
111     columns = ovsdb_parser_member(&parser, "columns", OP_OBJECT);
112     mutable = ovsdb_parser_member(&parser, "mutable",
113                                   OP_TRUE | OP_FALSE | OP_OPTIONAL);
114     max_rows = ovsdb_parser_member(&parser, "maxRows",
115                                    OP_INTEGER | OP_OPTIONAL);
116     is_root = ovsdb_parser_member(&parser, "isRoot", OP_BOOLEAN | OP_OPTIONAL);
117     error = ovsdb_parser_finish(&parser);
118     if (error) {
119         return error;
120     }
121
122     if (max_rows) {
123         if (json_integer(max_rows) <= 0) {
124             return ovsdb_syntax_error(json, NULL,
125                                       "maxRows must be at least 1");
126         }
127         n_max_rows = max_rows->u.integer;
128     } else {
129         n_max_rows = UINT_MAX;
130     }
131
132     if (shash_is_empty(json_object(columns))) {
133         return ovsdb_syntax_error(json, NULL,
134                                   "table must have at least one column");
135     }
136
137     ts = ovsdb_table_schema_create(name,
138                                    mutable ? json_boolean(mutable) : true,
139                                    MIN(n_max_rows, UINT_MAX),
140                                    is_root ? json_boolean(is_root) : false);
141     SHASH_FOR_EACH (node, json_object(columns)) {
142         struct ovsdb_column *column;
143
144         if (node->name[0] == '_') {
145             error = ovsdb_syntax_error(json, NULL, "names beginning with "
146                                        "\"_\" are reserved");
147         } else if (!ovsdb_parser_is_id(node->name)) {
148             error = ovsdb_syntax_error(json, NULL, "name must be a valid id");
149         } else {
150             error = ovsdb_column_from_json(node->data, node->name, &column);
151         }
152         if (error) {
153             ovsdb_table_schema_destroy(ts);
154             return error;
155         }
156
157         add_column(ts, column);
158     }
159     *tsp = ts;
160     return 0;
161 }
162
163 /* Returns table schema 'ts' serialized into JSON.
164  *
165  * The "isRoot" member is included in the JSON only if its value would differ
166  * from 'default_is_root'.  Ordinarily 'default_is_root' should be false,
167  * because ordinarily a table would be not be part of the root set if its
168  * "isRoot" member is omitted.  However, garbage collection was not orginally
169  * included in OVSDB, so in older schemas that do not include any "isRoot"
170  * members, every table is implicitly part of the root set.  To serialize such
171  * a schema in a way that can be read by older OVSDB tools, specify
172  * 'default_is_root' as true. */
173 struct json *
174 ovsdb_table_schema_to_json(const struct ovsdb_table_schema *ts,
175                            bool default_is_root)
176 {
177     struct json *json, *columns;
178     struct shash_node *node;
179
180     json = json_object_create();
181     if (!ts->mutable) {
182         json_object_put(json, "mutable", json_boolean_create(false));
183     }
184     if (default_is_root != ts->is_root) {
185         json_object_put(json, "isRoot", json_boolean_create(ts->is_root));
186     }
187
188     columns = json_object_create();
189
190     SHASH_FOR_EACH (node, &ts->columns) {
191         const struct ovsdb_column *column = node->data;
192         if (node->name[0] != '_') {
193             json_object_put(columns, column->name,
194                             ovsdb_column_to_json(column));
195         }
196     }
197     json_object_put(json, "columns", columns);
198     if (ts->max_rows != UINT_MAX) {
199         json_object_put(json, "maxRows", json_integer_create(ts->max_rows));
200     }
201
202     return json;
203 }
204
205 const struct ovsdb_column *
206 ovsdb_table_schema_get_column(const struct ovsdb_table_schema *ts,
207                               const char *name)
208 {
209     return shash_find_data(&ts->columns, name);
210 }
211 \f
212 struct ovsdb_table *
213 ovsdb_table_create(struct ovsdb_table_schema *ts)
214 {
215     struct ovsdb_table *table;
216
217     table = xmalloc(sizeof *table);
218     table->schema = ts;
219     table->txn_table = NULL;
220     hmap_init(&table->rows);
221
222     return table;
223 }
224
225 void
226 ovsdb_table_destroy(struct ovsdb_table *table)
227 {
228     if (table) {
229         struct ovsdb_row *row, *next;
230
231         HMAP_FOR_EACH_SAFE (row, next, hmap_node, &table->rows) {
232             ovsdb_row_destroy(row);
233         }
234         hmap_destroy(&table->rows);
235
236         ovsdb_table_schema_destroy(table->schema);
237         free(table);
238     }
239 }
240
241 const struct ovsdb_row *
242 ovsdb_table_get_row(const struct ovsdb_table *table, const struct uuid *uuid)
243 {
244     struct ovsdb_row *row;
245
246     HMAP_FOR_EACH_WITH_HASH (row, hmap_node, uuid_hash(uuid), &table->rows) {
247         if (uuid_equals(ovsdb_row_get_uuid(row), uuid)) {
248             return row;
249         }
250     }
251
252     return NULL;
253 }
254
255 /* This is probably not the function you want.  Use ovsdb_txn_row_modify()
256  * instead. */
257 bool
258 ovsdb_table_put_row(struct ovsdb_table *table, struct ovsdb_row *row)
259 {
260     const struct uuid *uuid = ovsdb_row_get_uuid(row);
261     if (!ovsdb_table_get_row(table, uuid)) {
262         hmap_insert(&table->rows, &row->hmap_node, uuid_hash(uuid));
263         return true;
264     } else {
265         return false;
266     }
267 }