.. toctree::

   :maxdepth: 1

   usage/general

   usage/git_support

   usage/performance

   usage/statistics

   usage/backup

   usage/debugging

   usage/troubleshooting

**Develop**

        m.connect('repo_pull', "/repo_pull/{repo_name:.*?}",

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

                                                      function=check_repo))

        m.connect('repo_as_fork', "/repo_as_fork/{repo_name:.*?}",

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

                                                      function=check_repo))

    with rmap.submapper(path_prefix=ADMIN_PREFIX,

                        controller='admin/repos_groups') as m:

        m.connect("repos_groups", "/repos_groups",

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

        m.connect("repos_groups", "/repos_groups",

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

        """

        try:

            RepoModel().delete_stats(repo_name)

            Session().commit()

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

        """

        try:

            ScmModel().mark_for_invalidation(repo_name)

            Session().commit()

        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 repo_public_journal(self, repo_name):

        """

        Set's this repository to be visible in public journal,

        in other words assing default user to follow this repo

        :param repo_name:

            self.user_perms = set()

        self.username = user.username

        self.repo_name = repo_name

        return self.check_permissions()

    def check_permissions(self):

                  'permissions %s for user:%s repository:%s', self.user_perms,

                                                self.username, self.repo_name)

        if self.required_perms.intersection(self.user_perms):

            log.debug('permission granted for user:%s on repo:%s' % (

                          self.username, self.repo_name

                     )

import logging

import time

import traceback

from paste.auth.basic import AuthBasicAuthenticator

from paste.httpexceptions import HTTPUnauthorized, HTTPForbidden

from paste.httpheaders import WWW_AUTHENTICATE

from pylons import config, tmpl_context as c, request, session, url

from pylons.controllers import WSGIController

from pylons.controllers.util import redirect

from pylons.templating import render_mako as render

from rhodecode import __version__, BACKENDS

from rhodecode.lib.auth import AuthUser, get_container_username, authfunc,\

    HasPermissionAnyMiddleware, CookieStoreWrapper

from rhodecode.lib.utils import get_repo_slug, invalidate_cache

from rhodecode.model import meta

from rhodecode.model.notification import NotificationModel

from rhodecode.model.scm import ScmModel

log = logging.getLogger(__name__)

def _get_ip_addr(environ):

    proxy_key = 'HTTP_X_REAL_IP'

        if require_ssl and org_proto == 'http':

            log.debug('proto is %s and SSL is required BAD REQUEST !'

                      % org_proto)

            return False

        return True

    def __call__(self, environ, start_response):

        start = time.time()

        try:

            return self._handle_request(environ, start_response)

        finally:

            log = logging.getLogger('rhodecode.' + self.__class__.__name__)

        hooks1 = RhodeCodeUi() if hooks1_ is None else hooks1_

        hooks1.ui_section = 'hooks'

        hooks1.ui_key = hooks1_key

        hooks1.ui_value = 'hg update >&2'

        hooks1.ui_active = False

        hooks2_key = RhodeCodeUi.HOOK_REPO_SIZE

        hooks2_ = self.sa.query(RhodeCodeUi)\

            .filter(RhodeCodeUi.ui_key == hooks2_key).scalar()

        hooks2 = RhodeCodeUi() if hooks2_ is None else hooks2_

        hooks2.ui_section = 'hooks'

        hooks2.ui_key = hooks2_key

        hooks2.ui_value = 'python:rhodecode.lib.hooks.repo_size'

        hooks3 = RhodeCodeUi()

        hooks3.ui_section = 'hooks'

        hooks3.ui_key = RhodeCodeUi.HOOK_PUSH

        hooks3.ui_value = 'python:rhodecode.lib.hooks.log_push_action'

        hooks4 = RhodeCodeUi()

        hooks4.ui_section = 'hooks'

        # enable largefiles

        largefiles = RhodeCodeUi()

        largefiles.ui_section = 'extensions'

        largefiles.ui_key = 'largefiles'

        largefiles.ui_value = ''

        # enable hgsubversion disabled by default

        hgsubversion = RhodeCodeUi()

        hgsubversion.ui_section = 'extensions'

        hgsubversion.ui_key = 'hgsubversion'

        hgsubversion.ui_value = ''

        hgsubversion.ui_active = False

        # enable hggit disabled by default

        hggit = RhodeCodeUi()

        hggit.ui_section = 'extensions'

        hggit.ui_key = 'hggit'

        hggit.ui_value = ''

        hggit.ui_active = False

        self.sa.add(hggit)

    def create_ldap_options(self, skip_existing=False):

        """Creates ldap settings"""

        for k, v in [('ldap_active', 'false'), ('ldap_host', ''),

        paths = RhodeCodeUi()

        paths.ui_section = 'paths'

        paths.ui_key = '/'

        paths.ui_value = path

        sett1 = RhodeCodeSetting('realm', 'RhodeCode authentication')

        sett2 = RhodeCodeSetting('title', 'RhodeCode')

        sett3 = RhodeCodeSetting('ga_code', '')

        sett4 = RhodeCodeSetting('show_public_icon', True)

        sett5 = RhodeCodeSetting('show_private_icon', True)

# 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/>.

class LdapUsernameError(Exception):

    pass

class LdapPasswordError(Exception):

class UsersGroupsAssignedException(Exception):

    pass

class StatusChangeOnClosedPullRequestError(Exception):

from webhelpers.html.tags import _set_input_attrs, _set_id_attr, \

    convert_boolean_attrs, NotGiven, _make_safe_id_component

from rhodecode.lib.annotate import annotate_highlight

from rhodecode.lib.utils import repo_name_slug

from rhodecode.lib.utils2 import str2bool, safe_unicode, safe_str, \

from rhodecode.lib.markup_renderer import MarkupRenderer

from rhodecode.lib.vcs.exceptions import ChangesetDoesNotExistError

from rhodecode.lib.vcs.backends.base import BaseChangeset

from rhodecode.config.conf import DATE_FORMAT, DATETIME_FORMAT

from rhodecode.model.changeset_status import ChangesetStatusModel

from rhodecode.model.db import URL_SEP, Permission

        return person_getter(user)

    # Still nothing?  Just pass back the author name then

    return _author

def desc_stylize(value):

    """

    converts tags from value into html equivalent

    :param value:

    """

from mercurial.node import nullrev

from rhodecode.lib import helpers as h

from rhodecode.lib.utils import action_logger

from rhodecode.lib.vcs.backends.base import EmptyChangeset

from rhodecode.lib.compat import json

def _get_scm_size(alias, root_path):

    if not alias.startswith('.'):

        alias += '.'

        size_hg_f, size_root_f, size_total_f, last_cs.rev(), last_cs.hex()[:12]

    )

    sys.stdout.write(msg)

def log_pull_action(ui, repo, **kwargs):

    """

    Logs user last pull action

    :param ui:

    :param repo:

        rc_extras = {}

    extras = dict(repo.ui.configitems('rhodecode_extras'))

    if 'username' in extras:

        username = extras['username']

        repository = extras['repository']

        scm = extras['scm']

    elif 'username' in rc_extras:

        username = rc_extras['username']

        repository = rc_extras['repository']

        scm = rc_extras['scm']

    else:

        raise Exception('Missing data in repo.ui and os.environ')

    action = 'pull'

    # extension hook call

    from rhodecode import EXTENSIONS

    callback = getattr(EXTENSIONS, 'PULL_HOOK', None)

    if isfunction(callback):

        kw = {}

        kw.update(extras)

        callback(**kw)

    return 0

def log_push_action(ui, repo, **kwargs):

    """

    Maps user last push action to new changeset id, from mercurial

    extras = dict(repo.ui.configitems('rhodecode_extras'))

    if 'username' in extras:

        username = extras['username']

        repository = extras['repository']

        scm = extras['scm']

    elif 'username' in rc_extras:

        username = rc_extras['username']

        repository = rc_extras['repository']

        scm = rc_extras['scm']

    else:

        raise Exception('Missing data in repo.ui and os.environ')

    action = 'push' + ':%s'

    if scm == 'hg':

    from rhodecode import EXTENSIONS

    callback = getattr(EXTENSIONS, 'PUSH_HOOK', None)

    if isfunction(callback):

        kw = {'pushed_revs': revs}

        kw.update(extras)

        callback(**kw)

    return 0

def log_create_repository(repository_dict, created_by, **kwargs):

    """

    Post create repository Hook. This is a dummy function for admins to re-use

        kw.update({'created_by': created_by})

        kw.update(kwargs)

        return callback(**kw)

    return 0

    """

    A really hacky method that is runned by git post-receive hook and logs

    an push action together with pushed revisions. It's executed by subprocess

    thus needs all info to be able to create a on the fly pylons enviroment,

    connect to database and run the logging code. Hacky as sh*t but works.

    from paste.deploy import appconfig

    from sqlalchemy import engine_from_config

    from rhodecode.config.environment import load_environment

    from rhodecode.model import init_model

    from rhodecode.model.db import RhodeCodeUi

    from rhodecode.lib.utils import make_ui

    path, ini_name = os.path.split(env['RHODECODE_CONFIG_FILE'])

    conf = appconfig('config:%s' % ini_name, relative_to=path)

    load_environment(conf.global_conf, conf.local_conf)

    engine = engine_from_config(conf, 'sqlalchemy.db1.')

    baseui = make_ui('db')

    # fix if it's not a bare repo

    if repo_path.endswith('.git'):

        repo_path = repo_path[:-4]

    repo = Repository.get_by_full_path(repo_path)

    _hooks = dict(baseui.configitems('hooks')) or {}

        for k, v in extras.items():

            baseui.setconfig('rhodecode_extras', k, v)

        repo = repo.scm_instance

        repo.ui = baseui

        rev_data = []

        for l in revs:

            old_rev, new_rev, ref = l.split(' ')

            _ref_data = ref.split('/')

            if _ref_data[1] in ['tags', 'heads']:

                rev_data.append({'old_rev': old_rev,

class GitRepository(object):

    git_folder_signature = set(['config', 'head', 'info', 'objects', 'refs'])

    commands = ['git-upload-pack', 'git-receive-pack']

        files = set([f.lower() for f in os.listdir(content_path)])

        if  not (self.git_folder_signature.intersection(files)

                == self.git_folder_signature):

            raise OSError('%s missing git signature' % content_path)

        self.content_path = content_path

        self.valid_accepts = ['application/x-%s-result' %

                              c for c in self.commands]

        self.repo_name = repo_name

    def _get_fixedpath(self, path):

        """

        Small fix for repo_path

        :param path:

    def inforefs(self, request, environ):

        """

        WSGI Response producer for HTTP GET Git Smart

        HTTP /info/refs request.

        """

        if git_command not in self.commands:

            log.debug('command %s not allowed' % git_command)

            return exc.HTTPMethodNotAllowed()

        # note to self:

        # please, resist the urge to add '\n' to git capture and increment

        else:

            inputstream = environ['wsgi.input']

        try:

            gitenv = os.environ

            from rhodecode import CONFIG

            # forget all configs

            gitenv['GIT_CONFIG_NOGLOBAL'] = '1'

            # we need current .ini file used to later initialize rhodecode

            # env and connect to db

            gitenv['RHODECODE_CONFIG_FILE'] = CONFIG['__file__']

            opts = dict(

            resp = exc.HTTPInternalServerError()

        return resp(environ, start_response)

class GitDirectory(object):

        repo_location = os.path.join(repo_root, repo_name)

        if not os.path.isdir(repo_location):

            raise OSError(repo_location)

        self.content_path = repo_location

        self.repo_name = repo_name

        self.repo_location = repo_location

    def __call__(self, environ, start_response):

        content_path = self.content_path

        try:

        except (AssertionError, OSError):

            if os.path.isdir(os.path.join(content_path, '.git')):

                app = GitRepository(self.repo_name,

                                    os.path.join(content_path, '.git'),

                                    self.username)

            else:

                return exc.HTTPNotFound()(environ, start_response)

        return app(environ, start_response)

import re

import logging

import traceback

from dulwich import server as dulserver

from dulwich.web import LimitedInputFilter, GunzipFilter

class SimpleGitUploadPackHandler(dulserver.UploadPackHandler):

    def handle(self):

        write = lambda x: self.proto.write_sideband(1, x)

    return isgit_path

class SimpleGit(BaseVCSController):

    def _handle_request(self, environ, start_response):

        if not is_git(environ):

            return self.application(environ, start_response)

        if not self._check_ssl(environ, start_response):

            return HTTPNotAcceptable('SSL REQUIRED !')(environ, start_response)

        ipaddr = self._get_ip_addr(environ)

        username = None

        self._git_first_op = False

        # skip passing error to error controller

        environ['pylons.status_code_redirect'] = True

                #check permissions for this repository

                perm = self._check_permission(action, user, repo_name)

                if perm is not True:

                    return HTTPForbidden()(environ, start_response)

        extras = {

            'ip': ipaddr,

            'username': username,

            'action': action,

            'repository': repo_name,

            'scm': 'git',

        }

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

        # GIT REQUEST HANDLING