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