:created_on: Apr 9, 2010

    :author: marcink

    :copyright: (C) 2009-2010 Marcin Kuzminski <marcin@python-works.com>    

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; version 2

# of the License or (at your opinion) any later version of the license.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

VERSION = (1, 1, 0, 'beta')

__version__ = '.'.join((str(each) for each in VERSION[:4]))

from rhodecode.lib.utils import get_current_revision

_rev = get_current_revision()

if len(VERSION) > 3 and _rev:

    __version__ += ' [rev:%s]' % _rev[0]

def get_version():

    """Returns shorter version (digit parts only) as string."""

    return '.'.join((str(each) for each in VERSION[:3]))

BACKENDS = {

    'hg': 'Mercurial repository',

   #'git': 'Git repository',

}

    :created_on: Dec 11, 2010

    :author: marcink

    :copyright: (C) 2009-2010 Marcin Kuzminski <marcin@python-works.com>    

    :license: GPLv3, see COPYING for more details.

"""

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; version 2

# of the License or (at your opinion) any later version of the license.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

import logging

from sqlalchemy import engine_from_config

from rhodecode.lib.dbmigrate.migrate.exceptions import \

    DatabaseNotControlledError

from rhodecode.lib.utils import BasePasterCommand, Command, add_cache

log = logging.getLogger(__name__)

class UpgradeDb(BasePasterCommand):

    """Command used for paster to upgrade our database to newer version

    """

    max_args = 1

    min_args = 1

    usage = "CONFIG_FILE"

    summary = "Upgrades current db to newer version given configuration file"

    group_name = "RhodeCode"

    parser = Command.standard_parser(verbose=True)

    def command(self):

        from pylons import config

        add_cache(config)

        try:

            msg = ('Found current database under version'

                 ' control with version %s' % curr_version)

        except (RuntimeError, DatabaseNotControlledError), e:

            msg = ('Current database is not under version control setting'

                   ' as version %s' % curr_version)

        print msg

    def update_parser(self):

        self.parser.add_option('--sql',

                      action='store_true',

                      dest='just_sql',

                      help="Prints upgrade sql for further investigation",

                      default=False)

    runs it.

    :argument column:

      The name of the column to be altered or a

      :class:`ChangesetColumn` column representing it.

    :param table:

      A :class:`~sqlalchemy.schema.Table` or table name to

      for the table where the column will be changed.

    :param engine:

      The :class:`~sqlalchemy.engine.base.Engine` to use for table

      reflection and schema alterations.

    :param alter_metadata:

      If `True`, which is the default, the

      :class:`~sqlalchemy.schema.Column` will also modified.

      If `False`, the :class:`~sqlalchemy.schema.Column` will be left

      as it was.

    :returns: A :class:`ColumnDelta` instance representing the change.

    """

    k.setdefault('alter_metadata', DEFAULT_ALTER_METADATA)

    if 'table' not in k and isinstance(p[0], sqlalchemy.Column):

        k['table'] = p[0].table

    if 'engine' not in k:

        k['engine'] = k['table'].bind

    # deprecation

    if len(p) >= 2 and isinstance(p[1], sqlalchemy.Column):

        warnings.warn(

            "Passing a Column object to alter_column is deprecated."

            " Just pass in keyword parameters instead.",

            MigrateDeprecationWarning

            )

    engine = k['engine']

    delta = ColumnDelta(*p, **k)

    visitorcallable = get_engine_visitor(engine, 'schemachanger')

    engine._run_visitor(visitorcallable, delta)

    return delta

def _to_table(table, engine=None):

            k = self.compare_2_columns(column, new_col, **k)

        return k

    def process_column(self, column):

        """Processes default values for column"""

        # XXX: this is a snippet from SA processing of positional parameters

        if not SQLA_06 and column.args:

            toinit = list(column.args)

        else:

            toinit = list()

        if column.server_default is not None:

            if isinstance(column.server_default, sqlalchemy.FetchedValue):

                toinit.append(column.server_default)

            else:

                toinit.append(sqlalchemy.DefaultClause(column.server_default))

        if column.server_onupdate is not None:

            if isinstance(column.server_onupdate, FetchedValue):

                toinit.append(column.server_default)

            else:

                toinit.append(sqlalchemy.DefaultClause(column.server_onupdate,

                                            for_update=True))

        if toinit:

            column._init_items(*toinit)

        if not SQLA_06:

            column.args = []

    def _get_table(self):

        return getattr(self, '_table', None)

    def _set_table(self, table):

        if isinstance(table, basestring):

            if self.alter_metadata:

                if not self.meta:

                    raise ValueError("metadata must be specified for table"

                        " reflection when using alter_metadata")

                meta = self.meta

                if self.engine:

                    meta.bind = self.engine

            else:

                if not self.engine and not self.meta:

                    raise ValueError("engine or metadata must be specified"

                        " to reflect tables")

                if not self.engine:

                    self.engine = self.meta.bind

                meta = sqlalchemy.MetaData(bind=self.engine)

            self._table = sqlalchemy.Table(table, meta, autoload=True)

        elif isinstance(table, sqlalchemy.Table):

        :param alter_metadata: If True, column will be removed from table object.

        :type alter_metadata: bool

        :param connection: reuse connection istead of creating new one.

        :type connection: :class:`sqlalchemy.engine.base.Connection` instance

        """

        self.alter_metadata = kwargs.pop('alter_metadata', DEFAULT_ALTER_METADATA)

        if table is not None:

            self.table = table

        engine = self.table.bind

        if self.alter_metadata:

            self.remove_from_table(self.table, unset_table=False)

        visitorcallable = get_engine_visitor(engine, 'columndropper')

        engine._run_visitor(visitorcallable, self, connection, **kwargs)

        if self.alter_metadata:

            self.table = None

        return self

    def add_to_table(self, table):

        if table is not None  and self.table is None:

            self._set_parent(table)

    def _col_name_in_constraint(self, cons, name):

        return False

    def remove_from_table(self, table, unset_table=True):

        # TODO: remove primary keys, constraints, etc

        if unset_table:

            self.table = None

        to_drop = set()

        for index in table.indexes:

            columns = []

            for col in index.columns:

                if col.name != self.name:

                    columns.append(col)

            if columns:

                index.columns = columns

            else:

                to_drop.add(index)

        table.indexes = table.indexes - to_drop

        to_drop = set()

        for cons in table.constraints:

            # TODO: deal with other types of constraint

            if isinstance(cons, (ForeignKeyConstraint,

                                UniqueConstraint)):

                for col_name in cons.columns:

                    if not isinstance(col_name, basestring):

                        col_name = col_name.name

                    if self.name == col_name:

                        to_drop.add(cons)

        table.constraints = table.constraints - to_drop

        if table.c.contains_column(self):

            table.c.remove(self)

    # TODO: this is fixed in 0.6

    def copy_fixed(self, **kw):

        """Create a copy of this ``Column``, with all attributes."""

        return sqlalchemy.Column(self.name, self.type, self.default,

            key=self.key,

            primary_key=self.primary_key,

            nullable=self.nullable,

            quote=self.quote,

            index=self.index,

            unique=self.unique,

            onupdate=self.onupdate,

            autoincrement=self.autoincrement,

            server_default=self.server_default,

            server_onupdate=self.server_onupdate,

            *[c.copy(**kw) for c in self.constraints])

    def _check_sanity_constraints(self, name):

        """Check if constraints names are correct"""

        obj = getattr(self, name)

        if (getattr(self, name[:-5]) and not obj):

            raise InvalidConstraintError("Column.create() accepts index_name,"

   .. versionchanged:: 0.5.4

    ``--preview_sql`` displays source file when using SQL scripts.

    If Python script is used, it runs the action with mocked engine and

    returns captured SQL statements.

   .. versionchanged:: 0.5.4

    Deprecated ``--echo`` parameter in favour of new

    :func:`migrate.versioning.util.construct_engine` behavior.

"""

# Dear migrate developers,

#

# please do not comment this module using sphinx syntax because its

# docstrings are presented as user help and most users cannot

# interpret sphinx annotated ReStructuredText.

#

# Thanks,

# Jan Dittberner

import sys

import inspect

import logging

from rhodecode.lib.dbmigrate.migrate import exceptions

from rhodecode.lib.dbmigrate.migrate.versioning.util import catch_known_errors, with_engine

log = logging.getLogger(__name__)

command_desc = {

    'help': 'displays help on a given command',

    'create': 'create an empty repository at the specified path',

    'script': 'create an empty change Python script',

    'script_sql': 'create empty change SQL scripts for given database',

    'version': 'display the latest version available in a repository',

    'db_version': 'show the current version of the repository under version control',

    'source': 'display the Python code for a particular version in this repository',

    'version_control': 'mark a database as under this repository\'s version control',

    'upgrade': 'upgrade a database to a later version',

    'downgrade': 'downgrade a database to an earlier version',

    'drop_version_control': 'removes version control from a database',

    'manage': 'creates a Python script that runs Migrate with a set of default values',

    'test': 'performs the upgrade and downgrade command on the given database',

    'compare_model_to_db': 'compare MetaData against the current database state',

    'create_model': 'dump the current database as a Python model to stdout',

    'make_update_script_for_model': 'create a script changing the old MetaData to the new (current) MetaData',

    'update_db_from_model': 'modify the database to match the structure of the current MetaData',

}

__all__ = command_desc.keys()

#!/usr/bin/env python

# -*- coding: utf-8 -*-

import logging

import shutil

from rhodecode.lib.dbmigrate.migrate.versioning.script import base

from rhodecode.lib.dbmigrate.migrate.versioning.template import Template

log = logging.getLogger(__name__)

class SqlScript(base.BaseScript):

    """A file containing plain SQL statements."""

    @classmethod

    def create(cls, path, **opts):

        """Create an empty migration script at specified path

        :returns: :class:`SqlScript instance <migrate.versioning.script.sql.SqlScript>`"""

        cls.require_notfound(path)

        src = Template(opts.pop('templates_path', None)).get_sql_script(theme=opts.pop('templates_theme', None))

        shutil.copy(src, path)

        return cls(path)

    # TODO: why is step parameter even here?

    def run(self, engine, step=None, executemany=True):

        """Runs SQL script through raw dbapi execute call"""

        text = self.source()

        # Don't rely on SA's autocommit here

        # (SA uses .startswith to check if a commit is needed. What if script

        # starts with a comment?)

        conn = engine.connect()

        try:

            trans = conn.begin()

            try:

                # HACK: SQLite doesn't allow multiple statements through

                # its execute() method, but it provides executescript() instead

                dbapi = conn.engine.raw_connection()

                if executemany and getattr(dbapi, 'executescript', None):

                    dbapi.executescript(text)

                else:

                    conn.execute(text)

                trans.commit()

            except:

    _mask = None

    def get_path(self, file):

        return os.path.join(self.path, str(file))

class RepositoryCollection(Collection):

    _mask = '%s'

class ScriptCollection(Collection):

    _mask = '%s.py_tmpl'

class ManageCollection(Collection):

    _mask = '%s.py_tmpl'

class SQLScriptCollection(Collection):

    _mask = '%s.py_tmpl'

class Template(pathed.Pathed):

    """Finds the paths/packages of various Migrate templates.

    :param path: Templates are loaded from rhodecode.lib.dbmigrate.migrate package

    if `path` is not provided.

    """

    _manage = 'manage.py_tmpl'

    def __new__(cls, path=None):

        if path is None:

            path = cls._find_path(cls.pkg)

        return super(Template, cls).__new__(cls, path)

    def __init__(self, path=None):

        if path is None:

            path = Template._find_path(self.pkg)

        super(Template, self).__init__(path)

        self.repository = RepositoryCollection(os.path.join(path, 'repository'))

        self.script = ScriptCollection(os.path.join(path, 'script'))

        self.manage = ManageCollection(os.path.join(path, 'manage'))

        self.sql_script = SQLScriptCollection(os.path.join(path, 'sql_script'))

    @classmethod

    def _find_path(cls, pkg):

        """Returns absolute path to dotted python package."""

        tmp_pkg = pkg.rsplit('.', 1)

        if len(tmp_pkg) != 1:

            return resource_filename(tmp_pkg[0], tmp_pkg[1])

        else:

            return resource_filename(tmp_pkg[0], '')

    def _get_item(self, collection, theme=None):

        """Locates and returns collection.

        :param collection: name of collection to locate

        :param type_: type of subfolder in collection (defaults to "_default")

        :returns: (package, source)

        :rtype: str, str

        """

        item = getattr(self, collection)

        theme_mask = getattr(item, '_mask')

        theme = theme_mask % (theme or 'default')

        return item.get_path(theme)

    def get_repository(self, *a, **kw):

        """Calls self._get_item('repository', *a, **kw)"""

        return self._get_item('repository', *a, **kw)

    def get_script(self, *a, **kw):

        """Calls self._get_item('script', *a, **kw)"""

        return self._get_item('script', *a, **kw)

    def get_sql_script(self, *a, **kw):

        """Calls self._get_item('sql_script', *a, **kw)"""

        return self._get_item('sql_script', *a, **kw)

    def get_manage(self, *a, **kw):

        """Calls self._get_item('manage', *a, **kw)"""

        return self._get_item('manage', *a, **kw)

#==============================================================================

# DB INITIAL MODEL

#==============================================================================

import logging

import datetime

from sqlalchemy import *

from sqlalchemy.exc import DatabaseError

from sqlalchemy.orm import relation, backref, class_mapper

from sqlalchemy.orm.session import Session

log = logging.getLogger(__name__)

class BaseModel(object):

    @classmethod

    def _get_keys(cls):

        """return column names for this model """

        return class_mapper(cls).c.keys()

    def get_dict(self):

        """return dict with keys and values corresponding 

        to this model data """

        d = {}

        for k in self._get_keys():

            d[k] = getattr(self, k)

        return d

    def get_appstruct(self):

        """return list with keys and values tupples corresponding 

        to this model data """

        l = []

def upgrade(migrate_engine):

    """ Upgrade operations go here. 

    Don't create your own engine; bind migrate_engine to your metadata

    """

    #==========================================================================

    # Upgrade of `users` table

    #==========================================================================

    tblname = 'users'

    tbl = Table(tblname, MetaData(bind=migrate_engine), autoload=True,

                    autoload_with=migrate_engine)

    #ADD is_ldap column

                     unique=None, default=False)

    #==========================================================================

    # Upgrade of `user_logs` table

    #==========================================================================    

    tblname = 'users'

    tbl = Table(tblname, MetaData(bind=migrate_engine), autoload=True,

                    autoload_with=migrate_engine)

    #ADD revision column

    revision = Column('revision', TEXT(length=None, convert_unicode=False,

                                       assert_unicode=None),

                      nullable=True, unique=None, default=None)

    revision.create(tbl)

    #==========================================================================

    # Upgrade of `repositories` table

    #==========================================================================    

    tblname = 'users'

    tbl = Table(tblname, MetaData(bind=migrate_engine), autoload=True,

                    autoload_with=migrate_engine)

    #ADD repo_type column

    repo_type = Column("repo_type", String(length=None, convert_unicode=False,

                                           assert_unicode=None),

    #ADD statistics column

    enable_statistics = Column("statistics", Boolean(), nullable=True,

                               unique=None, default=True)

    enable_statistics.create(tbl)

    #==========================================================================

    # Add table `user_followings`

    #==========================================================================

    tblname = 'user_followings'

    class UserFollowing(Base, BaseModel):

        __tablename__ = 'user_followings'

        __table_args__ = (UniqueConstraint('user_id', 'follows_repository_id'),

                          UniqueConstraint('user_id', 'follows_user_id')

                          , {'useexisting':True})

        user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

        user_id = Column("user_id", Integer(), ForeignKey(u'users.user_id'), nullable=False, unique=None, default=None)

        follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey(u'repositories.repo_id'), nullable=True, unique=None, default=None)

        follows_user_id = Column("follows_user_id", Integer(), ForeignKey(u'users.user_id'), nullable=True, unique=None, default=None)

        user = relation('User', primaryjoin='User.user_id==UserFollowing.user_id')

        follows_user = relation('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')

        follows_repository = relation('Repository')

    Base.metadata.tables[tblname].create(migrate_engine)

    #==========================================================================

    # Add table `cache_invalidation`

    #==========================================================================

    class CacheInvalidation(Base, BaseModel):

        __tablename__ = 'cache_invalidation'

        __table_args__ = (UniqueConstraint('cache_key'), {'useexisting':True})

        cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

        cache_key = Column("cache_key", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

        cache_args = Column("cache_args", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

        cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)

        def __init__(self, cache_key, cache_args=''):

            self.cache_key = cache_key

            self.cache_args = cache_args

            self.cache_active = False

        def __repr__(self):

            return "<CacheInvalidation('%s:%s')>" % (self.cache_id, self.cache_key)

    Base.metadata.tables[tblname].create(migrate_engine)

    return

            log.debug('updated user %s lastlogin', self.username)

        except (DatabaseError,):

            session.rollback()

class UserLog(Base, BaseModel):

    __tablename__ = 'user_logs'

    __table_args__ = {'useexisting':True}

    user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    user_id = Column("user_id", Integer(), ForeignKey(u'users.user_id'), nullable=False, unique=None, default=None)

    repository_id = Column("repository_id", Integer(length=None, convert_unicode=False, assert_unicode=None), ForeignKey(u'repositories.repo_id'), nullable=False, unique=None, default=None)

    repository_name = Column("repository_name", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    user_ip = Column("user_ip", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    action = Column("action", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)

    user = relation('User')

    repository = relation('Repository')

class Repository(Base, BaseModel):

    __tablename__ = 'repositories'

    __table_args__ = (UniqueConstraint('repo_name'), {'useexisting':True},)

    repo_id = Column("repo_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    repo_name = Column("repo_name", String(length=None, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)

    user_id = Column("user_id", Integer(), ForeignKey(u'users.user_id'), nullable=False, unique=False, default=None)

    private = Column("private", Boolean(), nullable=True, unique=None, default=None)

    enable_statistics = Column("statistics", Boolean(), nullable=True, unique=None, default=True)

    description = Column("description", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    fork_id = Column("fork_id", Integer(), ForeignKey(u'repositories.repo_id'), nullable=True, unique=False, default=None)

    user = relation('User')

    fork = relation('Repository', remote_side=repo_id)

    repo_to_perm = relation('RepoToPerm', cascade='all')

    stats = relation('Statistics', cascade='all', uselist=False)

    repo_followers = relation('UserFollowing', primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', cascade='all')

    def __repr__(self):

        return "<Repository('%s:%s')>" % (self.repo_id, self.repo_name)

class Permission(Base, BaseModel):

    __tablename__ = 'permissions'

    __table_args__ = {'useexisting':True}

    permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    permission_name = Column("permission_name", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    permission_longname = Column("permission_longname", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)