versioning implementation: http://semver.org/

    :created_on: Apr 9, 2010

    :author: marcink

    :copyright: (C) 2010-2012 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, either version 3 of the License, or

# (at your option) any later version.

#

# 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, see <http://www.gnu.org/licenses/>.

import sys

import platform

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

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

__platform__ = platform.system()

__license__ = 'GPLv3'

__py_version__ = sys.version_info

PLATFORM_WIN = ('Windows')

PLATFORM_OTHERS = ('Linux', 'Darwin', 'FreeBSD', 'OpenBSD', 'SunOS')

requirements = [

    "Pylons==1.0.0",

    "Beaker==1.6.2",

    "WebHelpers>=1.2",

    "formencode==1.2.4",

    "SQLAlchemy==0.7.4",

    "Mako==0.5.0",

    "pygments>=1.4",

    "whoosh>=2.3.0,<2.4",

    "celery>=2.2.5,<2.3",

    "babel",

    "python-dateutil>=1.5.0,<2.0.0",

    "dulwich>=0.8.0,<0.9.0",

    "vcs>=0.2.3.dev",

    "webob==1.0.8",

    "markdown==2.0.3",

    "docutils==0.8.1",

                  'bind_dn': ldap_settings.get('ldap_dn_user'),

                  'bind_pass': ldap_settings.get('ldap_dn_pass'),

                  'tls_kind': ldap_settings.get('ldap_tls_kind'),

                  'tls_reqcert': ldap_settings.get('ldap_tls_reqcert'),

                  'ldap_filter': ldap_settings.get('ldap_filter'),

                  'search_scope': ldap_settings.get('ldap_search_scope'),

                  'attr_login': ldap_settings.get('ldap_attr_login'),

                  'ldap_version': 3,

                  }

            log.debug('Checking for ldap authentication')

            try:

                aldap = AuthLdap(**kwargs)

                (user_dn, ldap_attrs) = aldap.authenticate_ldap(username,

                                                                password)

                log.debug('Got ldap DN response %s' % user_dn)

                get_ldap_attr = lambda k: ldap_attrs.get(ldap_settings\

                                                           .get(k), [''])[0]

                user_attrs = {

                 'name': safe_unicode(get_ldap_attr('ldap_attr_firstname')),

                 'lastname': safe_unicode(get_ldap_attr('ldap_attr_lastname')),

                 'email': get_ldap_attr('ldap_attr_email'),

                }

                # with some random generated password

                _password = PasswordGenerator().gen_password(length=8)

                # create this user on the fly if it doesn't exist in rhodecode

                # database

                if user_model.create_ldap(username, _password, user_dn,

                                          user_attrs):

                    log.info('created new ldap user %s' % username)

                Session.commit()

                return True

            except (LdapUsernameError, LdapPasswordError,):

                pass

            except (Exception,):

                log.error(traceback.format_exc())

                pass

    return False

def login_container_auth(username):

    user = User.get_by_username(username)

    if user is None:

        user_attrs = {

            'name': username,

            'lastname': None,

                                % __dbversion__)

                api.upgrade(db_uri, repository_path, __dbversion__)

                print ('Schema upgrade completed')

            def step_1(self):

                pass

            def step_2(self):

                print ('Patching repo paths for newer version of RhodeCode')

                self.klass.fix_repo_paths()

                print ('Patching default user of RhodeCode')

                self.klass.fix_default_user()

                log.info('Changing ui settings')

                self.klass.create_ui_settings()

            def step_3(self):

                print ('Adding additional settings into RhodeCode db')

                self.klass.fix_settings()

                print ('Adding ldap defaults')

                self.klass.create_ldap_options(skip_existing=True)

            def step_4(self):

                self.klass.create_permissions()

                self.klass.fixup_groups()

        upgrade_steps = [0] + range(curr_version + 1, __dbversion__ + 1)

        # CALL THE PROPER ORDER OF STEPS TO PERFORM FULL UPGRADE

        for step in upgrade_steps:

            print ('performing upgrade step %s' % step)

            getattr(UpgradeSteps(self), 'step_%s' % step)()

            self.sa.commit()

    def fix_repo_paths(self):

        """

        Fixes a old rhodecode version path into new one without a '*'

        """

        paths = self.sa.query(RhodeCodeUi)\

                .filter(RhodeCodeUi.ui_key == '/')\

                .scalar()

        paths.ui_value = paths.ui_value.replace('*', '')

        try:

            self.sa.add(paths)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise

    def fix_default_user(self):

        """

        Fixes a old default user with some 'nicer' default values,

        used mostly for anonymous access

        """

        def_user = self.sa.query(User)\

"""

   Extensions to SQLAlchemy for altering existing tables.

   At the moment, this isn't so much based off of ANSI as much as

   things that just happen to work with multiple databases.

"""

import StringIO

import sqlalchemy as sa

from sqlalchemy.schema import SchemaVisitor

from sqlalchemy.engine.default import DefaultDialect

from sqlalchemy.sql import ClauseElement

from sqlalchemy.schema import (ForeignKeyConstraint,

                               PrimaryKeyConstraint,

                               CheckConstraint,

                               UniqueConstraint,

                               Index)

from rhodecode.lib.dbmigrate.migrate import exceptions

class AlterTableVisitor(SchemaVisitor):

    """Common operations for ``ALTER TABLE`` statements."""

    def append(self, s):

        """Append content to the SchemaIterator's query buffer."""

        self.buffer.write(s)

    def execute(self):

        """Execute the contents of the SchemaIterator's buffer."""

        try:

            return self.connection.execute(self.buffer.getvalue())

        finally:

            self.buffer.truncate(0)

    def __init__(self, dialect, connection, **kw):

        self.connection = connection

        self.buffer = StringIO.StringIO()

        self.preparer = dialect.identifier_preparer

        self.dialect = dialect

    def traverse_single(self, elem):

        ret = super(AlterTableVisitor, self).traverse_single(elem)

        if ret:

            # adapt to 0.6 which uses a string-returning

            # object

        for cons in column.constraints:

            self.traverse_single(cons)

        self.execute()

        # ALTER TABLE STATEMENTS

        # add indexes and unique constraints

        if column.index_name:

            Index(column.index_name,column).create()

        elif column.unique_name:

            constraint.UniqueConstraint(column,

                                        name=column.unique_name).create()

        # SA bounds FK constraints to table, add manually

        for fk in column.foreign_keys:

            self.add_foreignkey(fk.constraint)

        # add primary key constraint if needed

        if column.primary_key_name:

            cons = constraint.PrimaryKeyConstraint(column,

                                                   name=column.primary_key_name)

            cons.create()

class ANSIColumnDropper(AlterTableVisitor, SchemaDropper):

    """Extends ANSI SQL dropper for column dropping (``ALTER TABLE

    DROP COLUMN``).

    """

    def visit_column(self, column):

        """Drop a column from its table.

        :param column: the column object

        :type column: :class:`sqlalchemy.Column`

        """

        table = self.start_alter_table(column)

        self.append('DROP COLUMN %s' % self.preparer.format_column(column))

        self.execute()

class ANSISchemaChanger(AlterTableVisitor, SchemaGenerator):

    """Manages changes to existing schema elements.

    Note that columns are schema elements; ``ALTER TABLE ADD COLUMN``

    is in SchemaGenerator.

    All items may be renamed. Columns can also have many of their properties -

        ret = func(table, delta.result_column, delta)

        self.execute()

    def start_alter_column(self, table, col_name):

        """Starts ALTER COLUMN"""

        self.start_alter_table(table)

        self.append("ALTER COLUMN %s " % self.preparer.quote(col_name, table.quote))

    def _visit_column_nullable(self, table, column, delta):

        nullable = delta['nullable']

        if nullable:

            self.append("DROP NOT NULL")

        else:

            self.append("SET NOT NULL")

    def _visit_column_default(self, table, column, delta):

        default_text = self.get_column_default_string(column)

        if default_text is not None:

            self.append("SET DEFAULT %s" % default_text)

        else:

            self.append("DROP DEFAULT")

    def _visit_column_type(self, table, column, delta):

        type_ = delta['type']

        self.append("TYPE %s" % type_text)

    def _visit_column_name(self, table, column, delta):

        self.start_alter_table(table)

        col_name = self.preparer.quote(delta.current_name, table.quote)

        new_name = self.preparer.format_column(delta.result_column)

        self.append('RENAME COLUMN %s TO %s' % (col_name, new_name))

class ANSIConstraintCommon(AlterTableVisitor):

    """

    Migrate's constraints require a separate creation function from

    SA's: Migrate's constraints are created independently of a table;

    SA's are created at the same time as the table.

    """

    def get_constraint_name(self, cons):

        """Gets a name for the given constraint.

        If the name is already set it will be used otherwise the

        constraint's :meth:`autoname <migrate.changeset.constraint.ConstraintChangeset.autoname>`

        method is used.

        :param cons: constraint object

        """

        if cons.name is not None:

            ret = cons.name

        else:

            ret = cons.name = cons.autoname()

        return self.preparer.quote(ret, cons.quote)

    def visit_migrate_primary_key_constraint(self, *p, **k):

        self._visit_constraint(*p, **k)

    def visit_migrate_foreign_key_constraint(self, *p, **k):

        self._visit_constraint(*p, **k)

    def visit_migrate_check_constraint(self, *p, **k):

        self._visit_constraint(*p, **k)

    def visit_migrate_unique_constraint(self, *p, **k):

        self._visit_constraint(*p, **k)

class ANSIDialect(DefaultDialect):

    columngenerator = ANSIColumnGenerator

    columndropper = ANSIColumnDropper

    schemachanger = ANSISchemaChanger

    constraintgenerator = ANSIConstraintGenerator

    constraintdropper = ANSIConstraintDropper

"""

   This module defines standalone schema constraint classes.

"""

from sqlalchemy import schema

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

class ConstraintChangeset(object):

    """Base class for Constraint classes."""

    def _normalize_columns(self, cols, table_name=False):

        """Given: column objects or names; return col names and

        (maybe) a table"""

        colnames = []

        table = None

        for col in cols:

            if isinstance(col, schema.Column):

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

                    table = col.table

                if table_name:

                    col = '.'.join((col.table.name, col.name))

                else:

                    col = col.name

            colnames.append(col)

        return colnames, table

    def __do_imports(self, visitor_name, *a, **kw):

        engine = kw.pop('engine', self.table.bind)

        from rhodecode.lib.dbmigrate.migrate.changeset.databases.visitor import (get_engine_visitor,

                                                                                 run_single_visitor)

        #self.columns.clear()

        return self

class PrimaryKeyConstraint(ConstraintChangeset, schema.PrimaryKeyConstraint):

    """Construct PrimaryKeyConstraint

    Migrate's additional parameters:

    :param cols: Columns in constraint.

    :param table: If columns are passed as strings, this kw is required

    :type table: Table instance

    :type cols: strings or Column instances

    """

    __migrate_visit_name__ = 'migrate_primary_key_constraint'

    def __init__(self, *cols, **kwargs):

        colnames, table = self._normalize_columns(cols)

        table = kwargs.pop('table', table)

        super(PrimaryKeyConstraint, self).__init__(*colnames, **kwargs)

        if table is not None:

            self._set_parent(table)

    def autoname(self):

        """Mimic the database's automatic constraint names"""

        return "%s_pkey" % self.table.name

class ForeignKeyConstraint(ConstraintChangeset, schema.ForeignKeyConstraint):

    """Construct ForeignKeyConstraint

    Migrate's additional parameters:

    :param columns: Columns in constraint

    :param refcolumns: Columns that this FK reffers to in another table.

    :param table: If columns are passed as strings, this kw is required

    :type table: Table instance

    :type columns: list of strings or Column instances

    :type refcolumns: list of strings or Column instances

    """

    __migrate_visit_name__ = 'migrate_foreign_key_constraint'

    def __init__(self, columns, refcolumns, *args, **kwargs):

        colnames, table = self._normalize_columns(columns)

        table = kwargs.pop('table', table)

        refcolnames, reftable = self._normalize_columns(refcolumns,

                                                        table_name=True)

        if table is not None:

            self._set_parent(table)

    @property

    def referenced(self):

        return [e.column for e in self.elements]

    @property

    def reftable(self):

        return self.referenced[0].table

    def autoname(self):

        """Mimic the database's automatic constraint names"""

        if hasattr(self.columns, 'keys'):

            # SA <= 0.5

            firstcol = self.columns[self.columns.keys()[0]]

            ret = "%(table)s_%(firstcolumn)s_fkey" % dict(

                table=firstcol.table.name,

                firstcolumn=firstcol.name,)

        else:

            # SA >= 0.6

            ret = "%(table)s_%(firstcolumn)s_fkey" % dict(

                table=self.table.name,

                firstcolumn=self.columns[0],)

    """Construct CheckConstraint

    Migrate's additional parameters:

    :param sqltext: Plain SQL text to check condition

    :param columns: If not name is applied, you must supply this kw\

    to autoname constraint

    :param table: If columns are passed as strings, this kw is required

    :type table: Table instance

    :type columns: list of Columns instances

    :type sqltext: string

    """

    __migrate_visit_name__ = 'migrate_check_constraint'

    def __init__(self, sqltext, *args, **kwargs):

        cols = kwargs.pop('columns', [])

        if not cols and not kwargs.get('name', False):

            raise InvalidConstraintError('You must either set "name"'

                'parameter or "columns" to autogenarate it.')

        colnames, table = self._normalize_columns(cols)

        table = kwargs.pop('table', table)

        schema.CheckConstraint.__init__(self, sqltext, *args, **kwargs)

        if table is not None:

            self._set_parent(table)

        self.colnames = colnames

    def autoname(self):

        return "%(table)s_%(cols)s_check" % \

            dict(table=self.table.name, cols="_".join(self.colnames))

class UniqueConstraint(ConstraintChangeset, schema.UniqueConstraint):

    """Construct UniqueConstraint

    Migrate's additional parameters:

    :param cols: Columns in constraint.

    :param table: If columns are passed as strings, this kw is required

    :type table: Table instance

    :type cols: strings or Column instances

    .. versionadded:: 0.6.0

    """

    __migrate_visit_name__ = 'migrate_unique_constraint'

    def __init__(self, *cols, **kwargs):

        self.colnames, table = self._normalize_columns(cols)

        table = kwargs.pop('table', table)

        super(UniqueConstraint, self).__init__(*self.colnames, **kwargs)

        if table is not None:

            self._set_parent(table)

    def autoname(self):

        """Mimic the database's automatic constraint names"""

"""

   Firebird database specific implementations of changeset classes.

"""

from sqlalchemy.databases import firebird as sa_base

from sqlalchemy.schema import PrimaryKeyConstraint

from rhodecode.lib.dbmigrate.migrate import exceptions

class FBColumnGenerator(FBSchemaGenerator, ansisql.ANSIColumnGenerator):

    """Firebird column generator implementation."""

class FBColumnDropper(ansisql.ANSIColumnDropper):

    """Firebird column dropper implementation."""

    def visit_column(self, column):

        """Firebird supports 'DROP col' instead of 'DROP COLUMN col' syntax

        Drop primary key and unique constraints if dropped column is referencing it."""

        if column.primary_key:

            if column.table.primary_key.columns.contains_column(column):

                column.table.primary_key.drop()

                # TODO: recreate primary key if it references more than this column

        for index in column.table.indexes:

            # "column in index.columns" causes problems as all

            # column objects compare equal and return a SQL expression

            if column.name in [col.name for col in index.columns]:

                index.drop()

                # TODO: recreate index if it references more than this column

        for cons in column.table.constraints:

            if isinstance(cons,PrimaryKeyConstraint):

                # will be deleted only when the column its on

                # is deleted!

                continue

            if should_drop:

                self.start_alter_table(column)

                self.append("DROP CONSTRAINT ")

                self.append(self.preparer.format_constraint(cons))

                self.execute()

            # TODO: recreate unique constraint if it refenrences more than this column

        self.start_alter_table(column)

        self.append('DROP %s' % self.preparer.format_column(column))

        self.execute()

class FBSchemaChanger(ansisql.ANSISchemaChanger):

    """Firebird schema changer implementation."""

    def visit_table(self, table):

        """Rename table not supported"""

        raise exceptions.NotSupportedError(

            "Firebird does not support renaming tables.")

    def _visit_column_name(self, table, column, delta):

        self.start_alter_table(table)

        col_name = self.preparer.quote(delta.current_name, table.quote)

        new_name = self.preparer.format_column(delta.result_column)

"""

   MySQL database specific implementations of changeset classes.

"""

from sqlalchemy.databases import mysql as sa_base

from sqlalchemy import types as sqltypes

from rhodecode.lib.dbmigrate.migrate import exceptions

class MySQLColumnGenerator(MySQLSchemaGenerator, ansisql.ANSIColumnGenerator):

    pass

class MySQLColumnDropper(ansisql.ANSIColumnDropper):

    pass

class MySQLSchemaChanger(MySQLSchemaGenerator, ansisql.ANSISchemaChanger):

    def visit_column(self, delta):

        table = delta.table

        colspec = self.get_column_specification(delta.result_column)

        if delta.result_column.autoincrement:

            primary_keys = [c for c in table.primary_key.columns

                       if (c.autoincrement and

                            isinstance(c.type, sqltypes.Integer) and

                            not c.foreign_keys)]

            if primary_keys:

                first = primary_keys.pop(0)

                if first.name == delta.current_name:

                    colspec += " AUTO_INCREMENT"

        old_col_name = self.preparer.quote(delta.current_name, table.quote)

        self.start_alter_table(table)

        self.append("CHANGE COLUMN %s " % old_col_name)

        self.append(colspec)

        self.execute()

    def visit_index(self, param):

        # If MySQL can do this, I can't find how

        raise exceptions.NotSupportedError("MySQL cannot rename indexes")

class MySQLConstraintGenerator(ansisql.ANSIConstraintGenerator):

    pass

class MySQLDialect(ansisql.ANSIDialect):

    columngenerator = MySQLColumnGenerator

    columndropper = MySQLColumnDropper

    schemachanger = MySQLSchemaChanger

    constraintgenerator = MySQLConstraintGenerator

    constraintdropper = MySQLConstraintDropper

"""

   `PostgreSQL`_ database specific implementations of changeset classes.

   .. _`PostgreSQL`: http://www.postgresql.org/

"""

class PGColumnGenerator(PGSchemaGenerator, ansisql.ANSIColumnGenerator):

    """PostgreSQL column generator implementation."""

    pass

class PGColumnDropper(ansisql.ANSIColumnDropper):

    """PostgreSQL column dropper implementation."""

    pass

class PGSchemaChanger(ansisql.ANSISchemaChanger):

    """PostgreSQL schema changer implementation."""

    pass

class PGConstraintGenerator(ansisql.ANSIConstraintGenerator):

    """PostgreSQL constraint generator implementation."""

    pass

class PGConstraintDropper(ansisql.ANSIConstraintDropper):

    """PostgreSQL constaint dropper implementation."""