def create_provider_model(self):
"""Create the database tables if they don't already exist."""
bind_metadata()
class_mapper(user_class).local_table.create(checkfirst=True)
class_mapper(group_class).local_table.create(checkfirst=True)
class_mapper(permission_class).local_table.create(checkfirst=True)
class_mapper(visit_class).local_table.create(checkfirst=True)
def doit(opts, metadata=None):
if not metadata:
from turbogears.database import metadata, bind_metadata
bind_metadata()
if opts.check:
version = opts.downgrade or 'head'
return 0 if check_db(metadata, version) else 1
elif opts.downgrade:
downgrade_db(metadata, opts.downgrade)
else:
table_names = metadata.bind.table_names()
# if database is empty then initialize it
# python-alembic-0.6.5-3 will autocreate the alembic_version table
# when checking an empty database. This is fixed in newer alembic
# versions; 0.8.3-4 does not have this issue
database_is_empty = len(table_names) == 0
only_has_alembic_version_table = (
len(table_names) == 1 and table_names[0] == 'alembic_version')
if database_is_empty or only_has_alembic_version_table:
if not opts.user_name:
logger.error('Database is empty, you must pass --user to create an admin user')
return 1
init_db(metadata)
else:
# upgrade to the latest DB version
upgrade_db(metadata)
populate_db(opts.user_name, opts.password, opts.display_name, opts.email_address)
logger.info('Exiting')
return 0
def doit(opts, metadata = None):
if not metadata:
from turbogears.database import metadata, bind_metadata
bind_metadata()
if opts.check:
version = opts.downgrade or 'head'
return 0 if check_db(metadata, version) else 1
elif opts.downgrade:
downgrade_db(metadata, opts.downgrade)
else:
table_names = metadata.bind.table_names()
# if database is empty then initialize it
# python-alembic-0.6.5-3 will autocreate the alembic_version table
# when checking an empty database. This is fixed in newer alembic
# versions; 0.8.3-4 does not have this issue
database_is_empty = len(table_names) == 0
only_has_alembic_version_table = (len(table_names) == 1 and table_names[0] == 'alembic_version')
if database_is_empty or only_has_alembic_version_table:
if not opts.user_name:
logger.error('Database is empty, you must pass --user to create an admin user')
return 1
init_db(metadata)
else:
# upgrade to the latest DB version
upgrade_db(metadata)
populate_db(opts.user_name, opts.password, opts.display_name, opts.email_address)
logger.info('Exiting')
return 0
def status(command, args):
bind_metadata()
get_model()
ret = compare_metadata(metadata, MetaData(metadata.bind))
for l in ret:
print l
if not ret:
print "Database matches model"
def setUp(self):
"""Set database configuration and set up database.
"""
self.sa_dburi = config.get('sqlalchemy.dburi')
set_db_uri('sqlite:///:memory:', 'sqlalchemy')
bind_metadata()
self.users_table = Table("users", metadata,
Column("user_id", Integer, primary_key=True),
Column("user_name", String(40)),
Column("password", String(10)))
metadata.create_all()
def setup_module():
global _sa_dburi, _so_dburi
_so_dburi = config.get("sqlobject.dburi", "sqlite:///:memory:")
_sa_dburi = config.get("sqlalchemy.dburi", "sqlite:///:memory:")
# sqlalchemy setup
database.set_db_uri("sqlite:///:memory:", "sqlalchemy")
sqlalchemy_cleanup()
bind_metadata()
# sqlobject setup
database.set_db_uri("sqlite:///:memory:", "sqlobject")
create_tables()
hub.commit()
def setup_module():
global users_table, test_table, multi_table, fresh_multi_table
config.update({
'sqlalchemy.dburi': 'sqlite:///:memory:',
'fresh.dburi': 'sqlite:///freshtest.db',
})
if os.path.exists('freshtest.db'):
os.unlink('freshtest.db')
fresh_metadata = get_metadata('fresh')
if metadata.is_bound():
metadata.bind = None
bind_metadata()
metadata.bind.echo = True
fresh_metadata.bind.echo = True
users_table = Table("users", metadata,
Column("user_id", Integer, primary_key=True),
Column("user_name", String(40)),
Column("password", String(10)))
persons_table = Table("persons", metadata,
Column("id", Integer, primary_key=True),
Column("name", String(40)))
addresses_table = Table("addresses", metadata,
Column("id", Integer, primary_key=True),
Column("address", String(40)),
Column("city", String(40)),
Column("person_id", Integer, ForeignKey(persons_table.c.id)))
multi_table = Table('multi', metadata,
Column('id', Integer, primary_key=True))
metadata.create_all()
test_table = Table("test", fresh_metadata,
Column("id", Integer, primary_key=True),
Column("val", String(40)))
fresh_multi_table = Table('multi', fresh_metadata,
Column('id', Integer, primary_key=True))
fresh_metadata.create_all()
mapper(User, users_table)
mapper(Person, persons_table)
mapper(Address, addresses_table, properties=dict(
person=relation(Person, backref='addresses')))
mapper(Test, test_table)
start_server()
def main():
parser = get_parser()
opts, args = parser.parse_args()
load_config_or_exit(opts.configfile)
log_to_stream(sys.stderr, level=logging.DEBUG if opts.debug else logging.WARNING)
from turbogears.database import metadata, bind_metadata
bind_metadata()
if opts.downgrade:
downgrade_db(metadata, opts.downgrade)
else:
# if database is empty then initialize it
if not metadata.bind.table_names():
init_db(metadata, user_name=opts.user_name, password=opts.password,
user_display_name=opts.display_name, user_email_address=opts.email_address)
else:
# upgrade to the latest DB version
upgrade_db(metadata)
def doit(opts):
from turbogears.database import metadata, bind_metadata
bind_metadata()
if opts.check:
version = opts.downgrade or 'head'
return 0 if check_db(metadata, version) else 1
elif opts.downgrade:
downgrade_db(metadata, opts.downgrade)
else:
# if database is empty then initialize it
if not metadata.bind.table_names():
if not opts.user_name:
logger.error('Database is empty, you must pass --user to create an admin user')
return 1
init_db(metadata)
else:
# upgrade to the latest DB version
upgrade_db(metadata)
populate_db(opts.user_name, opts.password, opts.display_name, opts.email_address)
logger.info('Exiting')
return 0
def main():
parser = get_parser()
opts, args = parser.parse_args()
load_config_or_exit(opts.configfile)
log_to_stream(sys.stderr,
level=logging.DEBUG if opts.debug else logging.WARNING)
from turbogears.database import metadata, bind_metadata
bind_metadata()
if opts.downgrade:
downgrade_db(metadata, opts.downgrade)
else:
# if database is empty then initialize it
if not metadata.bind.table_names():
if not opts.user_name:
parser.error('Pass --user to create an admin user')
init_db(metadata)
else:
# upgrade to the latest DB version
upgrade_db(metadata)
populate_db(opts.user_name, opts.password, opts.display_name,
opts.email_address)
def create(command, args):
print "Creating tables at %s" % (config.get("sqlalchemy.dburi"))
bind_metadata()
get_model()
metadata.create_all()
def startTurboGears():
"""Handles TurboGears tasks when the CherryPy server starts.
This performs the following initialization tasks (in given order):
* Turns off CherryPy's logging filter when in development mode
* If logging is not already set up, turns on old-style stdlib logging.
* Adds a static filter for TurboGears's static files (URL '/tg_static').
* Adds a static filter for TurboGears's JavaScript files (URL '/tg_js').
* Loads the template engines and the base templates.
* Adds the CherryPy request filters to the root controller.
* Adds the decoding filter to the root URL ('/') if enabled in the
configuration.
* Registers the server with the Bonjour framework, if available.
* Calls 'turbogears.database.bind_metadata' when using SQLAlchemy.
* Loads all turbogears.extensions entry points and calls their
'start_extension' method.
* Calls the callables registered in 'turbogears.call_on_startup'.
* Starts the TurboGears scheduler.
"""
global webpath
conf = config.get
rfn = pkg_resources.resource_filename
cherrypy.config.environments['development'][
'log_debug_info_filter.on'] = False
# XXX: obsolete --> to be removed
# Set up old-style logging
if not conf('tg.new_style_logging', False):
if conf('server.log_to_screen'):
setuplog = logging.getLogger()
setuplog.setLevel(logging.DEBUG)
fmt = logging.Formatter(
"%(asctime)s %(name)s %(levelname)s %(message)s")
handler = logging.StreamHandler(sys.stdout)
handler.setLevel(logging.DEBUG)
handler.setFormatter(fmt)
setuplog.addHandler(handler)
logfile = conf('server.log_file')
if logfile:
setuplog = logging.getLogger('turbogears.access')
setuplog.propagate = 0
fmt = logging.Formatter("%(message)s")
handler = logging.FileHandler(logfile)
handler.setLevel(logging.INFO)
handler.setFormatter(fmt)
setuplog.addHandler(handler)
# Add static filters
config.update({'/tg_static': {
'static_filter.on': True,
'static_filter.dir': abspath(rfn(__name__, 'static')),
'log_debug_info_filter.on': False,
}})
config.update({'/tg_js': {
'static_filter.on': True,
'static_filter.dir': abspath(rfn(__name__, 'static/js')),
'log_debug_info_filter.on': False,
}})
# Add decoding filter
if conf('decoding_filter.on', path='/') is None:
config.update({'/': {
'decoding_filter.on': True,
'decoding_filter.encoding': conf('kid.encoding', 'utf8')
}})
# Initialize template engines and load base templates
view.load_engines()
view.loadBaseTemplates()
# Add request filters
webpath = conf('server.webpath') or ''
if getattr(cherrypy, 'root', None):
if not hasattr(cherrypy.root, '_cp_filters'):
cherrypy.root._cp_filters = []
extra_filters = [
VirtualPathFilter(webpath),
EndTransactionsFilter(),
NestedVariablesFilter(),
SafeMultipartFilter()
]
# Do not add filters twice which are already present
for cp_filter in cherrypy.root._cp_filters[:]:
for candidate in extra_filters:
if candidate.__class__ == cp_filter.__class__:
extra_filters.remove(candidate)
break
cherrypy.root._cp_filters.extend(extra_filters)
# Monkey patch CherryPy Decoding filter: injects our replacement filter
# MonkeyDecodingFilter into the CherryPy filter chain
decoding_filter = MonkeyDecodingFilter()
for index, active_filter in enumerate(
cherrypy.filters._filterhooks.get('before_main', [])):
if active_filter.im_class == \
cherrypy.filters.decodingfilter.DecodingFilter:
cherrypy.filters._filterhooks['before_main'].pop(index)
if conf('decoding_filter.on', False, path='/'):
log.info("Request decoding filter activated.")
cherrypy.filters._filterhooks['before_main'].insert(
index, decoding_filter.before_main)
webpath = webpath.lstrip('/')
if webpath and not webpath.endswith('/'):
webpath += '/'
# Register server with Bonjour framework
bonjoursetting = conf('tg.bonjour', None)
if bonjoursetting or conf('server.environment') == 'development':
start_bonjour(bonjoursetting)
# Bind metadata for SQLAlchemy
if conf('sqlalchemy.dburi'):
database.bind_metadata()
# Start all TurboGears extensions
extensions = pkg_resources.iter_entry_points('turbogears.extensions')
for entrypoint in extensions:
# We try to load the extension and run its 'start_extension'
# method ,if present. If either fails, we simply log the exception and
# continue, because a) when the autoreloader is active, unhandled
# exceptions in the startup phase will not stop the server and
# b) faulty extensions (which may be from a different package)
# should not crash the server.
try:
ext = entrypoint.load()
except Exception, e:
log.exception("Error loading TurboGears extension plugin '%s': %s",
entrypoint, e)
continue
if hasattr(ext, 'start_extension'):
try:
ext.start_extension()
except Exception, e:
log.exception("Error starting TurboGears extension '%s': %s",
entrypoint, e)
def create_model(self):
"""Create the Visit table if it doesn't already exist."""
bind_metadata()
class_mapper(visit_class).local_table.create(checkfirst=True)
log.debug("Visit model database table(s) created.")
