async def test__connect_wait_tnt_started(self):
self.tnt.stop()
conn = asynctnt.Connection(host=self.tnt.host,
port=self.tnt.port,
username='******',
password='******',
fetch_schema=True,
reconnect_timeout=0.000000001)
try:
coro = self.ensure_future(conn.connect())
await self.sleep(0.3)
self.tnt.start()
await self.sleep(1)
while True:
try:
await coro
break
except TarantoolDatabaseError as e:
if e.code == ErrorCode.ER_NO_SUCH_USER:
# Try again
coro = self.ensure_future(conn.connect())
continue
raise
self.assertEqual(conn.state, ConnectionState.CONNECTED)
await conn.call('box.info')
finally:
await conn.disconnect()
async def test__connect(self):
conn = asynctnt.Connection(host=self.tnt.host,
port=self.tnt.port,
reconnect_timeout=0)
self.assertEqual(conn.host, self.tnt.host)
self.assertEqual(conn.port, self.tnt.port)
self.assertIsNone(conn.username)
self.assertIsNone(conn.password)
self.assertEqual(conn.reconnect_timeout, 0)
self.assertEqual(conn.connect_timeout, 3)
self.assertEqual(conn.loop, self.loop)
self.assertIsNone(conn.initial_read_buffer_size)
self.assertIsNone(conn.schema_id)
self.assertIsNone(conn.version)
self.assertEqual(
repr(conn),
"<asynctnt.Connection host={} port={} state={}>".format(
conn.host, conn.port, repr(conn.state)))
self.assertEqual(conn.state, ConnectionState.DISCONNECTED)
c = await conn.connect()
self.assertEqual(c, conn)
self.assertIsNotNone(conn._transport)
self.assertIsNotNone(conn._protocol)
self.assertTrue(conn.is_connected)
self.assertTrue(conn.is_fully_connected)
self.assertEqual(conn.state, ConnectionState.CONNECTED)
self.assertIsNotNone(conn._protocol.schema)
self.assertIsNotNone(conn.version)
await conn.call('box.info')
await conn.disconnect()
async def bench_asynctnt(n, b):
import asynctnt
from asynctnt.iproto.protocol import Iterator
conn = asynctnt.Connection(host='127.0.0.1',
port=3305,
username='******',
password='******',
reconnect_timeout=1)
await conn.connect()
n_requests_per_bulk = int(math.ceil(n / b))
async def bulk_f():
for _ in range(n_requests_per_bulk):
# await conn.ping()
# await conn.call('test')
# await conn.eval('return "hello"')
await conn.select(512)
# await conn.sql('select 1 as a, 2 as b')
# await conn.replace('tester', [2, 'hhhh'])
# await conn.update('tester', [2], [(':', 1, 1, 3, 'yo!')])
coros = [bulk_f() for _ in range(b)]
start = datetime.datetime.now()
await asyncio.wait(coros)
end = datetime.datetime.now()
elapsed = end - start
print('Elapsed: {}, RPS: {}. TPR: {}'.format(elapsed,
n / elapsed.total_seconds(),
elapsed.total_seconds() / n))
async def test__connect_while_reconnecting(self):
conn = asynctnt.Connection(host=self.tnt.host,
port=self.tnt.port,
reconnect_timeout=1)
try:
coros = []
for _ in range(10):
coros.append(asyncio.ensure_future(conn.connect()))
self.tnt.stop()
await self.sleep(0.5)
connect_coros = asyncio.ensure_future(asyncio.gather(*coros))
self.tnt.start()
await self.sleep(1)
await connect_coros
self.assertEqual(conn.state, ConnectionState.CONNECTED)
self.assertTrue(conn.is_connected)
await conn.call('box.info')
finally:
await conn.disconnect()
def __init__(self, config, type, store, loop=None):
super().__init__(config, type, store, loop=loop)
self._conn = asynctnt.Connection(host=self.host,
port=self.port,
username=self.username,
password=self.password,
loop=self.loop)
async def test__connect_error_no_reconnect(self):
conn = asynctnt.Connection(host="127.0.0.1",
port=1,
fetch_schema=True,
reconnect_timeout=0)
with self.assertRaises(ConnectionRefusedError):
await conn.connect()
async def test__connect_err_loading(self):
if self.in_docker:
self.skipTest('not running in docker')
return
with self.make_instance() as tnt:
tnt.replication_source = ['x:1']
tnt.start(wait=False)
await self.sleep(1)
if not check_version(self, tnt.version(), min=(1, 7)):
return
conn = asynctnt.Connection(host=tnt.host,
port=tnt.port,
username='******',
password='******',
fetch_schema=True,
reconnect_timeout=0,
connect_timeout=10)
try:
with self.assertRaises(TarantoolDatabaseError) as e:
await conn.connect()
self.assertEqual(e.exception.code, ErrorCode.ER_LOADING)
finally:
await conn.disconnect()
async def test__connect_force_disconnect(self):
conn = asynctnt.Connection(host=self.tnt.host,
port=44444,
reconnect_timeout=0.3)
self.ensure_future(conn.connect())
await self.sleep(1)
await conn.disconnect()
self.assertEqual(conn.state, ConnectionState.DISCONNECTED)
async def test__ensure_no_attribute_error_on_not_connected(self):
await self.tnt_disconnect()
self._conn = asynctnt.Connection(host=self.tnt.host,
port=self.tnt.port)
with self.assertRaises(TarantoolNotConnectedError):
await self.conn.ping()
async def run():
conn = asynctnt.Connection(host='127.0.0.1', port=3305)
await conn.connect()
resp = await conn.sql("insert into s (id, name) values (1, 'one')")
# resp = await conn.sql("select * from s")
print(resp)
print(resp.rowcount)
async def run():
conn = asynctnt.Connection(host='127.0.0.1', port=3305)
await conn.connect()
fut = conn.call("asyncaction", push_subscribe=True)
async for row in asynctnt.PushIterator(fut):
print('wow', row)
print(await fut)
async def test__close(self):
conn = asynctnt.Connection(host=self.tnt.host,
port=self.tnt.port,
reconnect_timeout=0)
await conn.connect()
await self.sleep(0.1)
conn.close()
await self.sleep(0.1)
self.assertEqual(conn.state, ConnectionState.DISCONNECTED)
async def get_connection(self, host='127.0.0.1', port=3301):
if self._killed:
return None
if self._connections_pool.empty():
new_conn = asynctnt.Connection(host=host, port=port)
await new_conn.connect()
return new_conn
else:
return await self._connections_pool.get()
async def test_reconnect_from_idle(self):
conn = asynctnt.Connection(host=self.tnt.host,
port=self.tnt.port,
reconnect_timeout=0)
await conn.reconnect()
try:
self.assertEqual(conn.state, ConnectionState.CONNECTED)
await conn.call('box.info')
finally:
await conn.disconnect()
async def run():
conn = asynctnt.Connection(host='127.0.0.1', port=3305)
begin = time.time()
n = 1000
for i in range(n):
await conn.connect()
await conn.disconnect()
dt = time.time() - begin
print('Total: {}'.format(dt))
print('1 connect+disconnect: {}'.format(dt / n))
async def run2():
conn = asynctnt.Connection(host='127.0.0.1', port=3305)
await conn.connect()
begin = time.time()
n = 10000
for i in range(n):
await conn.eval('return box.info')
dt = time.time() - begin
print('Total: {}'.format(dt))
print('1 ping: {}'.format(dt / n))
async def create_asynctnt(loop):
import asynctnt
conn = asynctnt.Connection(host=HOST,
port=PORT,
username=USERNAME,
password=PASSWORD,
reconnect_timeout=1,
fetch_schema=True,
auto_refetch_schema=True)
await conn.connect()
return conn
async def test__connect_invalid_user_no_reconnect(self):
conn = asynctnt.Connection(host=self.tnt.host,
port=self.tnt.port,
username='******',
password='******',
connect_timeout=1,
reconnect_timeout=0)
with self.assertRaises(TarantoolDatabaseError) as e:
await conn.connect()
self.assertEqual(e.exception.code, ErrorCode.ER_NO_SUCH_USER)
async def test__disconnect(self):
conn = asynctnt.Connection(host=self.tnt.host,
port=self.tnt.port,
reconnect_timeout=0)
await conn.connect()
await conn.disconnect()
self.assertFalse(conn.is_connected)
self.assertFalse(conn.is_fully_connected)
self.assertEqual(conn.state, ConnectionState.DISCONNECTED)
with self.assertRaises(TarantoolNotConnectedError):
await conn.call('box.info')
async def test__disconnect_in_request(self):
conn = asynctnt.Connection(host=self.tnt.host,
port=self.tnt.port,
reconnect_timeout=0)
await conn.connect()
coro = self.ensure_future(conn.eval('require "fiber".sleep(2)'))
await self.sleep(0.5)
await conn.disconnect()
with self.assertRaises(TarantoolNotConnectedError):
await coro
async def sql_usage():
conn = asynctnt.Connection(host='127.0.0.1', port=3301)
await conn.connect()
await conn.sql("insert into users (id, name) values (1, 'James Bond')")
await conn.sql("insert into users (id, name) values (2, 'Ethan Hunt')")
data = await conn.sql('select * from users')
for row in data:
print(row)
await conn.disconnect()
async def main():
c = asynctnt.Connection(
host='localhost',
port=3305,
connect_timeout=5,
request_timeout=5,
reconnect_timeout=1/3,
)
async with c:
while True:
res = await c.eval('local t ={}; for i=1,1000000 do t[i] = {i + 0.03} end; return t')
print(sys.getrefcount(res.body[0][-1]))
async def test__connect_contextmanager_connect_inside(self):
conn = asynctnt.Connection(host=self.tnt.host,
port=self.tnt.port,
reconnect_timeout=0)
self.assertEqual(conn.state, ConnectionState.DISCONNECTED)
async with conn:
await conn.connect()
self.assertEqual(conn.state, ConnectionState.CONNECTED)
await conn.call('box.info')
self.assertEqual(conn.state, ConnectionState.DISCONNECTED)
async def test__connect_cancel(self):
conn = asynctnt.Connection(host=self.tnt.host,
port=self.tnt.port,
fetch_schema=True,
reconnect_timeout=0)
try:
f = asyncio.ensure_future(conn.connect())
await self.sleep(0.0001)
f.cancel()
with self.assertRaises(asyncio.CancelledError):
await f
finally:
await conn.disconnect()
async def test__connect_contextmanager_disconnect_inside(self):
conn = asynctnt.Connection(host=self.tnt.host,
port=self.tnt.port,
reconnect_timeout=0)
self.assertEqual(conn.state, ConnectionState.DISCONNECTED)
async with conn:
await conn.disconnect()
self.assertEqual(conn.state, ConnectionState.DISCONNECTED)
with self.assertRaises(TarantoolNotConnectedError):
await conn.call('box.info')
self.assertEqual(conn.state, ConnectionState.DISCONNECTED)
async def test__connect_auth(self):
conn = asynctnt.Connection(host=self.tnt.host,
port=self.tnt.port,
username='******',
password='******',
reconnect_timeout=0)
async with conn:
self.assertIsNotNone(conn._transport)
self.assertIsNotNone(conn._protocol)
self.assertTrue(conn.is_connected)
self.assertTrue(conn.is_fully_connected)
self.assertEqual(conn.state, ConnectionState.CONNECTED)
self.assertIsNotNone(conn._protocol.schema)
await conn.call('box.info')
async def test__connect_no_schema(self):
conn = asynctnt.Connection(host=self.tnt.host,
port=self.tnt.port,
reconnect_timeout=0,
fetch_schema=False,
auto_refetch_schema=False)
async with conn:
self.assertIsNotNone(conn._transport)
self.assertIsNotNone(conn._protocol)
self.assertTrue(conn.is_connected)
self.assertTrue(conn.is_fully_connected)
self.assertEqual(conn.state, ConnectionState.CONNECTED)
self.assertIsNotNone(conn._protocol.schema)
await conn.call('box.info')
async def run4():
conn = asynctnt.Connection(host='127.0.0.1', port=3301)
await conn.connect()
begin = time.time()
n = 10000
for i in range(n):
resp = await conn.sql('select * from s')
dt = time.time() - begin
print('Total: {}'.format(dt))
print('1 sql: {}'.format(dt / n))
print(resp.encoding)
print(resp)
print(list(resp))
async def get_db_connector(space):
num = 0 # здесь вычисляем номер нужного шарда, в котором находится пространство
for i in range(SHARDS['count']):
name = 'SHARD' + str(i + 1) + '_SPACES'
if space in SHARDS[name]:
num = i + 1
break
connector = asynctnt.Connection(host=SHARDS['SHARD' + str(num)][0],
port=SHARDS['SHARD' + str(num)][1],
reconnect_timeout=0,
initial_read_buffer_size=600,
username=DB_USER,
password=DB_PASS)
try:
await connector.connect()
except ConnectionRefusedError:
for i in range(SHARDS['count_replics']):
connector = asynctnt.Connection(
host=SHARDS['SHARD' + str(num) + '_REPLICA' + str(i + 1)][0],
port=SHARDS['SHARD' + str(num) + '_REPLICA' + str(i + 1)][1],
reconnect_timeout=0,
initial_read_buffer_size=600,
username=DB_USER,
password=DB_PASS)
try:
await connector.connect()
except ConnectionRefusedError:
continue
else:
return connector
raise asynctnt.exceptions.TarantoolError(
"I can't connect"
" to my DB host={}, port={}".format(
SHARDS['SHARD' + str(num) + '_REPLICA' + str(1)][0],
SHARDS['SHARD' + str(num) + '_REPLICA' + str(1)][1]))
return connector
async def test__connect_from_multiple_coroutines(self):
conn = asynctnt.Connection(host=self.tnt.host,
port=self.tnt.port,
reconnect_timeout=1 / 3)
try:
coros = []
for _ in range(10):
coros.append(asyncio.ensure_future(conn.connect()))
await asyncio.gather(*coros)
self.assertEqual(conn.state, ConnectionState.CONNECTED)
self.assertTrue(conn.is_connected)
await conn.call('box.info')
finally:
await conn.disconnect()
