#include "bitmap.h"
#include "column.h"
-#include "dynamic-string.h"
+#include "openvswitch/dynamic-string.h"
#include "monitor.h"
#include "json.h"
#include "jsonrpc.h"
static void ovsdb_jsonrpc_session_reconnect_all(struct ovsdb_jsonrpc_remote *);
static void ovsdb_jsonrpc_session_set_all_options(
struct ovsdb_jsonrpc_remote *, const struct ovsdb_jsonrpc_options *);
-static bool ovsdb_jsonrpc_session_get_status(
+static bool ovsdb_jsonrpc_active_session_get_status(
const struct ovsdb_jsonrpc_remote *,
struct ovsdb_jsonrpc_remote_status *);
+static void ovsdb_jsonrpc_session_get_status(
+ const struct ovsdb_jsonrpc_session *,
+ struct ovsdb_jsonrpc_remote_status *);
static void ovsdb_jsonrpc_session_unlock_all(struct ovsdb_jsonrpc_session *);
static void ovsdb_jsonrpc_session_unlock__(struct ovsdb_lock_waiter *);
static void ovsdb_jsonrpc_session_send(struct ovsdb_jsonrpc_session *,
struct ovsdb_jsonrpc_server {
struct ovsdb_server up;
- unsigned int n_sessions, max_sessions;
+ unsigned int n_sessions;
struct shash remotes; /* Contains "struct ovsdb_jsonrpc_remote *"s. */
};
{
struct ovsdb_jsonrpc_server *server = xzalloc(sizeof *server);
ovsdb_server_init(&server->up);
- server->max_sessions = 330; /* Random limit. */
shash_init(&server->remotes);
return server;
}
remote = xmalloc(sizeof *remote);
remote->server = svr;
remote->listener = listener;
- list_init(&remote->sessions);
+ ovs_list_init(&remote->sessions);
remote->dscp = options->dscp;
shash_add(&svr->remotes, name, remote);
/* Stores status information for the remote named 'target', which should have
* been configured on 'svr' with a call to ovsdb_jsonrpc_server_set_remotes(),
* into '*status'. On success returns true, on failure (if 'svr' doesn't have
- * a remote named 'target' or if that remote is an inbound remote that has no
+ * a remote named 'target' or if that remote is an outbound remote that has no
* active connections) returns false. On failure, 'status' will be zeroed.
*/
bool
memset(status, 0, sizeof *status);
remote = shash_find_data(&svr->remotes, target);
- return remote && ovsdb_jsonrpc_session_get_status(remote, status);
+
+ if (!remote) {
+ return false;
+ }
+
+ if (remote->listener) {
+ status->bound_port = pstream_get_bound_port(remote->listener);
+ status->is_connected = !ovs_list_is_empty(&remote->sessions);
+ status->n_connections = ovs_list_size(&remote->sessions);
+ return true;
+ }
+
+ return ovsdb_jsonrpc_active_session_get_status(remote, status);
}
void
struct ovsdb_jsonrpc_remote *remote = node->data;
if (remote->listener) {
- if (svr->n_sessions < svr->max_sessions) {
- struct stream *stream;
- int error;
-
- error = pstream_accept(remote->listener, &stream);
- if (!error) {
- struct jsonrpc_session *js;
- js = jsonrpc_session_open_unreliably(jsonrpc_open(stream),
- remote->dscp);
- ovsdb_jsonrpc_session_create(remote, js);
- } else if (error != EAGAIN) {
- VLOG_WARN_RL(&rl, "%s: accept failed: %s",
- pstream_get_name(remote->listener),
- ovs_strerror(error));
- }
- } else {
- VLOG_WARN_RL(&rl, "%s: connection exceeded maximum (%d)",
+ struct stream *stream;
+ int error;
+
+ error = pstream_accept(remote->listener, &stream);
+ if (!error) {
+ struct jsonrpc_session *js;
+ js = jsonrpc_session_open_unreliably(jsonrpc_open(stream),
+ remote->dscp);
+ ovsdb_jsonrpc_session_create(remote, js);
+ } else if (error != EAGAIN) {
+ VLOG_WARN_RL(&rl, "%s: accept failed: %s",
pstream_get_name(remote->listener),
- svr->max_sessions);
+ ovs_strerror(error));
}
}
SHASH_FOR_EACH (node, &svr->remotes) {
struct ovsdb_jsonrpc_remote *remote = node->data;
- if (remote->listener && svr->n_sessions < svr->max_sessions) {
+ if (remote->listener) {
pstream_wait(remote->listener);
}
s = xzalloc(sizeof *s);
ovsdb_session_init(&s->up, &remote->server->up);
s->remote = remote;
- list_push_back(&remote->sessions, &s->node);
+ ovs_list_push_back(&remote->sessions, &s->node);
hmap_init(&s->triggers);
hmap_init(&s->monitors);
s->js = js;
hmap_destroy(&s->triggers);
jsonrpc_session_close(s->js);
- list_remove(&s->node);
+ ovs_list_remove(&s->node);
s->remote->server->n_sessions--;
ovsdb_session_destroy(&s->up);
free(s);
struct simap *usage)
{
simap_increase(usage, "triggers", hmap_count(&s->triggers));
- simap_increase(usage, "monitors", hmap_count(&s->monitors));
simap_increase(usage, "backlog", jsonrpc_session_get_backlog(s->js));
}
}
}
+/* Sets the 'status' of for the 'remote' with an outgoing connection. */
static bool
-ovsdb_jsonrpc_session_get_status(const struct ovsdb_jsonrpc_remote *remote,
- struct ovsdb_jsonrpc_remote_status *status)
+ovsdb_jsonrpc_active_session_get_status(
+ const struct ovsdb_jsonrpc_remote *remote,
+ struct ovsdb_jsonrpc_remote_status *status)
{
+ const struct ovs_list *sessions = &remote->sessions;
const struct ovsdb_jsonrpc_session *s;
+
+ if (ovs_list_is_empty(sessions)) {
+ return false;
+ }
+
+ ovs_assert(ovs_list_is_singleton(sessions));
+ s = CONTAINER_OF(ovs_list_front(sessions), struct ovsdb_jsonrpc_session, node);
+ ovsdb_jsonrpc_session_get_status(s, status);
+ status->n_connections = 1;
+
+ return true;
+}
+
+static void
+ovsdb_jsonrpc_session_get_status(const struct ovsdb_jsonrpc_session *session,
+ struct ovsdb_jsonrpc_remote_status *status)
+{
+ const struct ovsdb_jsonrpc_session *s = session;
const struct jsonrpc_session *js;
struct ovsdb_lock_waiter *waiter;
struct reconnect_stats rstats;
struct ds locks_held, locks_waiting, locks_lost;
- status->bound_port = (remote->listener
- ? pstream_get_bound_port(remote->listener)
- : htons(0));
-
- if (list_is_empty(&remote->sessions)) {
- return false;
- }
- s = CONTAINER_OF(remote->sessions.next, struct ovsdb_jsonrpc_session, node);
js = s->js;
status->is_connected = jsonrpc_session_is_connected(js);
status->locks_held = ds_steal_cstr(&locks_held);
status->locks_waiting = ds_steal_cstr(&locks_waiting);
status->locks_lost = ds_steal_cstr(&locks_lost);
-
- status->n_connections = list_size(&remote->sessions);
-
- return true;
}
/* Examines 'request' to determine the database to which it relates, and then
static void
ovsdb_jsonrpc_trigger_complete_done(struct ovsdb_jsonrpc_session *s)
{
- while (!list_is_empty(&s->up.completions)) {
+ while (!ovs_list_is_empty(&s->up.completions)) {
struct ovsdb_jsonrpc_trigger *t
= CONTAINER_OF(s->up.completions.next,
struct ovsdb_jsonrpc_trigger, trigger.node);
static struct ovsdb_error * OVS_WARN_UNUSED_RESULT
ovsdb_jsonrpc_parse_monitor_request(struct ovsdb_monitor *dbmon,
const struct ovsdb_table *table,
- const struct json *monitor_request,
- size_t *allocated_columns)
+ const struct json *monitor_request)
{
const struct ovsdb_table_schema *ts = table->schema;
enum ovsdb_monitor_selection select;
return ovsdb_syntax_error(columns, NULL, "%s is not a valid "
"column name", s);
}
- ovsdb_monitor_add_column(dbmon, table, column, select,
- allocated_columns);
+ if (ovsdb_monitor_add_column(dbmon, table, column,
+ select, true)) {
+ return ovsdb_syntax_error(columns, NULL, "column %s "
+ "mentioned more than once",
+ column->name);
+ }
}
} else {
struct shash_node *node;
SHASH_FOR_EACH (node, &ts->columns) {
const struct ovsdb_column *column = node->data;
if (column->index != OVSDB_COL_UUID) {
- ovsdb_monitor_add_column(dbmon, table, column, select,
- allocated_columns);
+ if (ovsdb_monitor_add_column(dbmon, table, column,
+ select, true)) {
+ return ovsdb_syntax_error(columns, NULL, "column %s "
+ "mentioned more than once",
+ column->name);
+ }
}
}
}
SHASH_FOR_EACH (node, json_object(monitor_requests)) {
const struct ovsdb_table *table;
- const char *column_name;
- size_t allocated_columns;
const struct json *mr_value;
size_t i;
/* Parse columns. */
mr_value = node->data;
- allocated_columns = 0;
if (mr_value->type == JSON_ARRAY) {
const struct json_array *array = &mr_value->u.array;
for (i = 0; i < array->n; i++) {
- error = ovsdb_jsonrpc_parse_monitor_request(
- m->dbmon, table, array->elems[i], &allocated_columns);
+ error = ovsdb_jsonrpc_parse_monitor_request(m->dbmon,
+ table,
+ array->elems[i]);
if (error) {
goto error;
}
}
} else {
- error = ovsdb_jsonrpc_parse_monitor_request(
- m->dbmon, table, mr_value, &allocated_columns);
+ error = ovsdb_jsonrpc_parse_monitor_request(m->dbmon,
+ table,
+ mr_value);
if (error) {
goto error;
}
}
-
- column_name = ovsdb_monitor_table_check_duplicates(m->dbmon, table);
-
- if (column_name) {
- error = ovsdb_syntax_error(mr_value, NULL, "column %s "
- "mentioned more than once",
- column_name);
- goto error;
- }
}
dbmon = ovsdb_monitor_add(m->dbmon);
if (dbmon != m->dbmon) {
/* Found an exisiting dbmon, reuse the current one. */
- ovsdb_monitor_remove_jsonrpc_monitor(m->dbmon, m);
+ ovsdb_monitor_remove_jsonrpc_monitor(m->dbmon, m, m->unflushed);
ovsdb_monitor_add_jsonrpc_monitor(dbmon, m);
m->dbmon = dbmon;
}
ovsdb_jsonrpc_monitor_compose_update(struct ovsdb_jsonrpc_monitor *m,
bool initial)
{
+ if (!ovsdb_monitor_needs_flush(m->dbmon, m->unflushed)) {
+ return NULL;
+ }
+
return ovsdb_monitor_get_update(m->dbmon, initial, &m->unflushed,
m->version);
}
{
json_destroy(m->monitor_id);
hmap_remove(&m->session->monitors, &m->node);
- ovsdb_monitor_remove_jsonrpc_monitor(m->dbmon, m);
+ ovsdb_monitor_remove_jsonrpc_monitor(m->dbmon, m, m->unflushed);
free(m);
}
projects / cascardo / ovs.git / blobdiff