/*
- * Copyright (c) 2009 Nicira Networks.
+ * Copyright (c) 2009, 2010 Nicira Networks.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
#include "jsonrpc.h"
+#include <assert.h>
#include <errno.h>
#include "byteq.h"
#include "dynamic-string.h"
+#include "fatal-signal.h"
#include "json.h"
#include "list.h"
#include "ofpbuf.h"
static void jsonrpc_received(struct jsonrpc *);
static void jsonrpc_cleanup(struct jsonrpc *);
+/* This is just the same as stream_open() except that it uses the default
+ * JSONRPC ports if none is specified. */
+int
+jsonrpc_stream_open(const char *name, struct stream **streamp)
+{
+ return stream_open_with_default_ports(name, JSONRPC_TCP_PORT,
+ JSONRPC_SSL_PORT, streamp);
+}
+
+/* This is just the same as pstream_open() except that it uses the default
+ * JSONRPC ports if none is specified. */
+int
+jsonrpc_pstream_open(const char *name, struct pstream **pstreamp)
+{
+ return pstream_open_with_default_ports(name, JSONRPC_TCP_PORT,
+ JSONRPC_SSL_PORT, pstreamp);
+}
+
struct jsonrpc *
jsonrpc_open(struct stream *stream)
{
return;
}
+ stream_run(rpc->stream);
while (!queue_is_empty(&rpc->output)) {
struct ofpbuf *buf = rpc->output.head;
int retval;
void
jsonrpc_wait(struct jsonrpc *rpc)
{
- if (!rpc->status && !queue_is_empty(&rpc->output)) {
- stream_send_wait(rpc->stream);
+ if (!rpc->status) {
+ stream_run_wait(rpc->stream);
+ if (!queue_is_empty(&rpc->output)) {
+ stream_send_wait(rpc->stream);
+ }
}
}
}
if (msg->params) {
ds_put_cstr(&s, ", params=");
- ds_put_and_free_cstr(&s, json_to_string(msg->params, 0));
+ json_to_ds(msg->params, 0, &s);
}
if (msg->result) {
ds_put_cstr(&s, ", result=");
- ds_put_and_free_cstr(&s, json_to_string(msg->result, 0));
+ json_to_ds(msg->result, 0, &s);
}
if (msg->error) {
ds_put_cstr(&s, ", error=");
- ds_put_and_free_cstr(&s, json_to_string(msg->error, 0));
+ json_to_ds(msg->error, 0, &s);
}
if (msg->id) {
ds_put_cstr(&s, ", id=");
- ds_put_and_free_cstr(&s, json_to_string(msg->id, 0));
+ json_to_ds(msg->id, 0, &s);
}
VLOG_DBG("%s: %s %s%s", rpc->name, title,
jsonrpc_msg_type_to_string(msg->type), ds_cstr(&s));
}
}
+/* Always takes ownership of 'msg', regardless of success. */
int
jsonrpc_send(struct jsonrpc *rpc, struct jsonrpc_msg *msg)
{
}
}
+/* Always takes ownership of 'msg', regardless of success. */
int
jsonrpc_send_block(struct jsonrpc *rpc, struct jsonrpc_msg *msg)
{
int error;
+ fatal_signal_run();
+
error = jsonrpc_send(rpc, msg);
if (error) {
return error;
}
- while (!queue_is_empty(&rpc->output) && !rpc->status) {
+ for (;;) {
jsonrpc_run(rpc);
+ if (queue_is_empty(&rpc->output) || rpc->status) {
+ return rpc->status;
+ }
jsonrpc_wait(rpc);
poll_block();
}
- return rpc->status;
}
int
for (;;) {
int error = jsonrpc_recv(rpc, msgp);
if (error != EAGAIN) {
+ fatal_signal_run();
return error;
}
}
}
+/* Always takes ownership of 'request', regardless of success. */
int
jsonrpc_transact_block(struct jsonrpc *rpc, struct jsonrpc_msg *request,
struct jsonrpc_msg **replyp)
struct reconnect *reconnect;
struct jsonrpc *rpc;
struct stream *stream;
+ struct pstream *pstream;
unsigned int seqno;
};
-/* Creates and returns a jsonrpc_session that connects and reconnects, with
- * back-off, to 'name', which should be a string acceptable to
- * stream_open(). */
+/* Creates and returns a jsonrpc_session to 'name', which should be a string
+ * acceptable to stream_open() or pstream_open().
+ *
+ * If 'name' is an active connection method, e.g. "tcp:127.1.2.3", the new
+ * jsonrpc_session connects and reconnects, with back-off, to 'name'.
+ *
+ * If 'name' is a passive connection method, e.g. "ptcp:", the new
+ * jsonrpc_session listens for connections to 'name'. It maintains at most one
+ * connection at any given time. Any new connection causes the previous one
+ * (if any) to be dropped. */
struct jsonrpc_session *
jsonrpc_session_open(const char *name)
{
reconnect_enable(s->reconnect, time_msec());
s->rpc = NULL;
s->stream = NULL;
+ s->pstream = NULL;
s->seqno = 0;
+ if (!pstream_verify_name(name)) {
+ reconnect_set_passive(s->reconnect, true, time_msec());
+ }
+
return s;
}
reconnect_connected(s->reconnect, time_msec());
s->rpc = jsonrpc;
s->stream = NULL;
+ s->pstream = NULL;
s->seqno = 0;
return s;
if (s) {
jsonrpc_close(s->rpc);
reconnect_destroy(s->reconnect);
+ stream_close(s->stream);
+ pstream_close(s->pstream);
free(s);
}
}
static void
jsonrpc_session_disconnect(struct jsonrpc_session *s)
{
- reconnect_disconnected(s->reconnect, time_msec(), 0);
if (s->rpc) {
jsonrpc_error(s->rpc, EOF);
jsonrpc_close(s->rpc);
static void
jsonrpc_session_connect(struct jsonrpc_session *s)
{
+ const char *name = reconnect_get_name(s->reconnect);
int error;
jsonrpc_session_disconnect(s);
- error = stream_open(reconnect_get_name(s->reconnect), &s->stream);
+ if (!reconnect_is_passive(s->reconnect)) {
+ error = jsonrpc_stream_open(name, &s->stream);
+ if (!error) {
+ reconnect_connecting(s->reconnect, time_msec());
+ }
+ } else {
+ error = s->pstream ? 0 : jsonrpc_pstream_open(name, &s->pstream);
+ if (!error) {
+ reconnect_listening(s->reconnect, time_msec());
+ }
+ }
+
if (error) {
reconnect_connect_failed(s->reconnect, time_msec(), error);
- } else {
- reconnect_connecting(s->reconnect, time_msec());
}
s->seqno++;
}
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) {
int error;
jsonrpc_run(s->rpc);
error = jsonrpc_get_status(s->rpc);
if (error) {
+ reconnect_disconnected(s->reconnect, time_msec(), 0);
jsonrpc_session_disconnect(s);
}
} else if (s->stream) {
- int error = stream_connect(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);
break;
case RECONNECT_DISCONNECT:
+ reconnect_disconnected(s->reconnect, time_msec(), 0);
jsonrpc_session_disconnect(s);
break;
if (s->rpc) {
jsonrpc_wait(s->rpc);
} else if (s->stream) {
+ stream_run_wait(s->stream);
stream_connect_wait(s->stream);
}
+ if (s->pstream) {
+ pstream_wait(s->pstream);
+ }
reconnect_wait(s->reconnect, time_msec());
}
return reconnect_get_name(s->reconnect);
}
+/* Always takes ownership of 'msg', regardless of success. */
int
jsonrpc_session_send(struct jsonrpc_session *s, struct jsonrpc_msg *msg)
{
- return s->rpc ? jsonrpc_send(s->rpc, msg) : ENOTCONN;
+ if (s->rpc) {
+ return jsonrpc_send(s->rpc, msg);
+ } else {
+ jsonrpc_msg_destroy(msg);
+ return ENOTCONN;
+ }
}
struct jsonrpc_msg *
projects / openvswitch / blobdiff