/*
- * Copyright (c) 2009, 2010 Nicira Networks.
+ * Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include <stdlib.h>
#include <string.h>
+#include "column.h"
#include "command-line.h"
#include "compiler.h"
+#include "dirs.h"
+#include "dynamic-string.h"
+#include "fatal-signal.h"
#include "file.h"
+#include "lockfile.h"
#include "log.h"
#include "json.h"
#include "ovsdb.h"
+#include "ovsdb-data.h"
#include "ovsdb-error.h"
+#include "socket-util.h"
#include "table.h"
#include "timeval.h"
#include "util.h"
-
#include "vlog.h"
-#define THIS_MODULE VLM_ovsdb_tool
/* -m, --more: Verbosity level for "show-log" command output. */
static int show_log_verbosity;
-static const struct command all_commands[];
+static const struct command *get_all_commands(void);
static void usage(void) NO_RETURN;
static void parse_options(int argc, char *argv[]);
+static const char *default_db(void);
+static const char *default_schema(void);
+
int
main(int argc, char *argv[])
{
set_program_name(argv[0]);
- time_init();
- vlog_init();
parse_options(argc, argv);
- signal(SIGPIPE, SIG_IGN);
- run_command(argc - optind, argv + optind, all_commands);
+ fatal_ignore_sigpipe();
+ run_command(argc - optind, argv + optind, get_all_commands());
return 0;
}
static void
parse_options(int argc, char *argv[])
{
- static struct option long_options[] = {
- {"more", no_argument, 0, 'm'},
- {"verbose", optional_argument, 0, 'v'},
- {"help", no_argument, 0, 'h'},
- {"version", no_argument, 0, 'V'},
- {0, 0, 0, 0},
+ static const struct option long_options[] = {
+ {"more", no_argument, NULL, 'm'},
+ {"verbose", optional_argument, NULL, 'v'},
+ {"help", no_argument, NULL, 'h'},
+ {"version", no_argument, NULL, 'V'},
+ {NULL, 0, NULL, 0},
};
char *short_options = long_options_to_short_options(long_options);
usage();
case 'V':
- OVS_PRINT_VERSION(0, 0);
+ ovs_print_version(0, 0);
exit(EXIT_SUCCESS);
case 'v':
{
printf("%s: Open vSwitch database management utility\n"
"usage: %s [OPTIONS] COMMAND [ARG...]\n"
- " create DB SCHEMA create DB with the given SCHEMA\n"
- " compact DB [DST] compact DB in-place (or to DST)\n"
- " extract-schema DB print DB's schema on stdout\n"
- " query DB TRNS execute read-only transaction on DB\n"
- " transact DB TRNS execute read/write transaction on DB\n"
- " show-log DB prints information about DB's log entries\n",
- program_name, program_name);
+ " create [DB [SCHEMA]] create DB with the given SCHEMA\n"
+ " compact [DB [DST]] compact DB in-place (or to DST)\n"
+ " convert [DB [SCHEMA [DST]]] convert DB to SCHEMA (to DST)\n"
+ " db-version [DB] report version of schema used by DB\n"
+ " db-cksum [DB] report checksum of schema used by DB\n"
+ " schema-version [SCHEMA] report SCHEMA's schema version\n"
+ " schema-cksum [SCHEMA] report SCHEMA's checksum\n"
+ " query [DB] TRNS execute read-only transaction on DB\n"
+ " transact [DB] TRNS execute read/write transaction on DB\n"
+ " [-m]... show-log [DB] print DB's log entries\n"
+ "The default DB is %s.\n"
+ "The default SCHEMA is %s.\n",
+ program_name, program_name, default_db(), default_schema());
vlog_usage();
printf("\nOther options:\n"
" -m, --more increase show-log verbosity\n"
" -V, --version display version information\n");
exit(EXIT_SUCCESS);
}
+
+static const char *
+default_db(void)
+{
+ static char *db;
+ if (!db) {
+ db = xasprintf("%s/conf.db", ovs_dbdir());
+ }
+ return db;
+}
+
+static const char *
+default_schema(void)
+{
+ static char *schema;
+ if (!schema) {
+ schema = xasprintf("%s/vswitch.ovsschema", ovs_pkgdatadir());
+ }
+ return schema;
+}
\f
static struct json *
parse_json(const char *s)
}
\f
static void
-do_create(int argc UNUSED, char *argv[])
+do_create(int argc, char *argv[])
{
- const char *db_file_name = argv[1];
- const char *schema_file_name = argv[2];
+ const char *db_file_name = argc >= 2 ? argv[1] : default_db();
+ const char *schema_file_name = argc >= 3 ? argv[2] : default_schema();
struct ovsdb_schema *schema;
struct ovsdb_log *log;
struct json *json;
ovsdb_schema_destroy(schema);
/* Create database file. */
- check_ovsdb_error(ovsdb_log_open(db_file_name, O_RDWR | O_CREAT | O_EXCL,
- &log));
+ check_ovsdb_error(ovsdb_log_open(db_file_name, OVSDB_LOG_CREATE,
+ -1, &log));
check_ovsdb_error(ovsdb_log_write(log, json));
check_ovsdb_error(ovsdb_log_commit(log));
ovsdb_log_close(log);
}
static void
-transact(bool read_only, const char *db_file_name, const char *transaction)
+compact_or_convert(const char *src_name_, const char *dst_name_,
+ const struct ovsdb_schema *new_schema,
+ const char *comment)
+{
+ char *src_name, *dst_name;
+ struct lockfile *src_lock;
+ struct lockfile *dst_lock;
+ bool in_place = dst_name_ == NULL;
+ struct ovsdb *db;
+ int retval;
+
+ /* Dereference symlinks for source and destination names. In the in-place
+ * case this ensures that, if the source name is a symlink, we replace its
+ * target instead of replacing the symlink by a regular file. In the
+ * non-in-place, this has the same effect for the destination name. */
+ src_name = follow_symlinks(src_name_);
+ dst_name = (in_place
+ ? xasprintf("%s.tmp", src_name)
+ : follow_symlinks(dst_name_));
+
+ /* Lock the source, if we will be replacing it. */
+ if (in_place) {
+ retval = lockfile_lock(src_name, &src_lock);
+ if (retval) {
+ ovs_fatal(retval, "%s: failed to lock lockfile", src_name);
+ }
+ }
+
+ /* Get (temporary) destination and lock it. */
+ retval = lockfile_lock(dst_name, &dst_lock);
+ if (retval) {
+ ovs_fatal(retval, "%s: failed to lock lockfile", dst_name);
+ }
+
+ /* Save a copy. */
+ check_ovsdb_error(new_schema
+ ? ovsdb_file_open_as_schema(src_name, new_schema, &db)
+ : ovsdb_file_open(src_name, true, &db, NULL));
+ check_ovsdb_error(ovsdb_file_save_copy(dst_name, false, comment, db));
+ ovsdb_destroy(db);
+
+ /* Replace source. */
+ if (in_place) {
+ if (rename(dst_name, src_name)) {
+ ovs_fatal(errno, "failed to rename \"%s\" to \"%s\"",
+ dst_name, src_name);
+ }
+ fsync_parent_dir(dst_name);
+ lockfile_unlock(src_lock);
+ }
+
+ lockfile_unlock(dst_lock);
+
+ free(src_name);
+ free(dst_name);
+}
+
+static void
+do_compact(int argc, char *argv[])
+{
+ const char *db = argc >= 2 ? argv[1] : default_db();
+ const char *target = argc >= 3 ? argv[2] : NULL;
+
+ compact_or_convert(db, target, NULL, "compacted by ovsdb-tool "VERSION);
+}
+
+static void
+do_convert(int argc, char *argv[])
+{
+ const char *db = argc >= 2 ? argv[1] : default_db();
+ const char *schema = argc >= 3 ? argv[2] : default_schema();
+ const char *target = argc >= 4 ? argv[3] : NULL;
+ struct ovsdb_schema *new_schema;
+
+ check_ovsdb_error(ovsdb_schema_from_file(schema, &new_schema));
+ compact_or_convert(db, target, new_schema,
+ "converted by ovsdb-tool "VERSION);
+ ovsdb_schema_destroy(new_schema);
+}
+
+static void
+do_needs_conversion(int argc, char *argv[])
+{
+ const char *db_file_name = argc >= 2 ? argv[1] : default_db();
+ const char *schema_file_name = argc >= 3 ? argv[2] : default_schema();
+ struct ovsdb_schema *schema1, *schema2;
+
+ check_ovsdb_error(ovsdb_file_read_schema(db_file_name, &schema1));
+ check_ovsdb_error(ovsdb_schema_from_file(schema_file_name, &schema2));
+ puts(ovsdb_schema_equal(schema1, schema2) ? "no" : "yes");
+ ovsdb_schema_destroy(schema1);
+ ovsdb_schema_destroy(schema2);
+}
+
+static void
+do_db_version(int argc, char *argv[])
+{
+ const char *db_file_name = argc >= 2 ? argv[1] : default_db();
+ struct ovsdb_schema *schema;
+
+ check_ovsdb_error(ovsdb_file_read_schema(db_file_name, &schema));
+ puts(schema->version);
+ ovsdb_schema_destroy(schema);
+}
+
+static void
+do_db_cksum(int argc OVS_UNUSED, char *argv[])
+{
+ const char *db_file_name = argc >= 2 ? argv[1] : default_db();
+ struct ovsdb_schema *schema;
+
+ check_ovsdb_error(ovsdb_file_read_schema(db_file_name, &schema));
+ puts(schema->cksum);
+ ovsdb_schema_destroy(schema);
+}
+
+static void
+do_schema_version(int argc, char *argv[])
+{
+ const char *schema_file_name = argc >= 2 ? argv[1] : default_schema();
+ struct ovsdb_schema *schema;
+
+ check_ovsdb_error(ovsdb_schema_from_file(schema_file_name, &schema));
+ puts(schema->version);
+ ovsdb_schema_destroy(schema);
+}
+
+static void
+do_schema_cksum(int argc, char *argv[])
+{
+ const char *schema_file_name = argc >= 2 ? argv[1] : default_schema();
+ struct ovsdb_schema *schema;
+
+ check_ovsdb_error(ovsdb_schema_from_file(schema_file_name, &schema));
+ puts(schema->cksum);
+ ovsdb_schema_destroy(schema);
+}
+
+static void
+transact(bool read_only, int argc, char *argv[])
{
+ const char *db_file_name = argc >= 3 ? argv[1] : default_db();
+ const char *transaction = argv[argc - 1];
struct json *request, *result;
struct ovsdb *db;
- check_ovsdb_error(ovsdb_file_open(db_file_name, read_only, &db));
+ check_ovsdb_error(ovsdb_file_open(db_file_name, read_only, &db, NULL));
request = parse_json(transaction);
- result = ovsdb_execute(db, request, 0, NULL);
+ result = ovsdb_execute(db, NULL, request, 0, NULL);
json_destroy(request);
print_and_free_json(result);
}
static void
-do_query(int argc UNUSED, char *argv[])
+do_query(int argc, char *argv[])
{
- transact(true, argv[1], argv[2]);
+ transact(true, argc, argv);
}
static void
-do_transact(int argc UNUSED, char *argv[])
+do_transact(int argc, char *argv[])
{
- transact(false, argv[1], argv[2]);
+ transact(false, argc, argv);
}
static void
-print_db_changes(struct shash *tables, struct shash *names)
+print_db_changes(struct shash *tables, struct shash *names,
+ const struct ovsdb_schema *schema)
{
struct shash_node *n1;
SHASH_FOR_EACH (n1, tables) {
const char *table = n1->name;
+ struct ovsdb_table_schema *table_schema;
struct json *rows = n1->data;
struct shash_node *n2;
continue;
}
+ table_schema = shash_find_data(&schema->tables, table);
SHASH_FOR_EACH (n2, json_object(rows)) {
const char *row_uuid = n2->name;
struct json *columns = n2->data;
if (!old_name) {
if (new_name) {
- printf(" insert row %s:\n", new_name);
+ printf(" insert row %s (%.8s):\n", new_name, row_uuid);
} else {
printf(" insert row %.8s:\n", row_uuid);
}
} else {
- printf(" row %s:\n", old_name);
+ printf(" row %s (%.8s):\n", old_name, row_uuid);
}
if (columns->type == JSON_OBJECT) {
if (show_log_verbosity > 1) {
SHASH_FOR_EACH (n3, json_object(columns)) {
const char *column = n3->name;
+ const struct ovsdb_column *column_schema;
struct json *value = n3->data;
- char *value_string;
-
- value_string = json_to_string(value, JSSF_SORT);
+ char *value_string = NULL;
+
+ column_schema =
+ (table_schema
+ ? shash_find_data(&table_schema->columns, column)
+ : NULL);
+ if (column_schema) {
+ const struct ovsdb_type *type;
+ struct ovsdb_error *error;
+ struct ovsdb_datum datum;
+
+ type = &column_schema->type;
+ error = ovsdb_datum_from_json(&datum, type,
+ value, NULL);
+ if (!error) {
+ struct ds s;
+
+ ds_init(&s);
+ ovsdb_datum_to_string(&datum, type, &s);
+ value_string = ds_steal_cstr(&s);
+ } else {
+ ovsdb_error_destroy(error);
+ }
+ }
+ if (!value_string) {
+ value_string = json_to_string(value, JSSF_SORT);
+ }
printf("\t\t%s=%s\n", column, value_string);
free(value_string);
}
: xmemdup0(row_uuid, 8)));
}
} else if (columns->type == JSON_NULL) {
+ struct shash_node *node;
+
printf("\t\tdelete row\n");
- shash_delete(names, shash_find(names, row_uuid));
+ node = shash_find(names, row_uuid);
+ if (node) {
+ shash_delete(names, node);
+ }
free(old_name);
}
}
static void
-do_show_log(int argc UNUSED, char *argv[])
+do_show_log(int argc, char *argv[])
{
- const char *db_file_name = argv[1];
+ const char *db_file_name = argc >= 2 ? argv[1] : default_db();
struct shash names;
struct ovsdb_log *log;
+ struct ovsdb_schema *schema;
unsigned int i;
- check_ovsdb_error(ovsdb_log_open(db_file_name, O_RDONLY, &log));
+ check_ovsdb_error(ovsdb_log_open(db_file_name, OVSDB_LOG_READ_ONLY,
+ -1, &log));
shash_init(&names);
+ schema = NULL;
for (i = 0; ; i++) {
struct json *json;
}
printf("record %u:", i);
- if (json->type == JSON_OBJECT) {
+ if (i == 0) {
+ check_ovsdb_error(ovsdb_schema_from_json(json, &schema));
+ printf(" \"%s\" schema, version=\"%s\", cksum=\"%s\"\n",
+ schema->name, schema->version, schema->cksum);
+ } else if (json->type == JSON_OBJECT) {
struct json *date, *comment;
date = shash_find_data(json_object(json), "_date");
if (date && date->type == JSON_INTEGER) {
- time_t t = json_integer(date);
- char s[128];
+ long long int t = json_integer(date);
+ char *s;
+
+ if (t < INT32_MAX) {
+ /* Older versions of ovsdb wrote timestamps in seconds. */
+ t *= 1000;
+ }
- strftime(s, sizeof s, "%Y-%m-%d %H:%M:%S", localtime(&t));
- printf(" %s", s);
+ s = xastrftime_msec(" %Y-%m-%d %H:%M:%S.###", t, true);
+ fputs(s, stdout);
+ free(s);
}
comment = shash_find_data(json_object(json), "_comment");
if (i > 0 && show_log_verbosity > 0) {
putchar('\n');
- print_db_changes(json_object(json), &names);
+ print_db_changes(json_object(json), &names, schema);
}
}
json_destroy(json);
putchar('\n');
}
+ ovsdb_log_close(log);
+ ovsdb_schema_destroy(schema);
/* XXX free 'names'. */
}
static void
-do_help(int argc UNUSED, char *argv[] UNUSED)
+do_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
{
usage();
}
static const struct command all_commands[] = {
- { "create", 2, 2, do_create },
- { "query", 2, 2, do_query },
- { "transact", 2, 2, do_transact },
- { "show-log", 1, 1, do_show_log },
+ { "create", 0, 2, do_create },
+ { "compact", 0, 2, do_compact },
+ { "convert", 0, 3, do_convert },
+ { "needs-conversion", 0, 2, do_needs_conversion },
+ { "db-version", 0, 1, do_db_version },
+ { "db-cksum", 0, 1, do_db_cksum },
+ { "schema-version", 0, 1, do_schema_version },
+ { "schema-cksum", 0, 1, do_schema_cksum },
+ { "query", 1, 2, do_query },
+ { "transact", 1, 2, do_transact },
+ { "show-log", 0, 1, do_show_log },
{ "help", 0, INT_MAX, do_help },
{ NULL, 0, 0, NULL },
};
+
+static const struct command *get_all_commands(void)
+{
+ return all_commands;
+}
git://git.onelab.eu / sliver-openvswitch.git / blobdiff