<%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>

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

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

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

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

# 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

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

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

              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:

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

        :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;')\

  #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

        )

        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)

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

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

        except OSError, e:

            raise RepositoryError(e.strerror)

    @LazyProperty

    def bookmarks(self):

        """

        """

        return {}

    @LazyProperty

    def _parsed_refs(self):

        return self._get_parsed_refs()

            self.nodes[path] = node

        return self.nodes[path]

    @LazyProperty

    def affected_files(self):

        """

        """

        return self._ctx.files()

    @property

    def added(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

        """

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

    @LazyProperty

    def tags(self):

        """

        """

        return self._get_tags()

    def _get_tags(self):

        if self._empty:

            return {}

        except Abort, e:

            raise RepositoryError(e.message)

    @LazyProperty

    def bookmarks(self):

        """

        """

        return self._get_bookmarks()

    def _get_bookmarks(self):

        if self._empty:

            return {}

    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:

            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

        """

        Session().delete(comment)

        return comment

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

        """

        :param repo_id:

        :param revision:

        :param pull_request:

        """

        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 = 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']

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

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

            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

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

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

	}; // History.initCore

	// Try and Initialise History

	History.init();

        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'

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