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")
