configure: Reject incompatible XenServer version.
[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         if (params->type != JSON_ARRAY) {
107             error = ovsdb_syntax_error(params, NULL, "array expected");
108         } else {
109             error = ovsdb_syntax_error(params, NULL, "database name expected "
110                                        "as first parameter");
111         }
112
113         results = ovsdb_error_to_json(error);
114         ovsdb_error_destroy(error);
115         return results;
116     }
117
118     x.db = db;
119     x.txn = ovsdb_txn_create(db);
120     x.symtab = ovsdb_symbol_table_create();
121     x.durable = false;
122     x.elapsed_msec = elapsed_msec;
123     x.timeout_msec = LLONG_MAX;
124     results = NULL;
125
126     results = json_array_create_empty();
127     n_operations = params->u.array.n - 1;
128     error = NULL;
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;
133         struct json *result;
134         const struct json *op;
135
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();
141         if (op) {
142             const char *op_name = json_string(op);
143             ovsdb_operation_executor *executor = lookup_executor(op_name);
144             if (executor) {
145                 error = executor(&x, &parser, result);
146             } else {
147                 ovsdb_parser_raise_error(&parser, "No operation \"%s\"",
148                                          op_name);
149             }
150         } else {
151             assert(ovsdb_parser_has_error(&parser));
152         }
153
154         /* A parse error overrides any other error.
155          * An error overrides any other result. */
156         parse_error = ovsdb_parser_finish(&parser);
157         if (parse_error) {
158             ovsdb_error_destroy(error);
159             error = parse_error;
160         }
161         if (error) {
162             json_destroy(result);
163             result = ovsdb_error_to_json(error);
164         }
165         if (error && !strcmp(ovsdb_error_get_tag(error), "not supported")
166             && timeout_msec) {
167             ovsdb_txn_abort(x.txn);
168             *timeout_msec = x.timeout_msec;
169
170             json_destroy(result);
171             json_destroy(results);
172             results = NULL;
173             goto exit;
174         }
175
176         /* Add result to array. */
177         json_array_add(results, result);
178         if (error) {
179             break;
180         }
181     }
182
183     if (!error) {
184         error = ovsdb_txn_commit(x.txn, x.durable);
185         if (error) {
186             json_array_add(results, ovsdb_error_to_json(error));
187         }
188     } else {
189         ovsdb_txn_abort(x.txn);
190     }
191
192     while (json_array(results)->n < n_operations) {
193         json_array_add(results, json_null_create());
194     }
195
196 exit:
197     ovsdb_error_destroy(error);
198     ovsdb_symbol_table_destroy(x.symtab);
199
200     return results;
201 }
202
203 struct ovsdb_error *
204 ovsdb_execute_commit(struct ovsdb_execution *x, struct ovsdb_parser *parser,
205                      struct json *result OVS_UNUSED)
206 {
207     const struct json *durable;
208
209     durable = ovsdb_parser_member(parser, "durable", OP_BOOLEAN);
210     if (durable && json_boolean(durable)) {
211         x->durable = true;
212     }
213     return NULL;
214 }
215
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)
220 {
221     return ovsdb_error("aborted", "aborted by request");
222 }
223
224 static struct ovsdb_table *
225 parse_table(struct ovsdb_execution *x,
226             struct ovsdb_parser *parser, const char *member)
227 {
228     struct ovsdb_table *table;
229     const char *table_name;
230     const struct json *json;
231
232     json = ovsdb_parser_member(parser, member, OP_ID);
233     if (!json) {
234         return NULL;
235     }
236     table_name = json_string(json);
237
238     table = shash_find_data(&x->db->tables, table_name);
239     if (!table) {
240         ovsdb_parser_raise_error(parser, "No table named %s.", table_name);
241     }
242     return table;
243 }
244
245 static WARN_UNUSED_RESULT struct ovsdb_error *
246 parse_row(struct ovsdb_parser *parser, const char *member,
247           const struct ovsdb_table *table,
248           struct ovsdb_symbol_table *symtab,
249           struct ovsdb_row **rowp, struct ovsdb_column_set *columns)
250 {
251     struct ovsdb_error *error;
252     const struct json *json;
253     struct ovsdb_row *row;
254
255     *rowp = NULL;
256
257     if (!table) {
258         return OVSDB_BUG("null table");
259     }
260     json = ovsdb_parser_member(parser, member, OP_OBJECT);
261     if (!json) {
262         return OVSDB_BUG("null row member");
263     }
264
265     row = ovsdb_row_create(table);
266     error = ovsdb_row_from_json(row, json, symtab, columns);
267     if (error) {
268         ovsdb_row_destroy(row);
269         return error;
270     } else {
271         *rowp = row;
272         return NULL;
273     }
274 }
275
276 struct ovsdb_error *
277 ovsdb_execute_insert(struct ovsdb_execution *x, struct ovsdb_parser *parser,
278                      struct json *result)
279 {
280     struct ovsdb_table *table;
281     struct ovsdb_row *row = NULL;
282     const struct json *uuid_name;
283     struct ovsdb_error *error;
284     struct uuid row_uuid;
285
286     table = parse_table(x, parser, "table");
287     uuid_name = ovsdb_parser_member(parser, "uuid-name", OP_ID | OP_OPTIONAL);
288     error = ovsdb_parser_get_error(parser);
289
290     if (uuid_name) {
291         struct ovsdb_symbol *symbol;
292
293         symbol = ovsdb_symbol_table_insert(x->symtab, json_string(uuid_name));
294         if (symbol->used) {
295             ovsdb_error_destroy(error);
296             return ovsdb_syntax_error(uuid_name, "duplicate uuid-name",
297                                       "This \"uuid-name\" appeared on an "
298                                       "earlier \"insert\" operation.");
299         }
300         row_uuid = symbol->uuid;
301         symbol->used = true;
302     } else {
303         uuid_generate(&row_uuid);
304     }
305
306     if (!error) {
307         error = parse_row(parser, "row", table, x->symtab, &row, NULL);
308     }
309     if (!error) {
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
314          * cheaper.  */
315         const struct shash_node *node;
316
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];
320
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. */
325             if (datum->n == 1) {
326                 error = ovsdb_datum_check_constraints(datum, &column->type);
327                 if (error) {
328                     ovsdb_row_destroy(row);
329                     break;
330                 }
331             }
332         }
333     }
334     if (!error) {
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],
339                                             &ovsdb_type_uuid));
340     }
341     return error;
342 }
343
344 struct ovsdb_error *
345 ovsdb_execute_select(struct ovsdb_execution *x, struct ovsdb_parser *parser,
346                      struct json *result)
347 {
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;
354
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);
360
361     error = ovsdb_parser_get_error(parser);
362     if (!error) {
363         error = ovsdb_condition_from_json(table->schema, where, x->symtab,
364                                           &condition);
365     }
366     if (!error) {
367         error = ovsdb_column_set_from_json(columns_json, table, &columns);
368     }
369     if (!error) {
370         error = ovsdb_column_set_from_json(sort_json, table, &sort);
371     }
372     if (!error) {
373         struct ovsdb_row_set rows = OVSDB_ROW_SET_INITIALIZER;
374
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));
379
380         ovsdb_row_set_destroy(&rows);
381     }
382
383     ovsdb_column_set_destroy(&columns);
384     ovsdb_column_set_destroy(&sort);
385     ovsdb_condition_destroy(&condition);
386
387     return error;
388 }
389
390 struct update_row_cbdata {
391     size_t n_matches;
392     struct ovsdb_txn *txn;
393     const struct ovsdb_row *row;
394     const struct ovsdb_column_set *columns;
395 };
396
397 static bool
398 update_row_cb(const struct ovsdb_row *row, void *ur_)
399 {
400     struct update_row_cbdata *ur = ur_;
401
402     ur->n_matches++;
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);
406     }
407
408     return true;
409 }
410
411 struct ovsdb_error *
412 ovsdb_execute_update(struct ovsdb_execution *x, struct ovsdb_parser *parser,
413                      struct json *result)
414 {
415     struct ovsdb_table *table;
416     const struct json *where;
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;
422
423     table = parse_table(x, parser, "table");
424     where = ovsdb_parser_member(parser, "where", OP_ARRAY);
425     error = ovsdb_parser_get_error(parser);
426     if (!error) {
427         error = parse_row(parser, "row", table, x->symtab, &row, &columns);
428     }
429     if (!error) {
430         error = ovsdb_condition_from_json(table->schema, where, x->symtab,
431                                           &condition);
432     }
433     if (!error) {
434         ur.n_matches = 0;
435         ur.txn = x->txn;
436         ur.row = row;
437         ur.columns = &columns;
438         ovsdb_query(table, &condition, update_row_cb, &ur);
439         json_object_put(result, "count", json_integer_create(ur.n_matches));
440     }
441
442     ovsdb_row_destroy(row);
443     ovsdb_column_set_destroy(&columns);
444     ovsdb_condition_destroy(&condition);
445
446     return error;
447 }
448
449 struct mutate_row_cbdata {
450     size_t n_matches;
451     struct ovsdb_txn *txn;
452     const struct ovsdb_mutation_set *mutations;
453 };
454
455 static bool
456 mutate_row_cb(const struct ovsdb_row *row, void *mr_)
457 {
458     struct mutate_row_cbdata *mr = mr_;
459
460     mr->n_matches++;
461     ovsdb_mutation_set_execute(ovsdb_txn_row_modify(mr->txn, row),
462                                mr->mutations);
463
464     return true;
465 }
466
467 struct ovsdb_error *
468 ovsdb_execute_mutate(struct ovsdb_execution *x, struct ovsdb_parser *parser,
469                      struct json *result)
470 {
471     struct ovsdb_table *table;
472     const struct json *where;
473     const struct json *mutations_json;
474     struct ovsdb_condition condition = OVSDB_CONDITION_INITIALIZER;
475     struct ovsdb_mutation_set mutations = OVSDB_MUTATION_SET_INITIALIZER;
476     struct ovsdb_row *row = NULL;
477     struct mutate_row_cbdata mr;
478     struct ovsdb_error *error;
479
480     table = parse_table(x, parser, "table");
481     where = ovsdb_parser_member(parser, "where", OP_ARRAY);
482     mutations_json = ovsdb_parser_member(parser, "mutations", OP_ARRAY);
483     error = ovsdb_parser_get_error(parser);
484     if (!error) {
485         error = ovsdb_mutation_set_from_json(table->schema, mutations_json,
486                                              x->symtab, &mutations);
487     }
488     if (!error) {
489         error = ovsdb_condition_from_json(table->schema, where, x->symtab,
490                                           &condition);
491     }
492     if (!error) {
493         mr.n_matches = 0;
494         mr.txn = x->txn;
495         mr.mutations = &mutations;
496         ovsdb_query(table, &condition, mutate_row_cb, &mr);
497         json_object_put(result, "count", json_integer_create(mr.n_matches));
498     }
499
500     ovsdb_row_destroy(row);
501     ovsdb_mutation_set_destroy(&mutations);
502     ovsdb_condition_destroy(&condition);
503
504     return error;
505 }
506
507 struct delete_row_cbdata {
508     size_t n_matches;
509     const struct ovsdb_table *table;
510     struct ovsdb_txn *txn;
511 };
512
513 static bool
514 delete_row_cb(const struct ovsdb_row *row, void *dr_)
515 {
516     struct delete_row_cbdata *dr = dr_;
517
518     dr->n_matches++;
519     ovsdb_txn_row_delete(dr->txn, row);
520
521     return true;
522 }
523
524 struct ovsdb_error *
525 ovsdb_execute_delete(struct ovsdb_execution *x, struct ovsdb_parser *parser,
526                      struct json *result)
527 {
528     struct ovsdb_table *table;
529     const struct json *where;
530     struct ovsdb_condition condition = OVSDB_CONDITION_INITIALIZER;
531     struct ovsdb_error *error;
532
533     where = ovsdb_parser_member(parser, "where", OP_ARRAY);
534     table = parse_table(x, parser, "table");
535     error = ovsdb_parser_get_error(parser);
536     if (!error) {
537         error = ovsdb_condition_from_json(table->schema, where, x->symtab,
538                                           &condition);
539     }
540     if (!error) {
541         struct delete_row_cbdata dr;
542
543         dr.n_matches = 0;
544         dr.table = table;
545         dr.txn = x->txn;
546         ovsdb_query(table, &condition, delete_row_cb, &dr);
547
548         json_object_put(result, "count", json_integer_create(dr.n_matches));
549     }
550
551     ovsdb_condition_destroy(&condition);
552
553     return error;
554 }
555
556 struct wait_auxdata {
557     struct ovsdb_row_hash *actual;
558     struct ovsdb_row_hash *expected;
559     bool *equal;
560 };
561
562 static bool
563 ovsdb_execute_wait_query_cb(const struct ovsdb_row *row, void *aux_)
564 {
565     struct wait_auxdata *aux = aux_;
566
567     if (ovsdb_row_hash_contains(aux->expected, row)) {
568         ovsdb_row_hash_insert(aux->actual, row);
569         return true;
570     } else {
571         /* The query row isn't in the expected result set, so the actual and
572          * expected results sets definitely differ and we can short-circuit the
573          * rest of the query. */
574         *aux->equal = false;
575         return false;
576     }
577 }
578
579 static struct ovsdb_error *
580 ovsdb_execute_wait(struct ovsdb_execution *x, struct ovsdb_parser *parser,
581                    struct json *result OVS_UNUSED)
582 {
583     struct ovsdb_table *table;
584     const struct json *timeout, *where, *columns_json, *until, *rows;
585     struct ovsdb_condition condition = OVSDB_CONDITION_INITIALIZER;
586     struct ovsdb_column_set columns = OVSDB_COLUMN_SET_INITIALIZER;
587     struct ovsdb_row_hash expected = OVSDB_ROW_HASH_INITIALIZER(expected);
588     struct ovsdb_row_hash actual = OVSDB_ROW_HASH_INITIALIZER(actual);
589     struct ovsdb_error *error;
590     struct wait_auxdata aux;
591     long long int timeout_msec = 0;
592     size_t i;
593
594     timeout = ovsdb_parser_member(parser, "timeout", OP_NUMBER | OP_OPTIONAL);
595     where = ovsdb_parser_member(parser, "where", OP_ARRAY);
596     columns_json = ovsdb_parser_member(parser, "columns",
597                                        OP_ARRAY | OP_OPTIONAL);
598     until = ovsdb_parser_member(parser, "until", OP_STRING);
599     rows = ovsdb_parser_member(parser, "rows", OP_ARRAY);
600     table = parse_table(x, parser, "table");
601     error = ovsdb_parser_get_error(parser);
602     if (!error) {
603         error = ovsdb_condition_from_json(table->schema, where, x->symtab,
604                                           &condition);
605     }
606     if (!error) {
607         error = ovsdb_column_set_from_json(columns_json, table, &columns);
608     }
609     if (!error) {
610         if (timeout) {
611             timeout_msec = MIN(LLONG_MAX, json_real(timeout));
612             if (timeout_msec < 0) {
613                 error = ovsdb_syntax_error(timeout, NULL,
614                                            "timeout must be nonnegative");
615             } else if (timeout_msec < x->timeout_msec) {
616                 x->timeout_msec = timeout_msec;
617             }
618         } else {
619             timeout_msec = LLONG_MAX;
620         }
621         if (strcmp(json_string(until), "==")
622             && strcmp(json_string(until), "!=")) {
623             error = ovsdb_syntax_error(until, NULL,
624                                        "\"until\" must be \"==\" or \"!=\"");
625         }
626     }
627     if (!error) {
628         /* Parse "rows" into 'expected'. */
629         ovsdb_row_hash_init(&expected, &columns);
630         for (i = 0; i < rows->u.array.n; i++) {
631             struct ovsdb_row *row;
632
633             row = ovsdb_row_create(table);
634             error = ovsdb_row_from_json(row, rows->u.array.elems[i], x->symtab,
635                                         NULL);
636             if (error) {
637                 break;
638             }
639
640             if (!ovsdb_row_hash_insert(&expected, row)) {
641                 /* XXX Perhaps we should abort with an error or log a
642                  * warning. */
643                 ovsdb_row_destroy(row);
644             }
645         }
646     }
647     if (!error) {
648         /* Execute query. */
649         bool equal = true;
650         ovsdb_row_hash_init(&actual, &columns);
651         aux.actual = &actual;
652         aux.expected = &expected;
653         aux.equal = &equal;
654         ovsdb_query(table, &condition, ovsdb_execute_wait_query_cb, &aux);
655         if (equal) {
656             /* We know that every row in 'actual' is also in 'expected'.  We
657              * also know that all of the rows in 'actual' are distinct and that
658              * all of the rows in 'expected' are distinct.  Therefore, if
659              * 'actual' and 'expected' have the same number of rows, then they
660              * have the same content. */
661             size_t n_actual = ovsdb_row_hash_count(&actual);
662             size_t n_expected = ovsdb_row_hash_count(&expected);
663             equal = n_actual == n_expected;
664         }
665         if (!strcmp(json_string(until), "==") != equal) {
666             if (timeout && x->elapsed_msec >= timeout_msec) {
667                 if (x->elapsed_msec) {
668                     error = ovsdb_error("timed out",
669                                         "\"wait\" timed out after %lld ms",
670                                         x->elapsed_msec);
671                 } else {
672                     error = ovsdb_error("timed out", "\"wait\" timed out");
673                 }
674             } else {
675                 /* ovsdb_execute() will change this, if triggers really are
676                  * supported. */
677                 error = ovsdb_error("not supported", "triggers not supported");
678             }
679         }
680     }
681
682
683     ovsdb_row_hash_destroy(&expected, true);
684     ovsdb_row_hash_destroy(&actual, false);
685     ovsdb_column_set_destroy(&columns);
686     ovsdb_condition_destroy(&condition);
687
688     return error;
689 }
690
691 static struct ovsdb_error *
692 ovsdb_execute_comment(struct ovsdb_execution *x, struct ovsdb_parser *parser,
693                       struct json *result OVS_UNUSED)
694 {
695     const struct json *comment;
696
697     comment = ovsdb_parser_member(parser, "comment", OP_STRING);
698     if (!comment) {
699         return NULL;
700     }
701     ovsdb_txn_add_comment(x->txn, json_string(comment));
702
703     return NULL;
704 }