# url('repo', repo_name=ID)

        repo_model = RepoModel()

        changed_name = repo_name

        _form = RepoForm(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, 'admin_updated_repo',

                              changed_name, '', self.sa)

        except formencode.Invalid, errors:

            c.repo_info = repo_model.get_by_repo_name(repo_name)

            if c.repo_info.stats:

                last_rev = c.repo_info.stats.stat_on_revision

            else:

                last_rev = 0

            c.stats_revision = last_rev

            repo, dbrepo = ScmModel().get(repo_name, retval='repo')

            if last_rev == 0:

                c.stats_percentage = 0

            else:

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

                                                c.repo_last_rev) * 100)

            c.users_array = repo_model.get_users_js()

            c.users_groups_array = repo_model.get_users_groups_js()

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

            return htmlfill.render(

                render('admin/repos/repo_edit.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('edit_repo', repo_name=changed_name))

    @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, dbrepo = ScmModel().get(repo_name, retval='repo')

        repo_model = RepoModel()

        c.repo_info = repo_model.get_by_repo_name(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

        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)

        c.users_array = repo_model.get_users_js()

        c.users_groups_array = repo_model.get_users_groups_js()

        defaults = c.repo_info.get_dict()

        #fill owner

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

        #fill repository users

        for p in c.repo_info.repo_to_perm:

            defaults.update({'u_perm_%s' % p.user.username:

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def __before__(self):

        super(ChangesetController, self).__before__()

    def index(self, revision):

        def wrap_to_table(str):

            return '''<table class="code-difftable">

                        <tr class="line">

                        <td class="lineno new"></td>

                        <td class="code"><pre>%s</pre></td>

                        </tr>

                      </table>''' % str

        #get ranges of revisions if preset

        rev_range = revision.split('...')[:2]

        range_limit = 50

        try:

            if len(rev_range) == 2:

                rev_start = rev_range[0]

                rev_end = rev_range[1]

            else:

                rev_ranges = [c.rhodecode_repo.get_changeset(revision)]

            c.cs_ranges = list(rev_ranges)

        except (RepositoryError, ChangesetDoesNotExistError, Exception), e:

            log.error(traceback.format_exc())

            h.flash(str(e), category='warning')

            return redirect(url('home'))

        c.changes = OrderedDict()

        c.sum_added = 0

        c.sum_removed = 0

        for changeset in c.cs_ranges:

            c.changes[changeset.raw_id] = []

            try:

                changeset_parent = changeset.parents[0]

            except IndexError:

                changeset_parent = None

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

            try:

                c.repo_tags[name] = c.repo.get_changeset(hash)

            except ChangesetError:

                c.repo_tags[name] = EmptyChangeset(hash)

        c.repo_branches = OrderedDict()

        for name, hash in c.repo.branches.items()[:10]:

            try:

                c.repo_branches[name] = c.repo.get_changeset(hash)

            except ChangesetError:

                c.repo_branches[name] = EmptyChangeset(hash)

        td = date.today() + timedelta(days=1)

        td_1m = td - timedelta(days=calendar.mdays[td.month])

        td_1y = td - timedelta(days=365)

        ts_min_m = mktime(td_1m.timetuple())

        ts_min_y = mktime(td_1y.timetuple())

        ts_max_y = mktime(td.timetuple())

        if dbrepo.enable_statistics:

            c.no_data_msg = _('No data loaded yet')

            run_task(get_commits_stats, c.repo.name, ts_min_y, ts_max_y)

        else:

        c.ts_min = ts_min_m

        c.ts_max = ts_max_y

        stats = self.sa.query(Statistics)\

            .filter(Statistics.repository == dbrepo)\

            .scalar()

        if stats and stats.languages:

            c.no_data = False is dbrepo.enable_statistics

            lang_stats = json.loads(stats.languages)

            c.commit_data = stats.commit_activity

            c.overview_data = stats.commit_activity_combined

            c.trending_languages = json.dumps(OrderedDict(

                                       sorted(lang_stats.items(), reverse=True,

                                            key=lambda k: k[1])[:10]

                                        )

                                    )

        else:

            c.commit_data = json.dumps({})

            c.overview_data = json.dumps([[ts_min_y, 0], [ts_max_y, 10] ])

            c.trending_languages = json.dumps({})

            c.no_data = True

"""

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

import sys

import socket

import traceback

import logging

from hashlib import md5

from decorator import decorator

from vcs.utils.lazy import LazyProperty

from rhodecode.lib import str2bool

from rhodecode.lib.pidlock import DaemonLock, LockHeld

from celery.messaging import establish_connection

log = logging.getLogger(__name__)

try:

    CELERY_ON = str2bool(config['app_conf'].get('use_celery'))

except KeyError:

    CELERY_ON = False

class ResultWrapper(object):

    def __init__(self, task):

        self.task = task

    @LazyProperty

    def result(self):

        return self.task

def run_task(task, *args, **kwargs):

    if CELERY_ON:

        try:

            t = task.apply_async(args=args, kwargs=kwargs)

            log.info('running task %s:%s', t.task_id, task)

            return t

        except socket.error, e:

            if  e.errno == 111: