def test_decoding(self):
conn = yield from create_connection(
('localhost', self.redis_port), encoding='utf-8', loop=self.loop)
self.assertEqual(conn.encoding, 'utf-8',)
res = yield from conn.execute('set', 'key1', 'value')
self.assertEqual(res, 'OK')
res = yield from conn.execute('get', 'key1')
self.assertEqual(res, 'value')
res = yield from conn.execute('set', 'key1', b'bin-value')
self.assertEqual(res, 'OK')
res = yield from conn.execute('get', 'key1')
self.assertEqual(res, 'bin-value')
res = yield from conn.execute('get', 'key1', encoding='ascii')
self.assertEqual(res, 'bin-value')
res = yield from conn.execute('get', 'key1', encoding=None)
self.assertEqual(res, b'bin-value')
with self.assertRaises(UnicodeDecodeError):
yield from conn.execute('set', 'key1', 'значение')
yield from conn.execute('get', 'key1', encoding='ascii')
conn2 = yield from create_connection(
('localhost', self.redis_port), loop=self.loop)
res = yield from conn2.execute('get', 'key1', encoding='utf-8')
self.assertEqual(res, 'значение')
def test_auth(self):
conn = yield from create_connection(
('localhost', self.redis_port), loop=self.loop)
res = yield from conn.execute('CONFIG', 'SET', 'requirepass', 'pass')
self.assertEqual(res, b'OK')
conn2 = yield from create_connection(
('localhost', self.redis_port), loop=self.loop)
with self.assertRaises(ReplyError):
yield from conn2.select(1)
res = yield from conn2.auth('pass')
self.assertEqual(res, True)
res = yield from conn2.select(1)
self.assertTrue(res)
conn3 = yield from create_connection(
('localhost', self.redis_port), password='******', loop=self.loop)
res = yield from conn3.select(1)
self.assertTrue(res)
res = yield from conn2.execute('CONFIG', 'SET', 'requirepass', '')
self.assertEqual(res, b'OK')
def test_connect_tcp(self):
conn = yield from create_connection(
('localhost', self.redis_port), loop=self.loop)
self.assertEqual(conn.db, 0)
self.assertEqual(str(conn), '<RedisConnection [db:0]>')
conn = yield from create_connection(
['localhost', self.redis_port], loop=self.loop)
self.assertEqual(conn.db, 0)
self.assertEqual(str(conn), '<RedisConnection [db:0]>')
def test_close_connection__tcp(self):
loop = self.loop
conn = loop.run_until_complete(create_connection(
('localhost', self.redis_port), loop=loop))
conn.close()
with self.assertRaises(AssertionError):
loop.run_until_complete(conn.select(1))
conn = loop.run_until_complete(create_connection(
('localhost', self.redis_port), loop=loop))
with self.assertRaises(AssertionError):
conn.close()
fut = conn.select(1)
loop.run_until_complete(fut)
def test_execute_exceptions(self):
conn = yield from create_connection(
('localhost', self.redis_port), loop=self.loop)
with self.assertRaises(TypeError):
yield from conn.execute(None)
with self.assertRaises(TypeError):
yield from conn.execute("ECHO", None)
def test_global_loop(self):
asyncio.set_event_loop(self.loop)
conn = self.loop.run_until_complete(create_connection(
('localhost', self.redis_port), db=0))
self.assertEqual(conn.db, 0)
self.assertIs(conn._loop, self.loop)
def redis_server(docker, session_id, loop, request):
if not request.config.option.no_pull:
docker.pull('redis:{}'.format('latest'))
container = docker.create_container(
image='redis:{}'.format('latest'),
name='redis-test-server-{}-{}'.format('latest', session_id),
ports=[6379],
detach=True,
)
docker.start(container=container['Id'])
inspection = docker.inspect_container(container['Id'])
host = inspection['NetworkSettings']['IPAddress']
delay = 0.001
for i in range(100):
try:
conn = loop.run_until_complete(
aioredis.create_connection((host, 6379), loop=loop))
loop.run_until_complete(conn.execute('SET', 'foo', 'bar'))
break
except ConnectionRefusedError as e:
time.sleep(delay)
delay *= 2
else:
pytest.fail("Cannot start redis server")
container['redis_params'] = dict(address=(host, 6379))
yield container
docker.kill(container=container['Id'])
docker.remove_container(container['Id'])
def drain_queues(transport, loop):
conn = yield from aioredis.create_connection(
(config.get('redis', 'host'), 6379), loop=loop)
while True:
# check redis for list of my clients
clients = yield from conn.execute('zrange', '%s:clients' % myid(), 0, -1)
# for each client, check redis if there is a message in their queue
for client in clients:
next_message_in_queue = yield from conn.execute('lpop', '%s:queue' % client)
if next_message_in_queue is not None:
# not needed but makes nice debug
msg = message.MQTTSNMessage()
msg.parse(next_message_in_queue)
logger.debug("Sending %s to %s" % (msg, client,))
# get the socket from redis
socket = pickle.loads(client)
# if I want more info about this, it's here
# client_info = r.hget('%s:socket' % client, 'socket'))
# get transport somehow
transport.sendto(next_message_in_queue, socket)
conn.close()
def go(params):
conn = yield from aioredis.create_connection(
('localhost', 6379), encoding='utf-8')
ok = yield from conn.execute(*params)
print("%s = %s" % (params, ok,))
conn.close()
def go(params):
conn = yield from aioredis.create_connection(('localhost', 6379),
encoding='utf-8')
ok = yield from conn.execute(*params)
print("%s = %s" % (
params,
ok,
))
conn.close()
def test_protocol_error(self):
loop = self.loop
conn = yield from create_connection(
('localhost', self.redis_port), loop=loop)
reader = conn._reader
with self.assertRaises(ProtocolError):
reader.feed_data(b'not good redis protocol response')
yield from conn.select(1)
self.assertEqual(len(conn._waiters), 0)
def test_select_db(self):
address = ('localhost', self.redis_port)
conn = yield from create_connection(address, loop=self.loop)
self.assertEqual(conn.db, 0)
with self.assertRaises(ValueError):
yield from create_connection(address, db=-1, loop=self.loop)
with self.assertRaises(TypeError):
yield from create_connection(address, db=1.0, loop=self.loop)
with self.assertRaises(TypeError):
yield from create_connection(
address, db='bad value', loop=self.loop)
with self.assertRaises(TypeError):
conn = yield from create_connection(
address, db=None, loop=self.loop)
yield from conn.select(None)
with self.assertRaises(ReplyError):
yield from create_connection(
address, db=100000, loop=self.loop)
yield from conn.select(1)
self.assertEqual(conn.db, 1)
yield from conn.select(2)
self.assertEqual(conn.db, 2)
yield from conn.execute('select', 0)
self.assertEqual(conn.db, 0)
yield from conn.execute(b'select', 1)
self.assertEqual(conn.db, 1)
def redis_server(
docker: DockerClient,
session_id: str,
loop: asyncio.AbstractEventLoop,
) -> Generator[_TContainerInfo, None, None]:
image = 'redis:{}'.format('latest')
if sys.platform.startswith('darwin'):
port = unused_port()
else:
port = None
container = docker.containers.run(
image=image,
detach=True,
name='redis-test-server-{}-{}'.format('latest', session_id),
ports={
'6379/tcp': port,
},
environment={
'http.host': '0.0.0.0',
'transport.host': '127.0.0.1',
},
)
if sys.platform.startswith('darwin'):
host = '0.0.0.0'
else:
inspection = docker.api.inspect_container(container.id)
host = inspection['NetworkSettings']['IPAddress']
port = 6379
delay = 0.1
for i in range(20):
try:
conn = loop.run_until_complete(
aioredis.create_connection((host, port), loop=loop))
loop.run_until_complete(conn.execute('SET', 'foo', 'bar'))
break
except ConnectionRefusedError:
time.sleep(delay)
delay *= 2
else:
pytest.fail("Cannot start redis server")
yield {'host': host, 'port': port, 'container': container}
container.kill(signal=9)
container.remove(force=True)
def go():
conn = yield from aioredis.create_connection(('localhost', 6379),
encoding='utf-8')
ok = yield from conn.execute('set', 'my-key', 'some value')
assert ok == 'OK', ok
str_value = yield from conn.execute('get', 'my-key')
raw_value = yield from conn.execute('get', 'my-key', encoding=None)
assert str_value == 'some value'
assert raw_value == b'some value'
print('str value:', str_value)
print('raw value:', raw_value)
# optionally close connection
conn.close()
def go():
conn = yield from aioredis.create_connection(
('localhost', 6379), encoding='utf-8')
ok = yield from conn.execute('set', 'my-key', 'some value')
assert ok == 'OK', ok
str_value = yield from conn.execute('get', 'my-key')
raw_value = yield from conn.execute('get', 'my-key', encoding=None)
assert str_value == 'some value'
assert raw_value == b'some value'
print('str value:', str_value)
print('raw value:', raw_value)
# optionally close connection
conn.close()
def main():
loop = asyncio.get_event_loop()
redis = loop.run_until_complete(
aioredis.create_connection(('localhost', 6379)))
bots = [
EchoBot(echo_bot_token, loop, redis),
JournalBot(journal_bot_token, loop, redis, client[journal_bot_token]),
]
try:
aiohttp.web.run_app(init_app(bots))
except BaseException as exc:
print(exc)
finally:
for bot in bots:
bot.shutdown()
def get_digest(value):
"""Get digest takes either an URI/URL or a Literal value and
calls the SHA1 for the add_get_hash.lua script.
Args:
value -- URI/URL or Literal value
"""
if not value:
return None
connection = yield from aioredis.create_connection(
(config.get("redis")["host"], config.get("redis")["port"]),
encoding='utf-8')
sha1_digest = yield from connection.execute(b'EVALSHA',
LUA_SCRIPTS['add_get_hash'], 1,
value,
config.get("redis").get('ttl'))
connection.close()
return sha1_digest
async def go():
foo = aioredis.create_connection(
(redis_url.hostname, redis_url.port),
password=redis_url.password,
loop=loop)
print(foo)
import types
print(isinstance(foo, types.GeneratorType))
conn = await foo
print(conn)
print('foo')
import json
foo = {'foo': 'bar'}
#await conn.execute('set', 'my-key', json.dumps(foo))
val = await conn.execute('get', 'my-key')
print(json.loads(val))
conn.close()
await conn.wait_closed()
def go():
# def create_connection(address, *, db=None, password=None,
# encoding=None, loop=None):
conn = yield from aioredis.create_connection(('localhost', 6379), encoding='utf-8')
print("redis connection:",conn)
ok = yield from conn.execute('set', 'my-key', 'selo')
assert ok == 'OK', ok
str_value = yield from conn.execute('get', 'my-key')
raw_value = yield from conn.execute('get', 'my-key', encoding=None)
print('str_value:', str_value)
print('raw_value:', raw_value)
assert str_value == 'selo'
assert raw_value == b'selo'
conn.close()
def connect_to_redis_servers(self):
print("[ {} ] Connecting to Redis servers...".format(
datetime.datetime.utcnow()))
self.redis_clients = []
self.redis_nodes = dict()
counter = 1
for IP, port in self.redis_endpoints:
print(
"[ {} ] Attempting to connect to Redis server {}/{} at {}:{}".
format(datetime.datetime.utcnow(), counter,
len(self.redis_endpoints), IP, port))
connection = yield aioredis.create_connection(
address=(IP, port),
loop=IOLoop.current().asyncio_loop,
encoding=options.encoding
) #redis.StrictRedis(host=IP, port = port, db = 0)
redis_client = aioredis.Redis(connection)
print("[ {} ] Successfully connected to Redis server {}.".format(
datetime.datetime.utcnow(), counter))
self.redis_clients.append(redis_client)
key_string = "node-" + str(IP) + ":" + str(port)
self.redis_nodes[key_string] = {
"hostname": key_string + ".FQDN",
"nodename": key_string,
"instance": redis_client,
"port": port,
"vnodes": 40
}
counter += 1
self.hash_ring = HashRing(self.redis_nodes)
#for port in self.redis_ports:
# print("[ {} ] Attempting to connect to Redis server {}/{} at {}:{}".format(datetime.datetime.utcnow(), counter, len(self.redis_ports), self.redis_endpoint, port))
# #connection = IOLoop.current().run_sync(lambda: aioredis.create_connection(address = (self.redis_endpoint, port), loop = IOLoop.current().asyncio_loop, encoding = options.encoding))
# connection = yield aioredis.create_connection(address = (self.redis_endpoint, port), loop = IOLoop.current().asyncio_loop, encoding = options.encoding)
# redis_client = aioredis.Redis(connection)
# self.redis_clients.append(redis_client)
# counter = counter + 1
self.num_redis_clients = len(self.redis_clients)
def create_connection(self, *args, **kw):
conn = yield from create_connection(*args, **kw)
self._conns.append(conn)
return conn
def f(*args, **kw):
conn = yield from aioredis.create_connection(*args, **kw)
_closable(conn)
return conn
lambda d: 'soundcloud' in d.data)
dp.register_callback_query_handler(
callback_handlers.artist_callback_handler,
lambda d: 'artist' in d.data)
dp.register_callback_query_handler(callback_handlers.callback_handler)
dp.register_chosen_inline_handler(inline_handlers.finish_download_handler)
dp.middleware.setup(Middleware())
try:
global session
bot = Bot(token=config.bot_token, loop=loop)
storage = MemoryStorage()
dp = Dispatcher(bot, storage=storage)
var.downloading = {}
var.session = aiohttp.ClientSession(raise_for_status=True)
print('created session')
var.CSRFToken = None
var.loop = loop
from spotify import Spotify_API
var.spot = Spotify_API(
config.spotify_client, config.spotify_secret)
var.db = database('db.sqlite')
var.conn = loop.run_until_complete(aioredis.create_connection(
('localhost', 6379), encoding='utf-8', db=4, loop=loop))
print('datebase connected')
except Exception as e:
print(e)
response.send_headers()
yield from response.write_eof()
def snare_setup():
if os.getuid() != 0:
print('Snare has to be started as root!')
sys.exit(1)
if not os.path.exists('/opt/snare'):
os.mkdir('/opt/snare')
if not os.path.exists('/opt/snare/pages'):
os.mkdir('/opt/snare/pages')
if __name__ == '__main__':
snare_setup()
parser = argparse.ArgumentParser()
parser.add_argument("--page-dir", help="name of the folder to be served")
args = parser.parse_args()
loop = asyncio.get_event_loop()
redis_conn = aioredis.create_connection(('localhost', 6379), loop=loop)
f = loop.create_server(
lambda: HttpRequestHandler(args, debug=True, keep_alive=75),
'0.0.0.0', '8080')
srv = loop.run_until_complete(f)
print('serving on', srv.sockets[0].getsockname())
try:
loop.run_forever()
except KeyboardInterrupt:
pass
def test_close_connection__socket(self):
conn = yield from create_connection(
self.redis_socket, loop=self.loop)
conn.close()
with self.assertRaises(AssertionError):
yield from conn.select(1)
def init_connection(self):
self.connection =\
yield from aioredis.create_connection((self.url, self.port), loop=self.loop, encoding='utf-8')
def f(*args, **kw):
conn = yield from aioredis.create_connection(*args, **kw)
_closable(conn)
return conn
def test_connect_unixsocket(self):
conn = yield from create_connection(
self.redis_socket, db=0, loop=self.loop)
self.assertEqual(conn.db, 0)
self.assertEqual(str(conn), '<RedisConnection [db:0]>')
def create_connection(self, *args, **kw):
conn = yield from create_connection(*args, **kw)
self._conns.append(conn)
return conn
'Connection':
'keep-alive',
}
var.session = aiohttp.ClientSession(cookies=cookies,
headers=headers,
raise_for_status=False)
var.session.get = utils.retry(aiohttp.ClientResponseError,
retries=5,
cooldown=0.1)(var.session.get)
var.session.post = utils.retry(aiohttp.ClientResponseError,
retries=5,
cooldown=0.1)(var.session.post)
print('created session')
var.CSRFToken = None
var.loop = loop
dp = Dispatcher(bot, storage=storage)
from spotify import Spotify_API
var.spot = Spotify_API(config.spotify_client, config.spotify_secret)
var.db = database('db.sqlite')
var.conn = loop.run_until_complete(
aioredis.create_connection(('localhost', 6379),
encoding='utf-8',
db=4,
loop=loop))
print('datebase connected')
except Exception as e:
print(e)
def f(*args, **kw):
kw.setdefault('loop', loop)
conn = yield from aioredis.create_connection(*args, **kw)
_closable(conn)
return conn
