HTTP service that converts *.bc to *.nexe....

tests/translation_service/server.py

+import bc2nexe
+import time
+import sys
+import urlparse
+import urllib
+import tempfile
+import socket
+import thread
+from cache import *
+from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
+
+class TranslateHandler(BaseHTTPRequestHandler):
+    prefix = '/service?'
+    # 10Mb translation cache
+    cache = TranslationCache('./cache', 10 << 20)
+    def do_GET(self):
+        try:
+            print self.server.server_port, self.path
+            # You can't haz parent directories
+            path = os.path.normpath(self.path)
+            # Serve static data - for testing purposes
+            if not self.path.startswith(TranslateHandler.prefix):
+                f = open('.' + path, 'rb')
+                self.send_response(200)
+                self.end_headers()
+                self.wfile.write(f.read())
+                f.close()
+                return
+            params = path[len(TranslateHandler.prefix):]
+            params = urlparse.parse_qs(params, True)
+            if not params.has_key('arch'):
+                self.send_error(404, 'arch param not found')
+                return
+            arch = params['arch'][0]
+            if not arch in ['x86-32', 'x86-64', 'arm']:
+                self.send_error(404, 'arch param must be one of '
+                                'x86-32, x86-64, arm')
+                return
+            if not params.has_key('url'):
+                self.send_error(404, 'url param not found')
+            url = params['url'][0]
+            if not url.startswith('http://') and not url.startswith('https://'):
+                url = 'http://' + url
+            t0 = time.time()
+            tmpFile = tempfile.NamedTemporaryFile()
+            try:
+                _, message =  urllib.urlretrieve(url, tmpFile.name)
+                print "retrieve", "%.3f" % (time.time() - t0)
+                if url.endswith(".nexe"):
+                    self.send_response(200)
+                    self.send_header('Content-type', '')
+                    self.end_headers()
+                    self.wfile.write(tmpFile.read())
+                    return
+                outFile = None
+                try:
+                    nexe_file, bc_key = TranslateHandler.cache.get_nexe(
+                        tmpFile.name, (arch,))
+                    if nexe_file is None:
+                        inst = bc2nexe.Compiler('../../..')
+                        outFile = tempfile.NamedTemporaryFile()
+                        inst.generateNEXE([tmpFile.name], arch, outFile.name)
+                        TranslateHandler.cache.cache_nexe(
+                            tmpFile.name, outFile.name,
+                            (arch,), file_key = bc_key)
+                    else:
+                        outFile = open(nexe_file, 'rb')
+                    self.send_response(200)
+                    self.send_header('Content-type', 'application/x-nacl-srpc')
+                    self.end_headers()
+                    t0 = time.time()
+                    self.wfile.write(outFile.read())
+                    print "send", "%.3f" % (time.time() - t0)
+                finally:
+                    if not (outFile is None):
+                        outFile.close()
+            finally:
+                tmpFile.close()
+        except IOError, error:
+            print error
+            self.send_error(404, str(error))
+        except bc2nexe.TranslateError, error:
+            print error
+            self.send_error(500, str(error))
+def startserver(port):
+    try:
+        server = HTTPServer(('', port), TranslateHandler)
+        server.serve_forever()
+    except KeyboardInterrupt:
+        server.socket.close()
+        sys.exit(0)
+if __name__ == '__main__':
+    socket.setdefaulttimeout(30)
+    # Our servers are single-threaded, so we need one server to retrieve
+    # the bitcode and another server to compile it.
+    thread.start_new_thread(startserver, (4444,))
+    startserver(4445)