def __init__(self, backend, autocommit = False, query_class = None):
self.backend = getdb(backend)
self.transaction = None
self.autocommit = autocommit
self._new = OrderedDict()
self._deleted = OrderedDict()
self._modified = OrderedDict()
self._loaded = {}
self.query_class = query_class or Query
def register(self, model, backend=None, read_backend=None,
include_related=True, **params):
'''Register a :class:`Model` with this :class:`Router`. If the
model was already registered it does nothing.
:param model: a :class:`Model` class.
:param backend: a :class:`stdnet.BackendDataServer` or a
:ref:`connection string <connection-string>`.
:param read_backend: Optional :class:`stdnet.BackendDataServer` for read
operations. This is useful when the server has a master/slave
configuration, where the master accept write and read operations
and the ``slave`` read only operations.
:param include_related: ``True`` if related models to ``model`` needs to be
registered. Default ``True``.
:param params: Additional parameters for the :func:`getdb` function.
:return: the number of models registered.
'''
backend = backend or self._default_backend
backend = getdb(backend=backend, **params)
if read_backend:
read_backend = getdb(read_backend)
registered = 0
if isinstance(model, Structure):
self._structures[model] = StructureManager(model, backend,
read_backend, self)
return model
for model in models_from_model(model, include_related=include_related):
if model in self._registered_models:
continue
registered += 1
default_manager = backend.default_manager or Manager
manager_class = getattr(model, 'manager_class', default_manager)
manager = manager_class(model, backend, read_backend, self)
self._registered_models[model] = manager
if isinstance(model, ModelType):
attr_name = model._meta.name
else:
attr_name = model.__name__.lower()
if attr_name not in self._registered_names:
self._registered_names[attr_name] = manager
if self._install_global:
model.objects = manager
if registered:
return backend
def create_backend(self, prefix):
from stdnet import odm
self.namespace = '%s%s-' % (prefix, gen_unique_id())
if self.connection_string:
server = getdb(self.connection_string, namespace=self.namespace,
**self.backend_params())
self.backend = server
yield server.flush()
self.mapper = odm.Router(self.backend)
for model in self.models:
self.mapper.register(model)
def create_backend(self, prefix):
from stdnet import odm
self.namespace = '%s%s-' % (prefix, gen_unique_id())
if self.connection_string:
server = getdb(self.connection_string,
namespace=self.namespace,
**self.backend_params())
self.backend = server
yield server.flush()
self.mapper = odm.Router(self.backend)
for model in self.models:
self.mapper.register(model)
def register(model, backend=None, ignore_duplicates=True, local_thread=False, **params):
"""The low level function for registering a :class:`stdnet.orm.StdModel`
classes with a :class:`stdnet.backends.BackendDataServer` data server.
:parameter model: a :class:`stdnet.orm.StdModel` class. Must be provided.
:parameter backend: a backend connection string.
For example::
redis://localhost:8080?db=6&prefix=bla.
Default ``settings.DEFAULT_BACKEND``.
:parameter params: optional parameters which can be used to override the
connection string parameters.
:parameter timeout: timeout in seconds for keys persistence.
If not provided it is calculated from the
connection string.
Default ``None``.
**Usage**
For Redis the syntax is the following::
import orm
orm.register(Author, 'redis://my.host.name:6379/?db=1')
orm.register(Book, 'redis://my.host.name:6379/?db=2')
orm.register(MyOtherModel,
'redis://my.host.name:6379/?db=2&keyprefix=differentprefix')
``my.host.name`` can be ``localhost`` or an ip address or a domain name,
while ``db`` indicates the database number (very useful for separating data
on the same redis instance)."""
global _GLOBAL_REGISTRY
from stdnet.conf import settings
if model in _GLOBAL_REGISTRY:
if not ignore_duplicates:
raise AlreadyRegistered("Model {0} is already registered".format(meta))
else:
return
backend = getdb(backend_uri=backend, **params)
for manager in model._managers:
manager.backend = backend
_GLOBAL_REGISTRY.add(model)
return model.objects.backend
def setUpClass(cls):
if not cls.models and cls.model:
cls.models = (cls.model,)
if not cls.model and cls.models:
cls.model = cls.models[0]
cls.namespace = 'stdnet-test-%s.' % gen_unique_id()
if cls.connection_string:
server = getdb(cls.connection_string, namespace=cls.namespace,
**cls.backend_params())
cls.backend = server
if server.name == 'redis':
r = server.client.script_flush()
if isinstance(r, BackendRequest):
return r.add_callback(lambda r: cls.clear_all())
return cls.clear_all()
def on_start(self):
servers = []
names = set()
for s in self.config.server:
try:
s = getdb(s)
s.ping()
except Exception:
LOGGER.error('Could not obtain server %s' % s, exc_info=True)
else:
if s.name not in names:
names.add(s.name)
servers.append(s.connection_string)
if not servers:
raise pulsar.HaltServer('No server available. BAILING OUT')
settings.servers = servers
def on_start(self):
servers = []
names = set()
for s in self.config.server:
try:
s = getdb(s)
s.ping()
except Exception:
LOGGER.error('Could not obtain server %s' % s,
exc_info=True)
else:
if s.name not in names:
names.add(s.name)
servers.append(s.connection_string)
if not servers:
raise pulsar.HaltServer('No server available. BAILING OUT')
settings.servers = servers
def register(model, backend=None, include_related=True, **params):
'''The low level function for registering a :class:`StdModel`
classes with a :class:`stdnet.BackendDataServer` data server.
:parameter model: a :class:`StdModel`. Must be provided.
:parameter backend: a backend connection string.
For example::
redis://localhost:8080?db=6&prefix=bla.
Default ``settings.DEFAULT_BACKEND``.
:parameter include_related: register all related models.
:parameter params: optional parameters which can be used to override the
connection string parameters.
**Usage**
For Redis the syntax is the following::
import odm
odm.register(Author, 'redis://my.host.name:6379/?db=1')
odm.register(Book, 'redis://my.host.name:6379/?db=2')
odm.register(MyOtherModel,
'redis://my.host.name:6379/?db=2&keyprefix=differentprefix.')
``my.host.name`` can be ``localhost`` or an ip address or a domain name,
while ``db`` indicates the database number (very useful for separating data
on the same redis instance).'''
backend = getdb(backend=backend, **params)
registered = []
for m in models_from_model(model, include_related=include_related):
if m in _GLOBAL_REGISTRY:
continue
for manager in m._managers:
manager.backend = backend
_GLOBAL_REGISTRY.add(m)
registered.append(m)
if registered:
return registered[0].objects.backend
def register(model, backend = None, keyprefix = None, timeout = 0):
'''Register a :class:`stdnet.rom.StdNet` model with a backend data server.'''
global _registry
from stdnet.conf import settings
backend = backend or settings.DEFAULT_BACKEND
prefix = keyprefix or model._meta.keyprefix or settings.DEFAULT_KEYPREFIX or ''
if prefix:
prefix = '%s:' % prefix
meta = model._meta
meta.keyprefix = prefix
meta.timeout = timeout or 0
objects = getattr(model,'objects',None)
if objects is None or isinstance(objects,UnregisteredManager):
objects = Manager()
else:
objects = copy.copy(objects)
model.objects = objects
meta.cursor = getdb(backend)
objects.model = model
objects._meta = meta
objects.cursor = meta.cursor
_registry[model] = meta
return meta.cursor.name
def register(model, backend=None, keyprefix=None, timeout=0):
'''Register a :class:`stdnet.rom.StdNet` model with a backend data server.'''
global _registry
from stdnet.conf import settings
backend = backend or settings.DEFAULT_BACKEND
prefix = keyprefix or model._meta.keyprefix or settings.DEFAULT_KEYPREFIX or ''
if prefix:
prefix = '%s:' % prefix
meta = model._meta
meta.keyprefix = prefix
meta.timeout = timeout or 0
objects = getattr(model, 'objects', None)
if objects is None or isinstance(objects, UnregisteredManager):
objects = Manager()
else:
objects = copy.copy(objects)
model.objects = objects
meta.cursor = getdb(backend)
objects.model = model
objects._meta = meta
objects.cursor = meta.cursor
_registry[model] = meta
return meta.cursor.name
def async_handler(backend):
if backend.client.connection_pool.connection_class == RedisConnection:
return backend
else:
return getdb(backend.connection_string,
connection_class=RedisConnection)
import time
import random
import stdnet
from stdnet.test import TestCase
cache = stdnet.getdb()
class TestString(TestCase):
def testSetGet(self):
cache.set('test',1)
self.assertEqual(cache.get('test'),1)
cache.set('test2','ciao',1)
self.assertEqual(cache.get('test2'),'ciao')
time.sleep(2)
self.assertEqual(cache.get('test2'),None)
def setUp(self):
rpy = getdb().client
rpy.set("test", "bla")
self.db = rpy.db
self.info = redis_info(rpy)
__test__ = False
try:
from example.luxweb.settings import *
except ImportError:
import sys
print('Add a settings file in the example.luxweb module')
sys.exit(1)
EXTENSIONS = ['lux.extensions.base']
from stdnet import getdb
from pulsar.utils.security import gen_unique_id
c = getdb(DATASTORE[''], db=7, namespace='luxtest:%s:' % gen_unique_id()[:8])
DATASTORE = {'': c.connection_string}
def __init__(self, server = None, pickler = Json, shard_hint = None):
if isclass(pickler):
pickler = pickler()
self.pickler = pickler
self.client = getdb(server).redispy
def testRedis(self):
b = getdb('redis://')
self.assertEqual(b.name, 'redis')
self.assertEqual(b.connection_string, 'redis://127.0.0.1:6379?db=0')
__test__ = False
try:
from example.luxweb.settings import *
except ImportError:
import sys
print("Add a settings file in the example.luxweb module")
sys.exit(1)
EXTENSIONS = ["lux.extensions.base"]
from stdnet import getdb
from pulsar.utils.security import gen_unique_id
c = getdb(DATASTORE[""], db=7, namespace="luxtest:%s:" % gen_unique_id()[:8])
DATASTORE = {"": c.connection_string}
def __call__(self, server = None, id = None, pickler = None,
value_pickler = None, **kwargs):
db = getdb(server)
s = TS(db, self._id(id))
self._structs[s.id] = s
return s
def makeredis(pool = None):
db = getdb(format(settings.DEFAULT_BACKEND), decode = 1)
return db.client
def __init__(self, backend, query_class=None):
self.backend = getdb(backend)
self.transaction = None
self._models = OrderedDict()
self.query_class = query_class or Query
def server(self):
return getdb(self.backend.connection_string)
def _pre_setup(self):
if not self.models and self.model:
self.models = (self.model,)
self.prefix = 'stdnet-test-'+gen_unique_id()+'.'
self.backend = getdb(prefix = self.prefix)
return self.backend.flush(pattern = 'stdnet-test-*')
def rpy(self):
return getdb().client
def register(self):
self.orm.register(SimpleModel)
self.rpy = getdb().redispy
def __init__(self, server=None, encoder=None):
encoder = encoder or self.encoder
if isclass(encoder):
encoder = encoder()
self.encoder = encoder
self.server = getdb(server)
def testRedis(self):
b = getdb('redis://')
self.assertEqual(b.name, 'redis')
self.assertEqual(b.connection_string, 'redis://127.0.0.1:6379?db=0')
def makeredis(pool = None):
cursor = getdb(format(settings.DEFAULT_BACKEND), decode = 1,
connection_class = AsyncRedisConnection)
return cursor.client
