Merge branch 'master' into next
[openvswitch] / ovsdb / ovsdb-client.c
1 /*
2  * Copyright (c) 2009, 2010 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 <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 "dynamic-string.h"
33 #include "json.h"
34 #include "jsonrpc.h"
35 #include "ovsdb.h"
36 #include "ovsdb-error.h"
37 #include "stream.h"
38 #include "stream-ssl.h"
39 #include "table.h"
40 #include "timeval.h"
41 #include "util.h"
42
43 #include "vlog.h"
44 #define THIS_MODULE VLM_ovsdb_client
45
46 /* --format: Output formatting. */
47 static enum {
48     FMT_TABLE,                  /* Textual table. */
49     FMT_HTML,                   /* HTML table. */
50     FMT_CSV                     /* Comma-separated lines. */
51 } output_format;
52
53 /* --wide: For --format=table, the maximum output width. */
54 static int output_width;
55
56 /* --no-headings: Whether table output should include headings. */
57 static int output_headings = true;
58
59 /* --pretty: Flags to pass to json_to_string(). */
60 static int json_flags = JSSF_SORT;
61
62 static const struct command all_commands[];
63
64 static void usage(void) NO_RETURN;
65 static void parse_options(int argc, char *argv[]);
66
67 int
68 main(int argc, char *argv[])
69 {
70     proctitle_init(argc, argv);
71     set_program_name(argv[0]);
72     time_init();
73     vlog_init();
74     parse_options(argc, argv);
75     signal(SIGPIPE, SIG_IGN);
76     run_command(argc - optind, argv + optind, all_commands);
77     return 0;
78 }
79
80 static void
81 parse_options(int argc, char *argv[])
82 {
83     enum {
84         OPT_BOOTSTRAP_CA_CERT = UCHAR_MAX + 1
85     };
86     static struct option long_options[] = {
87         {"wide", no_argument, &output_width, INT_MAX},
88         {"format", required_argument, 0, 'f'},
89             {"no-headings", no_argument, &output_headings, 0},
90         {"pretty", no_argument, &json_flags, JSSF_PRETTY | JSSF_SORT},
91         {"verbose", optional_argument, 0, 'v'},
92         {"help", no_argument, 0, 'h'},
93         {"version", no_argument, 0, 'V'},
94         DAEMON_LONG_OPTIONS,
95 #ifdef HAVE_OPENSSL
96         {"bootstrap-ca-cert", required_argument, 0, OPT_BOOTSTRAP_CA_CERT},
97         STREAM_SSL_LONG_OPTIONS
98 #endif
99         {0, 0, 0, 0},
100     };
101     char *short_options = long_options_to_short_options(long_options);
102
103     output_width = isatty(fileno(stdout)) ? 79 : INT_MAX;
104     for (;;) {
105         int c;
106
107         c = getopt_long(argc, argv, short_options, long_options, NULL);
108         if (c == -1) {
109             break;
110         }
111
112         switch (c) {
113         case 'f':
114             if (!strcmp(optarg, "table")) {
115                 output_format = FMT_TABLE;
116             } else if (!strcmp(optarg, "html")) {
117                 output_format = FMT_HTML;
118             } else if (!strcmp(optarg, "csv")) {
119                 output_format = FMT_CSV;
120             } else {
121                 ovs_fatal(0, "unknown output format \"%s\"", optarg);
122             }
123             break;
124
125         case 'w':
126             output_width = INT_MAX;
127             break;
128
129         case 'h':
130             usage();
131
132         case 'V':
133             OVS_PRINT_VERSION(0, 0);
134             exit(EXIT_SUCCESS);
135
136         case 'v':
137             vlog_set_verbosity(optarg);
138             break;
139
140         DAEMON_OPTION_HANDLERS
141
142 #ifdef HAVE_OPENSSL
143         STREAM_SSL_OPTION_HANDLERS
144
145         case OPT_BOOTSTRAP_CA_CERT:
146             stream_ssl_set_ca_cert_file(optarg, true);
147             break;
148 #endif
149
150         case '?':
151             exit(EXIT_FAILURE);
152
153         case 0:
154             /* getopt_long() already set the value for us. */
155             break;
156
157         default:
158             abort();
159         }
160     }
161     free(short_options);
162 }
163
164 static void
165 usage(void)
166 {
167     printf("%s: Open vSwitch database JSON-RPC client\n"
168            "usage: %s [OPTIONS] COMMAND [ARG...]\n"
169            "\nValid commands are:\n"
170            "\n  get-schema SERVER\n"
171            "    retrieve schema from SERVER\n"
172            "\n  list-tables SERVER\n"
173            "    list SERVER's tables\n"
174            "\n  list-columns SERVER [TABLE]\n"
175            "    list columns in TABLE (or all tables) on SERVER\n"
176            "\n  transact SERVER TRANSACTION\n"
177            "    run TRANSACTION (a JSON array of operations) on SERVER\n"
178            "    and print the results as JSON on stdout\n"
179            "\n  monitor SERVER TABLE [COLUMN,...] [SELECT,...]\n"
180            "    monitor contents of (COLUMNs in) TABLE on SERVER\n"
181            "    Valid SELECTs are: initial, insert, delete, modify\n",
182            program_name, program_name);
183     stream_usage("SERVER", true, true, true);
184     printf("\nOutput formatting options:\n"
185            "  -f, --format=FORMAT         set output formatting to FORMAT\n"
186            "                              (\"table\", \"html\", or \"csv\"\n"
187            "  --wide                      don't limit TTY lines to 79 bytes\n"
188            "  --no-headings               omit table heading row\n"
189            "  --pretty                    pretty-print JSON in output");
190     daemon_usage();
191     vlog_usage();
192     printf("\nOther options:\n"
193            "  -h, --help                  display this help message\n"
194            "  -V, --version               display version information\n");
195     exit(EXIT_SUCCESS);
196 }
197 \f
198 static struct json *
199 parse_json(const char *s)
200 {
201     struct json *json = json_from_string(s);
202     if (json->type == JSON_STRING) {
203         ovs_fatal(0, "\"%s\": %s", s, json->u.string);
204     }
205     return json;
206 }
207
208 static struct jsonrpc *
209 open_jsonrpc(const char *server)
210 {
211     struct stream *stream;
212     int error;
213
214     error = stream_open_block(server, &stream);
215     if (error == EAFNOSUPPORT) {
216         struct pstream *pstream;
217
218         error = pstream_open(server, &pstream);
219         if (error) {
220             ovs_fatal(error, "failed to connect or listen to \"%s\"", server);
221         }
222
223         VLOG_INFO("%s: waiting for connection...", server);
224         error = pstream_accept_block(pstream, &stream);
225         if (error) {
226             ovs_fatal(error, "failed to accept connection on \"%s\"", server);
227         }
228
229         pstream_close(pstream);
230     } else if (error) {
231         ovs_fatal(error, "failed to connect to \"%s\"", server);
232     }
233
234     return jsonrpc_open(stream);
235 }
236
237 static void
238 print_json(struct json *json)
239 {
240     char *string = json_to_string(json, json_flags);
241     fputs(string, stdout);
242     free(string);
243 }
244
245 static void
246 print_and_free_json(struct json *json)
247 {
248     print_json(json);
249     json_destroy(json);
250 }
251
252 static void
253 check_ovsdb_error(struct ovsdb_error *error)
254 {
255     if (error) {
256         ovs_fatal(0, "%s", ovsdb_error_to_string(error));
257     }
258 }
259
260 static struct ovsdb_schema *
261 fetch_schema_from_rpc(struct jsonrpc *rpc)
262 {
263     struct jsonrpc_msg *request, *reply;
264     struct ovsdb_schema *schema;
265     int error;
266
267     request = jsonrpc_create_request("get_schema", json_array_create_empty(),
268                                      NULL);
269     error = jsonrpc_transact_block(rpc, request, &reply);
270     if (error) {
271         ovs_fatal(error, "transaction failed");
272     }
273     check_ovsdb_error(ovsdb_schema_from_json(reply->result, &schema));
274     jsonrpc_msg_destroy(reply);
275
276     return schema;
277 }
278
279 static struct ovsdb_schema *
280 fetch_schema(const char *server)
281 {
282     struct ovsdb_schema *schema;
283     struct jsonrpc *rpc;
284
285     rpc = open_jsonrpc(server);
286     schema = fetch_schema_from_rpc(rpc);
287     jsonrpc_close(rpc);
288
289     return schema;
290 }
291 \f
292 struct column {
293     char *heading;
294     int width;
295 };
296
297 struct table {
298     char **cells;
299     struct column *columns;
300     size_t n_columns, allocated_columns;
301     size_t n_rows, allocated_rows;
302     size_t current_column;
303 };
304
305 static void
306 table_init(struct table *table)
307 {
308     memset(table, 0, sizeof *table);
309 }
310
311 static void
312 table_destroy(struct table *table)
313 {
314     size_t i;
315
316     for (i = 0; i < table->n_columns; i++) {
317         free(table->columns[i].heading);
318     }
319     free(table->columns);
320
321     for (i = 0; i < table->n_columns * table->n_rows; i++) {
322         free(table->cells[i]);
323     }
324     free(table->cells);
325 }
326
327 static void
328 table_add_column(struct table *table, const char *heading, ...)
329     PRINTF_FORMAT(2, 3);
330
331 static void
332 table_add_column(struct table *table, const char *heading, ...)
333 {
334     struct column *column;
335     va_list args;
336
337     assert(!table->n_rows);
338     if (table->n_columns >= table->allocated_columns) {
339         table->columns = x2nrealloc(table->columns, &table->allocated_columns,
340                                     sizeof *table->columns);
341     }
342     column = &table->columns[table->n_columns++];
343
344     va_start(args, heading);
345     column->heading = xvasprintf(heading, args);
346     column->width = strlen(column->heading);
347     va_end(args);
348 }
349
350 static char **
351 table_cell__(const struct table *table, size_t row, size_t column)
352 {
353     return &table->cells[column + row * table->n_columns];
354 }
355
356 static void
357 table_add_row(struct table *table)
358 {
359     size_t x, y;
360
361     if (table->n_rows >= table->allocated_rows) {
362         table->cells = x2nrealloc(table->cells, &table->allocated_rows,
363                                   table->n_columns * sizeof *table->cells);
364     }
365
366     y = table->n_rows++;
367     table->current_column = 0;
368     for (x = 0; x < table->n_columns; x++) {
369         *table_cell__(table, y, x) = NULL;
370     }
371 }
372
373 static void
374 table_add_cell_nocopy(struct table *table, char *s)
375 {
376     size_t x, y;
377     int length;
378
379     assert(table->n_rows > 0);
380     assert(table->current_column < table->n_columns);
381
382     x = table->current_column++;
383     y = table->n_rows - 1;
384     *table_cell__(table, y, x) = s;
385
386     length = strlen(s);
387     if (length > table->columns[x].width) {
388         table->columns[x].width = length;
389     }
390 }
391
392 static void
393 table_add_cell(struct table *table, const char *format, ...)
394 {
395     va_list args;
396
397     va_start(args, format);
398     table_add_cell_nocopy(table, xvasprintf(format, args));
399     va_end(args);
400 }
401
402 static void
403 table_print_table_line__(struct ds *line, size_t max_width)
404 {
405     ds_truncate(line, max_width);
406     puts(ds_cstr(line));
407     ds_clear(line);
408 }
409
410 static void
411 table_print_table__(const struct table *table)
412 {
413     struct ds line = DS_EMPTY_INITIALIZER;
414     size_t x, y;
415
416     if (output_headings) {
417         for (x = 0; x < table->n_columns; x++) {
418             const struct column *column = &table->columns[x];
419             if (x) {
420                 ds_put_char(&line, ' ');
421             }
422             ds_put_format(&line, "%-*s", column->width, column->heading);
423         }
424         table_print_table_line__(&line, output_width);
425
426         for (x = 0; x < table->n_columns; x++) {
427             const struct column *column = &table->columns[x];
428             int i;
429
430             if (x) {
431                 ds_put_char(&line, ' ');
432             }
433             for (i = 0; i < column->width; i++) {
434                 ds_put_char(&line, '-');
435             }
436         }
437         table_print_table_line__(&line, output_width);
438     }
439
440     for (y = 0; y < table->n_rows; y++) {
441         for (x = 0; x < table->n_columns; x++) {
442             const char *cell = *table_cell__(table, y, x);
443             if (x) {
444                 ds_put_char(&line, ' ');
445             }
446             ds_put_format(&line, "%-*s", table->columns[x].width, cell);
447         }
448         table_print_table_line__(&line, output_width);
449     }
450
451     ds_destroy(&line);
452 }
453
454 static void
455 table_print_html_cell__(const char *element, const char *content)
456 {
457     const char *p;
458
459     printf("    <%s>", element);
460     for (p = content; *p != '\0'; p++) {
461         switch (*p) {
462         case '&':
463             fputs("&amp;", stdout);
464             break;
465         case '<':
466             fputs("&lt;", stdout);
467             break;
468         case '>':
469             fputs("&gt;", stdout);
470             break;
471         default:
472             putchar(*p);
473             break;
474         }
475     }
476     printf("</%s>\n", element);
477 }
478
479 static void
480 table_print_html__(const struct table *table)
481 {
482     size_t x, y;
483
484     fputs("<table>\n", stdout);
485
486     if (output_headings) {
487         fputs("  <tr>\n", stdout);
488         for (x = 0; x < table->n_columns; x++) {
489             const struct column *column = &table->columns[x];
490             table_print_html_cell__("th", column->heading);
491         }
492         fputs("  </tr>\n", stdout);
493     }
494
495     for (y = 0; y < table->n_rows; y++) {
496         fputs("  <tr>\n", stdout);
497         for (x = 0; x < table->n_columns; x++) {
498             table_print_html_cell__("td", *table_cell__(table, y, x));
499         }
500         fputs("  </tr>\n", stdout);
501     }
502
503     fputs("</table>\n", stdout);
504 }
505
506 static void
507 table_print_csv_cell__(const char *content)
508 {
509     const char *p;
510
511     if (!strpbrk(content, "\n\",")) {
512         fputs(content, stdout);
513     } else {
514         putchar('"');
515         for (p = content; *p != '\0'; p++) {
516             switch (*p) {
517             case '"':
518                 fputs("\"\"", stdout);
519                 break;
520             default:
521                 putchar(*p);
522                 break;
523             }
524         }
525         putchar('"');
526     }
527 }
528
529 static void
530 table_print_csv__(const struct table *table)
531 {
532     size_t x, y;
533
534     if (output_headings) {
535         for (x = 0; x < table->n_columns; x++) {
536             const struct column *column = &table->columns[x];
537             if (x) {
538                 putchar(',');
539             }
540             table_print_csv_cell__(column->heading);
541         }
542         putchar('\n');
543     }
544
545     for (y = 0; y < table->n_rows; y++) {
546         for (x = 0; x < table->n_columns; x++) {
547             if (x) {
548                 putchar(',');
549             }
550             table_print_csv_cell__(*table_cell__(table, y, x));
551         }
552         putchar('\n');
553     }
554 }
555
556 static void
557 table_print(const struct table *table)
558 {
559     switch (output_format) {
560     case FMT_TABLE:
561         table_print_table__(table);
562         break;
563
564     case FMT_HTML:
565         table_print_html__(table);
566         break;
567
568     case FMT_CSV:
569         table_print_csv__(table);
570         break;
571     }
572 }
573 \f
574 static void
575 do_get_schema(int argc UNUSED, char *argv[])
576 {
577     struct ovsdb_schema *schema = fetch_schema(argv[1]);
578     print_and_free_json(ovsdb_schema_to_json(schema));
579     ovsdb_schema_destroy(schema);
580 }
581
582 static void
583 do_list_tables(int argc UNUSED, char *argv[])
584 {
585     struct ovsdb_schema *schema;
586     struct shash_node *node;
587     struct table t;
588
589     schema = fetch_schema(argv[1]);
590     table_init(&t);
591     table_add_column(&t, "Table");
592     table_add_column(&t, "Comment");
593     SHASH_FOR_EACH (node, &schema->tables) {
594         struct ovsdb_table_schema *ts = node->data;
595
596         table_add_row(&t);
597         table_add_cell(&t, ts->name);
598         if (ts->comment) {
599             table_add_cell(&t, ts->comment);
600         }
601     }
602     ovsdb_schema_destroy(schema);
603     table_print(&t);
604 }
605
606 static void
607 do_list_columns(int argc UNUSED, char *argv[])
608 {
609     const char *table_name = argv[2];
610     struct ovsdb_schema *schema;
611     struct shash_node *table_node;
612     struct table t;
613
614     schema = fetch_schema(argv[1]);
615     table_init(&t);
616     if (!table_name) {
617         table_add_column(&t, "Table");
618     }
619     table_add_column(&t, "Column");
620     table_add_column(&t, "Type");
621     table_add_column(&t, "Comment");
622     SHASH_FOR_EACH (table_node, &schema->tables) {
623         struct ovsdb_table_schema *ts = table_node->data;
624
625         if (!table_name || !strcmp(table_name, ts->name)) {
626             struct shash_node *column_node;
627
628             SHASH_FOR_EACH (column_node, &ts->columns) {
629                 struct ovsdb_column *column = column_node->data;
630                 struct json *type = ovsdb_type_to_json(&column->type);
631
632                 table_add_row(&t);
633                 if (!table_name) {
634                     table_add_cell(&t, ts->name);
635                 }
636                 table_add_cell(&t, column->name);
637                 table_add_cell_nocopy(&t, json_to_string(type, JSSF_SORT));
638                 if (column->comment) {
639                     table_add_cell(&t, column->comment);
640                 }
641
642                 json_destroy(type);
643             }
644         }
645     }
646     ovsdb_schema_destroy(schema);
647     table_print(&t);
648 }
649
650 static void
651 do_transact(int argc UNUSED, char *argv[])
652 {
653     struct jsonrpc_msg *request, *reply;
654     struct json *transaction;
655     struct jsonrpc *rpc;
656     int error;
657
658     transaction = parse_json(argv[2]);
659
660     rpc = open_jsonrpc(argv[1]);
661     request = jsonrpc_create_request("transact", transaction, NULL);
662     error = jsonrpc_transact_block(rpc, request, &reply);
663     if (error) {
664         ovs_fatal(error, "transaction failed");
665     }
666     if (reply->error) {
667         ovs_fatal(error, "transaction returned error: %s",
668                   json_to_string(reply->error, json_flags));
669     }
670     print_json(reply->result);
671     putchar('\n');
672     jsonrpc_msg_destroy(reply);
673     jsonrpc_close(rpc);
674 }
675
676 static void
677 monitor_print_row(struct json *row, const char *type, const char *uuid,
678                   const struct ovsdb_column_set *columns, struct table *t)
679 {
680     size_t i;
681
682     if (!row) {
683         ovs_error(0, "missing %s row", type);
684         return;
685     } else if (row->type != JSON_OBJECT) {
686         ovs_error(0, "<row> is not object");
687         return;
688     }
689
690     table_add_row(t);
691     table_add_cell(t, uuid);
692     table_add_cell(t, type);
693     for (i = 0; i < columns->n_columns; i++) {
694         const struct ovsdb_column *column = columns->columns[i];
695         struct json *value = shash_find_data(json_object(row), column->name);
696         if (value) {
697             table_add_cell_nocopy(t, json_to_string(value, JSSF_SORT));
698         } else {
699             table_add_cell(t, "");
700         }
701     }
702 }
703
704 static void
705 monitor_print(struct json *table_updates,
706               const struct ovsdb_table_schema *table,
707               const struct ovsdb_column_set *columns, bool initial)
708 {
709     struct json *table_update;
710     struct shash_node *node;
711     struct table t;
712     size_t i;
713
714     table_init(&t);
715
716     if (table_updates->type != JSON_OBJECT) {
717         ovs_error(0, "<table-updates> is not object");
718         return;
719     }
720     table_update = shash_find_data(json_object(table_updates), table->name);
721     if (!table_update) {
722         return;
723     }
724     if (table_update->type != JSON_OBJECT) {
725         ovs_error(0, "<table-update> is not object");
726         return;
727     }
728
729     table_add_column(&t, "row");
730     table_add_column(&t, "action");
731     for (i = 0; i < columns->n_columns; i++) {
732         table_add_column(&t, "%s", columns->columns[i]->name);
733     }
734     SHASH_FOR_EACH (node, json_object(table_update)) {
735         struct json *row_update = node->data;
736         struct json *old, *new;
737
738         if (row_update->type != JSON_OBJECT) {
739             ovs_error(0, "<row-update> is not object");
740             continue;
741         }
742         old = shash_find_data(json_object(row_update), "old");
743         new = shash_find_data(json_object(row_update), "new");
744         if (initial) {
745             monitor_print_row(new, "initial", node->name, columns, &t);
746         } else if (!old) {
747             monitor_print_row(new, "insert", node->name, columns, &t);
748         } else if (!new) {
749             monitor_print_row(old, "delete", node->name, columns, &t);
750         } else {
751             monitor_print_row(old, "old", node->name, columns, &t);
752             monitor_print_row(new, "new", "", columns, &t);
753         }
754     }
755     table_print(&t);
756     table_destroy(&t);
757 }
758
759 static void
760 do_monitor(int argc, char *argv[])
761 {
762     struct ovsdb_column_set columns = OVSDB_COLUMN_SET_INITIALIZER;
763     struct ovsdb_table_schema *table;
764     struct ovsdb_schema *schema;
765     struct jsonrpc_msg *request;
766     struct jsonrpc *rpc;
767     struct json *select, *monitor, *monitor_request, *monitor_requests,
768         *request_id;
769
770     rpc = open_jsonrpc(argv[1]);
771
772     schema = fetch_schema_from_rpc(rpc);
773     table = shash_find_data(&schema->tables, argv[2]);
774     if (!table) {
775         ovs_fatal(0, "%s: no table named \"%s\"", argv[1], argv[2]);
776     }
777
778     if (argc >= 4 && *argv[3] != '\0') {
779         char *save_ptr = NULL;
780         char *token;
781
782         for (token = strtok_r(argv[3], ",", &save_ptr); token != NULL;
783              token = strtok_r(NULL, ",", &save_ptr)) {
784             const struct ovsdb_column *column;
785             column = ovsdb_table_schema_get_column(table, token);
786             if (!column) {
787                 ovs_fatal(0, "%s: table \"%s\" does not have a "
788                           "column named \"%s\"", argv[1], argv[2], token);
789             }
790             ovsdb_column_set_add(&columns, column);
791         }
792     } else {
793         struct shash_node *node;
794
795         SHASH_FOR_EACH (node, &table->columns) {
796             const struct ovsdb_column *column = node->data;
797             if (column->index != OVSDB_COL_UUID) {
798                 ovsdb_column_set_add(&columns, column);
799             }
800         }
801     }
802
803     if (argc >= 5 && *argv[4] != '\0') {
804         char *save_ptr = NULL;
805         char *token;
806
807         select = json_object_create();
808         for (token = strtok_r(argv[4], ",", &save_ptr); token != NULL;
809              token = strtok_r(NULL, ",", &save_ptr)) {
810             json_object_put(select, token, json_boolean_create(true));
811         }
812     } else {
813         select = NULL;
814     }
815
816     monitor_request = json_object_create();
817     json_object_put(monitor_request,
818                     "columns", ovsdb_column_set_to_json(&columns));
819     if (select) {
820         json_object_put(monitor_request, "select", select);
821     }
822
823     monitor_requests = json_object_create();
824     json_object_put(monitor_requests, argv[2], monitor_request);
825
826     monitor = json_array_create_2(json_null_create(), monitor_requests);
827     request = jsonrpc_create_request("monitor", monitor, NULL);
828     request_id = json_clone(request->id);
829     jsonrpc_send(rpc, request);
830     for (;;) {
831         struct jsonrpc_msg *msg;
832         int error;
833
834         error = jsonrpc_recv_block(rpc, &msg);
835         if (error) {
836             ovsdb_schema_destroy(schema);
837             ovs_fatal(error, "%s: receive failed", argv[1]);
838         }
839
840         if (msg->type == JSONRPC_REQUEST && !strcmp(msg->method, "echo")) {
841             jsonrpc_send(rpc, jsonrpc_create_reply(json_clone(msg->params),
842                                                    msg->id));
843         } else if (msg->type == JSONRPC_REPLY
844                    && json_equal(msg->id, request_id)) {
845             monitor_print(msg->result, table, &columns, true);
846             fflush(stdout);
847             if (get_detach()) {
848                 /* daemonize() closes the standard file descriptors.  We output
849                  * to stdout, so we need to save and restore STDOUT_FILENO. */
850                 int fd = dup(STDOUT_FILENO);
851                 daemonize();
852                 dup2(fd, STDOUT_FILENO);
853                 close(fd);
854             }
855         } else if (msg->type == JSONRPC_NOTIFY
856                    && !strcmp(msg->method, "update")) {
857             struct json *params = msg->params;
858             if (params->type == JSON_ARRAY
859                 && params->u.array.n == 2
860                 && params->u.array.elems[0]->type == JSON_NULL) {
861                 monitor_print(params->u.array.elems[1],
862                               table, &columns, false);
863                 fflush(stdout);
864             }
865         }
866         jsonrpc_msg_destroy(msg);
867     }
868 }
869
870 static void
871 do_help(int argc UNUSED, char *argv[] UNUSED)
872 {
873     usage();
874 }
875
876 static const struct command all_commands[] = {
877     { "get-schema", 1, 1, do_get_schema },
878     { "list-tables", 1, 1, do_list_tables },
879     { "list-columns", 1, 2, do_list_columns },
880     { "transact", 2, 2, do_transact },
881     { "monitor", 2, 4, do_monitor },
882     { "help", 0, INT_MAX, do_help },
883     { NULL, 0, 0, NULL },
884 };