-/* Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
+/* Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014, 2015 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 "bitmap.h"
+#include "coverage.h"
#include "dynamic-string.h"
#include "fatal-signal.h"
#include "json.h"
#include "jsonrpc.h"
+#include "ovsdb/ovsdb.h"
+#include "ovsdb/table.h"
#include "ovsdb-data.h"
#include "ovsdb-error.h"
#include "ovsdb-idl-provider.h"
+#include "ovsdb-parser.h"
#include "poll-loop.h"
#include "shash.h"
+#include "sset.h"
#include "util.h"
-#include "vlog.h"
+#include "openvswitch/vlog.h"
VLOG_DEFINE_THIS_MODULE(ovsdb_idl);
+COVERAGE_DEFINE(txn_uncommitted);
+COVERAGE_DEFINE(txn_unchanged);
+COVERAGE_DEFINE(txn_incomplete);
+COVERAGE_DEFINE(txn_aborted);
+COVERAGE_DEFINE(txn_success);
+COVERAGE_DEFINE(txn_try_again);
+COVERAGE_DEFINE(txn_not_locked);
+COVERAGE_DEFINE(txn_error);
+
/* An arc from one idl_row to another. When row A contains a UUID that
* references row B, this is represented by an arc from A (the source) to B
* (the destination).
* tables.
*/
struct ovsdb_idl_arc {
- struct list src_node; /* In src->src_arcs list. */
- struct list dst_node; /* In dst->dst_arcs list. */
+ struct ovs_list src_node; /* In src->src_arcs list. */
+ struct ovs_list dst_node; /* In dst->dst_arcs list. */
struct ovsdb_idl_row *src; /* Source row. */
struct ovsdb_idl_row *dst; /* Destination row. */
};
+enum ovsdb_idl_state {
+ IDL_S_SCHEMA_REQUESTED,
+ IDL_S_MONITOR_REQUESTED,
+ IDL_S_MONITORING
+};
+
struct ovsdb_idl {
const struct ovsdb_idl_class *class;
struct jsonrpc_session *session;
struct shash table_by_name;
struct ovsdb_idl_table *tables; /* Contains "struct ovsdb_idl_table *"s.*/
- struct json *monitor_request_id;
- unsigned int last_monitor_request_seqno;
unsigned int change_seqno;
bool verify_write_only;
+ /* Session state. */
+ unsigned int state_seqno;
+ enum ovsdb_idl_state state;
+ struct json *request_id;
+
/* Database locking. */
char *lock_name; /* Name of lock we need, NULL if none. */
bool has_lock; /* Has db server told us we have the lock? */
char *error;
bool dry_run;
struct ds comment;
- unsigned int commit_seqno;
/* Increments. */
const char *inc_table;
static struct vlog_rate_limit semantic_rl = VLOG_RATE_LIMIT_INIT(1, 5);
static void ovsdb_idl_clear(struct ovsdb_idl *);
-static void ovsdb_idl_send_monitor_request(struct ovsdb_idl *);
+static void ovsdb_idl_send_schema_request(struct ovsdb_idl *);
+static void ovsdb_idl_send_monitor_request(struct ovsdb_idl *,
+ const struct json *schema_json);
static void ovsdb_idl_parse_update(struct ovsdb_idl *, const struct json *);
static struct ovsdb_error *ovsdb_idl_parse_update__(struct ovsdb_idl *,
const struct json *);
hmap_init(&table->rows);
table->idl = idl;
}
- idl->last_monitor_request_seqno = UINT_MAX;
+
+ idl->state_seqno = UINT_MAX;
+ idl->request_id = NULL;
+
hmap_init(&idl->outstanding_txns);
return idl;
}
shash_destroy(&idl->table_by_name);
free(idl->tables);
- json_destroy(idl->monitor_request_id);
+ json_destroy(idl->request_id);
free(idl->lock_name);
json_destroy(idl->lock_request_id);
hmap_destroy(&idl->outstanding_txns);
unsigned int seqno;
seqno = jsonrpc_session_get_seqno(idl->session);
- if (idl->last_monitor_request_seqno != seqno) {
- idl->last_monitor_request_seqno = seqno;
+ if (idl->state_seqno != seqno) {
+ idl->state_seqno = seqno;
+ json_destroy(idl->request_id);
+ idl->request_id = NULL;
ovsdb_idl_txn_abort_all(idl);
- ovsdb_idl_send_monitor_request(idl);
+
+ ovsdb_idl_send_schema_request(idl);
+ idl->state = IDL_S_SCHEMA_REQUESTED;
if (idl->lock_name) {
ovsdb_idl_send_lock_request(idl);
}
- break;
}
msg = jsonrpc_session_recv(idl->session);
/* Database contents changed. */
ovsdb_idl_parse_update(idl, msg->params->u.array.elems[1]);
} else if (msg->type == JSONRPC_REPLY
- && idl->monitor_request_id
- && json_equal(idl->monitor_request_id, msg->id)) {
- /* Reply to our "monitor" request. */
- idl->change_seqno++;
- json_destroy(idl->monitor_request_id);
- idl->monitor_request_id = NULL;
- ovsdb_idl_clear(idl);
- ovsdb_idl_parse_update(idl, msg->result);
+ && idl->request_id
+ && json_equal(idl->request_id, msg->id)) {
+ switch (idl->state) {
+ case IDL_S_SCHEMA_REQUESTED:
+ /* Reply to our "get_schema" request. */
+ json_destroy(idl->request_id);
+ idl->request_id = NULL;
+ ovsdb_idl_send_monitor_request(idl, msg->result);
+ idl->state = IDL_S_MONITOR_REQUESTED;
+ break;
+
+ case IDL_S_MONITOR_REQUESTED:
+ /* Reply to our "monitor" request. */
+ idl->change_seqno++;
+ json_destroy(idl->request_id);
+ idl->request_id = NULL;
+ idl->state = IDL_S_MONITORING;
+ ovsdb_idl_clear(idl);
+ ovsdb_idl_parse_update(idl, msg->result);
+ break;
+
+ case IDL_S_MONITORING:
+ default:
+ OVS_NOT_REACHED();
+ }
} else if (msg->type == JSONRPC_REPLY
&& idl->lock_request_id
&& json_equal(idl->lock_request_id, msg->id)) {
&& !strcmp(msg->method, "stolen")) {
/* Someone else stole our lock. */
ovsdb_idl_parse_lock_notify(idl, msg->params, false);
- } else if (msg->type == JSONRPC_REPLY && msg->id->type == JSON_STRING
- && !strcmp(msg->id->u.string, "echo")) {
- /* Reply to our echo request. Ignore it. */
} else if ((msg->type == JSONRPC_ERROR
|| msg->type == JSONRPC_REPLY)
&& ovsdb_idl_txn_process_reply(idl, msg)) {
return ovsdb_idl_get_seqno(idl) != 0;
}
+/* Reconfigures 'idl' so that it would reconnect to the database, if
+ * connection was dropped. */
+void
+ovsdb_idl_enable_reconnect(struct ovsdb_idl *idl)
+{
+ jsonrpc_session_enable_reconnect(idl->session);
+}
+
/* Forces 'idl' to drop its connection to the database and reconnect. In the
* meantime, the contents of 'idl' will not change. */
void
idl->verify_write_only = true;
}
+/* Returns true if 'idl' is currently connected or trying to connect. */
bool
ovsdb_idl_is_alive(const struct ovsdb_idl *idl)
{
return jsonrpc_session_is_alive(idl->session);
}
+/* Returns the last error reported on a connection by 'idl'. The return value
+ * is 0 only if no connection made by 'idl' has ever encountered an error. See
+ * jsonrpc_get_status() for return value interpretation. */
int
ovsdb_idl_get_last_error(const struct ovsdb_idl *idl)
{
}
}
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
static void
}
}
- NOT_REACHED();
+ OVS_NOT_REACHED();
}
/* Turns off OVSDB_IDL_ALERT for 'column' in 'idl'.
}
\f
static void
-ovsdb_idl_send_monitor_request(struct ovsdb_idl *idl)
+ovsdb_idl_send_schema_request(struct ovsdb_idl *idl)
{
+ struct jsonrpc_msg *msg;
+
+ json_destroy(idl->request_id);
+ msg = jsonrpc_create_request(
+ "get_schema",
+ json_array_create_1(json_string_create(idl->class->database)),
+ &idl->request_id);
+ jsonrpc_session_send(idl->session, msg);
+}
+
+static void
+log_error(struct ovsdb_error *error)
+{
+ char *s = ovsdb_error_to_string(error);
+ VLOG_WARN("error parsing database schema: %s", s);
+ free(s);
+ ovsdb_error_destroy(error);
+}
+
+/* Frees 'schema', which is in the format returned by parse_schema(). */
+static void
+free_schema(struct shash *schema)
+{
+ if (schema) {
+ struct shash_node *node, *next;
+
+ SHASH_FOR_EACH_SAFE (node, next, schema) {
+ struct sset *sset = node->data;
+ sset_destroy(sset);
+ free(sset);
+ shash_delete(schema, node);
+ }
+ shash_destroy(schema);
+ free(schema);
+ }
+}
+
+/* Parses 'schema_json', an OVSDB schema in JSON format as described in RFC
+ * 7047, to obtain the names of its rows and columns. If successful, returns
+ * an shash whose keys are table names and whose values are ssets, where each
+ * sset contains the names of its table's columns. On failure (due to a parse
+ * error), returns NULL.
+ *
+ * It would also be possible to use the general-purpose OVSDB schema parser in
+ * ovsdb-server, but that's overkill, possibly too strict for the current use
+ * case, and would require restructuring ovsdb-server to separate the schema
+ * code from the rest. */
+static struct shash *
+parse_schema(const struct json *schema_json)
+{
+ struct ovsdb_parser parser;
+ const struct json *tables_json;
+ struct ovsdb_error *error;
+ struct shash_node *node;
+ struct shash *schema;
+
+ ovsdb_parser_init(&parser, schema_json, "database schema");
+ tables_json = ovsdb_parser_member(&parser, "tables", OP_OBJECT);
+ error = ovsdb_parser_destroy(&parser);
+ if (error) {
+ log_error(error);
+ return NULL;
+ }
+
+ schema = xmalloc(sizeof *schema);
+ shash_init(schema);
+ SHASH_FOR_EACH (node, json_object(tables_json)) {
+ const char *table_name = node->name;
+ const struct json *json = node->data;
+ const struct json *columns_json;
+
+ ovsdb_parser_init(&parser, json, "table schema for table %s",
+ table_name);
+ columns_json = ovsdb_parser_member(&parser, "columns", OP_OBJECT);
+ error = ovsdb_parser_destroy(&parser);
+ if (error) {
+ log_error(error);
+ free_schema(schema);
+ return NULL;
+ }
+
+ struct sset *columns = xmalloc(sizeof *columns);
+ sset_init(columns);
+
+ struct shash_node *node2;
+ SHASH_FOR_EACH (node2, json_object(columns_json)) {
+ const char *column_name = node2->name;
+ sset_add(columns, column_name);
+ }
+ shash_add(schema, table_name, columns);
+ }
+ return schema;
+}
+
+static void
+ovsdb_idl_send_monitor_request(struct ovsdb_idl *idl,
+ const struct json *schema_json)
+{
+ struct shash *schema = parse_schema(schema_json);
struct json *monitor_requests;
struct jsonrpc_msg *msg;
size_t i;
const struct ovsdb_idl_table *table = &idl->tables[i];
const struct ovsdb_idl_table_class *tc = table->class;
struct json *monitor_request, *columns;
+ const struct sset *table_schema;
size_t j;
+ table_schema = (schema
+ ? shash_find_data(schema, table->class->name)
+ : NULL);
+
columns = table->need_table ? json_array_create_empty() : NULL;
for (j = 0; j < tc->n_columns; j++) {
const struct ovsdb_idl_column *column = &tc->columns[j];
if (table->modes[j] & OVSDB_IDL_MONITOR) {
+ if (table_schema
+ && !sset_contains(table_schema, column->name)) {
+ VLOG_WARN("%s table in %s database lacks %s column "
+ "(database needs upgrade?)",
+ table->class->name, idl->class->database,
+ column->name);
+ continue;
+ }
if (!columns) {
columns = json_array_create_empty();
}
}
if (columns) {
+ if (schema && !table_schema) {
+ VLOG_WARN("%s database lacks %s table "
+ "(database needs upgrade?)",
+ idl->class->database, table->class->name);
+ json_destroy(columns);
+ continue;
+ }
+
monitor_request = json_object_create();
json_object_put(monitor_request, "columns", columns);
json_object_put(monitor_requests, tc->name, monitor_request);
}
}
+ free_schema(schema);
- json_destroy(idl->monitor_request_id);
+ json_destroy(idl->request_id);
msg = jsonrpc_create_request(
"monitor",
json_array_create_3(json_string_create(idl->class->database),
json_null_create(), monitor_requests),
- &idl->monitor_request_id);
+ &idl->request_id);
jsonrpc_session_send(idl->session, msg);
}
return ovsdb_idl_read(row, column);
}
+/* Returns true if the field represented by 'column' in 'row' may be modified,
+ * false if it is immutable.
+ *
+ * Normally, whether a field is mutable is controlled by its column's schema.
+ * However, an immutable column can be set to any initial value at the time of
+ * insertion, so if 'row' is a new row (one that is being added as part of the
+ * current transaction, supposing that a transaction is in progress) then even
+ * its "immutable" fields are actually mutable. */
+bool
+ovsdb_idl_is_mutable(const struct ovsdb_idl_row *row,
+ const struct ovsdb_idl_column *column)
+{
+ return column->mutable || (row->new && !row->old);
+}
+
/* Returns false if 'row' was obtained from the IDL, true if it was initialized
* to all-zero-bits by some other entity. If 'row' was set up some other way
* then the return value is indeterminate. */
txn->error = NULL;
txn->dry_run = false;
ds_init(&txn->comment);
- txn->commit_seqno = txn->idl->change_seqno;
txn->inc_table = NULL;
txn->inc_column = NULL;
bool any_updates;
if (txn != txn->idl->txn) {
- return txn->status;
+ goto coverage_out;
}
/* If we need a lock but don't have it, give up quickly. */
if (txn->idl->lock_name && !ovsdb_idl_has_lock(txn->idl)) {
txn->status = TXN_NOT_LOCKED;
- ovsdb_idl_txn_disassemble(txn);
- return txn->status;
+ goto disassemble_out;
}
operations = json_array_create_1(
txn->status = TXN_TRY_AGAIN;
}
+disassemble_out:
ovsdb_idl_txn_disassemble(txn);
+coverage_out:
+ switch (txn->status) {
+ case TXN_UNCOMMITTED: COVERAGE_INC(txn_uncommitted); break;
+ case TXN_UNCHANGED: COVERAGE_INC(txn_unchanged); break;
+ case TXN_INCOMPLETE: COVERAGE_INC(txn_incomplete); break;
+ case TXN_ABORTED: COVERAGE_INC(txn_aborted); break;
+ case TXN_SUCCESS: COVERAGE_INC(txn_success); break;
+ case TXN_TRY_AGAIN: COVERAGE_INC(txn_try_again); break;
+ case TXN_NOT_LOCKED: COVERAGE_INC(txn_not_locked); break;
+ case TXN_ERROR: COVERAGE_INC(txn_error); break;
+ }
+
return txn->status;
}
if (txn->inc_index + 2 > results->n) {
VLOG_WARN_RL(&syntax_rl, "reply does not contain enough operations "
- "for increment (has %zu, needs %u)",
+ "for increment (has %"PRIuSIZE", needs %u)",
results->n, txn->inc_index + 2);
return false;
}
return false;
}
if (rows->u.array.n != 1) {
- VLOG_WARN_RL(&syntax_rl, "\"select\" reply \"rows\" has %zu elements "
+ VLOG_WARN_RL(&syntax_rl, "\"select\" reply \"rows\" has %"PRIuSIZE" elements "
"instead of 1",
rows->u.array.n);
return false;
if (insert->op_index >= results->n) {
VLOG_WARN_RL(&syntax_rl, "reply does not contain enough operations "
- "for insert (has %zu, needs %u)",
+ "for insert (has %"PRIuSIZE", needs %u)",
results->n, insert->op_index);
return false;
}
ovsdb_idl_update_has_lock(struct ovsdb_idl *idl, bool new_has_lock)
{
if (new_has_lock && !idl->has_lock) {
- if (!idl->monitor_request_id) {
+ if (idl->state == IDL_S_MONITORING) {
idl->change_seqno++;
} else {
- /* We're waiting for a monitor reply, so don't signal that the
- * database changed. The monitor reply will increment change_seqno
+ /* We're setting up a session, so don't signal that the database
+ * changed. Finalizing the session will increment change_seqno
* anyhow. */
}
idl->is_lock_contended = false;
projects / cascardo / ovs.git / blobdiff