: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)

   .. 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:

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

# 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)