def test_arecv_zero(): server = socketserver.TCPServer( ("127.0.0.1", random.randint(20000, 30000)), TcpEchoHandler) server_addr = server.server_address pcs = Process(target=server.serve_forever) pcs.start() io_engine = ioloop.get_ioloop("select") client = connection.TCPConnection(io_engine=io_engine) def on_recved(_, data, err): client.close() client.stop() assert not data def on_sent(conn, err): assert err.errcode == connection.E_OK os.kill(pcs.pid, signal.SIGTERM) conn.arecv(2048, on_recved) pcs.join() def on_connected(conn, err): assert err.errcode == connection.E_OK conn.asend(b'x' * 2048, on_sent) time.sleep(1) client.aconnect(server_addr, on_connected) client.run()
def __init__(self): self.HOST = "localhost" self.PORT = get_unused_port() self.httpd = socketserver.TCPServer((self.HOST, self.PORT), RequestHandler503) self.http_server_thread = threading.Thread(target=self.httpd.serve_forever) self.http_server_thread.start()
def handle(func): server = socketserver.TCPServer(("0.0.0.0", 9999), HandleHandler) server.request_queue_size = 1 # drop any connections except from the first server.timeout = None server.func = func server.handle_request() server.server_close()
def start_local_server(url_root, host=HOST, port=PORT, callback=None): """ Starts a local HTTP server with the site root pointing to the directory passed in as url_root. This function does not return - if using this in a GUI app, make sure to call this in a thread. If the host and port are not passed in, they default to "%s" and %s, respectively. If there's a callback function, it will call that once it starts the server. This is useful for taking an action like opening the site in a web browser once it is loaded. """ % (HOST, PORT) http_handler = SimpleHTTPServer.SimpleHTTPRequestHandler logging.info("Starting local server") httpd = socketserver.TCPServer((HOST, PORT), http_handler) try: root = os.path.abspath(url_root) os.chdir(root) hostname = HOST if HOST == "": hostname = "localhost" url = "http://%s:%d/" % (hostname, PORT) if callback: logging.info("callback being called") timer = threading.Timer(1.0, callback, (url, )) timer.start() httpd.serve_forever() except KeyboardInterrupt: httpd.socket.close()
def serve(c): """Serve site contents locally for development""" os.chdir("www/") httpd = socketserver.TCPServer((HTTP_HOST, int(HTTP_PORT)), SimpleHTTPServer.SimpleHTTPRequestHandler) print("Serving on http://{}:{}".format(httpd.socket.getsockname()[0], httpd.socket.getsockname()[1])) httpd.serve_forever()
def tcp_server_process(): server = socketserver.TCPServer( ("127.0.0.1", random.randint(20000, 30000)), TcpEchoHandler) server_addr = server.server_address pcs = Process(target=server.serve_forever) pcs.start() yield server_addr os.kill(pcs.pid, signal.SIGINT) pcs.join()
def initiateServer(self, address): self.address = (address[0], address[1] ) # Copy address & keep it for future reference... addr = ('0.0.0.0', address[1]) # Adapt to listen on 0.0.0.0 self.server = socketserver.TCPServer(addr, HTTPServerHandler) self.server.socket = ssl.wrap_socket(self.server.socket, certfile=self.certFile, server_side=True)
def __init__(self, address, port): """Creates a FakeBigQueryServer. Args: address: Server address port: Server port. Pass 0 to automatically pick an empty port. """ threading.Thread.__init__(self) self.handler = BigQueryRequestHandler self.httpd = socketserver.TCPServer((address, port), self.handler)
def http_server(dir, ip, port, quiet): """Use Python's Simple HTTP server to expose the image over HTTP for clair to grab it. """ sys.stderr.write("Serving Image to Clair from http://%s:%d\n" % (ip, port)) chdir(dir) if quiet: Handler = QuietSimpleHTTPHandler else: Handler = SimpleHTTPServer.SimpleHTTPRequestHandler httpd = socketserver.TCPServer((ip, port), Handler) httpd.serve_forever()
def serve(c): class MyHandler(SimpleHTTPServer.SimpleHTTPRequestHandler): def do_GET(self): # The URL does not include ".html". Add it to serve the file for dev if "/aws/" in self.path: self.path += ".html" SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self) """Serve site contents locally for development""" os.chdir("www/") httpd = socketserver.TCPServer((HTTP_HOST, int(HTTP_PORT)), MyHandler) print("Serving on http://{}:{}".format(httpd.socket.getsockname()[0], httpd.socket.getsockname()[1])) httpd.serve_forever()
def __init__(self, address, port): """Creates a FakeBigQueryServer. Args: address: Server address port: Server port. Pass 0 to automatically pick an empty port. """ threading.Thread.__init__(self) self.handler = BigQueryRequestHandler try: self.httpd = socketserver.TCPServer((address, port), self.handler) self.host_port = "{}:{}".format(*self.httpd.server_address) except IOError: self.httpd = IPv6TCPServer((address, port), self.handler) self.host_port = "[{}]:{}".format(*self.httpd.server_address)
def __init__(self, address, service): super(self.__class__, self).__init__() if HTTPServerHandler.uuid is None: HTTPServerHandler.uuid = ''.join( random.choice(string.ascii_letters + string.digits) for _ in range(48)) HTTPServerHandler.service = service self.certFile = createSelfSignedCert() self.server = socketserver.TCPServer(address, HTTPServerHandler) self.server.socket = ssl.wrap_socket(self.server.socket, certfile=self.certFile, server_side=True)
def view_html(): port = settings.HTML_PORT os.chdir("%s%s%s" % (settings.OUTPUT_DIR, os.sep, "html")) handler = SimpleHTTPServer.SimpleHTTPRequestHandler while True: try: httpd = socketserver.TCPServer(("", port), handler) break except socket_error as err: if not err.errno == errno.EADDRINUSE: raise err warning("Port already in use, trying %i" % (port + 1)) port += 1 webbrowser.open("http://localhost:%i" % port, autoraise=True) httpd.serve_forever()
def udp_server_process(): s1 = socketserver.UDPServer(("127.0.0.1", random.randint(20000, 30000)), UdpEcho1Handler) server_addr1 = s1.server_address p1 = Process(target=s1.serve_forever) p1.start() s2 = socketserver.TCPServer(("127.0.0.1", random.randint(20000, 30000)), TcpEchoHandler) server_addr2 = s2.server_address p2 = Process(target=s2.serve_forever) p2.start() yield (server_addr1, server_addr2) p1.terminate() p2.terminate()
def temporary_http_file_server(self, stream): '''Serve data from an IO stream over HTTP.''' class Handler(BaseHTTPServer.BaseHTTPRequestHandler): def do_GET(self): self.send_response(200) self.send_header('Content-Type', 'application/x-tar') self.end_headers() shutil.copyfileobj(stream, self.wfile) server = socketserver.TCPServer(('', 0), Handler) thread = threading.Thread(target=server.serve_forever) thread.setDaemon(True) thread.start() yield 'http://%s:%s' % (socket.gethostname(), server.server_address[1]) server.shutdown()
def _run_webserver(workers, accessor, opts): def handle_health_request(request): path = request.path.strip("/") if path != "health": return False statusOk = all(w["thread"].is_alive() for w in workers.values()) if statusOk: request.send_response(200) request.end_headers() request.wfile.write("OK") else: request.send_response(503) request.end_headers() request.wfile.write("FAILURE: some thread(s) are down\n") for worker in workers.values(): request.wfile.write( "%s is %s\n" % (worker["name"], "OK" if worker["thread"].is_alive() else "KO")) return True def handle_worker_request(request): worker = workers.get(request.path.strip("/"), None) workers_to_display = [worker] if worker else workers.values() request.send_response(200) request.end_headers() for worker in workers_to_display: request.wfile.write(worker["name"] + " ::::::::::::::::::::::\n") if worker["status"]: request.wfile.write('\nStatus: ' + worker["status"] + '\n') request.wfile.write('\n'.join(worker["output"])) request.wfile.write('\n\n') http_handler = SimpleHTTPServer.SimpleHTTPRequestHandler http_handler.do_GET = lambda req: handle_health_request( req) or handle_worker_request(req) logging.info("Starting http server on %s" % opts.listen_on) SocketServer.TCPServer.allow_reuse_address = True http_server = SocketServer.TCPServer(("", opts.listen_on), http_handler) http_server.serve_forever()
def start_server(self): config.public_path self.port os.chdir(config.public_path) Handler = SimpleHTTPServer.SimpleHTTPRequestHandler socketserver.TCPServer.allow_reuse_address = True httpd = socketserver.TCPServer(("", self.port), Handler) logger.info("Serving at: localhost:{}".format(self.port)) try: httpd.serve_forever() except KeyboardInterrupt: logger.info('Stopping server...') httpd.server_close()
def _launch_on_first_available_port(first_port): Handler = QuietHTTPRequestHandler port = first_port while True: try: httpd = socketserver.TCPServer(('', port), Handler) # print 'Serving on port', port ARTEMIS_LOGGER.warn("Serving Plots at http://localhost:%s" % (port, )) httpd.serve_forever() except socketserver.socket.error as exc: if exc.args[0] == 48 or exc.args[0] == 98: ARTEMIS_LOGGER.info('Port', port, 'already in use') port += 1 else: raise else: break
def server_in_tempdir(parent, prefix): """Create a server in a temporary directory, shutting down on exit.""" import threading from six.moves import socketserver # suppress(import-error) from six.moves import SimpleHTTPServer # suppress(import-error) with in_tempdir(parent, prefix) as temp_dir: class QuietHTTPHandler(SimpleHTTPServer.SimpleHTTPRequestHandler, object): """Custom SimpleHTTPRequestHandler, does not log messages.""" def log_message(self, message, *args): """Ignore message.""" pass def do_GET(self): # suppress(N802) """Change into temp_dir and then chain up. The reason why we need to do this is that the underlying SimpleHTTPRequestHandler object queries the directory that we are currently in, as opposed to the directory that the server was created in. If the user changes their active directory (as is done in the tests) then requests will be resolved relative to that directory, which is an error. """ with in_dir(temp_dir): return super(QuietHTTPHandler, self).do_GET() server = socketserver.TCPServer(("localhost", 0), QuietHTTPHandler) thread = threading.Thread(target=server.serve_forever) thread.start() try: yield (temp_dir, "{0}:{1}".format(server.server_address[0], server.server_address[1])) finally: server.shutdown() thread.join()
def startWebServer(path): # check the default web server if not os.path.exists(path): os.makedirs(path) testpath = os.path.join(path, 'test') with open(testpath, 'w') as f: f.write(path) default_uri = 'http://%s:%d/%s' % (socket.gethostname(), DEFAULT_WEB_PORT, os.path.basename(path)) try: data = urllib.request.urlopen(default_uri + '/' + 'test').read() if data == path.encode('utf-8'): return default_uri except IOError: pass logger.warning('default webserver at %s not available', DEFAULT_WEB_PORT) LocalizedHTTP.basedir = os.path.dirname(path) ss = socketserver.TCPServer(('0.0.0.0', 0), LocalizedHTTP) spawn(ss.serve_forever) uri = 'http://%s:%d/%s' % (socket.gethostname(), ss.server_address[1], os.path.basename(path)) return uri
def main(): parser = argparse.ArgumentParser() parser.add_argument('-p', '--port', help='port to listen on', default=8000) parser.add_argument('-i', '--pid', help='PID filename', default='httpserver.pid') parser.add_argument('--host', help='Network interface to bind to', default='127.0.0.1') args = parser.parse_args() server_address = (args.host, int(args.port)) handler = SimpleHTTPServer.SimpleHTTPRequestHandler httpd = socketserver.TCPServer( server_address, handler, bind_and_activate=False ) # Allow address reuse to avoid bind to fail due to TIME_WAIT # connections httpd.allow_reuse_address = True httpd.server_bind() httpd.server_activate() signal.signal(signal.SIGINT, sigterm_handler) signal.signal(signal.SIGTERM, sigterm_handler) pid = os.fork() if pid: # parent with open(args.pid, 'w') as f: f.write(str(pid)) sys.exit(0) else: # child try: httpd.serve_forever() finally: os.unlink(args.pid) sys.exit(1)
def setUp(self): # disable insecure requests warning, obviously they are not secure! from requests.packages.urllib3.exceptions import InsecureRequestWarning requests.packages.urllib3.disable_warnings(InsecureRequestWarning) self.account_key = jose.JWK.load( test_util.load_vector('rsa1024_key.pem')) self.resources = set() # pylint: disable=no-member self.redirect_server = socketserver.TCPServer(('', 0), RedirectHandler) self.port = self.redirect_server.socket.getsockname()[1] self.redirect_thread = threading.Thread( target=self.redirect_server.serve_forever) self.redirect_thread.start() from acme.standalone import HTTP01TLSServer self.server = HTTP01TLSServer(('', 0), self.resources) self.thread = threading.Thread(target=self.server.serve_forever) self.thread.start() # make sure the redirect server directs to the port where the TLS # server is running RedirectHandler.port = self.server.socket.getsockname()[1]
def setup_delayed_server(self, delay): server = socketserver.TCPServer(("", 0), get_delayed_handler(delay)) thread = threading.Thread(target=server.serve_forever) thread.daemon = True thread.start() return server
def main(): port = 8000 handler = RequestHandler httpd = socketserver.TCPServer(("", port), handler) httpd.serve_forever()
def __init__(self): self.port = find_available_port() self.handler = SimpleHTTPServer.SimpleHTTPRequestHandler self.httpd = socketserver.TCPServer(("", self.port), self.handler) self.close_signal = threading.Event() self.server_started = False
def main(): Handler = MyHandler httpd = socketserver.TCPServer(("", port), Handler) httpd.serve_forever()
def create_server(port=0): handler = HttpHandler server = socketserver.TCPServer(("", port), handler) return server
self.handler.feed(self.request.recv(1024)) def client(): def message_received(frame): print(frame) s = socket.socket() s.connect(('127.0.0.1', 7070)) proto_handler = StreamProtocolHandler(EchoProtocolFrame, message_received) while True: input = raw_input("Data to send: ") request = EchoProtocolFrame() request.frame_type = FRAME_TYPE_ECHO_REQUEST request.payload = input s.sendall(request.pack()) # to handle asynchronous messages, this would be done asynchronously proto_handler.feed(s.recv(1024)) if __name__ == '__main__': if len(sys.argv) != 2: print("Usage Client: %s -c" % sys.argv[0]) print("Usage Server: %s -s" % sys.argv[1]) if sys.argv[1] == '-c': client() elif sys.argv[1] == '-s': server = socketserver.TCPServer(('0.0.0.0', 7070), EchoTCPHandler) server.serve_forever()
def start_server(host, port, config, serving_state, backend_service_fn, preprocess_fn, translate_fn, postprocess_fn): """Start a serving service. This function will only return on SIGINT or SIGTERM signals. Args: host: The hostname of the service. port: The port used by the service. serving_state: The framework state to propagate to pre/postprocessing callbacks. backend_service_fn: A callable to start the framework dependent backend service. preprocess_fn: A callable taking (serving_state, text) and returning tokens. translation_fn: A callable that forwards the request to the translation backend. postprocess_fn: A callable taking (serving_state, tokens) and returning text. """ global backend_process global backend_info backend_process, backend_info = backend_service_fn() global_timeout = None global_max_batch_size = None if config is not None and isinstance(config, dict): global_timeout = config.get('timeout') global_max_batch_size = config.get('max_batch_size') class ServerHandler(SimpleHTTPServer.SimpleHTTPRequestHandler): def do_POST(self): if self.path == '/translate': self.translate() elif self.path == '/unload_model': self.unload_model() elif self.path == '/reload_model': self.reload_model() else: self.send_error(404, 'invalid route %s' % self.path) def translate(self): global backend_process if backend_process is not None and not _process_is_running( backend_process): self.send_error(503, 'backend service is unavailable') return content_len = int(self.headers.getheader('content-length', 0)) if content_len == 0: self.send_error(400, 'missing request data') return post_body = self.rfile.read(content_len) try: body = json.loads(post_body) except ValueError: self.send_error(400, 'badly formatted JSON data') return self.handle_request(body) def unload_model(self): global backend_process global backend_info if backend_process is not None and _process_is_running( backend_process): backend_process.terminate() backend_process = None backend_info = None self.send_response(200) def reload_model(self): global backend_process global backend_info if backend_process is not None and _process_is_running( backend_process): backend_process.terminate() backend_process, backend_info = backend_service_fn() self.send_response(200) def send_result(self, result): self.send_response(200) self.send_header('Content-type', 'application/json') self.end_headers() self.wfile.write(json.dumps(result)) def handle_request(self, request): if 'src' not in request: self.send_error(400, 'missing src field') return results = {'tgt': []} if not request['src']: self.send_result(results) return if not isinstance(request['src'], list): self.send_error(400, 'src field must be a list') return timeout = global_timeout max_batch_size = global_max_batch_size if 'options' in request and isinstance(request['options'], dict): timeout = request['options'].get('timeout', timeout) max_batch_size = request['options'].get( 'max_batch_size', max_batch_size) batch_tokens = [ preprocess_fn(serving_state, src['text']) for src in request['src'] ] if max_batch_size is not None and len( batch_tokens) > max_batch_size: offset = 0 batch_hypotheses = [] while offset < len(batch_tokens): lower_bound = offset upper_bound = min(offset + max_batch_size, len(batch_tokens)) batch_hypotheses.extend( translate_fn(batch_tokens[lower_bound:upper_bound], backend_info, timeout=timeout)) offset = upper_bound else: batch_hypotheses = translate_fn(batch_tokens, backend_info, timeout=timeout) if batch_hypotheses is None: self.send_error(504, 'translation request timed out') return for src_tokens, hypotheses in zip(batch_tokens, batch_hypotheses): result = [] for output in hypotheses: tgt = {} tgt['text'] = postprocess_fn(serving_state, output.output) if output.score is not None: tgt['score'] = output.score if output.attention is not None: tgt['align'] = _align(src_tokens, output.output, output.attention) result.append(tgt) results['tgt'].append(result) self.send_result(results) try: frontend_server = socketserver.TCPServer((host, port), ServerHandler) except socket.error as e: if backend_process is not None: backend_process.terminate() raise e def shutdown(signum, frame): frontend_server.shutdown() if backend_process is not None: backend_process.terminate() signal.signal(signal.SIGINT, shutdown) signal.signal(signal.SIGTERM, shutdown) logger.info('Serving model on port %d', port) server_thread = threading.Thread(target=frontend_server.serve_forever) server_thread.start() while server_thread.is_alive(): time.sleep(1) frontend_server.server_close()
def guess_type(self, path): """Guess at the mime type for the specified file. """ mimetype = srvmod.SimpleHTTPRequestHandler.guess_type(self, path) # If the default guess is too generic, try the python-magic library if mimetype == 'application/octet-stream' and magic_from_file: mimetype = magic_from_file(path, mime=True) return mimetype if __name__ == '__main__': PORT = len(sys.argv) in (2, 3) and int(sys.argv[1]) or 8000 SERVER = len(sys.argv) == 3 and sys.argv[2] or "" socketserver.TCPServer.allow_reuse_address = True try: httpd = socketserver.TCPServer( (SERVER, PORT), ComplexHTTPRequestHandler) except OSError as e: logging.error("Could not listen on port %s, server %s.", PORT, SERVER) sys.exit(getattr(e, 'exitcode', 1)) logging.info("Serving at port %s, server %s.", PORT, SERVER) try: httpd.serve_forever() except KeyboardInterrupt as e: logging.info("Shutting down server.") httpd.socket.close()