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