Here are the examples of the python api aiohttp.ws_connect taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
21 Examples
3
Example 1
@asyncio.coroutine
def websocket_query(self, path, params={}):
"""
Open a websocket connection
:param path: Endpoint in API
:param params: Parameters added as a query arg
:returns: Websocket
"""
url = "http://docker/" + path
connection = yield from aiohttp.ws_connect(url,
connector=(yield from self.connector()),
origin="http://docker",
autoping=True)
return connection
3
Example 2
@asyncio.coroutine
def test_ws_connect_with_origin(key_data, loop):
resp = mock.Mock()
resp.status = 403
with mock.patch('aiohttp.client.os') as m_os:
with mock.patch('aiohttp.client.ClientSession.get') as m_req:
m_os.urandom.return_value = key_data
m_req.return_value = helpers.create_future(loop)
m_req.return_value.set_result(resp)
origin = 'https://example.org/page.html'
with pytest.raises(errors.WSServerHandshakeError):
yield from aiohttp.ws_connect('http://test.org',
loop=loop,
origin=origin)
assert hdrs.ORIGIN in m_req.call_args[1]["headers"]
assert m_req.call_args[1]["headers"][hdrs.ORIGIN] == origin
3
Example 3
@asyncio.coroutine
def _websocket(self, url, **params):
if not params:
params = {
'stdout': 1,
'stderr': 1,
'stream': 1
}
url = self._endpoint(url) + "?" + urllib.parse.urlencode(params)
ws = yield from aiohttp.ws_connect(url, connector=self.connector)
return ws
2
Example 4
def client(loop, url, name):
ws = yield from aiohttp.ws_connect(url + '/getCaseCount')
num_tests = int((yield from ws.receive()).data)
print('running %d cases' % num_tests)
yield from ws.close()
for i in range(1, num_tests + 1):
print('running test case:', i)
text_url = url + '/runCase?case=%d&agent=%s' % (i, name)
ws = yield from aiohttp.ws_connect(text_url)
while True:
msg = yield from ws.receive()
if msg.type == aiohttp.MsgType.text:
ws.send_str(msg.data)
elif msg.type == aiohttp.MsgType.binary:
ws.send_bytes(msg.data)
elif msg.type == aiohttp.MsgType.close:
yield from ws.close()
break
else:
break
url = url + '/updateReports?agent=%s' % name
ws = yield from aiohttp.ws_connect(url)
yield from ws.close()
0
Example 5
def _connect(self,
conn_type,
session,
force_close,
force_release,
pool):
future = self._future_class()
loop = self._connector._loop
ws = aiohttp.ws_connect(
self._url, connector=self._connector, loop=loop)
if self._timeout:
future_conn = asyncio.wait_for(ws, self._timeout, loop=self._loop)
else:
future_conn = asyncio.async(ws, loop=self._loop)
def on_connect(f):
try:
conn = f.result()
# Need to figure out some errors
except Exception as e:
future.set_exception(e)
else:
resp = Response(conn, self._future_class, loop=self._loop)
gc = conn_type(resp, self._future_class, self._timeout,
self._username, self._password, self._loop,
force_close, pool, force_release, session)
future.set_result(gc)
future_conn.add_done_callback(on_connect)
return future
0
Example 6
def start_client(loop, url):
name = input('Please enter your name: ')
# send request
ws = yield from aiohttp.ws_connect(url, autoclose=False, autoping=False)
# input reader
def stdin_callback():
line = sys.stdin.buffer.readline().decode('utf-8')
if not line:
loop.stop()
else:
ws.send_str(name + ': ' + line)
loop.add_reader(sys.stdin.fileno(), stdin_callback)
@asyncio.coroutine
def dispatch():
while True:
msg = yield from ws.receive()
if msg.type == aiohttp.WSMsgType.TEXT:
print('Text: ', msg.data.strip())
elif msg.type == aiohttp.WSMsgType.BINARY:
print('Binary: ', msg.data)
elif msg.type == aiohttp.WSMsgType.PING:
ws.pong()
elif msg.type == aiohttp.WSMsgType.PONG:
print('Pong received')
else:
if msg.type == aiohttp.WSMsgType.CLOSE:
yield from ws.close()
elif msg.type == aiohttp.WSMsgType.ERROR:
print('Error during receive %s' % ws.exception())
elif msg.type == aiohttp.WSMsgType.CLOSED:
pass
break
yield from dispatch()
0
Example 7
@asyncio.coroutine
def test_ws_connect(ws_key, loop, key_data):
resp = mock.Mock()
resp.status = 101
resp.headers = {
hdrs.UPGRADE: hdrs.WEBSOCKET,
hdrs.CONNECTION: hdrs.UPGRADE,
hdrs.SEC_WEBSOCKET_ACCEPT: ws_key,
hdrs.SEC_WEBSOCKET_PROTOCOL: 'chat'
}
with mock.patch('aiohttp.client.os') as m_os:
with mock.patch('aiohttp.client.ClientSession.get') as m_req:
m_os.urandom.return_value = key_data
m_req.return_value = helpers.create_future(loop)
m_req.return_value.set_result(resp)
res = yield from aiohttp.ws_connect(
'http://test.org',
protocols=('t1', 't2', 'chat'),
loop=loop)
assert isinstance(res, ClientWebSocketResponse)
assert res.protocol == 'chat'
assert hdrs.ORIGIN not in m_req.call_args[1]["headers"]
0
Example 8
@asyncio.coroutine
def test_ws_connect_custom_response(loop, ws_key, key_data):
class CustomResponse(ClientWebSocketResponse):
def read(self, decode=False):
return 'customized!'
resp = mock.Mock()
resp.status = 101
resp.headers = {
hdrs.UPGRADE: hdrs.WEBSOCKET,
hdrs.CONNECTION: hdrs.UPGRADE,
hdrs.SEC_WEBSOCKET_ACCEPT: ws_key,
}
with mock.patch('aiohttp.client.os') as m_os:
with mock.patch('aiohttp.client.ClientSession.get') as m_req:
m_os.urandom.return_value = key_data
m_req.return_value = helpers.create_future(loop)
m_req.return_value.set_result(resp)
res = yield from aiohttp.ws_connect(
'http://test.org',
ws_response_class=CustomResponse,
loop=loop)
assert res.read() == 'customized!'
0
Example 9
@asyncio.coroutine
def test_ws_connect_global_loop(loop, ws_key, key_data):
asyncio.set_event_loop(loop)
resp = mock.Mock()
resp.status = 101
resp.headers = {
hdrs.UPGRADE: hdrs.WEBSOCKET,
hdrs.CONNECTION: hdrs.UPGRADE,
hdrs.SEC_WEBSOCKET_ACCEPT: ws_key
}
with mock.patch('aiohttp.client.os') as m_os:
with mock.patch('aiohttp.client.ClientSession.get') as m_req:
m_os.urandom.return_value = key_data
m_req.return_value = helpers.create_future(loop)
m_req.return_value.set_result(resp)
resp = yield from aiohttp.ws_connect('http://test.org')
assert resp._loop is loop
asyncio.set_event_loop(None)
0
Example 10
@asyncio.coroutine
def test_ws_connect_err_status(loop, ws_key, key_data):
resp = mock.Mock()
resp.status = 500
resp.headers = {
hdrs.UPGRADE: hdrs.WEBSOCKET,
hdrs.CONNECTION: hdrs.UPGRADE,
hdrs.SEC_WEBSOCKET_ACCEPT: ws_key
}
with mock.patch('aiohttp.client.os') as m_os:
with mock.patch('aiohttp.client.ClientSession.get') as m_req:
m_os.urandom.return_value = key_data
m_req.return_value = helpers.create_future(loop)
m_req.return_value.set_result(resp)
with pytest.raises(errors.WSServerHandshakeError) as ctx:
yield from aiohttp.ws_connect('http://test.org',
protocols=('t1', 't2', 'chat'),
loop=loop)
assert ctx.value.message == 'Invalid response status'
0
Example 11
@asyncio.coroutine
def test_ws_connect_err_upgrade(loop, ws_key, key_data):
resp = mock.Mock()
resp.status = 101
resp.headers = {
hdrs.UPGRADE: 'test',
hdrs.CONNECTION: hdrs.UPGRADE,
hdrs.SEC_WEBSOCKET_ACCEPT: ws_key
}
with mock.patch('aiohttp.client.os') as m_os:
with mock.patch('aiohttp.client.ClientSession.get') as m_req:
m_os.urandom.return_value = key_data
m_req.return_value = helpers.create_future(loop)
m_req.return_value.set_result(resp)
with pytest.raises(errors.WSServerHandshakeError) as ctx:
yield from aiohttp.ws_connect('http://test.org',
protocols=('t1', 't2', 'chat'),
loop=loop)
assert ctx.value.message == 'Invalid upgrade header'
0
Example 12
@asyncio.coroutine
def test_ws_connect_err_conn(loop, ws_key, key_data):
resp = mock.Mock()
resp.status = 101
resp.headers = {
hdrs.UPGRADE: hdrs.WEBSOCKET,
hdrs.CONNECTION: 'close',
hdrs.SEC_WEBSOCKET_ACCEPT: ws_key
}
with mock.patch('aiohttp.client.os') as m_os:
with mock.patch('aiohttp.client.ClientSession.get') as m_req:
m_os.urandom.return_value = key_data
m_req.return_value = helpers.create_future(loop)
m_req.return_value.set_result(resp)
with pytest.raises(errors.WSServerHandshakeError) as ctx:
yield from aiohttp.ws_connect('http://test.org',
protocols=('t1', 't2', 'chat'),
loop=loop)
assert ctx.value.message == 'Invalid connection header'
0
Example 13
@asyncio.coroutine
def test_ws_connect_err_challenge(loop, ws_key, key_data):
resp = mock.Mock()
resp.status = 101
resp.headers = {
hdrs.UPGRADE: hdrs.WEBSOCKET,
hdrs.CONNECTION: hdrs.UPGRADE,
hdrs.SEC_WEBSOCKET_ACCEPT: 'asdfasdfasdfasdfasdfasdf'
}
with mock.patch('aiohttp.client.os') as m_os:
with mock.patch('aiohttp.client.ClientSession.get') as m_req:
m_os.urandom.return_value = key_data
m_req.return_value = helpers.create_future(loop)
m_req.return_value.set_result(resp)
with pytest.raises(errors.WSServerHandshakeError) as ctx:
yield from aiohttp.ws_connect('http://test.org',
protocols=('t1', 't2', 'chat'),
loop=loop)
assert ctx.value.message == 'Invalid challenge response'
0
Example 14
@asyncio.coroutine
def test_close(loop, ws_key, key_data):
resp = mock.Mock()
resp.status = 101
resp.headers = {
hdrs.UPGRADE: hdrs.WEBSOCKET,
hdrs.CONNECTION: hdrs.UPGRADE,
hdrs.SEC_WEBSOCKET_ACCEPT: ws_key,
}
with mock.patch('aiohttp.client.WebSocketWriter') as WebSocketWriter:
with mock.patch('aiohttp.client.os') as m_os:
with mock.patch('aiohttp.client.ClientSession.get') as m_req:
m_os.urandom.return_value = key_data
m_req.return_value = helpers.create_future(loop)
m_req.return_value.set_result(resp)
writer = WebSocketWriter.return_value = mock.Mock()
reader = mock.Mock()
resp.connection.reader.set_parser.return_value = reader
resp = yield from aiohttp.ws_connect('http://test.org',
loop=loop)
assert not resp.closed
msg = aiohttp.WSMessage(aiohttp.MsgType.CLOSE, b'', b'')
reader.read.return_value = helpers.create_future(loop)
reader.read.return_value.set_result(msg)
res = yield from resp.close()
writer.close.assert_called_with(1000, b'')
assert resp.closed
assert res
assert resp.exception() is None
# idempotent
res = yield from resp.close()
assert not res
assert writer.close.call_count == 1
0
Example 15
@asyncio.coroutine
def test_close_exc(loop, ws_key, key_data):
resp = mock.Mock()
resp.status = 101
resp.headers = {
hdrs.UPGRADE: hdrs.WEBSOCKET,
hdrs.CONNECTION: hdrs.UPGRADE,
hdrs.SEC_WEBSOCKET_ACCEPT: ws_key,
}
with mock.patch('aiohttp.client.WebSocketWriter') as WebSocketWriter:
with mock.patch('aiohttp.client.os') as m_os:
with mock.patch('aiohttp.client.ClientSession.get') as m_req:
m_os.urandom.return_value = key_data
m_req.return_value = helpers.create_future(loop)
m_req.return_value.set_result(resp)
WebSocketWriter.return_value = mock.Mock()
reader = mock.Mock()
resp.connection.reader.set_parser.return_value = reader
resp = yield from aiohttp.ws_connect('http://test.org',
loop=loop)
assert not resp.closed
exc = ValueError()
reader.read.return_value = helpers.create_future(loop)
reader.read.return_value.set_exception(exc)
yield from resp.close()
assert resp.closed
assert resp.exception() is exc
0
Example 16
@asyncio.coroutine
def test_close_exc2(loop, ws_key, key_data):
resp = mock.Mock()
resp.status = 101
resp.headers = {
hdrs.UPGRADE: hdrs.WEBSOCKET,
hdrs.CONNECTION: hdrs.UPGRADE,
hdrs.SEC_WEBSOCKET_ACCEPT: ws_key,
}
with mock.patch('aiohttp.client.WebSocketWriter') as WebSocketWriter:
with mock.patch('aiohttp.client.os') as m_os:
with mock.patch('aiohttp.client.ClientSession.get') as m_req:
m_os.urandom.return_value = key_data
m_req.return_value = helpers.create_future(loop)
m_req.return_value.set_result(resp)
writer = WebSocketWriter.return_value = mock.Mock()
resp.connection.reader.set_parser.return_value = mock.Mock()
resp = yield from aiohttp.ws_connect('http://test.org',
loop=loop)
assert not resp.closed
exc = ValueError()
writer.close.side_effect = exc
yield from resp.close()
assert resp.closed
assert resp.exception() is exc
resp._closed = False
writer.close.side_effect = asyncio.CancelledError()
with pytest.raises(asyncio.CancelledError):
yield from resp.close()
0
Example 17
@asyncio.coroutine
def test_send_data_after_close(ws_key, key_data, loop):
resp = mock.Mock()
resp.status = 101
resp.headers = {
hdrs.UPGRADE: hdrs.WEBSOCKET,
hdrs.CONNECTION: hdrs.UPGRADE,
hdrs.SEC_WEBSOCKET_ACCEPT: ws_key,
}
with mock.patch('aiohttp.client.WebSocketWriter') as WebSocketWriter:
with mock.patch('aiohttp.client.os') as m_os:
with mock.patch('aiohttp.client.ClientSession.get') as m_req:
m_os.urandom.return_value = key_data
m_req.return_value = helpers.create_future(loop)
m_req.return_value.set_result(resp)
WebSocketWriter.return_value = mock.Mock()
resp = yield from aiohttp.ws_connect('http://test.org',
loop=loop)
resp._closed = True
pytest.raises(RuntimeError, resp.ping)
pytest.raises(RuntimeError, resp.pong)
pytest.raises(RuntimeError, resp.send_str, 's')
pytest.raises(RuntimeError, resp.send_bytes, b'b')
pytest.raises(RuntimeError, resp.send_json, {})
0
Example 18
@asyncio.coroutine
def test_send_data_type_errors(ws_key, key_data, loop):
resp = mock.Mock()
resp.status = 101
resp.headers = {
hdrs.UPGRADE: hdrs.WEBSOCKET,
hdrs.CONNECTION: hdrs.UPGRADE,
hdrs.SEC_WEBSOCKET_ACCEPT: ws_key,
}
with mock.patch('aiohttp.client.WebSocketWriter') as WebSocketWriter:
with mock.patch('aiohttp.client.os') as m_os:
with mock.patch('aiohttp.client.ClientSession.get') as m_req:
m_os.urandom.return_value = key_data
m_req.return_value = helpers.create_future(loop)
m_req.return_value.set_result(resp)
WebSocketWriter.return_value = mock.Mock()
resp = yield from aiohttp.ws_connect('http://test.org',
loop=loop)
pytest.raises(TypeError, resp.send_str, b's')
pytest.raises(TypeError, resp.send_bytes, 'b')
pytest.raises(TypeError, resp.send_json, set())
0
Example 19
@asyncio.coroutine
def test_reader_read_exception(ws_key, key_data, loop):
hresp = mock.Mock()
hresp.status = 101
hresp.headers = {
hdrs.UPGRADE: hdrs.WEBSOCKET,
hdrs.CONNECTION: hdrs.UPGRADE,
hdrs.SEC_WEBSOCKET_ACCEPT: ws_key,
}
with mock.patch('aiohttp.client.WebSocketWriter') as WebSocketWriter:
with mock.patch('aiohttp.client.os') as m_os:
with mock.patch('aiohttp.client.ClientSession.get') as m_req:
m_os.urandom.return_value = key_data
m_req.return_value = helpers.create_future(loop)
m_req.return_value.set_result(hresp)
WebSocketWriter.return_value = mock.Mock()
reader = mock.Mock()
hresp.connection.reader.set_parser.return_value = reader
resp = yield from aiohttp.ws_connect('http://test.org',
loop=loop)
exc = ValueError()
reader.read.return_value = helpers.create_future(loop)
reader.read.return_value.set_exception(exc)
msg = yield from resp.receive()
assert msg.type == aiohttp.MsgType.ERROR
assert msg.type is msg.tp
assert resp.exception() is exc
0
Example 20
@asyncio.coroutine
def test_ws_connect_close_resp_on_err(loop, ws_key, key_data):
resp = mock.Mock()
resp.status = 500
resp.headers = {
hdrs.UPGRADE: hdrs.WEBSOCKET,
hdrs.CONNECTION: hdrs.UPGRADE,
hdrs.SEC_WEBSOCKET_ACCEPT: ws_key
}
with mock.patch('aiohttp.client.os') as m_os:
with mock.patch('aiohttp.client.ClientSession.get') as m_req:
m_os.urandom.return_value = key_data
m_req.return_value = helpers.create_future(loop)
m_req.return_value.set_result(resp)
with pytest.raises(errors.WSServerHandshakeError):
yield from aiohttp.ws_connect('http://test.org',
protocols=('t1', 't2', 'chat'),
loop=loop)
resp.close.assert_called_with()
0
Example 21
@asyncio.coroutine
def test_ws_connect_non_overlapped_protocols(ws_key, loop, key_data):
resp = mock.Mock()
resp.status = 101
resp.headers = {
hdrs.UPGRADE: hdrs.WEBSOCKET,
hdrs.CONNECTION: hdrs.UPGRADE,
hdrs.SEC_WEBSOCKET_ACCEPT: ws_key,
hdrs.SEC_WEBSOCKET_PROTOCOL: 'other,another'
}
with mock.patch('aiohttp.client.os') as m_os:
with mock.patch('aiohttp.client.ClientSession.get') as m_req:
m_os.urandom.return_value = key_data
m_req.return_value = helpers.create_future(loop)
m_req.return_value.set_result(resp)
res = yield from aiohttp.ws_connect(
'http://test.org',
protocols=('t1', 't2', 'chat'),
loop=loop)
assert res.protocol is None