コード例 #1
0
 def environment_needs_upgrade(self):
     """
     Called when Trac checks whether the environment needs to be upgraded.
     Returns `True` if upgrade is needed, `False` otherwise.
     """
     dbm = DatabaseManager(self.env)
     return dbm.get_database_version(db_version_key) != db_version
コード例 #2
0
ファイル: env.py プロジェクト: hanotch/trac
    def upgrade(self, backup=False, backup_dest=None):
        """Upgrade database.

        :param backup: whether or not to backup before upgrading
        :param backup_dest: name of the backup file
        :return: whether the upgrade was performed
        """
        upgraders = []
        for participant in self.setup_participants:
            with self.component_guard(participant, reraise=True):
                if participant.environment_needs_upgrade():
                    upgraders.append(participant)
        if not upgraders:
            return

        if backup:
            try:
                self.backup(backup_dest)
            except Exception as e:
                raise BackupError(e)

        for participant in upgraders:
            self.log.info("upgrading %s...", participant)
            with self.component_guard(participant, reraise=True):
                participant.upgrade_environment()
            # Database schema may have changed, so close all connections
            dbm = DatabaseManager(self)
            if dbm.connection_uri != 'sqlite::memory:':
                dbm.shutdown()

        self._update_sample_config()
        del self.database_version
        return True
コード例 #3
0
 def upgrade_environment(self, db):
     db_connector, _ = DatabaseManager(self.env).get_connector()
     cursor = db.cursor()
     dbver = self.get_db_version()
     if dbver == 0:
         self.env.log.info("Initialize %s database schema to version %s",
                           PLUGIN_NAME, PLUGIN_VERSION)
         for table in SCHEMA:
             for stmt in db_connector.to_sql(table):
                 cursor.execute(stmt)
         cursor.execute(
             """
             INSERT INTO system (name, value)
             VALUES (%s, %s)
             """, (PLUGIN_NAME, PLUGIN_VERSION))
     else:
         while dbver != PLUGIN_VERSION:
             dbver = dbver + 1
             self.env.log.info("Upgrade %s database schema to version %s",
                               PLUGIN_NAME, dbver)
             modulename = 'db%i' % dbver
             upgrades = __import__('cards.upgrades', globals(), locals(),
                                   [modulename])
             script = getattr(upgrades, modulename)
             script.do_upgrade(self.env, dbver, cursor)
         cursor.execute(
             """
             UPDATE system
             SET value=%s
             WHERE name=%s
             """, (PLUGIN_VERSION, PLUGIN_NAME))
コード例 #4
0
 def setUp(self):
     self.env = EnvironmentStub(path=mkdtemp())
     self.dbm = DatabaseManager(self.env)
     with self.env.db_transaction:
         self.dbm.drop_tables(new_schema)
         self.dbm.create_tables(old_schema)
         self.dbm.set_database_version(VERSION - 1)
コード例 #5
0
ファイル: db38.py プロジェクト: pkdevbox/trac
def do_upgrade(env, ver, cursor):
    """Add an auto-increment primary key to `node_change` table and indices
    (repos, rev, path) and (repos, path, rev) (#3676).
    """
    db_connector, _ = DatabaseManager(env)._get_connector()
    table = Table('node_change', key='id')[
        Column('id', auto_increment=True),
        Column('repos', type='int'),
        Column('rev', key_size=40),
        Column('path', key_size=255),
        Column('node_type', size=1),
        Column('change_type', size=1),
        Column('base_path'),
        Column('base_rev'),
        Index(['repos', 'rev', 'path']),
        Index(['repos', 'path', 'rev'])]

    with env.db_transaction:
        cursor.execute("""CREATE TEMPORARY TABLE node_change_old AS
                          SELECT * FROM node_change""")
        cursor.execute("DROP TABLE node_change")

        for stmt in db_connector.to_sql(table):
            cursor.execute(stmt)

        cursor.execute("""\
            INSERT INTO node_change
            (repos,rev,path,node_type,change_type,base_path,base_rev)
            SELECT repos,rev,path,node_type,change_type,base_path,base_rev
            FROM node_change_old""")
        cursor.execute("DROP TABLE node_change_old")
コード例 #6
0
ファイル: db.py プロジェクト: nagyistoce/trac-multiproject
def trac_db_query(env):
    """
    Context manager to handle database connection and cursor from trac environment's
    read only connection. This does not attempt to roll back or commit, the connection
    is meant only for accessing the data. For examples on use, see db_query().

    Internally, this uses Trac's connection pool via the Trac DatabaseManager class

    :param Environment env: The Trac environment
    """
    conn = None
    cursor = None

    try:
        dm = DatabaseManager(env)
        conn = dm.get_connection()
    except Exception:
        env.log.exception(
            "Failed to get database connection from trac database manager")
        raise

    try:
        # NOTE: Trac's connection does not support alternative cursor types!
        cursor = conn.cursor()
        yield cursor
    except Exception:
        env.log.error("Failed to query database")
        raise
    finally:
        cursor.close()
        conn.close()
コード例 #7
0
ファイル: core.py プロジェクト: folpindo/psuter-cards-plugin
 def upgrade_environment(self, db):
     db_connector, _ = DatabaseManager(self.env).get_connector() 
     cursor = db.cursor()
     dbver = self.get_db_version()
     if dbver == 0:
         self.env.log.info("Initialize %s database schema to version %s",
                      PLUGIN_NAME, PLUGIN_VERSION)
         for table in SCHEMA:
             for stmt in db_connector.to_sql(table):
                 cursor.execute(stmt)
         cursor.execute("""
             INSERT INTO system (name, value)
             VALUES (%s, %s)
             """, (PLUGIN_NAME, PLUGIN_VERSION))
     else:
         while dbver != PLUGIN_VERSION:
             dbver = dbver + 1
             self.env.log.info("Upgrade %s database schema to version %s",
                      PLUGIN_NAME, dbver)
             modulename = 'db%i' % dbver
             upgrades = __import__('cards.upgrades', globals(), locals(), [modulename])
             script = getattr(upgrades, modulename)
             script.do_upgrade(self.env, dbver, cursor)
         cursor.execute("""
             UPDATE system
             SET value=%s
             WHERE name=%s
             """, (PLUGIN_VERSION, PLUGIN_NAME))
コード例 #8
0
ファイル: db38.py プロジェクト: linhcao1611/Trac-JIRA
def do_upgrade(env, ver, cursor):
    """Add an auto-increment primary key to `node_change` table and indices
    (repos, rev, path) and (repos, path, rev) (#3676).
    """
    db_connector, _ = DatabaseManager(env)._get_connector()
    table = Table('node_change', key='id')[Column('id', auto_increment=True),
                                           Column('repos', type='int'),
                                           Column('rev', key_size=40),
                                           Column('path', key_size=255),
                                           Column('node_type', size=1),
                                           Column('change_type', size=1),
                                           Column('base_path'),
                                           Column('base_rev'),
                                           Index(['repos', 'rev', 'path']),
                                           Index(['repos', 'path', 'rev'])]

    with env.db_transaction:
        cursor.execute("""CREATE TEMPORARY TABLE node_change_old AS
                          SELECT * FROM node_change""")
        cursor.execute("DROP TABLE node_change")

        for stmt in db_connector.to_sql(table):
            cursor.execute(stmt)

        cursor.execute("""\
            INSERT INTO node_change
            (repos,rev,path,node_type,change_type,base_path,base_rev)
            SELECT repos,rev,path,node_type,change_type,base_path,base_rev
            FROM node_change_old""")
        cursor.execute("DROP TABLE node_change_old")
コード例 #9
0
ファイル: db2.py プロジェクト: aroth-arsoft/trac-announcer
def do_upgrade(env, ver, cursor):
    """Changes to subscription db table:

    - 'subscriptions.destination', 'subscriptions.format'
    + 'subscriptions.authenticated', 'subscriptions.transport'
    'subscriptions.managed' type='int' --> (default == char)
    """
    cursor.execute("""
        CREATE TEMPORARY TABLE subscriptions_old
            AS SELECT * FROM subscriptions
    """)
    cursor.execute("DROP TABLE subscriptions")

    connector = DatabaseManager(env).get_connector()[0]
    for table in schema:
        for stmt in connector.to_sql(table):
            cursor.execute(stmt)
    cursor.execute("""
        INSERT INTO subscriptions
               (sid,authenticated,enabled,managed,
                realm,category,rule,transport)
        SELECT o.sid,s.authenticated,o.enabled,'watcher',
               o.realm,o.category,rule,'email'
          FROM subscriptions_old AS o
          LEFT JOIN session AS s
               ON o.sid=s.sid
    """)
    cursor.execute("DROP TABLE subscriptions_old")
コード例 #10
0
ファイル: db.py プロジェクト: alvabai/trac-multiproject
def trac_db_transaction(env):
    """
    Context manager to handle database connection and cursor from trac environment's
    read / write connection. This handles automatic commits, rollbacks and connection
    closing.

    Internally, this uses Trac's connection pool via the Trac DatabaseManager class.
    This is because it would appear that to multiproject uses, Trac's with_transaction()
    is not sufficient.

    For examples of use, see db_transaction()

    :param Environment env: The Trac Environment in use.
    """
    conn = None
    cursor = None

    try:
        dm = DatabaseManager(env)
        conn = dm.get_connection()
    except Exception:
        env.log.exception("Failed to get database connection from trac database manager")
        raise

    try:
        cursor = conn.cursor()
        yield cursor
        conn.commit()
    except Exception:
        env.log.error("Failed to perform transaction to database")
        conn.rollback()
        raise
    finally:
        cursor.close()
        conn.close()
コード例 #11
0
 def setUp(self):
     self.env = EnvironmentStub()
     self.dbm = DatabaseManager(self.env)
     self.schema = [
         Table('table1', key='col1')[
             Column('col1', auto_increment=True),
             Column('col2'),
             Column('col3'),
         ],
         Table('table2', key='col1')[
             Column('col1'),
             Column('col2'),
         ],
         Table('table3', key='col2')[
             Column('col1'),
             Column('col2', type='int'),
             Column('col3')
         ]
     ]
     self.dbm.create_tables(self.schema)
     self.new_schema = copy.deepcopy([self.schema[0], self.schema[2]])
     self.new_schema[0].remove_columns(('col2',))
     self.new_schema[1].columns.append(Column('col4'))
     self.new_schema.append(
         Table('table4')[
             Column('col1'),
         ]
     )
コード例 #12
0
def do_upgrade(env, ver, cursor):
    """Change `subscription_attribute` db table:

    + 'subscription_attribute.authenticated'
    """
    cursor.execute("""
        CREATE TEMPORARY TABLE subscription_attribute_old
            AS SELECT * FROM subscription_attribute
    """)
    cursor.execute("DROP TABLE subscription_attribute")

    connector = DatabaseManager(env).get_connector()[0]
    for table in schema:
        for stmt in connector.to_sql(table):
            cursor.execute(stmt)
    cursor.execute("""
        INSERT INTO subscription_attribute
               (sid,authenticated,class,realm,target)
        SELECT o.sid,s.authenticated,o.class,o.realm,o.target
          FROM subscription_attribute_old AS o
          LEFT JOIN session AS s
               ON o.sid=s.sid
    """)
    cursor.execute("DROP TABLE subscription_attribute_old")

    # DEVEL: Think that an old 'subscriptions' db table may still exist here.
    cursor.execute("DROP TABLE IF EXISTS subscriptions")
コード例 #13
0
ファイル: db.py プロジェクト: alvabai/trac-multiproject
def trac_db_query(env):
    """
    Context manager to handle database connection and cursor from trac environment's
    read only connection. This does not attempt to roll back or commit, the connection
    is meant only for accessing the data. For examples on use, see db_query().

    Internally, this uses Trac's connection pool via the Trac DatabaseManager class

    :param Environment env: The Trac environment
    """
    conn = None
    cursor = None

    try:
        dm = DatabaseManager(env)
        conn = dm.get_connection()
    except Exception:
        env.log.exception("Failed to get database connection from trac database manager")
        raise

    try:
        # NOTE: Trac's connection does not support alternative cursor types!
        cursor = conn.cursor()
        yield cursor
    except Exception:
        env.log.error("Failed to query database")
        raise
    finally:
        cursor.close()
        conn.close()
コード例 #14
0
ファイル: db3.py プロジェクト: aroth-arsoft/trac-announcer
def do_upgrade(env, ver, cursor):
    """Add two more subscription db tables for a better normalized schema."""

    connector = DatabaseManager(env).get_connector()[0]
    for table in schema:
        for stmt in connector.to_sql(table):
            cursor.execute(stmt)
コード例 #15
0
def do_upgrade(env, ver, cursor):
    """Add two more subscription db tables for a better normalized schema."""

    connector = DatabaseManager(env).get_connector()[0]
    for table in schema:
        for stmt in connector.to_sql(table):
            cursor.execute(stmt)
コード例 #16
0
 def setUp(self):
     self.env = EnvironmentStub()
     self.schema = [
         Table('test_simple', key='id')[Column('id', auto_increment=True),
                                        Column('username'),
                                        Column('email'),
                                        Column('enabled', type='int'),
                                        Column('extra'),
                                        Index(['username'], unique=True),
                                        Index(['email'], unique=False), ],
         Table('test_composite',
               key=['id',
                    'name'])[Column('id', type='int'),
                             Column('name'),
                             Column('value'),
                             Column('enabled', type='int'),
                             Index(['name', 'value'], unique=False),
                             Index(['enabled', 'name'], unique=True), ],
     ]
     self.dbm = DatabaseManager(self.env)
     self.dbm.drop_tables(self.schema)
     self.dbm.create_tables(self.schema)
     self.dbm.insert_into_tables([
         ('test_simple', ('username', 'email', 'enabled'),
          [('joe', '*****@*****.**', 1), (u'joé', '*****@*****.**', 0)]),
         ('test_composite', ('id', 'name', 'value', 'enabled'),
          [(1, 'foo', '42', 1), (1, 'bar', '42', 1), (2, 'foo', '43', 0),
           (2, 'bar', '43', 0)]),
     ])
コード例 #17
0
 def environment_needs_upgrade(self):
     """
     Called when Trac checks whether the environment needs to be upgraded.
     Returns `True` if upgrade is needed, `False` otherwise.
     """
     dbm = DatabaseManager(self.env)
     return dbm.get_database_version(db_version_key) != db_version
コード例 #18
0
ファイル: env.py プロジェクト: hanotch/trac
    def _do_convert_db_in_place(self, dst_dburi):
        dbm = DatabaseManager(self.env)
        src_dburi = dbm.connection_uri
        if src_dburi == dst_dburi:
            printferr("Source database and destination database are same: %s",
                      dst_dburi)
            return 1

        env_path = mkdtemp(prefix='convert_db-',
                           dir=os.path.dirname(self.env.path))
        try:
            dst_env = self._create_env(env_path, dst_dburi)
            src_db = dbm.get_connection()
            dst_db = DatabaseManager(dst_env).get_connection()
            self._copy_tables(dst_env, src_db, dst_db, src_dburi, dst_dburi)
            del src_db
            del dst_db
            dst_env.shutdown()
            dst_env = None
            schema, params = parse_connection_uri(dst_dburi)
            if schema == 'sqlite':
                dbpath = os.path.join(self.env.path, params['path'])
                dbdir = os.path.dirname(dbpath)
                if not os.path.isdir(dbdir):
                    os.makedirs(dbdir)
                shutil.copy(os.path.join(env_path, params['path']), dbpath)
        finally:
            shutil.rmtree(env_path)

        backup_config_file(self.env, '.convert_db-%d' % int(time.time()))
        self.config.set('trac', 'database', dst_dburi)
        self.config.save()
コード例 #19
0
 def upgrade_environment(self, db):
     self.log.debug("Upgrading schema for svnhooks plugin")
     db_backend, _ = DatabaseManager(self.env).get_connector()
     cursor = db.cursor()
     for table in SVNHooksModel.svnhooks_schema:
         for stmt in db_backend.to_sql(table):
             self.log.debug(stmt)
             cursor.execute(stmt)
コード例 #20
0
ファイル: mysql_backend.py プロジェクト: skshel123/trac
 def _max_bytes(self, cnx):
     if cnx is None:
         connector, args = DatabaseManager(self.env).get_connector()
         with closing(connector.get_connection(**args)) as cnx:
             charset = cnx.charset
     else:
         charset = cnx.charset
     return 4 if charset == 'utf8mb4' else 3
コード例 #21
0
ファイル: mysql_backend.py プロジェクト: t2y/trac
 def _utf8_size(self, cnx):
     if cnx is None:
         connector, args = DatabaseManager(self.env).get_connector()
         cnx = connector.get_connection(**args)
         charset = cnx.charset
         cnx.close()
     else:
         charset = cnx.charset
     return 4 if charset == 'utf8mb4' else 3
コード例 #22
0
ファイル: mysql_backend.py プロジェクト: exocad/exotrac
 def _utf8_size(self, cnx):
     if cnx is None:
         connector, args = DatabaseManager(self.env).get_connector()
         cnx = connector.get_connection(**args)
         charset = cnx.charset
         cnx.close()
     else:
         charset = cnx.charset
     return 4 if charset == 'utf8mb4' else 3
コード例 #23
0
def to_sql(env, table):
    """ Convenience function to get the to_sql for the active connector."""
    from trac.db.api import DatabaseManager
    dm = DatabaseManager(env)
    if hasattr(dm, 'get_connector'):  # Trac ~+1.3.2
        dc = dm.get_connector()[0]
    else:
        dc = dm._get_connector()[0]
    return dc.to_sql(table)
コード例 #24
0
 def _create_env(self, path, dburi):
     env = Environment(path, True,
                       [('trac', 'database', dburi),
                        ('trac', 'base_url', 'http://localhost/'),
                        ('project', 'name', u'Pŕójéćŧ Ńáḿé')])
     dbm = DatabaseManager(env)
     dbm.set_database_version(21, 'initial_database_version')
     att = Attachment(env, 'wiki', 'WikiStart')
     att.insert('filename.txt', io.BytesIO('test'), 4)
     env.shutdown()
コード例 #25
0
 def upgrade_environment(self, db=None):
     dbm = DatabaseManager(self.env)
     if dbm.get_database_version(DB_NAME) is False:
         dbm.create_tables(schema)
         dbm.set_database_version(DB_VERSION, DB_NAME)
     else:
         dbm.upgrade(DB_VERSION, DB_NAME, 'coderev.upgrades')
コード例 #26
0
ファイル: test.py プロジェクト: wiraqutra/photrackjp
    def reset_db(self, default_data=None):
        """Remove all data from Trac tables, keeping the tables themselves.
        :param default_data: after clean-up, initialize with default data
        :return: True upon success
        """
        from trac import db_default
        if EnvironmentStub.dbenv:
            db = self.get_db_cnx()
            scheme, db_prop = _parse_db_str(self.dburi)

            tables = []
            db.rollback() # make sure there's no transaction in progress
            try:
                # check the database version
                cursor = db.cursor()
                cursor.execute("SELECT value FROM system "
                               "WHERE name='database_version'")
                database_version = cursor.fetchone()
                if database_version:
                    database_version = int(database_version[0])
                if database_version == db_default.db_version:
                    # same version, simply clear the tables (faster)
                    m = sys.modules[__name__]
                    reset_fn = 'reset_%s_db' % scheme
                    if hasattr(m, reset_fn):
                        tables = getattr(m, reset_fn)(db, db_prop)
                else:
                    # different version or version unknown, drop the tables
                    self.destroy_db(scheme, db_prop)
            except:
                db.rollback()
                # tables are likely missing

            if not tables:
                del db
                dm = DatabaseManager(EnvironmentStub.dbenv)
                dm.init_db()
                # we need to make sure the next get_db_cnx() will re-create 
                # a new connection aware of the new data model - see #8518.
                dm.shutdown() 

        db = self.get_db_cnx()
        cursor = db.cursor()
        if default_data:
            for table, cols, vals in db_default.get_data(db):
                cursor.executemany("INSERT INTO %s (%s) VALUES (%s)"
                                   % (table, ','.join(cols),
                                      ','.join(['%s' for c in cols])),
                                   vals)
        elif EnvironmentStub.dbenv:
            cursor.execute("INSERT INTO system (name, value) "
                           "VALUES (%s, %s)",
                           ('database_version', str(db_default.db_version)))
        db.commit()
コード例 #27
0
ファイル: core.py プロジェクト: folpindo/psuter-cards-plugin
 def environment_created(self):
     db_connector, _ = DatabaseManager(self.env).get_connector()
     with self.env.db_transaction as db:
         cursor = db.cursor()
         for table in SCHEMA:
             for stmt in db_connector.to_sql(table): 
                 cursor.execute(stmt) 
         cursor.execute(""" 
             INSERT INTO system (name, value) 
             VALUES (%s, %s) 
             """, (PLUGIN_NAME, PLUGIN_VERSION)) 
コード例 #28
0
 def upgrade_environment(self):
     dbm = DatabaseManager(self.env)
     if dbm.get_database_version(PLUGIN_NAME) == 0:
         dbm.create_tables(SCHEMA)
         dbm.set_database_version(PLUGIN_VERSION, PLUGIN_NAME)
     else:
         dbm.upgrade(PLUGIN_VERSION, PLUGIN_NAME,
                     'packagerepository.upgrades')
コード例 #29
0
 def environment_created(self):
     db_connector, _ = DatabaseManager(self.env).get_connector()
     with self.env.db_transaction as db:
         cursor = db.cursor()
         for table in SCHEMA:
             for stmt in db_connector.to_sql(table):
                 cursor.execute(stmt)
         cursor.execute(
             """ 
             INSERT INTO system (name, value) 
             VALUES (%s, %s) 
             """, (PLUGIN_NAME, PLUGIN_VERSION))
コード例 #30
0
ファイル: api.py プロジェクト: linhcao1611/Trac-JIRA
 def setUp(self):
     self.env = EnvironmentStub()
     self.schema = [
         Table('HOURS', key='ID')[Column('ID', auto_increment=True),
                                  Column('AUTHOR')],
         Table('blog', key='bid')[Column('bid', auto_increment=True),
                                  Column('author'),
                                  Column('comment')]
     ]
     self.dbm = DatabaseManager(self.env)
     self.dbm.drop_tables(self.schema)
     self.dbm.create_tables(self.schema)
コード例 #31
0
ファイル: db.py プロジェクト: idevat/trac-tags-plugin
    def upgrade_environment(self, db):
        """Each schema version should have its own upgrade module, named
        upgrades/dbN.py, where 'N' is the version number (int).
        """
        db_mgr = DatabaseManager(self.env)
        schema_ver = self.get_schema_version(db)

        cursor = db.cursor()
        # Is this a new installation?
        if not schema_ver:
            # Perform a single-step install: Create plugin schema and
            # insert default data into the database.
            connector = db_mgr._get_connector()[0]
            for table in db_default.schema:
                for stmt in connector.to_sql(table):
                    cursor.execute(stmt)
            for table, cols, vals in db_default.get_data(db):
                cursor.executemany(
                    "INSERT INTO %s (%s) VALUES (%s)" %
                    (table, ','.join(cols), ','.join(['%s' for c in cols])),
                    vals)
        else:
            # Perform incremental upgrades.
            for i in range(schema_ver + 1, db_default.schema_version + 1):
                name = 'db%i' % i
                try:
                    upgrades = __import__('tractags.upgrades', globals(),
                                          locals(), [name])
                    script = getattr(upgrades, name)
                except AttributeError:
                    raise TracError(
                        _(
                            "No upgrade module for version %(num)i "
                            "(%(version)s.py)",
                            num=i,
                            version=name))
                script.do_upgrade(self.env, i, cursor)
        cursor.execute(
            """
            UPDATE system
               SET value=%s
             WHERE name='tags_version'
            """, (db_default.schema_version, ))
        self.log.info("Upgraded TracTags db schema from version %d to %d" %
                      (schema_ver, db_default.schema_version))

        TicketTagProvider(self.env)._fetch_tkt_tags(db)
        self.log.info("Synchronized ticket attributes to tags table")

        db.commit()
コード例 #32
0
def create_table(env):
    '''
    Constructor, see trac/db/postgres_backend.py:95 (method init_db)
    '''
    conn, dummyArgs = DatabaseManager(env).get_connector()
    db = env.get_read_db()
    cursor = db.cursor()

    for stmt in conn.to_sql(XMAIL_TABLE):
        if db.schema:
            stmt = re.sub(r'CREATE TABLE ',
                          'CREATE TABLE "' + db.schema + '".', stmt)
        env.log.info("result of execution: %s" % cursor.execute(stmt))
    db.commit()
    db.close()
コード例 #33
0
 def upgrade_environment(self, db):
     self.log.debug("Upgrading schema for disclaimer plugin")
     db_backend, _ = DatabaseManager(self.env).get_connector()
     cursor = db.cursor()
     for table in DisclaimerModel.disclaimer_schema:
         for stmt in db_backend.to_sql(table):
             self.log.debug(stmt)
             cursor.execute(stmt)
     cursor.execute("select count(*) from disclaimer")
     entries = cursor.fetchone()[0]
     if entries == 0:
         DisclaimerModel(self.env).insert(self.c_name,
                                          self.c_text,
                                          'system',
                                          db=db)
コード例 #34
0
def create_table(env):
    '''
    Constructor, see trac/db/postgres_backend.py:95 (method init_db)
    '''
    conn, dummyArgs = DatabaseManager(env).get_connector()
    db = env.get_read_db()
    cursor = db.cursor()

    for stmt in conn.to_sql(XMAIL_TABLE):
        if db.schema:
            stmt = re.sub(r'CREATE TABLE ','CREATE TABLE "' 
                          + db.schema + '".', stmt) 
        env.log.info( "result of execution: %s" % cursor.execute(stmt) )
    db.commit()
    db.close()
コード例 #35
0
ファイル: env.py プロジェクト: hanotch/trac
    def database_version(self):
        """Returns the current version of the database.

        :since 1.0.2:
        """
        return DatabaseManager(self) \
               .get_database_version('database_version')
コード例 #36
0
ファイル: env.py プロジェクト: hanotch/trac
 def shutdown(self, tid=None):
     """Close the environment."""
     from trac.versioncontrol.api import RepositoryManager
     RepositoryManager(self).shutdown(tid)
     DatabaseManager(self).shutdown(tid)
     if tid is None:
         log.shutdown(self.log)
コード例 #37
0
 def __init__(self, path):
     self.env = Environment(path)
     self.loginNameCache = {}
     self.fieldNameCache = {}
     from trac.db.api import DatabaseManager
     self.using_postgres = \
         DatabaseManager(self.env).connection_uri.startswith("postgres:")
コード例 #38
0
ファイル: env.py プロジェクト: ashwins21/trac
    def upgrade(self, backup=False, backup_dest=None):
        """Upgrade database.

        :param backup: whether or not to backup before upgrading
        :param backup_dest: name of the backup file
        :return: whether the upgrade was performed
        """
        upgraders = []
        for participant in self.setup_participants:
            if participant.environment_needs_upgrade():
                upgraders.append(participant)
        if not upgraders:
            return

        if backup:
            try:
                self.backup(backup_dest)
            except Exception as e:
                raise BackupError(e)

        for participant in upgraders:
            self.log.info("%s.%s upgrading...", participant.__module__,
                          participant.__class__.__name__)
            participant.upgrade_environment()
            # Database schema may have changed, so close all connections
            DatabaseManager(self).shutdown()
        del self.database_version
        return True
コード例 #39
0
ファイル: env.py プロジェクト: t2y/trac
    def get_db_cnx(self):
        """Return a database connection from the connection pool

        :deprecated: Use :meth:`db_transaction` or :meth:`db_query` instead

        `db_transaction` for obtaining the `db` database connection
        which can be used for performing any query
        (SELECT/INSERT/UPDATE/DELETE)::

           with env.db_transaction as db:
               ...

        Note that within the block, you don't need to (and shouldn't)
        call ``commit()`` yourself, the context manager will take care
        of it (if it's the outermost such context manager on the
        stack).


        `db_query` for obtaining a `db` database connection which can
        be used for performing SELECT queries only::

           with env.db_query as db:
               ...
        """
        return DatabaseManager(self).get_connection()
コード例 #40
0
    def backup(self, dest=None):
        """Create a backup of the database.

        :param dest: Destination file; if not specified, the backup is
                     stored in a file called db_name.trac_version.bak
        """
        return DatabaseManager(self).backup(dest)
コード例 #41
0
    def upgrade(self, backup=False, backup_dest=None):
        """Upgrade database.
        
        :param backup: whether or not to backup before upgrading
        :param backup_dest: name of the backup file
        :return: whether the upgrade was performed
        """
        upgraders = []
        with self.db_query as db:
            for participant in self.setup_participants:
                if participant.environment_needs_upgrade(db):
                    upgraders.append(participant)
        if not upgraders:
            return

        if backup:
            self.backup(backup_dest)

        for participant in upgraders:
            self.log.info("%s.%s upgrading...", participant.__module__,
                          participant.__class__.__name__)
            with self.db_transaction as db:
                participant.upgrade_environment(db)
            # Database schema may have changed, so close all connections
            DatabaseManager(self).shutdown()
        return True
コード例 #42
0
ファイル: model.py プロジェクト: aroth-arsoft/trac-crashdump
 def setUp(self):
     self.env = EnvironmentStub(enable=['trac.*', 'crashdump.*'])
     self.env.path = tempfile.mkdtemp()
     self.db_mgr = DatabaseManager(self.env)
     self.env.upgrade()
     #self.db = self.env.get_db_cnx()
     self.crashdump_module = CrashDumpModule(self.env)
コード例 #43
0
ファイル: env.py プロジェクト: spsoft-RockWang/project-_trac
    def get_version(self, initial=False):
        """Return the current version of the database.  If the
        optional argument `initial` is set to `True`, the version of
        the database used at the time of creation will be returned.

        In practice, for database created before 0.11, this will
        return `False` which is "older" than any db version number.

        :since: 0.11

        :since 1.0.2: The lazily-evaluated attributes `database_version` and
                      `database_initial_version` should be used instead. This
                      method will be removed in release 1.3.1.
        """
        dbm = DatabaseManager(self)
        return dbm.get_database_version("{0}database_version".format("initial_" if initial else ""))
コード例 #44
0
ファイル: db4.py プロジェクト: aroth-arsoft/trac-announcer
def do_upgrade(env, ver, cursor):
    """Migrate old `subscriptions` db table.

    Changes to other tables:
    'subscription.priority' type=(default == char) --> 'int'
    'subscription_attribute.name --> 'subscription_attribute.realm'
    'subscription_attribute.value --> 'subscription_attribute.target'
    """
    with env.db_transaction as db:
        cursor = db.cursor()
        cursor.execute("""
            CREATE TEMPORARY TABLE subscription_old
                AS SELECT * FROM subscription
        """)
        cursor.execute("DROP TABLE subscription")
        cursor.execute("""
            CREATE TEMPORARY TABLE subscription_attribute_old
                AS SELECT * FROM subscription_attribute
        """)
        cursor.execute("DROP TABLE subscription_attribute")

        connector = DatabaseManager(env).get_connector()[0]
        for table in schema:
            for stmt in connector.to_sql(table):
                cursor.execute(stmt)
        # Convert priority values to integer.
        cursor.execute("""
            INSERT INTO subscription
                   (time,changetime,class,sid,authenticated,
                    distributor,format,priority,adverb)
            SELECT o.time,o.changetime,o.class,o.sid,o.authenticated,
                   o.distributor,o.format,%s,o.adverb
              FROM subscription_old AS o
            """ % db.cast('o.priority', 'int'))
        cursor.execute("DROP TABLE subscription_old")

        # Copy table on column name change.
        cursor.execute("""
            INSERT INTO subscription_attribute
                   (sid,class,realm,target)
            SELECT o.sid,o.class,o.name,o.value
              FROM subscription_attribute_old AS o
        """)
        cursor.execute("DROP TABLE subscription_attribute_old")

        # DEVEL: Migrate old subscription db table data.
        cursor.execute("DROP TABLE IF EXISTS subscriptions")
コード例 #45
0
ファイル: wikimeta.py プロジェクト: chamer81/tracwikimeta
    def upgrade_environment(self, db):
        dbm = DatabaseManager(self.env)
        pluginName = 'wikimeta_version'
        schema_ver = self.get_schema_version(db=db, pluginName=pluginName)

        if schema_ver == 0:
            dbm.create_tables(PLUGIN_SCHEMA)

            cursor = db.cursor()

            cursor.execute("""
                INSERT into system (name, value)
                   values (%s,%s)
                """, (pluginName, PLUGIN_DB_VERSION))
            self.log.info("initialized wikimeta db schema: %d to %d"
                      % (schema_ver, PLUGIN_DB_VERSION))
            db.commit()
コード例 #46
0
ファイル: db.py プロジェクト: kzhamaji/TracTagsPlugin
    def upgrade_environment(self, db):
        """Each schema version should have its own upgrade module, named
        upgrades/dbN.py, where 'N' is the version number (int).
        """
        db_mgr = DatabaseManager(self.env)
        schema_ver = self.get_schema_version(db)

        cursor = db.cursor()
        # Is this a new installation?
        if not schema_ver:
            # Perform a single-step install: Create plugin schema and
            # insert default data into the database.
            connector = db_mgr._get_connector()[0]
            for table in db_default.schema:
                for stmt in connector.to_sql(table):
                    cursor.execute(stmt)
            for table, cols, vals in db_default.get_data(db):
                cursor.executemany("INSERT INTO %s (%s) VALUES (%s)" % (table,
                                   ','.join(cols),
                                   ','.join(['%s' for c in cols])), vals)
        else:
            # Perform incremental upgrades.
            for i in range(schema_ver + 1, db_default.schema_version + 1):
                name  = 'db%i' % i
                try:
                    upgrades = __import__('tractags.upgrades', globals(),
                                          locals(), [name])
                    script = getattr(upgrades, name)
                except AttributeError:
                    raise TracError(_("No upgrade module for version %(num)i "
                                      "(%(version)s.py)", num=i, version=name))
                script.do_upgrade(self.env, i, cursor)
        cursor.execute("""
            UPDATE system
               SET value=%s
             WHERE name='tags_version'
            """, (db_default.schema_version,))
        self.log.info("Upgraded TracTags db schema from version %d to %d"
                      % (schema_ver, db_default.schema_version))

        TicketTagProvider(self.env)._fetch_tkt_tags(db)
        self.log.info("Synchronized ticket attributes to tags table")

        db.commit()
コード例 #47
0
ファイル: ticketbudgeting.py プロジェクト: lkraav/trachacks
 def create_table(self):
     '''
     Constructor, see trac/postgres_backend.py:95 (method init_db)
     '''
     conn, dummyArgs = DatabaseManager(self.env).get_connector()
     try:
         with self.env.db_transaction as db:
             for stmt in conn.to_sql(BUDGETING_TABLE):
                 if db.schema:
                     stmt = re.sub(r'CREATE TABLE ', 'CREATE TABLE "'
                                   + db.schema + '".', stmt)
                 stmt = re.sub(r'(?i)bigint', 'NUMERIC(10,2)', stmt)
                 stmt += ";"
                 self.log.info("[INIT table] executing sql: %s" % stmt)
                 db(stmt)
                 self.log.info("[INIT table] successfully created table %s"
                                % BUDGETING_TABLE.name)
     except Exception, e:
         self.log.error("[INIT table] Error executing SQL Statement \n %s" % e)
コード例 #48
0
 def upgrade_environment(self):
     """
     Actually perform an environment upgrade, but don't commit as
     that is done by the common upgrade procedure when all plugins are done.
     """
     dbm = DatabaseManager(self.env)
     current_ver = dbm.get_database_version(db_version_key)
     if current_ver == 0:
         dbm.create_tables(schema.values())
     else:
         while current_ver + 1 <= db_version:
             upgrade_map[current_ver + 1](self.env)
             current_ver += 1
     dbm.set_database_version(db_version, db_version_key)
コード例 #49
0
def to_sql(env, table):
    """ Convenience function to get the to_sql for the active connector."""
    dc = DatabaseManager(env)._get_connector()[0]
    return dc.to_sql(table)
コード例 #50
0
def upgrade_from_2_to_3(env):
    # Add the new table
    dbm = DatabaseManager(env)
    dbm.create_tables((schema['code_comments_subscriptions'],))
コード例 #51
0
ファイル: api.py プロジェクト: aroth-arsoft/trac-announcer
 def setUp(self):
     self.env = EnvironmentStub(enable=['trac.*'])
     self.env.path = tempfile.mkdtemp()
     self.db_mgr = DatabaseManager(self.env)
     self.an_sys = AnnouncementSystem(self.env)
コード例 #52
0
ファイル: api.py プロジェクト: aroth-arsoft/trac-announcer
class AnnouncementSystemSetupTestCase(unittest.TestCase):
    def setUp(self):
        self.env = EnvironmentStub(enable=['trac.*'])
        self.env.path = tempfile.mkdtemp()
        self.db_mgr = DatabaseManager(self.env)
        self.an_sys = AnnouncementSystem(self.env)

    def tearDown(self):
        self.env.shutdown()
        shutil.rmtree(self.env.path)

    # Helpers

    def _schema_init(self, schema=None):
        # Current announcer schema is setup with enabled component anyway.
        #   Revert these changes for clean install testing.
        with self.env.db_transaction as db:
            db("DROP TABLE IF EXISTS subscriptions")
            db("DROP TABLE IF EXISTS subscription")
            db("DROP TABLE IF EXISTS subscription_attribute")
            db("DELETE FROM system WHERE name='announcer_version'")

            if schema:
                connector = self.db_mgr.get_connector()[0]
                for table in schema:
                    for stmt in connector.to_sql(table):
                        db(stmt)

    def _verify_curr_schema(self):
        self.assertFalse(self.an_sys.environment_needs_upgrade())
        with self.env.db_query as db:
            cursor = db.cursor()
            cursor.execute("SELECT * FROM subscription_attribute")
            columns = [col[0] for col in cursor.cursor.description]
        self.assertTrue('name' not in columns)
        self.assertTrue('value' not in columns)
        self.assertEquals(
            ['id', 'sid', 'authenticated', 'class', 'realm', 'target'],
            columns
        )
        with self.env.db_query as db:
            cursor = db.cursor()
            cursor.execute("""
                SELECT value
                  FROM system
                 WHERE name='announcer_version'
            """)
            version = int(cursor.fetchone()[0])
        self.assertEquals(db_default.schema_version, version)

    def _verify_version_unregistered(self):
        with self.env.db_query as db:
            cursor = db.cursor()
            cursor.execute("""
                SELECT value
                  FROM system
                 WHERE name='announcer_version'
            """)
            self.assertFalse(cursor.fetchone())

    def test_new_install(self):
        # Just do db table clean-up.
        self._schema_init()

        self.assertEquals(0, self.an_sys.get_schema_version())
        self.assertTrue(self.an_sys.environment_needs_upgrade())

        self.an_sys.upgrade_environment()
        self._verify_curr_schema()

    def test_upgrade_v1_to_current(self):
        # The initial db schema from r3015 - 10-Jan-2008 by Stephen Hansen.
        schema = [
            Table('subscriptions', key='id')[
                Column('id', auto_increment=True),
                Column('sid'),
                Column('enabled', type='int'),
                Column('managed', type='int'),
                Column('realm'),
                Column('category'),
                Column('rule'),
                Column('destination'),
                Column('format'),
                Index(['id']),
                Index(['realm', 'category', 'enabled']),
            ]
        ]
        self._schema_init(schema)

        # Populate tables with test data.
        with self.env.db_transaction as db:
            cursor = db.cursor()
            cursor.executemany("""
                INSERT INTO session
                       (sid,authenticated,last_visit)
                VALUES (%s,%s,%s)
            """, (('somebody', '0', '0'), ('user', '1', '0')))
            cursor.executemany("""
                INSERT INTO session_attribute
                       (sid,authenticated,name,value)
                VALUES (%s,1,%s,%s)
            """, (('user', 'announcer_email_format_ticket', 'text/html'),
                  ('user', 'announcer_specified_email', '')))
            cursor.executemany("""
                INSERT INTO subscriptions
                       (sid,enabled,managed,
                        realm,category,rule,destination,format)
                VALUES (%s,%s,0,%s,%s,%s,%s,%s)
            """, (('somebody', 1, 'ticket', 'changed', '1', '1', 'email'),
                  ('user', 1, 'ticket', 'attachment added', '1', '1', 'email')))

        self.assertEquals(1, self.an_sys.get_schema_version())
        target = 6
        db_default.schema_version = target
        self.assertTrue(self.an_sys.environment_needs_upgrade())

        self.an_sys.upgrade_environment()
        self._verify_curr_schema()

    def test_upgrade_to_schema_v2(self):
        # The initial db schema from r3015 - 10-Jan-2008 by Stephen Hansen.
        schema = [
            Table('subscriptions', key='id')[
                Column('id', auto_increment=True),
                Column('sid'),
                Column('enabled', type='int'),
                Column('managed', type='int'),
                Column('realm'),
                Column('category'),
                Column('rule'),
                Column('destination'),
                Column('format'),
                Index(['id']),
                Index(['realm', 'category', 'enabled']),
            ]
        ]
        self._schema_init(schema)

        # Populate tables with test data.
        with self.env.db_transaction as db:
            cursor = db.cursor()
            cursor.executemany("""
                INSERT INTO session
                       (sid,authenticated,last_visit)
                VALUES (%s,%s,%s)
            """, (('somebody', '0', '0'), ('user', '1', '0')))
            cursor.executemany("""
                INSERT INTO session_attribute
                       (sid,authenticated,name,value)
                VALUES (%s,1,%s,%s)
            """, (('user', 'announcer_email_format_ticket', 'text/html'),
                  ('user', 'announcer_specified_email', '')))
            cursor.executemany("""
                INSERT INTO subscriptions
                       (sid,enabled,managed,
                        realm,category,rule,destination,format)
                VALUES (%s,%s,0,%s,%s,%s,%s,%s)
            """, (('somebody', 1, 'ticket', 'changed', '1', '1', 'email'),
                  ('user', 1, 'ticket', 'attachment added', '1', '1', 'email')))

        self.assertEquals(1, self.an_sys.get_schema_version())
        target = 2
        db_default.schema_version = target
        self.assertTrue(self.an_sys.environment_needs_upgrade())

        # Change from r3047 - 13-Jan-2008 for announcer-0.2 by Stephen Hansen.
        # - 'subscriptions.destination', 'subscriptions.format'
        # + 'subscriptions.authenticated', 'subscriptions.transport'
        # 'subscriptions.managed' type='int' --> (default == char)
        self.an_sys.upgrade_environment()

        self.assertEquals(target, self.an_sys.get_schema_version())
        self._verify_version_unregistered()
        with self.env.db_query as db:
            cursor = db.cursor()
            cursor.execute("SELECT * FROM subscriptions")
            columns = [col[0] for col in cursor.cursor.description]
        self.assertEquals(['id', 'sid', 'authenticated', 'enabled', 'managed',
                           'realm', 'category', 'rule', 'transport'],
                          columns
                          )

    def test_upgrade_to_schema_v3(self):
        # Schema from r3047 - 13-Jan-2008 for announcer-0.2 by Stephen Hansen.
        schema = [
            Table('subscriptions', key='id')[
                Column('id', auto_increment=True),
                Column('sid'),
                Column('authenticated', type='int'),
                Column('enabled', type='int'),
                Column('managed'),
                Column('realm'),
                Column('category'),
                Column('rule'),
                Column('transport'),
                Index(['id']),
                Index(['realm', 'category', 'enabled']),
            ]
        ]
        self._schema_init(schema)

        # Populate tables with test data.
        with self.env.db_transaction as db:
            cursor = db.cursor()
            cursor.executemany("""
                INSERT INTO session_attribute
                       (sid,authenticated,name,value)
                VALUES (%s,1,%s,%s)
            """, (('user', 'announcer_email_format_ticket', 'text/html'),
                  ('user', 'announcer_email_format_wiki', 'text/plain'),
                  ('user', 'announcer_specified_email', '')))
            cursor.executemany("""
                INSERT INTO subscriptions
                       (sid,authenticated,enabled,managed,
                        realm,category,rule,transport)
                VALUES (%s,%s,1,%s,%s,%s,%s,%s)
            """, (('user', 1, 'watcher', 'ticket', 'changed', '1', 'email'),
                  ('user', 1, 'watcher', 'wiki', '*', 'WikiStart', 'email')))

        self.assertEquals(2, self.an_sys.get_schema_version())
        target = 3
        db_default.schema_version = target
        self.assertTrue(self.an_sys.environment_needs_upgrade())

        # From r9116 - 25-Sep-2010 for announcer-0.12.1 by Robert Corsaro.
        # + table 'subscription', 'subscription_attribute'
        self.an_sys.upgrade_environment()

        self.assertEquals(target, self.an_sys.get_schema_version())

    def test_upgrade_to_schema_v4(self):
        # Schema from r9116 - 25-Sep-2010 for announcer-0.12.1 by R. Corsaro.
        schema = [
            Table('subscriptions', key='id')[
                Column('id', auto_increment=True),
                Column('sid'),
                Column('authenticated', type='int'),
                Column('enabled', type='int'),
                Column('managed'),
                Column('realm'),
                Column('category'),
                Column('rule'),
                Column('transport'),
                Index(['id']),
                Index(['realm', 'category', 'enabled']),
            ],
            Table('subscription', key='id')[
                Column('id', auto_increment=True),
                Column('time', type='int64'),
                Column('changetime', type='int64'),
                Column('class'),
                Column('sid'),
                Column('authenticated', type='int'),
                Column('distributor'),
                Column('format'),
                Column('priority'),
                Column('adverb')
            ],
            Table('subscription_attribute', key='id')[
                Column('id', auto_increment=True),
                Column('sid'),
                Column('class'),
                Column('name'),
                Column('value')
            ]
        ]
        self._schema_init(schema)

        # Populate tables with test data.
        with self.env.db_transaction as db:
            cursor = db.cursor()
            cursor.execute("""
                INSERT INTO subscription
                       (time,changetime,class,sid,authenticated,
                        distributor,format,priority,adverb)
                VALUES ('0','0','GeneralWikiSubscriber','user','1',
                        'email','text/plain','1','always')
            """)
            cursor.executemany("""
                INSERT INTO subscription_attribute
                       (sid,class,name,value)
                VALUES (%s,%s,%s,%s)
            """, (('somebody', 'GeneralWikiSubscriber', 'wiki', '*'),
                  ('somebody', 'UserChangeSubscriber', 'wiki', 'created'),
                  ('user', 'GeneralWikiSubscriber', 'wiki', 'TracWiki')))

        self.assertEquals(3, self.an_sys.get_schema_version())
        target = 4
        db_default.schema_version = target
        self.assertTrue(self.an_sys.environment_needs_upgrade())

        # From r9210 - 29-Sep-2010 for announcer-0.12.1 by Robert Corsaro.
        # - table 'subscriptions'
        # 'subscription.priority' type=(default == char) --> 'int'
        # 'subscription_attribute.name --> 'subscription_attribute.realm'
        # 'subscription_attribute.value --> 'subscription_attribute.target'
        self.an_sys.upgrade_environment()

        self.assertEquals(target, self.an_sys.get_schema_version())
        # Check type of priority value.
        with self.env.db_query as db:
            cursor = db.cursor()
            cursor.execute("SELECT priority FROM subscription")
            for priority in cursor:
                # Shouldn't raise an TypeError with appropriate column type.
                result = priority[0] + 0

    def test_upgrade_to_schema_v5(self):
        # Schema from r9210 - 29-Sep-2010 for announcer-0.12.1 by R. Corsaro.
        schema = [
            Table('subscription', key='id')[
                Column('id', auto_increment=True),
                Column('time', type='int64'),
                Column('changetime', type='int64'),
                Column('class'),
                Column('sid'),
                Column('authenticated', type='int'),
                Column('distributor'),
                Column('format'),
                Column('priority', type='int'),
                Column('adverb')
            ],
            Table('subscription_attribute', key='id')[
                Column('id', auto_increment=True),
                Column('sid'),
                Column('class'),
                Column('realm'),
                Column('target')
            ]
        ]
        self._schema_init(schema)

        # Populate tables with test data.
        with self.env.db_transaction as db:
            cursor = db.cursor()
            cursor.executemany("""
                INSERT INTO session
                       (sid,authenticated,last_visit)
                VALUES (%s,%s,%s)
            """, (('somebody', '0', '0'), ('user', '1', '0')))
            cursor.executemany("""
                INSERT INTO subscription_attribute
                       (sid,class,realm,target)
                VALUES (%s,%s,%s,%s)
            """, (('somebody', 'GeneralWikiSubscriber', 'wiki', '*'),
                  ('somebody', 'UserChangeSubscriber', 'wiki', 'created'),
                  ('user', 'GeneralWikiSubscriber', 'wiki', 'TracWiki')))

        self.assertEquals(4, self.an_sys.get_schema_version())
        target = 5
        db_default.schema_version = target
        self.assertTrue(self.an_sys.environment_needs_upgrade())

        # From r9235 - 01-Oct-2010 for announcer-0.12.1 by Robert Corsaro.
        # + 'subscription_attribute.authenticated'
        self.an_sys.upgrade_environment()

        self.assertEquals(target, self.an_sys.get_schema_version())
        self._verify_version_unregistered()
        with self.env.db_query as db:
            cursor = db.cursor()
            cursor.execute("SELECT * FROM subscription_attribute")
            columns = [col[0] for col in cursor.cursor.description]
        self.assertTrue('name' not in columns)
        self.assertTrue('value' not in columns)
        self.assertEquals(
            ['id', 'sid', 'authenticated', 'class', 'realm', 'target'],
            columns
        )
        # Check authenticated attribute for session IDs.
        subscriptions = [(row[1], (row[2])) for row in cursor]
        for sub in subscriptions:
            self.assertTrue((sub[0] == 'user' and sub[1] == 1) or sub[1] == 0)

    def test_upgrade_to_schema_v6(self):
        # Check data migration and registration of unversioned schema.

        # Table definitions are identical to current schema here, see
        # schema from r9235 - 01-Oct-2010 for announcer-0.12.1 by R. Corsaro.
        self._schema_init(db_default.schema)

        # Populate table with test data.
        with self.env.db_transaction as db:
            cursor = db.cursor()
            if self.env.config.get('trac', 'database').startswith('sqlite'):
                # Add dataset with CURRENT_TIMESTAMP strings.
                cursor.execute("""
                    INSERT INTO subscription
                           (time,changetime,
                            class,sid,authenticated,
                            distributor,format,priority,adverb)
                    VALUES ('1970-01-01 00:00:00','2012-10-31 23:59:59',
                            'GeneralWikiSubscriber','user','1',
                            'email','text/plain','1','always')
                """)
            else:
                cursor.execute("""
                    INSERT INTO subscription
                           (time,changetime,
                            class,sid,authenticated,
                            distributor,format,priority,adverb)
                    VALUES ('0','1351724399',
                            'GeneralWikiSubscriber','user','1',
                            'email','text/plain','1','always')
                """)
            cursor.execute("""
                INSERT INTO subscription_attribute
                       (sid,authenticated,class,realm,target)
                VALUES ('user','1','GeneralWikiSubscriber','wiki', 'TracWiki')
            """)
            self.assertEquals(5, self.an_sys.get_schema_version())
            target = 6
            db_default.schema_version = target
            self.assertTrue(self.an_sys.environment_needs_upgrade())

            # Data migration and registration of unversioned schema.
            self.an_sys.upgrade_environment()

            self._verify_curr_schema()
            cursor.execute("SELECT time,changetime FROM subscription")
            for time in cursor:
                # Shouldn't raise an TypeError with proper int/long values.
                check = time[1] - time[0]
コード例 #53
0
ファイル: api.py プロジェクト: pkdevbox/trac
class DatabaseManagerTestCase(unittest.TestCase):

    def setUp(self):
        self.env = EnvironmentStub(default_data=True)
        self.dbm = DatabaseManager(self.env)

    def tearDown(self):
        self.env.reset_db()

    def test_get_default_database_version(self):
        """Get database version for the default entry named
        `database_version`.
        """
        self.assertEqual(default_db_version, self.dbm.get_database_version())

    def test_get_table_names(self):
        """Get table names for the default database."""
        self.assertEqual(sorted(table.name for table in default_schema),
                         sorted(self.dbm.get_table_names()))

    def test_set_default_database_version(self):
        """Set database version for the default entry named
        `database_version`.
        """
        new_db_version = default_db_version + 1
        self.dbm.set_database_version(new_db_version)
        self.assertEqual(new_db_version, self.dbm.get_database_version())

        # Restore the previous version to avoid destroying the database
        # on teardown
        self.dbm.set_database_version(default_db_version)
        self.assertEqual(default_db_version, self.dbm.get_database_version())

    def test_set_get_plugin_database_version(self):
        """Get and set database version for an entry with an
        arbitrary name.
        """
        name = 'a_trac_plugin_version'
        db_ver = 1

        self.assertFalse(self.dbm.get_database_version(name))
        self.dbm.set_database_version(db_ver, name)
        self.assertEqual(db_ver, self.dbm.get_database_version(name))
コード例 #54
0
ファイル: api.py プロジェクト: pkdevbox/trac
 def setUp(self):
     self.env = EnvironmentStub(default_data=True)
     self.dbm = DatabaseManager(self.env)
コード例 #55
0
ファイル: test.py プロジェクト: spsoft-RockWang/project-_trac
class EnvironmentStub(Environment):
    """A stub of the trac.env.Environment class for testing."""

    global_databasemanager = None
    required = False
    abstract = True

    def __init__(self, default_data=False, enable=None, disable=None,
                 path=None, destroying=False):
        """Construct a new Environment stub object.

        :param default_data: If True, populate the database with some
                             defaults.
        :param enable: A list of component classes or name globs to
                       activate in the stub environment.
        :param disable: A list of component classes or name globs to
                        deactivate in the stub environment.
        :param path: The location of the environment in the file system.
                     No files or directories are created when specifying
                     this parameter.
        :param destroying: If True, the database will not be reset. This is
                           useful for cases when the object is being
                           constructed in order to call `destroy_db`.
        """
        if enable is not None and not isinstance(enable, (list, tuple)):
            raise TypeError('Keyword argument "enable" must be a list')
        if disable is not None and not isinstance(disable, (list, tuple)):
            raise TypeError('Keyword argument "disable" must be a list')

        ComponentManager.__init__(self)

        self.systeminfo = []

        import trac
        self.path = path
        if self.path is None:
            self.path = os.path.dirname(trac.__file__)
            if not os.path.isabs(self.path):
                self.path = os.path.join(os.getcwd(), self.path)

        # -- configuration
        self.config = Configuration(None)
        # We have to have a ticket-workflow config for ''lots'' of things to
        # work.  So insert the basic-workflow config here.  There may be a
        # better solution than this.
        load_workflow_config_snippet(self.config, 'basic-workflow.ini')
        self.config.set('logging', 'log_level', 'DEBUG')
        self.config.set('logging', 'log_type', 'stderr')
        if enable is not None:
            self.config.set('components', 'trac.*', 'disabled')
        else:
            self.config.set('components', 'tracopt.versioncontrol.*',
                            'enabled')
        for name_or_class in enable or ():
            config_key = self._component_name(name_or_class)
            self.config.set('components', config_key, 'enabled')
        for name_or_class in disable or ():
            config_key = self._component_name(name_or_class)
            self.config.set('components', config_key, 'disabled')

        # -- logging
        from trac.log import logger_handler_factory
        self.log, self._log_handler = logger_handler_factory('test')

        # -- database
        self.config.set('components', 'trac.db.*', 'enabled')
        self.dburi = get_dburi()

        init_global = False
        if self.global_databasemanager:
            self.components[DatabaseManager] = self.global_databasemanager
        else:
            self.config.set('trac', 'database', self.dburi)
            self.global_databasemanager = DatabaseManager(self)
            self.config.set('trac', 'debug_sql', True)
            init_global = not destroying

        if default_data or init_global:
            self.reset_db(default_data)

        self.config.set('trac', 'base_url', 'http://example.org/trac.cgi')

        translation.activate(locale_en)

    def reset_db(self, default_data=None):
        """Remove all data from Trac tables, keeping the tables themselves.

        :param default_data: after clean-up, initialize with default data
        :return: True upon success
        """
        from trac import db_default
        tables = []
        dbm = self.global_databasemanager
        try:
            with self.db_transaction as db:
                db.rollback()  # make sure there's no transaction in progress
                # check the database version
                db_version = dbm.get_database_version()
        except (TracError, self.env.db_exc.DatabaseError):
            pass
        else:
            if db_version == db_default.db_version:
                # same version, simply clear the tables (faster)
                tables = dbm.reset_tables()
            else:
                # different version or version unknown, drop the tables
                self.destroy_db()

        if not tables:
            dbm.init_db()
            # we need to make sure the next get_db_cnx() will re-create
            # a new connection aware of the new data model - see #8518.
            if self.dburi != 'sqlite::memory:':
                dbm.shutdown()

        if default_data:
            dbm.insert_into_tables(db_default.get_data)
        else:
            dbm.set_database_version(db_default.db_version)

    def destroy_db(self, scheme=None, db_prop=None):
        """Destroy the database.

        :since 1.1.5: the `scheme` and `db_prop` parameters are deprecated and
                      will be removed in 1.3.1.
        """
        try:
            self.global_databasemanager.destroy_db()
        except (TracError, self.db_exc.DatabaseError):
            pass
        return False

    def insert_known_users(self, users):
        with self.env.db_transaction as db:
            for username, name, email in users:
                db("INSERT INTO session VALUES (%s, %s, %s)",
                   (username, 1, int(time.time())))
                db("INSERT INTO session_attribute VALUES (%s,%s,'name',%s)",
                   (username, 1, name))
                db("INSERT INTO session_attribute VALUES (%s,%s,'email',%s)",
                   (username, 1, email))

    # overridden

    def is_component_enabled(self, cls):
        if self._component_name(cls).startswith('__main__.'):
            return True
        return Environment.is_component_enabled(self, cls)
コード例 #56
0
ファイル: main.py プロジェクト: nyuhuhuu/trachacks
 def setUp(self):
     self.env = EnvironmentStub(enable=['trac.*'])
     self.env.path = tempfile.mkdtemp()
     self.db_mgr = DatabaseManager(self.env)
     self.db = self.env.get_db_cnx()
     self.votes = VoteSystem(self.env)
コード例 #57
0
ファイル: main.py プロジェクト: nyuhuhuu/trachacks
class EnvironmentSetupTestCase(unittest.TestCase):

    def setUp(self):
        self.env = EnvironmentStub(enable=['trac.*'])
        self.env.path = tempfile.mkdtemp()
        self.db_mgr = DatabaseManager(self.env)
        self.db = self.env.get_db_cnx()
        self.votes = VoteSystem(self.env)

    def tearDown(self):
        self.db.close()
        # Really close db connections.
        self.env.shutdown()
        shutil.rmtree(self.env.path)

    # Helpers

    def _schema_init(self, schema=None):
        cursor = self.db.cursor()
        cursor.execute("DROP TABLE IF EXISTS votes")
        if schema:
            connector = self.db_mgr._get_connector()[0]
            for table in schema:
                for stmt in connector.to_sql(table):
                    cursor.execute(stmt)

    def _verify_curr_schema(self):
        self.assertFalse(self.votes.environment_needs_upgrade(self.db))
        cursor = self.db.cursor()
        cursor.execute('SELECT * FROM votes')
        cols = get_column_names(cursor)
        self.assertTrue('resource' not in cols)
        self.assertEquals(['realm', 'resource_id', 'version', 'username',
                           'vote', 'time', 'changetime'], cols)
        cursor.execute("""
            SELECT value
              FROM system
             WHERE name='vote_version'
        """)
        schema_ver = int(cursor.fetchone()[0])
        self.assertEquals(self.votes.schema_version, schema_ver)

    def _verify_schema_unregistered(self):
        cursor = self.db.cursor()
        cursor.execute("""
            SELECT value
              FROM system
             WHERE name='vote_version'
        """)
        self.assertFalse(cursor.fetchone())

    # Tests

    def test_new_install(self):
        # Current tracvotes schema is setup with enabled component anyway.
        #   Revert these changes for clean install testing.
        self._schema_init()

        self.assertEquals(0, self.votes.get_schema_version(self.db))
        self.assertTrue(self.votes.environment_needs_upgrade(self.db))

        self.votes.upgrade_environment(self.db)
        self._verify_curr_schema()

    def test_upgrade_v1_to_current(self):
        # The initial db schema from r2963 - 02-Jan-2008 by Alec Thomas.
        schema = [
            Table('votes', key=('resource', 'username', 'vote'))[
                Column('resource'),
                Column('username'),
                Column('vote', 'int'),
                ]
            ]
        self._schema_init(schema)

        # Populate tables with test data.
        cursor = self.db.cursor()
        cursor.executemany("""
            INSERT INTO votes
                   (resource,username,vote)
            VALUES (%s,%s,%s)
        """, (('ticket/1','user',-1), ('ticket/2','user',1),
              ('wiki/DeletedPage','user',-1), ('wiki/ExistingPage','user',1)))
        # Resources must exist for successful data migration.
        t = Ticket(self.env, db=self.db)
        t['summary'] = 'test ticket'
        t.insert()
        w = WikiPage(self.env, 'ExistingPage')
        w.text = 'content'
        w.save('author', 'comment', '::1')
        self._verify_schema_unregistered()
        self.assertEquals(1, self.votes.get_schema_version(self.db))
        self.assertTrue(self.votes.environment_needs_upgrade(self.db))

        # Data migration and registration of unversioned schema.
        self.votes.upgrade_environment(self.db)
        self._verify_curr_schema()

        cursor.execute('SELECT * FROM votes')
        votes = cursor.fetchall()
        t_votes = [id for realm,id,ver,u,v,t,c in votes if realm == 'ticket']
        w_votes = [id for realm,id,ver,u,v,t,c in votes if realm == 'wiki']
        self.assertTrue('1' in t_votes)
        if resource_check:
            self.assertFalse('2' in t_votes)
            self.assertFalse('DeletedPage' in w_votes)
        self.assertTrue('ExistingPage' in w_votes)
コード例 #58
0
ファイル: test.py プロジェクト: exocad/exotrac
class EnvironmentStub(Environment):
    """A stub of the trac.env.Environment object for testing."""

    global_databasemanager = None
    required = False

    def __init__(self, default_data=False, enable=None, disable=None,
                 path=None, destroying=False):
        """Construct a new Environment stub object.

        :param default_data: If True, populate the database with some
                             defaults.
        :param enable: A list of component classes or name globs to
                       activate in the stub environment.
        :param disable: A list of component classes or name globs to
                        deactivate in the stub environment.
        :param path: The location of the environment in the file system.
                     No files or directories are created when specifying
                     this parameter.
        :param destroying: If True, the database will not be reset. This is
                           useful for cases when the object is being
                           constructed in order to call `destroy_db`.
        """
        if enable is not None and not isinstance(enable, (list, tuple)):
            raise TypeError('Keyword argument "enable" must be a list')
        if disable is not None and not isinstance(disable, (list, tuple)):
            raise TypeError('Keyword argument "disable" must be a list')

        ComponentManager.__init__(self)

        self.systeminfo = []

        import trac
        self.path = path
        if self.path is None:
            self.path = os.path.dirname(trac.__file__)
            if not os.path.isabs(self.path):
                self.path = os.path.join(os.getcwd(), self.path)

        # -- configuration
        self.config = Configuration(None)
        # We have to have a ticket-workflow config for ''lots'' of things to
        # work.  So insert the basic-workflow config here.  There may be a
        # better solution than this.
        load_workflow_config_snippet(self.config, 'basic-workflow.ini')
        self.config.set('logging', 'log_level', 'DEBUG')
        self.config.set('logging', 'log_type', 'stderr')
        if enable is not None:
            self.config.set('components', 'trac.*', 'disabled')
        else:
            self.config.set('components', 'tracopt.versioncontrol.*',
                            'enabled')
        for name_or_class in enable or ():
            config_key = self._component_name(name_or_class)
            self.config.set('components', config_key, 'enabled')
        for name_or_class in disable or ():
            config_key = self._component_name(name_or_class)
            self.config.set('components', config_key, 'disabled')

        # -- logging
        from trac.log import logger_handler_factory
        self.log, self._log_handler = logger_handler_factory('test')

        # -- database
        self.config.set('components', 'trac.db.*', 'enabled')
        self.dburi = get_dburi()

        init_global = False
        if self.global_databasemanager:
            self.components[DatabaseManager] = self.global_databasemanager
        else:
            self.config.set('trac', 'database', self.dburi)
            self.global_databasemanager = DatabaseManager(self)
            self.config.set('trac', 'debug_sql', True)
            init_global = not destroying

        if default_data or init_global:
            self.reset_db(default_data)

        self.config.set('trac', 'base_url', 'http://example.org/trac.cgi')

        self.known_users = []
        translation.activate(locale_en)

    def reset_db(self, default_data=None):
        """Remove all data from Trac tables, keeping the tables themselves.
        :param default_data: after clean-up, initialize with default data
        :return: True upon success
        """
        from trac import db_default
        scheme, db_prop = _parse_db_str(self.dburi)
        tables = []
        remove_sqlite_db = False
        try:
            with self.db_transaction as db:
                db.rollback()  # make sure there's no transaction in progress
                # check the database version
                database_version = self.get_version()
        except Exception:
            # "Database not found ...",
            # "OperationalError: no such table: system" or the like
            pass
        else:
            if database_version == db_default.db_version:
                # same version, simply clear the tables (faster)
                m = sys.modules[__name__]
                reset_fn = 'reset_%s_db' % scheme
                if hasattr(m, reset_fn):
                    tables = getattr(m, reset_fn)(self, db_prop)
            else:
                # different version or version unknown, drop the tables
                remove_sqlite_db = True
                self.destroy_db(scheme, db_prop)

        if scheme == 'sqlite' and remove_sqlite_db:
            path = db_prop['path']
            if path != ':memory:':
                if not os.path.isabs(path):
                    path = os.path.join(self.path, path)
                self.global_databasemanager.shutdown()
                os.remove(path)

        if not tables:
            self.global_databasemanager.init_db()
            # we need to make sure the next get_db_cnx() will re-create
            # a new connection aware of the new data model - see #8518.
            if self.dburi != 'sqlite::memory:':
                self.global_databasemanager.shutdown()

        with self.db_transaction as db:
            if default_data:
                for table, cols, vals in db_default.get_data(db):
                    db.executemany("INSERT INTO %s (%s) VALUES (%s)"
                                   % (table, ','.join(cols),
                                      ','.join(['%s'] * len(cols))), vals)
            else:
                db("INSERT INTO system (name, value) VALUES (%s, %s)",
                   ('database_version', str(db_default.db_version)))

    def destroy_db(self, scheme=None, db_prop=None):
        if not (scheme and db_prop):
            scheme, db_prop = _parse_db_str(self.dburi)
        try:
            with self.db_transaction as db:
                if scheme == 'postgres' and db.schema:
                    db('DROP SCHEMA %s CASCADE' % db.quote(db.schema))
                elif scheme == 'mysql':
                    for table in db.get_table_names():
                        db("DROP TABLE IF EXISTS `%s`" % table)
        except Exception:
            # "TracError: Database not found...",
            # psycopg2.ProgrammingError: schema "tractest" does not exist
            pass
        return False

    # overridden

    def is_component_enabled(self, cls):
        if self._component_name(cls).startswith('__main__.'):
            return True
        return Environment.is_component_enabled(self, cls)

    def get_known_users(self, cnx=None):
        return self.known_users
コード例 #59
0
ファイル: test.py プロジェクト: exocad/exotrac
    def __init__(self, default_data=False, enable=None, disable=None,
                 path=None, destroying=False):
        """Construct a new Environment stub object.

        :param default_data: If True, populate the database with some
                             defaults.
        :param enable: A list of component classes or name globs to
                       activate in the stub environment.
        :param disable: A list of component classes or name globs to
                        deactivate in the stub environment.
        :param path: The location of the environment in the file system.
                     No files or directories are created when specifying
                     this parameter.
        :param destroying: If True, the database will not be reset. This is
                           useful for cases when the object is being
                           constructed in order to call `destroy_db`.
        """
        if enable is not None and not isinstance(enable, (list, tuple)):
            raise TypeError('Keyword argument "enable" must be a list')
        if disable is not None and not isinstance(disable, (list, tuple)):
            raise TypeError('Keyword argument "disable" must be a list')

        ComponentManager.__init__(self)

        self.systeminfo = []

        import trac
        self.path = path
        if self.path is None:
            self.path = os.path.dirname(trac.__file__)
            if not os.path.isabs(self.path):
                self.path = os.path.join(os.getcwd(), self.path)

        # -- configuration
        self.config = Configuration(None)
        # We have to have a ticket-workflow config for ''lots'' of things to
        # work.  So insert the basic-workflow config here.  There may be a
        # better solution than this.
        load_workflow_config_snippet(self.config, 'basic-workflow.ini')
        self.config.set('logging', 'log_level', 'DEBUG')
        self.config.set('logging', 'log_type', 'stderr')
        if enable is not None:
            self.config.set('components', 'trac.*', 'disabled')
        else:
            self.config.set('components', 'tracopt.versioncontrol.*',
                            'enabled')
        for name_or_class in enable or ():
            config_key = self._component_name(name_or_class)
            self.config.set('components', config_key, 'enabled')
        for name_or_class in disable or ():
            config_key = self._component_name(name_or_class)
            self.config.set('components', config_key, 'disabled')

        # -- logging
        from trac.log import logger_handler_factory
        self.log, self._log_handler = logger_handler_factory('test')

        # -- database
        self.config.set('components', 'trac.db.*', 'enabled')
        self.dburi = get_dburi()

        init_global = False
        if self.global_databasemanager:
            self.components[DatabaseManager] = self.global_databasemanager
        else:
            self.config.set('trac', 'database', self.dburi)
            self.global_databasemanager = DatabaseManager(self)
            self.config.set('trac', 'debug_sql', True)
            init_global = not destroying

        if default_data or init_global:
            self.reset_db(default_data)

        self.config.set('trac', 'base_url', 'http://example.org/trac.cgi')

        self.known_users = []
        translation.activate(locale_en)