def start(client, data):
task1 = tulip.Task(foo(client))
task2 = tulip.Task(bar(client))
while True:
if task1.done() and task2.done():
client.log(task1.result())
client.log(task2.result())
break
else:
yield from tulip.sleep(1)
def run_briefly(loop):
@tulip.coroutine
def once():
pass
t = tulip.Task(once(), loop=loop)
loop.run_until_complete(t)
def print_headers(task):
response = task.result()
for k, v in response.items():
print('{}: {}'.format(k, v[:80]))
task = tulip.Task(response.read())
task.add_done_callback(print_body)
def scanport(port):
ippat = '10.1.10.%d'
loop = tulip.get_event_loop()
loop.add_signal_handler(signal.SIGINT, loop.stop)
futs = []
for x in range(1, 255):
host = ippat % x
print('trying', host, port, end='\r', flush=True)
fut = tulip.Task(loop.create_connection(Scanner, host, port),
timeout=1)
futs.append(fut)
loop.run_until_complete(tulip.sleep(0.001))
print()
for fut in futs:
try:
loop.run_until_complete(fut)
except tulip.CancelledError:
pass
except os.error as exc:
if exc.errno == 24:
print()
print(exc)
except Exception as exc:
print()
print(exc)
print()
loop.call_later(1, loop.stop)
loop.run_forever()
def handle_one_request(self, rline, message):
self.close()
# headers
headers = http.client.HTTPMessage()
for hdr, val in message.headers:
headers[hdr] = val
if 'websocket' in headers.get('UPGRADE', '').lower():
# init ws
wsclient = WebSocketProto()
status, headers = wsclient.serve(
headers, self.transport, self.rstream)
write = self.transport.write
write(b'HTTP/1.1 ' + status.encode())
for hdr in headers:
write(hdr)
write(b'\r\n')
if status.startswith('101'):
# start websocket
@tulip.coroutine
def rstream():
while True:
try:
data = yield from wsclient.receive()
if not data:
break
except:
break
data = data.strip()
print(data)
for wsc in self._connections:
if wsc is not wsclient:
wsc.send(data.encode())
print('Someone joined.')
for wsc in self._connections:
wsc.send(b'Someone joined.')
self._connections.append(wsclient)
t = tulip.Task(rstream())
done, pending = yield from tulip.wait([t])
assert t in done
assert not pending
self._connections.remove(wsclient)
print('Someone disconnected.')
for wsc in self._connections:
wsc.send(b'Someone disconnected.')
else:
write = self.transport.write
write(b'HTTP/1.0 200 Ok\r\n')
write(b'Content-type: text/html\r\n')
write(b'\r\n')
write(WS_SRV_HTML)
def switch_protocols():
ws_proto = websockets.WebSocketCommonProtocol()
# Disconnect transport from http_proto and connect it to ws_proto
http_proto.transport = DummyTransport()
transport._protocol = ws_proto
ws_proto.connection_made(transport)
# Run the WebSocket handler in a Tulip Task
tulip.Task(run_ws_handler(ws_proto))
def run_briefly(loop):
@tulip.coroutine
def once():
pass
gen = once()
t = tulip.Task(gen, loop=loop)
try:
loop.run_until_complete(t)
finally:
gen.close()
def create_connection_with_cb(on_result, on_error, loop, *args, **kw):
""" Calls loop.create_connection and runs it to the end.
On done calls on_result callback
"""
task = tulip.Task(loop.create_connection(*args, **kw), loop=loop)
def dispatch_result(task):
try:
on_result(*task.result())
except OSError as exc:
on_error(exc)
task.add_done_callback(dispatch_result)
def main(loop):
# program which prints evaluation of each expression from stdin
code = r'''if 1:
import os
def writeall(fd, buf):
while buf:
n = os.write(fd, buf)
buf = buf[n:]
while True:
s = os.read(0, 1024)
if not s:
break
s = s.decode('ascii')
s = repr(eval(s)) + '\n'
s = s.encode('ascii')
writeall(1, s)
'''
# commands to send to input
commands = iter([b"1+1\n", b"2**16\n", b"1/3\n", b"'x'*50", b"1/0\n"])
# start subprocess and wrap stdin, stdout, stderr
p = Popen([sys.executable, '-c', code],
stdin=PIPE,
stdout=PIPE,
stderr=PIPE)
stdin = yield from connect_write_pipe(p.stdin)
stdout, stdout_transport = yield from connect_read_pipe(p.stdout)
stderr, stderr_transport = yield from connect_read_pipe(p.stderr)
# interact with subprocess
name = {stdout: 'OUT', stderr: 'ERR'}
registered = {
tulip.Task(stderr.readline()): stderr,
tulip.Task(stdout.readline()): stdout
}
while registered:
# write command
cmd = next(commands, None)
if cmd is None:
stdin.close()
else:
print('>>>', cmd.decode('ascii').rstrip())
stdin.write(cmd)
# get and print lines from stdout, stderr
timeout = None
while registered:
done, pending = yield from tulip.wait(
registered, timeout=timeout, return_when=tulip.FIRST_COMPLETED)
if not done:
break
for f in done:
stream = registered.pop(f)
res = f.result()
print(name[stream], res.decode('ascii').rstrip())
if res != b'':
registered[tulip.Task(stream.readline())] = stream
timeout = 0.0
stdout_transport.close()
stderr_transport.close()
def request(method,
url,
*,
params=None,
data=None,
headers=None,
cookies=None,
files=None,
auth=None,
allow_redirects=True,
max_redirects=10,
encoding='utf-8',
version=(1, 1),
timeout=None,
compress=None,
chunked=None,
session=None,
loop=None):
"""Constructs and sends a request. Returns response object.
method: http method
url: request url
params: (optional) Dictionary or bytes to be sent in the query string
of the new request
data: (optional) Dictionary, bytes, or file-like object to
send in the body of the request
headers: (optional) Dictionary of HTTP Headers to send with the request
cookies: (optional) Dict object to send with the request
files: (optional) Dictionary of 'name': file-like-objects
for multipart encoding upload
auth: (optional) Auth tuple to enable Basic HTTP Auth
timeout: (optional) Float describing the timeout of the request
allow_redirects: (optional) Boolean. Set to True if POST/PUT/DELETE
redirect following is allowed.
compress: Boolean. Set to True if request has to be compressed
with deflate encoding.
chunked: Boolean or Integer. Set to chunk size for chunked
transfer encoding.
session: tulip.http.Session instance to support connection pooling and
session cookies.
loop: Optional event loop.
Usage:
import tulip.http
>> resp = yield from tulip.http.request('GET', 'http://python.org/')
>> resp
<HttpResponse(python.org/) [200]>
>> data = yield from resp.content.read()
"""
redirects = 0
if loop is None:
loop = tulip.get_event_loop()
while True:
req = HttpRequest(method,
url,
params=params,
headers=headers,
data=data,
cookies=cookies,
files=files,
auth=auth,
encoding=encoding,
version=version,
compress=compress,
chunked=chunked)
if session is None:
conn = start(req, loop)
else:
conn = session.start(req, loop)
# connection timeout
try:
resp = yield from tulip.Task(conn, timeout=timeout, loop=loop)
except tulip.CancelledError:
raise tulip.TimeoutError from None
# redirects
if resp.status in (301, 302) and allow_redirects:
redirects += 1
if max_redirects and redirects >= max_redirects:
resp.close()
break
r_url = resp.get('location') or resp.get('uri')
scheme = urllib.parse.urlsplit(r_url)[0]
if scheme not in ('http', 'https', ''):
raise ValueError('Can redirect only to http or https')
elif not scheme:
r_url = urllib.parse.urljoin(url, r_url)
url = urllib.parse.urldefrag(r_url)[0]
if url:
resp.close()
continue
break
return resp
def start_client(loop, host, port):
t = tulip.Task(loop.create_connection(EchoClient, host, port))
loop.run_until_complete(t)
def start_client(loop, addr):
t = tulip.Task(
loop.create_datagram_endpoint(MyClientUdpEchoProtocol,
remote_addr=addr))
loop.run_until_complete(t)
def start_server(loop, addr):
t = tulip.Task(
loop.create_datagram_endpoint(MyServerUdpEchoProtocol,
local_addr=addr))
loop.run_until_complete(t)
import tulip
from tulip import http
def print_headers(task):
response = task.result()
for k, v in response.items():
print('{}: {}'.format(k, v[:80]))
task = tulip.Task(response.read())
task.add_done_callback(print_body)
def print_body(task):
data = task.result()
print('\nReceived {} bytes.\n'.format(len(data)))
tulip.get_event_loop().stop()
if __name__ == '__main__':
loop = tulip.get_event_loop()
t = tulip.Task(http.request('GET', 'http://megafeihong.tumblr.com'))
t.add_done_callback(print_headers)
loop.run_forever()
ARGS = argparse.ArgumentParser(
description="websocket console client for wssrv.py example.")
ARGS.add_argument('--host',
action="store",
dest='host',
default='127.0.0.1',
help='Host name')
ARGS.add_argument('--port',
action="store",
dest='port',
default=8080,
type=int,
help='Port number')
if __name__ == '__main__':
args = ARGS.parse_args()
if ':' in args.host:
args.host, port = args.host.split(':', 1)
args.port = int(port)
url = 'http://{}:{}'.format(args.host, args.port)
loop = tulip.SelectorEventLoop(tulip.selectors.SelectSelector())
tulip.set_event_loop(loop)
loop.add_signal_handler(signal.SIGINT, loop.stop)
tulip.Task(start_client(loop, url))
loop.run_forever()
def connection_made(self, transport):
self.transport = transport
self.stream = tulip.StreamBuffer(loop=self._loop)
self._request_handler = tulip.Task(self.start(), loop=self._loop)
