# The ErrorController route (handles 404/500 error pages); it should

    # likely stay at the top, ensuring it can always be resolved

    map.connect('/error/{action}', controller='error')

    map.connect('/error/{action}/{id}', controller='error')

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

    # CUSTOM ROUTES HERE

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

    #MAIN PAGE

    map.connect('home', '/', controller='home', action='index')

    map.connect('bugtracker', "http://bitbucket.org/marcinkuzminski/rhodecode/issues", _static=True)

    map.connect('gpl_license', "http://www.gnu.org/licenses/gpl.html", _static=True)

    #ADMIN REPOSITORY REST ROUTES

    with map.submapper(path_prefix='/_admin', controller='admin/repos') as m:

        m.connect("repos", "/repos",

             action="create", conditions=dict(method=["POST"]))

        m.connect("repos", "/repos",

             action="index", conditions=dict(method=["GET"]))

        m.connect("formatted_repos", "/repos.{format}",

             action="index",

            conditions=dict(method=["GET"]))

        m.connect("new_repo", "/repos/new",

             action="new", conditions=dict(method=["GET"]))

        m.connect("formatted_new_repo", "/repos/new.{format}",

             action="new", conditions=dict(method=["GET"]))

        m.connect("/repos/{repo_name:.*}",

             action="update", conditions=dict(method=["PUT"],

                                              function=check_repo))

        m.connect("/repos/{repo_name:.*}",

             action="delete", conditions=dict(method=["DELETE"],

                                              function=check_repo))

        m.connect("edit_repo", "/repos/{repo_name:.*}/edit",

             action="edit", conditions=dict(method=["GET"],

                                            function=check_repo))

        m.connect("formatted_edit_repo", "/repos/{repo_name:.*}.{format}/edit",

             action="edit", conditions=dict(method=["GET"],

                                            function=check_repo))

        m.connect("repo", "/repos/{repo_name:.*}",

             action="show", conditions=dict(method=["GET"],

                                            function=check_repo))

        m.connect("formatted_repo", "/repos/{repo_name:.*}.{format}",

             action="show", conditions=dict(method=["GET"],

                                            function=check_repo))

        #ajax delete repo perm user

        m.connect('delete_repo_user', "/repos_delete_user/{repo_name:.*}",

             action="delete_perm_user", conditions=dict(method=["DELETE"],

                                                        function=check_repo))

        #settings actions

        m.connect('repo_stats', "/repos_stats/{repo_name:.*}",

             action="repo_stats", conditions=dict(method=["DELETE"],

                                                        function=check_repo))

        m.connect('repo_cache', "/repos_cache/{repo_name:.*}",

             action="repo_cache", conditions=dict(method=["DELETE"],

                                                        function=check_repo))

    #ADMIN USER REST ROUTES

    map.resource('user', 'users', controller='admin/users', path_prefix='/_admin')

    #ADMIN USER REST ROUTES

    map.resource('users_group', 'users_groups', controller='admin/users_groups', path_prefix='/_admin')

    #ADMIN GROUP REST ROUTES

    map.resource('group', 'groups', controller='admin/groups', path_prefix='/_admin')

    #ADMIN PERMISSIONS REST ROUTES

    map.resource('permission', 'permissions', controller='admin/permissions', path_prefix='/_admin')

    ##ADMIN LDAP SETTINGS

    map.connect('ldap_settings', '/_admin/ldap', controller='admin/ldap_settings',

                action='ldap_settings', conditions=dict(method=["POST"]))

    map.connect('ldap_home', '/_admin/ldap', controller='admin/ldap_settings',)

    #ADMIN SETTINGS REST ROUTES

    with map.submapper(path_prefix='/_admin', controller='admin/settings') as m:

        m.connect("admin_settings", "/settings",

             action="create", conditions=dict(method=["POST"]))

        m.connect("admin_settings", "/settings",

             action="index", conditions=dict(method=["GET"]))

        m.connect("formatted_admin_settings", "/settings.{format}",

             action="index", conditions=dict(method=["GET"]))

        m.connect("admin_new_setting", "/settings/new",

             action="new", conditions=dict(method=["GET"]))

        m.connect("formatted_admin_new_setting", "/settings/new.{format}",

             action="new", conditions=dict(method=["GET"]))

        m.connect("/settings/{setting_id}",

             action="update", conditions=dict(method=["PUT"]))

        m.connect("/settings/{setting_id}",

             action="delete", conditions=dict(method=["DELETE"]))

        m.connect("admin_edit_setting", "/settings/{setting_id}/edit",

             action="edit", conditions=dict(method=["GET"]))

        m.connect("formatted_admin_edit_setting", "/settings/{setting_id}.{format}/edit",

             action="edit", conditions=dict(method=["GET"]))

        m.connect("admin_setting", "/settings/{setting_id}",

             action="show", conditions=dict(method=["GET"]))

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of repository %s') \

                    % repo_name, category='error')

        return redirect(url('edit_repo', repo_name=changed_name))

    @HasPermissionAllDecorator('hg.admin')

    def delete(self, repo_name):

        """DELETE /repos/repo_name: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('repo', repo_name=ID),

        #           method='delete')

        # url('repo', repo_name=ID)

        repo_model = RepoModel()

        repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was moved or renamed  from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('repos'))

        try:

            action_logger(self.rhodecode_user, 'admin_deleted_repo',

                              repo_name, '', self.sa)

            repo_model.delete(repo)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            h.flash(_('deleted repository %s') % repo_name, category='success')

        except Exception, e:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during deletion of %s') % repo_name,

                    category='error')

        return redirect(url('repos'))

    @HasPermissionAllDecorator('hg.admin')

    def delete_perm_user(self, repo_name):

        :param repo_name:

        """

        try:

            repo_model = RepoModel()

            repo_model.delete_perm_user(request.POST, repo_name)

        except Exception, e:

            h.flash(_('An error occurred during deletion of repository user'),

                    category='error')

            raise HTTPInternalServerError()

    @HasPermissionAllDecorator('hg.admin')

        """

        :param repo_name:

        """

        try:

            repo_model = RepoModel()

            repo_model.delete_stats(repo_name)

        except Exception, e:

            h.flash(_('An error occurred during deletion of repository stats'),

                    category='error')

        return redirect(url('edit_repo', repo_name=repo_name))

    @HasPermissionAllDecorator('hg.admin')

    def repo_cache(self, repo_name):

        :param repo_name:

        """

        try:

            ScmModel().mark_for_invalidation(repo_name)

        except Exception, e:

            h.flash(_('An error occurred during cache invalidation'),

                    category='error')

        return redirect(url('edit_repo', repo_name=repo_name))

    @HasPermissionAllDecorator('hg.admin')

    def show(self, repo_name, format='html'):

        """GET /repos/repo_name: Show a specific item"""

        # url('repo', repo_name=ID)

    @HasPermissionAllDecorator('hg.admin')

    def edit(self, repo_name, format='html'):

        """GET /repos/repo_name/edit: Form to edit an existing item"""

        # url('edit_repo', repo_name=ID)

        repo_model = RepoModel()

        r = ScmModel().get(repo_name)

        if c.repo_info is None:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was created or renamed from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('repos'))

        if c.repo_info.stats:

            last_rev = c.repo_info.stats.stat_on_revision

        else:

            last_rev = 0

        c.stats_revision = last_rev

        c.repo_last_rev = r.revisions[-1] if r.revisions else 0

        if last_rev == 0 or c.repo_last_rev == 0:

            c.stats_percentage = 0

        else:

            c.stats_percentage = '%.2f' % ((float((last_rev)) /

                                            c.repo_last_rev) * 100)

        defaults = c.repo_info.get_dict()

        if c.repo_info.user:

            defaults.update({'user':c.repo_info.user.username})

        else:

            replacement_user = self.sa.query(User)\

            .filter(User.admin == True).first().username

            defaults.update({'user':replacement_user})

        for p in c.repo_info.repo_to_perm:

                             p.permission.permission_name})

        return htmlfill.render(

            render('admin/repos/repo_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

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

"""

    rhodecode.controllers.settings

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    Settings controller for rhodecode

    :created_on: Jun 30, 2010

    :author: marcink

    :copyright: (C) 2009-2011 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

import traceback

import formencode

from formencode import htmlfill

from pylons import tmpl_context as c, request, url

from pylons.controllers.util import redirect

from pylons.i18n.translation import _

import rhodecode.lib.helpers as h

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.lib.utils import invalidate_cache, action_logger

from rhodecode.model.forms import RepoSettingsForm, RepoForkForm

from rhodecode.model.repo import RepoModel

log = logging.getLogger(__name__)

class SettingsController(BaseController):

    @LoginRequired()

    @HasRepoPermissionAllDecorator('repository.admin')

    def __before__(self):

        super(SettingsController, self).__before__()

    def index(self, repo_name):

        repo_model = RepoModel()

        c.repo_info = repo = repo_model.get_by_repo_name(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps'

                      ' it was created or renamed from the file system'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

            return redirect(url('home'))

        c.users_array = repo_model.get_users_js()

        for p in c.repo_info.repo_to_perm:

                             p.permission.permission_name})

        return htmlfill.render(

            render('settings/repo_settings.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )

    def update(self, repo_name):

        repo_model = RepoModel()

        changed_name = repo_name

        _form = RepoSettingsForm(edit=True, old_data={'repo_name':repo_name})()

        try:

            form_result = _form.to_python(dict(request.POST))

            repo_model.update(repo_name, form_result)

            invalidate_cache('get_repo_cached_%s' % repo_name)

            h.flash(_('Repository %s updated successfully' % repo_name),

                    category='success')

            changed_name = form_result['repo_name']

            action_logger(self.rhodecode_user, 'user_updated_repo',

                              changed_name, '', self.sa)

        except formencode.Invalid, errors:

            c.repo_info = repo_model.get_by_repo_name(repo_name)

            c.users_array = repo_model.get_users_js()

            errors.value.update({'user':c.repo_info.user.username})

            return htmlfill.render(

                render('settings/repo_settings.html'),

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of repository %s') \

                    % repo_name, category='error')

        return redirect(url('repo_settings_home', repo_name=changed_name))

    def delete(self, repo_name):

        """DELETE /repos/repo_name: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('repo_settings_delete', repo_name=ID),

        #           method='delete')

    user = relationship('User')

    repository = relationship('Repository')

class UsersGroup(Base, BaseModel):

    __tablename__ = 'users_groups'

    __table_args__ = {'useexisting':True}

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

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

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

    members = relationship('UsersGroupMember', cascade="all, delete, delete-orphan", lazy="joined")

class UsersGroupMember(Base, BaseModel):

    __tablename__ = 'users_groups_members'

    __table_args__ = {'useexisting':True}

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

    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

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

    user = relationship('User', lazy='joined')

    users_group = relationship('UsersGroup')

    def __init__(self, gr_id, u_id):

        self.users_group_id = gr_id

        self.user_id = u_id

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)

    repo_type = Column("repo_type", String(length=None, convert_unicode=False, assert_unicode=None), nullable=False, unique=False, default='hg')

    user_id = Column("user_id", Integer(), ForeignKey('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)

    enable_downloads = Column("downloads", 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('repositories.repo_id'), nullable=True, unique=False, default=None)

    group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=False, default=None)

    user = relationship('User')

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

    group = relationship('Group')

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

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

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

    logs = relationship('UserLog', cascade='all')

    def __repr__(self):

        return "<%s('%s:%s')>" % (self.__class__.__name__,

                                  self.repo_id, self.repo_name)

class Group(Base, BaseModel):

    __tablename__ = 'groups'

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

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

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

    group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)

    parent_group = relationship('Group', remote_side=group_id)

    def __init__(self, group_name='', parent_group=None):

        self.group_name = group_name

        self.parent_group = parent_group

    def __repr__(self):

        return "<%s('%s:%s')>" % (self.__class__.__name__, self.group_id,

                                  self.group_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)

    def __repr__(self):

        return "<%s('%s:%s')>" % (self.__class__.__name__,

                                  self.permission_id, self.permission_name)

class RepoToPerm(Base, BaseModel):

    __tablename__ = 'repo_to_perm'

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

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

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

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

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

        try:

            self.user_db = sa.query(User)\

                .filter(User.active == True)\

                .filter(User.username == value).one()

        except Exception:

            raise formencode.Invalid(_('This username is not valid'),

                                     value, state)

        finally:

            meta.Session.remove()

        return self.user_db.user_id

def ValidRepoName(edit, old_data):

    class _ValidRepoName(formencode.validators.FancyValidator):

        def to_python(self, value, state):

            slug = h.repo_name_slug(value)

            if slug in ['_admin']:

                raise formencode.Invalid(_('This repository name is disallowed'),

                                         value, state)

            if old_data.get('repo_name') != value or not edit:

                if RepoModel().get_by_repo_name(slug, cache=False):

                    raise formencode.Invalid(_('This repository already exists') ,

                                             value, state)

            return slug

    return _ValidRepoName

def ValidForkType(old_data):

    class _ValidForkType(formencode.validators.FancyValidator):

        def to_python(self, value, state):

            if old_data['repo_type'] != value:

                raise formencode.Invalid(_('Fork have to be the same type as original'),

                                         value, state)

            return value

    return _ValidForkType

class ValidPerms(formencode.validators.FancyValidator):

    messages = {'perm_new_member_name':_('This username or users group name'

                                         ' is not valid')}

    def to_python(self, value, state):

        perms_update = []

        perms_new = []

        #build a list of permission to update and new permission to create

        for k, v in value.items():

        value['perms_updates'] = perms_update

        value['perms_new'] = perms_new

        #update permissions

        sa = meta.Session

        for k, v, t in perms_new:

            try:

                if t is 'user':

                    self.user_db = sa.query(User)\

                        .filter(User.active == True)\

                        .filter(User.username == k).one()

                if t is 'users_group':

                    self.user_db = sa.query(UsersGroup)\

                        .filter(UsersGroup.users_group_active == True)\

                        .filter(UsersGroup.users_group_name == k).one()

            except Exception:

                msg = self.message('perm_new_member_name',

                                     state=State_obj)

                raise formencode.Invalid(msg, value, state,

                                         error_dict={'perm_new_member_name':msg})

        return value

class ValidSettings(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        #settings  form can't edit user

        if value.has_key('user'):

            del['value']['user']

        return value

class ValidPath(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        if not os.path.isdir(value):

            msg = _('This is not a valid path')

            raise formencode.Invalid(msg, value, state,

                                     error_dict={'paths_root_path':msg})

        return value

def UniqSystemEmail(old_data):

    class _UniqSystemEmail(formencode.validators.FancyValidator):

        def to_python(self, value, state):

            value = value.lower()

            if old_data.get('email') != value:

                sa = meta.Session()

                try:

                    user = sa.query(User).filter(User.email == value).scalar()

                    if user:

                        raise formencode.Invalid(_("This e-mail address is already taken") ,

                                                 value, state)

                finally:

                    meta.Session.remove()

            return value

    return _UniqSystemEmail

class ValidSystemEmail(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        value = value.lower()

        sa = meta.Session

        try:

            user = sa.query(User).filter(User.email == value).scalar()

            if  user is None:

                raise formencode.Invalid(_("This e-mail address doesn't exist.") ,

                                         value, state)

        finally:

            meta.Session.remove()

        return value

class LdapLibValidator(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        try:

            import ldap

        except ImportError:

            raise LdapImportError

        return value

class AttrLoginValidator(formencode.validators.FancyValidator):

    def to_python(self, value, state):

        if not value or not isinstance(value, (str, unicode)):

                                     value, state)

        return value

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

# FORMS        

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

class LoginForm(formencode.Schema):

    allow_extra_fields = True

    filter_extra_fields = True

    username = UnicodeString(

                             strip=True,

                             min=1,

                             not_empty=True,

                             messages={

                                       'empty':_('Please enter a login'),

                                       'tooShort':_('Enter a value %(min)i characters long or more')}

                            )

    password = UnicodeString(

                            strip=True,

                            min=6,

                            not_empty=True,

                            messages={

                                      'empty':_('Please enter a password'),

                                      'tooShort':_('Enter %(min)i characters or more')}

                                )

    #chained validators have access to all data

    chained_validators = [ValidAuth]

def UserForm(edit=False, old_data={}):

    class _UserForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        username = All(UnicodeString(strip=True, min=1, not_empty=True),

                       ValidUsername(edit, old_data))

        if edit:

            new_password = All(UnicodeString(strip=True, min=6, not_empty=False))

            admin = StringBoolean(if_missing=False)

        else:

            password = All(UnicodeString(strip=True, min=6, not_empty=True))

        active = StringBoolean(if_missing=False)

        name = UnicodeString(strip=True, min=1, not_empty=True)

        lastname = UnicodeString(strip=True, min=1, not_empty=True)

        email = All(Email(not_empty=True), UniqSystemEmail(old_data))

                    .one().permission_id

            repo_to_perm.repository_id = new_repo.repo_id

            repo_to_perm.user_id = UserModel(self.sa)\

                .get_by_username('default', cache=False).user_id

            self.sa.add(repo_to_perm)

            self.sa.commit()

            #now automatically start following this repository as owner

            from rhodecode.model.scm import ScmModel

            ScmModel(self.sa).toggle_following_repo(new_repo.repo_id,

                                             cur_user.user_id)

            if not just_db:

                self.__create_repo(repo_name, form_data['repo_type'])

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def create_fork(self, form_data, cur_user):

        from rhodecode.lib.celerylib import tasks, run_task

        run_task(tasks.create_repo_fork, form_data, cur_user)

    def delete(self, repo):

        try:

            self.sa.delete(repo)

            self.__delete_repo(repo)

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def delete_perm_user(self, form_data, repo_name):

        try:

            self.sa.query(RepoToPerm)\

                .filter(RepoToPerm.repository \

                        == self.get_by_repo_name(repo_name))\

                .filter(RepoToPerm.user_id == form_data['user_id']).delete()

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def delete_stats(self, repo_name):

        try:

            self.sa.query(Statistics)\

                .filter(Statistics.repository == \

                        self.get_by_repo_name(repo_name)).delete()

            self.sa.commit()

        except:

            log.error(traceback.format_exc())

            self.sa.rollback()

            raise

    def __create_repo(self, repo_name, alias):

        """

        makes repository on filesystem

        :param repo_name:

        :param alias:

        """

        from rhodecode.lib.utils import check_repo

        repo_path = os.path.join(self.base_path, repo_name)

        if check_repo(repo_name, self.base_path):

            log.info('creating repo %s in %s', repo_name, repo_path)

            backend = get_backend(alias)

            backend(repo_path, create=True)

    def __rename_repo(self, old, new):

        """

        renames repository on filesystem

        :param old: old name

        :param new: new name

        """

        log.info('renaming repo from %s to %s', old, new)

        old_path = os.path.join(self.base_path, old)

        new_path = os.path.join(self.base_path, new)

        if os.path.isdir(new_path):

            raise Exception('Was trying to rename to already existing dir %s',

                            new_path)

        shutil.move(old_path, new_path)

    def __delete_repo(self, repo):

        """

        removes repo from filesystem, the removal is acctually made by

        added rm__ prefix into dir, and rename internat .hg/.git dirs so this

        repository is no longer valid for rhodecode, can be undeleted later on