def save(self, model, **kwargs):
""" Saves model instance.
Before actual saving it runs `*_isinstance` function.
"""
self._isinstance(model)
db.get_session().add(model)
return model
def set_search_path(event):
request = event.request
public_schema, public_include = get_public_schema_info()
session = db.get_session()
set_schema_to_public(session=session, public_schema=public_schema)
domain_url = get_domain_url_from_request(request)
tenant = Meta.TenantModel.manager.get_or_404(domain_url=domain_url)
request.tenant = tenant
register_tenant_schema(request=request, session=session, tenant=tenant)
def schema_context(schema_name=None, domain_url=None):
if schema_name is None and domain_url is None:
raise ValueError(u"Gimme schema_name or domain_url")
session = db.get_session()
if schema_name:
tenant = Meta.TenantModel.manager.get_or_404(schema_name=schema_name)
else:
tenant = Meta.TenantModel.manager.get_or_404(domain_url=domain_url)
session.execute('SET search_path TO {0}'.format(tenant.schema_name))
yield
def save(self, model, create_schema=True, **kwargs):
from sqlalchemy.schema import CreateSchema
from seth import tenancy
public_schema, _ = tenancy.get_public_schema_info()
session = db.get_session()
tenancy.set_schema_to_public(
session=session, public_schema=public_schema
)
super(TenantManager, self).save(model)
if not model.id and create_schema and model.schema_name != public_schema:
session.execute(CreateSchema(model.schema_name))
tenancy.set_schema_to_public(
session=session, public_schema=public_schema
)
def _register_tenancy(config, TenantModel):
from seth import db
from seth import tenancy
tenancy.Meta.TenantModel = TenantModel
session = db.get_session()
dialect = session.connection().engine.url.get_dialect()
if dialect.name in tenancy.supported_dialects:
config.add_subscriber(tenancy.set_search_path, NewRequest)
else:
msg = 'Cannot register tenancy. Dialect: {0} is not supported'.format(
dialect.name
)
logger.error(msg)
raise RuntimeError(msg)
def query(self):
""" Provides shortcut to sqlalchemy's `*session.query` function
from manager.
For example:
.. code-block:: python
MyModel.manager.query
or
.. code-block:: python
MyModel.query
"""
return db.get_session().query(self.model_class)
def setUp(self):
self.connection = self.engine.connect()
self.trans = self.connection.begin()
self.config = testing.setUp()
self.session = db.get_session()
if __name__ == '__main__':
logging.basicConfig(level=logging.DEBUG)
config = Configurator()
settings = {
'sqlalchemy.url': 'sqlite://'
}
engine = engine_from_config(settings, prefix='sqlalchemy.')
maker = scoped_session(sessionmaker(
extension=ZopeTransactionExtension()
))
maker.configure(bind=engine)
db.register_maker(maker=maker)
Base.metadata.bind = engine
Base.metadata.create_all(engine)
# create two blank models
session = db.get_session()
for i in range(10000):
SuperModel.manager.create()
db.commit()
config.include('seth')
config.register_query_listener(engine, 0)
config.register_resource(SampleResource, '/test/')
app = config.make_wsgi_app()
server = make_server('0.0.0.0', 6543, app)
server.serve_forever()
def test_assert_raises_not_initialized_exception_when_db_is_not_initialized(self):
old_maker = db.Meta.maker
db.Meta.maker = None
self.assertRaises(db.SessionNotInitializedException, lambda: db.get_session())
db.Meta.maker = old_maker
def save(self, model, **kwargs):
if not self.query.count():
self._isinstance(model)
model.id = self.default_pk
db.get_session().add(model)
return model
def delete(self, model):
""" Deletes model instance performing verification first.
"""
self._isinstance(model)
db.get_session().delete(model)
def handle_update(self, instance, data):
session = db.get_session()
instance.manager.update(model=instance, **data)
session.flush()
def handle_deletion(self, instance):
session = db.get_session()
instance.manager.delete(model=instance)
session.flush()
def handle_creation(self, instance):
session = db.get_session()
instance.manager.save(model=instance)
session.flush()
