X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=tests%2Ftest-ovsdb.c;h=4f44afe86979436cf0ccb193e2e2e274eb3aadfb;hb=586bb84a49efa62a56e9aed2a345e01679dcccca;hp=27523fb222d674146133826d245073bbc54ed4f9;hpb=bd06962ad334fa4631b67905fc9f43f96a908915;p=openvswitch diff --git a/tests/test-ovsdb.c b/tests/test-ovsdb.c index 27523fb2..4f44afe8 100644 --- a/tests/test-ovsdb.c +++ b/tests/test-ovsdb.c @@ -25,8 +25,10 @@ #include "command-line.h" #include "json.h" +#include "jsonrpc.h" #include "ovsdb-data.h" #include "ovsdb-error.h" +#include "ovsdb-idl.h" #include "ovsdb-types.h" #include "ovsdb/column.h" #include "ovsdb/condition.h" @@ -39,7 +41,9 @@ #include "ovsdb/transaction.h" #include "ovsdb/trigger.h" #include "poll-loop.h" +#include "stream.h" #include "svec.h" +#include "tests/idltest.h" #include "timeval.h" #include "util.h" #include "vlog.h" @@ -64,6 +68,7 @@ static void parse_options(int argc, char *argv[]) { static struct option long_options[] = { + {"timeout", required_argument, 0, 't'}, {"verbose", optional_argument, 0, 'v'}, {"help", no_argument, 0, 'h'}, {0, 0, 0, 0}, @@ -71,12 +76,25 @@ parse_options(int argc, char *argv[]) char *short_options = long_options_to_short_options(long_options); for (;;) { - int c = getopt_long(argc, argv, short_options, long_options, NULL); + unsigned long int timeout; + int c; + + c = getopt_long(argc, argv, short_options, long_options, NULL); if (c == -1) { break; } switch (c) { + case 't': + timeout = strtoul(optarg, NULL, 10); + if (timeout <= 0) { + ovs_fatal(0, "value %s on -t or --timeout is not at least 1", + optarg); + } else { + time_alarm(timeout); + } + break; + case 'h': usage(); @@ -144,10 +162,16 @@ usage(void) " executes each TRANSACTION on an initially empty database\n" " the specified SCHEMA. A TRANSACTION of the form\n" " [\"advance\", NUMBER] advances NUMBER milliseconds in\n" - " simulated time, for causing triggers to time out.\n", + " simulated time, for causing triggers to time out.\n" + " idl SERVER [TRANSACTION...]\n" + " connect to SERVER and dump the contents of the database\n" + " as seen initially by the IDL implementation and after\n" + " executing each TRANSACTION. (Each TRANSACTION must modify\n" + " the database or this command will hang.)\n", program_name, program_name); vlog_usage(); printf("\nOther options:\n" + " -t, --timeout=SECS give up after SECS seconds\n" " -h, --help display this help message\n"); exit(EXIT_SUCCESS); } @@ -1207,6 +1231,326 @@ do_transact(int argc, char *argv[]) ovsdb_destroy(do_transact_db); /* Also destroys 'schema'. */ } +static int +compare_link1(const void *a_, const void *b_) +{ + const struct idltest_link1 *const *ap = a_; + const struct idltest_link1 *const *bp = b_; + const struct idltest_link1 *a = *ap; + const struct idltest_link1 *b = *bp; + + return a->i < b->i ? -1 : a->i > b->i; +} + +static void +print_idl(struct ovsdb_idl *idl, int step) +{ + const struct idltest_simple *s; + const struct idltest_link1 *l1; + const struct idltest_link2 *l2; + int n = 0; + + IDLTEST_SIMPLE_FOR_EACH (s, idl) { + size_t i; + + printf("%03d: i=%"PRId64" r=%g b=%s s=%s u="UUID_FMT" ia=[", + step, s->i, s->r, s->b ? "true" : "false", + s->s, UUID_ARGS(&s->u)); + for (i = 0; i < s->n_ia; i++) { + printf("%s%"PRId64, i ? " " : "", s->ia[i]); + } + printf("] ra=["); + for (i = 0; i < s->n_ra; i++) { + printf("%s%g", i ? " " : "", s->ra[i]); + } + printf("] ba=["); + for (i = 0; i < s->n_ba; i++) { + printf("%s%s", i ? " " : "", s->ba[i] ? "true" : "false"); + } + printf("] sa=["); + for (i = 0; i < s->n_sa; i++) { + printf("%s%s", i ? " " : "", s->sa[i]); + } + printf("] ua=["); + for (i = 0; i < s->n_ua; i++) { + printf("%s"UUID_FMT, i ? " " : "", UUID_ARGS(&s->ua[i])); + } + printf("] uuid="UUID_FMT"\n", UUID_ARGS(&s->header_.uuid)); + n++; + } + IDLTEST_LINK1_FOR_EACH (l1, idl) { + struct idltest_link1 **links; + size_t i; + + printf("%03d: i=%"PRId64" k=", step, l1->i); + if (l1->k) { + printf("%"PRId64, l1->k->i); + } + printf(" ka=["); + links = xmemdup(l1->ka, l1->n_ka * sizeof *l1->ka); + qsort(links, l1->n_ka, sizeof *links, compare_link1); + for (i = 0; i < l1->n_ka; i++) { + printf("%s%"PRId64, i ? " " : "", links[i]->i); + } + free(links); + printf("] l2="); + if (l1->l2) { + printf("%"PRId64, l1->l2->i); + } + printf(" uuid="UUID_FMT"\n", UUID_ARGS(&l1->header_.uuid)); + n++; + } + IDLTEST_LINK2_FOR_EACH (l2, idl) { + printf("%03d: i=%"PRId64" l1=", step, l2->i); + if (l2->l1) { + printf("%"PRId64, l2->l1->i); + } + printf(" uuid="UUID_FMT"\n", UUID_ARGS(&l2->header_.uuid)); + n++; + } + if (!n) { + printf("%03d: empty\n", step); + } +} + +static unsigned int +print_updated_idl(struct ovsdb_idl *idl, struct jsonrpc *rpc, + int step, unsigned int seqno) +{ + for (;;) { + unsigned int new_seqno; + + if (rpc) { + jsonrpc_run(rpc); + } + ovsdb_idl_run(idl); + new_seqno = ovsdb_idl_get_seqno(idl); + if (new_seqno != seqno) { + print_idl(idl, step); + return new_seqno; + } + + if (rpc) { + jsonrpc_wait(rpc); + } + ovsdb_idl_wait(idl); + poll_block(); + } +} + +static void +parse_uuids(const struct json *json, struct ovsdb_symbol_table *symtab, + size_t *n) +{ + struct uuid uuid; + + if (json->type == JSON_STRING && uuid_from_string(&uuid, json->u.string)) { + char *name = xasprintf("#%d#", *n); + fprintf(stderr, "%s = "UUID_FMT"\n", name, UUID_ARGS(&uuid)); + ovsdb_symbol_table_put(symtab, name, &uuid, false); + free(name); + *n += 1; + } else if (json->type == JSON_ARRAY) { + size_t i; + + for (i = 0; i < json->u.array.n; i++) { + parse_uuids(json->u.array.elems[i], symtab, n); + } + } else if (json->type == JSON_OBJECT) { + const struct shash_node *node; + + SHASH_FOR_EACH (node, json_object(json)) { + parse_uuids(node->data, symtab, n); + } + } +} + +static void +substitute_uuids(struct json *json, const struct ovsdb_symbol_table *symtab) +{ + if (json->type == JSON_STRING) { + const struct ovsdb_symbol *symbol; + + symbol = ovsdb_symbol_table_get(symtab, json->u.string); + if (symbol) { + free(json->u.string); + json->u.string = xasprintf(UUID_FMT, UUID_ARGS(&symbol->uuid)); + } + } else if (json->type == JSON_ARRAY) { + size_t i; + + for (i = 0; i < json->u.array.n; i++) { + substitute_uuids(json->u.array.elems[i], symtab); + } + } else if (json->type == JSON_OBJECT) { + const struct shash_node *node; + + SHASH_FOR_EACH (node, json_object(json)) { + substitute_uuids(node->data, symtab); + } + } +} + +static const struct idltest_simple * +idltest_find_simple(struct ovsdb_idl *idl, int i) +{ + const struct idltest_simple *s; + + IDLTEST_SIMPLE_FOR_EACH (s, idl) { + if (s->i == i) { + return s; + } + } + return NULL; +} + +static void +idl_set(struct ovsdb_idl *idl, char *commands, int step) +{ + char *cmd, *save_ptr1 = NULL; + struct ovsdb_idl_txn *txn; + enum ovsdb_idl_txn_status status; + + txn = ovsdb_idl_txn_create(idl); + for (cmd = strtok_r(commands, ",", &save_ptr1); cmd; + cmd = strtok_r(NULL, ",", &save_ptr1)) { + char *save_ptr2 = NULL; + char *name, *arg1, *arg2, *arg3; + + name = strtok_r(cmd, " ", &save_ptr2); + arg1 = strtok_r(NULL, " ", &save_ptr2); + arg2 = strtok_r(NULL, " ", &save_ptr2); + arg3 = strtok_r(NULL, " ", &save_ptr2); + + if (!strcmp(name, "set")) { + const struct idltest_simple *s; + + if (!arg3) { + ovs_fatal(0, "\"set\" command requires 3 arguments"); + } + + s = idltest_find_simple(idl, atoi(arg1)); + if (!s) { + ovs_fatal(0, "\"set\" command asks for nonexistent " + "i=%d", atoi(arg1)); + } + + if (!strcmp(arg2, "b")) { + idltest_simple_set_b(s, atoi(arg3)); + } else if (!strcmp(arg2, "s")) { + idltest_simple_set_s(s, arg3); + } else if (!strcmp(arg2, "u")) { + struct uuid uuid; + uuid_from_string(&uuid, arg3); + idltest_simple_set_u(s, uuid); + } else if (!strcmp(arg2, "r")) { + idltest_simple_set_r(s, atof(arg3)); + } else { + ovs_fatal(0, "\"set\" command asks for unknown column %s", + arg2); + } + } else if (!strcmp(name, "insert")) { + struct idltest_simple *s; + + if (!arg1 || arg2) { + ovs_fatal(0, "\"set\" command requires 1 argument"); + } + + s = idltest_simple_insert(txn); + idltest_simple_set_i(s, atoi(arg1)); + } else if (!strcmp(name, "delete")) { + const struct idltest_simple *s; + + if (!arg1 || arg2) { + ovs_fatal(0, "\"set\" command requires 1 argument"); + } + + s = idltest_find_simple(idl, atoi(arg1)); + if (!s) { + ovs_fatal(0, "\"set\" command asks for nonexistent " + "i=%d", atoi(arg1)); + } + idltest_simple_delete(s); + } else { + ovs_fatal(0, "unknown command %s", name); + } + } + + while ((status = ovsdb_idl_txn_commit(txn)) == TXN_INCOMPLETE) { + ovsdb_idl_run(idl); + ovsdb_idl_wait(idl); + ovsdb_idl_txn_wait(txn); + poll_block(); + } + printf("%03d: commit, status=%s\n", + step, ovsdb_idl_txn_status_to_string(status)); + ovsdb_idl_txn_destroy(txn); +} + +static void +do_idl(int argc, char *argv[]) +{ + struct jsonrpc *rpc; + struct ovsdb_idl *idl; + unsigned int seqno = 0; + struct ovsdb_symbol_table *symtab; + size_t n_uuids = 0; + int step = 0; + int error; + int i; + + idl = ovsdb_idl_create(argv[1], &idltest_idl_class); + if (argc > 2) { + struct stream *stream; + + error = stream_open_block(argv[1], &stream); + if (error) { + ovs_fatal(error, "failed to connect to \"%s\"", argv[1]); + } + rpc = jsonrpc_open(stream); + } else { + rpc = NULL; + } + + symtab = ovsdb_symbol_table_create(); + for (i = 2; i < argc; i++) { + struct jsonrpc_msg *request, *reply; + int error; + + seqno = print_updated_idl(idl, rpc, step++, seqno); + + if (!strcmp(argv[i], "reconnect")) { + printf("%03d: reconnect\n", step++); + ovsdb_idl_force_reconnect(idl); + } else if (argv[i][0] != '[') { + idl_set(idl, argv[i], step++); + } else { + struct json *json = parse_json(argv[i]); + substitute_uuids(json, symtab); + request = jsonrpc_create_request("transact", json, NULL); + error = jsonrpc_transact_block(rpc, request, &reply); + if (error) { + ovs_fatal(error, "jsonrpc transaction failed"); + } + printf("%03d: ", step++); + if (reply->result) { + parse_uuids(reply->result, symtab, &n_uuids); + } + json_destroy(reply->id); + reply->id = NULL; + print_and_free_json(jsonrpc_msg_to_json(reply)); + } + } + ovsdb_symbol_table_destroy(symtab); + + if (rpc) { + jsonrpc_close(rpc); + } + print_updated_idl(idl, NULL, step++, seqno); + ovsdb_idl_destroy(idl); + printf("%03d: done\n", step); +} + static struct command all_commands[] = { { "log-io", 2, INT_MAX, do_log_io }, { "parse-atomic-type", 1, 1, do_parse_atomic_type }, @@ -1225,6 +1569,7 @@ static struct command all_commands[] = { { "transact", 1, INT_MAX, do_transact }, { "execute", 2, INT_MAX, do_execute }, { "trigger", 2, INT_MAX, do_trigger }, + { "idl", 1, INT_MAX, do_idl }, { "help", 0, INT_MAX, do_help }, { NULL, 0, 0, NULL }, };