checkfirst = not override

        meta.Base.metadata.create_all(checkfirst=checkfirst)

        log.info('Created tables for %s', self.dbname)

    def set_db_version(self):

        ver = DbMigrateVersion()

        ver.version = __dbversion__

        ver.repository_id = 'rhodecode_db_migrations'

        ver.repository_path = 'versions'

        self.sa.add(ver)

        log.info('db version set to: %s', __dbversion__)

    def upgrade(self):

        """

        Upgrades given database schema to given revision following

        all needed steps, to perform the upgrade

        """

        from rhodecode.lib.dbmigrate.migrate.versioning import api

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

            DatabaseNotControlledError

        if 'sqlite' in self.dburi:

            print (

               '********************** WARNING **********************\n'

               'Make sure your version of sqlite is at least 3.7.X.  \n'

               'Earlier versions are known to fail on some migrations\n'

               '*****************************************************\n'

            )

        upgrade = ask_ok('You are about to perform database upgrade, make '

                         'sure You backed up your database before. '

                         'Continue ? [y/n]')

        if not upgrade:

            sys.exit('Nothing done')

        repository_path = jn(dn(dn(dn(os.path.realpath(__file__)))),

                             'rhodecode/lib/dbmigrate')

        db_uri = self.dburi

        try:

            curr_version = api.db_version(db_uri, repository_path)

            msg = ('Found current database under version'

                 ' control with version %s' % curr_version)

        except (RuntimeError, DatabaseNotControlledError):

            curr_version = 1

            msg = ('Current database is not under version control. Setting'

                   ' as version %s' % curr_version)

            api.version_control(db_uri, repository_path, curr_version)

        print (msg)

        if curr_version == __dbversion__:

            sys.exit('This database is already at the newest version')

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

        # UPGRADE STEPS

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

        class UpgradeSteps(object):

            """

            Those steps follow schema versions so for example schema

            for example schema with seq 002 == step_2 and so on.

            """

            def __init__(self, klass):

                self.klass = klass

            def step_0(self):

                # step 0 is the schema upgrade, and than follow proper upgrades

                print ('attempting to do database upgrade to version %s' \

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

                print ('TODO:')

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

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

                .filter(User.username == 'default')\

                .one()

        def_user.name = 'Anonymous'

        def_user.lastname = 'User'

        def_user.email = 'anonymous@rhodecode.org'

        try:

            self.sa.add(def_user)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise

    def fix_settings(self):

        """

        Fixes rhodecode settings adds ga_code key for google analytics

        """

        hgsettings3 = RhodeCodeSetting('ga_code', '')

        try:

            self.sa.add(hgsettings3)

            self.sa.commit()

        except:

            self.sa.rollback()

            raise

    def admin_prompt(self, second=False):

        if not self.tests:

            import getpass

            def get_password():

                password = getpass.getpass('Specify admin password '

                                           '(min 6 chars):')

                confirm = getpass.getpass('Confirm password:')

                if password != confirm:

                    log.error('passwords mismatch')

                    return False

                if len(password) < 6:

                    log.error('password is to short use at least 6 characters')

                    return False

                return password

            username = raw_input('Specify admin username:')

            password = get_password()

            if not password:

                #second try

                password = get_password()

                if not password:

                    sys.exit()

            email = raw_input('Specify admin email:')

            self.create_user(username, password, email, True)

        else:

            log.info('creating admin and regular test users')

            from rhodecode.tests import TEST_USER_ADMIN_LOGIN,\

            TEST_USER_ADMIN_PASS, TEST_USER_ADMIN_EMAIL,\

            TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS,\

            TEST_USER_REGULAR_EMAIL, TEST_USER_REGULAR2_LOGIN, \

            TEST_USER_REGULAR2_PASS, TEST_USER_REGULAR2_EMAIL

class Attachment(object):

    """

    Encapsulates file attachment information.

    :param filename: filename of attachment

    :param content_type: file mimetype

    :param data: the raw file data, either as string or file obj

    :param disposition: content-disposition (if any)

    """

    def __init__(self,

                 filename=None,

                 content_type=None,

                 data=None,

                 disposition=None):

        self.filename = filename

        self.content_type = content_type

        self.disposition = disposition or 'attachment'

        self._data = data

    @property

    def data(self):

        if isinstance(self._data, basestring):

            return self._data

        self._data = self._data.read()

        return self._data

class Message(object):

    """

    Encapsulates an email message.

    :param subject: email subject header

    :param recipients: list of email addresses

    :param body: plain text message

    :param html: HTML message

    :param sender: email sender address

    :param cc: CC list

    :param bcc: BCC list

    :param extra_headers: dict of extra email headers

    :param attachments: list of Attachment instances

    :param recipients_separator: alternative separator for any of

        'From', 'To', 'Delivered-To', 'Cc', 'Bcc' fields

    """

    def __init__(self,

                 subject=None,

                 recipients=None,

                 body=None,

                 html=None,

                 sender=None,

                 cc=None,

                 bcc=None,

                 extra_headers=None,

                 attachments=None,

                 recipients_separator="; "):

        self.subject = subject or ''

        self.sender = sender

        self.body = body

        self.html = html

        self.recipients = recipients or []

        self.attachments = attachments or []

        self.cc = cc or []

        self.bcc = bcc or []

        self.extra_headers = extra_headers or {}

        self.recipients_separator = recipients_separator

    @property

    def send_to(self):

        return set(self.recipients) | set(self.bcc or ()) | set(self.cc or ())

    def to_message(self):

        """

        Returns raw email.Message instance.Validates message first.

        """

        self.validate()

        return self.get_response().to_message()

    def get_response(self):

        """

        Creates a Lamson MailResponse instance

        """

        response = MailResponse(Subject=self.subject,

                                To=self.recipients,

                                From=self.sender,

                                Body=self.body,

                                Html=self.html,

                                separator=self.recipients_separator)

        if self.cc:

            response.base['Cc'] = self.cc

        for attachment in self.attachments:

            response.attach(attachment.filename,

                            attachment.content_type,

                            attachment.data,

                            attachment.disposition)

        response.update(self.extra_headers)

        return response

    def is_bad_headers(self):

        """

        Checks for bad headers i.e. newlines in subject, sender or recipients.

        """

        headers = [self.subject, self.sender]

        headers += list(self.send_to)

        headers += self.extra_headers.values()

        for val in headers:

            for c in '\r\n':

                if c in val:

                    return True

        return False

    def validate(self):

        """

        Checks if message is valid and raises appropriate exception.

        """

        if not self.recipients:

            raise InvalidMessage, "No recipients have been added"

        if not self.body and not self.html:

            raise InvalidMessage, "No body has been set"

        if not self.sender:

            raise InvalidMessage, "No sender address has been set"

        if self.is_bad_headers():

            raise BadHeaders

    def add_recipient(self, recipient):

        """

        Adds another recipient to the message.

        :param recipient: email address of recipient.

        """

        self.recipients.append(recipient)

    def add_cc(self, recipient):

        """

        Adds an email address to the CC list.

        :param recipient: email address of recipient.

        """

        self.cc.append(recipient)

    def add_bcc(self, recipient):

        """

        Adds an email address to the BCC list.

        :param recipient: email address of recipient.

        """

        self.bcc.append(recipient)

    def attach(self, attachment):

        """

        Adds an attachment to the message.

        :param attachment: an **Attachment** instance.

        """

        self.attachments.append(attachment)