1 /* Copyright (c) 2009, 2010, 2011 Nicira Networks
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.
22 #include "condition.h"
26 #include "ovsdb-data.h"
27 #include "ovsdb-error.h"
28 #include "ovsdb-parser.h"
34 #include "transaction.h"
36 struct ovsdb_execution {
38 struct ovsdb_txn *txn;
39 struct ovsdb_symbol_table *symtab;
43 long long int elapsed_msec;
44 long long int timeout_msec;
47 typedef struct ovsdb_error *ovsdb_operation_executor(struct ovsdb_execution *,
48 struct ovsdb_parser *,
51 static ovsdb_operation_executor ovsdb_execute_insert;
52 static ovsdb_operation_executor ovsdb_execute_select;
53 static ovsdb_operation_executor ovsdb_execute_update;
54 static ovsdb_operation_executor ovsdb_execute_mutate;
55 static ovsdb_operation_executor ovsdb_execute_delete;
56 static ovsdb_operation_executor ovsdb_execute_wait;
57 static ovsdb_operation_executor ovsdb_execute_commit;
58 static ovsdb_operation_executor ovsdb_execute_abort;
59 static ovsdb_operation_executor ovsdb_execute_comment;
61 static ovsdb_operation_executor *
62 lookup_executor(const char *name)
64 struct ovsdb_operation {
66 ovsdb_operation_executor *executor;
69 static const struct ovsdb_operation operations[] = {
70 { "insert", ovsdb_execute_insert },
71 { "select", ovsdb_execute_select },
72 { "update", ovsdb_execute_update },
73 { "mutate", ovsdb_execute_mutate },
74 { "delete", ovsdb_execute_delete },
75 { "wait", ovsdb_execute_wait },
76 { "commit", ovsdb_execute_commit },
77 { "abort", ovsdb_execute_abort },
78 { "comment", ovsdb_execute_comment },
83 for (i = 0; i < ARRAY_SIZE(operations); i++) {
84 const struct ovsdb_operation *c = &operations[i];
85 if (!strcmp(c->name, name)) {
93 ovsdb_execute(struct ovsdb *db, const struct json *params,
94 long long int elapsed_msec, long long int *timeout_msec)
96 struct ovsdb_execution x;
97 struct ovsdb_error *error;
102 if (params->type != JSON_ARRAY
103 || !params->u.array.n
104 || params->u.array.elems[0]->type != JSON_STRING
105 || strcmp(params->u.array.elems[0]->u.string, db->schema->name)) {
106 if (params->type != JSON_ARRAY) {
107 error = ovsdb_syntax_error(params, NULL, "array expected");
109 error = ovsdb_syntax_error(params, NULL, "database name expected "
110 "as first parameter");
113 results = ovsdb_error_to_json(error);
114 ovsdb_error_destroy(error);
119 x.txn = ovsdb_txn_create(db);
120 x.symtab = ovsdb_symbol_table_create();
122 x.elapsed_msec = elapsed_msec;
123 x.timeout_msec = LLONG_MAX;
126 results = json_array_create_empty();
127 n_operations = params->u.array.n - 1;
129 for (i = 1; i <= n_operations; i++) {
130 struct json *operation = params->u.array.elems[i];
131 struct ovsdb_error *parse_error;
132 struct ovsdb_parser parser;
134 const struct json *op;
136 /* Parse and execute operation. */
137 ovsdb_parser_init(&parser, operation,
138 "ovsdb operation %zu of %zu", i, n_operations);
139 op = ovsdb_parser_member(&parser, "op", OP_ID);
140 result = json_object_create();
142 const char *op_name = json_string(op);
143 ovsdb_operation_executor *executor = lookup_executor(op_name);
145 error = executor(&x, &parser, result);
147 ovsdb_parser_raise_error(&parser, "No operation \"%s\"",
151 assert(ovsdb_parser_has_error(&parser));
154 /* A parse error overrides any other error.
155 * An error overrides any other result. */
156 parse_error = ovsdb_parser_finish(&parser);
158 ovsdb_error_destroy(error);
162 json_destroy(result);
163 result = ovsdb_error_to_json(error);
165 if (error && !strcmp(ovsdb_error_get_tag(error), "not supported")
167 ovsdb_txn_abort(x.txn);
168 *timeout_msec = x.timeout_msec;
170 json_destroy(result);
171 json_destroy(results);
176 /* Add result to array. */
177 json_array_add(results, result);
184 error = ovsdb_txn_commit(x.txn, x.durable);
186 json_array_add(results, ovsdb_error_to_json(error));
189 ovsdb_txn_abort(x.txn);
192 while (json_array(results)->n < n_operations) {
193 json_array_add(results, json_null_create());
197 ovsdb_error_destroy(error);
198 ovsdb_symbol_table_destroy(x.symtab);
203 static struct ovsdb_error *
204 ovsdb_execute_commit(struct ovsdb_execution *x, struct ovsdb_parser *parser,
205 struct json *result OVS_UNUSED)
207 const struct json *durable;
209 durable = ovsdb_parser_member(parser, "durable", OP_BOOLEAN);
210 if (durable && json_boolean(durable)) {
216 static struct ovsdb_error *
217 ovsdb_execute_abort(struct ovsdb_execution *x OVS_UNUSED,
218 struct ovsdb_parser *parser OVS_UNUSED,
219 struct json *result OVS_UNUSED)
221 return ovsdb_error("aborted", "aborted by request");
224 static struct ovsdb_table *
225 parse_table(struct ovsdb_execution *x,
226 struct ovsdb_parser *parser, const char *member)
228 struct ovsdb_table *table;
229 const char *table_name;
230 const struct json *json;
232 json = ovsdb_parser_member(parser, member, OP_ID);
236 table_name = json_string(json);
238 table = shash_find_data(&x->db->tables, table_name);
240 ovsdb_parser_raise_error(parser, "No table named %s.", table_name);
245 static WARN_UNUSED_RESULT struct ovsdb_error *
246 parse_row(const struct json *json, const struct ovsdb_table *table,
247 struct ovsdb_symbol_table *symtab,
248 struct ovsdb_row **rowp, struct ovsdb_column_set *columns)
250 struct ovsdb_error *error;
251 struct ovsdb_row *row;
256 return OVSDB_BUG("null table");
259 return OVSDB_BUG("null row");
262 row = ovsdb_row_create(table);
263 error = ovsdb_row_from_json(row, json, symtab, columns);
265 ovsdb_row_destroy(row);
273 static struct ovsdb_error *
274 ovsdb_execute_insert(struct ovsdb_execution *x, struct ovsdb_parser *parser,
277 struct ovsdb_table *table;
278 struct ovsdb_row *row = NULL;
279 const struct json *uuid_name, *row_json;
280 struct ovsdb_error *error;
281 struct uuid row_uuid;
283 table = parse_table(x, parser, "table");
284 uuid_name = ovsdb_parser_member(parser, "uuid-name", OP_ID | OP_OPTIONAL);
285 row_json = ovsdb_parser_member(parser, "row", OP_OBJECT);
286 error = ovsdb_parser_get_error(parser);
292 struct ovsdb_symbol *symbol;
294 symbol = ovsdb_symbol_table_insert(x->symtab, json_string(uuid_name));
295 if (symbol->created) {
296 return ovsdb_syntax_error(uuid_name, "duplicate uuid-name",
297 "This \"uuid-name\" appeared on an "
298 "earlier \"insert\" operation.");
300 row_uuid = symbol->uuid;
301 symbol->created = true;
303 uuid_generate(&row_uuid);
307 error = parse_row(row_json, table, x->symtab, &row, NULL);
310 /* Check constraints for columns not included in "row", in case the
311 * default values do not satisfy the constraints. We could check only
312 * the columns that have their default values by supplying an
313 * ovsdb_column_set to parse_row() above, but I suspect that this is
315 const struct shash_node *node;
317 SHASH_FOR_EACH (node, &table->schema->columns) {
318 const struct ovsdb_column *column = node->data;
319 const struct ovsdb_datum *datum = &row->fields[column->index];
321 /* If there are 0 keys or pairs, there's nothing to check.
322 * If there is 1, it might be a default value.
323 * If there are more, it can't be a default value, so the value has
324 * already been checked. */
326 error = ovsdb_datum_check_constraints(datum, &column->type);
328 ovsdb_row_destroy(row);
335 *ovsdb_row_get_uuid_rw(row) = row_uuid;
336 ovsdb_txn_row_insert(x->txn, row);
337 json_object_put(result, "uuid",
338 ovsdb_datum_to_json(&row->fields[OVSDB_COL_UUID],
344 static struct ovsdb_error *
345 ovsdb_execute_select(struct ovsdb_execution *x, struct ovsdb_parser *parser,
348 struct ovsdb_table *table;
349 const struct json *where, *columns_json, *sort_json;
350 struct ovsdb_condition condition = OVSDB_CONDITION_INITIALIZER;
351 struct ovsdb_column_set columns = OVSDB_COLUMN_SET_INITIALIZER;
352 struct ovsdb_column_set sort = OVSDB_COLUMN_SET_INITIALIZER;
353 struct ovsdb_error *error;
355 table = parse_table(x, parser, "table");
356 where = ovsdb_parser_member(parser, "where", OP_ARRAY);
357 columns_json = ovsdb_parser_member(parser, "columns",
358 OP_ARRAY | OP_OPTIONAL);
359 sort_json = ovsdb_parser_member(parser, "sort", OP_ARRAY | OP_OPTIONAL);
361 error = ovsdb_parser_get_error(parser);
363 error = ovsdb_condition_from_json(table->schema, where, x->symtab,
367 error = ovsdb_column_set_from_json(columns_json, table, &columns);
370 error = ovsdb_column_set_from_json(sort_json, table, &sort);
373 struct ovsdb_row_set rows = OVSDB_ROW_SET_INITIALIZER;
375 ovsdb_query_distinct(table, &condition, &columns, &rows);
376 ovsdb_row_set_sort(&rows, &sort);
377 json_object_put(result, "rows",
378 ovsdb_row_set_to_json(&rows, &columns));
380 ovsdb_row_set_destroy(&rows);
383 ovsdb_column_set_destroy(&columns);
384 ovsdb_column_set_destroy(&sort);
385 ovsdb_condition_destroy(&condition);
390 struct update_row_cbdata {
392 struct ovsdb_txn *txn;
393 const struct ovsdb_row *row;
394 const struct ovsdb_column_set *columns;
398 update_row_cb(const struct ovsdb_row *row, void *ur_)
400 struct update_row_cbdata *ur = ur_;
403 if (!ovsdb_row_equal_columns(row, ur->row, ur->columns)) {
404 ovsdb_row_update_columns(ovsdb_txn_row_modify(ur->txn, row),
405 ur->row, ur->columns);
411 static struct ovsdb_error *
412 ovsdb_execute_update(struct ovsdb_execution *x, struct ovsdb_parser *parser,
415 struct ovsdb_table *table;
416 const struct json *where, *row_json;
417 struct ovsdb_condition condition = OVSDB_CONDITION_INITIALIZER;
418 struct ovsdb_column_set columns = OVSDB_COLUMN_SET_INITIALIZER;
419 struct ovsdb_row *row = NULL;
420 struct update_row_cbdata ur;
421 struct ovsdb_error *error;
423 table = parse_table(x, parser, "table");
424 where = ovsdb_parser_member(parser, "where", OP_ARRAY);
425 row_json = ovsdb_parser_member(parser, "row", OP_OBJECT);
426 error = ovsdb_parser_get_error(parser);
428 error = parse_row(row_json, table, x->symtab, &row, &columns);
431 error = ovsdb_condition_from_json(table->schema, where, x->symtab,
438 ur.columns = &columns;
439 ovsdb_query(table, &condition, update_row_cb, &ur);
440 json_object_put(result, "count", json_integer_create(ur.n_matches));
443 ovsdb_row_destroy(row);
444 ovsdb_column_set_destroy(&columns);
445 ovsdb_condition_destroy(&condition);
450 struct mutate_row_cbdata {
452 struct ovsdb_txn *txn;
453 const struct ovsdb_mutation_set *mutations;
457 mutate_row_cb(const struct ovsdb_row *row, void *mr_)
459 struct mutate_row_cbdata *mr = mr_;
462 ovsdb_mutation_set_execute(ovsdb_txn_row_modify(mr->txn, row),
468 static struct ovsdb_error *
469 ovsdb_execute_mutate(struct ovsdb_execution *x, struct ovsdb_parser *parser,
472 struct ovsdb_table *table;
473 const struct json *where;
474 const struct json *mutations_json;
475 struct ovsdb_condition condition = OVSDB_CONDITION_INITIALIZER;
476 struct ovsdb_mutation_set mutations = OVSDB_MUTATION_SET_INITIALIZER;
477 struct ovsdb_row *row = NULL;
478 struct mutate_row_cbdata mr;
479 struct ovsdb_error *error;
481 table = parse_table(x, parser, "table");
482 where = ovsdb_parser_member(parser, "where", OP_ARRAY);
483 mutations_json = ovsdb_parser_member(parser, "mutations", OP_ARRAY);
484 error = ovsdb_parser_get_error(parser);
486 error = ovsdb_mutation_set_from_json(table->schema, mutations_json,
487 x->symtab, &mutations);
490 error = ovsdb_condition_from_json(table->schema, where, x->symtab,
496 mr.mutations = &mutations;
497 ovsdb_query(table, &condition, mutate_row_cb, &mr);
498 json_object_put(result, "count", json_integer_create(mr.n_matches));
501 ovsdb_row_destroy(row);
502 ovsdb_mutation_set_destroy(&mutations);
503 ovsdb_condition_destroy(&condition);
508 struct delete_row_cbdata {
510 const struct ovsdb_table *table;
511 struct ovsdb_txn *txn;
515 delete_row_cb(const struct ovsdb_row *row, void *dr_)
517 struct delete_row_cbdata *dr = dr_;
520 ovsdb_txn_row_delete(dr->txn, row);
525 static struct ovsdb_error *
526 ovsdb_execute_delete(struct ovsdb_execution *x, struct ovsdb_parser *parser,
529 struct ovsdb_table *table;
530 const struct json *where;
531 struct ovsdb_condition condition = OVSDB_CONDITION_INITIALIZER;
532 struct ovsdb_error *error;
534 where = ovsdb_parser_member(parser, "where", OP_ARRAY);
535 table = parse_table(x, parser, "table");
536 error = ovsdb_parser_get_error(parser);
538 error = ovsdb_condition_from_json(table->schema, where, x->symtab,
542 struct delete_row_cbdata dr;
547 ovsdb_query(table, &condition, delete_row_cb, &dr);
549 json_object_put(result, "count", json_integer_create(dr.n_matches));
552 ovsdb_condition_destroy(&condition);
557 struct wait_auxdata {
558 struct ovsdb_row_hash *actual;
559 struct ovsdb_row_hash *expected;
564 ovsdb_execute_wait_query_cb(const struct ovsdb_row *row, void *aux_)
566 struct wait_auxdata *aux = aux_;
568 if (ovsdb_row_hash_contains(aux->expected, row)) {
569 ovsdb_row_hash_insert(aux->actual, row);
572 /* The query row isn't in the expected result set, so the actual and
573 * expected results sets definitely differ and we can short-circuit the
574 * rest of the query. */
580 static struct ovsdb_error *
581 ovsdb_execute_wait(struct ovsdb_execution *x, struct ovsdb_parser *parser,
582 struct json *result OVS_UNUSED)
584 struct ovsdb_table *table;
585 const struct json *timeout, *where, *columns_json, *until, *rows;
586 struct ovsdb_condition condition = OVSDB_CONDITION_INITIALIZER;
587 struct ovsdb_column_set columns = OVSDB_COLUMN_SET_INITIALIZER;
588 struct ovsdb_row_hash expected = OVSDB_ROW_HASH_INITIALIZER(expected);
589 struct ovsdb_row_hash actual = OVSDB_ROW_HASH_INITIALIZER(actual);
590 struct ovsdb_error *error;
591 struct wait_auxdata aux;
592 long long int timeout_msec = 0;
595 timeout = ovsdb_parser_member(parser, "timeout", OP_NUMBER | OP_OPTIONAL);
596 where = ovsdb_parser_member(parser, "where", OP_ARRAY);
597 columns_json = ovsdb_parser_member(parser, "columns",
598 OP_ARRAY | OP_OPTIONAL);
599 until = ovsdb_parser_member(parser, "until", OP_STRING);
600 rows = ovsdb_parser_member(parser, "rows", OP_ARRAY);
601 table = parse_table(x, parser, "table");
602 error = ovsdb_parser_get_error(parser);
604 error = ovsdb_condition_from_json(table->schema, where, x->symtab,
608 error = ovsdb_column_set_from_json(columns_json, table, &columns);
612 timeout_msec = MIN(LLONG_MAX, json_real(timeout));
613 if (timeout_msec < 0) {
614 error = ovsdb_syntax_error(timeout, NULL,
615 "timeout must be nonnegative");
616 } else if (timeout_msec < x->timeout_msec) {
617 x->timeout_msec = timeout_msec;
620 timeout_msec = LLONG_MAX;
622 if (strcmp(json_string(until), "==")
623 && strcmp(json_string(until), "!=")) {
624 error = ovsdb_syntax_error(until, NULL,
625 "\"until\" must be \"==\" or \"!=\"");
629 /* Parse "rows" into 'expected'. */
630 ovsdb_row_hash_init(&expected, &columns);
631 for (i = 0; i < rows->u.array.n; i++) {
632 struct ovsdb_row *row;
634 row = ovsdb_row_create(table);
635 error = ovsdb_row_from_json(row, rows->u.array.elems[i], x->symtab,
641 if (!ovsdb_row_hash_insert(&expected, row)) {
642 /* XXX Perhaps we should abort with an error or log a
644 ovsdb_row_destroy(row);
651 ovsdb_row_hash_init(&actual, &columns);
652 aux.actual = &actual;
653 aux.expected = &expected;
655 ovsdb_query(table, &condition, ovsdb_execute_wait_query_cb, &aux);
657 /* We know that every row in 'actual' is also in 'expected'. We
658 * also know that all of the rows in 'actual' are distinct and that
659 * all of the rows in 'expected' are distinct. Therefore, if
660 * 'actual' and 'expected' have the same number of rows, then they
661 * have the same content. */
662 size_t n_actual = ovsdb_row_hash_count(&actual);
663 size_t n_expected = ovsdb_row_hash_count(&expected);
664 equal = n_actual == n_expected;
666 if (!strcmp(json_string(until), "==") != equal) {
667 if (timeout && x->elapsed_msec >= timeout_msec) {
668 if (x->elapsed_msec) {
669 error = ovsdb_error("timed out",
670 "\"wait\" timed out after %lld ms",
673 error = ovsdb_error("timed out", "\"wait\" timed out");
676 /* ovsdb_execute() will change this, if triggers really are
678 error = ovsdb_error("not supported", "triggers not supported");
684 ovsdb_row_hash_destroy(&expected, true);
685 ovsdb_row_hash_destroy(&actual, false);
686 ovsdb_column_set_destroy(&columns);
687 ovsdb_condition_destroy(&condition);
692 static struct ovsdb_error *
693 ovsdb_execute_comment(struct ovsdb_execution *x, struct ovsdb_parser *parser,
694 struct json *result OVS_UNUSED)
696 const struct json *comment;
698 comment = ovsdb_parser_member(parser, "comment", OP_STRING);
702 ovsdb_txn_add_comment(x->txn, json_string(comment));