def setUp(self): self.loop = TestIOLoop() CustomAssertionError.io_loop = self.loop self.client = brukva.Client(io_loop=self.loop) self.client.connection.connect() self.client.select(9) self.client.flushdb()
def __init__(self, *args, **kwargs): super(APIHandler, self).__init__(*args, **kwargs) self.client = brukva.Client() self.client.connect() self.io_loop = tornado.ioloop.IOLoop.instance() # Ниже принудительный сброс флага online при рестарте приложения (пока так) Node.objects.filter(online=True).update(online=False)
def __init__(self, *args, **kwargs): super(GameHandler, self).__init__(*args, **kwargs) self.client = brukva.Client( # host=settings.SESSION_REDIS_HOST, # port=int(settings.SESSION_REDIS_PORT) ) self.client.connect()
def setUp(self): self.loop = IOLoop.instance() setattr(self.loop, 'handle_callback_exception', handle_callback_exception) CustomAssertionError.io_loop = self.loop self.client = brukva.Client(io_loop=self.loop) self.client.connection.connect() self.client.select(9) self.client.flushdb()
def _wait(self, token, cookie, callback): cls = SignalMixin # initialize redis if not cls.api: cls.api = redis.StrictRedis() if not cls.listener: cls.listener = brukva.Client() cls.listener.psubscribe(cls.CHANNEL_PREFIX + '*') cls.listener.listen(self._signal) # try to find the token object_key = cls.api.get(cls.TOKEN_PREFIX + token) if not object_key: return False # update token expiry cls.api.expire(cls.TOKEN_PREFIX + token, cls.TOKEN_TTL) # try to find to see if there is any event already event_keys = cls.api.keys(cls.EVENT_PREFIX + object_key + '.*') filtered_event_keys = [] filtered_event_ids = [] for event_key in event_keys: event_id = int(event_key.rsplit('.', 1)[1]) if event_id > cookie: filtered_event_keys.append(event_key) filtered_event_ids.append(event_id) # get the list of events in one go and calculate new cookie events = [] cookie = 0 if filtered_event_keys: filtered_events = cls.api.mget(filtered_event_keys) for event_id, event in zip(filtered_event_ids, filtered_events): if event: events.append(simplejson.loads(event)) if event_id > cookie: cookie = event_id # early return to caller if events: return { 'cookie': cookie, 'events': events, } # register callback callbacks = [] if object_key in cls.callbacks: callbacks = cls.callbacks[object_key] if not callback in callbacks: callbacks.append(callback) cls.callbacks[object_key] = callbacks return None
def get(self): """Subscribe to a channel. """ channel_id = self.get_argument('id', None) logging.debug('GET: application key: %s' %channel_id) client = brukva.Client(port=6380) client.connect() logging.debug('subscribing to %s' %channel_id) client.subscribe([channel_id]) client.listen(self.stream_channel_messages)
def __init__(self, ClientNUM, TEST_TIME, DataFile): self.ClientNUM = ClientNUM self.TEST_TIME = TEST_TIME self.DataFile = DataFile assert (self.DataFile["PROTOCOL_TYPE"] == u"RedisProtocol") self._client = brukva.Client(host=DataFile['HOST'], port=DataFile['PORT'], selected_db=DataFile['SELECTED_DB']) self._client.connect() self._io_loop = self._client.connection._stream.io_loop
def post(self): message = { "id": str(uuid.uuid4()), "from": self.current_user["first_name"], "body": self.get_argument("body"), } message["html"] = self.render_string("message.html", message=message) c = brukva.Client() c.connect() text = json.dumps(message) c.publish('chat_channel', text) self.finish(str(text))
def post(self): """Handle the POST request for publishing a message. """ channel_id = self.get_argument('id', None) channel_data = {} channel_data['message'] = self.request.body channel_data['content_type'] = self.request.headers.get('Content-Type') channel_data['last_modified'] = self.request.headers.get('Last-Modified') client = brukva.Client(port=6380) client.connect() tornado.ioloop.IOLoop().instance().add_callback( lambda: self.publish_message(client, channel_id, channel_data))
def get_brukva(): print 'Get Brukva connect with: %s:%s:%s' % \ (settings.REDIS_HOST, settings.REDIS_PORT, settings.REDIS_DB) try: c = brukva.Client(host=settings.REDIS_HOST, port=settings.REDIS_PORT, selected_db=settings.REDIS_DB) c.connect() except: print traceback.format_exc() else: print 'Ok' return c
def __init__(self): # create a new redis connection redis_connection = brukva.Client() redis_connection.connect() handlers = [ (r"/hits", HitsHandler, { "redis_connection": redis_connection }), (r"/hit", HitHandler, { "redis_connection": redis_connection }), (r"/(.*)", tornado.web.StaticFileHandler, { "path": os.path.join(os.getcwd(), "public") }), # configure static file handler ] tornado.web.Application.__init__(self, handlers)
def redis_connect(): """ Established an asynchronous resi connection. """ # Get Redis connection settings for Heroku with fallback to defaults. redistogo_url = os.getenv('REDISTOGO_URL', None) if redistogo_url == None: REDIS_HOST = 'localhost' REDIS_PORT = 6379 REDIS_PWD = None REDIS_USER = None else: redis_url = redistogo_url redis_url = redis_url.split('redis://')[1] redis_url = redis_url.split('/')[0] REDIS_USER, redis_url = redis_url.split(':', 1) REDIS_PWD, redis_url = redis_url.split('@', 1) REDIS_HOST, REDIS_PORT = redis_url.split(':', 1) client = brukva.Client(host=REDIS_HOST, port=int(REDIS_PORT), password=REDIS_PWD) client.connect() return client
def redis_connect(): """ 通过Heroku建立一个异步的redis服务器 """ redistogo_url = os.getenv('REDISTOGO_URL', None) if redistogo_url == None: REDIS_HOST = 'localhost' REDIS_PORT = 6379 REDIS_PWD = None REDIS_USER = None else: redis_url = redistogo_url redis_url = redis_url.split('redis://')[1] redis_url = redis_url.split('/')[0] REDIS_USER, redis_url = redis_url.split(':', 1) REDIS_PWD, redis_url = redis_url.split('@', 1) REDIS_HOST, REDIS_PORT = redis_url.split(':', 1) client = brukva.Client(host=REDIS_HOST, port=int(REDIS_PORT), password=REDIS_PWD) client.connect() return client
def redis_connect(): """ Redis connection """ herokuredis_url = os.getenv('REDIS_URL', None) logging.warning(str(herokuredis_url)) if herokuredis_url == None: REDIS_HOST = 'localhost' REDIS_PORT = 6379 REDIS_PWD = None REDIS_USER = None else: redis_url = herokuredis_url redis_url = redis_url.split('redis://')[1] redis_url = redis_url.split('/')[0] REDIS_USER, redis_url = redis_url.split(':', 1) REDIS_PWD, redis_url = redis_url.split('@', 1) REDIS_HOST, REDIS_PORT = redis_url.split(':', 1) client = brukva.Client(host=REDIS_HOST, port=int(REDIS_PORT), password=REDIS_PWD) client.connect() return client
def __init__(self, host, port, dbnum, password=None): """Create our redis object, connecting to the specified host, port and database. :param host: Redis host to connect to :type host: str :param port: Redis port to connect to :type port: int :param dbnum: Redis database number to connect to :type dbnum: int :param password: Redis database password :type password: str """ self._logger = logging.getLogger(__name__) ioloop_ = ioloop.IOLoop.instance() self._logger.info('Connecting to Redis (%s:%i:%i)', host, port, dbnum) self.client = brukva.Client(host, port, password, dbnum, ioloop_) try: self.client.connect() except brukva.ConnectionError as error: self._logger.error('Redis connection error: %s', error)
#! /usr/bin/env python from functools import partial import time import os from pprint import pprint import brukva c = brukva.Client() c.connect() def delayed(dt, cmd, *args, **kwargs): c._io_loop.add_timeout( time.time()+dt, partial(cmd, *args, **kwargs) ) def ac(cmd, *args, **kwargs): c._io_loop.add_callback( partial(cmd, *args, **kwargs) ) stt = time.time() def on_resp(res): pprint(res) print (time.time() - stt) c.set('gt', 'er', on_resp) c.mget(['gt','sdfas'], on_resp)
def __init__(self, *args, **kwargs): super(MessagesHandler, self).__init__(*args, **kwargs) self.client = brukva.Client() self.client.connect()
def __init__(self, *args, **kwargs): super(MessagesCatcher, self).__init__(*args, **kwargs) self.client = brukva.Client() self.client.connect() self.client.subscribe('test_channel')
def setUp(self, *args, **kwargs): super(PubSubTestCase, self).setUp(*args, **kwargs) self.client2 = brukva.Client(io_loop=self.loop) self.client2.connection.connect() self.client2.select(9)
def set_source(self): cls = self.__class__ if not cls._source: cls._source = brukva.Client() cls._source.connect()
def post(self): cursor = self.get_argument("cursor", None) self.client = brukva.Client() self.client.connect() self.client.subscribe('chat_channel') self.client.listen(self.on_message)
import brukva import tornado.httpserver import tornado.web import tornado.websocket import tornado.ioloop import redis REDIS_HOST = 'localhost' REDIS_PORT = 6379 r = redis.Redis(REDIS_HOST, REDIS_PORT, db=9) c = brukva.Client(REDIS_HOST, REDIS_PORT) c.connect() c.select(9) c.set('foo', 'bar') c.set('foo2', 'bar2') class BrukvaHandler(tornado.web.RequestHandler): @tornado.web.asynchronous @brukva.adisp.process def get(self): foo, foo2 = yield [c. async .get('foo'), c. async .get('foo2')] self.set_header('Content-Type', 'text/plain') self.write(foo) self.write(foo2) self.finish()
from rest_framework.views import APIView from rest_framework.response import Response from rest_framework.decorators import api_view, authentication_classes, permission_classes from .models import ChatMessage from quiz.models.models import Question import json import brukva from chat.models import ChatRoom from django.utils.translation import ugettext_lazy as _ from django.utils.translation import gettext as __ import threading import time from .utils import get_current_question, check_answer, get_answers from quiz.views.api.utils import CsrfExemptSessionAuthentication bclient = brukva.Client() bclient.connect() @api_view(['POST']) @authentication_classes([CsrfExemptSessionAuthentication]) @permission_classes([]) def submit(request): input_data = json.loads(request.body) is_true = check_answer(input_data['message']) if is_true: input_data['message'] = input_data['message'] + get_answers() #print is_true #input_data['is_right']=check_answer(input_data['message']) input_data['is_right'] = is_true input_data['is_service'] = False
def client(cls): if not hasattr(cls, '_client'): cls._client = brukva.Client() cls._client.connect() return cls._client
def _init_redis_listener(self): self.redis_client = brukva.Client() self.redis_client.connect() self.redis_client.subscribe('%s#%s#' % (self.get_redis_app_name(), self.name)) self.redis_client.listen(self.on_messages_published)
# Create tornadio router WSRouter = TornadioRouter( WebSocketHandler, dict(enabled_protocols=[ 'websocket', 'xhr-polling', 'jsonp-polling', 'htmlfile' ])) # Create socket application application = web.Application( WSRouter.apply_routes([(r"/step-(\d)+[/]?", StepPageHandler)]), flash_policy_port=843, flash_policy_file=os.path.join(ROOT, 'flashpolicy.xml'), template_path=os.path.join(ROOT, 'templates'), static_path=os.path.join(ROOT, 'static'), socket_io_port=8001, enable_pretty_logging=True) if __name__ == '__main__': socketio_server = SocketServer(application, auto_start=False) STATS = ServerStats() redis = brukva.Client(host='localhost', port=6379, selected_db=0) redis.connect() redis.subscribe('events') redis.listen(broadcast_events) ioloop.IOLoop.instance().start()
def __init__(self, *args): super(QuizConnection, self).__init__(*args) self.client = brukva.Client() self.client.connect() self.user = None self.lesson = None
import os import sys lib_path = os.path.realpath( os.path.join(os.path.abspath(os.path.dirname(__file__)), '..', 'lib')) if lib_path not in sys.path: sys.path[0:0] = [lib_path] PORT = 9090 import redis REDIS_SYNC = redis.StrictRedis(db=0) import brukva REDIS_ASYNC = brukva.Client(selected_db=0) import celery CELERY = celery.Celery('spider', broker='redis://localhost:6379/0') STORE = os.path.realpath( os.path.join(os.path.abspath(os.path.dirname(__file__)), '..', 'store')) CONFIDENCE = 0.5 SCORE = 1000.0 try: from settings_local import * except ImportError: pass
from .helpers import (RedisSourceService, DataSourceService, TaskService, TaskStatusEnum, TaskErrorCodeEnum) from core.models import (Datasource, Dimension, Measure, QueueList, DatasourceMeta, DatasourceMetaKeys, DatasourceSettings, Dataset, DatasetToMeta, Cube) from django.conf import settings from djcelery import celery from itertools import groupby, izip BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.append(BASE_DIR) os.environ["DJANGO_SETTINGS_MODULE"] = "config.settings.production" client = brukva.Client(host=settings.REDIS_HOST, port=int(settings.REDIS_PORT), selected_db=settings.REDIS_DB) client.connect() logger = logging.getLogger(__name__) ASCENDING = 1 class TaskProcessing(object): """ Базовый класс, отвечающий за про процесс выполнения celery-задач Attributes: task_id(int): id задачи channel(str): Канал передачи на клиент