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()
