from pulsar.apps.data import register_store from .startds import start_store from ..redis import store __all__ = ["PulsarStore", "start_store"] class PulsarStore(store.RedisStore): pass register_store("pulsar", "pulsar.apps.data.PulsarStore")
.. autoclass:: pulsar.apps.data.redis.client.RedisClient :members: :member-order: bysource Redis Pipeline ~~~~~~~~~~~~~~~ .. autoclass:: pulsar.apps.data.redis.client.Pipeline :members: :member-order: bysource ''' from pulsar.utils.config import Global from pulsar.apps.data import register_store from .store import RedisStore, RedisStoreConnection from .client import RedisScript, ResponseError, RedisError, Consumer __all__ = ['RedisStore', 'RedisScript'] class RedisServer(Global): name = 'redis_server' flags = ['--redis-server'] meta = "CONNECTION_STRING" default = '127.0.0.1:6379' desc = 'Default connection string for the redis server' register_store('redis', 'pulsar.apps.data.RedisStore')
from pulsar.apps.data import register_store from .startds import start_store from ..redis import store __all__ = ['PulsarStore', 'start_store'] class PulsarStore(store.RedisStore): pass register_store('pulsar', 'pulsar.apps.data.PulsarStore')
data = response.decode_content() if 'error' in data: raise couch_db_error(**data) else: coroutine_return(data) def encode_bytes(self, data): return b64encode(data).decode(self._encoding) def dencode_bytes(self, data): return b64decode(data.encode(self._encoding)) def model_data(self, model, action): '''A generator of field/value pair for the store ''' meta = model._meta pkname = meta.pkname() _id = '_id' if action == Command.DELETE: yield _id, model.id yield '_deleted', True else: for key, value in meta.store_data(model, self, action): yield _id if key == pkname else key, value yield 'Type', meta.table_name register_store("couchdb", "pulsar.apps.data.stores.CouchDBStore") register_store("http+couchdb", "pulsar.apps.data.stores.CouchDBStore") register_store("https+couchdb", "pulsar.apps.data.stores.CouchDBStore")
from pulsar.apps import data from pulsar.apps import tasks from .models import TaskData class Store(data.Store): pass class TaskBackend(tasks.TaskBackend): def get_task(self, task_id=None, timeout=1): task_manager = self.task_manager() # if not task_id: task_id = yield task_manager.queue.block_pop_front(timeout=timeout) if task_id: task_data = yield self._get_task(task_id) if task_data: yield task_data.as_task() tasks.task_backends['stdnet'] = TaskBackend data.register_store('redis', 'stdnet.apps.tasks.Store')
Redis Pipeline ~~~~~~~~~~~~~~~ .. autoclass:: pulsar.apps.data.redis.client.Pipeline :members: :member-order: bysource ''' from pulsar.utils.config import Global from pulsar.apps.data import register_store from pulsar.apps.ds import RedisError, NoScriptError, redis_parser from .store import RedisStore, RedisStoreConnection from .client import ResponseError, Consumer, Pipeline __all__ = [ 'RedisStore', 'RedisError', 'NoScriptError', 'redis_parser', 'RedisStoreConnection', 'Consumer', 'Pipeline', 'ResponseError' ] class RedisServer(Global): name = 'redis_server' flags = ['--redis-server'] meta = "CONNECTION_STRING" default = '127.0.0.1:6379/7' desc = 'Default connection string for the redis server' register_store('redis', 'pulsar.apps.data.RedisStore')
''' from pulsar.apps.greenio import pg pg.make_asynchronous() @green_task def create_database(self, dbname=None, **kw): dbname = dbname or self.database store = create_store(self.dns, database='postgres', loop=self._loop) conn = store.sql_engine.connect() # when creating a database the connection must not be in a transaction conn.execute("commit") conn.execute("create database %s" % dbname) conn.close() return dbname @green_task def delete_database(self, dbname=None): # make sure no connections are opened self.sql_engine.dispose() dbname = dbname or self.database # switch to postgres database store = create_store(self.dns, database='postgres', loop=self._loop) conn = store.sql_engine.connect() conn.execute("commit") conn.execute("drop database %s" % dbname) conn.close() return dbname register_store('postgresql', 'pulsar.apps.data.stores.PostgreSqlStore')
from pulsar.apps import data from pulsar.apps import tasks from .models import TaskData class Store(data.Store): pass class TaskBackend(tasks.TaskBackend): def get_task(self, task_id=None, timeout=1): task_manager = self.task_manager() # if not task_id: task_id = yield task_manager.queue.block_pop_front(timeout=timeout) if task_id: task_data = yield self._get_task(task_id) if task_data: yield task_data.as_task() tasks.task_backends['stdnet'] = TaskBackend data.register_store('stdnet', 'stdnet.apps.tasks.Store')
from pulsar.apps.data import register_store from .startds import start_store from ..redis import store __all__ = ['PulsarStore', 'start_store'] class PulsarStore(store.RedisStore): pass register_store('pulsar', 'pulsar.apps.data.stores.PulsarStore')
from pulsar.apps.data import Store, register_store, create_store class DummyStore(Store): def ping(self): return True def client(self): return self def set(self, key, value, **params): pass def get(self, key): pass def hmset(self, key, iterable): pass def hmget(self, key, *fields): pass register_store('dummy', 'lux.core.cache.DummyStore')
from pulsar.apps.data import register_store from .startds import start_store from ..redis import store __all__ = ['start_store'] class PulsarStore(store.RedisStore): pass register_store('pulsar', 'pulsar.apps.data.pulsards:PulsarStore')
loop = self._loop try: state = self.connection.poll() except Exception: exc = sys.exc_info() if registered: loop.remove_connector(self._sock_fd) else: if state == POLL_OK: if registered: loop.remove_connector(self._sock_fd) callback() elif not registered: loop.add_connector(self._sock_fd, self.wait, callback, errback, True) return self.close() exc = Failure(exc) if errback: errback(exc) class PostgreSqlStore(Store): def _init(self, **kw): dns = self._buildurl() self._sql = create_engine(dns, creator=self._connect) register_store('postgresql', 'pulsar.apps.data.stores.postgresql.store.PostgreSql')
raise couch_db_error(**data) else: coroutine_return(data) def encode_bytes(self, data): return b64encode(data).decode(self._encoding) def dencode_bytes(self, data): return b64decode(data.encode(self._encoding)) def model_data(self, model, action): '''A generator of field/value pair for the store ''' meta = model._meta pkname = meta.pkname() _id = '_id' if action == Command.DELETE: yield _id, model.id yield '_deleted', True else: for key, value in meta.store_data(model, self, action): yield _id if key == pkname else key, value yield 'Type', meta.table_name if '_rev' in model: yield '_rev', model['_rev'] register_store("couchdb", "pulsar.apps.data.stores.CouchDBStore") register_store("http+couchdb", "pulsar.apps.data.stores.CouchDBStore") register_store("https+couchdb", "pulsar.apps.data.stores.CouchDBStore")
pool_size=self.max_size, loop=self.store._loop) self.pool_id += 1 if force: return self._create_connection(pair) else: return self.pool.connect() def maybe_return_socket(self, sock_info): pass class MongoDbStore(Store): protocol_factory = MongoDbConnection def _init(self, **kw): if isinstance(self._host, tuple): host, port = self._host else: raise NotImplementedError('Could not connect to %s' % str(self._host)) kw['_pool_class'] = partial(MongoDbPool, self) kw['_connect'] = False self.delegate = pymongo.MongoClient(host, port, **kw) def client(self): return MongoDbClient(self) register_store('mongodb', 'lux.stores.mongodb.store.MongoDbStore')
loop=self.store._loop) self.pool_id += 1 if force: return self._create_connection(pair) else: return self.pool.connect() def maybe_return_socket(self, sock_info): pass class MongoDbStore(Store): protocol_factory = MongoDbConnection def _init(self, **kw): if isinstance(self._host, tuple): host, port = self._host else: raise NotImplementedError('Could not connect to %s' % str(self._host)) kw['_pool_class'] = partial(MongoDbPool, self) kw['_connect'] = False self.delegate = pymongo.MongoClient(host, port, **kw) def client(self): return MongoDbClient(self) register_store('mongodb', 'lux.stores.mongodb.store.MongoDbStore')
from pulsar.apps import data from pulsar.apps import tasks from .models import TaskData class Store(data.Store): pass class TaskBackend(tasks.TaskBackend): def get_task(self, task_id=None, timeout=1): task_manager = self.task_manager() # if not task_id: task_id = yield task_manager.queue.block_pop_front(timeout=timeout) if task_id: task_data = yield self._get_task(task_id) if task_data: yield task_data.as_task() tasks.task_backends["stdnet"] = TaskBackend data.register_store("redis", "stdnet.apps.tasks.Store")