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