[mirror_ovs.git] / tests / test-jsonrpc.c

/*
 * 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.
 * You may obtain a copy of the License at:
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <config.h>
#undef NDEBUG
#include "jsonrpc.h"
#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <stdio.h>
#include <stdlib.h>
#include "command-line.h"
#include "daemon.h"
#include "openvswitch/json.h"
#include "ovstest.h"
#include "poll-loop.h"
#include "stream-ssl.h"
#include "stream.h"
#include "timeval.h"
#include "util.h"
#include "openvswitch/vlog.h"

OVS_NO_RETURN static void usage(void);
static void parse_options(int argc, char *argv[]);
static struct ovs_cmdl_command *get_all_commands(void);

static void
test_jsonrpc_main(int argc, char *argv[])
{
    struct ovs_cmdl_context ctx = { .argc = 0, };
    ovs_cmdl_proctitle_init(argc, argv);
    set_program_name(argv[0]);
    service_start(&argc, &argv);
    parse_options(argc, argv);
    ctx.argc = argc - optind;
    ctx.argv = argv + optind;
    ovs_cmdl_run_command(&ctx, get_all_commands());
}

static void
parse_options(int argc, char *argv[])
{
    enum {
        OPT_BOOTSTRAP_CA_CERT = UCHAR_MAX + 1,
        DAEMON_OPTION_ENUMS
    };
    static const struct option long_options[] = {
        {"verbose", optional_argument, NULL, 'v'},
        {"help", no_argument, NULL, 'h'},
        DAEMON_LONG_OPTIONS,
        {"bootstrap-ca-cert", required_argument, NULL, OPT_BOOTSTRAP_CA_CERT},
        STREAM_SSL_LONG_OPTIONS,
        {NULL, 0, NULL, 0},
    };
    char *short_options = ovs_cmdl_long_options_to_short_options(long_options);

    for (;;) {
        int c = getopt_long(argc, argv, short_options, long_options, NULL);
        if (c == -1) {
            break;
        }

        switch (c) {
        case 'h':
            usage();

        case 'v':
            vlog_set_verbosity(optarg);
            break;

        DAEMON_OPTION_HANDLERS

        STREAM_SSL_OPTION_HANDLERS

        case OPT_BOOTSTRAP_CA_CERT:
            stream_ssl_set_ca_cert_file(optarg, true);
            break;

        case '?':
            exit(EXIT_FAILURE);

        default:
            abort();
        }
    }
    free(short_options);
}

static void
usage(void)
{
    printf("%s: JSON-RPC test utility\n"
           "usage: %s [OPTIONS] COMMAND [ARG...]\n"
           "  listen LOCAL             listen for connections on LOCAL\n"
           "  request REMOTE METHOD PARAMS   send request, print reply\n"
           "  notify REMOTE METHOD PARAMS  send notification and exit\n",
           program_name, program_name);
    stream_usage("JSON-RPC", true, true, true);
    daemon_usage();
    vlog_usage();
    printf("\nOther options:\n"
           "  -h, --help                  display this help message\n");
    exit(EXIT_SUCCESS);
}
\f
/* Command helper functions. */

static struct json *
parse_json(const char *s)
{
    struct json *json = json_from_string(s);
    if (json->type == JSON_STRING) {
        ovs_fatal(0, "\"%s\": %s", s, json->u.string);
    }
    return json;
}

static void
print_and_free_json(struct json *json)
{
    char *string = json_to_string(json, JSSF_SORT);
    json_destroy(json);
    puts(string);
    free(string);
}
\f
/* Command implementations. */

static int
handle_rpc(struct jsonrpc *rpc, struct jsonrpc_msg *msg, bool *done)
{
    if (msg->type == JSONRPC_REQUEST) {
        struct jsonrpc_msg *reply = NULL;
        if (!strcmp(msg->method, "echo")) {
            reply = jsonrpc_create_reply(json_clone(msg->params), msg->id);
        } else {
            struct json *error = json_object_create();
            json_object_put_string(error, "error", "unknown method");
            reply = jsonrpc_create_error(error, msg->id);
            ovs_error(0, "unknown request %s", msg->method);
        }
        jsonrpc_send(rpc, reply);
        return 0;
    } else if (msg->type == JSONRPC_NOTIFY) {
        if (!strcmp(msg->method, "shutdown")) {
            *done = true;
            return 0;
        } else {
            ovs_error(0, "unknown notification %s", msg->method);
            return ENOTTY;
        }
    } else {
        ovs_error(0, "unsolicited JSON-RPC reply or error");
        return EPROTO;
    }
}

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);
}

static void
do_request(struct ovs_cmdl_context *ctx)
{
    struct jsonrpc_msg *msg;
    struct jsonrpc *rpc;
    struct json *params;
    struct stream *stream;
    const char *method;
    char *string;
    int error;

    method = ctx->argv[2];
    params = parse_json(ctx->argv[3]);
    msg = jsonrpc_create_request(method, params, NULL);
    string = jsonrpc_msg_is_valid(msg);
    if (string) {
        ovs_fatal(0, "not a valid JSON-RPC request: %s", string);
    }

    error = stream_open_block(jsonrpc_stream_open(ctx->argv[1], &stream,
                              DSCP_DEFAULT), &stream);
    if (error) {
        ovs_fatal(error, "could not open \"%s\"", ctx->argv[1]);
    }
    rpc = jsonrpc_open(stream);

    error = jsonrpc_send(rpc, msg);
    if (error) {
        ovs_fatal(error, "could not send request");
    }

    error = jsonrpc_recv_block(rpc, &msg);
    if (error) {
        ovs_fatal(error, "error waiting for reply");
    }
    print_and_free_json(jsonrpc_msg_to_json(msg));

    jsonrpc_close(rpc);
}

static void
do_notify(struct ovs_cmdl_context *ctx)
{
    struct jsonrpc_msg *msg;
    struct jsonrpc *rpc;
    struct json *params;
    struct stream *stream;
    const char *method;
    char *string;
    int error;

    method = ctx->argv[2];
    params = parse_json(ctx->argv[3]);
    msg = jsonrpc_create_notify(method, params);
    string = jsonrpc_msg_is_valid(msg);
    if (string) {
        ovs_fatal(0, "not a JSON RPC-valid notification: %s", string);
    }

    error = stream_open_block(jsonrpc_stream_open(ctx->argv[1], &stream,
                              DSCP_DEFAULT), &stream);
    if (error) {
        ovs_fatal(error, "could not open \"%s\"", ctx->argv[1]);
    }
    rpc = jsonrpc_open(stream);

    error = jsonrpc_send_block(rpc, msg);
    if (error) {
        ovs_fatal(error, "could not send notification");
    }
    jsonrpc_close(rpc);
}

static void
do_help(struct ovs_cmdl_context *ctx OVS_UNUSED)
{
    usage();
}

static struct ovs_cmdl_command all_commands[] = {
    { "listen", NULL, 1, 1, do_listen },
    { "request", NULL, 3, 3, do_request },
    { "notify", NULL, 3, 3, do_notify },
    { "help", NULL, 0, INT_MAX, do_help },
    { NULL, NULL, 0, 0, NULL },
};

static struct ovs_cmdl_command *
get_all_commands(void)
{
    return all_commands;
}

OVSTEST_REGISTER("test-jsonrpc", test_jsonrpc_main);
Commit	Line	Data
f2129093	1	/*
e91b927d	2	* Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014, 2015 Nicira, Inc.
f2129093 BP	3	*
	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:
	7	*
	8	* http://www.apache.org/licenses/LICENSE-2.0
	9	*
	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.
	15	*/
	16
	17	#include <config.h>
3f636c7e	18	#undef NDEBUG
f2129093	19	#include "jsonrpc.h"
f2129093 BP	20	#include <errno.h>
	21	#include <fcntl.h>
	22	#include <getopt.h>
	23	#include <stdio.h>
	24	#include <stdlib.h>
f2129093 BP	25	#include "command-line.h"
f2129093 BP	26	#include "daemon.h"
ee89ea7b	27	#include "openvswitch/json.h"
3f636c7e	28	#include "ovstest.h"
f2129093	29	#include "poll-loop.h"
9467fe62	30	#include "stream-ssl.h"
f2129093 BP	31	#include "stream.h"
	32	#include "timeval.h"
	33	#include "util.h"
e6211adc	34	#include "openvswitch/vlog.h"
f2129093	35
cab50449	36	OVS_NO_RETURN static void usage(void);
f2129093	37	static void parse_options(int argc, char *argv[]);
5f383751	38	static struct ovs_cmdl_command *get_all_commands(void);
f2129093	39
eadd1644 AZ	40	static void
eadd1644 AZ	41	test_jsonrpc_main(int argc, char *argv[])
f2129093	42	{
1636c761	43	struct ovs_cmdl_context ctx = { .argc = 0, };
5f383751	44	ovs_cmdl_proctitle_init(argc, argv);
f2129093	45	set_program_name(argv[0]);
dad530c1	46	service_start(&argc, &argv);
f2129093	47	parse_options(argc, argv);
1636c761 RB	48	ctx.argc = argc - optind;
	49	ctx.argv = argv + optind;
	50	ovs_cmdl_run_command(&ctx, get_all_commands());
f2129093 BP	51	}
	52
	53	static void
	54	parse_options(int argc, char *argv[])
	55	{
9467fe62	56	enum {
8274ae95 BP	57	OPT_BOOTSTRAP_CA_CERT = UCHAR_MAX + 1,
8274ae95 BP	58	DAEMON_OPTION_ENUMS
9467fe62	59	};
07fc4ed3	60	static const struct option long_options[] = {
e3c17733 BP	61	{"verbose", optional_argument, NULL, 'v'},
e3c17733 BP	62	{"help", no_argument, NULL, 'h'},
f2129093	63	DAEMON_LONG_OPTIONS,
e3c17733	64	{"bootstrap-ca-cert", required_argument, NULL, OPT_BOOTSTRAP_CA_CERT},
bf8f2167	65	STREAM_SSL_LONG_OPTIONS,
e3c17733	66	{NULL, 0, NULL, 0},
f2129093	67	};
5f383751	68	char *short_options = ovs_cmdl_long_options_to_short_options(long_options);
f2129093 BP	69
	70	for (;;) {
	71	int c = getopt_long(argc, argv, short_options, long_options, NULL);
	72	if (c == -1) {
	73	break;
	74	}
	75
	76	switch (c) {
	77	case 'h':
	78	usage();
	79
	80	case 'v':
	81	vlog_set_verbosity(optarg);
	82	break;
	83
	84	DAEMON_OPTION_HANDLERS
	85
9467fe62 BP	86	STREAM_SSL_OPTION_HANDLERS
	87
	88	case OPT_BOOTSTRAP_CA_CERT:
	89	stream_ssl_set_ca_cert_file(optarg, true);
	90	break;
9467fe62	91
f2129093 BP	92	case '?':
	93	exit(EXIT_FAILURE);
	94
	95	default:
	96	abort();
	97	}
	98	}
	99	free(short_options);
	100	}
	101
	102	static void
	103	usage(void)
	104	{
	105	printf("%s: JSON-RPC test utility\n"
	106	"usage: %s [OPTIONS] COMMAND [ARG...]\n"
	107	" listen LOCAL listen for connections on LOCAL\n"
	108	" request REMOTE METHOD PARAMS send request, print reply\n"
	109	" notify REMOTE METHOD PARAMS send notification and exit\n",
	110	program_name, program_name);
9467fe62	111	stream_usage("JSON-RPC", true, true, true);
f2129093 BP	112	daemon_usage();
	113	vlog_usage();
	114	printf("\nOther options:\n"
	115	" -h, --help display this help message\n");
	116	exit(EXIT_SUCCESS);
	117	}
	118	\f
	119	/* Command helper functions. */
	120
	121	static struct json *
	122	parse_json(const char *s)
	123	{
	124	struct json *json = json_from_string(s);
	125	if (json->type == JSON_STRING) {
	126	ovs_fatal(0, "\"%s\": %s", s, json->u.string);
	127	}
	128	return json;
	129	}
	130
	131	static void
	132	print_and_free_json(struct json *json)
	133	{
	134	char *string = json_to_string(json, JSSF_SORT);
	135	json_destroy(json);
	136	puts(string);
	137	free(string);
	138	}
	139	\f
	140	/* Command implementations. */
	141
c1ce8fbf	142	static int
f2129093 BP	143	handle_rpc(struct jsonrpc rpc, struct jsonrpc_msg msg, bool *done)
f2129093 BP	144	{
f2129093	145	if (msg->type == JSONRPC_REQUEST) {
c1ce8fbf	146	struct jsonrpc_msg *reply = NULL;
f2129093 BP	147	if (!strcmp(msg->method, "echo")) {
	148	reply = jsonrpc_create_reply(json_clone(msg->params), msg->id);
	149	} else {
	150	struct json *error = json_object_create();
	151	json_object_put_string(error, "error", "unknown method");
	152	reply = jsonrpc_create_error(error, msg->id);
	153	ovs_error(0, "unknown request %s", msg->method);
	154	}
c1ce8fbf BP	155	jsonrpc_send(rpc, reply);
c1ce8fbf BP	156	return 0;
f2129093 BP	157	} else if (msg->type == JSONRPC_NOTIFY) {
	158	if (!strcmp(msg->method, "shutdown")) {
	159	*done = true;
c1ce8fbf	160	return 0;
f2129093	161	} else {
f2129093	162	ovs_error(0, "unknown notification %s", msg->method);
c1ce8fbf	163	return ENOTTY;
f2129093 BP	164	}
f2129093 BP	165	} else {
f2129093	166	ovs_error(0, "unsolicited JSON-RPC reply or error");
c1ce8fbf	167	return EPROTO;
f2129093 BP	168	}
	169	}
	170
	171	static void
1636c761	172	do_listen(struct ovs_cmdl_context *ctx)
f2129093 BP	173	{
	174	struct pstream *pstream;
	175	struct jsonrpc **rpcs;
	176	size_t n_rpcs, allocated_rpcs;
	177	bool done;
	178	int error;
	179
1636c761	180	error = jsonrpc_pstream_open(ctx->argv[1], &pstream, DSCP_DEFAULT);
f2129093	181	if (error) {
1636c761	182	ovs_fatal(error, "could not listen on \"%s\"", ctx->argv[1]);
f2129093 BP	183	}
	184
	185	daemonize();
	186
	187	rpcs = NULL;
	188	n_rpcs = allocated_rpcs = 0;
	189	done = false;
	190	for (;;) {
	191	struct stream *stream;
	192	size_t i;
	193
	194	/* Accept new connections. */
	195	error = pstream_accept(pstream, &stream);
	196	if (!error) {
	197	if (n_rpcs >= allocated_rpcs) {
	198	rpcs = x2nrealloc(rpcs, &allocated_rpcs, sizeof *rpcs);
	199	}
	200	rpcs[n_rpcs++] = jsonrpc_open(stream);
	201	} else if (error != EAGAIN) {
	202	ovs_fatal(error, "pstream_accept failed");
	203	}
	204
	205	/* Service existing connections. */
	206	for (i = 0; i < n_rpcs; ) {
	207	struct jsonrpc *rpc = rpcs[i];
	208	struct jsonrpc_msg *msg;
	209
	210	jsonrpc_run(rpc);
	211	if (!jsonrpc_get_backlog(rpc)) {
	212	error = jsonrpc_recv(rpc, &msg);
	213	if (!error) {
c1ce8fbf	214	error = handle_rpc(rpc, msg, &done);
f2129093	215	jsonrpc_msg_destroy(msg);
c1ce8fbf BP	216	} else if (error == EAGAIN) {
c1ce8fbf BP	217	error = 0;
f2129093 BP	218	}
	219	}
	220
c1ce8fbf BP	221	if (!error) {
	222	error = jsonrpc_get_status(rpc);
	223	}
f2129093 BP	224	if (error) {
	225	jsonrpc_close(rpc);
	226	ovs_error(error, "connection closed");
	227	memmove(&rpcs[i], &rpcs[i + 1],
	228	(n_rpcs - i - 1) * sizeof *rpcs);
	229	n_rpcs--;
	230	} else {
	231	i++;
	232	}
	233	}
	234
	235	/* Wait for something to do. */
	236	if (done && !n_rpcs) {
	237	break;
	238	}
	239	pstream_wait(pstream);
	240	for (i = 0; i < n_rpcs; i++) {
	241	struct jsonrpc *rpc = rpcs[i];
	242
	243	jsonrpc_wait(rpc);
	244	if (!jsonrpc_get_backlog(rpc)) {
	245	jsonrpc_recv_wait(rpc);
	246	}
	247	}
	248	poll_block();
	249	}
93ff0290 BP	250	free(rpcs);
93ff0290 BP	251	pstream_close(pstream);
f2129093 BP	252	}
f2129093 BP	253
f2129093	254	static void
1636c761	255	do_request(struct ovs_cmdl_context *ctx)
f2129093 BP	256	{
	257	struct jsonrpc_msg *msg;
	258	struct jsonrpc *rpc;
	259	struct json *params;
	260	struct stream *stream;
	261	const char *method;
	262	char *string;
	263	int error;
	264
1636c761 RB	265	method = ctx->argv[2];
1636c761 RB	266	params = parse_json(ctx->argv[3]);
20bed8be	267	msg = jsonrpc_create_request(method, params, NULL);
f2129093 BP	268	string = jsonrpc_msg_is_valid(msg);
	269	if (string) {
	270	ovs_fatal(0, "not a valid JSON-RPC request: %s", string);
	271	}
	272
1636c761	273	error = stream_open_block(jsonrpc_stream_open(ctx->argv[1], &stream,
f125905c	274	DSCP_DEFAULT), &stream);
f2129093	275	if (error) {
1636c761	276	ovs_fatal(error, "could not open \"%s\"", ctx->argv[1]);
f2129093 BP	277	}
	278	rpc = jsonrpc_open(stream);
	279
	280	error = jsonrpc_send(rpc, msg);
	281	if (error) {
	282	ovs_fatal(error, "could not send request");
	283	}
	284
	285	error = jsonrpc_recv_block(rpc, &msg);
	286	if (error) {
	287	ovs_fatal(error, "error waiting for reply");
	288	}
	289	print_and_free_json(jsonrpc_msg_to_json(msg));
	290
	291	jsonrpc_close(rpc);
	292	}
	293
	294	static void
1636c761	295	do_notify(struct ovs_cmdl_context *ctx)
f2129093 BP	296	{
	297	struct jsonrpc_msg *msg;
	298	struct jsonrpc *rpc;
	299	struct json *params;
	300	struct stream *stream;
	301	const char *method;
	302	char *string;
	303	int error;
	304
1636c761 RB	305	method = ctx->argv[2];
1636c761 RB	306	params = parse_json(ctx->argv[3]);
f2129093 BP	307	msg = jsonrpc_create_notify(method, params);
	308	string = jsonrpc_msg_is_valid(msg);
	309	if (string) {
	310	ovs_fatal(0, "not a JSON RPC-valid notification: %s", string);
	311	}
	312
1636c761	313	error = stream_open_block(jsonrpc_stream_open(ctx->argv[1], &stream,
f125905c	314	DSCP_DEFAULT), &stream);
f2129093	315	if (error) {
1636c761	316	ovs_fatal(error, "could not open \"%s\"", ctx->argv[1]);
f2129093 BP	317	}
	318	rpc = jsonrpc_open(stream);
	319
	320	error = jsonrpc_send_block(rpc, msg);
	321	if (error) {
99155935	322	ovs_fatal(error, "could not send notification");
f2129093 BP	323	}
	324	jsonrpc_close(rpc);
	325	}
	326
	327	static void
1636c761	328	do_help(struct ovs_cmdl_context *ctx OVS_UNUSED)
f2129093 BP	329	{
	330	usage();
	331	}
	332
5f383751	333	static struct ovs_cmdl_command all_commands[] = {
451de37e AW	334	{ "listen", NULL, 1, 1, do_listen },
	335	{ "request", NULL, 3, 3, do_request },
	336	{ "notify", NULL, 3, 3, do_notify },
	337	{ "help", NULL, 0, INT_MAX, do_help },
	338	{ NULL, NULL, 0, 0, NULL },
f2129093	339	};
eadd1644	340
5f383751	341	static struct ovs_cmdl_command *
d2586fce GS	342	get_all_commands(void)
	343	{
	344	return all_commands;
	345	}
	346
eadd1644	347	OVSTEST_REGISTER("test-jsonrpc", test_jsonrpc_main);