void
jsonrpc_session_run(struct jsonrpc_session *s)
{
if (s->pstream) {
struct stream *stream;
int error;
error = pstream_accept(s->pstream, &stream);
if (!error) {
if (s->rpc || s->stream) {
VLOG_INFO_RL(&rl,
"%s: new connection replacing active connection",
reconnect_get_name(s->reconnect));
jsonrpc_session_disconnect(s);
}
reconnect_connected(s->reconnect, time_msec());
s->rpc = jsonrpc_open(stream);
} else if (error != EAGAIN) {
reconnect_listen_error(s->reconnect, time_msec(), error);
pstream_close(s->pstream);
s->pstream = NULL;
}
}
if (s->rpc) {
size_t backlog;
int error;
backlog = jsonrpc_get_backlog(s->rpc);
jsonrpc_run(s->rpc);
if (jsonrpc_get_backlog(s->rpc) < backlog) {
/* Data previously caught in a queue was successfully sent (or
* there's an error, which we'll catch below.)
*
* We don't count data that is successfully sent immediately as
* activity, because there's a lot of queuing downstream from us,
* which means that we can push a lot of data into a connection
* that has stalled and won't ever recover.
*/
reconnect_activity(s->reconnect, time_msec());
}
error = jsonrpc_get_status(s->rpc);
if (error) {
reconnect_disconnected(s->reconnect, time_msec(), error);
jsonrpc_session_disconnect(s);
s->last_error = error;
}
} else if (s->stream) {
int error;
stream_run(s->stream);
error = stream_connect(s->stream);
if (!error) {
reconnect_connected(s->reconnect, time_msec());
s->rpc = jsonrpc_open(s->stream);
s->stream = NULL;
} else if (error != EAGAIN) {
reconnect_connect_failed(s->reconnect, time_msec(), error);
stream_close(s->stream);
s->stream = NULL;
s->last_error = error;
}
}
switch (reconnect_run(s->reconnect, time_msec())) {
case RECONNECT_CONNECT:
jsonrpc_session_connect(s);
break;
case RECONNECT_DISCONNECT:
reconnect_disconnected(s->reconnect, time_msec(), 0);
jsonrpc_session_disconnect(s);
break;
case RECONNECT_PROBE:
if (s->rpc) {
struct json *params;
struct jsonrpc_msg *request;
params = json_array_create_empty();
request = jsonrpc_create_request("echo", params, NULL);
json_destroy(request->id);
request->id = json_string_create("echo");
jsonrpc_send(s->rpc, request);
}
break;
}
}
size_t
jsonrpc_session_get_backlog(const struct jsonrpc_session *s)
{
return s->rpc ? jsonrpc_get_backlog(s->rpc) : 0;
}
static void
do_listen(struct ovs_cmdl_context *ctx)
{
struct pstream *pstream;
struct jsonrpc **rpcs;
size_t n_rpcs, allocated_rpcs;
bool done;
int error;
error = jsonrpc_pstream_open(ctx->argv[1], &pstream, DSCP_DEFAULT);
if (error) {
ovs_fatal(error, "could not listen on \"%s\"", ctx->argv[1]);
}
daemonize();
rpcs = NULL;
n_rpcs = allocated_rpcs = 0;
done = false;
for (;;) {
struct stream *stream;
size_t i;
/* Accept new connections. */
error = pstream_accept(pstream, &stream);
if (!error) {
if (n_rpcs >= allocated_rpcs) {
rpcs = x2nrealloc(rpcs, &allocated_rpcs, sizeof *rpcs);
}
rpcs[n_rpcs++] = jsonrpc_open(stream);
} else if (error != EAGAIN) {
ovs_fatal(error, "pstream_accept failed");
}
/* Service existing connections. */
for (i = 0; i < n_rpcs; ) {
struct jsonrpc *rpc = rpcs[i];
struct jsonrpc_msg *msg;
jsonrpc_run(rpc);
if (!jsonrpc_get_backlog(rpc)) {
error = jsonrpc_recv(rpc, &msg);
if (!error) {
error = handle_rpc(rpc, msg, &done);
jsonrpc_msg_destroy(msg);
} else if (error == EAGAIN) {
error = 0;
}
}
if (!error) {
error = jsonrpc_get_status(rpc);
}
if (error) {
jsonrpc_close(rpc);
ovs_error(error, "connection closed");
memmove(&rpcs[i], &rpcs[i + 1],
(n_rpcs - i - 1) * sizeof *rpcs);
n_rpcs--;
} else {
i++;
}
}
/* Wait for something to do. */
if (done && !n_rpcs) {
break;
}
pstream_wait(pstream);
for (i = 0; i < n_rpcs; i++) {
struct jsonrpc *rpc = rpcs[i];
jsonrpc_wait(rpc);
if (!jsonrpc_get_backlog(rpc)) {
jsonrpc_recv_wait(rpc);
}
}
poll_block();
}
free(rpcs);
pstream_close(pstream);
}