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 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 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 makeredis(pool = None): cursor = getdb(format(settings.DEFAULT_BACKEND), decode = 1, connection_class = AsyncRedisConnection) return cursor.client