Debian: Add Homepage
[openvswitch] / ovsdb / execution.c
1 /* Copyright (c) 2009, 2010 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 <assert.h>
19 #include <limits.h>
20
21 #include "column.h"
22 #include "condition.h"
23 #include "file.h"
24 #include "json.h"
25 #include "mutation.h"
26 #include "ovsdb-data.h"
27 #include "ovsdb-error.h"
28 #include "ovsdb-parser.h"
29 #include "ovsdb.h"
30 #include "query.h"
31 #include "row.h"
32 #include "table.h"
33 #include "timeval.h"
34 #include "transaction.h"
35
36 struct ovsdb_execution {
37     struct ovsdb *db;
38     struct ovsdb_txn *txn;
39     struct ovsdb_symbol_table *symtab;
40     bool durable;
41
42     /* Triggers. */
43     long long int elapsed_msec;
44     long long int timeout_msec;
45 };
46
47 typedef struct ovsdb_error *ovsdb_operation_executor(struct ovsdb_execution *,
48                                                      struct ovsdb_parser *,
49                                                      struct json *result);
50
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;
60
61 static ovsdb_operation_executor *
62 lookup_executor(const char *name)
63 {
64     struct ovsdb_operation {
65         const char *name;
66         ovsdb_operation_executor *executor;
67     };
68
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 },
79     };
80
81     size_t i;
82
83     for (i = 0; i < ARRAY_SIZE(operations); i++) {
84         const struct ovsdb_operation *c = &operations[i];
85         if (!strcmp(c->name, name)) {
86             return c->executor;
87         }
88     }
89     return NULL;
90 }
91
92 struct json *
93 ovsdb_execute(struct ovsdb *db, const struct json *params,
94               long long int elapsed_msec, long long int *timeout_msec)
95 {
96     struct ovsdb_execution x;
97     struct ovsdb_error *error;
98     struct json *results;
99     size_t n_operations;
100     size_t i;
101
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         struct ovsdb_error *error;
107
108         if (params->type != JSON_ARRAY) {
109             error = ovsdb_syntax_error(params, NULL, "array expected");
110         } else {
111             error = ovsdb_syntax_error(params, NULL, "database name expected "
112                                        "as first parameter");
113         }
114
115         results = ovsdb_error_to_json(error);
116         ovsdb_error_destroy(error);
117         return results;
118     }
119
120     x.db = db;
121     x.txn = ovsdb_txn_create(db);
122     x.symtab = ovsdb_symbol_table_create();
123     x.durable = false;
124     x.elapsed_msec = elapsed_msec;
125     x.timeout_msec = LLONG_MAX;
126     results = NULL;
127
128     results = json_array_create_empty();
129     n_operations = params->u.array.n - 1;
130     error = NULL;
131     for (i = 1; i <= n_operations; i++) {
132         struct json *operation = params->u.array.elems[i];
133         struct ovsdb_error *parse_error;
134         struct ovsdb_parser parser;
135         struct json *result;
136         const struct json *op;
137
138         /* Parse and execute operation. */
139         ovsdb_parser_init(&parser, operation,
140                           "ovsdb operation %zu of %zu", i, n_operations);
141         op = ovsdb_parser_member(&parser, "op", OP_ID);
142         result = json_object_create();
143         if (op) {
144             const char *op_name = json_string(op);
145             ovsdb_operation_executor *executor = lookup_executor(op_name);
146             if (executor) {
147                 error = executor(&x, &parser, result);
148             } else {
149                 ovsdb_parser_raise_error(&parser, "No operation \"%s\"",
150                                          op_name);
151             }
152         } else {
153             assert(ovsdb_parser_has_error(&parser));
154         }
155
156         /* A parse error overrides any other error.
157          * An error overrides any other result. */
158         parse_error = ovsdb_parser_finish(&parser);
159         if (parse_error) {
160             ovsdb_error_destroy(error);
161             error = parse_error;
162         }
163         if (error) {
164             json_destroy(result);
165             result = ovsdb_error_to_json(error);
166         }
167         if (error && !strcmp(ovsdb_error_get_tag(error), "not supported")
168             && timeout_msec) {
169             ovsdb_txn_abort(x.txn);
170             *timeout_msec = x.timeout_msec;
171
172             json_destroy(result);
173             json_destroy(results);
174             results = NULL;
175             goto exit;
176         }
177
178         /* Add result to array. */
179         json_array_add(results, result);
180         if (error) {
181             break;
182         }
183     }
184
185     if (!error) {
186         error = ovsdb_txn_commit(x.txn, x.durable);
187         if (error) {
188             json_array_add(results, ovsdb_error_to_json(error));
189         }
190     } else {
191         ovsdb_txn_abort(x.txn);
192     }
193
194     while (json_array(results)->n < n_operations) {
195         json_array_add(results, json_null_create());
196     }
197
198 exit:
199     ovsdb_error_destroy(error);
200     ovsdb_symbol_table_destroy(x.symtab);
201
202     return results;
203 }
204
205 struct ovsdb_error *
206 ovsdb_execute_commit(struct ovsdb_execution *x, struct ovsdb_parser *parser,
207                      struct json *result OVS_UNUSED)
208 {
209     const struct json *durable;
210
211     durable = ovsdb_parser_member(parser, "durable", OP_BOOLEAN);
212     if (durable && json_boolean(durable)) {
213         x->durable = true;
214     }
215     return NULL;
216 }
217
218 static struct ovsdb_error *
219 ovsdb_execute_abort(struct ovsdb_execution *x OVS_UNUSED,
220                     struct ovsdb_parser *parser OVS_UNUSED,
221                     struct json *result OVS_UNUSED)
222 {
223     return ovsdb_error("aborted", "aborted by request");
224 }
225
226 static struct ovsdb_table *
227 parse_table(struct ovsdb_execution *x,
228             struct ovsdb_parser *parser, const char *member)
229 {
230     struct ovsdb_table *table;
231     const char *table_name;
232     const struct json *json;
233
234     json = ovsdb_parser_member(parser, member, OP_ID);
235     if (!json) {
236         return NULL;
237     }
238     table_name = json_string(json);
239
240     table = shash_find_data(&x->db->tables, table_name);
241     if (!table) {
242         ovsdb_parser_raise_error(parser, "No table named %s.", table_name);
243     }
244     return table;
245 }
246
247 static WARN_UNUSED_RESULT struct ovsdb_error *
248 parse_row(struct ovsdb_parser *parser, const char *member,
249           const struct ovsdb_table *table,
250           struct ovsdb_symbol_table *symtab,
251           struct ovsdb_row **rowp, struct ovsdb_column_set *columns)
252 {
253     struct ovsdb_error *error;
254     const struct json *json;
255     struct ovsdb_row *row;
256
257     *rowp = NULL;
258
259     if (!table) {
260         return OVSDB_BUG("null table");
261     }
262     json = ovsdb_parser_member(parser, member, OP_OBJECT);
263     if (!json) {
264         return OVSDB_BUG("null row member");
265     }
266
267     row = ovsdb_row_create(table);
268     error = ovsdb_row_from_json(row, json, symtab, columns);
269     if (error) {
270         ovsdb_row_destroy(row);
271         return error;
272     } else {
273         *rowp = row;
274         return NULL;
275     }
276 }
277
278 struct ovsdb_error *
279 ovsdb_execute_insert(struct ovsdb_execution *x, struct ovsdb_parser *parser,
280                      struct json *result)
281 {
282     struct ovsdb_table *table;
283     struct ovsdb_row *row = NULL;
284     const struct json *uuid_name;
285     struct ovsdb_error *error;
286     struct uuid row_uuid;
287
288     table = parse_table(x, parser, "table");
289     uuid_name = ovsdb_parser_member(parser, "uuid-name", OP_ID | OP_OPTIONAL);
290     error = ovsdb_parser_get_error(parser);
291
292     if (uuid_name) {
293         struct ovsdb_symbol *symbol;
294
295         symbol = ovsdb_symbol_table_insert(x->symtab, json_string(uuid_name));
296         if (symbol->used) {
297             return ovsdb_syntax_error(uuid_name, "duplicate uuid-name",
298                                       "This \"uuid-name\" appeared on an "
299                                       "earlier \"insert\" operation.");
300         }
301         row_uuid = symbol->uuid;
302         symbol->used = true;
303     } else {
304         uuid_generate(&row_uuid);
305     }
306
307     if (!error) {
308         error = parse_row(parser, "row", table, x->symtab, &row, NULL);
309     }
310     if (!error) {
311         /* Check constraints for columns not included in "row", in case the
312          * default values do not satisfy the constraints.  We could check only
313          * the columns that have their default values by supplying an
314          * ovsdb_column_set to parse_row() above, but I suspect that this is
315          * cheaper.  */
316         const struct shash_node *node;
317
318         SHASH_FOR_EACH (node, &table->schema->columns) {
319             const struct ovsdb_column *column = node->data;
320             const struct ovsdb_datum *datum = &row->fields[column->index];
321
322             /* If there are 0 keys or pairs, there's nothing to check.
323              * If there is 1, it might be a default value.
324              * If there are more, it can't be a default value, so the value has
325              * already been checked. */
326             if (datum->n == 1) {
327                 error = ovsdb_datum_check_constraints(datum, &column->type);
328                 if (error) {
329                     ovsdb_row_destroy(row);
330                     break;
331                 }
332             }
333         }
334     }
335     if (!error) {
336         *ovsdb_row_get_uuid_rw(row) = row_uuid;
337         ovsdb_txn_row_insert(x->txn, row);
338         json_object_put(result, "uuid",
339                         ovsdb_datum_to_json(&row->fields[OVSDB_COL_UUID],
340                                             &ovsdb_type_uuid));
341     }
342     return error;
343 }
344
345 struct ovsdb_error *
346 ovsdb_execute_select(struct ovsdb_execution *x, struct ovsdb_parser *parser,
347                      struct json *result)
348 {
349     struct ovsdb_table *table;
350     const struct json *where, *columns_json, *sort_json;
351     struct ovsdb_condition condition = OVSDB_CONDITION_INITIALIZER;
352     struct ovsdb_column_set columns = OVSDB_COLUMN_SET_INITIALIZER;
353     struct ovsdb_column_set sort = OVSDB_COLUMN_SET_INITIALIZER;
354     struct ovsdb_error *error;
355
356     table = parse_table(x, parser, "table");
357     where = ovsdb_parser_member(parser, "where", OP_ARRAY);
358     columns_json = ovsdb_parser_member(parser, "columns",
359                                        OP_ARRAY | OP_OPTIONAL);
360     sort_json = ovsdb_parser_member(parser, "sort", OP_ARRAY | OP_OPTIONAL);
361
362     error = ovsdb_parser_get_error(parser);
363     if (!error) {
364         error = ovsdb_condition_from_json(table->schema, where, x->symtab,
365                                           &condition);
366     }
367     if (!error) {
368         error = ovsdb_column_set_from_json(columns_json, table, &columns);
369     }
370     if (!error) {
371         error = ovsdb_column_set_from_json(sort_json, table, &sort);
372     }
373     if (!error) {
374         struct ovsdb_row_set rows = OVSDB_ROW_SET_INITIALIZER;
375
376         ovsdb_query_distinct(table, &condition, &columns, &rows);
377         ovsdb_row_set_sort(&rows, &sort);
378         json_object_put(result, "rows",
379                         ovsdb_row_set_to_json(&rows, &columns));
380
381         ovsdb_row_set_destroy(&rows);
382     }
383
384     ovsdb_column_set_destroy(&columns);
385     ovsdb_column_set_destroy(&sort);
386     ovsdb_condition_destroy(&condition);
387
388     return error;
389 }
390
391 struct update_row_cbdata {
392     size_t n_matches;
393     struct ovsdb_txn *txn;
394     const struct ovsdb_row *row;
395     const struct ovsdb_column_set *columns;
396 };
397
398 static bool
399 update_row_cb(const struct ovsdb_row *row, void *ur_)
400 {
401     struct update_row_cbdata *ur = ur_;
402
403     ur->n_matches++;
404     if (!ovsdb_row_equal_columns(row, ur->row, ur->columns)) {
405         ovsdb_row_update_columns(ovsdb_txn_row_modify(ur->txn, row),
406                                  ur->row, ur->columns);
407     }
408
409     return true;
410 }
411
412 struct ovsdb_error *
413 ovsdb_execute_update(struct ovsdb_execution *x, struct ovsdb_parser *parser,
414                      struct json *result)
415 {
416     struct ovsdb_table *table;
417     const struct json *where;
418     struct ovsdb_condition condition = OVSDB_CONDITION_INITIALIZER;
419     struct ovsdb_column_set columns = OVSDB_COLUMN_SET_INITIALIZER;
420     struct ovsdb_row *row = NULL;
421     struct update_row_cbdata ur;
422     struct ovsdb_error *error;
423
424     table = parse_table(x, parser, "table");
425     where = ovsdb_parser_member(parser, "where", OP_ARRAY);
426     error = ovsdb_parser_get_error(parser);
427     if (!error) {
428         error = parse_row(parser, "row", table, x->symtab, &row, &columns);
429     }
430     if (!error) {
431         error = ovsdb_condition_from_json(table->schema, where, x->symtab,
432                                           &condition);
433     }
434     if (!error) {
435         ur.n_matches = 0;
436         ur.txn = x->txn;
437         ur.row = row;
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));
441     }
442
443     ovsdb_row_destroy(row);
444     ovsdb_column_set_destroy(&columns);
445     ovsdb_condition_destroy(&condition);
446
447     return error;
448 }
449
450 struct mutate_row_cbdata {
451     size_t n_matches;
452     struct ovsdb_txn *txn;
453     const struct ovsdb_mutation_set *mutations;
454 };
455
456 static bool
457 mutate_row_cb(const struct ovsdb_row *row, void *mr_)
458 {
459     struct mutate_row_cbdata *mr = mr_;
460
461     mr->n_matches++;
462     ovsdb_mutation_set_execute(ovsdb_txn_row_modify(mr->txn, row),
463                                mr->mutations);
464
465     return true;
466 }
467
468 struct ovsdb_error *
469 ovsdb_execute_mutate(struct ovsdb_execution *x, struct ovsdb_parser *parser,
470                      struct json *result)
471 {
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;
480
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);
485     if (!error) {
486         error = ovsdb_mutation_set_from_json(table->schema, mutations_json,
487                                              x->symtab, &mutations);
488     }
489     if (!error) {
490         error = ovsdb_condition_from_json(table->schema, where, x->symtab,
491                                           &condition);
492     }
493     if (!error) {
494         mr.n_matches = 0;
495         mr.txn = x->txn;
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));
499     }
500
501     ovsdb_row_destroy(row);
502     ovsdb_mutation_set_destroy(&mutations);
503     ovsdb_condition_destroy(&condition);
504
505     return error;
506 }
507
508 struct delete_row_cbdata {
509     size_t n_matches;
510     const struct ovsdb_table *table;
511     struct ovsdb_txn *txn;
512 };
513
514 static bool
515 delete_row_cb(const struct ovsdb_row *row, void *dr_)
516 {
517     struct delete_row_cbdata *dr = dr_;
518
519     dr->n_matches++;
520     ovsdb_txn_row_delete(dr->txn, row);
521
522     return true;
523 }
524
525 struct ovsdb_error *
526 ovsdb_execute_delete(struct ovsdb_execution *x, struct ovsdb_parser *parser,
527                      struct json *result)
528 {
529     struct ovsdb_table *table;
530     const struct json *where;
531     struct ovsdb_condition condition = OVSDB_CONDITION_INITIALIZER;
532     struct ovsdb_error *error;
533
534     where = ovsdb_parser_member(parser, "where", OP_ARRAY);
535     table = parse_table(x, parser, "table");
536     error = ovsdb_parser_get_error(parser);
537     if (!error) {
538         error = ovsdb_condition_from_json(table->schema, where, x->symtab,
539                                           &condition);
540     }
541     if (!error) {
542         struct delete_row_cbdata dr;
543
544         dr.n_matches = 0;
545         dr.table = table;
546         dr.txn = x->txn;
547         ovsdb_query(table, &condition, delete_row_cb, &dr);
548
549         json_object_put(result, "count", json_integer_create(dr.n_matches));
550     }
551
552     ovsdb_condition_destroy(&condition);
553
554     return error;
555 }
556
557 struct wait_auxdata {
558     struct ovsdb_row_hash *actual;
559     struct ovsdb_row_hash *expected;
560     bool *equal;
561 };
562
563 static bool
564 ovsdb_execute_wait_query_cb(const struct ovsdb_row *row, void *aux_)
565 {
566     struct wait_auxdata *aux = aux_;
567
568     if (ovsdb_row_hash_contains(aux->expected, row)) {
569         ovsdb_row_hash_insert(aux->actual, row);
570         return true;
571     } else {
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. */
575         *aux->equal = false;
576         return false;
577     }
578 }
579
580 static struct ovsdb_error *
581 ovsdb_execute_wait(struct ovsdb_execution *x, struct ovsdb_parser *parser,
582                    struct json *result OVS_UNUSED)
583 {
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;
593     size_t i;
594
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);
603     if (!error) {
604         error = ovsdb_condition_from_json(table->schema, where, x->symtab,
605                                           &condition);
606     }
607     if (!error) {
608         error = ovsdb_column_set_from_json(columns_json, table, &columns);
609     }
610     if (!error) {
611         if (timeout) {
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;
618             }
619         } else {
620             timeout_msec = LLONG_MAX;
621         }
622         if (strcmp(json_string(until), "==")
623             && strcmp(json_string(until), "!=")) {
624             error = ovsdb_syntax_error(until, NULL,
625                                        "\"until\" must be \"==\" or \"!=\"");
626         }
627     }
628     if (!error) {
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_error *error;
633             struct ovsdb_row *row;
634
635             row = ovsdb_row_create(table);
636             error = ovsdb_row_from_json(row, rows->u.array.elems[i], x->symtab,
637                                         NULL);
638             if (error) {
639                 break;
640             }
641
642             if (!ovsdb_row_hash_insert(&expected, row)) {
643                 /* XXX Perhaps we should abort with an error or log a
644                  * warning. */
645                 ovsdb_row_destroy(row);
646             }
647         }
648     }
649     if (!error) {
650         /* Execute query. */
651         bool equal = true;
652         ovsdb_row_hash_init(&actual, &columns);
653         aux.actual = &actual;
654         aux.expected = &expected;
655         aux.equal = &equal;
656         ovsdb_query(table, &condition, ovsdb_execute_wait_query_cb, &aux);
657         if (equal) {
658             /* We know that every row in 'actual' is also in 'expected'.  We
659              * also know that all of the rows in 'actual' are distinct and that
660              * all of the rows in 'expected' are distinct.  Therefore, if
661              * 'actual' and 'expected' have the same number of rows, then they
662              * have the same content. */
663             size_t n_actual = ovsdb_row_hash_count(&actual);
664             size_t n_expected = ovsdb_row_hash_count(&expected);
665             equal = n_actual == n_expected;
666         }
667         if (!strcmp(json_string(until), "==") != equal) {
668             if (timeout && x->elapsed_msec >= timeout_msec) {
669                 if (x->elapsed_msec) {
670                     error = ovsdb_error("timed out",
671                                         "\"wait\" timed out after %lld ms",
672                                         x->elapsed_msec);
673                 } else {
674                     error = ovsdb_error("timed out", "\"wait\" timed out");
675                 }
676             } else {
677                 /* ovsdb_execute() will change this, if triggers really are
678                  * supported. */
679                 error = ovsdb_error("not supported", "triggers not supported");
680             }
681         }
682     }
683
684
685     ovsdb_row_hash_destroy(&expected, true);
686     ovsdb_row_hash_destroy(&actual, false);
687     ovsdb_column_set_destroy(&columns);
688     ovsdb_condition_destroy(&condition);
689
690     return error;
691 }
692
693 static struct ovsdb_error *
694 ovsdb_execute_comment(struct ovsdb_execution *x, struct ovsdb_parser *parser,
695                       struct json *result OVS_UNUSED)
696 {
697     const struct json *comment;
698
699     comment = ovsdb_parser_member(parser, "comment", OP_STRING);
700     if (!comment) {
701         return NULL;
702     }
703     ovsdb_txn_add_comment(x->txn, json_string(comment));
704
705     return NULL;
706 }