%if http_server == 'gunicorn':

<%text>## GUNICORN ##</%text>

use = egg:gunicorn#main

<%text>## number of process workers. You must set `instance_id = *` when this option</%text>

<%text>## is set to more than one worker</%text>

workers = 1

<%text>## process name</%text>

proc_name = rhodecode

<%text>## type of worker class, one of sync, eventlet, gevent, tornado</%text>

<%text>## recommended for bigger setup is using of of other than sync one</%text>

worker_class = sync

max_requests = 1000

<%text>## restarted</%text>

timeout = 3600

%endif

%if http_server == 'uwsgi':

<%text>## UWSGI ##</%text>

<%text>## run with uwsgi --ini-paste-logged <inifile.ini></%text>

[uwsgi]

socket = /tmp/uwsgi.sock

master = true

http = 0.0.0.0:5000

<%text>## set as deamon and redirect all output to file</%text>

## GUNICORN ##

#use = egg:gunicorn#main

## number of process workers. You must set `instance_id = *` when this option

## is set to more than one worker

#workers = 1

## process name

#proc_name = rhodecode

## type of worker class, one of sync, eventlet, gevent, tornado

## recommended for bigger setup is using of of other than sync one

#worker_class = sync

#max_requests = 5

## restarted

#timeout = 3600

## UWSGI ##

## run with uwsgi --ini-paste-logged <inifile.ini>

#[uwsgi]

#socket = /tmp/uwsgi.sock

#master = true

#http = 127.0.0.1:5000

## set as deamon and redirect all output to file

#daemonize = ./uwsgi_rhodecode.log

def main():

    if rhodecode is None:

        # exit with success if we cannot import rhodecode !!

        # this allows simply push to this repo even without

        # rhodecode

        sys.exit(0)

    repo_path = os.path.abspath('.')

    push_data = sys.stdin.readlines()

    # os.environ is modified here by a subprocess call that

    # runs git and later git executes this hook.

    # like IP or username from basic-auth

    handle_git_post_receive(repo_path, push_data, os.environ)

    sys.exit(0)

if __name__ == '__main__':

    main()

def main():

    if rhodecode is None:

        # exit with success if we cannot import rhodecode !!

        # this allows simply push to this repo even without

        # rhodecode

        sys.exit(0)

    repo_path = os.path.abspath('.')

    push_data = sys.stdin.readlines()

    # os.environ is modified here by a subprocess call that

    # runs git and later git executes this hook.

    # like IP or username from basic-auth

    handle_git_pre_receive(repo_path, push_data, os.environ)

    sys.exit(0)

if __name__ == '__main__':

    main()

# python -c "import pprint;from pygments import lexers;pprint.pprint([(x[0], x[1]) for x in lexers.get_all_lexers()]);"

EXTRA_LEXERS = {}

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

# WHOOSH INDEX EXTENSIONS

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

# if INDEX_EXTENSIONS is [] it'll use pygments lexers extensions by default.

# To set your own just add to this list extensions to index with content

INDEX_EXTENSIONS = []

# additional extensions for indexing besides the default from pygments

EXTRA_INDEX_EXTENSIONS = []

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

# POST CREATE REPOSITORY HOOK

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

# this function will be executed after each repository is created

def _crrepohook(*args, **kwargs):

    """

    Post create repository HOOK

    kwargs available:

     :param repo_name:

        return download_l

    def __get_readme_data(self, db_repo):

        repo_name = db_repo.repo_name

        @cache_region('long_term')

        def _get_readme_from_cache(key, kind):

            readme_data = None

            readme_file = None

            log.debug('Looking for README file')

            try:

                cs = db_repo.get_landing_changeset()

                if isinstance(cs, EmptyChangeset):

                    raise EmptyRepositoryError()

                renderer = MarkupRenderer()

                for f in README_FILES:

                    try:

                        readme = cs.get_node(f)

                        if not isinstance(readme, FileNode):

                            continue

                        readme_file = f

                        log.debug('Found README file `%s` rendering...' %

                                  readme_file)

        return None

    user.update_lastlogin()

    Session().commit()

    log.debug('User %s is now logged in by container authentication',

              user.username)

    return user

def get_container_username(environ, config, clean_username=False):

    """

    from REMOTE_USER if container_auth_enabled is enabled, if that fails

    it tries to get username from HTTP_X_FORWARDED_USER if proxypass_auth_enabled

    is enabled. clean_username extracts the username from this data if it's

    having @ in it.

    :param environ:

    :param config:

    :param clean_username:

    """

    username = None

    if str2bool(config.get('container_auth_enabled', False)):

        # base path of repo locations

        self.basepath = self.config['base_path']

        #authenticate this mercurial request using authfunc

        self.authenticate = BasicAuth('', authfunc,

                                      config.get('auth_ret_code'))

        self.ip_addr = '0.0.0.0'

    def _handle_request(self, environ, start_response):

        raise NotImplementedError()

    def _get_by_id(self, repo_name):

        """

        with a repository_name for support of _<ID> non changable urls

        :param repo_name:

        """

        try:

            data = repo_name.split('/')

            if len(data) >= 2:

                by_id = data[1].split('_')

                if len(by_id) == 2 and by_id[1].isdigit():

                    _repo_name = Repository.get(by_id[1]).repo_name

                    data[1] = _repo_name

        except Exception:

        self.__udiff, iterator_copy = tee(self.__udiff)

        return iterator_copy

    def _escaper(self, string):

        """

        Escaper for diff escapes special chars and checks the diff limit

        :param string:

        """

        self.cur_diff_size += len(string)

        # parsed line doesn't exceed the diff limit

        if self.diff_limit is not None and self.cur_diff_size > self.diff_limit:

            raise DiffLimitExceeded('Diff Limit Exceeded')

        return safe_unicode(string).replace('&', '&')\

                .replace('<', '&lt;')\

                .replace('>', '>')

    def _line_counter(self, l):

        """

        Checks each line and bumps total adds/removes for this diff

            self.progress(msg + "\n")

        # we are done

        self.proto.write("0000")

dulserver.DEFAULT_HANDLERS = {

  #git-ls-remote, git-clone, git-fetch and git-pull

  'git-upload-pack': SimpleGitUploadPackHandler,

  #git-push

  'git-receive-pack': dulserver.ReceivePackHandler,

}

#from dulwich.repo import Repo

#from dulwich.web import make_wsgi_chain

from paste.httpheaders import REMOTE_USER, AUTH_TYPE

from webob.exc import HTTPNotFound, HTTPForbidden, HTTPInternalServerError, \

    HTTPBadRequest, HTTPNotAcceptable

from rhodecode.lib.utils2 import safe_str, fix_PATH, get_server_url,\

    _set_extras

from rhodecode.lib.base import BaseVCSController

from rhodecode.lib.auth import get_container_username

from rhodecode.lib.utils import is_valid_repo, make_ui

        from rhodecode.lib.middleware.pygrack import make_wsgi_app

        app = make_wsgi_app(

            repo_root=safe_str(self.basepath),

            repo_name=repo_name,

            extras=extras,

        )

        app = GunzipFilter(LimitedInputFilter(app))

        return app

    def __get_repository(self, environ):

        """

        :param environ: environ where PATH_INFO is stored

        """

        try:

            environ['PATH_INFO'] = self._get_by_id(environ['PATH_INFO'])

            repo_name = GIT_PROTO_PAT.match(environ['PATH_INFO']).group(1)

        except Exception:

            log.error(traceback.format_exc())

            raise

        return repo_name

            if action == 'push':

                self._invalidate_cache(repo_name)

    def __make_app(self, repo_name, baseui, extras):

        """

        Make an wsgi application using hgweb, and inject generated baseui

        instance, additionally inject some extras into ui object

        """

        return hgweb_mod.hgweb(repo_name, name=repo_name, baseui=baseui)

    def __get_repository(self, environ):

        """

        :param environ: environ where PATH_INFO is stored

        """

        try:

            environ['PATH_INFO'] = self._get_by_id(environ['PATH_INFO'])

            repo_name = '/'.join(environ['PATH_INFO'].split('/')[1:])

            if repo_name.endswith('/'):

                repo_name = repo_name.rstrip('/')

        except Exception:

            log.error(traceback.format_exc())

            raise

                    node._blob = obj

                else:

                    raise NodeDoesNotExistError("There is no file nor directory "

                        "at the given path '%s' at revision %s"

                        % (path, self.short_id))

            # cache node

            self.nodes[path] = node

        return self.nodes[path]

    @LazyProperty

    def affected_files(self):

        """

        """

        added, modified, deleted = self._changes_cache

        return list(added.union(modified).union(deleted))

    @LazyProperty

    def _diff_name_status(self):

        output = []

        for parent in self.parents:

            cmd = 'diff --name-status %s %s --encoding=utf8' % (parent.raw_id,

                                                                self.raw_id)

            so, se = self.repository.run_git_command(cmd)

            output.append(so.strip())

            raise TagDoesNotExistError("Tag %s does not exist" % name)

        tagpath = posixpath.join(self._repo.refs.path, 'refs', 'tags', name)

        try:

            os.remove(tagpath)

            self._parsed_refs = self._get_parsed_refs()

            self.tags = self._get_tags()

        except OSError, e:

            raise RepositoryError(e.strerror)

    @LazyProperty

    def bookmarks(self):

        """

        """

        return {}

    @LazyProperty

    def _parsed_refs(self):

        return self._get_parsed_refs()

    def _get_parsed_refs(self):

        # cache the property

        _repo = self._repo

        refs = _repo.get_refs()

        keys = [('refs/heads/', 'H'),

                    node = DirNode(path, changeset=self)

            else:

                raise NodeDoesNotExistError("There is no file nor directory "

                    "at the given path: '%s' at revision %s"

                    % (path, self.short_id))

            # cache node

            self.nodes[path] = node

        return self.nodes[path]

    @LazyProperty

    def affected_files(self):

        """

        """

        return self._ctx.files()

    @property

    def added(self):

        """

        Returns list of added ``FileNode`` objects.

        """

        return AddedFileNodesGenerator([n for n in self.status[1]], self)

    @property

    def changed(self):

    def closed_branches(self):

        return self._get_branches(normal=False, closed=True)

    @LazyProperty

    def allbranches(self):

        """

        List all branches, including closed branches.

        """

        return self._get_branches(closed=True)

    def _get_branches(self, normal=True, closed=False):

        """

        Returns only not closed branches by default

        :param closed: return also closed branches for mercurial

        :param normal: return also normal branches

        """

        if self._empty:

            return {}

        def _branchtags(localrepo):

            """

            Patched version of mercurial branchtags to not return the closed

                bt.update(bt_closed)

            return bt

        sortkey = lambda ctx: ctx[0]  # sort by name

        _branches = [(safe_unicode(n), hex(h),) for n, h in

                     _branchtags(self._repo).items()]

        return OrderedDict(sorted(_branches, key=sortkey, reverse=False))

    @LazyProperty

    def tags(self):

        """

        """

        return self._get_tags()

    def _get_tags(self):

        if self._empty:

            return {}

        sortkey = lambda ctx: ctx[0]  # sort by name

        _tags = [(safe_unicode(n), hex(h),) for n, h in

                 self._repo.tags().items()]

        return OrderedDict(sorted(_tags, key=sortkey, reverse=True))

            date = datetime.datetime.now().ctime()

        local = False

        try:

            self._repo.tag(name, nullid, message, local, user, date)

            self.tags = self._get_tags()

        except Abort, e:

            raise RepositoryError(e.message)

    @LazyProperty

    def bookmarks(self):

        """

        """

        return self._get_bookmarks()

    def _get_bookmarks(self):

        if self._empty:

            return {}

        sortkey = lambda ctx: ctx[0]  # sort by name

        _bookmarks = [(safe_unicode(n), hex(h),) for n, h in

                 self._repo._bookmarks.items()]

        return OrderedDict(sorted(_bookmarks, key=sortkey, reverse=True))

            cl_path = os.path.join(self.path, '.hg', "00changelog.i")

            st_path = os.path.join(self.path, '.hg', "store")

            if os.path.exists(cl_path):

                return os.stat(cl_path).st_mtime

            else:

                return os.stat(st_path).st_mtime

    def _get_hidden(self):

        return self._repo.ui.configbool("web", "hidden", untrusted=True)

    def _get_revision(self, revision):

        """

        40 char revision number

        :param revision: str or int or None

        """

        if self._empty:

            raise EmptyRepositoryError("There are no changesets yet")

        if revision in [-1, 'tip', None]:

            revision = 'tip'

        try:

    """

    cls = None  # override in child class

    def __init__(self, sa=None):

        if sa is not None:

            self.sa = sa

        else:

            self.sa = meta.Session()

    def _get_instance(self, cls, instance, callback=None):

        """

        :param cls: class to fetch

        :param instance: int or Instance

        :param callback: callback to call if all lookups failed

        """

        if isinstance(instance, cls):

            return instance

        elif isinstance(instance, (int, long)) or safe_str(instance).isdigit():

            return cls.get(instance)

        else:

            if instance:

        """

        Deletes given comment

        :param comment_id:

        """

        comment = self.__get_changeset_comment(comment)

        Session().delete(comment)

        return comment

    def get_comments(self, repo_id, revision=None, pull_request=None):

        """

        :param repo_id:

        :param revision:

        :param pull_request:

        """

        q = ChangesetComment.query()\

                .filter(ChangesetComment.repo_id == repo_id)\

                .filter(ChangesetComment.line_no == None)\

                .filter(ChangesetComment.f_path == None)

        if revision:

            q = q.filter(ChangesetComment.revision == revision)

        repo_to_perm = UserRepoToPerm()

        repo_to_perm.permission = Permission.get_by_key(default_perm)

        repo_to_perm.repository = repository

        repo_to_perm.user_id = def_user.user_id

        return repo_to_perm

    @LazyProperty

    def repos_path(self):

        """

        """

        q = self.sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()

        return q.ui_value

    def get(self, repo_id, cache=False):

        repo = self.sa.query(Repository)\

            .filter(Repository.repo_id == repo_id)

        if cache:

            repo = repo.options(FromCache("sql_cache_short",

                                          "get_repo_%s" % repo_id))

    def get_by_repo_name(self, repo_name, cache=False):

        repo = self.sa.query(Repository)\

            .filter(Repository.repo_name == repo_name)

        if cache:

            repo = repo.options(FromCache("sql_cache_short",

                                          "get_repo_%s" % repo_name))

        return repo.scalar()

    def get_all_user_repos(self, user):

        """

        :param user:

        """

        from rhodecode.lib.auth import AuthUser

        user = self._get_user(user)

        repos = AuthUser(user_id=user.user_id).permissions['repositories']

        access_check = lambda r: r[1] in ['repository.read',

                                          'repository.write',

                                          'repository.admin']

        repos = [x[0] for x in filter(access_check, repos.items())]

        return Repository.query().filter(Repository.repo_name.in_(repos))

            repos_data.append(row)

        return {

            "totalRecords": len(repos_list),

            "startIndex": 0,

            "sort": "name",

            "dir": "asc",

            "records": repos_data

        }

    def _get_defaults(self, repo_name):

        """

        usage in forms

        :param repo_name:

        """

        repo_info = Repository.get_by_repo_name(repo_name)

        if repo_info is None:

            return None

        defaults = repo_info.get_dict()

        group, repo_name, repo_name_full = repo_info.groups_and_repo

    def _get_user_group(self, users_group):

        return self._get_instance(UserGroup, users_group,

                                  callback=UserGroup.get_by_group_name)

    def _get_repo_group(self, repos_group):

        return self._get_instance(RepoGroup, repos_group,

                                  callback=RepoGroup.get_by_group_name)

    @LazyProperty

    def repos_path(self):

        """

        """

        q = RhodeCodeUi.get_by_key('/')

        return q.ui_value

    def _create_default_perms(self, new_group):

        # create default permission

        default_perm = 'group.read'

        def_user = User.get_default_user()

        for p in def_user.user_perms:

            if p.permission.permission_name.startswith('group.'):

                default_perm = p.permission.permission_name

            return instance

        elif isinstance(instance, int) or safe_str(instance).isdigit():

            return cls.get(instance)

        elif isinstance(instance, basestring):

            return cls.get_by_repo_name(instance)

        elif instance:

            raise Exception('given object must be int, basestr or Instance'

                            ' of %s got %s' % (type(cls), type(instance)))

    @LazyProperty

    def repos_path(self):

        """

        """

        q = self.sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()

        return q.ui_value

    def repo_scan(self, repos_path=None):

        """

        Listing of repositories in given path. This path should not be a

        repository itself. Return a dictionary of repository objects

        :param repos_path: path to directory containing repositories

				alert(message);

			}

			// Return true

			return true;

		};

		// ----------------------------------------------------------------------

		// Emulated Status

		/**

		 * History.getInternetExplorerMajorVersion()

		 * @return {integer}

		 * @license Public Domain

		 * @author Benjamin Arthur Lupton <contact@balupton.com>

		 * @author James Padolsey <https://gist.github.com/527683>

		 */

		History.getInternetExplorerMajorVersion = function(){

			var result = History.getInternetExplorerMajorVersion.cached =

					(typeof History.getInternetExplorerMajorVersion.cached !== 'undefined')

				?	History.getInternetExplorerMajorVersion.cached

				:	(function(){

						var v = 3,

								div = document.createElement('div'),

						History.Adapter.trigger(window,'hashchange');

					});

				}

			}

		} // !History.emulated.pushState

	}; // History.initCore

	// Try and Initialise History

	History.init();

        response.follow()

        response = self.app.get(url(controller='changeset', action='index',

                                repo_name=HG_REPO, revision=rev))

        # test DB

        self.assertEqual(ChangesetComment.query().count(), 1)

        response.mustcontain('''<div class="comments-number">%s '''

                             '''comment (0 inline)</div>''' % 1)

        self.assertEqual(Notification.query().count(), 2)

        users = [x.user.username for x in UserNotification.query().all()]

        self.assertEqual(sorted(users), [u'test_admin', u'test_regular'])

    def test_delete(self):

        self.log_user()

        rev = '27cd5cce30c96924232dffcd24178a07ffeb5dfc'

        text = u'CommentOnRevision'

        params = {'text': text}

        response = self.app.post(url(controller='changeset', action='comment',

                                     repo_name=HG_REPO, revision=rev),

                                     params=params)

        a1_auth = AuthUser(user_id=self.a1.user_id)

        perms = {

            'repositories_groups': {},

            'global': set([u'hg.admin']),

            'repositories': {u'vcs_test_hg': u'repository.admin'}

        }

        self.assertEqual(a1_auth.permissions['repositories'][HG_REPO],

                         perms['repositories'][HG_REPO])

        new_perm = 'repository.write'

        RepoModel().grant_user_permission(repo=HG_REPO, user=self.a1,

                                          perm=new_perm)

        Session().commit()

        # admin !

        u1_auth = AuthUser(user_id=self.a1.user_id)

        self.assertEqual(u1_auth.permissions['repositories'][HG_REPO],

                         perms['repositories'][HG_REPO])

    def test_default_group_perms(self):

        self.g1 = fixture.create_group('test1', skip_if_exists=True)

        self.g2 = fixture.create_group('test2', skip_if_exists=True)