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