python: Implement write support in Python IDL for OVSDB.
[openvswitch] / ovsdb / ovsdb-client.c
1 /*
2  * Copyright (c) 2009, 2010, 2011 Nicira Networks.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <config.h>
18
19 #include <assert.h>
20 #include <ctype.h>
21 #include <errno.h>
22 #include <getopt.h>
23 #include <limits.h>
24 #include <signal.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <unistd.h>
28
29 #include "command-line.h"
30 #include "column.h"
31 #include "compiler.h"
32 #include "daemon.h"
33 #include "dirs.h"
34 #include "dynamic-string.h"
35 #include "json.h"
36 #include "jsonrpc.h"
37 #include "lib/table.h"
38 #include "ovsdb.h"
39 #include "ovsdb-data.h"
40 #include "ovsdb-error.h"
41 #include "sort.h"
42 #include "sset.h"
43 #include "stream.h"
44 #include "stream-ssl.h"
45 #include "table.h"
46 #include "timeval.h"
47 #include "util.h"
48 #include "vlog.h"
49
50 VLOG_DEFINE_THIS_MODULE(ovsdb_client);
51
52 enum args_needed {
53     NEED_NONE,            /* No JSON-RPC connection or database name needed. */
54     NEED_RPC,             /* JSON-RPC connection needed. */
55     NEED_DATABASE         /* JSON-RPC connection and database name needed. */
56 };
57
58 struct ovsdb_client_command {
59     const char *name;
60     enum args_needed need;
61     int min_args;
62     int max_args;
63     void (*handler)(struct jsonrpc *rpc, const char *database,
64                     int argc, char *argv[]);
65 };
66
67 /* Format for table output. */
68 static struct table_style table_style = TABLE_STYLE_DEFAULT;
69
70 static const struct ovsdb_client_command all_commands[];
71
72 static void usage(void) NO_RETURN;
73 static void parse_options(int argc, char *argv[]);
74 static struct jsonrpc *open_jsonrpc(const char *server);
75 static void fetch_dbs(struct jsonrpc *, struct sset *dbs);
76
77 int
78 main(int argc, char *argv[])
79 {
80     const struct ovsdb_client_command *command;
81     const char *database;
82     struct jsonrpc *rpc;
83
84     proctitle_init(argc, argv);
85     set_program_name(argv[0]);
86     parse_options(argc, argv);
87     signal(SIGPIPE, SIG_IGN);
88
89     if (optind >= argc) {
90         ovs_fatal(0, "missing command name; use --help for help");
91     }
92
93     for (command = all_commands; ; command++) {
94         if (!command->name) {
95             VLOG_FATAL("unknown command '%s'; use --help for help",
96                        argv[optind]);
97         } else if (!strcmp(command->name, argv[optind])) {
98             break;
99         }
100     }
101     optind++;
102
103     if (command->need != NEED_NONE) {
104         if (argc - optind > command->min_args
105             && (isalpha((unsigned char) argv[optind][0])
106                 && strchr(argv[optind], ':'))) {
107             rpc = open_jsonrpc(argv[optind++]);
108         } else {
109             char *sock = xasprintf("unix:%s/db.sock", ovs_rundir());
110             rpc = open_jsonrpc(sock);
111             free(sock);
112         }
113     } else {
114         rpc = NULL;
115     }
116
117     if (command->need == NEED_DATABASE) {
118         struct sset dbs;
119
120         sset_init(&dbs);
121         fetch_dbs(rpc, &dbs);
122         if (argc - optind > command->min_args
123             && sset_contains(&dbs, argv[optind])) {
124             database = argv[optind++];
125         } else if (sset_count(&dbs) == 1) {
126             database = xstrdup(SSET_FIRST(&dbs));
127         } else if (sset_contains(&dbs, "Open_vSwitch")) {
128             database = "Open_vSwitch";
129         } else {
130             ovs_fatal(0, "no default database for `%s' command, please "
131                       "specify a database name", command->name);
132         }
133         sset_destroy(&dbs);
134     } else {
135         database = NULL;
136     }
137
138     if (argc - optind < command->min_args ||
139         argc - optind > command->max_args) {
140         VLOG_FATAL("invalid syntax for '%s' (use --help for help)",
141                     command->name);
142     }
143
144     command->handler(rpc, database, argc - optind, argv + optind);
145
146     jsonrpc_close(rpc);
147
148     if (ferror(stdout)) {
149         VLOG_FATAL("write to stdout failed");
150     }
151     if (ferror(stderr)) {
152         VLOG_FATAL("write to stderr failed");
153     }
154
155     return 0;
156 }
157
158 static void
159 parse_options(int argc, char *argv[])
160 {
161     enum {
162         OPT_BOOTSTRAP_CA_CERT = UCHAR_MAX + 1,
163         DAEMON_OPTION_ENUMS,
164         TABLE_OPTION_ENUMS
165     };
166     static struct option long_options[] = {
167         {"verbose", optional_argument, NULL, 'v'},
168         {"help", no_argument, NULL, 'h'},
169         {"version", no_argument, NULL, 'V'},
170         DAEMON_LONG_OPTIONS,
171 #ifdef HAVE_OPENSSL
172         {"bootstrap-ca-cert", required_argument, NULL, OPT_BOOTSTRAP_CA_CERT},
173         STREAM_SSL_LONG_OPTIONS,
174 #endif
175         TABLE_LONG_OPTIONS,
176         {NULL, 0, NULL, 0},
177     };
178     char *short_options = long_options_to_short_options(long_options);
179
180     for (;;) {
181         int c;
182
183         c = getopt_long(argc, argv, short_options, long_options, NULL);
184         if (c == -1) {
185             break;
186         }
187
188         switch (c) {
189         case 'h':
190             usage();
191
192         case 'V':
193             ovs_print_version(0, 0);
194             exit(EXIT_SUCCESS);
195
196         case 'v':
197             vlog_set_verbosity(optarg);
198             break;
199
200         DAEMON_OPTION_HANDLERS
201
202         TABLE_OPTION_HANDLERS(&table_style)
203
204         STREAM_SSL_OPTION_HANDLERS
205
206         case OPT_BOOTSTRAP_CA_CERT:
207             stream_ssl_set_ca_cert_file(optarg, true);
208             break;
209
210         case '?':
211             exit(EXIT_FAILURE);
212
213         case 0:
214             /* getopt_long() already set the value for us. */
215             break;
216
217         default:
218             abort();
219         }
220     }
221     free(short_options);
222 }
223
224 static void
225 usage(void)
226 {
227     printf("%s: Open vSwitch database JSON-RPC client\n"
228            "usage: %s [OPTIONS] COMMAND [ARG...]\n"
229            "\nValid commands are:\n"
230            "\n  list-dbs [SERVER]\n"
231            "    list databases available on SERVER\n"
232            "\n  get-schema [SERVER] [DATABASE]\n"
233            "    retrieve schema for DATABASE from SERVER\n"
234            "\n  get-schema-version [SERVER] [DATABASE]\n"
235            "    retrieve schema for DATABASE from SERVER and report only its\n"
236            "    version number on stdout\n"
237            "\n  list-tables [SERVER] [DATABASE]\n"
238            "    list tables for DATABASE on SERVER\n"
239            "\n  list-columns [SERVER] [DATABASE] [TABLE]\n"
240            "    list columns in TABLE (or all tables) in DATABASE on SERVER\n"
241            "\n  transact [SERVER] TRANSACTION\n"
242            "    run TRANSACTION (a JSON array of operations) on SERVER\n"
243            "    and print the results as JSON on stdout\n"
244            "\n  monitor [SERVER] [DATABASE] TABLE [COLUMN,...]...\n"
245            "    monitor contents of COLUMNs in TABLE in DATABASE on SERVER.\n"
246            "    COLUMNs may include !initial, !insert, !delete, !modify\n"
247            "    to avoid seeing the specified kinds of changes.\n"
248            "\n  dump [SERVER] [DATABASE]\n"
249            "    dump contents of DATABASE on SERVER to stdout\n"
250            "\nThe default SERVER is unix:%s/db.sock.\n"
251            "The default DATABASE is Open_vSwitch.\n",
252            program_name, program_name, ovs_rundir());
253     stream_usage("SERVER", true, true, true);
254     printf("\nOutput formatting options:\n"
255            "  -f, --format=FORMAT         set output formatting to FORMAT\n"
256            "                              (\"table\", \"html\", \"csv\", "
257            "or \"json\")\n"
258            "  --no-headings               omit table heading row\n"
259            "  --pretty                    pretty-print JSON in output");
260     daemon_usage();
261     vlog_usage();
262     printf("\nOther options:\n"
263            "  -h, --help                  display this help message\n"
264            "  -V, --version               display version information\n");
265     exit(EXIT_SUCCESS);
266 }
267 \f
268 static struct json *
269 parse_json(const char *s)
270 {
271     struct json *json = json_from_string(s);
272     if (json->type == JSON_STRING) {
273         ovs_fatal(0, "\"%s\": %s", s, json->u.string);
274     }
275     return json;
276 }
277
278 static struct jsonrpc *
279 open_jsonrpc(const char *server)
280 {
281     struct stream *stream;
282     int error;
283
284     error = stream_open_block(jsonrpc_stream_open(server, &stream), &stream);
285     if (error == EAFNOSUPPORT) {
286         struct pstream *pstream;
287
288         error = jsonrpc_pstream_open(server, &pstream);
289         if (error) {
290             ovs_fatal(error, "failed to connect or listen to \"%s\"", server);
291         }
292
293         VLOG_INFO("%s: waiting for connection...", server);
294         error = pstream_accept_block(pstream, &stream);
295         if (error) {
296             ovs_fatal(error, "failed to accept connection on \"%s\"", server);
297         }
298
299         pstream_close(pstream);
300     } else if (error) {
301         ovs_fatal(error, "failed to connect to \"%s\"", server);
302     }
303
304     return jsonrpc_open(stream);
305 }
306
307 static void
308 print_json(struct json *json)
309 {
310     char *string = json_to_string(json, table_style.json_flags);
311     fputs(string, stdout);
312     free(string);
313 }
314
315 static void
316 print_and_free_json(struct json *json)
317 {
318     print_json(json);
319     json_destroy(json);
320 }
321
322 static void
323 check_ovsdb_error(struct ovsdb_error *error)
324 {
325     if (error) {
326         ovs_fatal(0, "%s", ovsdb_error_to_string(error));
327     }
328 }
329
330 static struct ovsdb_schema *
331 fetch_schema(struct jsonrpc *rpc, const char *database)
332 {
333     struct jsonrpc_msg *request, *reply;
334     struct ovsdb_schema *schema;
335     int error;
336
337     request = jsonrpc_create_request("get_schema",
338                                      json_array_create_1(
339                                          json_string_create(database)),
340                                      NULL);
341     error = jsonrpc_transact_block(rpc, request, &reply);
342     if (error) {
343         ovs_fatal(error, "transaction failed");
344     }
345     check_ovsdb_error(ovsdb_schema_from_json(reply->result, &schema));
346     jsonrpc_msg_destroy(reply);
347
348     return schema;
349 }
350
351 static void
352 fetch_dbs(struct jsonrpc *rpc, struct sset *dbs)
353 {
354     struct jsonrpc_msg *request, *reply;
355     int error;
356     size_t i;
357
358     request = jsonrpc_create_request("list_dbs", json_array_create_empty(),
359                                      NULL);
360     error = jsonrpc_transact_block(rpc, request, &reply);
361     if (error) {
362         ovs_fatal(error, "transaction failed");
363     }
364
365     if (reply->result->type != JSON_ARRAY) {
366         ovs_fatal(0, "list_dbs response is not array");
367     }
368
369     for (i = 0; i < reply->result->u.array.n; i++) {
370         const struct json *name = reply->result->u.array.elems[i];
371
372         if (name->type != JSON_STRING) {
373             ovs_fatal(0, "list_dbs response %zu is not string", i);
374         }
375         sset_add(dbs, name->u.string);
376     }
377     jsonrpc_msg_destroy(reply);
378 }
379 \f
380 static void
381 do_list_dbs(struct jsonrpc *rpc, const char *database OVS_UNUSED,
382             int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
383 {
384     const char *db_name;
385     struct sset dbs;
386
387     sset_init(&dbs);
388     fetch_dbs(rpc, &dbs);
389     SSET_FOR_EACH (db_name, &dbs) {
390         puts(db_name);
391     }
392     sset_destroy(&dbs);
393 }
394
395 static void
396 do_get_schema(struct jsonrpc *rpc, const char *database,
397               int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
398 {
399     struct ovsdb_schema *schema = fetch_schema(rpc, database);
400     print_and_free_json(ovsdb_schema_to_json(schema));
401     ovsdb_schema_destroy(schema);
402 }
403
404 static void
405 do_get_schema_version(struct jsonrpc *rpc, const char *database,
406                       int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
407 {
408     struct ovsdb_schema *schema = fetch_schema(rpc, database);
409     puts(schema->version);
410     ovsdb_schema_destroy(schema);
411 }
412
413 static void
414 do_list_tables(struct jsonrpc *rpc, const char *database,
415                int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
416 {
417     struct ovsdb_schema *schema;
418     struct shash_node *node;
419     struct table t;
420
421     schema = fetch_schema(rpc, database);
422     table_init(&t);
423     table_add_column(&t, "Table");
424     SHASH_FOR_EACH (node, &schema->tables) {
425         struct ovsdb_table_schema *ts = node->data;
426
427         table_add_row(&t);
428         table_add_cell(&t)->text = xstrdup(ts->name);
429     }
430     ovsdb_schema_destroy(schema);
431     table_print(&t, &table_style);
432 }
433
434 static void
435 do_list_columns(struct jsonrpc *rpc, const char *database,
436                 int argc OVS_UNUSED, char *argv[])
437 {
438     const char *table_name = argv[0];
439     struct ovsdb_schema *schema;
440     struct shash_node *table_node;
441     struct table t;
442
443     schema = fetch_schema(rpc, database);
444     table_init(&t);
445     if (!table_name) {
446         table_add_column(&t, "Table");
447     }
448     table_add_column(&t, "Column");
449     table_add_column(&t, "Type");
450     SHASH_FOR_EACH (table_node, &schema->tables) {
451         struct ovsdb_table_schema *ts = table_node->data;
452
453         if (!table_name || !strcmp(table_name, ts->name)) {
454             struct shash_node *column_node;
455
456             SHASH_FOR_EACH (column_node, &ts->columns) {
457                 const struct ovsdb_column *column = column_node->data;
458
459                 table_add_row(&t);
460                 if (!table_name) {
461                     table_add_cell(&t)->text = xstrdup(ts->name);
462                 }
463                 table_add_cell(&t)->text = xstrdup(column->name);
464                 table_add_cell(&t)->json = ovsdb_type_to_json(&column->type);
465             }
466         }
467     }
468     ovsdb_schema_destroy(schema);
469     table_print(&t, &table_style);
470 }
471
472 static void
473 do_transact(struct jsonrpc *rpc, const char *database OVS_UNUSED,
474             int argc OVS_UNUSED, char *argv[])
475 {
476     struct jsonrpc_msg *request, *reply;
477     struct json *transaction;
478     int error;
479
480     transaction = parse_json(argv[0]);
481
482     request = jsonrpc_create_request("transact", transaction, NULL);
483     error = jsonrpc_transact_block(rpc, request, &reply);
484     if (error) {
485         ovs_fatal(error, "transaction failed");
486     }
487     if (reply->error) {
488         ovs_fatal(error, "transaction returned error: %s",
489                   json_to_string(reply->error, table_style.json_flags));
490     }
491     print_json(reply->result);
492     putchar('\n');
493     jsonrpc_msg_destroy(reply);
494 }
495
496 static void
497 monitor_print_row(struct json *row, const char *type, const char *uuid,
498                   const struct ovsdb_column_set *columns, struct table *t)
499 {
500     size_t i;
501
502     if (!row) {
503         ovs_error(0, "missing %s row", type);
504         return;
505     } else if (row->type != JSON_OBJECT) {
506         ovs_error(0, "<row> is not object");
507         return;
508     }
509
510     table_add_row(t);
511     table_add_cell(t)->text = xstrdup(uuid);
512     table_add_cell(t)->text = xstrdup(type);
513     for (i = 0; i < columns->n_columns; i++) {
514         const struct ovsdb_column *column = columns->columns[i];
515         struct json *value = shash_find_data(json_object(row), column->name);
516         struct cell *cell = table_add_cell(t);
517         if (value) {
518             cell->json = json_clone(value);
519             cell->type = &column->type;
520         }
521     }
522 }
523
524 static void
525 monitor_print(struct json *table_updates,
526               const struct ovsdb_table_schema *table,
527               const struct ovsdb_column_set *columns, bool initial)
528 {
529     struct json *table_update;
530     struct shash_node *node;
531     struct table t;
532     size_t i;
533
534     table_init(&t);
535
536     if (table_updates->type != JSON_OBJECT) {
537         ovs_error(0, "<table-updates> is not object");
538         return;
539     }
540     table_update = shash_find_data(json_object(table_updates), table->name);
541     if (!table_update) {
542         return;
543     }
544     if (table_update->type != JSON_OBJECT) {
545         ovs_error(0, "<table-update> is not object");
546         return;
547     }
548
549     table_add_column(&t, "row");
550     table_add_column(&t, "action");
551     for (i = 0; i < columns->n_columns; i++) {
552         table_add_column(&t, "%s", columns->columns[i]->name);
553     }
554     SHASH_FOR_EACH (node, json_object(table_update)) {
555         struct json *row_update = node->data;
556         struct json *old, *new;
557
558         if (row_update->type != JSON_OBJECT) {
559             ovs_error(0, "<row-update> is not object");
560             continue;
561         }
562         old = shash_find_data(json_object(row_update), "old");
563         new = shash_find_data(json_object(row_update), "new");
564         if (initial) {
565             monitor_print_row(new, "initial", node->name, columns, &t);
566         } else if (!old) {
567             monitor_print_row(new, "insert", node->name, columns, &t);
568         } else if (!new) {
569             monitor_print_row(old, "delete", node->name, columns, &t);
570         } else {
571             monitor_print_row(old, "old", node->name, columns, &t);
572             monitor_print_row(new, "new", "", columns, &t);
573         }
574     }
575     table_print(&t, &table_style);
576     table_destroy(&t);
577 }
578
579 static void
580 add_column(const char *server, const struct ovsdb_column *column,
581            struct ovsdb_column_set *columns, struct json *columns_json)
582 {
583     if (ovsdb_column_set_contains(columns, column->index)) {
584         ovs_fatal(0, "%s: column \"%s\" mentioned multiple times",
585                   server, column->name);
586     }
587     ovsdb_column_set_add(columns, column);
588     json_array_add(columns_json, json_string_create(column->name));
589 }
590
591 static struct json *
592 parse_monitor_columns(char *arg, const char *server, const char *database,
593                       const struct ovsdb_table_schema *table,
594                       struct ovsdb_column_set *columns)
595 {
596     bool initial, insert, delete, modify;
597     struct json *mr, *columns_json;
598     char *save_ptr = NULL;
599     char *token;
600
601     mr = json_object_create();
602     columns_json = json_array_create_empty();
603     json_object_put(mr, "columns", columns_json);
604
605     initial = insert = delete = modify = true;
606     for (token = strtok_r(arg, ",", &save_ptr); token != NULL;
607          token = strtok_r(NULL, ",", &save_ptr)) {
608         if (!strcmp(token, "!initial")) {
609             initial = false;
610         } else if (!strcmp(token, "!insert")) {
611             insert = false;
612         } else if (!strcmp(token, "!delete")) {
613             delete = false;
614         } else if (!strcmp(token, "!modify")) {
615             modify = false;
616         } else {
617             const struct ovsdb_column *column;
618
619             column = ovsdb_table_schema_get_column(table, token);
620             if (!column) {
621                 ovs_fatal(0, "%s: table \"%s\" in %s does not have a "
622                           "column named \"%s\"",
623                           server, table->name, database, token);
624             }
625             add_column(server, column, columns, columns_json);
626         }
627     }
628
629     if (columns_json->u.array.n == 0) {
630         const struct shash_node **nodes;
631         size_t i, n;
632
633         n = shash_count(&table->columns);
634         nodes = shash_sort(&table->columns);
635         for (i = 0; i < n; i++) {
636             const struct ovsdb_column *column = nodes[i]->data;
637             if (column->index != OVSDB_COL_UUID
638                 && column->index != OVSDB_COL_VERSION) {
639                 add_column(server, column, columns, columns_json);
640             }
641         }
642         free(nodes);
643
644         add_column(server, ovsdb_table_schema_get_column(table,"_version"),
645                    columns, columns_json);
646     }
647
648     if (!initial || !insert || !delete || !modify) {
649         struct json *select = json_object_create();
650         json_object_put(select, "initial", json_boolean_create(initial));
651         json_object_put(select, "insert", json_boolean_create(insert));
652         json_object_put(select, "delete", json_boolean_create(delete));
653         json_object_put(select, "modify", json_boolean_create(modify));
654         json_object_put(mr, "select", select);
655     }
656
657     return mr;
658 }
659
660 static void
661 do_monitor(struct jsonrpc *rpc, const char *database,
662            int argc, char *argv[])
663 {
664     const char *server = jsonrpc_get_name(rpc);
665     const char *table_name = argv[0];
666     struct ovsdb_column_set columns = OVSDB_COLUMN_SET_INITIALIZER;
667     struct ovsdb_table_schema *table;
668     struct ovsdb_schema *schema;
669     struct jsonrpc_msg *request;
670     struct json *monitor, *monitor_request_array,
671         *monitor_requests, *request_id;
672
673     schema = fetch_schema(rpc, database);
674     table = shash_find_data(&schema->tables, table_name);
675     if (!table) {
676         ovs_fatal(0, "%s: %s does not have a table named \"%s\"",
677                   server, database, table_name);
678     }
679
680     monitor_request_array = json_array_create_empty();
681     if (argc > 1) {
682         int i;
683
684         for (i = 1; i < argc; i++) {
685             json_array_add(
686                 monitor_request_array,
687                 parse_monitor_columns(argv[i], server, database, table,
688                                       &columns));
689         }
690     } else {
691         /* Allocate a writable empty string since parse_monitor_columns() is
692          * going to strtok() it and that's risky with literal "". */
693         char empty[] = "";
694         json_array_add(
695             monitor_request_array,
696             parse_monitor_columns(empty, server, database, table, &columns));
697     }
698
699     monitor_requests = json_object_create();
700     json_object_put(monitor_requests, table_name, monitor_request_array);
701
702     monitor = json_array_create_3(json_string_create(database),
703                                   json_null_create(), monitor_requests);
704     request = jsonrpc_create_request("monitor", monitor, NULL);
705     request_id = json_clone(request->id);
706     jsonrpc_send(rpc, request);
707     for (;;) {
708         struct jsonrpc_msg *msg;
709         int error;
710
711         error = jsonrpc_recv_block(rpc, &msg);
712         if (error) {
713             ovsdb_schema_destroy(schema);
714             ovs_fatal(error, "%s: receive failed", server);
715         }
716
717         if (msg->type == JSONRPC_REQUEST && !strcmp(msg->method, "echo")) {
718             jsonrpc_send(rpc, jsonrpc_create_reply(json_clone(msg->params),
719                                                    msg->id));
720         } else if (msg->type == JSONRPC_REPLY
721                    && json_equal(msg->id, request_id)) {
722             monitor_print(msg->result, table, &columns, true);
723             fflush(stdout);
724             if (get_detach()) {
725                 /* daemonize() closes the standard file descriptors.  We output
726                  * to stdout, so we need to save and restore STDOUT_FILENO. */
727                 int fd = dup(STDOUT_FILENO);
728                 daemonize();
729                 dup2(fd, STDOUT_FILENO);
730                 close(fd);
731             }
732         } else if (msg->type == JSONRPC_NOTIFY
733                    && !strcmp(msg->method, "update")) {
734             struct json *params = msg->params;
735             if (params->type == JSON_ARRAY
736                 && params->u.array.n == 2
737                 && params->u.array.elems[0]->type == JSON_NULL) {
738                 monitor_print(params->u.array.elems[1],
739                               table, &columns, false);
740                 fflush(stdout);
741             }
742         }
743         jsonrpc_msg_destroy(msg);
744     }
745 }
746
747 struct dump_table_aux {
748     struct ovsdb_datum **data;
749     const struct ovsdb_column **columns;
750     size_t n_columns;
751 };
752
753 static int
754 compare_data(size_t a_y, size_t b_y, size_t x,
755              const struct dump_table_aux *aux)
756 {
757     return ovsdb_datum_compare_3way(&aux->data[a_y][x],
758                                     &aux->data[b_y][x],
759                                     &aux->columns[x]->type);
760 }
761
762 static int
763 compare_rows(size_t a_y, size_t b_y, void *aux_)
764 {
765     struct dump_table_aux *aux = aux_;
766     size_t x;
767
768     /* Skip UUID columns on the first pass, since their values tend to be
769      * random and make our results less reproducible. */
770     for (x = 0; x < aux->n_columns; x++) {
771         if (aux->columns[x]->type.key.type != OVSDB_TYPE_UUID) {
772             int cmp = compare_data(a_y, b_y, x, aux);
773             if (cmp) {
774                 return cmp;
775             }
776         }
777     }
778
779     /* Use UUID columns as tie-breakers. */
780     for (x = 0; x < aux->n_columns; x++) {
781         if (aux->columns[x]->type.key.type == OVSDB_TYPE_UUID) {
782             int cmp = compare_data(a_y, b_y, x, aux);
783             if (cmp) {
784                 return cmp;
785             }
786         }
787     }
788
789     return 0;
790 }
791
792 static void
793 swap_rows(size_t a_y, size_t b_y, void *aux_)
794 {
795     struct dump_table_aux *aux = aux_;
796     struct ovsdb_datum *tmp = aux->data[a_y];
797     aux->data[a_y] = aux->data[b_y];
798     aux->data[b_y] = tmp;
799 }
800
801 static int
802 compare_columns(const void *a_, const void *b_)
803 {
804     const struct ovsdb_column *const *ap = a_;
805     const struct ovsdb_column *const *bp = b_;
806     const struct ovsdb_column *a = *ap;
807     const struct ovsdb_column *b = *bp;
808
809     return strcmp(a->name, b->name);
810 }
811
812 static void
813 dump_table(const struct ovsdb_table_schema *ts, struct json_array *rows)
814 {
815     const struct ovsdb_column **columns;
816     size_t n_columns;
817
818     struct ovsdb_datum **data;
819
820     struct dump_table_aux aux;
821     struct shash_node *node;
822     struct table t;
823     size_t x, y;
824
825     /* Sort columns by name, for reproducibility. */
826     columns = xmalloc(shash_count(&ts->columns) * sizeof *columns);
827     n_columns = 0;
828     SHASH_FOR_EACH (node, &ts->columns) {
829         struct ovsdb_column *column = node->data;
830         if (strcmp(column->name, "_version")) {
831             columns[n_columns++] = column;
832         }
833     }
834     qsort(columns, n_columns, sizeof *columns, compare_columns);
835
836     /* Extract data from table. */
837     data = xmalloc(rows->n * sizeof *data);
838     for (y = 0; y < rows->n; y++) {
839         struct shash *row;
840
841         if (rows->elems[y]->type != JSON_OBJECT) {
842             ovs_fatal(0,  "row %zu in table %s response is not a JSON object: "
843                       "%s", y, ts->name, json_to_string(rows->elems[y], 0));
844         }
845         row = json_object(rows->elems[y]);
846
847         data[y] = xmalloc(n_columns * sizeof **data);
848         for (x = 0; x < n_columns; x++) {
849             const struct json *json = shash_find_data(row, columns[x]->name);
850             if (!json) {
851                 ovs_fatal(0, "row %zu in table %s response lacks %s column",
852                           y, ts->name, columns[x]->name);
853             }
854
855             check_ovsdb_error(ovsdb_datum_from_json(&data[y][x],
856                                                     &columns[x]->type,
857                                                     json, NULL));
858         }
859     }
860
861     /* Sort rows by column values, for reproducibility. */
862     aux.data = data;
863     aux.columns = columns;
864     aux.n_columns = n_columns;
865     sort(rows->n, compare_rows, swap_rows, &aux);
866
867     /* Add column headings. */
868     table_init(&t);
869     table_set_caption(&t, xasprintf("%s table", ts->name));
870     for (x = 0; x < n_columns; x++) {
871         table_add_column(&t, "%s", columns[x]->name);
872     }
873
874     /* Print rows. */
875     for (y = 0; y < rows->n; y++) {
876         table_add_row(&t);
877         for (x = 0; x < n_columns; x++) {
878             struct cell *cell = table_add_cell(&t);
879             cell->json = ovsdb_datum_to_json(&data[y][x], &columns[x]->type);
880             cell->type = &columns[x]->type;
881         }
882     }
883     table_print(&t, &table_style);
884     table_destroy(&t);
885 }
886
887 static void
888 do_dump(struct jsonrpc *rpc, const char *database,
889         int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
890 {
891     struct jsonrpc_msg *request, *reply;
892     struct ovsdb_schema *schema;
893     struct json *transaction;
894     int error;
895
896     const struct shash_node **tables;
897     size_t n_tables;
898
899     size_t i;
900
901     schema = fetch_schema(rpc, database);
902     tables = shash_sort(&schema->tables);
903     n_tables = shash_count(&schema->tables);
904
905     /* Construct transaction to retrieve entire database. */
906     transaction = json_array_create_1(json_string_create(database));
907     for (i = 0; i < n_tables; i++) {
908         const struct ovsdb_table_schema *ts = tables[i]->data;
909         struct json *op, *columns;
910         struct shash_node *node;
911
912         columns = json_array_create_empty();
913         SHASH_FOR_EACH (node, &ts->columns) {
914             const struct ovsdb_column *column = node->data;
915
916             if (strcmp(column->name, "_version")) {
917                 json_array_add(columns, json_string_create(column->name));
918             }
919         }
920
921         op = json_object_create();
922         json_object_put_string(op, "op", "select");
923         json_object_put_string(op, "table", tables[i]->name);
924         json_object_put(op, "where", json_array_create_empty());
925         json_object_put(op, "columns", columns);
926         json_array_add(transaction, op);
927     }
928
929     /* Send request, get reply. */
930     request = jsonrpc_create_request("transact", transaction, NULL);
931     error = jsonrpc_transact_block(rpc, request, &reply);
932     if (error) {
933         ovs_fatal(error, "transaction failed");
934     }
935
936     /* Print database contents. */
937     if (reply->result->type != JSON_ARRAY
938         || reply->result->u.array.n != n_tables) {
939         ovs_fatal(0, "reply is not array of %zu elements: %s",
940                   n_tables, json_to_string(reply->result, 0));
941     }
942     for (i = 0; i < n_tables; i++) {
943         const struct ovsdb_table_schema *ts = tables[i]->data;
944         const struct json *op_result = reply->result->u.array.elems[i];
945         struct json *rows;
946
947         if (op_result->type != JSON_OBJECT
948             || !(rows = shash_find_data(json_object(op_result), "rows"))
949             || rows->type != JSON_ARRAY) {
950             ovs_fatal(0, "%s table reply is not an object with a \"rows\" "
951                       "member array: %s",
952                       ts->name, json_to_string(op_result, 0));
953         }
954
955         dump_table(ts, &rows->u.array);
956     }
957 }
958
959 static void
960 do_help(struct jsonrpc *rpc OVS_UNUSED, const char *database OVS_UNUSED,
961         int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
962 {
963     usage();
964 }
965
966 /* All command handlers (except for "help") are expected to take an optional
967  * server socket name (e.g. "unix:...") as their first argument.  The socket
968  * name argument must be included in max_args (but left out of min_args).  The
969  * command name and socket name are not included in the arguments passed to the
970  * handler: the argv[0] passed to the handler is the first argument after the
971  * optional server socket name.  The connection to the server is available as
972  * global variable 'rpc'. */
973 static const struct ovsdb_client_command all_commands[] = {
974     { "list-dbs",           NEED_RPC,      0, 0,       do_list_dbs },
975     { "get-schema",         NEED_DATABASE, 0, 0,       do_get_schema },
976     { "get-schema-version", NEED_DATABASE, 0, 0,       do_get_schema_version },
977     { "list-tables",        NEED_DATABASE, 0, 0,       do_list_tables },
978     { "list-columns",       NEED_DATABASE, 0, 1,       do_list_columns },
979     { "transact",           NEED_RPC,      1, 1,       do_transact },
980     { "monitor",            NEED_DATABASE, 1, INT_MAX, do_monitor },
981     { "dump",               NEED_DATABASE, 0, 0,       do_dump },
982
983     { "help",               NEED_NONE,     0, INT_MAX, do_help },
984
985     { NULL,                 0,             0, 0,       NULL },
986 };