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 };