"""Routes configuration

The more specific and detailed routes should be defined first so they

may take precedent over the more generic routes. For more information

refer to the routes manual at http://routes.groovie.org/docs/

"""

from routes import Mapper

def make_map(config):

    """Create, configure and return the routes Mapper"""

    map = Mapper(directory=config['pylons.paths']['controllers'],

                 always_scan=config['debug'])

    map.minimization = False

    map.explicit = False

    # 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

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

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

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

    #ADMIN

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

        m.connect('admin_home', '/', action='index')#main page

        m.connect('admin_add_repo', '/add_repo/{new_repo:[a-z0-9\. _-]*}',

                  action='add_repo')

    #FEEDS

                controller='feed', action='rss')

                controller='feed', action='atom')

    map.connect('login_home', '/login', controller='login')

    map.connect('logout_home', '/logout', controller='login', action='logout')

                controller='changeset', revision='tip')

                controller='summary')

                controller='shortlog')

                controller='branches')

                controller='tags')

                controller='changelog')    

                controller='files', revision='tip', f_path='')

                controller='files', action='diff', revision='tip', f_path='')

                controller='files', action='rawfile', revision='tip', f_path='')

                controller='files', action='annotate', revision='tip', f_path='')    

                controller='files', action='archivefile', revision='tip')

    return map

from pylons import request, response, session, tmpl_context as c, url, \

    app_globals as g

from pylons.controllers.util import abort, redirect

from pylons_app.lib.auth import LoginRequired

from pylons_app.lib.base import BaseController, render

from pylons_app.lib.filters import clean_repo

from pylons_app.lib.utils import check_repo, invalidate_cache

from pylons_app.model.hg_model import HgModel

import logging

import os

import shutil

from operator import itemgetter

log = logging.getLogger(__name__)

class ReposController(BaseController):

    """REST Controller styled on the Atom Publishing Protocol"""

    # To properly map this controller, ensure your config/routing.py

    # file has a resource setup:

    #     map.resource('repo', 'repos')

    @LoginRequired()

    def __before__(self):

        c.admin_user = session.get('admin_user')

        c.admin_username = session.get('admin_username')

        super(ReposController, self).__before__()

    def index(self, format='html'):

        """GET /repos: All items in the collection"""

        # url('repos')

        cached_repo_list = HgModel().get_repos()

        c.repos_list = sorted(cached_repo_list, key=itemgetter('name_sort'))

        return render('admin/repos/repos.html')

    def create(self):

        """POST /repos: Create a new item"""

        # url('repos')

        name = request.POST.get('name')

        try:

            self._create_repo(name)

            #clear our cached list for refresh with new repo

            invalidate_cache('cached_repo_list')

        except Exception as e:

            log.error(e)

        return redirect('repos')

    def _create_repo(self, repo_name):        

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

        if check_repo(repo_name, g.base_path):

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

            from vcs.backends.hg import MercurialRepository

            MercurialRepository(repo_path, create=True)

    def new(self, format='html'):

        """GET /repos/new: Form to create a new item"""

        new_repo = request.GET.get('repo', '')

        c.new_repo = clean_repo(new_repo)

        return render('admin/repos/repo_add.html')

    def update(self, id):

        """PUT /repos/id: Update an existing item"""

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

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

        # Or using helpers:

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

        #           method='put')

        # url('repo', id=ID)

    def delete(self, id):

        """DELETE /repos/id: 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', id=ID),

        #           method='delete')

        # url('repo', id=ID)

        from datetime import datetime

        path = g.paths[0][1].replace('*', '')

        rm_path = os.path.join(path, id)

        log.info("Removing %s", rm_path)

        shutil.move(os.path.join(rm_path, '.hg'), os.path.join(rm_path, 'rm__.hg'))

        shutil.move(rm_path, os.path.join(path, 'rm__%s-%s' % (datetime.today(), id)))

        #clear our cached list for refresh with new repo

        invalidate_cache('cached_repo_list')

        return redirect(url('repos'))

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

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

        # url('repo', id=ID)

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

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

        # url('edit_repo', id=ID)

        c.new_repo = id

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

#

"""

Created on 2010-04-28

@author: marcink

SimpleHG middleware for handling mercurial protocol request (push/clone etc.)

It's implemented with basic auth function

"""

from datetime import datetime

from mercurial.hgweb import hgweb

from mercurial.hgweb.request import wsgiapplication

from paste.auth.basic import AuthBasicAuthenticator

from paste.httpheaders import REMOTE_USER, AUTH_TYPE

from pylons_app.lib.auth import authfunc

from pylons_app.lib.utils import is_mercurial, make_ui, invalidate_cache

from pylons_app.model import meta

from pylons_app.model.db import UserLog, User

from webob.exc import HTTPNotFound

import logging

import os

log = logging.getLogger(__name__)

class SimpleHg(object):

    def __init__(self, application, config):

        self.application = application

        self.config = config

        #authenticate this mercurial request using 

        realm = '%s %s' % (config['hg_app_name'], 'mercurial repository')

        self.authenticate = AuthBasicAuthenticator(realm, authfunc)

    def __call__(self, environ, start_response):

        if not is_mercurial(environ):

            return self.application(environ, start_response)

        else:

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

            # AUTHENTICATE THIS MERCURIAL REQUEST

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

            username = REMOTE_USER(environ)

            if not username:

                result = self.authenticate(environ)

                if isinstance(result, str):

                    AUTH_TYPE.update(environ, 'basic')

                    REMOTE_USER.update(environ, result)

                else:

                    return result.wsgi_application(environ, start_response)

            try:

                return HTTPNotFound()(environ, start_response)

            #since we wrap into hgweb, just reset the path

            environ['PATH_INFO'] = '/'

            self.baseui = make_ui(self.config['hg_app_repo_conf'])

            self.basepath = self.baseui.configitems('paths')[0][1]\

                                                            .replace('*', '')

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

            try:

                app = wsgiapplication(self.__make_app)

            except Exception as e:

                return HTTPNotFound()(environ, start_response)

            action = self.__get_action(environ)            

            #invalidate cache on push

            if action == 'push':

                self.__invalidate_cache(repo_name)

            if action:

                username = self.__get_environ_user(environ)

                self.__log_user_action(username, action, repo_name)

            return app(environ, start_response)            

    def __make_app(self):

        hgserve = hgweb(self.repo_path)

        return  self.__load_web_settings(hgserve)

    def __get_environ_user(self, environ):

        return environ.get('REMOTE_USER')

    def __get_action(self, environ):

        """

        Maps mercurial request commands into a pull or push command.

        @param environ:

        """

        mapping = {

            'changegroup': 'pull',

            'changegroupsubset': 'pull',

            'unbundle': 'push',

            'stream_out': 'pull',

        }                    

        for qry in environ['QUERY_STRING'].split('&'):

            if qry.startswith('cmd'):

                cmd = qry.split('=')[-1]

                if mapping.has_key(cmd):

                    return mapping[cmd]

    def __log_user_action(self, username, action, repo):

        sa = meta.Session

        try:

            user = sa.query(User).filter(User.username == username).one()

            user_log = UserLog()

            user_log.user_id = user.user_id

            user_log.action = action

            user_log.repository = repo.replace('/', '')

            user_log.action_date = datetime.now()

            sa.add(user_log)

            sa.commit()

            log.info('Adding user %s, action %s on %s',

import os

import logging

from mercurial import ui, config, hg

from mercurial.error import RepoError

log = logging.getLogger(__name__)

def get_repo_slug(request):

def is_mercurial(environ):

    """

    Returns True if request's target is mercurial server - header

    ``HTTP_ACCEPT`` of such request would start with ``application/mercurial``.

    """

    http_accept = environ.get('HTTP_ACCEPT')

    if http_accept and http_accept.startswith('application/mercurial'):

        return True

    return False

def check_repo_dir(paths):

    repos_path = paths[0][1].split('/')

    if repos_path[-1] in ['*', '**']:

        repos_path = repos_path[:-1]

    if repos_path[0] != '/':

        repos_path[0] = '/'

    if not os.path.isdir(os.path.join(*repos_path)):

        raise Exception('Not a valid repository in %s' % paths[0][1])

def check_repo(repo_name, base_path):

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

    try:

        r = hg.repository(ui.ui(), repo_path)

        hg.verify(r)

        #here we hnow that repo exists it was verified

        log.info('%s repo is already created', repo_name)

        return False

        #raise Exception('Repo exists')

    except RepoError:

        log.info('%s repo is free for creation', repo_name)

        #it means that there is no valid repo there...

        return True

def make_ui(path=None, checkpaths=True):        

    """

    A funcion that will read python rc files and make an ui from read options

    @param path: path to mercurial config file

    """

    if not path:

        log.error('repos config path is empty !')

    if not os.path.isfile(path):

        log.warning('Unable to read config file %s' % path)

        return False

    cfg = config.config()

    cfg.read(path)

    if checkpaths:check_repo_dir(cfg.items('paths'))

    for section in sections:

        for k, v in cfg.items(section):

            baseui.setconfig(section, k, v)

    return baseui

def invalidate_cache(name, *args):

    """Invalidates given name cache"""

    from beaker.cache import region_invalidate

    log.info('INVALIDATING CACHE FOR %s', name)

    """propagate our arguments to make sure invalidation works. First

    argument has to be the name of cached func name give to cache decorator

    without that the invalidation would not work"""

    tmp = [name]

    tmp.extend(args)

    args = tuple(tmp)

    if name == 'cached_repo_list':

        from pylons_app.model.hg_model import _get_repos_cached

        region_invalidate(_get_repos_cached, None, *args)

    if name == 'full_changelog':

        from pylons_app.model.hg_model import _full_changelog_cached

        region_invalidate(_full_changelog_cached, None, *args)

from vcs.backends.base import BaseChangeset

from vcs.utils.lazy import LazyProperty

class EmptyChangeset(BaseChangeset):

    revision = -1

    @LazyProperty

    def raw_id(self):

        """

        Returns raw string identifing this changeset, useful for web

        representation.

        """

        return '0' * 12

def repo2db_mapper():

    """

    """

def _full_changelog_cached(repo_name):

    log.info('getting full changelog for %s', repo_name)

    return list(reversed(list(HgModel().get_repo(repo_name))))

class HgModel(object):

    """

    Mercurial Model

    """

    def __init__(self):

        """

        Constructor

        """

        pass

    @staticmethod

    def repo_scan(repos_prefix, repos_path, baseui):

        """

        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 it could take syntax with 

        * or ** for deep recursive displaying repositories

        """

        def check_repo_dir(path):

            """

            Checks the repository

            :param path:

            """

            repos_path = path.split('/')

            if repos_path[-1] in ['*', '**']:

                repos_path = repos_path[:-1]

            if repos_path[0] != '/':

                repos_path[0] = '/'

            if not os.path.isdir(os.path.join(*repos_path)):

                raise RepositoryError('Not a valid repository in %s' % path[0][1])        

        if not repos_path.endswith('*'):

            raise VCSError('You need to specify * or ** at the end of path '

                            'for recursive scanning')

        check_repo_dir(repos_path)

        log.info('scanning for repositories in %s', repos_path)

        repos = findrepos([(repos_prefix, repos_path)])

        if not isinstance(baseui, ui.ui):

            baseui = ui.ui()

        repos_list = {}

        for name, path in repos:

            try:

            except OSError:

                continue

        return repos_list

    def get_repos(self):

        for name, repo in _get_repos_cached().items():

            if repo._get_hidden():

                #skip hidden web repository

                continue

            last_change = repo.last_change

            try:

                tip = repo.get_changeset('tip')

            except RepositoryError:

                from pylons_app.lib.utils import EmptyChangeset

                tip = EmptyChangeset()

            tmp_d = {}

            tmp_d['name'] = repo.name

            tmp_d['name_sort'] = tmp_d['name'].lower()

            tmp_d['description'] = repo.description

            tmp_d['description_sort'] = tmp_d['description']

            tmp_d['last_change'] = last_change

            tmp_d['last_change_sort'] = last_change[1] - last_change[0]

            tmp_d['tip'] = tip.raw_id

            tmp_d['tip_sort'] = tip.revision 

            tmp_d['rev'] = tip.revision

            tmp_d['contact'] = repo.contact

            tmp_d['contact_sort'] = tmp_d['contact']

            tmp_d['repo_archives'] = list(repo._get_archives())

            yield tmp_d

    def get_repo(self, repo_name):

        return _get_repos_cached()[repo_name]