2 * Copyright (c) 2009, 2010 Nicira Networks.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
25 #include "dynamic-string.h"
29 #include "poll-loop.h"
31 #include "reconnect.h"
35 #define THIS_MODULE VLM_jsonrpc
39 struct stream *stream;
45 struct json_parser *parser;
46 struct jsonrpc_msg *received;
49 struct ovs_queue output;
53 /* Rate limit for error messages. */
54 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 5);
56 static void jsonrpc_received(struct jsonrpc *);
57 static void jsonrpc_cleanup(struct jsonrpc *);
60 jsonrpc_open(struct stream *stream)
64 assert(stream != NULL);
66 rpc = xzalloc(sizeof *rpc);
67 rpc->name = xstrdup(stream_get_name(stream));
69 byteq_init(&rpc->input);
70 queue_init(&rpc->output);
76 jsonrpc_close(struct jsonrpc *rpc)
86 jsonrpc_run(struct jsonrpc *rpc)
92 stream_run(rpc->stream);
93 while (!queue_is_empty(&rpc->output)) {
94 struct ofpbuf *buf = rpc->output.head;
97 retval = stream_send(rpc->stream, buf->data, buf->size);
99 rpc->backlog -= retval;
100 ofpbuf_pull(buf, retval);
102 ofpbuf_delete(queue_pop_head(&rpc->output));
105 if (retval != -EAGAIN) {
106 VLOG_WARN_RL(&rl, "%s: send error: %s",
107 rpc->name, strerror(-retval));
108 jsonrpc_error(rpc, -retval);
116 jsonrpc_wait(struct jsonrpc *rpc)
119 stream_run_wait(rpc->stream);
120 if (!queue_is_empty(&rpc->output)) {
121 stream_send_wait(rpc->stream);
127 jsonrpc_get_status(const struct jsonrpc *rpc)
133 jsonrpc_get_backlog(const struct jsonrpc *rpc)
135 return rpc->status ? 0 : rpc->backlog;
139 jsonrpc_get_name(const struct jsonrpc *rpc)
145 jsonrpc_log_msg(const struct jsonrpc *rpc, const char *title,
146 const struct jsonrpc_msg *msg)
148 if (VLOG_IS_DBG_ENABLED()) {
149 struct ds s = DS_EMPTY_INITIALIZER;
151 ds_put_format(&s, ", method=\"%s\"", msg->method);
154 ds_put_cstr(&s, ", params=");
155 ds_put_and_free_cstr(&s, json_to_string(msg->params, 0));
158 ds_put_cstr(&s, ", result=");
159 ds_put_and_free_cstr(&s, json_to_string(msg->result, 0));
162 ds_put_cstr(&s, ", error=");
163 ds_put_and_free_cstr(&s, json_to_string(msg->error, 0));
166 ds_put_cstr(&s, ", id=");
167 ds_put_and_free_cstr(&s, json_to_string(msg->id, 0));
169 VLOG_DBG("%s: %s %s%s", rpc->name, title,
170 jsonrpc_msg_type_to_string(msg->type), ds_cstr(&s));
176 jsonrpc_send(struct jsonrpc *rpc, struct jsonrpc_msg *msg)
184 jsonrpc_msg_destroy(msg);
188 jsonrpc_log_msg(rpc, "send", msg);
190 json = jsonrpc_msg_to_json(msg);
191 s = json_to_string(json, 0);
195 buf = xmalloc(sizeof *buf);
196 ofpbuf_use(buf, s, length);
198 queue_push_tail(&rpc->output, buf);
199 rpc->backlog += length;
201 if (rpc->output.n == 1) {
208 jsonrpc_recv(struct jsonrpc *rpc, struct jsonrpc_msg **msgp)
215 while (!rpc->received) {
216 if (byteq_is_empty(&rpc->input)) {
220 chunk = byteq_headroom(&rpc->input);
221 retval = stream_recv(rpc->stream, byteq_head(&rpc->input), chunk);
223 if (retval == -EAGAIN) {
226 VLOG_WARN_RL(&rl, "%s: receive error: %s",
227 rpc->name, strerror(-retval));
228 jsonrpc_error(rpc, -retval);
231 } else if (retval == 0) {
232 VLOG_INFO_RL(&rl, "%s: connection closed", rpc->name);
233 jsonrpc_error(rpc, EOF);
236 byteq_advance_head(&rpc->input, retval);
241 rpc->parser = json_parser_create(0);
243 n = byteq_tailroom(&rpc->input);
244 used = json_parser_feed(rpc->parser,
245 (char *) byteq_tail(&rpc->input), n);
246 byteq_advance_tail(&rpc->input, used);
247 if (json_parser_is_done(rpc->parser)) {
248 jsonrpc_received(rpc);
256 *msgp = rpc->received;
257 rpc->received = NULL;
262 jsonrpc_recv_wait(struct jsonrpc *rpc)
264 if (rpc->status || rpc->received || !byteq_is_empty(&rpc->input)) {
265 poll_immediate_wake();
267 stream_recv_wait(rpc->stream);
272 jsonrpc_send_block(struct jsonrpc *rpc, struct jsonrpc_msg *msg)
276 error = jsonrpc_send(rpc, msg);
281 while (!queue_is_empty(&rpc->output) && !rpc->status) {
290 jsonrpc_recv_block(struct jsonrpc *rpc, struct jsonrpc_msg **msgp)
293 int error = jsonrpc_recv(rpc, msgp);
294 if (error != EAGAIN) {
300 jsonrpc_recv_wait(rpc);
306 jsonrpc_transact_block(struct jsonrpc *rpc, struct jsonrpc_msg *request,
307 struct jsonrpc_msg **replyp)
309 struct jsonrpc_msg *reply = NULL;
313 id = json_clone(request->id);
314 error = jsonrpc_send_block(rpc, request);
317 error = jsonrpc_recv_block(rpc, &reply);
319 || (reply->type == JSONRPC_REPLY
320 && json_equal(id, reply->id))) {
323 jsonrpc_msg_destroy(reply);
326 *replyp = error ? NULL : reply;
332 jsonrpc_received(struct jsonrpc *rpc)
334 struct jsonrpc_msg *msg;
338 json = json_parser_finish(rpc->parser);
340 if (json->type == JSON_STRING) {
341 VLOG_WARN_RL(&rl, "%s: error parsing stream: %s",
342 rpc->name, json_string(json));
343 jsonrpc_error(rpc, EPROTO);
348 error = jsonrpc_msg_from_json(json, &msg);
350 VLOG_WARN_RL(&rl, "%s: received bad JSON-RPC message: %s",
353 jsonrpc_error(rpc, EPROTO);
357 jsonrpc_log_msg(rpc, "received", msg);
362 jsonrpc_error(struct jsonrpc *rpc, int error)
367 jsonrpc_cleanup(rpc);
372 jsonrpc_cleanup(struct jsonrpc *rpc)
374 stream_close(rpc->stream);
377 json_parser_abort(rpc->parser);
380 jsonrpc_msg_destroy(rpc->received);
381 rpc->received = NULL;
383 queue_clear(&rpc->output);
387 static struct jsonrpc_msg *
388 jsonrpc_create(enum jsonrpc_msg_type type, const char *method,
389 struct json *params, struct json *result, struct json *error,
392 struct jsonrpc_msg *msg = xmalloc(sizeof *msg);
394 msg->method = method ? xstrdup(method) : NULL;
395 msg->params = params;
396 msg->result = result;
403 jsonrpc_create_id(void)
405 static unsigned int id;
406 return json_integer_create(id++);
410 jsonrpc_create_request(const char *method, struct json *params,
413 struct json *id = jsonrpc_create_id();
415 *idp = json_clone(id);
417 return jsonrpc_create(JSONRPC_REQUEST, method, params, NULL, NULL, id);
421 jsonrpc_create_notify(const char *method, struct json *params)
423 return jsonrpc_create(JSONRPC_NOTIFY, method, params, NULL, NULL, NULL);
427 jsonrpc_create_reply(struct json *result, const struct json *id)
429 return jsonrpc_create(JSONRPC_REPLY, NULL, NULL, result, NULL,
434 jsonrpc_create_error(struct json *error, const struct json *id)
436 return jsonrpc_create(JSONRPC_REPLY, NULL, NULL, NULL, error,
441 jsonrpc_msg_type_to_string(enum jsonrpc_msg_type type)
444 case JSONRPC_REQUEST:
448 return "notification";
460 jsonrpc_msg_is_valid(const struct jsonrpc_msg *m)
462 const char *type_name;
463 unsigned int pattern;
465 if (m->params && m->params->type != JSON_ARRAY) {
466 return xstrdup("\"params\" must be JSON array");
470 case JSONRPC_REQUEST:
487 return xasprintf("invalid JSON-RPC message type %d", m->type);
490 type_name = jsonrpc_msg_type_to_string(m->type);
491 if ((m->method != NULL) != ((pattern & 0x10000) != 0)) {
492 return xasprintf("%s must%s have \"method\"",
493 type_name, (pattern & 0x10000) ? "" : " not");
496 if ((m->params != NULL) != ((pattern & 0x1000) != 0)) {
497 return xasprintf("%s must%s have \"params\"",
498 type_name, (pattern & 0x1000) ? "" : " not");
501 if ((m->result != NULL) != ((pattern & 0x100) != 0)) {
502 return xasprintf("%s must%s have \"result\"",
503 type_name, (pattern & 0x100) ? "" : " not");
506 if ((m->error != NULL) != ((pattern & 0x10) != 0)) {
507 return xasprintf("%s must%s have \"error\"",
508 type_name, (pattern & 0x10) ? "" : " not");
511 if ((m->id != NULL) != ((pattern & 0x1) != 0)) {
512 return xasprintf("%s must%s have \"id\"",
513 type_name, (pattern & 0x1) ? "" : " not");
520 jsonrpc_msg_destroy(struct jsonrpc_msg *m)
524 json_destroy(m->params);
525 json_destroy(m->result);
526 json_destroy(m->error);
533 null_from_json_null(struct json *json)
535 if (json && json->type == JSON_NULL) {
543 jsonrpc_msg_from_json(struct json *json, struct jsonrpc_msg **msgp)
545 struct json *method = NULL;
546 struct jsonrpc_msg *msg = NULL;
547 struct shash *object;
550 if (json->type != JSON_OBJECT) {
551 error = xstrdup("message is not a JSON object");
554 object = json_object(json);
556 method = shash_find_and_delete(object, "method");
557 if (method && method->type != JSON_STRING) {
558 error = xstrdup("method is not a JSON string");
562 msg = xzalloc(sizeof *msg);
563 msg->method = method ? xstrdup(method->u.string) : NULL;
564 msg->params = null_from_json_null(shash_find_and_delete(object, "params"));
565 msg->result = null_from_json_null(shash_find_and_delete(object, "result"));
566 msg->error = null_from_json_null(shash_find_and_delete(object, "error"));
567 msg->id = null_from_json_null(shash_find_and_delete(object, "id"));
568 msg->type = (msg->result ? JSONRPC_REPLY
569 : msg->error ? JSONRPC_ERROR
570 : msg->id ? JSONRPC_REQUEST
572 if (!shash_is_empty(object)) {
573 error = xasprintf("message has unexpected member \"%s\"",
574 shash_first(object)->name);
577 error = jsonrpc_msg_is_valid(msg);
583 json_destroy(method);
586 jsonrpc_msg_destroy(msg);
594 jsonrpc_msg_to_json(struct jsonrpc_msg *m)
596 struct json *json = json_object_create();
599 json_object_put(json, "method", json_string_create_nocopy(m->method));
603 json_object_put(json, "params", m->params);
607 json_object_put(json, "result", m->result);
608 } else if (m->type == JSONRPC_ERROR) {
609 json_object_put(json, "result", json_null_create());
613 json_object_put(json, "error", m->error);
614 } else if (m->type == JSONRPC_REPLY) {
615 json_object_put(json, "error", json_null_create());
619 json_object_put(json, "id", m->id);
620 } else if (m->type == JSONRPC_NOTIFY) {
621 json_object_put(json, "id", json_null_create());
629 /* A JSON-RPC session with reconnection. */
631 struct jsonrpc_session {
632 struct reconnect *reconnect;
634 struct stream *stream;
638 /* Creates and returns a jsonrpc_session that connects and reconnects, with
639 * back-off, to 'name', which should be a string acceptable to
641 struct jsonrpc_session *
642 jsonrpc_session_open(const char *name)
644 struct jsonrpc_session *s;
646 s = xmalloc(sizeof *s);
647 s->reconnect = reconnect_create(time_msec());
648 reconnect_set_name(s->reconnect, name);
649 reconnect_enable(s->reconnect, time_msec());
657 /* Creates and returns a jsonrpc_session that is initially connected to
658 * 'jsonrpc'. If the connection is dropped, it will not be reconnected. */
659 struct jsonrpc_session *
660 jsonrpc_session_open_unreliably(struct jsonrpc *jsonrpc)
662 struct jsonrpc_session *s;
664 s = xmalloc(sizeof *s);
665 s->reconnect = reconnect_create(time_msec());
666 reconnect_set_name(s->reconnect, jsonrpc_get_name(jsonrpc));
667 reconnect_set_max_tries(s->reconnect, 0);
668 reconnect_connected(s->reconnect, time_msec());
677 jsonrpc_session_close(struct jsonrpc_session *s)
680 jsonrpc_close(s->rpc);
681 reconnect_destroy(s->reconnect);
687 jsonrpc_session_disconnect(struct jsonrpc_session *s)
690 jsonrpc_error(s->rpc, EOF);
691 jsonrpc_close(s->rpc);
694 } else if (s->stream) {
695 stream_close(s->stream);
702 jsonrpc_session_connect(struct jsonrpc_session *s)
706 jsonrpc_session_disconnect(s);
707 error = stream_open(reconnect_get_name(s->reconnect), &s->stream);
709 reconnect_connect_failed(s->reconnect, time_msec(), error);
711 reconnect_connecting(s->reconnect, time_msec());
717 jsonrpc_session_run(struct jsonrpc_session *s)
723 error = jsonrpc_get_status(s->rpc);
725 reconnect_disconnected(s->reconnect, time_msec(), 0);
726 jsonrpc_session_disconnect(s);
728 } else if (s->stream) {
731 stream_run(s->stream);
732 error = stream_connect(s->stream);
734 reconnect_connected(s->reconnect, time_msec());
735 s->rpc = jsonrpc_open(s->stream);
737 } else if (error != EAGAIN) {
738 reconnect_connect_failed(s->reconnect, time_msec(), error);
739 stream_close(s->stream);
744 switch (reconnect_run(s->reconnect, time_msec())) {
745 case RECONNECT_CONNECT:
746 jsonrpc_session_connect(s);
749 case RECONNECT_DISCONNECT:
750 reconnect_disconnected(s->reconnect, time_msec(), 0);
751 jsonrpc_session_disconnect(s);
754 case RECONNECT_PROBE:
757 struct jsonrpc_msg *request;
759 params = json_array_create_empty();
760 request = jsonrpc_create_request("echo", params, NULL);
761 json_destroy(request->id);
762 request->id = json_string_create("echo");
763 jsonrpc_send(s->rpc, request);
770 jsonrpc_session_wait(struct jsonrpc_session *s)
773 jsonrpc_wait(s->rpc);
774 } else if (s->stream) {
775 stream_run_wait(s->stream);
776 stream_connect_wait(s->stream);
778 reconnect_wait(s->reconnect, time_msec());
782 jsonrpc_session_get_backlog(const struct jsonrpc_session *s)
784 return s->rpc ? jsonrpc_get_backlog(s->rpc) : 0;
788 jsonrpc_session_get_name(const struct jsonrpc_session *s)
790 return reconnect_get_name(s->reconnect);
794 jsonrpc_session_send(struct jsonrpc_session *s, struct jsonrpc_msg *msg)
796 return s->rpc ? jsonrpc_send(s->rpc, msg) : ENOTCONN;
800 jsonrpc_session_recv(struct jsonrpc_session *s)
803 struct jsonrpc_msg *msg;
804 jsonrpc_recv(s->rpc, &msg);
806 reconnect_received(s->reconnect, time_msec());
807 if (msg->type == JSONRPC_REQUEST && !strcmp(msg->method, "echo")) {
808 /* Echo request. Send reply. */
809 struct jsonrpc_msg *reply;
811 reply = jsonrpc_create_reply(json_clone(msg->params), msg->id);
812 jsonrpc_session_send(s, reply);
813 } else if (msg->type == JSONRPC_REPLY
814 && msg->id && msg->id->type == JSON_STRING
815 && !strcmp(msg->id->u.string, "echo")) {
816 /* It's a reply to our echo request. Suppress it. */
820 jsonrpc_msg_destroy(msg);
827 jsonrpc_session_recv_wait(struct jsonrpc_session *s)
830 jsonrpc_recv_wait(s->rpc);
835 jsonrpc_session_is_alive(const struct jsonrpc_session *s)
837 return s->rpc || s->stream || reconnect_get_max_tries(s->reconnect);
841 jsonrpc_session_is_connected(const struct jsonrpc_session *s)
843 return s->rpc != NULL;
847 jsonrpc_session_get_seqno(const struct jsonrpc_session *s)
853 jsonrpc_session_force_reconnect(struct jsonrpc_session *s)
855 reconnect_force_reconnect(s->reconnect, time_msec());