AUTHORS: Add Joe Perches.
[sliver-openvswitch.git] / tests / test-jsonrpc.py
1 # Copyright (c) 2009, 2010 Nicira Networks
2 #
3 # Licensed under the Apache License, Version 2.0 (the "License");
4 # you may not use this file except in compliance with the License.
5 # You may obtain a copy of the License at:
6 #
7 #     http://www.apache.org/licenses/LICENSE-2.0
8 #
9 # Unless required by applicable law or agreed to in writing, software
10 # distributed under the License is distributed on an "AS IS" BASIS,
11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 # See the License for the specific language governing permissions and
13 # limitations under the License.
14
15 import errno
16 import getopt
17 import os
18 import sys
19
20 import ovs.daemon
21 import ovs.json
22 import ovs.jsonrpc
23 import ovs.poller
24 import ovs.stream
25
26 def handle_rpc(rpc, msg):
27     done = False
28     reply = None
29
30     if msg.type == ovs.jsonrpc.Message.T_REQUEST:
31         if msg.method == "echo":
32             reply = ovs.jsonrpc.Message.create_reply(msg.params, msg.id)
33         else:
34             reply = ovs.jsonrpc.Message.create_error(
35                 {"error": "unknown method"}, msg.id)
36             sys.stderr.write("unknown request %s" % msg.method)
37     elif msg.type == ovs.jsonrpc.Message.T_NOTIFY:
38         if msg.method == "shutdown":
39             done = True
40         else:
41             rpc.error(errno.ENOTTY)
42             sys.stderr.write("unknown notification %s" % msg.method)
43     else:
44         rpc.error(errno.EPROTO)
45         sys.stderr.write("unsolicited JSON-RPC reply or error\n")
46         
47     if reply:
48         rpc.send(reply)
49     return done
50
51 def do_listen(name):
52     ovs.daemon.die_if_already_running()
53
54     error, pstream = ovs.stream.PassiveStream.open(name)
55     if error:
56         sys.stderr.write("could not listen on \"%s\": %s\n"
57                          % (name, os.strerror(error)))
58         sys.exit(1)
59
60     ovs.daemon.daemonize()
61
62     rpcs = []
63     done = False
64     while True:
65         # Accept new connections.
66         error, stream = pstream.accept()
67         if stream:
68             rpcs.append(ovs.jsonrpc.Connection(stream))
69         elif error != errno.EAGAIN:
70             sys.stderr.write("PassiveStream.accept() failed\n")
71             sys.exit(1)
72
73         # Service existing connections.
74         dead_rpcs = []
75         for rpc in rpcs:
76             rpc.run()
77
78             error = 0
79             if not rpc.get_backlog():
80                 error, msg = rpc.recv()
81                 if not error:
82                     if handle_rpc(rpc, msg):
83                         done = True
84
85             error = rpc.get_status()
86             if error:
87                 rpc.close()
88                 dead_rpcs.append(rpc)
89         rpcs = [rpc for rpc in rpcs if not rpc in dead_rpcs]
90
91         if done and not rpcs:
92             break
93
94         poller = ovs.poller.Poller()
95         pstream.wait(poller)
96         for rpc in rpcs:
97             rpc.wait(poller)
98             if not rpc.get_backlog():
99                 rpc.recv_wait(poller)
100         poller.block()
101     pstream.close()
102
103 def do_request(name, method, params_string):
104     params = ovs.json.from_string(params_string)
105     msg = ovs.jsonrpc.Message.create_request(method, params)
106     s = msg.is_valid()
107     if s:
108         sys.stderr.write("not a valid JSON-RPC request: %s\n" % s)
109         sys.exit(1)
110
111     error, stream = ovs.stream.Stream.open_block(ovs.stream.Stream.open(name))
112     if error:
113         sys.stderr.write("could not open \"%s\": %s\n"
114                          % (name, os.strerror(error)))
115         sys.exit(1)
116
117     rpc = ovs.jsonrpc.Connection(stream)
118
119     error = rpc.send(msg)
120     if error:
121         sys.stderr.write("could not send request: %s\n" % os.strerror(error))
122         sys.exit(1)
123
124     error, msg = rpc.recv_block()
125     if error:
126         sys.stderr.write("error waiting for reply: %s\n" % os.strerror(error))
127         sys.exit(1)
128     
129     print ovs.json.to_string(msg.to_json())
130
131     rpc.close()
132     
133 def do_notify(name, method, params_string):
134     params = ovs.json.from_string(params_string)
135     msg = ovs.jsonrpc.Message.create_notify(method, params)
136     s = msg.is_valid()
137     if s:
138         sys.stderr.write("not a valid JSON-RPC notification: %s\n" % s)
139         sys.exit(1)
140
141     error, stream = ovs.stream.Stream.open_block(ovs.stream.Stream.open(name))
142     if error:
143         sys.stderr.write("could not open \"%s\": %s\n"
144                          % (name, os.strerror(error)))
145         sys.exit(1)
146
147     rpc = ovs.jsonrpc.Connection(stream)
148
149     error = rpc.send_block(msg)
150     if error:
151         sys.stderr.write("could not send notification: %s\n"
152                          % os.strerror(error))
153         sys.exit(1)
154
155     rpc.close()
156
157 def main(argv):
158     try:
159         options, args = getopt.gnu_getopt(
160             argv[1:], 'h', ["help"] + ovs.daemon.LONG_OPTIONS)
161     except getopt.GetoptError, geo:
162         sys.stderr.write("%s: %s\n" % (ovs.util.PROGRAM_NAME, geo.msg))
163         sys.exit(1)
164
165     for key, value in options:
166         if key in ['h', '--help']:
167             usage()
168         elif not ovs.daemon.parse_opt(key, value):
169             sys.stderr.write("%s: unhandled option %s\n"
170                              % (ovs.util.PROGRAM_NAME, key))
171             sys.exit(1)
172
173     commands = {"listen": (do_listen, 1),
174                 "request": (do_request, 3),
175                 "notify": (do_notify, 3),
176                 "help": (usage, (0,))}
177
178     command_name = args[0]
179     args = args[1:]
180     if not command_name in commands:
181         sys.stderr.write("%s: unknown command \"%s\" "
182                          "(use --help for help)\n" % (argv0, command_name))
183         sys.exit(1)
184
185     func, n_args = commands[command_name]
186     if type(n_args) == tuple:
187         if len(args) < n_args[0]:
188             sys.stderr.write("%s: \"%s\" requires at least %d arguments but "
189                              "only %d provided\n"
190                              % (argv0, command_name, n_args, len(args)))
191             sys.exit(1)
192     elif type(n_args) == int:
193         if len(args) != n_args:
194             sys.stderr.write("%s: \"%s\" requires %d arguments but %d "
195                              "provided\n"
196                              % (argv0, command_name, n_args, len(args)))
197             sys.exit(1)
198     else:
199         assert False
200
201     func(*args)
202
203 def usage():
204     sys.stdout.write("""\
205 %s: JSON-RPC test utility for Python
206 usage: %s [OPTIONS] COMMAND [ARG...]
207   listen LOCAL             listen for connections on LOCAL
208   request REMOTE METHOD PARAMS   send request, print reply
209   notify REMOTE METHOD PARAMS  send notification and exit
210 """ % (ovs.util.PROGRAM_NAME, ovs.util.PROGRAM_NAME))
211     ovs.stream.usage("JSON-RPC", True, True, True)
212     ovs.daemon.usage()
213     sys.stdout.write("""
214 Other options:
215   -h, --help              display this help message
216 """)
217     sys.exit(0)
218
219 if __name__ == '__main__':
220     main(sys.argv)
221