def setUp(self):
super(GRedisTest, self).setUp()
self.client = AsyncRedis(
"192.168.1.50",
6379,
encoding="utf8",
decode_responses=True,
)
def setUp(self):
super(GRedisTest, self).setUp()
self.client = AsyncRedis(decode_responses=True)
class GRedisTest(AsyncTestCase):
# NOTE: Make sure to launch a Redis docker container and port forward 6379 before running the tests.
# $ docker run -d -p 6379:6379 --name gredis-test redis
def setUp(self):
super(GRedisTest, self).setUp()
self.client = AsyncRedis(decode_responses=True)
@gen_test
def test_get_set(self):
key = "g_test_key"
yield self.client.set(key, "w")
# print("set")
future = self.client.get(key)
response = yield future
self.assertEqual(response, "w")
@gen_test
def test_list(self):
key = "g_test_list_key"
self.client.delete(key)
yield self.client.lpush(key, "w")
key, response = yield self.client.blpop(key)
print(response)
self.assertEqual(response, "w")
lst = ['a', 'b', 'c']
for i in lst:
yield self.client.rpush(key, i)
_lst = yield self.client.lrange(key, 0, -1)
self.assertListEqual(lst, _lst)
@gen_test
def test_to_blocking_client(self):
key = "g_test_1_key"
yield self.client.set(key, "gredis")
client = self.client.to_blocking_client()
result = client.get(key)
self.assertEqual(result, "gredis")
asyc_result = yield self.client.get(key)
self.assertEqual(asyc_result, "gredis")
@gen_test
def test_blocking_pipeline(self):
key = "g_pipeline_test"
key1 = "g_pipeline_test1"
pipeline = self.client.pipeline()
pipeline.set(key, "gredis")
pipeline.set(key1, "gredis1")
pipeline.execute()
ret = yield self.client.get(key)
self.assertEqual(ret, "gredis")
ret1 = yield self.client.get(key1)
self.assertEqual(ret1, "gredis1")
@gen_test
def test_async_pubsub(self):
pubsub = self.client.pubsub()
channel = "test"
yield pubsub.subscribe(channel)
response = yield pubsub.get_message(True)
self.assertEqual(response["type"], "subscribe")
yield self.client.publish(channel, "test")
response = yield pubsub.get_message(True)
self.assertEqual(response["type"], "message")
self.assertEqual(response["data"], "test")
# Author : cold # E-mail : [email protected] # Date : 15/04/18 13:21:25 # Desc : A Chat Demo written with gredis # """ A chat demo based on list type of Redis, written with gredis """ from __future__ import absolute_import, print_function, division, with_statement import uuid from tornado import gen from tornado import web from tornado import ioloop from gredis.client import AsyncRedis client = AsyncRedis("192.168.1.50") CHAT_PEER_KEY = "chat::peer" class ChatHandler(web.RequestHandler): @gen.coroutine def get(self, chat_id=None): if not chat_id: chat_id = uuid.uuid1().get_hex() dist_id = uuid.uuid1().get_hex() yield client.hmset(CHAT_PEER_KEY, {chat_id: dist_id}) yield client.hmset(CHAT_PEER_KEY, {dist_id: chat_id}) self.redirect("/chat/{0}".format(chat_id)) else: dist_id = yield client.hget(CHAT_PEER_KEY, chat_id)
def setUp(self):
super(GRedisTest, self).setUp()
self.client = AsyncRedis("192.168.1.50", 6379)
class GRedisTest(AsyncTestCase):
def setUp(self):
super(GRedisTest, self).setUp()
self.client = AsyncRedis("192.168.1.50", 6379)
@gen_test
def test_get_set(self):
key = "g_test_key"
yield self.client.set(key, "w")
# print("set")
future = self.client.get(key)
response = yield future
self.assertEqual(response, "w")
@gen_test
def test_list(self):
key = "g_test_list_key"
self.client.delete(key)
yield self.client.lpush(key, "w")
key, response = yield self.client.blpop(key)
print(response)
self.assertEqual(response, "w")
lst = ["a", "b", "c"]
for i in lst:
yield self.client.rpush(key, i)
_lst = yield self.client.lrange(key, 0, -1)
self.assertListEqual(lst, _lst)
@gen_test
def test_to_blocking_client(self):
key = "g_test_1_key"
yield self.client.set(key, "gredis")
client = self.client.to_blocking_client()
result = client.get(key)
self.assertEqual(result, "gredis")
asyc_result = yield self.client.get(key)
self.assertEqual(asyc_result, "gredis")
@gen_test
def test_blocking_pipeline(self):
key = "g_pipeline_test"
key1 = "g_pipeline_test1"
pipeline = self.client.pipeline()
pipeline.set(key, "gredis")
pipeline.set(key1, "gredis1")
pipeline.execute()
ret = yield self.client.get(key)
self.assertEqual(ret, "gredis")
ret1 = yield self.client.get(key1)
self.assertEqual(ret1, "gredis1")
@gen_test
def test_async_pubsub(self):
pubsub = self.client.pubsub()
channel = "test"
yield pubsub.subscribe(channel)
response = yield pubsub.get_message(True)
self.assertEqual(response["type"], "subscribe")
yield self.client.publish(channel, "test")
response = yield pubsub.get_message(True)
self.assertEqual(response["type"], "message")
self.assertEqual(response["data"], "test")
import os.path
import logging
from ConfigParser import ConfigParser
from gredis.client import AsyncRedis
from tornado.ioloop import IOLoop
from tornado import gen
from tornado.websocket import WebSocketHandler, WebSocketClosedError
from tornado.web import (Application, StaticFileHandler, url)
config = ConfigParser()
config.read('nserv.ini')
logging.basicConfig(level=config.get('logging', 'level'))
redis = AsyncRedis(
config.get('redis', 'host'),
config.get('redis', 'port'),
)
class NotificationHandler(WebSocketHandler):
"""
Websocket handler for "pushing" notifications to the client
"""
@gen.coroutine
def open(self):
logging.debug('Client connected to NotificationHandler')
pubsub = redis.pubsub()
yield pubsub.subscribe(config.get('redis', 'channel'))
while True:
message = yield pubsub.get_message(True)
def setUp(self):
super(GRedisTest, self).setUp()
self.client = AsyncRedis("192.168.1.50", 6379)
class GRedisTest(AsyncTestCase):
def setUp(self):
super(GRedisTest, self).setUp()
self.client = AsyncRedis("192.168.1.50", 6379)
@gen_test
def test_get_set(self):
key = "g_test_key"
yield self.client.set(key, "w")
# print("set")
future = self.client.get(key)
response = yield future
self.assertEqual(response, "w")
@gen_test
def test_list(self):
key = "g_test_list_key"
self.client.delete(key)
yield self.client.lpush(key, "w")
key, response = yield self.client.blpop(key)
print(response)
self.assertEqual(response, "w")
lst = ['a', 'b', 'c']
for i in lst:
yield self.client.rpush(key, i)
_lst = yield self.client.lrange(key, 0, -1)
self.assertListEqual(lst, _lst)
@gen_test
def test_to_blocking_client(self):
key = "g_test_1_key"
yield self.client.set(key, "gredis")
client = self.client.to_blocking_client()
result = client.get(key)
self.assertEqual(result, "gredis")
asyc_result = yield self.client.get(key)
self.assertEqual(asyc_result, "gredis")
@gen_test
def test_blocking_pipeline(self):
key = "g_pipeline_test"
key1 = "g_pipeline_test1"
pipeline = self.client.pipeline()
pipeline.set(key, "gredis")
pipeline.set(key1, "gredis1")
pipeline.execute()
ret = yield self.client.get(key)
self.assertEqual(ret, "gredis")
ret1 = yield self.client.get(key1)
self.assertEqual(ret1, "gredis1")
@gen_test
def test_async_pubsub(self):
pubsub = self.client.pubsub()
channel = "test"
yield pubsub.subscribe(channel)
response = yield pubsub.get_message(True)
self.assertEqual(response["type"], "subscribe")
yield self.client.publish(channel, "test")
response = yield pubsub.get_message(True)
self.assertEqual(response["type"], "message")
self.assertEqual(response["data"], "test")
