Debian Codegraph @

lang/py3/avro/tool.py

raw
1 #!/usr/bin/env python3
2 # -*- mode: python -*-
3 # -*- coding: utf-8 -*-
4
5 # Licensed to the Apache Software Foundation (ASF) under one
6 # or more contributor license agreements. See the NOTICE file
7 # distributed with this work for additional information
8 # regarding copyright ownership. The ASF licenses this file
9 # to you under the Apache License, Version 2.0 (the
10 # "License"); you may not use this file except in compliance
11 # with the License. You may obtain a copy of the License at
12 #
13 # http://www.apache.org/licenses/LICENSE-2.0
14 #
15 # Unless required by applicable law or agreed to in writing, software
16 # distributed under the License is distributed on an "AS IS" BASIS,
17 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 # See the License for the specific language governing permissions and
19 # limitations under the License.
20 """
21 Command-line tool
22
23 NOTE: The API for the command-line tool is experimental.
24 """
25
26 import sys
27 import urllib
28
29 from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler
30
31 from avro import io
32 from avro import datafile
33 from avro import protocol
34 from avro import ipc
35
36 class GenericResponder(ipc.Responder):
37 def __init__(self, proto, msg, datum):
38 proto_json = file(proto, 'r').read()
39 ipc.Responder.__init__(self, protocol.Parse(proto_json))
40 self.msg = msg
41 self.datum = datum
42
43 def invoke(self, message, request):
44 if message.name == self.msg:
45 print >> sys.stderr, "Message: %s Datum: %s" % (message.name, self.datum)
46 # server will shut down after processing a single Avro request
47 global server_should_shutdown
48 server_should_shutdown = True
49 return self.datum
50
51 class GenericHandler(BaseHTTPRequestHandler):
52 def do_POST(self):
53 self.responder = responder
54 call_request_reader = ipc.FramedReader(self.rfile)
55 call_request = call_request_reader.read_framed_message()
56 resp_body = self.responder.respond(call_request)
57 self.send_response(200)
58 self.send_header('Content-Type', 'avro/binary')
59 self.end_headers()
60 resp_writer = ipc.FramedWriter(self.wfile)
61 resp_writer.write_framed_message(resp_body)
62 if server_should_shutdown:
63 print >> sys.stderr, "Shutting down server."
64 self.server.force_stop()
65
66 class StoppableHTTPServer(HTTPServer):
67 """HTTPServer.shutdown added in Python 2.6. FML."""
68 stopped = False
69 allow_reuse_address = True
70 def __init__(self, *args, **kw):
71 HTTPServer.__init__(self, *args, **kw)
72 self.allow_reuse_address = True
73
74 def serve_forever(self):
75 while not self.stopped:
76 self.handle_request()
77
78 def force_stop(self):
79 self.server_close()
80 self.stopped = True
81 self.serve_forever()
82
83 def run_server(uri, proto, msg, datum):
84 url_obj = urllib.parse.urlparse(uri)
85 server_addr = (url_obj.hostname, url_obj.port)
86 global responder
87 global server_should_shutdown
88 server_should_shutdown = False
89 responder = GenericResponder(proto, msg, datum)
90 server = StoppableHTTPServer(server_addr, GenericHandler)
91 print("Port: %s" % server.server_port)
92 sys.stdout.flush()
93 server.allow_reuse_address = True
94 print >> sys.stderr, "Starting server."
95 server.serve_forever()
96
97 def send_message(uri, proto, msg, datum):
98 url_obj = urllib.parse.urlparse(uri)
99 client = ipc.HTTPTransceiver(url_obj.hostname, url_obj.port)
100 proto_json = file(proto, 'r').read()
101 requestor = ipc.Requestor(protocol.Parse(proto_json), client)
102 print(requestor.request(msg, datum))
103
104 def file_or_stdin(f):
105 if f == "-":
106 return sys.stdin
107 else:
108 return file(f)
109
110 def main(args=sys.argv):
111 if len(args) == 1:
112 print("Usage: %s [dump|rpcreceive|rpcsend]" % args[0])
113 return 1
114
115 if args[1] == "dump":
116 if len(args) != 3:
117 print("Usage: %s dump input_file" % args[0])
118 return 1
119 for d in datafile.DataFileReader(file_or_stdin(args[2]), io.DatumReader()):
120 print(repr(d))
121 elif args[1] == "rpcreceive":
122 usage_str = "Usage: %s rpcreceive uri protocol_file " % args[0]
123 usage_str += "message_name (-data d | -file f)"
124 if len(args) not in [5, 7]:
125 print(usage_str)
126 return 1
127 uri, proto, msg = args[2:5]
128 datum = None
129 if len(args) > 5:
130 if args[5] == "-file":
131 reader = open(args[6], 'rb')
132 datum_reader = io.DatumReader()
133 dfr = datafile.DataFileReader(reader, datum_reader)
134 datum = dfr.next()
135 elif args[5] == "-data":
136 print("JSON Decoder not yet implemented.")
137 return 1
138 else:
139 print(usage_str)
140 return 1
141 run_server(uri, proto, msg, datum)
142 elif args[1] == "rpcsend":
143 usage_str = "Usage: %s rpcsend uri protocol_file " % args[0]
144 usage_str += "message_name (-data d | -file f)"
145 if len(args) not in [5, 7]:
146 print(usage_str)
147 return 1
148 uri, proto, msg = args[2:5]
149 datum = None
150 if len(args) > 5:
151 if args[5] == "-file":
152 reader = open(args[6], 'rb')
153 datum_reader = io.DatumReader()
154 dfr = datafile.DataFileReader(reader, datum_reader)
155 datum = dfr.next()
156 elif args[5] == "-data":
157 print("JSON Decoder not yet implemented.")
158 return 1
159 else:
160 print(usage_str)
161 return 1
162 send_message(uri, proto, msg, datum)
163 return 0
164
165 if __name__ == "__main__":
166 sys.exit(main(sys.argv))