merge 1.3 into stable

init.d/celeryd-upstart.conf

@@ -0,0 +1,34 b''
+# celeryd - run the celeryd daemon as an upstart job for rhodecode
+# Change variables/paths as necessary and place file /etc/init/celeryd.conf
+# start/stop/restart as normal upstart job (ie: $ start celeryd)
+
+description	"Celery for RhodeCode Mercurial Server"
+author		"Matt Zuba <[e-mail]"
+
+start on starting rhodecode
+stop on stopped rhodecode
+
+respawn
+
+umask 0022
+
+env PIDFILE=/tmp/celeryd.pid
+env APPINI=/var/hg/rhodecode/production.ini
+env HOME=/var/hg
+env USER=hg
+# To use group (if different from user), you must edit sudoers file and change
+# root's entry from (ALL) to (ALL:ALL)
+# env GROUP=hg
+
+script
+    COMMAND="/var/hg/.virtualenvs/rhodecode/bin/paster celeryd $APPINI --pidfile=$PIDFILE"
+    if [ -z "$GROUP" ]; then
+        exec sudo -u $USER $COMMAND
+    else
+        exec sudo -u $USER -g $GROUP $COMMAND
+    fi
+end script
+
+post-stop script
+    rm -f $PIDFILE
+end script

init.d/rhodecode-upstart.conf

@@ -0,0 +1,26 b''
+# rhodecode - run the rhodecode daemon as an upstart job
+# Change variables/paths as necessary and place file /etc/init/rhodecode.conf
+# start/stop/restart as normal upstart job (ie: $ start rhodecode)
+
+description	"RhodeCode Mercurial Server"
+author		"Matt Zuba <[e-mail]"
+
+start on (local-filesystems and runlevel [2345])
+stop on runlevel [!2345]
+
+respawn
+
+umask 0022
+
+env PIDFILE=/var/hg/rhodecode/rhodecode.pid
+env LOGFILE=/var/hg/rhodecode/log/rhodecode.log
+env APPINI=/var/hg/rhodecode/production.ini
+env HOME=/var/hg
+env USER=hg
+env GROUP=hg
+
+exec /var/hg/.virtualenvs/rhodecode/bin/paster serve --user=$USER --group=$GROUP --pid-file=$PIDFILE --log-file=$LOGFILE $APPINI
+
+post-stop script
+	rm -f $PIDFILE
+end script

rhodecode/controllers/admin/notifications.py

@@ -0,0 +1,140 b''
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.controllers.admin.notifications
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    notifications controller for RhodeCode
+
+    :created_on: Nov 23, 2010
+    :author: marcink
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
+    :license: GPLv3, see COPYING for more details.
+"""
+# 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, either version 3 of the License, or
+# (at your option) any later version.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+import logging
+import traceback
+
+from pylons import request
+from pylons import tmpl_context as c, url
+from pylons.controllers.util import redirect
+
+from rhodecode.lib.base import BaseController, render
+from rhodecode.model.db import Notification
+
+from rhodecode.model.notification import NotificationModel
+from rhodecode.lib.auth import LoginRequired, NotAnonymous
+from rhodecode.lib import helpers as h
+from rhodecode.model.meta import Session
+
+
+log = logging.getLogger(__name__)
+
+
+class NotificationsController(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('notification', 'notifications', controller='_admin/notifications',
+    #         path_prefix='/_admin', name_prefix='_admin_')
+
+    @LoginRequired()
+    @NotAnonymous()
+    def __before__(self):
+        super(NotificationsController, self).__before__()
+
+    def index(self, format='html'):
+        """GET /_admin/notifications: All items in the collection"""
+        # url('notifications')
+        c.user = self.rhodecode_user
+        c.notifications = NotificationModel()\
+                            .get_for_user(self.rhodecode_user.user_id)
+        return render('admin/notifications/notifications.html')
+
+    def mark_all_read(self):
+        if request.environ.get('HTTP_X_PARTIAL_XHR'):
+            nm = NotificationModel()
+            # mark all read
+            nm.mark_all_read_for_user(self.rhodecode_user.user_id)
+            Session.commit()
+            c.user = self.rhodecode_user
+            c.notifications = nm.get_for_user(self.rhodecode_user.user_id)
+            return render('admin/notifications/notifications_data.html')
+
+    def create(self):
+        """POST /_admin/notifications: Create a new item"""
+        # url('notifications')
+
+    def new(self, format='html'):
+        """GET /_admin/notifications/new: Form to create a new item"""
+        # url('new_notification')
+
+    def update(self, notification_id):
+        """PUT /_admin/notifications/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('notification', notification_id=ID),
+        #           method='put')
+        # url('notification', notification_id=ID)
+
+    def delete(self, notification_id):
+        """DELETE /_admin/notifications/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('notification', notification_id=ID),
+        #           method='delete')
+        # url('notification', notification_id=ID)
+
+        try:
+            no = Notification.get(notification_id)
+            owner = lambda: (no.notifications_to_users.user.user_id
+                             == c.rhodecode_user.user_id)
+            if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:
+                    NotificationModel().delete(c.rhodecode_user.user_id, no)
+                    Session.commit()
+                    return 'ok'
+        except Exception:
+            Session.rollback()
+            log.error(traceback.format_exc())
+        return 'fail'
+
+    def show(self, notification_id, format='html'):
+        """GET /_admin/notifications/id: Show a specific item"""
+        # url('notification', notification_id=ID)
+        c.user = self.rhodecode_user
+        no = Notification.get(notification_id)
+
+        owner = lambda: (no.notifications_to_users.user.user_id
+                         == c.user.user_id)
+        if no and (h.HasPermissionAny('hg.admin', 'repository.admin')() or owner):
+            unotification = NotificationModel()\
+                            .get_user_notification(c.user.user_id, no)
+
+            # if this association to user is not valid, we don't want to show
+            # this message
+            if unotification:
+                if unotification.read is False:
+                    unotification.mark_as_read()
+                    Session.commit()
+                c.notification = no
+
+                return render('admin/notifications/show_notification.html')
+
+        return redirect(url('notifications'))
+
+    def edit(self, notification_id, format='html'):
+        """GET /_admin/notifications/id/edit: Form to edit an existing item"""
+        # url('edit_notification', notification_id=ID)

rhodecode/controllers/bookmarks.py

@@ -0,0 +1,57 b''
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.controllers.bookmarks
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Bookmarks controller for rhodecode
+
+    :created_on: Dec 1, 2011
+    :author: marcink
+    :copyright: (C) 2011-2012 Marcin Kuzminski <[e-mail]>
+    :license: GPLv3, see COPYING for more details.
+"""
+# 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, either version 3 of the License, or
+# (at your option) any later version.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+import logging
+
+from pylons import tmpl_context as c
+
+from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
+from rhodecode.lib.base import BaseRepoController, render
+from rhodecode.lib.compat import OrderedDict
+from webob.exc import HTTPNotFound
+
+log = logging.getLogger(__name__)
+
+
+class BookmarksController(BaseRepoController):
+
+    @LoginRequired()
+    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
+                                   'repository.admin')
+    def __before__(self):
+        super(BookmarksController, self).__before__()
+
+    def index(self):
+        if c.rhodecode_repo.alias != 'hg':
+            raise HTTPNotFound()
+
+        c.repo_bookmarks = OrderedDict()
+
+        bookmarks = [(name, c.rhodecode_repo.get_changeset(hash_)) for \
+                 name, hash_ in c.rhodecode_repo._repo._bookmarks.items()]
+        ordered_tags = sorted(bookmarks, key=lambda x: x[1].date, reverse=True)
+        for name, cs_book in ordered_tags:
+            c.repo_bookmarks[name] = cs_book
+
+        return render('bookmarks/bookmarks.html')

rhodecode/lib/annotate.py

@@ -0,0 +1,190 b''
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.lib.annotate
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Anontation library for usage in rhodecode, previously part of vcs
+
+    :created_on: Dec 4, 2011
+    :author: marcink
+    :copyright: (C) 2011-2012 Marcin Kuzminski <[e-mail]>
+    :license: GPLv3, see COPYING for more details.
+"""
+
+from rhodecode.lib.vcs.exceptions import VCSError
+from rhodecode.lib.vcs.nodes import FileNode
+from pygments.formatters import HtmlFormatter
+from pygments import highlight
+
+import StringIO
+
+
+def annotate_highlight(filenode, annotate_from_changeset_func=None,
+        order=None, headers=None, **options):
+    """
+    Returns html portion containing annotated table with 3 columns: line
+    numbers, changeset information and pygmentized line of code.
+
+    :param filenode: FileNode object
+    :param annotate_from_changeset_func: function taking changeset and
+      returning single annotate cell; needs break line at the end
+    :param order: ordered sequence of ``ls`` (line numbers column),
+      ``annotate`` (annotate column), ``code`` (code column); Default is
+      ``['ls', 'annotate', 'code']``
+    :param headers: dictionary with headers (keys are whats in ``order``
+      parameter)
+    """
+    options['linenos'] = True
+    formatter = AnnotateHtmlFormatter(filenode=filenode, order=order,
+        headers=headers,
+        annotate_from_changeset_func=annotate_from_changeset_func, **options)
+    lexer = filenode.lexer
+    highlighted = highlight(filenode.content, lexer, formatter)
+    return highlighted
+
+
+class AnnotateHtmlFormatter(HtmlFormatter):
+
+    def __init__(self, filenode, annotate_from_changeset_func=None,
+            order=None, **options):
+        """
+        If ``annotate_from_changeset_func`` is passed it should be a function
+        which returns string from the given changeset. For example, we may pass
+        following function as ``annotate_from_changeset_func``::
+
+            def changeset_to_anchor(changeset):
+                return '<a href="/changesets/%s/">%s</a>\n' %\
+                       (changeset.id, changeset.id)
+
+        :param annotate_from_changeset_func: see above
+        :param order: (default: ``['ls', 'annotate', 'code']``); order of
+          columns;
+        :param options: standard pygment's HtmlFormatter options, there is
+          extra option tough, ``headers``. For instance we can pass::
+
+             formatter = AnnotateHtmlFormatter(filenode, headers={
+                'ls': '#',
+                'annotate': 'Annotate',
+                'code': 'Code',
+             })
+
+        """
+        super(AnnotateHtmlFormatter, self).__init__(**options)
+        self.annotate_from_changeset_func = annotate_from_changeset_func
+        self.order = order or ('ls', 'annotate', 'code')
+        headers = options.pop('headers', None)
+        if headers and not ('ls' in headers and 'annotate' in headers and
+            'code' in headers):
+            raise ValueError("If headers option dict is specified it must "
+                "all 'ls', 'annotate' and 'code' keys")
+        self.headers = headers
+        if isinstance(filenode, FileNode):
+            self.filenode = filenode
+        else:
+            raise VCSError("This formatter expect FileNode parameter, not %r"
+                % type(filenode))
+
+    def annotate_from_changeset(self, changeset):
+        """
+        Returns full html line for single changeset per annotated line.
+        """
+        if self.annotate_from_changeset_func:
+            return self.annotate_from_changeset_func(changeset)
+        else:
+            return ''.join((changeset.id, '\n'))
+
+    def _wrap_tablelinenos(self, inner):
+        dummyoutfile = StringIO.StringIO()
+        lncount = 0
+        for t, line in inner:
+            if t:
+                lncount += 1
+            dummyoutfile.write(line)
+
+        fl = self.linenostart
+        mw = len(str(lncount + fl - 1))
+        sp = self.linenospecial
+        st = self.linenostep
+        la = self.lineanchors
+        aln = self.anchorlinenos
+        if sp:
+            lines = []
+
+            for i in range(fl, fl + lncount):
+                if i % st == 0:
+                    if i % sp == 0:
+                        if aln:
+                            lines.append('<a href="#%s-%d" class="special">'
+                                         '%*d</a>' %
+                                         (la, i, mw, i))
+                        else:
+                            lines.append('<span class="special">'
+                                         '%*d</span>' % (mw, i))
+                    else:
+                        if aln:
+                            lines.append('<a href="#%s-%d">'
+                                         '%*d</a>' % (la, i, mw, i))
+                        else:
+                            lines.append('%*d' % (mw, i))
+                else:
+                    lines.append('')
+            ls = '\n'.join(lines)
+        else:
+            lines = []
+            for i in range(fl, fl + lncount):
+                if i % st == 0:
+                    if aln:
+                        lines.append('<a href="#%s-%d">%*d</a>' \
+                                     % (la, i, mw, i))
+                    else:
+                        lines.append('%*d' % (mw, i))
+                else:
+                    lines.append('')
+            ls = '\n'.join(lines)
+
+        annotate_changesets = [tup[1] for tup in self.filenode.annotate]
+        # If pygments cropped last lines break we need do that too
+        ln_cs = len(annotate_changesets)
+        ln_ = len(ls.splitlines())
+        if  ln_cs > ln_:
+            annotate_changesets = annotate_changesets[:ln_ - ln_cs]
+        annotate = ''.join((self.annotate_from_changeset(changeset)
+            for changeset in annotate_changesets))
+        # in case you wonder about the seemingly redundant <div> here:
+        # since the content in the other cell also is wrapped in a div,
+        # some browsers in some configurations seem to mess up the formatting.
+        '''
+        yield 0, ('<table class="%stable">' % self.cssclass +
+                  '<tr><td class="linenos"><div class="linenodiv"><pre>' +
+                  ls + '</pre></div></td>' +
+                  '<td class="code">')
+        yield 0, dummyoutfile.getvalue()
+        yield 0, '</td></tr></table>'
+
+        '''
+        headers_row = []
+        if self.headers:
+            headers_row = ['<tr class="annotate-header">']
+            for key in self.order:
+                td = ''.join(('<td>', self.headers[key], '</td>'))
+                headers_row.append(td)
+            headers_row.append('</tr>')
+
+        body_row_start = ['<tr>']
+        for key in self.order:
+            if key == 'ls':
+                body_row_start.append(
+                    '<td class="linenos"><div class="linenodiv"><pre>' +
+                    ls + '</pre></div></td>')
+            elif key == 'annotate':
+                body_row_start.append(
+                    '<td class="annotate"><div class="annotatediv"><pre>' +
+                    annotate + '</pre></div></td>')
+            elif key == 'code':
+                body_row_start.append('<td class="code">')
+        yield 0, ('<table class="%stable">' % self.cssclass +
+                  ''.join(headers_row) +
+                  ''.join(body_row_start)
+                  )
+        yield 0, dummyoutfile.getvalue()
+        yield 0, '</td></tr></table>'

rhodecode/lib/dbmigrate/schema/__init__.py

@@ -0,0 +1,14 b''
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.lib.dbmigrate.schema
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+    Schemas for migrations
+
+
+    :created_on: Nov 1, 2011
+    :author: marcink
+    :copyright: (C) 2009-2010 Marcin Kuzminski <[e-mail]>
+    :license: <name>, see LICENSE_FILE for more details.
+"""

rhodecode/lib/dbmigrate/schema/db_1_1_0.py

@@ -0,0 +1,94 b''
+from sqlalchemy import *
+from sqlalchemy.exc import DatabaseError
+from sqlalchemy.orm import relation, backref, class_mapper
+from sqlalchemy.orm.session import Session
+from rhodecode.model.meta import Base
+
+class BaseModel(object):
+    """Base Model for all classess
+
+    """
+
+    @classmethod
+    def _get_keys(cls):
+        """return column names for this model """
+        return class_mapper(cls).c.keys()
+
+    def get_dict(self):
+        """return dict with keys and values corresponding
+        to this model data """
+
+        d = {}
+        for k in self._get_keys():
+            d[k] = getattr(self, k)
+        return d
+
+    def get_appstruct(self):
+        """return list with keys and values tupples corresponding
+        to this model data """
+
+        l = []
+        for k in self._get_keys():
+            l.append((k, getattr(self, k),))
+        return l
+
+    def populate_obj(self, populate_dict):
+        """populate model with data from given populate_dict"""
+
+        for k in self._get_keys():
+            if k in populate_dict:
+                setattr(self, k, populate_dict[k])
+
+    @classmethod
+    def query(cls):
+        return Session.query(cls)
+
+    @classmethod
+    def get(cls, id_):
+        if id_:
+            return cls.query().get(id_)
+
+    @classmethod
+    def getAll(cls):
+        return cls.query().all()
+
+    @classmethod
+    def delete(cls, id_):
+        obj = cls.query().get(id_)
+        Session.delete(obj)
+        Session.commit()
+
+
+class UserFollowing(Base, BaseModel):
+    __tablename__ = 'user_followings'
+    __table_args__ = (UniqueConstraint('user_id', 'follows_repository_id'),
+                      UniqueConstraint('user_id', 'follows_user_id')
+                      , {'useexisting':True})
+
+    user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey(u'users.user_id'), nullable=False, unique=None, default=None)
+    follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey(u'repositories.repo_id'), nullable=True, unique=None, default=None)
+    follows_user_id = Column("follows_user_id", Integer(), ForeignKey(u'users.user_id'), nullable=True, unique=None, default=None)
+
+    user = relation('User', primaryjoin='User.user_id==UserFollowing.user_id')
+
+    follows_user = relation('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
+    follows_repository = relation('Repository')
+
+
+class CacheInvalidation(Base, BaseModel):
+    __tablename__ = 'cache_invalidation'
+    __table_args__ = (UniqueConstraint('cache_key'), {'useexisting':True})
+    cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    cache_key = Column("cache_key", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    cache_args = Column("cache_args", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
+
+
+    def __init__(self, cache_key, cache_args=''):
+        self.cache_key = cache_key
+        self.cache_args = cache_args
+        self.cache_active = False
+
+    def __repr__(self):
+        return "<CacheInvalidation('%s:%s')>" % (self.cache_id, self.cache_key)

rhodecode/lib/dbmigrate/schema/db_1_2_0.py

@@ -0,0 +1,1098 b''
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.model.db
+    ~~~~~~~~~~~~~~~~~~
+
+    Database Models for RhodeCode
+
+    :created_on: Apr 08, 2010
+    :author: marcink
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
+    :license: GPLv3, see COPYING for more details.
+"""
+# 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, either version 3 of the License, or
+# (at your option) any later version.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+import os
+import logging
+import datetime
+import traceback
+from datetime import date
+
+from sqlalchemy import *
+from sqlalchemy.ext.hybrid import hybrid_property
+from sqlalchemy.orm import relationship, joinedload, class_mapper, validates
+from beaker.cache import cache_region, region_invalidate
+
+from rhodecode.lib.vcs import get_backend
+from rhodecode.lib.vcs.utils.helpers import get_scm
+from rhodecode.lib.vcs.exceptions import VCSError
+from rhodecode.lib.vcs.utils.lazy import LazyProperty
+
+from rhodecode.lib import str2bool, safe_str, get_changeset_safe, \
+    generate_api_key, safe_unicode
+from rhodecode.lib.exceptions import UsersGroupsAssignedException
+from rhodecode.lib.compat import json
+
+from rhodecode.model.meta import Base, Session
+from rhodecode.lib.caching_query import FromCache
+
+
+log = logging.getLogger(__name__)
+
+#==============================================================================
+# BASE CLASSES
+#==============================================================================
+
+class ModelSerializer(json.JSONEncoder):
+    """
+    Simple Serializer for JSON,
+
+    usage::
+
+        to make object customized for serialization implement a __json__
+        method that will return a dict for serialization into json
+
+    example::
+
+        class Task(object):
+
+            def __init__(self, name, value):
+                self.name = name
+                self.value = value
+
+            def __json__(self):
+                return dict(name=self.name,
+                            value=self.value)
+
+    """
+
+    def default(self, obj):
+
+        if hasattr(obj, '__json__'):
+            return obj.__json__()
+        else:
+            return json.JSONEncoder.default(self, obj)
+
+class BaseModel(object):
+    """Base Model for all classess
+
+    """
+
+    @classmethod
+    def _get_keys(cls):
+        """return column names for this model """
+        return class_mapper(cls).c.keys()
+
+    def get_dict(self):
+        """return dict with keys and values corresponding
+        to this model data """
+
+        d = {}
+        for k in self._get_keys():
+            d[k] = getattr(self, k)
+        return d
+
+    def get_appstruct(self):
+        """return list with keys and values tupples corresponding
+        to this model data """
+
+        l = []
+        for k in self._get_keys():
+            l.append((k, getattr(self, k),))
+        return l
+
+    def populate_obj(self, populate_dict):
+        """populate model with data from given populate_dict"""
+
+        for k in self._get_keys():
+            if k in populate_dict:
+                setattr(self, k, populate_dict[k])
+
+    @classmethod
+    def query(cls):
+        return Session.query(cls)
+
+    @classmethod
+    def get(cls, id_):
+        if id_:
+            return cls.query().get(id_)
+
+    @classmethod
+    def getAll(cls):
+        return cls.query().all()
+
+    @classmethod
+    def delete(cls, id_):
+        obj = cls.query().get(id_)
+        Session.delete(obj)
+        Session.commit()
+
+
+class RhodeCodeSetting(Base, BaseModel):
+    __tablename__ = 'rhodecode_settings'
+    __table_args__ = (UniqueConstraint('app_settings_name'), {'extend_existing':True})
+    app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    app_settings_name = Column("app_settings_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    _app_settings_value = Column("app_settings_value", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+
+    def __init__(self, k='', v=''):
+        self.app_settings_name = k
+        self.app_settings_value = v
+
+
+    @validates('_app_settings_value')
+    def validate_settings_value(self, key, val):
+        assert type(val) == unicode
+        return val
+
+    @hybrid_property
+    def app_settings_value(self):
+        v = self._app_settings_value
+        if v == 'ldap_active':
+            v = str2bool(v)
+        return v
+
+    @app_settings_value.setter
+    def app_settings_value(self, val):
+        """
+        Setter that will always make sure we use unicode in app_settings_value
+
+        :param val:
+        """
+        self._app_settings_value = safe_unicode(val)
+
+    def __repr__(self):
+        return "<%s('%s:%s')>" % (self.__class__.__name__,
+                                  self.app_settings_name, self.app_settings_value)
+
+
+    @classmethod
+    def get_by_name(cls, ldap_key):
+        return cls.query()\
+            .filter(cls.app_settings_name == ldap_key).scalar()
+
+    @classmethod
+    def get_app_settings(cls, cache=False):
+
+        ret = cls.query()
+
+        if cache:
+            ret = ret.options(FromCache("sql_cache_short", "get_hg_settings"))
+
+        if not ret:
+            raise Exception('Could not get application settings !')
+        settings = {}
+        for each in ret:
+            settings['rhodecode_' + each.app_settings_name] = \
+                each.app_settings_value
+
+        return settings
+
+    @classmethod
+    def get_ldap_settings(cls, cache=False):
+        ret = cls.query()\
+                .filter(cls.app_settings_name.startswith('ldap_')).all()
+        fd = {}
+        for row in ret:
+            fd.update({row.app_settings_name:row.app_settings_value})
+
+        return fd
+
+
+class RhodeCodeUi(Base, BaseModel):
+    __tablename__ = 'rhodecode_ui'
+    __table_args__ = (UniqueConstraint('ui_key'), {'extend_existing':True})
+
+    HOOK_UPDATE = 'changegroup.update'
+    HOOK_REPO_SIZE = 'changegroup.repo_size'
+    HOOK_PUSH = 'pretxnchangegroup.push_logger'
+    HOOK_PULL = 'preoutgoing.pull_logger'
+
+    ui_id = Column("ui_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    ui_section = Column("ui_section", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    ui_key = Column("ui_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    ui_value = Column("ui_value", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    ui_active = Column("ui_active", Boolean(), nullable=True, unique=None, default=True)
+
+
+    @classmethod
+    def get_by_key(cls, key):
+        return cls.query().filter(cls.ui_key == key)
+
+
+    @classmethod
+    def get_builtin_hooks(cls):
+        q = cls.query()
+        q = q.filter(cls.ui_key.in_([cls.HOOK_UPDATE,
+                                    cls.HOOK_REPO_SIZE,
+                                    cls.HOOK_PUSH, cls.HOOK_PULL]))
+        return q.all()
+
+    @classmethod
+    def get_custom_hooks(cls):
+        q = cls.query()
+        q = q.filter(~cls.ui_key.in_([cls.HOOK_UPDATE,
+                                    cls.HOOK_REPO_SIZE,
+                                    cls.HOOK_PUSH, cls.HOOK_PULL]))
+        q = q.filter(cls.ui_section == 'hooks')
+        return q.all()
+
+    @classmethod
+    def create_or_update_hook(cls, key, val):
+        new_ui = cls.get_by_key(key).scalar() or cls()
+        new_ui.ui_section = 'hooks'
+        new_ui.ui_active = True
+        new_ui.ui_key = key
+        new_ui.ui_value = val
+
+        Session.add(new_ui)
+        Session.commit()
+
+
+class User(Base, BaseModel):
+    __tablename__ = 'users'
+    __table_args__ = (UniqueConstraint('username'), UniqueConstraint('email'), {'extend_existing':True})
+    user_id = Column("user_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    username = Column("username", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    password = Column("password", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    active = Column("active", Boolean(), nullable=True, unique=None, default=None)
+    admin = Column("admin", Boolean(), nullable=True, unique=None, default=False)
+    name = Column("name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    lastname = Column("lastname", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    email = Column("email", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    last_login = Column("last_login", DateTime(timezone=False), nullable=True, unique=None, default=None)
+    ldap_dn = Column("ldap_dn", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    api_key = Column("api_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+
+    user_log = relationship('UserLog', cascade='all')
+    user_perms = relationship('UserToPerm', primaryjoin="User.user_id==UserToPerm.user_id", cascade='all')
+
+    repositories = relationship('Repository')
+    user_followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_user_id==User.user_id', cascade='all')
+    repo_to_perm = relationship('UserRepoToPerm', primaryjoin='UserRepoToPerm.user_id==User.user_id', cascade='all')
+
+    group_member = relationship('UsersGroupMember', cascade='all')
+
+    @property
+    def full_contact(self):
+        return '%s %s <%s>' % (self.name, self.lastname, self.email)
+
+    @property
+    def short_contact(self):
+        return '%s %s' % (self.name, self.lastname)
+
+    @property
+    def is_admin(self):
+        return self.admin
+
+    def __repr__(self):
+        try:
+            return "<%s('id:%s:%s')>" % (self.__class__.__name__,
+                                             self.user_id, self.username)
+        except:
+            return self.__class__.__name__
+
+    @classmethod
+    def get_by_username(cls, username, case_insensitive=False):
+        if case_insensitive:
+            return Session.query(cls).filter(cls.username.ilike(username)).scalar()
+        else:
+            return Session.query(cls).filter(cls.username == username).scalar()
+
+    @classmethod
+    def get_by_api_key(cls, api_key):
+        return cls.query().filter(cls.api_key == api_key).one()
+
+    def update_lastlogin(self):
+        """Update user lastlogin"""
+
+        self.last_login = datetime.datetime.now()
+        Session.add(self)
+        Session.commit()
+        log.debug('updated user %s lastlogin' % self.username)
+
+    @classmethod
+    def create(cls, form_data):
+        from rhodecode.lib.auth import get_crypt_password
+
+        try:
+            new_user = cls()
+            for k, v in form_data.items():
+                if k == 'password':
+                    v = get_crypt_password(v)
+                setattr(new_user, k, v)
+
+            new_user.api_key = generate_api_key(form_data['username'])
+            Session.add(new_user)
+            Session.commit()
+            return new_user
+        except:
+            log.error(traceback.format_exc())
+            Session.rollback()
+            raise
+
+class UserLog(Base, BaseModel):
+    __tablename__ = 'user_logs'
+    __table_args__ = {'extend_existing':True}
+    user_log_id = Column("user_log_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
+    repository_name = Column("repository_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    user_ip = Column("user_ip", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    action = Column("action", UnicodeText(length=1200000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    action_date = Column("action_date", DateTime(timezone=False), nullable=True, unique=None, default=None)
+
+    @property
+    def action_as_day(self):
+        return date(*self.action_date.timetuple()[:3])
+
+    user = relationship('User')
+    repository = relationship('Repository')
+
+
+class UsersGroup(Base, BaseModel):
+    __tablename__ = 'users_groups'
+    __table_args__ = {'extend_existing':True}
+
+    users_group_id = Column("users_group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    users_group_name = Column("users_group_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)
+    users_group_active = Column("users_group_active", Boolean(), nullable=True, unique=None, default=None)
+
+    members = relationship('UsersGroupMember', cascade="all, delete, delete-orphan", lazy="joined")
+
+    def __repr__(self):
+        return '<userGroup(%s)>' % (self.users_group_name)
+
+    @classmethod
+    def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
+        if case_insensitive:
+            gr = cls.query()\
+                .filter(cls.users_group_name.ilike(group_name))
+        else:
+            gr = cls.query()\
+                .filter(cls.users_group_name == group_name)
+        if cache:
+            gr = gr.options(FromCache("sql_cache_short",
+                                          "get_user_%s" % group_name))
+        return gr.scalar()
+
+
+    @classmethod
+    def get(cls, users_group_id, cache=False):
+        users_group = cls.query()
+        if cache:
+            users_group = users_group.options(FromCache("sql_cache_short",
+                                    "get_users_group_%s" % users_group_id))
+        return users_group.get(users_group_id)
+
+    @classmethod
+    def create(cls, form_data):
+        try:
+            new_users_group = cls()
+            for k, v in form_data.items():
+                setattr(new_users_group, k, v)
+
+            Session.add(new_users_group)
+            Session.commit()
+            return new_users_group
+        except:
+            log.error(traceback.format_exc())
+            Session.rollback()
+            raise
+
+    @classmethod
+    def update(cls, users_group_id, form_data):
+
+        try:
+            users_group = cls.get(users_group_id, cache=False)
+
+            for k, v in form_data.items():
+                if k == 'users_group_members':
+                    users_group.members = []
+                    Session.flush()
+                    members_list = []
+                    if v:
+                        v = [v] if isinstance(v, basestring) else v
+                        for u_id in set(v):
+                            member = UsersGroupMember(users_group_id, u_id)
+                            members_list.append(member)
+                    setattr(users_group, 'members', members_list)
+                setattr(users_group, k, v)
+
+            Session.add(users_group)
+            Session.commit()
+        except:
+            log.error(traceback.format_exc())
+            Session.rollback()
+            raise
+
+    @classmethod
+    def delete(cls, users_group_id):
+        try:
+
+            # check if this group is not assigned to repo
+            assigned_groups = UsersGroupRepoToPerm.query()\
+                .filter(UsersGroupRepoToPerm.users_group_id ==
+                        users_group_id).all()
+
+            if assigned_groups:
+                raise UsersGroupsAssignedException('RepoGroup assigned to %s' %
+                                                   assigned_groups)
+
+            users_group = cls.get(users_group_id, cache=False)
+            Session.delete(users_group)
+            Session.commit()
+        except:
+            log.error(traceback.format_exc())
+            Session.rollback()
+            raise
+
+class UsersGroupMember(Base, BaseModel):
+    __tablename__ = 'users_groups_members'
+    __table_args__ = {'extend_existing':True}
+
+    users_group_member_id = Column("users_group_member_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+
+    user = relationship('User', lazy='joined')
+    users_group = relationship('UsersGroup')
+
+    def __init__(self, gr_id='', u_id=''):
+        self.users_group_id = gr_id
+        self.user_id = u_id
+
+    @staticmethod
+    def add_user_to_group(group, user):
+        ugm = UsersGroupMember()
+        ugm.users_group = group
+        ugm.user = user
+        Session.add(ugm)
+        Session.commit()
+        return ugm
+
+class Repository(Base, BaseModel):
+    __tablename__ = 'repositories'
+    __table_args__ = (UniqueConstraint('repo_name'), {'extend_existing':True},)
+
+    repo_id = Column("repo_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    repo_name = Column("repo_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)
+    clone_uri = Column("clone_uri", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=False, default=None)
+    repo_type = Column("repo_type", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=False, default='hg')
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=False, default=None)
+    private = Column("private", Boolean(), nullable=True, unique=None, default=None)
+    enable_statistics = Column("statistics", Boolean(), nullable=True, unique=None, default=True)
+    enable_downloads = Column("downloads", Boolean(), nullable=True, unique=None, default=True)
+    description = Column("description", String(length=10000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    created_on = Column('created_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
+
+    fork_id = Column("fork_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=False, default=None)
+    group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=False, default=None)
+
+
+    user = relationship('User')
+    fork = relationship('Repository', remote_side=repo_id)
+    group = relationship('RepoGroup')
+    repo_to_perm = relationship('UserRepoToPerm', cascade='all', order_by='UserRepoToPerm.repo_to_perm_id')
+    users_group_to_perm = relationship('UsersGroupRepoToPerm', cascade='all')
+    stats = relationship('Statistics', cascade='all', uselist=False)
+
+    followers = relationship('UserFollowing', primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', cascade='all')
+
+    logs = relationship('UserLog', cascade='all')
+
+    def __repr__(self):
+        return "<%s('%s:%s')>" % (self.__class__.__name__,
+                                  self.repo_id, self.repo_name)
+
+    @classmethod
+    def url_sep(cls):
+        return '/'
+
+    @classmethod
+    def get_by_repo_name(cls, repo_name):
+        q = Session.query(cls).filter(cls.repo_name == repo_name)
+        q = q.options(joinedload(Repository.fork))\
+                .options(joinedload(Repository.user))\
+                .options(joinedload(Repository.group))
+        return q.one()
+
+    @classmethod
+    def get_repo_forks(cls, repo_id):
+        return cls.query().filter(Repository.fork_id == repo_id)
+
+    @classmethod
+    def base_path(cls):
+        """
+        Returns base path when all repos are stored
+
+        :param cls:
+        """
+        q = Session.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key ==
+                                              cls.url_sep())
+        q.options(FromCache("sql_cache_short", "repository_repo_path"))
+        return q.one().ui_value
+
+    @property
+    def just_name(self):
+        return self.repo_name.split(Repository.url_sep())[-1]
+
+    @property
+    def groups_with_parents(self):
+        groups = []
+        if self.group is None:
+            return groups
+
+        cur_gr = self.group
+        groups.insert(0, cur_gr)
+        while 1:
+            gr = getattr(cur_gr, 'parent_group', None)
+            cur_gr = cur_gr.parent_group
+            if gr is None:
+                break
+            groups.insert(0, gr)
+
+        return groups
+
+    @property
+    def groups_and_repo(self):
+        return self.groups_with_parents, self.just_name
+
+    @LazyProperty
+    def repo_path(self):
+        """
+        Returns base full path for that repository means where it actually
+        exists on a filesystem
+        """
+        q = Session.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key ==
+                                              Repository.url_sep())
+        q.options(FromCache("sql_cache_short", "repository_repo_path"))
+        return q.one().ui_value
+
+    @property
+    def repo_full_path(self):
+        p = [self.repo_path]
+        # we need to split the name by / since this is how we store the
+        # names in the database, but that eventually needs to be converted
+        # into a valid system path
+        p += self.repo_name.split(Repository.url_sep())
+        return os.path.join(*p)
+
+    def get_new_name(self, repo_name):
+        """
+        returns new full repository name based on assigned group and new new
+
+        :param group_name:
+        """
+        path_prefix = self.group.full_path_splitted if self.group else []
+        return Repository.url_sep().join(path_prefix + [repo_name])
+
+    @property
+    def _ui(self):
+        """
+        Creates an db based ui object for this repository
+        """
+        from mercurial import ui
+        from mercurial import config
+        baseui = ui.ui()
+
+        #clean the baseui object
+        baseui._ocfg = config.config()
+        baseui._ucfg = config.config()
+        baseui._tcfg = config.config()
+
+
+        ret = RhodeCodeUi.query()\
+            .options(FromCache("sql_cache_short", "repository_repo_ui")).all()
+
+        hg_ui = ret
+        for ui_ in hg_ui:
+            if ui_.ui_active:
+                log.debug('settings ui from db[%s]%s:%s', ui_.ui_section,
+                          ui_.ui_key, ui_.ui_value)
+                baseui.setconfig(ui_.ui_section, ui_.ui_key, ui_.ui_value)
+
+        return baseui
+
+    @classmethod
+    def is_valid(cls, repo_name):
+        """
+        returns True if given repo name is a valid filesystem repository
+
+        :param cls:
+        :param repo_name:
+        """
+        from rhodecode.lib.utils import is_valid_repo
+
+        return is_valid_repo(repo_name, cls.base_path())
+
+
+    #==========================================================================
+    # SCM PROPERTIES
+    #==========================================================================
+
+    def get_changeset(self, rev):
+        return get_changeset_safe(self.scm_instance, rev)
+
+    @property
+    def tip(self):
+        return self.get_changeset('tip')
+
+    @property
+    def author(self):
+        return self.tip.author
+
+    @property
+    def last_change(self):
+        return self.scm_instance.last_change
+
+    #==========================================================================
+    # SCM CACHE INSTANCE
+    #==========================================================================
+
+    @property
+    def invalidate(self):
+        return CacheInvalidation.invalidate(self.repo_name)
+
+    def set_invalidate(self):
+        """
+        set a cache for invalidation for this instance
+        """
+        CacheInvalidation.set_invalidate(self.repo_name)
+
+    @LazyProperty
+    def scm_instance(self):
+        return self.__get_instance()
+
+    @property
+    def scm_instance_cached(self):
+        @cache_region('long_term')
+        def _c(repo_name):
+            return self.__get_instance()
+        rn = self.repo_name
+
+        inv = self.invalidate
+        if inv is not None:
+            region_invalidate(_c, None, rn)
+            # update our cache
+            CacheInvalidation.set_valid(inv.cache_key)
+        return _c(rn)
+
+    def __get_instance(self):
+
+        repo_full_path = self.repo_full_path
+
+        try:
+            alias = get_scm(repo_full_path)[0]
+            log.debug('Creating instance of %s repository' % alias)
+            backend = get_backend(alias)
+        except VCSError:
+            log.error(traceback.format_exc())
+            log.error('Perhaps this repository is in db and not in '
+                      'filesystem run rescan repositories with '
+                      '"destroy old data " option from admin panel')
+            return
+
+        if alias == 'hg':
+
+            repo = backend(safe_str(repo_full_path), create=False,
+                           baseui=self._ui)
+            # skip hidden web repository
+            if repo._get_hidden():
+                return
+        else:
+            repo = backend(repo_full_path, create=False)
+
+        return repo
+
+
+class RepoGroup(Base, BaseModel):
+    __tablename__ = 'groups'
+    __table_args__ = (UniqueConstraint('group_name', 'group_parent_id'),
+                      CheckConstraint('group_id != group_parent_id'), {'extend_existing':True},)
+    __mapper_args__ = {'order_by':'group_name'}
+
+    group_id = Column("group_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    group_name = Column("group_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)
+    group_parent_id = Column("group_parent_id", Integer(), ForeignKey('groups.group_id'), nullable=True, unique=None, default=None)
+    group_description = Column("group_description", String(length=10000, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+
+    parent_group = relationship('RepoGroup', remote_side=group_id)
+
+
+    def __init__(self, group_name='', parent_group=None):
+        self.group_name = group_name
+        self.parent_group = parent_group
+
+    def __repr__(self):
+        return "<%s('%s:%s')>" % (self.__class__.__name__, self.group_id,
+                                  self.group_name)
+
+    @classmethod
+    def groups_choices(cls):
+        from webhelpers.html import literal as _literal
+        repo_groups = [('', '')]
+        sep = ' &raquo; '
+        _name = lambda k: _literal(sep.join(k))
+
+        repo_groups.extend([(x.group_id, _name(x.full_path_splitted))
+                              for x in cls.query().all()])
+
+        repo_groups = sorted(repo_groups, key=lambda t: t[1].split(sep)[0])
+        return repo_groups
+
+    @classmethod
+    def url_sep(cls):
+        return '/'
+
+    @classmethod
+    def get_by_group_name(cls, group_name, cache=False, case_insensitive=False):
+        if case_insensitive:
+            gr = cls.query()\
+                .filter(cls.group_name.ilike(group_name))
+        else:
+            gr = cls.query()\
+                .filter(cls.group_name == group_name)
+        if cache:
+            gr = gr.options(FromCache("sql_cache_short",
+                                          "get_group_%s" % group_name))
+        return gr.scalar()
+
+    @property
+    def parents(self):
+        parents_recursion_limit = 5
+        groups = []
+        if self.parent_group is None:
+            return groups
+        cur_gr = self.parent_group
+        groups.insert(0, cur_gr)
+        cnt = 0
+        while 1:
+            cnt += 1
+            gr = getattr(cur_gr, 'parent_group', None)
+            cur_gr = cur_gr.parent_group
+            if gr is None:
+                break
+            if cnt == parents_recursion_limit:
+                # this will prevent accidental infinit loops
+                log.error('group nested more than %s' %
+                          parents_recursion_limit)
+                break
+
+            groups.insert(0, gr)
+        return groups
+
+    @property
+    def children(self):
+        return Group.query().filter(Group.parent_group == self)
+
+    @property
+    def name(self):
+        return self.group_name.split(Group.url_sep())[-1]
+
+    @property
+    def full_path(self):
+        return self.group_name
+
+    @property
+    def full_path_splitted(self):
+        return self.group_name.split(Group.url_sep())
+
+    @property
+    def repositories(self):
+        return Repository.query().filter(Repository.group == self)
+
+    @property
+    def repositories_recursive_count(self):
+        cnt = self.repositories.count()
+
+        def children_count(group):
+            cnt = 0
+            for child in group.children:
+                cnt += child.repositories.count()
+                cnt += children_count(child)
+            return cnt
+
+        return cnt + children_count(self)
+
+
+    def get_new_name(self, group_name):
+        """
+        returns new full group name based on parent and new name
+
+        :param group_name:
+        """
+        path_prefix = (self.parent_group.full_path_splitted if
+                       self.parent_group else [])
+        return Group.url_sep().join(path_prefix + [group_name])
+
+
+class Permission(Base, BaseModel):
+    __tablename__ = 'permissions'
+    __table_args__ = {'extend_existing':True}
+    permission_id = Column("permission_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    permission_name = Column("permission_name", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    permission_longname = Column("permission_longname", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+
+    def __repr__(self):
+        return "<%s('%s:%s')>" % (self.__class__.__name__,
+                                  self.permission_id, self.permission_name)
+
+    @classmethod
+    def get_by_key(cls, key):
+        return cls.query().filter(cls.permission_name == key).scalar()
+
+class UserRepoToPerm(Base, BaseModel):
+    __tablename__ = 'repo_to_perm'
+    __table_args__ = (UniqueConstraint('user_id', 'repository_id'), {'extend_existing':True})
+    repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
+
+    user = relationship('User')
+    permission = relationship('Permission')
+    repository = relationship('Repository')
+
+class UserToPerm(Base, BaseModel):
+    __tablename__ = 'user_to_perm'
+    __table_args__ = (UniqueConstraint('user_id', 'permission_id'), {'extend_existing':True})
+    user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+
+    user = relationship('User')
+    permission = relationship('Permission')
+
+    @classmethod
+    def has_perm(cls, user_id, perm):
+        if not isinstance(perm, Permission):
+            raise Exception('perm needs to be an instance of Permission class')
+
+        return cls.query().filter(cls.user_id == user_id)\
+            .filter(cls.permission == perm).scalar() is not None
+
+    @classmethod
+    def grant_perm(cls, user_id, perm):
+        if not isinstance(perm, Permission):
+            raise Exception('perm needs to be an instance of Permission class')
+
+        new = cls()
+        new.user_id = user_id
+        new.permission = perm
+        try:
+            Session.add(new)
+            Session.commit()
+        except:
+            Session.rollback()
+
+
+    @classmethod
+    def revoke_perm(cls, user_id, perm):
+        if not isinstance(perm, Permission):
+            raise Exception('perm needs to be an instance of Permission class')
+
+        try:
+            cls.query().filter(cls.user_id == user_id)\
+                .filter(cls.permission == perm).delete()
+            Session.commit()
+        except:
+            Session.rollback()
+
+class UsersGroupRepoToPerm(Base, BaseModel):
+    __tablename__ = 'users_group_repo_to_perm'
+    __table_args__ = (UniqueConstraint('repository_id', 'users_group_id', 'permission_id'), {'extend_existing':True})
+    users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)
+
+    users_group = relationship('UsersGroup')
+    permission = relationship('Permission')
+    repository = relationship('Repository')
+
+    def __repr__(self):
+        return '<userGroup:%s => %s >' % (self.users_group, self.repository)
+
+class UsersGroupToPerm(Base, BaseModel):
+    __tablename__ = 'users_group_to_perm'
+    __table_args__ = {'extend_existing':True}
+    users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+
+    users_group = relationship('UsersGroup')
+    permission = relationship('Permission')
+
+
+    @classmethod
+    def has_perm(cls, users_group_id, perm):
+        if not isinstance(perm, Permission):
+            raise Exception('perm needs to be an instance of Permission class')
+
+        return cls.query().filter(cls.users_group_id ==
+                                         users_group_id)\
+                                         .filter(cls.permission == perm)\
+                                         .scalar() is not None
+
+    @classmethod
+    def grant_perm(cls, users_group_id, perm):
+        if not isinstance(perm, Permission):
+            raise Exception('perm needs to be an instance of Permission class')
+
+        new = cls()
+        new.users_group_id = users_group_id
+        new.permission = perm
+        try:
+            Session.add(new)
+            Session.commit()
+        except:
+            Session.rollback()
+
+
+    @classmethod
+    def revoke_perm(cls, users_group_id, perm):
+        if not isinstance(perm, Permission):
+            raise Exception('perm needs to be an instance of Permission class')
+
+        try:
+            cls.query().filter(cls.users_group_id == users_group_id)\
+                .filter(cls.permission == perm).delete()
+            Session.commit()
+        except:
+            Session.rollback()
+
+
+class UserRepoGroupToPerm(Base, BaseModel):
+    __tablename__ = 'group_to_perm'
+    __table_args__ = (UniqueConstraint('group_id', 'permission_id'), {'extend_existing':True})
+
+    group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)
+    group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)
+
+    user = relationship('User')
+    permission = relationship('Permission')
+    group = relationship('RepoGroup')
+
+class Statistics(Base, BaseModel):
+    __tablename__ = 'statistics'
+    __table_args__ = (UniqueConstraint('repository_id'), {'extend_existing':True})
+    stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)
+    stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)
+    commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data
+    commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data
+    languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data
+
+    repository = relationship('Repository', single_parent=True)
+
+class UserFollowing(Base, BaseModel):
+    __tablename__ = 'user_followings'
+    __table_args__ = (UniqueConstraint('user_id', 'follows_repository_id'),
+                      UniqueConstraint('user_id', 'follows_user_id')
+                      , {'extend_existing':True})
+
+    user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None, default=None)
+    follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)
+    follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)
+    follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)
+
+    user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')
+
+    follows_user = relationship('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
+    follows_repository = relationship('Repository', order_by='Repository.repo_name')
+
+
+    @classmethod
+    def get_repo_followers(cls, repo_id):
+        return cls.query().filter(cls.follows_repo_id == repo_id)
+
+class CacheInvalidation(Base, BaseModel):
+    __tablename__ = 'cache_invalidation'
+    __table_args__ = (UniqueConstraint('cache_key'), {'extend_existing':True})
+    cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
+    cache_key = Column("cache_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    cache_args = Column("cache_args", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
+
+
+    def __init__(self, cache_key, cache_args=''):
+        self.cache_key = cache_key
+        self.cache_args = cache_args
+        self.cache_active = False
+
+    def __repr__(self):
+        return "<%s('%s:%s')>" % (self.__class__.__name__,
+                                  self.cache_id, self.cache_key)
+
+    @classmethod
+    def invalidate(cls, key):
+        """
+        Returns Invalidation object if this given key should be invalidated
+        None otherwise. `cache_active = False` means that this cache
+        state is not valid and needs to be invalidated
+
+        :param key:
+        """
+        return cls.query()\
+                .filter(CacheInvalidation.cache_key == key)\
+                .filter(CacheInvalidation.cache_active == False)\
+                .scalar()
+
+    @classmethod
+    def set_invalidate(cls, key):
+        """
+        Mark this Cache key for invalidation
+
+        :param key:
+        """
+
+        log.debug('marking %s for invalidation' % key)
+        inv_obj = Session.query(cls)\
+            .filter(cls.cache_key == key).scalar()
+        if inv_obj:
+            inv_obj.cache_active = False
+        else:
+            log.debug('cache key not found in invalidation db -> creating one')
+            inv_obj = CacheInvalidation(key)
+
+        try:
+            Session.add(inv_obj)
+            Session.commit()
+        except Exception:
+            log.error(traceback.format_exc())
+            Session.rollback()
+
+    @classmethod
+    def set_valid(cls, key):
+        """
+        Mark this cache key as active and currently cached
+
+        :param key:
+        """
+        inv_obj = Session.query(CacheInvalidation)\
+            .filter(CacheInvalidation.cache_key == key).scalar()
+        inv_obj.cache_active = True
+        Session.add(inv_obj)
+        Session.commit()
+
+class DbMigrateVersion(Base, BaseModel):
+    __tablename__ = 'db_migrate_version'
+    __table_args__ = {'extend_existing':True}
+    repository_id = Column('repository_id', String(250), primary_key=True)
+    repository_path = Column('repository_path', Text)
+    version = Column('version', Integer)

rhodecode/lib/dbmigrate/schema/db_1_3_0.py

@@ -0,0 +1,28 b''
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.model.db
+    ~~~~~~~~~~~~~~~~~~
+
+    Database Models for RhodeCode
+
+    :created_on: Apr 08, 2010
+    :author: marcink
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
+    :license: GPLv3, see COPYING for more details.
+"""
+# 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, either version 3 of the License, or
+# (at your option) any later version.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+#TODO: when branch 1.3 is finished replacem with db.py content
+
+from rhodecode.model.db import *

rhodecode/lib/dbmigrate/versions/004_version_1_3_0.py

@@ -0,0 +1,74 b''
+import logging
+import datetime
+
+from sqlalchemy import *
+from sqlalchemy.exc import DatabaseError
+from sqlalchemy.orm import relation, backref, class_mapper
+from sqlalchemy.orm.session import Session
+
+from rhodecode.lib.dbmigrate.migrate import *
+from rhodecode.lib.dbmigrate.migrate.changeset import *
+
+from rhodecode.model.meta import Base
+
+log = logging.getLogger(__name__)
+
+
+def upgrade(migrate_engine):
+    """ Upgrade operations go here.
+    Don't create your own engine; bind migrate_engine to your metadata
+    """
+    #==========================================================================
+    # Add table `users_group_repo_group_to_perm`
+    #==========================================================================
+    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import UsersGroupRepoGroupToPerm
+    UsersGroupRepoGroupToPerm().__table__.create()
+
+    #==========================================================================
+    # Add table `changeset_comments`
+    #==========================================================================
+    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import  ChangesetComment
+    ChangesetComment().__table__.create()
+
+    #==========================================================================
+    # Add table `notifications`
+    #==========================================================================
+    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import  Notification
+    Notification().__table__.create()
+
+    #==========================================================================
+    # Add table `user_to_notification`
+    #==========================================================================
+    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import  UserNotification
+    UserNotification().__table__.create()
+
+    #==========================================================================
+    # Add unique to table `users_group_to_perm`
+    #==========================================================================
+    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import UsersGroupToPerm
+    tbl = UsersGroupToPerm().__table__
+    cons = UniqueConstraint('users_group_id', 'permission_id', table=tbl)
+    cons.create()
+
+    #==========================================================================
+    # Fix unique constrain on table `user_logs`
+    #==========================================================================
+    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import UserLog
+    tbl = UserLog().__table__
+    col = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'),
+                 nullable=False, unique=None, default=None)
+    col.alter(nullable=True, table=tbl)
+
+    #==========================================================================
+    # Rename table `group_to_perm` to `user_repo_group_to_perm`
+    #==========================================================================
+    tbl = Table('group_to_perm', MetaData(bind=migrate_engine), autoload=True,
+                    autoload_with=migrate_engine)
+    tbl.rename('user_repo_group_to_perm')
+
+    return
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine

rhodecode/lib/dbmigrate/versions/005_version_1_3_0.py

@@ -0,0 +1,65 b''
+import logging
+import datetime
+
+from sqlalchemy import *
+from sqlalchemy.exc import DatabaseError
+from sqlalchemy.orm import relation, backref, class_mapper
+from sqlalchemy.orm.session import Session
+
+from rhodecode.lib.dbmigrate.migrate import *
+from rhodecode.lib.dbmigrate.migrate.changeset import *
+
+from rhodecode.model.meta import Base
+
+log = logging.getLogger(__name__)
+
+
+def upgrade(migrate_engine):
+    """ Upgrade operations go here.
+    Don't create your own engine; bind migrate_engine to your metadata
+    """
+
+    #==========================================================================
+    # Change unique constraints of table `repo_to_perm`
+    #==========================================================================
+    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import UserRepoToPerm
+    tbl = UserRepoToPerm().__table__
+    new_cons = UniqueConstraint('user_id', 'repository_id', 'permission_id', table=tbl)
+    new_cons.create()
+
+    if migrate_engine.name in ['mysql']:
+        old_cons = UniqueConstraint('user_id', 'repository_id', table=tbl, name="user_id")
+        old_cons.drop()
+    elif migrate_engine.name in ['postgresql']:
+        old_cons = UniqueConstraint('user_id', 'repository_id', table=tbl)
+        old_cons.drop()
+    else:
+        # sqlite doesn't support dropping constraints...
+        print """Please manually drop UniqueConstraint('user_id', 'repository_id')"""
+
+    #==========================================================================
+    # fix uniques of table `user_repo_group_to_perm`
+    #==========================================================================
+    from rhodecode.lib.dbmigrate.schema.db_1_3_0 import UserRepoGroupToPerm
+    tbl = UserRepoGroupToPerm().__table__
+    new_cons = UniqueConstraint('group_id', 'permission_id', 'user_id', table=tbl)
+    new_cons.create()
+
+    # fix uniqueConstraints
+    if migrate_engine.name in ['mysql']:
+        #mysql is givinig troubles here...
+        old_cons = UniqueConstraint('group_id', 'permission_id', table=tbl, name="group_id")
+        old_cons.drop()
+    elif migrate_engine.name in ['postgresql']:
+        old_cons = UniqueConstraint('group_id', 'permission_id', table=tbl, name='group_to_perm_group_id_permission_id_key')
+        old_cons.drop()
+    else:
+        # sqlite doesn't support dropping constraints...
+        print """Please manually drop UniqueConstraint('group_id', 'permission_id')"""
+
+    return
+
+
+def downgrade(migrate_engine):
+    meta = MetaData()
+    meta.bind = migrate_engine

rhodecode/lib/diffs.py

@@ -0,0 +1,517 b''
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.lib.diffs
+    ~~~~~~~~~~~~~~~~~~~
+
+    Set of diffing helpers, previously part of vcs
+
+
+    :created_on: Dec 4, 2011
+    :author: marcink
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
+    :original copyright: 2007-2008 by Armin Ronacher
+    :license: GPLv3, see COPYING for more details.
+"""
+# 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, either version 3 of the License, or
+# (at your option) any later version.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+import re
+import difflib
+import markupsafe
+from itertools import tee, imap
+
+from pylons.i18n.translation import _
+
+from rhodecode.lib.vcs.exceptions import VCSError
+from rhodecode.lib.vcs.nodes import FileNode
+
+from rhodecode.lib.utils import EmptyChangeset
+
+
+def wrap_to_table(str_):
+    return '''<table class="code-difftable">
+                <tr class="line no-comment">
+                <td class="lineno new"></td>
+                <td class="code no-comment"><pre>%s</pre></td>
+                </tr>
+              </table>''' % str_
+
+
+def wrapped_diff(filenode_old, filenode_new, cut_off_limit=None,
+                ignore_whitespace=True, line_context=3,
+                enable_comments=False):
+    """
+    returns a wrapped diff into a table, checks for cut_off_limit and presents
+    proper message
+    """
+
+    if filenode_old is None:
+        filenode_old = FileNode(filenode_new.path, '', EmptyChangeset())
+
+    if filenode_old.is_binary or filenode_new.is_binary:
+        diff = wrap_to_table(_('binary file'))
+        stats = (0, 0)
+        size = 0
+
+    elif cut_off_limit != -1 and (cut_off_limit is None or
+    (filenode_old.size < cut_off_limit and filenode_new.size < cut_off_limit)):
+
+        f_gitdiff = get_gitdiff(filenode_old, filenode_new,
+                                ignore_whitespace=ignore_whitespace,
+                                context=line_context)
+        diff_processor = DiffProcessor(f_gitdiff, format='gitdiff')
+
+        diff = diff_processor.as_html(enable_comments=enable_comments)
+        stats = diff_processor.stat()
+        size = len(diff or '')
+    else:
+        diff = wrap_to_table(_('Changeset was to big and was cut off, use '
+                               'diff menu to display this diff'))
+        stats = (0, 0)
+        size = 0
+
+    if not diff:
+        diff = wrap_to_table(_('No changes detected'))
+
+    cs1 = filenode_old.last_changeset.raw_id
+    cs2 = filenode_new.last_changeset.raw_id
+
+    return size, cs1, cs2, diff, stats
+
+
+def get_gitdiff(filenode_old, filenode_new, ignore_whitespace=True, context=3):
+    """
+    Returns git style diff between given ``filenode_old`` and ``filenode_new``.
+
+    :param ignore_whitespace: ignore whitespaces in diff
+    """
+    # make sure we pass in default context
+    context = context or 3
+
+    for filenode in (filenode_old, filenode_new):
+        if not isinstance(filenode, FileNode):
+            raise VCSError("Given object should be FileNode object, not %s"
+                % filenode.__class__)
+
+    repo = filenode_new.changeset.repository
+    old_raw_id = getattr(filenode_old.changeset, 'raw_id', repo.EMPTY_CHANGESET)
+    new_raw_id = getattr(filenode_new.changeset, 'raw_id', repo.EMPTY_CHANGESET)
+
+    vcs_gitdiff = repo.get_diff(old_raw_id, new_raw_id, filenode_new.path,
+                                 ignore_whitespace, context)
+
+    return vcs_gitdiff
+
+
+class DiffProcessor(object):
+    """
+    Give it a unified diff and it returns a list of the files that were
+    mentioned in the diff together with a dict of meta information that
+    can be used to render it in a HTML template.
+    """
+    _chunk_re = re.compile(r'@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)')
+
+    def __init__(self, diff, differ='diff', format='udiff'):
+        """
+        :param diff:   a text in diff format or generator
+        :param format: format of diff passed, `udiff` or `gitdiff`
+        """
+        if isinstance(diff, basestring):
+            diff = [diff]
+
+        self.__udiff = diff
+        self.__format = format
+        self.adds = 0
+        self.removes = 0
+
+        if isinstance(self.__udiff, basestring):
+            self.lines = iter(self.__udiff.splitlines(1))
+
+        elif self.__format == 'gitdiff':
+            udiff_copy = self.copy_iterator()
+            self.lines = imap(self.escaper, self._parse_gitdiff(udiff_copy))
+        else:
+            udiff_copy = self.copy_iterator()
+            self.lines = imap(self.escaper, udiff_copy)
+
+        # Select a differ.
+        if differ == 'difflib':
+            self.differ = self._highlight_line_difflib
+        else:
+            self.differ = self._highlight_line_udiff
+
+    def escaper(self, string):
+        return markupsafe.escape(string)
+
+    def copy_iterator(self):
+        """
+        make a fresh copy of generator, we should not iterate thru
+        an original as it's needed for repeating operations on
+        this instance of DiffProcessor
+        """
+        self.__udiff, iterator_copy = tee(self.__udiff)
+        return iterator_copy
+
+    def _extract_rev(self, line1, line2):
+        """
+        Extract the filename and revision hint from a line.
+        """
+
+        try:
+            if line1.startswith('--- ') and line2.startswith('+++ '):
+                l1 = line1[4:].split(None, 1)
+                old_filename = (l1[0].replace('a/', '', 1)
+                                if len(l1) >= 1 else None)
+                old_rev = l1[1] if len(l1) == 2 else 'old'
+
+                l2 = line2[4:].split(None, 1)
+                new_filename = (l2[0].replace('b/', '', 1)
+                                if len(l1) >= 1 else None)
+                new_rev = l2[1] if len(l2) == 2 else 'new'
+
+                filename = (old_filename
+                            if old_filename != '/dev/null' else new_filename)
+
+                return filename, new_rev, old_rev
+        except (ValueError, IndexError):
+            pass
+
+        return None, None, None
+
+    def _parse_gitdiff(self, diffiterator):
+        def line_decoder(l):
+            if l.startswith('+') and not l.startswith('+++'):
+                self.adds += 1
+            elif l.startswith('-') and not l.startswith('---'):
+                self.removes += 1
+            return l.decode('utf8', 'replace')
+
+        output = list(diffiterator)
+        size = len(output)
+
+        if size == 2:
+            l = []
+            l.extend([output[0]])
+            l.extend(output[1].splitlines(1))
+            return map(line_decoder, l)
+        elif size == 1:
+            return  map(line_decoder, output[0].splitlines(1))
+        elif size == 0:
+            return []
+
+        raise Exception('wrong size of diff %s' % size)
+
+    def _highlight_line_difflib(self, line, next_):
+        """
+        Highlight inline changes in both lines.
+        """
+
+        if line['action'] == 'del':
+            old, new = line, next_
+        else:
+            old, new = next_, line
+
+        oldwords = re.split(r'(\W)', old['line'])
+        newwords = re.split(r'(\W)', new['line'])
+
+        sequence = difflib.SequenceMatcher(None, oldwords, newwords)
+
+        oldfragments, newfragments = [], []
+        for tag, i1, i2, j1, j2 in sequence.get_opcodes():
+            oldfrag = ''.join(oldwords[i1:i2])
+            newfrag = ''.join(newwords[j1:j2])
+            if tag != 'equal':
+                if oldfrag:
+                    oldfrag = '<del>%s</del>' % oldfrag
+                if newfrag:
+                    newfrag = '<ins>%s</ins>' % newfrag
+            oldfragments.append(oldfrag)
+            newfragments.append(newfrag)
+
+        old['line'] = "".join(oldfragments)
+        new['line'] = "".join(newfragments)
+
+    def _highlight_line_udiff(self, line, next_):
+        """
+        Highlight inline changes in both lines.
+        """
+        start = 0
+        limit = min(len(line['line']), len(next_['line']))
+        while start < limit and line['line'][start] == next_['line'][start]:
+            start += 1
+        end = -1
+        limit -= start
+        while -end <= limit and line['line'][end] == next_['line'][end]:
+            end -= 1
+        end += 1
+        if start or end:
+            def do(l):
+                last = end + len(l['line'])
+                if l['action'] == 'add':
+                    tag = 'ins'
+                else:
+                    tag = 'del'
+                l['line'] = '%s<%s>%s</%s>%s' % (
+                    l['line'][:start],
+                    tag,
+                    l['line'][start:last],
+                    tag,
+                    l['line'][last:]
+                )
+            do(line)
+            do(next_)
+
+    def _parse_udiff(self):
+        """
+        Parse the diff an return data for the template.
+        """
+        lineiter = self.lines
+        files = []
+        try:
+            line = lineiter.next()
+            # skip first context
+            skipfirst = True
+            while 1:
+                # continue until we found the old file
+                if not line.startswith('--- '):
+                    line = lineiter.next()
+                    continue
+
+                chunks = []
+                filename, old_rev, new_rev = \
+                    self._extract_rev(line, lineiter.next())
+                files.append({
+                    'filename':         filename,
+                    'old_revision':     old_rev,
+                    'new_revision':     new_rev,
+                    'chunks':           chunks
+                })
+
+                line = lineiter.next()
+                while line:
+                    match = self._chunk_re.match(line)
+                    if not match:
+                        break
+
+                    lines = []
+                    chunks.append(lines)
+
+                    old_line, old_end, new_line, new_end = \
+                        [int(x or 1) for x in match.groups()[:-1]]
+                    old_line -= 1
+                    new_line -= 1
+                    context = len(match.groups()) == 5
+                    old_end += old_line
+                    new_end += new_line
+
+                    if context:
+                        if not skipfirst:
+                            lines.append({
+                                'old_lineno': '...',
+                                'new_lineno': '...',
+                                'action':     'context',
+                                'line':       line,
+                            })
+                        else:
+                            skipfirst = False
+
+                    line = lineiter.next()
+                    while old_line < old_end or new_line < new_end:
+                        if line:
+                            command, line = line[0], line[1:]
+                        else:
+                            command = ' '
+                        affects_old = affects_new = False
+
+                        # ignore those if we don't expect them
+                        if command in '#@':
+                            continue
+                        elif command == '+':
+                            affects_new = True
+                            action = 'add'
+                        elif command == '-':
+                            affects_old = True
+                            action = 'del'
+                        else:
+                            affects_old = affects_new = True
+                            action = 'unmod'
+
+                        old_line += affects_old
+                        new_line += affects_new
+                        lines.append({
+                            'old_lineno':   affects_old and old_line or '',
+                            'new_lineno':   affects_new and new_line or '',
+                            'action':       action,
+                            'line':         line
+                        })
+                        line = lineiter.next()
+
+        except StopIteration:
+            pass
+
+        # highlight inline changes
+        for _ in files:
+            for chunk in chunks:
+                lineiter = iter(chunk)
+                #first = True
+                try:
+                    while 1:
+                        line = lineiter.next()
+                        if line['action'] != 'unmod':
+                            nextline = lineiter.next()
+                            if nextline['action'] == 'unmod' or \
+                               nextline['action'] == line['action']:
+                                continue
+                            self.differ(line, nextline)
+                except StopIteration:
+                    pass
+
+        return files
+
+    def prepare(self):
+        """
+        Prepare the passed udiff for HTML rendering. It'l return a list
+        of dicts
+        """
+        return self._parse_udiff()
+
+    def _safe_id(self, idstring):
+        """Make a string safe for including in an id attribute.
+
+        The HTML spec says that id attributes 'must begin with
+        a letter ([A-Za-z]) and may be followed by any number
+        of letters, digits ([0-9]), hyphens ("-"), underscores
+        ("_"), colons (":"), and periods (".")'. These regexps
+        are slightly over-zealous, in that they remove colons
+        and periods unnecessarily.
+
+        Whitespace is transformed into underscores, and then
+        anything which is not a hyphen or a character that
+        matches \w (alphanumerics and underscore) is removed.
+
+        """
+        # Transform all whitespace to underscore
+        idstring = re.sub(r'\s', "_", '%s' % idstring)
+        # Remove everything that is not a hyphen or a member of \w
+        idstring = re.sub(r'(?!-)\W', "", idstring).lower()
+        return idstring
+
+    def raw_diff(self):
+        """
+        Returns raw string as udiff
+        """
+        udiff_copy = self.copy_iterator()
+        if self.__format == 'gitdiff':
+            udiff_copy = self._parse_gitdiff(udiff_copy)
+        return u''.join(udiff_copy)
+
+    def as_html(self, table_class='code-difftable', line_class='line',
+                new_lineno_class='lineno old', old_lineno_class='lineno new',
+                code_class='code', enable_comments=False):
+        """
+        Return udiff as html table with customized css classes
+        """
+        def _link_to_if(condition, label, url):
+            """
+            Generates a link if condition is meet or just the label if not.
+            """
+
+            if condition:
+                return '''<a href="%(url)s">%(label)s</a>''' % {
+                    'url': url,
+                    'label': label
+                }
+            else:
+                return label
+        diff_lines = self.prepare()
+        _html_empty = True
+        _html = []
+        _html.append('''<table class="%(table_class)s">\n''' % {
+            'table_class': table_class
+        })
+        for diff in diff_lines:
+            for line in diff['chunks']:
+                _html_empty = False
+                for change in line:
+                    _html.append('''<tr class="%(lc)s %(action)s">\n''' % {
+                        'lc': line_class,
+                        'action': change['action']
+                    })
+                    anchor_old_id = ''
+                    anchor_new_id = ''
+                    anchor_old = "%(filename)s_o%(oldline_no)s" % {
+                        'filename': self._safe_id(diff['filename']),
+                        'oldline_no': change['old_lineno']
+                    }
+                    anchor_new = "%(filename)s_n%(oldline_no)s" % {
+                        'filename': self._safe_id(diff['filename']),
+                        'oldline_no': change['new_lineno']
+                    }
+                    cond_old = (change['old_lineno'] != '...' and
+                                change['old_lineno'])
+                    cond_new = (change['new_lineno'] != '...' and
+                                change['new_lineno'])
+                    if cond_old:
+                        anchor_old_id = 'id="%s"' % anchor_old
+                    if cond_new:
+                        anchor_new_id = 'id="%s"' % anchor_new
+                    ###########################################################
+                    # OLD LINE NUMBER
+                    ###########################################################
+                    _html.append('''\t<td %(a_id)s class="%(olc)s">''' % {
+                        'a_id': anchor_old_id,
+                        'olc': old_lineno_class
+                    })
+
+                    _html.append('''%(link)s''' % {
+                        'link': _link_to_if(True, change['old_lineno'],
+                                            '#%s' % anchor_old)
+                    })
+                    _html.append('''</td>\n''')
+                    ###########################################################
+                    # NEW LINE NUMBER
+                    ###########################################################
+
+                    _html.append('''\t<td %(a_id)s class="%(nlc)s">''' % {
+                        'a_id': anchor_new_id,
+                        'nlc': new_lineno_class
+                    })
+
+                    _html.append('''%(link)s''' % {
+                        'link': _link_to_if(True, change['new_lineno'],
+                                            '#%s' % anchor_new)
+                    })
+                    _html.append('''</td>\n''')
+                    ###########################################################
+                    # CODE
+                    ###########################################################
+                    comments = '' if enable_comments else 'no-comment'
+                    _html.append('''\t<td class="%(cc)s %(inc)s">''' % {
+                        'cc': code_class,
+                        'inc': comments
+                    })
+                    _html.append('''\n\t\t<pre>%(code)s</pre>\n''' % {
+                        'code': change['line']
+                    })
+                    _html.append('''\t</td>''')
+                    _html.append('''\n</tr>\n''')
+        _html.append('''</table>''')
+        if _html_empty:
+            return None
+        return ''.join(_html)
+
+    def stat(self):
+        """
+        Returns tuple of added, and removed lines for this instance
+        """
+        return self.adds, self.removes

rhodecode/lib/markup_renderer.py

@@ -0,0 +1,137 b''
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.lib.markup_renderer
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+    Renderer for markup languages with ability to parse using rst or markdown
+
+    :created_on: Oct 27, 2011
+    :author: marcink
+    :copyright: (C) 2011-2012 Marcin Kuzminski <[e-mail]>
+    :license: GPLv3, see COPYING for more details.
+"""
+# 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, either version 3 of the License, or
+# (at your option) any later version.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+import re
+import logging
+
+from rhodecode.lib import safe_unicode
+
+log = logging.getLogger(__name__)
+
+
+class MarkupRenderer(object):
+    RESTRUCTUREDTEXT_DISALLOWED_DIRECTIVES = ['include', 'meta', 'raw']
+
+    MARKDOWN_PAT = re.compile(r'md|mkdn?|mdown|markdown', re.IGNORECASE)
+    RST_PAT = re.compile(r're?st', re.IGNORECASE)
+    PLAIN_PAT = re.compile(r'readme', re.IGNORECASE)
+
+    def __detect_renderer(self, source, filename=None):
+        """
+        runs detection of what renderer should be used for generating html
+        from a markup language
+
+        filename can be also explicitly a renderer name
+
+        :param source:
+        :param filename:
+        """
+
+        if MarkupRenderer.MARKDOWN_PAT.findall(filename):
+            detected_renderer = 'markdown'
+        elif MarkupRenderer.RST_PAT.findall(filename):
+            detected_renderer = 'rst'
+        elif MarkupRenderer.PLAIN_PAT.findall(filename):
+            detected_renderer = 'rst'
+        else:
+            detected_renderer = 'plain'
+
+        return getattr(MarkupRenderer, detected_renderer)
+
+    def render(self, source, filename=None):
+        """
+        Renders a given filename using detected renderer
+        it detects renderers based on file extension or mimetype.
+        At last it will just do a simple html replacing new lines with <br/>
+
+        :param file_name:
+        :param source:
+        """
+
+        renderer = self.__detect_renderer(source, filename)
+        readme_data = renderer(source)
+        return readme_data
+
+    @classmethod
+    def plain(cls, source):
+        source = safe_unicode(source)
+
+        def urlify_text(text):
+            url_pat = re.compile(r'(http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]'
+                                 '|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+)')
+
+            def url_func(match_obj):
+                url_full = match_obj.groups()[0]
+                return '<a href="%(url)s">%(url)s</a>' % ({'url': url_full})
+
+            return url_pat.sub(url_func, text)
+
+        source = urlify_text(source)
+        return '<br />' + source.replace("\n", '<br />')
+
+    @classmethod
+    def markdown(cls, source):
+        source = safe_unicode(source)
+        try:
+            import markdown as __markdown
+            return __markdown.markdown(source, ['codehilite'])
+        except ImportError:
+            log.warning('Install markdown to use this function')
+            return cls.plain(source)
+
+    @classmethod
+    def rst(cls, source):
+        source = safe_unicode(source)
+        try:
+            from docutils.core import publish_parts
+            from docutils.parsers.rst import directives
+            docutils_settings = dict([(alias, None) for alias in
+                                cls.RESTRUCTUREDTEXT_DISALLOWED_DIRECTIVES])
+
+            docutils_settings.update({'input_encoding': 'unicode',
+                                      'report_level': 4})
+
+            for k, v in docutils_settings.iteritems():
+                directives.register_directive(k, v)
+
+            parts = publish_parts(source=source,
+                                  writer_name="html4css1",
+                                  settings_overrides=docutils_settings)
+
+            return parts['html_title'] + parts["fragment"]
+        except ImportError:
+            log.warning('Install docutils to use this function')
+            return cls.plain(source)
+
+    @classmethod
+    def rst_with_mentions(cls, source):
+        mention_pat = re.compile(r'(?:^@|\s@)(\w+)')
+
+        def wrapp(match_obj):
+            uname = match_obj.groups()[0]
+            return ' **@%(uname)s** ' % {'uname':uname}
+        mention_hl = mention_pat.sub(wrapp, source).strip()
+        return cls.rst(mention_hl)

rhodecode/lib/rcmail/exceptions.py

@@ -0,0 +1,13 b''
+
+
+class InvalidMessage(RuntimeError):
+    """
+    Raised if message is missing vital headers, such
+    as recipients or sender address.
+    """
+
+
+class BadHeaders(RuntimeError):
+    """
+    Raised if message contains newlines in headers.
+    """

rhodecode/lib/rcmail/message.py

@@ -0,0 +1,182 b''
+from rhodecode.lib.rcmail.response import MailResponse
+
+from rhodecode.lib.rcmail.exceptions import BadHeaders
+from rhodecode.lib.rcmail.exceptions import InvalidMessage
+
+class Attachment(object):
+    """
+    Encapsulates file attachment information.
+
+    :param filename: filename of attachment
+    :param content_type: file mimetype
+    :param data: the raw file data, either as string or file obj
+    :param disposition: content-disposition (if any)
+    """
+
+    def __init__(self,
+                 filename=None,
+                 content_type=None,
+                 data=None,
+                 disposition=None):
+
+        self.filename = filename
+        self.content_type = content_type
+        self.disposition = disposition or 'attachment'
+        self._data = data
+
+    @property
+    def data(self):
+        if isinstance(self._data, basestring):
+            return self._data
+        self._data = self._data.read()
+        return self._data
+
+
+class Message(object):
+    """
+    Encapsulates an email message.
+
+    :param subject: email subject header
+    :param recipients: list of email addresses
+    :param body: plain text message
+    :param html: HTML message
+    :param sender: email sender address
+    :param cc: CC list
+    :param bcc: BCC list
+    :param extra_headers: dict of extra email headers
+    :param attachments: list of Attachment instances
+    :param recipients_separator: alternative separator for any of
+        'From', 'To', 'Delivered-To', 'Cc', 'Bcc' fields
+    """
+
+    def __init__(self,
+                 subject=None,
+                 recipients=None,
+                 body=None,
+                 html=None,
+                 sender=None,
+                 cc=None,
+                 bcc=None,
+                 extra_headers=None,
+                 attachments=None,
+                 recipients_separator="; "):
+
+        self.subject = subject or ''
+        self.sender = sender
+        self.body = body
+        self.html = html
+
+        self.recipients = recipients or []
+        self.attachments = attachments or []
+        self.cc = cc or []
+        self.bcc = bcc or []
+        self.extra_headers = extra_headers or {}
+
+        self.recipients_separator = recipients_separator
+
+    @property
+    def send_to(self):
+        return set(self.recipients) | set(self.bcc or ()) | set(self.cc or ())
+
+    def to_message(self):
+        """
+        Returns raw email.Message instance.Validates message first.
+        """
+
+        self.validate()
+
+        return self.get_response().to_message()
+
+    def get_response(self):
+        """
+        Creates a Lamson MailResponse instance
+        """
+
+        response = MailResponse(Subject=self.subject,
+                                To=self.recipients,
+                                From=self.sender,
+                                Body=self.body,
+                                Html=self.html,
+                                separator=self.recipients_separator)
+
+        if self.cc:
+            response.base['Cc'] = self.cc
+
+        for attachment in self.attachments:
+
+            response.attach(attachment.filename,
+                            attachment.content_type,
+                            attachment.data,
+                            attachment.disposition)
+
+        response.update(self.extra_headers)
+
+        return response
+
+    def is_bad_headers(self):
+        """
+        Checks for bad headers i.e. newlines in subject, sender or recipients.
+        """
+
+        headers = [self.subject, self.sender]
+        headers += list(self.send_to)
+        headers += self.extra_headers.values()
+
+        for val in headers:
+            for c in '\r\n':
+                if c in val:
+                    return True
+        return False
+
+    def validate(self):
+        """
+        Checks if message is valid and raises appropriate exception.
+        """
+
+        if not self.recipients:
+            raise InvalidMessage, "No recipients have been added"
+
+        if not self.body and not self.html:
+            raise InvalidMessage, "No body has been set"
+
+        if not self.sender:
+            raise InvalidMessage, "No sender address has been set"
+
+        if self.is_bad_headers():
+            raise BadHeaders
+
+    def add_recipient(self, recipient):
+        """
+        Adds another recipient to the message.
+
+        :param recipient: email address of recipient.
+        """
+
+        self.recipients.append(recipient)
+
+    def add_cc(self, recipient):
+        """
+        Adds an email address to the CC list.
+
+        :param recipient: email address of recipient.
+        """
+
+        self.cc.append(recipient)
+
+    def add_bcc(self, recipient):
+        """
+        Adds an email address to the BCC list.
+
+        :param recipient: email address of recipient.
+        """
+
+        self.bcc.append(recipient)
+
+    def attach(self, attachment):
+        """
+        Adds an attachment to the message.
+
+        :param attachment: an **Attachment** instance.
+        """
+
+        self.attachments.append(attachment)

.hgignore

@@ -1,6 +1,7 b''
 syntax: glob
 *.pyc
 *.swp
+*.sqlite
 *.egg-info
 *.egg
 
@@ -12,6 +13,9 b' syntax: regexp'
 ^\.settings$
 ^\.project$
 ^\.pydevproject$
+^\.coverage$
 ^rhodecode\.db$
 ^test\.db$
-^repositories\.config$
+^RhodeCode\.egg-info$
+^rc\.ini$
+^fabfile.py

CONTRIBUTORS

@@ -13,3 +13,6 b' List of contributors to RhodeCode projec'
     Ankit Solanki <[e-mail]>    
     Liad Shani <[e-mail]>
     Les Peabody <[e-mail]>
+    Jonas Oberschweiber <[e-mail]>
+    Matt Zuba <[e-mail]>
+    Aras Pranckevicius <[e-mail]>
  No newline at end of file

README.rst

@@ -1,22 +1,40 b''
-=================================================
-Welcome to RhodeCode (RhodiumCode) documentation!
-=================================================
+=========
+RhodeCode
+=========
 
-``RhodeCode`` is a Pylons framework based Mercurial repository 
-browser/management tool with a built in push/pull server and full text search.
+About
+-----
+
+``RhodeCode`` is a fast and powerful management tool for Mercurial_ and GIT_ 
+with a built in push/pull server and full text search and code-review.
 It works on http/https and has a built in permission/authentication system with 
-the ability to authenticate via LDAP or ActiveDirectory. RhodeCode also supports
-simple API so it's easy integrable with existing systems.
+the ability to authenticate via LDAP or ActiveDirectory. RhodeCode also provides
+simple API so it's easy integrable with existing external systems.
 
 RhodeCode is similar in some respects to github or bitbucket_, 
-however RhodeCode can be run as standalone hosted application on your own server.  
+however RhodeCode can be run as standalone hosted application on your own server.
 It is open source and donation ware and focuses more on providing a customized, 
-self administered interface for Mercurial(and soon GIT) repositories. 
+self administered interface for Mercurial and GIT repositories. 
 RhodeCode is powered by a vcs_ library that Lukasz Balcerzak and I created to 
 handle multiple different version control systems.
 
 RhodeCode uses `Semantic Versioning <http://semver.org/>`_
 
+Installation
+------------
+Stable releases of RhodeCode are best installed via::
+
+    easy_install rhodecode
+
+Or::
+
+    pip install rhodecode 
+
+Detailed instructions and links may be found on the Installation page.
+
+Please visit http://packages.python.org/RhodeCode/installation.html for
+more details
+
 RhodeCode demo
 --------------
 
@@ -45,16 +63,11 b' Sources at github_'
 
 https://github.com/marcinkuzminski/rhodecode
 
-Installation
-------------
-
-Please visit http://packages.python.org/RhodeCode/installation.html
-
 
 RhodeCode Features
 ------------------
 
-- Has it's own middleware to handle mercurial_ protocol requests. 
+- Has its own middleware to handle mercurial_ protocol requests. 
   Each request can be logged and authenticated.
 - Runs on threads unlike hgweb. You can make multiple pulls/pushes simultaneous.
   Supports http/https and LDAP
@@ -75,6 +88,9 b' RhodeCode Features'
 - Server side forks. It is possible to fork a project and modify it freely 
   without breaking the main repository. You can even write Your own hooks 
   and install them
+- code review with notification system, inline commenting, all parsed using
+  rst syntax
+- rst and markdown README support for repositories  
 - Full text search powered by Whoosh on the source files, and file names.
   Build in indexing daemons, with optional incremental index build
   (no external search servers required all in one application)
@@ -88,20 +104,14 b' RhodeCode Features'
   location 
 - Based on pylons / sqlalchemy / sqlite / whoosh / vcs
 
-
-.. include:: ./docs/screenshots.rst
-    
     
 Incoming / Plans
 ----------------
 
 - Finer granular permissions per branch, repo group or subrepo
 - pull requests and web based merges
-- notification and message system 
+- per line file history
 - SSH based authentication with server side key management
-- Code review (probably based on hg-review)
-- Full git_ support, with push/pull server (currently in beta tests)
-- Redmine and other bugtrackers integration
 - Commit based built in wiki system
 - More statistics and graph (global annotation + some more statistics)
 - Other advancements as development continues (or you can of course make 
@@ -113,21 +123,35 b' License'
 ``RhodeCode`` is released under the GPLv3 license.
 
 
-Mailing group Q&A
------------------
+Getting help
+------------
 
-Join the `Google group <http://groups.google.com/group/rhodecode>`_
+Listed bellow are various support resources that should help.
 
-Open an issue at `issue tracker <http://bitbucket.org/marcinkuzminski/rhodecode/issues>`_
+.. note::
+   
+   Please try to read the documentation before posting any issues
+ 
+- Join the `Google group <http://groups.google.com/group/rhodecode>`_ and ask
+  any questions.
 
-Join #rhodecode on FreeNode (irc.freenode.net)
-or use http://webchat.freenode.net/?channels=rhodecode for web access to irc.
+- Open an issue at `issue tracker <http://bitbucket.org/marcinkuzminski/rhodecode/issues>`_
+
+
+- Join #rhodecode on FreeNode (irc.freenode.net)
+  or use http://webchat.freenode.net/?channels=rhodecode for web access to irc.
+
+- You can also follow me on twitter @marcinkuzminski where i often post some
+  news about RhodeCode
+
 
 Online documentation
 --------------------
 
 Online documentation for the current version of RhodeCode is available at
-http://packages.python.org/RhodeCode/.
+ - http://packages.python.org/RhodeCode/
+ - http://rhodecode.readthedocs.org/en/latest/index.html
+
 You may also build the documentation for yourself - go into ``docs/`` and run::
 
    make html

development.ini

@@ -17,6 +17,7 b' pdebug = false'
 #error_email_from = paste_error@localhost
 #app_email_from = rhodecode-noreply@localhost
 #error_message =
+#email_prefix = [RhodeCode]
 
 #smtp_server = mail.server.com
 #smtp_username = 
@@ -32,7 +33,7 b' pdebug = false'
 threadpool_workers = 5
 
 ##max request before thread respawn
-threadpool_max_requests = 6
+threadpool_max_requests = 10
 
 ##option to use threads of process
 use_threadpool = true
@@ -45,14 +46,52 b' port = 5000'
 use = egg:rhodecode
 full_stack = true
 static_files = true
-lang=en
+lang = en
 cache_dir = %(here)s/data
 index_dir = %(here)s/data/index
-app_instance_uuid = develop
+app_instance_uuid = rc-develop
 cut_off_limit = 256000
 force_https = false
 commit_parse_limit = 25
 use_gravatar = true
+container_auth_enabled = false
+proxypass_auth_enabled = false
+default_encoding = utf8
+
+## overwrite schema of clone url
+## available vars:
+## scheme - http/https
+## user - current user
+## pass - password 
+## netloc - network location
+## path - usually repo_name
+
+#clone_uri = {scheme}://{user}{pass}{netloc}{path}
+
+## issue tracking mapping for commits messages
+## comment out issue_pat, issue_server, issue_prefix to enable
+
+## pattern to get the issues from commit messages
+## default one used here is #<numbers> with a regex passive group for `#`
+## {id} will be all groups matched from this pattern
+
+issue_pat = (?:\s*#)(\d+)
+
+## server url to the issue, each {id} will be replaced with match
+## fetched from the regex and {repo} is replaced with repository name
+
+issue_server_link = https://myissueserver.com/{repo}/issue/{id}
+
+## prefix to add to link to indicate it's an url
+## #314 will be replaced by <issue_prefix><id>
+
+issue_prefix = #
+
+## instance-id prefix
+## a prefix key for this instance used for cache invalidation when running 
+## multiple instances of rhodecode, make sure it's globally unique for 
+## all running rhodecode instances. Leave empty if you don't use it
+instance_id = 
 
 ####################################
 ###        CELERY CONFIG        ####
@@ -91,21 +130,27 b' beaker.cache.regions=super_short_term,sh'
 
 beaker.cache.super_short_term.type=memory
 beaker.cache.super_short_term.expire=10
+beaker.cache.super_short_term.key_length = 256
 
 beaker.cache.short_term.type=memory
 beaker.cache.short_term.expire=60
+beaker.cache.short_term.key_length = 256
 
 beaker.cache.long_term.type=memory
 beaker.cache.long_term.expire=36000
+beaker.cache.long_term.key_length = 256
 
 beaker.cache.sql_cache_short.type=memory
 beaker.cache.sql_cache_short.expire=10
+beaker.cache.sql_cache_short.key_length = 256
 
 beaker.cache.sql_cache_med.type=memory
 beaker.cache.sql_cache_med.expire=360
+beaker.cache.sql_cache_med.key_length = 256
 
 beaker.cache.sql_cache_long.type=file
 beaker.cache.sql_cache_long.expire=3600
+beaker.cache.sql_cache_long.key_length = 256
 
 ####################################
 ###       BEAKER SESSION        ####
@@ -113,12 +158,26 b' beaker.cache.sql_cache_long.expire=3600'
 ## Type of storage used for the session, current types are 
 ## dbm, file, memcached, database, and memory. 
 ## The storage uses the Container API 
-##that is also used by the cache system.
-beaker.session.type = file
+## that is also used by the cache system.
+
+## db session example
+
+#beaker.session.type = ext:database
+#beaker.session.sa.url = postgresql://postgres:qwe@localhost/rhodecode
+#beaker.session.table_name = db_session 
 
+## encrypted cookie session, good for many instances
+#beaker.session.type = cookie
+
+beaker.session.type = file
 beaker.session.key = rhodecode
-beaker.session.secret = g654dcno0-9873jhgfreyu
+#beaker.session.encrypt_key = g654dcno0-9873jhgfreyu
+#beaker.session.validate_key = 9712sds2212c--zxc123
 beaker.session.timeout = 36000
+beaker.session.httponly = true
+
+## uncomment for https secure cookie
+beaker.session.secure = false
 
 ##auto save the session to not to use .save()
 beaker.session.auto = False
@@ -126,7 +185,7 b' beaker.session.auto = False'
 ##true exire at browser close
 #beaker.session.cookie_expires = 3600
 
-    
+
 ################################################################################
 ## WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*  ##
 ## Debug mode will enable the interactive debugging tool, allowing ANYONE to  ##

docs/api/api.rst

@@ -26,16 +26,18 b' API ACCESS'
 
 All clients are required to send JSON-RPC spec JSON data::
 
-    {
+    {   
+        "id:<id>,
         "api_key":"<api_key>",
         "method":"<method_name>",
         "args":{"<arg_key>":"<arg_val>"}
     }
 
 Example call for autopulling remotes repos using curl::
-    curl https://server.com/_admin/api -X POST -H 'content-type:text/plain' --data-binary '{"api_key":"xe7cdb2v278e4evbdf5vs04v832v0efvcbcve4a3","method":"pull","args":{"repo":"CPython"}}'
+    curl https://server.com/_admin/api -X POST -H 'content-type:text/plain' --data-binary '{"id":1,"api_key":"xe7cdb2v278e4evbdf5vs04v832v0efvcbcve4a3","method":"pull","args":{"repo":"CPython"}}'
 
 Simply provide
+ - *id* A value of any type, which is used to match the response with the request that it is replying to.
  - *api_key* for access and permission validation.
  - *method* is name of method to call
  - *args* is an key:value list of arguments to pass to method
@@ -47,7 +49,8 b' Simply provide'
 
 RhodeCode API will return always a JSON-RPC response::
 
-    {
+    {   
+        "id":<id>,
         "result": "<result>",
         "error": null
     }
@@ -72,21 +75,55 b' INPUT::'
     api_key : "<api_key>"
     method :  "pull"
     args :    {
-                "repo" : "<repo_name>"
+                "repo_name" : "<reponame>"
               }
 
 OUTPUT::
 
-    result : "Pulled from <repo_name>"
+    result : "Pulled from <reponame>"
     error :  null
 
 
+get_user
+--------
+
+Get's an user by username or user_id, Returns empty result if user is not found.
+This command can be executed only using api_key belonging to user with admin 
+rights.
+
+
+INPUT::
+
+    api_key : "<api_key>"
+    method :  "get_user"
+    args :    { 
+                "userid" : "<username or user_id>"
+              }
+
+OUTPUT::
+
+    result: None if user does not exist or 
+            {
+                "id" :       "<id>",
+                "username" : "<username>",
+                "firstname": "<firstname>",
+                "lastname" : "<lastname>",
+                "email" :    "<email>",
+                "active" :   "<bool>",
+                "admin" :    "<bool>",
+                "ldap_dn" :  "<ldap_dn>"
+            }
+
+    error:  null
+
+
 get_users
 ---------
 
 Lists all existing users. This command can be executed only using api_key
 belonging to user with admin rights.
 
+
 INPUT::
 
     api_key : "<api_key>"
@@ -104,18 +141,20 b' OUTPUT::'
                 "email" :    "<email>",
                 "active" :   "<bool>",
                 "admin" :    "<bool>",
-                "ldap" :     "<ldap_dn>"
+                "ldap_dn" :  "<ldap_dn>"
               },
     	      …
             ]
     error:  null
 
+
 create_user
 -----------
 
-Creates new user or updates current one if such user exists. This command can 
+Creates new user. This command can 
 be executed only using api_key belonging to user with admin rights.
 
+
 INPUT::
 
     api_key : "<api_key>"
@@ -123,9 +162,9 b' INPUT::'
     args :    {
                 "username" :  "<username>",
                 "password" :  "<password>",
-                "firstname" : "<firstname>",
-                "lastname" :  "<lastname>",
-                "email" :     "<useremail>"
+                "email" :     "<useremail>",
+                "firstname" : "<firstname> = None",
+                "lastname" :  "<lastname> = None",
                 "active" :    "<bool> = True",
                 "admin" :     "<bool> = False",
                 "ldap_dn" :   "<ldap_dn> = None"
@@ -134,15 +173,88 b' INPUT::'
 OUTPUT::
 
     result: {
+              "id" : "<new_user_id>",
               "msg" : "created new user <username>"
             }
     error:  null
 
+
+update_user
+-----------
+
+updates current one if such user exists. This command can 
+be executed only using api_key belonging to user with admin rights.
+
+
+INPUT::
+
+    api_key : "<api_key>"
+    method :  "update_user"
+    args :    {
+                "userid" : "<user_id or username>",
+                "username" :  "<username>",
+                "password" :  "<password>",
+                "email" :     "<useremail>",
+                "firstname" : "<firstname>",
+                "lastname" :  "<lastname>",
+                "active" :    "<bool>",
+                "admin" :     "<bool>",
+                "ldap_dn" :   "<ldap_dn>"
+              }
+
+OUTPUT::
+
+    result: {
+              "id" : "<edited_user_id>",
+              "msg" : "updated user <username>"
+            }
+    error:  null
+
+
+get_users_group
+---------------
+
+Gets an existing users group. This command can be executed only using api_key
+belonging to user with admin rights.
+
+
+INPUT::
+
+    api_key : "<api_key>"
+    method :  "get_users_group"
+    args :    {
+                "group_name" : "<name>"
+              }
+
+OUTPUT::
+
+    result : None if group not exist
+             {
+               "id" :         "<id>",
+               "group_name" : "<groupname>",
+               "active":      "<bool>",
+               "members" :  [
+                              { "id" :       "<userid>",
+                                "username" : "<username>",
+                                "firstname": "<firstname>",
+                                "lastname" : "<lastname>",
+                                "email" :    "<email>",
+                                "active" :   "<bool>",
+                                "admin" :    "<bool>",
+                                "ldap" :     "<ldap_dn>"
+                              },
+                              …
+                            ]
+             }
+    error : null
+
+
 get_users_groups
 ----------------
 
-Lists all existing users groups. This command can be executed only using api_key
-belonging to user with admin rights.
+Lists all existing users groups. This command can be executed only using 
+api_key belonging to user with admin rights.
+
 
 INPUT::
 
@@ -154,9 +266,9 b' OUTPUT::'
 
     result : [
                {
-                 "id" :       "<id>",
-                 "name" :     "<name>",
-                 "active":    "<bool>",
+                 "id" :         "<id>",
+                 "group_name" : "<groupname>",
+                 "active":      "<bool>",
                  "members" :  [
 	    	                    {
 	    	                      "id" :       "<userid>",
@@ -174,41 +286,6 b' OUTPUT::'
               ]
     error : null
 
-get_users_group
----------------
-
-Gets an existing users group. This command can be executed only using api_key
-belonging to user with admin rights.
-
-INPUT::
-
-    api_key : "<api_key>"
-    method :  "get_users_group"
-    args :    {
-                "group_name" : "<name>"
-              }
-
-OUTPUT::
-
-    result : None if group not exist
-             {
-               "id" :       "<id>",
-               "name" :     "<name>",
-               "active":    "<bool>",
-               "members" :  [
-	    	                  { "id" :       "<userid>",
-	                            "username" : "<username>",
-	                            "firstname": "<firstname>",
-	                            "lastname" : "<lastname>",
-	                            "email" :    "<email>",
-	                            "active" :   "<bool>",
-	                            "admin" :    "<bool>",
-	                            "ldap" :     "<ldap_dn>"
-	                          },
-	    	                  …
-	                        ]
-             }
-    error : null
 
 create_users_group
 ------------------
@@ -216,12 +293,13 b' create_users_group'
 Creates new users group. This command can be executed only using api_key
 belonging to user with admin rights
 
+
 INPUT::
 
     api_key : "<api_key>"
     method :  "create_users_group"
     args:     {
-                "name":  "<name>",
+                "group_name":  "<groupname>",
                 "active":"<bool> = True"
               }
 
@@ -229,39 +307,120 b' OUTPUT::'
 
     result: {
               "id":  "<newusersgroupid>",
-              "msg": "created new users group <name>"
+              "msg": "created new users group <groupname>"
             }
     error:  null
 
+
 add_user_to_users_group
 -----------------------
 
-Adds a user to a users group. This command can be executed only using api_key
+Adds a user to a users group. If user exists in that group success will be 
+`false`. This command can be executed only using api_key
 belonging to user with admin rights
 
+
 INPUT::
 
     api_key : "<api_key>"
     method :  "add_user_users_group"
     args:     {
                 "group_name" :  "<groupname>",
-                "user_name" :   "<username>"
+                "username" :   "<username>"
               }
 
 OUTPUT::
 
     result: {
               "id":  "<newusersgroupmemberid>",
-              "msg": "created new users group member"
+              "success": True|False # depends on if member is in group
+              "msg": "added member <username> to users group <groupname> | 
+                      User is already in that group"
+            }
+    error:  null
+
+
+remove_user_from_users_group
+----------------------------
+
+Removes a user from a users group. If user is not in given group success will
+be `false`. This command can be executed only 
+using api_key belonging to user with admin rights
+
+
+INPUT::
+
+    api_key : "<api_key>"
+    method :  "remove_user_from_users_group"
+    args:     {
+                "group_name" :  "<groupname>",
+                "username" :   "<username>"
+              }
+
+OUTPUT::
+
+    result: {
+              "success":  True|False,  # depends on if member is in group
+              "msg": "removed member <username> from users group <groupname> | 
+                      User wasn't in group"
             }
     error:  null
 
+
+get_repo
+--------
+
+Gets an existing repository by it's name or repository_id. This command can 
+be executed only using api_key belonging to user with admin rights.
+
+
+INPUT::
+
+    api_key : "<api_key>"
+    method :  "get_repo"
+    args:     {
+                "repoid" : "<reponame or repo_id>"
+              }
+
+OUTPUT::
+
+    result: None if repository does not exist or
+            {
+                "id" :          "<id>",
+                "repo_name" :   "<reponame>"
+                "type" :        "<type>",
+                "description" : "<description>",
+                "members" :     [
+                                  { "id" :         "<userid>",
+                                    "username" :   "<username>",
+                                    "firstname":   "<firstname>",
+                                    "lastname" :   "<lastname>",
+                                    "email" :      "<email>",
+                                    "active" :     "<bool>",
+                                    "admin" :      "<bool>",
+                                    "ldap" :       "<ldap_dn>",
+                                    "permission" : "repository.(read|write|admin)"
+                                  },
+                                  …
+                                  {
+                                    "id" :       "<usersgroupid>",
+                                    "name" :     "<usersgroupname>",
+                                    "active":    "<bool>",
+                                    "permission" : "repository.(read|write|admin)"
+                                  },
+                                  …
+                                ]
+            }
+    error:  null
+
+
 get_repos
 ---------
 
 Lists all existing repositories. This command can be executed only using api_key
 belonging to user with admin rights
 
+
 INPUT::
 
     api_key : "<api_key>"
@@ -273,7 +432,7 b' OUTPUT::'
     result: [
               {
                 "id" :          "<id>",
-                "name" :        "<name>"
+                "repo_name" :   "<reponame>"
                 "type" :        "<type>",
                 "description" : "<description>"
               },
@@ -281,51 +440,39 b' OUTPUT::'
             ]
     error:  null
 
-get_repo
---------
+
+get_repo_nodes
+--------------
 
-Gets an existing repository. This command can be executed only using api_key
-belonging to user with admin rights
+returns a list of nodes and it's children in a flat list for a given path 
+at given revision. It's possible to specify ret_type to show only `files` or 
+`dirs`. This command can be executed only using api_key belonging to user 
+with admin rights
+
 
 INPUT::
 
     api_key : "<api_key>"
-    method :  "get_repo"
+    method :  "get_repo_nodes"
     args:     {
-                "name" : "<name>"
+                "repo_name" : "<reponame>",
+                "revision"  : "<revision>",
+                "root_path" : "<root_path>",
+                "ret_type"  : "<ret_type>" = 'all'
               }
 
 OUTPUT::
 
-    result: None if repository not exist
-            {
-                "id" :          "<id>",
+    result: [
+              {
                 "name" :        "<name>"
                 "type" :        "<type>",
-                "description" : "<description>",
-                "members" :     [
-                                  { "id" :         "<userid>",
-	                                "username" :   "<username>",
-	                                "firstname":   "<firstname>",
-	                                "lastname" :   "<lastname>",
-	                                "email" :      "<email>",
-	                                "active" :     "<bool>",
-	                                "admin" :      "<bool>",
-	                                "ldap" :       "<ldap_dn>",
-	                                "permission" : "repository.(read|write|admin)"
-	                              },
-                                  …
-                                  {
-                                    "id" :       "<usersgroupid>",
-                                    "name" :     "<usersgroupname>",
-                                    "active":    "<bool>",
-                                    "permission" : "repository.(read|write|admin)"
-                                  },
-                                  …
-                                ]
-            }
+              },
+              …
+            ]
     error:  null
 
+
 create_repo
 -----------
 
@@ -335,58 +482,146 b' If repository name contains "/", all nee'
 For example "foo/bar/baz" will create groups "foo", "bar" (with "foo" as parent),
 and create "baz" repository with "bar" as group.
 
+
 INPUT::
 
     api_key : "<api_key>"
     method :  "create_repo"
     args:     {
-                "name" :        "<name>",
+                "repo_name" :   "<reponame>",
                 "owner_name" :  "<ownername>",
                 "description" : "<description> = ''",
                 "repo_type" :   "<type> = 'hg'",
-                "private" :     "<bool> = False"
+                "private" :     "<bool> = False",
+                "clone_uri" :   "<clone_uri> = None",
               }
 
 OUTPUT::
 
-    result: None
+    result: {
+              "id": "<newrepoid>",
+              "msg": "Created new repository <reponame>",
+            }
     error:  null
 
-add_user_to_repo
-----------------
+
+delete_repo
+-----------
+
+Deletes a repository. This command can be executed only using api_key
+belonging to user with admin rights.
+
+
+INPUT::
+
+    api_key : "<api_key>"
+    method :  "delete_repo"
+    args:     {
+                "repo_name" :   "<reponame>",
+              }
 
-Add a user to a repository. This command can be executed only using api_key
-belonging to user with admin rights.
-If "perm" is None, user will be removed from the repository.
+OUTPUT::
+
+    result: {
+              "msg": "Deleted repository <reponame>",
+            }
+    error:  null
+
+
+grant_user_permission
+---------------------
+
+Grant permission for user on given repository, or update existing one
+if found. This command can be executed only using api_key belonging to user 
+with admin rights.
+
 
 INPUT::
 
     api_key : "<api_key>"
-    method :  "add_user_to_repo"
+    method :  "grant_user_permission"
     args:     {
                 "repo_name" :  "<reponame>",
-                "user_name" :  "<username>",
-                "perm" :       "(None|repository.(read|write|admin))",
+                "username" :   "<username>",
+                "perm" :       "(repository.(none|read|write|admin))",
+              }
+
+OUTPUT::
+
+    result: {
+              "msg" : "Granted perm: <perm> for user: <username> in repo: <reponame>"
+            }
+    error:  null
+
+
+revoke_user_permission
+----------------------
+
+Revoke permission for user on given repository. This command can be executed 
+only using api_key belonging to user with admin rights.
+
+
+INPUT::
+
+    api_key : "<api_key>"
+    method  : "revoke_user_permission"
+    args:     {
+                "repo_name" :  "<reponame>",
+                "username" :   "<username>",
               }
 
 OUTPUT::
 
-    result: None
+    result: {
+              "msg" : "Revoked perm for user: <suername> in repo: <reponame>"
+            }
     error:  null
 
-add_users_group_to_repo
------------------------
+
+grant_users_group_permission
+----------------------------
 
-Add a users group to a repository. This command can be executed only using 
-api_key belonging to user with admin rights. If "perm" is None, group will 
-be removed from the repository.
+Grant permission for users group on given repository, or update
+existing one if found. This command can be executed only using 
+api_key belonging to user with admin rights.
+
 
 INPUT::
 
     api_key : "<api_key>"
-    method :  "add_users_group_to_repo"
+    method :  "grant_users_group_permission"
+    args:     {
+                "repo_name" : "<reponame>",
+                "group_name" : "<usersgroupname>",
+                "perm" : "(repository.(none|read|write|admin))",
+              }
+
+OUTPUT::
+
+    result: {
+              "msg" : "Granted perm: <perm> for group: <usersgroupname> in repo: <reponame>"
+            }
+    error:  null
+    
+    
+revoke_users_group_permission
+-----------------------------
+
+Revoke permission for users group on given repository.This command can be 
+executed only using api_key belonging to user with admin rights.
+
+INPUT::
+
+    api_key : "<api_key>"
+    method  : "revoke_users_group_permission"
     args:     {
                 "repo_name" :  "<reponame>",
-                "group_name" :  "<groupname>",
-                "perm" :       "(None|repository.(read|write|admin))",
-              }
  No newline at end of file
+                "users_group" :   "<usersgroupname>",
+              }
+
+OUTPUT::
+
+    result: {
+              "msg" : "Revoked perm for group: <usersgroupname> in repo: <reponame>"
+            }
+    error:  null
  No newline at end of file

docs/api/models.rst

@@ -6,14 +6,29 b' The :mod:`models` Module'
 .. automodule:: rhodecode.model
    :members:
    
+.. automodule:: rhodecode.model.comment
+   :members:
+  
+.. automodule:: rhodecode.model.notification
+   :members:   
+
 .. automodule:: rhodecode.model.permission
    :members:
-  
+
+.. automodule:: rhodecode.model.repo_permission
+   :members:      
+
 .. automodule:: rhodecode.model.repo
    :members:   
 
+.. automodule:: rhodecode.model.repos_group
+   :members:
+   
 .. automodule:: rhodecode.model.scm
    :members:
-
+   
 .. automodule:: rhodecode.model.user
    :members:      
+   
+.. automodule:: rhodecode.model.users_group
+   :members:   
  No newline at end of file

docs/changelog.rst

@@ -4,14 +4,73 b' Changelog'
 =========
 
 
-1.2.5 (**2012-01-28**)
-======================
+1.3.0 (**2012-02-XX**)
+----------------------
+
+:status: in-progress
+:branch: beta
 
 news
-----
+++++
+
+- code review, inspired by github code-comments 
+- #215 rst and markdown README files support
+- #252 Container-based and proxy pass-through authentication support
+- #44 branch browser. Filtering of changelog by branches
+- mercurial bookmarks support
+- new hover top menu, optimized to add maximum size for important views
+- configurable clone url template with possibility to specify  protocol like 
+  ssh:// or http:// and also manually alter other parts of clone_url.
+- enabled largefiles extension by default
+- optimized summary file pages and saved a lot of unused space in them
+- #239 option to manually mark repository as fork
+- #320 mapping of commit authors to RhodeCode users
+- #304 hashes are displayed using monospace font    
+- diff configuration, toggle white lines and context lines
+- #307 configurable diffs, whitespace toggle, increasing context lines
+- sorting on branches, tags and bookmarks using YUI datatable
+- improved file filter on files page
+- implements #330 api method for listing nodes ar particular revision
+- #73 added linking issues in commit messages to chosen issue tracker url
+  based on user defined regular expression
+- added linking of changesets in commit messages  
+- new compact changelog with expandable commit messages
+- firstname and lastname are optional in user creation
+- #348 added post-create repository hook
+- #212 global encoding settings is now configurable from .ini files 
+- #227 added repository groups permissions
+- markdown gets codehilite extensions
+- new API methods, delete_repositories, grante/revoke permissions for groups 
+  and repos
+  
+    
+fixes
++++++
+
+- rewrote dbsession management for atomic operations, and better error handling
+- fixed sorting of repo tables
+- #326 escape of special html entities in diffs
+- normalized user_name => username in api attributes
+- fixes #298 ldap created users with mixed case emails created conflicts 
+  on saving a form
+- fixes issue when owner of a repo couldn't revoke permissions for users 
+  and groups
+- fixes #271 rare JSON serialization problem with statistics
+- fixes #337 missing validation check for conflicting names of a group with a
+  repositories group
+- #340 fixed session problem for mysql and celery tasks
+- fixed #331 RhodeCode mangles repository names if the a repository group 
+  contains the "full path" to the repositories
+- #355 RhodeCode doesn't store encrypted LDAP passwords
+
+1.2.5 (**2012-01-28**)
+----------------------
+
+news
+++++
 
 fixes
------
++++++
 
 - #340 Celery complains about MySQL server gone away, added session cleanup
   for celery tasks
@@ -24,10 +83,10 b' fixes'
   forking on windows impossible 
 
 1.2.4 (**2012-01-19**)
-======================
+----------------------
 
 news
-----
+++++
 
 - RhodeCode is bundled with mercurial series 2.0.X by default, with
   full support to largefiles extension. Enabled by default in new installations
@@ -35,7 +94,7 b' news'
 - added requires.txt file with requirements
      
 fixes
------
++++++
 
 - fixes db session issues with celery when emailing admins
 - #331 RhodeCode mangles repository names if the a repository group 
@@ -52,10 +111,10 b' fixes'
 - #316 fixes issues with web description in hgrc files 
 
 1.2.3 (**2011-11-02**)
-======================
+----------------------
 
 news
-----
+++++
 
 - added option to manage repos group for non admin users
 - added following API methods for get_users, create_user, get_users_groups, 
@@ -67,24 +126,23 b' news'
   administrator users, and global config email.
      
 fixes
------
++++++
 
 - added option for passing auth method for smtp mailer
 - #276 issue with adding a single user with id>10 to usergroups
 - #277 fixes windows LDAP settings in which missing values breaks the ldap auth 
 - #288 fixes managing of repos in a group for non admin user
 
-
 1.2.2 (**2011-10-17**)
-======================
+----------------------
 
 news
-----
+++++
 
 - #226 repo groups are available by path instead of numerical id
  
 fixes
------
++++++
 
 - #259 Groups with the same name but with different parent group
 - #260 Put repo in group, then move group to another group -> repo becomes unavailable
@@ -98,27 +156,25 b' fixes'
 - fixes #248 cannot edit repos inside a group on windows
 - fixes #219 forking problems on windows
 
-
 1.2.1 (**2011-10-08**)
-======================
+----------------------
 
 news
-----
+++++
 
 
 fixes
------
++++++
 
 - fixed problems with basic auth and push problems 
 - gui fixes
 - fixed logger
 
-
 1.2.0 (**2011-10-07**)
-======================
+----------------------
 
 news
-----
+++++
 
 - implemented #47 repository groups
 - implemented #89 Can setup google analytics code from settings menu
@@ -158,7 +214,7 b' news'
 - Implemented advanced hook management
 
 fixes
------
++++++
 
 - fixed file browser bug, when switching into given form revision the url was 
   not changing
@@ -185,18 +241,17 b' fixes'
 - fixes #218 os.kill patch for windows was missing sig param
 - improved rendering of dag (they are not trimmed anymore when number of 
   heads exceeds 5)
-
-
+    
 1.1.8 (**2011-04-12**)
-======================
+----------------------
 
 news
-----
+++++
 
 - improved windows support
 
 fixes
------
++++++
 
 - fixed #140 freeze of python dateutil library, since new version is python2.x
   incompatible
@@ -219,40 +274,40 b' fixes'
 
 
 1.1.7 (**2011-03-23**)
-======================
+----------------------
 
 news
-----
+++++
 
 fixes
------
++++++
 
 - fixed (again) #136 installation support for FreeBSD
 
 
 1.1.6 (**2011-03-21**)
-======================
+----------------------
 
 news
-----
+++++
 
 fixes
------
++++++
 
 - fixed #136 installation support for FreeBSD
 - RhodeCode will check for python version during installation
 
 1.1.5 (**2011-03-17**)
-======================
+----------------------
 
 news
-----
+++++
 
 - basic windows support, by exchanging pybcrypt into sha256 for windows only
   highly inspired by idea of mantis406
 
 fixes
------
++++++
 
 - fixed sorting by author in main page
 - fixed crashes with diffs on binary files
@@ -264,13 +319,13 b' fixes'
 - cleaned out docs, big thanks to Jason Harris
 
 1.1.4 (**2011-02-19**)
-======================
+----------------------
 
 news
-----
+++++
 
 fixes
------
++++++
 
 - fixed formencode import problem on settings page, that caused server crash
   when that page was accessed as first after server start
@@ -278,17 +333,17 b' fixes'
 - fixed option to access repository just by entering http://server/<repo_name> 
 
 1.1.3 (**2011-02-16**)
-======================
+----------------------
 
 news
-----
+++++
 
 - implemented #102 allowing the '.' character in username
 - added option to access repository just by entering http://server/<repo_name>
 - celery task ignores result for better performance
 
 fixes
------
++++++
 
 - fixed ehlo command and non auth mail servers on smtp_lib. Thanks to 
   apollo13 and Johan Walles
@@ -304,31 +359,31 b' fixes'
 - fixed static files paths links to use of url() method
 
 1.1.2 (**2011-01-12**)
-======================
+----------------------
 
 news
-----
+++++
 
 
 fixes
------
++++++
 
 - fixes #98 protection against float division of percentage stats
 - fixed graph bug
 - forced webhelpers version since it was making troubles during installation 
 
 1.1.1 (**2011-01-06**)
-======================
+----------------------
  
 news
-----
+++++
 
 - added force https option into ini files for easier https usage (no need to
   set server headers with this options)
 - small css updates
 
 fixes
------
++++++
 
 - fixed #96 redirect loop on files view on repositories without changesets
 - fixed #97 unicode string passed into server header in special cases (mod_wsgi)
@@ -337,16 +392,16 b' fixes'
 - fixed #92 whoosh indexer is more error proof
 
 1.1.0 (**2010-12-18**)
-======================
+----------------------
 
 news
-----
+++++
 
 - rewrite of internals for vcs >=0.1.10
 - uses mercurial 1.7 with dotencode disabled for maintaining compatibility 
   with older clients
 - anonymous access, authentication via ldap
-- performance upgrade for cached repos list - each repository has it's own 
+- performance upgrade for cached repos list - each repository has its own 
   cache that's invalidated when needed.
 - performance upgrades on repositories with large amount of commits (20K+)
 - main page quick filter for filtering repositories
@@ -365,7 +420,7 b' news'
 - other than sqlite database backends can be used
 
 fixes
------
++++++
 
 - fixes #61 forked repo was showing only after cache expired
 - fixes #76 no confirmation on user deletes
@@ -385,16 +440,16 b' fixes'
 
 
 1.0.2 (**2010-11-12**)
-======================
+----------------------
 
 news
-----
+++++
 
 - tested under python2.7
 - bumped sqlalchemy and celery versions
 
 fixes
------
++++++
 
 - fixed #59 missing graph.js
 - fixed repo_size crash when repository had broken symlinks
@@ -402,15 +457,15 b' fixes'
 
 
 1.0.1 (**2010-11-10**)
-======================
+----------------------
 
 news
-----
+++++
 
 - small css updated
 
 fixes
------
++++++
 
 - fixed #53 python2.5 incompatible enumerate calls
 - fixed #52 disable mercurial extension for web
@@ -418,7 +473,7 b' fixes'
 
 
 1.0.0 (**2010-11-02**)
-======================
+----------------------
 
 - security bugfix simplehg wasn't checking for permissions on commands
   other than pull or push.
@@ -428,7 +483,7 b' 1.0.0 (**2010-11-02**)'
 - permissions cached queries
 
 1.0.0rc4  (**2010-10-12**)
-==========================
+--------------------------
 
 - fixed python2.5 missing simplejson imports (thanks to Jens Bäckman)
 - removed cache_manager settings from sqlalchemy meta
@@ -438,12 +493,12 b' 1.0.0rc4 (**2010-10-12**)'
 
 
 1.0.0rc3 (**2010-10-11**)
-=========================
+-------------------------
 
 - fixed i18n during installation.
 
 1.0.0rc2 (**2010-10-11**)
-=========================
+-------------------------
 
 - Disabled dirsize in file browser, it's causing nasty bug when dir renames 
   occure. After vcs is fixed it'll be put back again.

docs/index.rst

@@ -2,8 +2,8 b''
 
 .. include:: ./../README.rst
 
-Documentation
--------------
+Users Guide
+-----------
 
 **Installation:**
 
@@ -20,10 +20,9 b' Documentation'
    :maxdepth: 1
 
    usage/general
-   usage/enable_git
+   usage/git_support
    usage/statistics
    usage/backup
-   usage/api_key_access
    
 **Develop**
 
@@ -36,9 +35,10 b' Documentation'
 **API**
 
 .. toctree::
-   :maxdepth: 2
+   :maxdepth: 1
 
-   api/index
+   api/api
+   api/models
    
 
 Other topics

docs/setup.rst

@@ -346,6 +346,106 b' All other LDAP settings will likely be s'
 appropriately configured.
 
 
+Authentication by container or reverse-proxy
+--------------------------------------------
+
+Starting with version 1.3, RhodeCode supports delegating the authentication
+of users to its WSGI container, or to a reverse-proxy server through which all
+clients access the application.
+
+When these authentication methods are enabled in RhodeCode, it uses the
+username that the container/proxy (Apache/Nginx/etc) authenticated and doesn't
+perform the authentication itself. The authorization, however, is still done by
+RhodeCode according to its settings.
+
+When a user logs in for the first time using these authentication methods,
+a matching user account is created in RhodeCode with default permissions. An
+administrator can then modify it using RhodeCode's admin interface.
+It's also possible for an administrator to create accounts and configure their
+permissions before the user logs in for the first time.
+
+Container-based authentication
+''''''''''''''''''''''''''''''
+
+In a container-based authentication setup, RhodeCode reads the user name from
+the ``REMOTE_USER`` server variable provided by the WSGI container.
+
+After setting up your container (see `Apache's WSGI config`_), you'd need
+to configure it to require authentication on the location configured for
+RhodeCode.
+
+In order for RhodeCode to start using the provided username, you should set the
+following in the [app:main] section of your .ini file::
+
+    container_auth_enabled = true
+
+
+Proxy pass-through authentication
+'''''''''''''''''''''''''''''''''
+
+In a proxy pass-through authentication setup, RhodeCode reads the user name
+from the ``X-Forwarded-User`` request header, which should be configured to be
+sent by the reverse-proxy server.
+
+After setting up your proxy solution (see `Apache virtual host reverse proxy example`_,
+`Apache as subdirectory`_ or `Nginx virtual host example`_), you'd need to
+configure the authentication and add the username in a request header named
+``X-Forwarded-User``.
+
+For example, the following config section for Apache sets a subdirectory in a
+reverse-proxy setup with basic auth::
+
+    <Location /<someprefix> >
+      ProxyPass http://127.0.0.1:5000/<someprefix>
+      ProxyPassReverse http://127.0.0.1:5000/<someprefix>
+      SetEnvIf X-Url-Scheme https HTTPS=1
+
+      AuthType Basic
+      AuthName "RhodeCode authentication"
+      AuthUserFile /home/web/rhodecode/.htpasswd
+      require valid-user
+
+      RequestHeader unset X-Forwarded-User
+
+      RewriteEngine On
+      RewriteCond %{LA-U:REMOTE_USER} (.+)
+      RewriteRule .* - [E=RU:%1]
+      RequestHeader set X-Forwarded-User %{RU}e
+    </Location> 
+
+In order for RhodeCode to start using the forwarded username, you should set
+the following in the [app:main] section of your .ini file::
+
+    proxypass_auth_enabled = true
+
+.. note::
+   If you enable proxy pass-through authentication, make sure your server is
+   only accessible through the proxy. Otherwise, any client would be able to
+   forge the authentication header and could effectively become authenticated
+   using any account of their liking.
+
+Integration with Issue trackers
+-------------------------------
+
+RhodeCode provides a simple integration with issue trackers. It's possible
+to define a regular expression that will fetch issue id stored in commit
+messages and replace that with an url to this issue. To enable this simply
+uncomment following variables in the ini file::
+
+    url_pat = (?:^#|\s#)(\w+)
+    issue_server_link = https://myissueserver.com/{repo}/issue/{id}
+    issue_prefix = #
+
+`url_pat` is the regular expression that will fetch issues from commit messages.
+Default regex will match issues in format of #<number> eg. #300.
+ 
+Matched issues will be replace with the link specified as `issue_server_link` 
+{id} will be replaced with issue id, and {repo} with repository name.
+Since the # is striped `issue_prefix` is added as a prefix to url. 
+`issue_prefix` can be something different than # if you pass 
+ISSUE- as issue prefix this will generate an url in format::
+ 
+  <a href="https://myissueserver.com/example_repo/issue/300">ISSUE-300</a>  
 
 Hook management
 ---------------
@@ -361,6 +461,17 b' To add another custom hook simply fill i'
 can be found at *rhodecode.lib.hooks*. 
 
 
+Changing default encoding
+-------------------------
+
+By default RhodeCode uses utf8 encoding, starting from 1.3 series this
+can be changed, simply edit default_encoding in .ini file to desired one.
+This affects many parts in rhodecode including commiters names, filenames,
+encoding of commit messages. In addition RhodeCode can detect if `chardet`
+library is installed. If `chardet` is detected RhodeCode will fallback to it
+when there are encode/decode errors.
+
+
 Setting Up Celery
 -----------------
 
@@ -397,27 +508,36 b' Nginx virtual host example'
 
 Sample config for nginx using proxy::
 
+    upstream rc {
+        server 127.0.0.1:5000;
+        # add more instances for load balancing
+        #server 127.0.0.1:5001;
+        #server 127.0.0.1:5002;
+    }
+    
     server {
        listen          80;
        server_name     hg.myserver.com;
        access_log      /var/log/nginx/rhodecode.access.log;
        error_log       /var/log/nginx/rhodecode.error.log;
+
        location / {
-               root /var/www/rhodecode/rhodecode/public/;
-               if (!-f $request_filename){
-                   proxy_pass      http://127.0.0.1:5000;
-               }
-               #this is important if you want to use https !!!
-               proxy_set_header X-Url-Scheme $scheme;
-               include         /etc/nginx/proxy.conf;  
+            try_files $uri @rhode;
        }
+    
+       location @rhode {
+            proxy_pass      http://rc;
+            include         /etc/nginx/proxy.conf;
+       }
+
     }  
   
 Here's the proxy.conf. It's tuned so it will not timeout on long
 pushes or large pushes::
-
+    
     proxy_redirect              off;
     proxy_set_header            Host $host;
+    proxy_set_header            X-Url-Scheme $scheme;
     proxy_set_header            X-Host $http_host;
     proxy_set_header            X-Real-IP $remote_addr;
     proxy_set_header            X-Forwarded-For $proxy_add_x_forwarded_for;

docs/theme/nature/layout.html

@@ -1,12 +1,12 b''
 {% extends "basic/layout.html" %}
 
 {% block sidebarlogo %}
-<h3>Support my development effort.</h3>
+<h3>Support RhodeCode development.</h3>
 <div style="text-align:center">
 	<form action="https://www.paypal.com/cgi-bin/webscr" method="post">
 	<input type="hidden" name="cmd" value="_s-xclick">
 	<input type="hidden" name="hosted_button_id" value="8U2LLRPLBKWDU">
-	<input style="border:0px !important" type="image" src="https://www.paypal.com/en_US/i/btn/btn_donate_SM.gif" 
+	<input style="border:0px !important" type="image" src="https://www.paypal.com/en_US/i/btn/btn_donate_SM.gif"
 	border="0" name="submit" alt="PayPal - The safer, easier way to pay online!">
 	<img alt="" border="0" src="https://www.paypal.com/en_US/i/scr/pixel.gif" width="1" height="1">
 	</form>

docs/usage/general.rst

@@ -36,6 +36,31 b' Compare view is also available from the '
 one changeset
 
 
+Non changeable repository urls
+------------------------------
+
+Due to complicated nature of repository grouping, often urls of repositories
+can change.
+
+example::
+  
+  #before
+  http://server.com/repo_name
+  # after insertion to test_group group the url will be
+  http://server.com/test_group/repo_name
+  
+This can be an issue for build systems and any other hardcoded scripts, moving
+repository to a group leads to a need for changing external systems. To 
+overcome this RhodeCode introduces a non changable replacement url. It's 
+simply an repository ID prefixed with `_` above urls are also accessible as::
+
+  http://server.com/_<ID>
+  
+Since ID are always the same moving the repository will not affect such url.
+the _<ID> syntax can be used anywhere in the system so urls with repo_name 
+for changelogs, files and other can be exchanged with _<ID> syntax.
+
+
 
 Mailing
 -------

docs/usage/git_support.rst

@@ -1,13 +1,41 b''
-.. _enable_git:
+.. _git_support:
 
-Enabling GIT support (beta)
-===========================
+GIT support
+===========
 
 
-Git support in RhodeCode 1.1 was disabled due to current instability issues. 
-However,if you would like to test git support please feel free to re-enable it. 
-To re-enable GIT support just uncomment the git line in the 
-file **rhodecode/__init__.py**
+Git support in RhodeCode 1.3 was enabled by default. 
+Although There are some limitations on git usage.
+
+- No hooks are runned for git push/pull actions.
+- logs in action journals don't have git operations
+- large pushes needs http server with chunked encoding support.
+ 
+if you plan to use git you need to run RhodeCode with some
+http server that supports chunked encoding which git http protocol uses, 
+i recommend using waitress_ or gunicorn_ (linux only) for `paste` wsgi app 
+replacement.
+
+To use waitress simply change change the following in the .ini file::
+
+    use = egg:Paste#http
+
+To::
+    
+    use = egg:waitress#main
+
+And comment out bellow options::
+
+    threadpool_workers = 
+    threadpool_max_requests = 
+    use_threadpool = 
+    
+
+You can simply run `paster serve` as usual.
+
+  
+You can always disable git/hg support by editing a 
+file **rhodecode/__init__.py** and commenting out backends
 
 .. code-block:: python
  
@@ -16,9 +44,5 b' file **rhodecode/__init__.py**'
        #'git': 'Git repository',
    }
 
-.. note::
-   Please note that the git support provided by RhodeCode is not yet fully
-   stable and RhodeCode might crash while using git repositories. (That is why
-   it is currently disabled.) Thus be careful about enabling git support, and
-   certainly don't use it in a production setting!
-   
  No newline at end of file
+.. _waitress: http://pypi.python.org/pypi/waitress
+.. _gunicorn: http://pypi.python.org/pypi/gunicorn
  No newline at end of file

production.ini

@@ -17,6 +17,7 b' pdebug = false'
 #error_email_from = paste_error@localhost
 #app_email_from = rhodecode-noreply@localhost
 #error_message =
+#email_prefix = [RhodeCode]
 
 #smtp_server = mail.server.com
 #smtp_username = 
@@ -45,14 +46,52 b' port = 8001'
 use = egg:rhodecode
 full_stack = true
 static_files = true
-lang=en
+lang = en
 cache_dir = %(here)s/data
 index_dir = %(here)s/data/index
-app_instance_uuid = prod1234
+app_instance_uuid = rc-production
 cut_off_limit = 256000
-force_https = false 
+force_https = false
 commit_parse_limit = 50
 use_gravatar = true
+container_auth_enabled = false
+proxypass_auth_enabled = false
+default_encoding = utf8
+
+## overwrite schema of clone url
+## available vars:
+## scheme - http/https
+## user - current user
+## pass - password 
+## netloc - network location
+## path - usually repo_name
+
+#clone_uri = {scheme}://{user}{pass}{netloc}{path}
+
+## issue tracking mapping for commits messages
+## comment out issue_pat, issue_server, issue_prefix to enable
+
+## pattern to get the issues from commit messages
+## default one used here is #<numbers> with a regex passive group for `#`
+## {id} will be all groups matched from this pattern
+
+issue_pat = (?:\s*#)(\d+)
+
+## server url to the issue, each {id} will be replaced with match
+## fetched from the regex and {repo} is replaced with repository name
+
+issue_server_link = https://myissueserver.com/{repo}/issue/{id}
+
+## prefix to add to link to indicate it's an url
+## #314 will be replaced by <issue_prefix><id>
+
+issue_prefix = #
+
+## instance-id prefix
+## a prefix key for this instance used for cache invalidation when running 
+## multiple instances of rhodecode, make sure it's globally unique for 
+## all running rhodecode instances. Leave empty if you don't use it
+instance_id = 
 
 ####################################
 ###        CELERY CONFIG        ####
@@ -91,21 +130,27 b' beaker.cache.regions=super_short_term,sh'
 
 beaker.cache.super_short_term.type=memory
 beaker.cache.super_short_term.expire=10
+beaker.cache.super_short_term.key_length = 256
 
 beaker.cache.short_term.type=memory
 beaker.cache.short_term.expire=60
+beaker.cache.short_term.key_length = 256
 
 beaker.cache.long_term.type=memory
 beaker.cache.long_term.expire=36000
+beaker.cache.long_term.key_length = 256
 
 beaker.cache.sql_cache_short.type=memory
 beaker.cache.sql_cache_short.expire=10
+beaker.cache.sql_cache_short.key_length = 256
 
 beaker.cache.sql_cache_med.type=memory
 beaker.cache.sql_cache_med.expire=360
+beaker.cache.sql_cache_med.key_length = 256
 
 beaker.cache.sql_cache_long.type=file
 beaker.cache.sql_cache_long.expire=3600
+beaker.cache.sql_cache_long.key_length = 256
 
 ####################################
 ###       BEAKER SESSION        ####
@@ -113,12 +158,27 b' beaker.cache.sql_cache_long.expire=3600'
 ## Type of storage used for the session, current types are 
 ## dbm, file, memcached, database, and memory. 
 ## The storage uses the Container API 
-##that is also used by the cache system.
-beaker.session.type = file
+## that is also used by the cache system.
+
+## db session example
+
+#beaker.session.type = ext:database
+#beaker.session.sa.url = postgresql://postgres:qwe@localhost/rhodecode
+#beaker.session.table_name = db_session 
+
+## encrypted cookie session, good for many instances
+#beaker.session.type = cookie
 
+beaker.session.type = file
 beaker.session.key = rhodecode
-beaker.session.secret = g654dcno0-9873jhgfreyu
+# secure cookie requires AES python libraries
+#beaker.session.encrypt_key = g654dcno0-9873jhgfreyu
+#beaker.session.validate_key = 9712sds2212c--zxc123
 beaker.session.timeout = 36000
+beaker.session.httponly = true
+
+## uncomment for https secure cookie
+beaker.session.secure = false
 
 ##auto save the session to not to use .save()
 beaker.session.auto = False
@@ -126,7 +186,7 b' beaker.session.auto = False'
 ##true exire at browser close
 #beaker.session.cookie_expires = 3600
 
-    
+
 ################################################################################
 ## WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*  ##
 ## Debug mode will enable the interactive debugging tool, allowing ANYONE to  ##
@@ -232,4 +292,4 b' datefmt = %Y-%m-%d %H:%M:%S'
 [formatter_color_formatter_sql]
 class=rhodecode.lib.colored_formatter.ColorFormatterSql
 format= %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
-datefmt = %Y-%m-%d %H:%M:%S
  No newline at end of file
+datefmt = %Y-%m-%d %H:%M:%S

requires.txt

@@ -1,16 +1,17 b''
 Pylons==1.0.0
-Beaker==1.5.4
+Beaker==1.6.2
 WebHelpers>=1.2
 formencode==1.2.4
 SQLAlchemy==0.7.4
 Mako==0.5.0
 pygments>=1.4
-whoosh<1.8
+whoosh>=2.3.0,<2.4
 celery>=2.2.5,<2.3
 babel
 python-dateutil>=1.5.0,<2.0.0
 dulwich>=0.8.0,<0.9.0
-vcs==0.2.2
 webob==1.0.8
+markdown==2.1.1
+docutils==0.8.1
 py-bcrypt
-mercurial==2.0.2
  No newline at end of file
+mercurial>=2.1,<2.2
  No newline at end of file

rhodecode/__init__.py

@@ -26,9 +26,9 b''
 import sys
 import platform
 
-VERSION = (1, 2, 5)
+VERSION = (1, 3, 0)
 __version__ = '.'.join((str(each) for each in VERSION[:4]))
-__dbversion__ = 3  # defines current db version for migrations
+__dbversion__ = 5  # defines current db version for migrations
 __platform__ = platform.system()
 __license__ = 'GPLv3'
 __py_version__ = sys.version_info
@@ -38,19 +38,20 b" PLATFORM_OTHERS = ('Linux', 'Darwin', 'F"
 
 requirements = [
     "Pylons==1.0.0",
-    "Beaker==1.5.4",
+    "Beaker==1.6.2",
     "WebHelpers>=1.2",
     "formencode==1.2.4",
     "SQLAlchemy==0.7.4",
     "Mako==0.5.0",
     "pygments>=1.4",
-    "whoosh<1.8",
+    "whoosh>=2.3.0,<2.4",
     "celery>=2.2.5,<2.3",
     "babel",
     "python-dateutil>=1.5.0,<2.0.0",
     "dulwich>=0.8.0,<0.9.0",
-    "vcs==0.2.2",
-    "webob==1.0.8"
+    "webob==1.0.8",
+    "markdown==2.1.1",
+    "docutils==0.8.1",
 ]
 
 if __py_version__ < (2, 6):
@@ -58,15 +59,15 b' if __py_version__ < (2, 6):'
     requirements.append("pysqlite")
 
 if __platform__ in PLATFORM_WIN:
-    requirements.append("mercurial==2.0.1")
+    requirements.append("mercurial>=2.1,<2.2")
 else:
     requirements.append("py-bcrypt")
-    requirements.append("mercurial==2.0.2")
+    requirements.append("mercurial>=2.1,<2.2")
 
 
 try:
     from rhodecode.lib import get_current_revision
-    _rev = get_current_revision(quiet=True)
+    _rev = get_current_revision()
 except ImportError:
     # this is needed when doing some setup.py operations
     _rev = False
@@ -82,5 +83,10 b' def get_version():'
 
 BACKENDS = {
     'hg': 'Mercurial repository',
-    #'git': 'Git repository',
+    'git': 'Git repository',
 }
+
+CELERY_ON = False
+
+# link to config for pylons
+CONFIG = {}

rhodecode/config/deployment.ini_tmpl

@@ -17,6 +17,7 b' pdebug = false'
 #error_email_from = paste_error@localhost
 #app_email_from = rhodecode-noreply@localhost
 #error_message =
+#email_prefix = [RhodeCode]
 
 #smtp_server = mail.server.com
 #smtp_username = 
@@ -45,14 +46,52 b' port = 5000'
 use = egg:rhodecode
 full_stack = true
 static_files = true
-lang=en
+lang = en
 cache_dir = %(here)s/data
 index_dir = %(here)s/data/index
 app_instance_uuid = ${app_instance_uuid}
 cut_off_limit = 256000
-force_https = false 
+force_https = false
 commit_parse_limit = 50
 use_gravatar = true
+container_auth_enabled = false
+proxypass_auth_enabled = false
+default_encoding = utf8
+
+## overwrite schema of clone url
+## available vars:
+## scheme - http/https
+## user - current user
+## pass - password 
+## netloc - network location
+## path - usually repo_name
+
+#clone_uri = {scheme}://{user}{pass}{netloc}{path}
+
+## issue tracking mapping for commits messages
+## comment out issue_pat, issue_server, issue_prefix to enable
+
+## pattern to get the issues from commit messages
+## default one used here is #<numbers> with a regex passive group for `#`
+## {id} will be all groups matched from this pattern
+
+issue_pat = (?:\s*#)(\d+)
+
+## server url to the issue, each {id} will be replaced with match
+## fetched from the regex and {repo} is replaced with repository name
+
+issue_server_link = https://myissueserver.com/{repo}/issue/{id}
+
+## prefix to add to link to indicate it's an url
+## #314 will be replaced by <issue_prefix><id>
+
+issue_prefix = #
+
+## instance-id prefix
+## a prefix key for this instance used for cache invalidation when running 
+## multiple instances of rhodecode, make sure it's globally unique for 
+## all running rhodecode instances. Leave empty if you don't use it
+instance_id = 
 
 ####################################
 ###        CELERY CONFIG        ####
@@ -91,21 +130,27 b' beaker.cache.regions=super_short_term,sh'
 
 beaker.cache.super_short_term.type=memory
 beaker.cache.super_short_term.expire=10
+beaker.cache.super_short_term.key_length = 256
 
 beaker.cache.short_term.type=memory
 beaker.cache.short_term.expire=60
+beaker.cache.short_term.key_length = 256
 
 beaker.cache.long_term.type=memory
 beaker.cache.long_term.expire=36000
+beaker.cache.long_term.key_length = 256
 
 beaker.cache.sql_cache_short.type=memory
 beaker.cache.sql_cache_short.expire=10
+beaker.cache.sql_cache_short.key_length = 256
 
 beaker.cache.sql_cache_med.type=memory
 beaker.cache.sql_cache_med.expire=360
+beaker.cache.sql_cache_med.key_length = 256
 
 beaker.cache.sql_cache_long.type=file
 beaker.cache.sql_cache_long.expire=3600
+beaker.cache.sql_cache_long.key_length = 256
 
 ####################################
 ###       BEAKER SESSION        ####
@@ -113,12 +158,27 b' beaker.cache.sql_cache_long.expire=3600'
 ## Type of storage used for the session, current types are 
 ## dbm, file, memcached, database, and memory. 
 ## The storage uses the Container API 
-##that is also used by the cache system.
-beaker.session.type = file
+## that is also used by the cache system.
+
+## db session example
+
+#beaker.session.type = ext:database
+#beaker.session.sa.url = postgresql://postgres:qwe@localhost/rhodecode
+#beaker.session.table_name = db_session 
+
+## encrypted cookie session, good for many instances
+#beaker.session.type = cookie
 
+beaker.session.type = file
 beaker.session.key = rhodecode
-beaker.session.secret = ${app_instance_secret}
+# secure cookie requires AES python libraries
+#beaker.session.encrypt_key = ${app_instance_secret}
+#beaker.session.validate_key = ${app_instance_secret}
 beaker.session.timeout = 36000
+beaker.session.httponly = true
+
+## uncomment for https secure cookie
+beaker.session.secure = false
 
 ##auto save the session to not to use .save()
 beaker.session.auto = False
@@ -126,7 +186,7 b' beaker.session.auto = False'
 ##true exire at browser close
 #beaker.session.cookie_expires = 3600
 
-    
+
 ################################################################################
 ## WARNING: *THE LINE BELOW MUST BE UNCOMMENTED ON A PRODUCTION ENVIRONMENT*  ##
 ## Debug mode will enable the interactive debugging tool, allowing ANYONE to  ##
@@ -154,6 +214,7 b' sqlalchemy.db1.url = sqlite:///%(here)s/'
 # MySQL
 # sqlalchemy.db1.url = mysql://user:pass@localhost/rhodecode
 
+# see sqlalchemy docs for others
 
 sqlalchemy.db1.echo = false
 sqlalchemy.db1.pool_recycle = 3600
@@ -217,13 +278,13 b' propagate = 0'
 class = StreamHandler
 args = (sys.stderr,)
 level = INFO
-formatter = color_formatter
+formatter = generic
 
 [handler_console_sql]
 class = StreamHandler
 args = (sys.stderr,)
 level = WARN
-formatter = color_formatter_sql
+formatter = generic
 
 ################
 ## FORMATTERS ##
@@ -241,4 +302,4 b' datefmt = %Y-%m-%d %H:%M:%S'
 [formatter_color_formatter_sql]
 class=rhodecode.lib.colored_formatter.ColorFormatterSql
 format= %(asctime)s.%(msecs)03d %(levelname)-5.5s [%(name)s] %(message)s
-datefmt = %Y-%m-%d %H:%M:%S
  No newline at end of file
+datefmt = %Y-%m-%d %H:%M:%S

rhodecode/config/environment.py

@@ -7,13 +7,14 b' from mako.lookup import TemplateLookup'
 from pylons.configuration import PylonsConfig
 from pylons.error import handle_mako_error
 
+import rhodecode
 import rhodecode.lib.app_globals as app_globals
 import rhodecode.lib.helpers
 
 from rhodecode.config.routing import make_map
-from rhodecode.lib import celerypylons
+# don't remove this import it does magic for celery
+from rhodecode.lib import celerypylons, str2bool
 from rhodecode.lib import engine_from_config
-from rhodecode.lib.timerproxy import TimerProxy
 from rhodecode.lib.auth import set_available_permissions
 from rhodecode.lib.utils import repo2db_mapper, make_ui, set_rhodecode_config
 from rhodecode.model import init_model
@@ -38,10 +39,13 b' def load_environment(global_conf, app_co'
     # Initialize config with the basic options
     config.init_app(global_conf, app_conf, package='rhodecode', paths=paths)
 
+    # store some globals into rhodecode
+    rhodecode.CELERY_ON = str2bool(config['app_conf'].get('use_celery'))
+
     config['routes.map'] = make_map(config)
     config['pylons.app_globals'] = app_globals.Globals(config)
     config['pylons.h'] = rhodecode.lib.helpers
-
+    rhodecode.CONFIG = config
     # Setup cache object as early as possible
     import pylons
     pylons.cache._push_object(config['pylons.app_globals'].cache)
@@ -54,7 +58,7 b' def load_environment(global_conf, app_co'
         input_encoding='utf-8', default_filters=['escape'],
         imports=['from webhelpers.html import escape'])
 
-    #sets the c attribute access when don't existing attribute are accessed
+    # sets the c attribute access when don't existing attribute are accessed
     config['pylons.strict_tmpl_context'] = True
     test = os.path.split(config['__file__'])[-1] == 'test.ini'
     if test:
@@ -63,7 +67,7 b' def load_environment(global_conf, app_co'
         create_test_env(TESTS_TMP_PATH, config)
         create_test_index(TESTS_TMP_PATH, config, True)
 
-    #MULTIPLE DB configs
+    # MULTIPLE DB configs
     # Setup the SQLAlchemy database engine
     sa_engine_db1 = engine_from_config(config, 'sqlalchemy.db1.')
 
@@ -77,4 +81,7 b' def load_environment(global_conf, app_co'
     # CONFIGURATION OPTIONS HERE (note: all config options will override
     # any Pylons config options)
 
+    # store config reference into our module to skip import magic of
+    # pylons
+    rhodecode.CONFIG.update(config)
     return config

rhodecode/config/middleware.py

@@ -51,15 +51,16 b' def make_app(global_conf, full_stack=Tru'
         from rhodecode.lib.profiler import ProfilingMiddleware
         app = ProfilingMiddleware(app)
 
-    # we want our low level middleware to get to the request ASAP. We don't
-    # need any pylons stack middleware in them
-    app = SimpleHg(app, config)
-    app = SimpleGit(app, config)
+    if asbool(full_stack):
 
-    if asbool(full_stack):
         # Handle Python exceptions
         app = ErrorHandler(app, global_conf, **config['pylons.errorware'])
 
+        # we want our low level middleware to get to the request ASAP. We don't
+        # need any pylons stack middleware in them
+        app = SimpleHg(app, config)
+        app = SimpleGit(app, config)
+
         # Display error documents for 401, 403, 404 status codes (and
         # 500 when debug is disabled)
         if asbool(config['debug']):

rhodecode/config/routing.py

@@ -8,7 +8,6 b' refer to the routes manual at http://rou'
 from __future__ import with_statement
 from routes import Mapper
 
-
 # prefix for non repository related links needs to be prefixed with `/`
 ADMIN_PREFIX = '/_admin'
 
@@ -26,18 +25,27 b' def make_map(config):'
     def check_repo(environ, match_dict):
         """
         check for valid repository for proper 404 handling
-        
+
         :param environ:
         :param match_dict:
         """
+        from rhodecode.model.db import Repository
+        repo_name = match_dict.get('repo_name')
 
-        repo_name = match_dict.get('repo_name')
+        try:
+            by_id = repo_name.split('_')
+            if len(by_id) == 2 and by_id[1].isdigit():
+                repo_name = Repository.get(by_id[1]).repo_name
+                match_dict['repo_name'] = repo_name
+        except:
+            pass
+
         return is_valid_repo(repo_name, config['base_path'])
 
     def check_group(environ, match_dict):
         """
         check for valid repositories group for proper 404 handling
-        
+
         :param environ:
         :param match_dict:
         """
@@ -45,7 +53,6 b' def make_map(config):'
 
         return is_valid_repos_group(repos_group_name, config['base_path'])
 
-
     def check_int(environ, match_dict):
         return match_dict.get('id').isdigit()
 
@@ -62,9 +69,14 b' def make_map(config):'
     rmap.connect('home', '/', controller='home', action='index')
     rmap.connect('repo_switcher', '/repos', controller='home',
                  action='repo_switcher')
+    rmap.connect('branch_tag_switcher', '/branches-tags/{repo_name:.*}',
+                 controller='home', action='branch_tag_switcher')
     rmap.connect('bugtracker',
                  "http://bitbucket.org/marcinkuzminski/rhodecode/issues",
                  _static=True)
+    rmap.connect('rst_help',
+                 "http://docutils.sourceforge.net/docs/user/rst/quickref.html",
+                 _static=True)
     rmap.connect('rhodecode_official', "http://rhodecode.org", _static=True)
 
     #ADMIN REPOSITORY REST ROUTES
@@ -101,8 +113,9 b' def make_map(config):'
                                             function=check_repo))
         #ajax delete repo perm user
         m.connect('delete_repo_user', "/repos_delete_user/{repo_name:.*}",
-             action="delete_perm_user", conditions=dict(method=["DELETE"],
-                                                        function=check_repo))
+             action="delete_perm_user",
+             conditions=dict(method=["DELETE"], function=check_repo))
+
         #ajax delete repo perm users_group
         m.connect('delete_repo_users_group',
                   "/repos_delete_users_group/{repo_name:.*}",
@@ -111,18 +124,20 b' def make_map(config):'
 
         #settings actions
         m.connect('repo_stats', "/repos_stats/{repo_name:.*}",
-             action="repo_stats", conditions=dict(method=["DELETE"],
-                                                        function=check_repo))
+                  action="repo_stats", conditions=dict(method=["DELETE"],
+                                                       function=check_repo))
         m.connect('repo_cache', "/repos_cache/{repo_name:.*}",
-             action="repo_cache", conditions=dict(method=["DELETE"],
+                  action="repo_cache", conditions=dict(method=["DELETE"],
+                                                       function=check_repo))
+        m.connect('repo_public_journal', "/repos_public_journal/{repo_name:.*}",
+                  action="repo_public_journal", conditions=dict(method=["PUT"],
                                                         function=check_repo))
-        m.connect('repo_public_journal',
-                  "/repos_public_journal/{repo_name:.*}",
-                  action="repo_public_journal", conditions=dict(method=["PUT"],
-                  function=check_repo))
         m.connect('repo_pull', "/repo_pull/{repo_name:.*}",
-             action="repo_pull", conditions=dict(method=["PUT"],
-                                                        function=check_repo))
+                  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:
@@ -155,6 +170,17 b' def make_map(config):'
         m.connect("formatted_repos_group", "/repos_groups/{id}.{format}",
                   action="show", conditions=dict(method=["GET"],
                                                  function=check_int))
+        # ajax delete repos group perm user
+        m.connect('delete_repos_group_user_perm',
+                  "/delete_repos_group_user_perm/{group_name:.*}",
+             action="delete_repos_group_user_perm",
+             conditions=dict(method=["DELETE"], function=check_group))
+
+        # ajax delete repos group perm users_group
+        m.connect('delete_repos_group_users_group_perm',
+                  "/delete_repos_group_users_group_perm/{group_name:.*}",
+                  action="delete_repos_group_users_group_perm",
+                  conditions=dict(method=["DELETE"], function=check_group))
 
     #ADMIN USER REST ROUTES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
@@ -267,6 +293,34 b' def make_map(config):'
         m.connect("admin_settings_create_repository", "/create_repository",
                   action="create_repository", conditions=dict(method=["GET"]))
 
+    #NOTIFICATION REST ROUTES
+    with rmap.submapper(path_prefix=ADMIN_PREFIX,
+                        controller='admin/notifications') as m:
+        m.connect("notifications", "/notifications",
+                  action="create", conditions=dict(method=["POST"]))
+        m.connect("notifications", "/notifications",
+                  action="index", conditions=dict(method=["GET"]))
+        m.connect("notifications_mark_all_read", "/notifications/mark_all_read",
+                  action="mark_all_read", conditions=dict(method=["GET"]))
+        m.connect("formatted_notifications", "/notifications.{format}",
+                  action="index", conditions=dict(method=["GET"]))
+        m.connect("new_notification", "/notifications/new",
+                  action="new", conditions=dict(method=["GET"]))
+        m.connect("formatted_new_notification", "/notifications/new.{format}",
+                  action="new", conditions=dict(method=["GET"]))
+        m.connect("/notification/{notification_id}",
+                  action="update", conditions=dict(method=["PUT"]))
+        m.connect("/notification/{notification_id}",
+                  action="delete", conditions=dict(method=["DELETE"]))
+        m.connect("edit_notification", "/notification/{notification_id}/edit",
+                  action="edit", conditions=dict(method=["GET"]))
+        m.connect("formatted_edit_notification",
+                  "/notification/{notification_id}.{format}/edit",
+                  action="edit", conditions=dict(method=["GET"]))
+        m.connect("notification", "/notification/{notification_id}",
+                  action="show", conditions=dict(method=["GET"]))
+        m.connect("formatted_notification", "/notifications/{notification_id}.{format}",
+                  action="show", conditions=dict(method=["GET"]))
 
     #ADMIN MAIN PAGES
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
@@ -276,13 +330,12 b' def make_map(config):'
                   action='add_repo')
 
     #==========================================================================
-    # API V1
+    # API V2
     #==========================================================================
     with rmap.submapper(path_prefix=ADMIN_PREFIX,
                         controller='api/api') as m:
         m.connect('api', '/api')
 
-
     #USER JOURNAL
     rmap.connect('journal', '%s/journal' % ADMIN_PREFIX, controller='journal')
 
@@ -344,6 +397,16 b' def make_map(config):'
                 controller='changeset', revision='tip',
                 conditions=dict(function=check_repo))
 
+    rmap.connect('changeset_comment',
+                 '/{repo_name:.*}/changeset/{revision}/comment',
+                controller='changeset', revision='tip', action='comment',
+                conditions=dict(function=check_repo))
+
+    rmap.connect('changeset_comment_delete',
+                 '/{repo_name:.*}/changeset/comment/{comment_id}/delete',
+                controller='changeset', action='delete_comment',
+                conditions=dict(function=check_repo, method=["DELETE"]))
+
     rmap.connect('raw_changeset_home',
                  '/{repo_name:.*}/raw-changeset/{revision}',
                  controller='changeset', action='raw_changeset',
@@ -361,6 +424,9 b' def make_map(config):'
     rmap.connect('tags_home', '/{repo_name:.*}/tags',
                 controller='tags', conditions=dict(function=check_repo))
 
+    rmap.connect('bookmarks_home', '/{repo_name:.*}/bookmarks',
+                controller='bookmarks', conditions=dict(function=check_repo))
+
     rmap.connect('changelog_home', '/{repo_name:.*}/changelog',
                 controller='changelog', conditions=dict(function=check_repo))
 
@@ -423,19 +489,19 b' def make_map(config):'
                 conditions=dict(function=check_repo))
 
     rmap.connect('repo_fork_create_home', '/{repo_name:.*}/fork',
-                controller='settings', action='fork_create',
+                controller='forks', action='fork_create',
                 conditions=dict(function=check_repo, method=["POST"]))
 
     rmap.connect('repo_fork_home', '/{repo_name:.*}/fork',
-                controller='settings', action='fork',
+                controller='forks', action='fork',
                 conditions=dict(function=check_repo))
 
+    rmap.connect('repo_forks_home', '/{repo_name:.*}/forks',
+                 controller='forks', action='forks',
+                 conditions=dict(function=check_repo))
+
     rmap.connect('repo_followers_home', '/{repo_name:.*}/followers',
                  controller='followers', action='followers',
                  conditions=dict(function=check_repo))
 
-    rmap.connect('repo_forks_home', '/{repo_name:.*}/forks',
-                 controller='forks', action='forks',
-                 conditions=dict(function=check_repo))
-
     return rmap

rhodecode/controllers/admin/admin.py

@@ -7,7 +7,7 b''
 
     :created_on: Apr 7, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify

rhodecode/controllers/admin/ldap_settings.py

@@ -7,7 +7,7 b''
 
     :created_on: Nov 26, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -39,7 +39,7 b' from rhodecode.lib import helpers as h'
 from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator
 from rhodecode.lib.exceptions import LdapImportError
 from rhodecode.model.forms import LdapSettingsForm
-from rhodecode.model.db import RhodeCodeSettings
+from rhodecode.model.db import RhodeCodeSetting
 
 log = logging.getLogger(__name__)
 
@@ -83,7 +83,7 b' class LdapSettingsController(BaseControl'
         super(LdapSettingsController, self).__before__()
 
     def index(self):
-        defaults = RhodeCodeSettings.get_ldap_settings()
+        defaults = RhodeCodeSetting.get_ldap_settings()
         c.search_scope_cur = defaults.get('ldap_search_scope')
         c.tls_reqcert_cur = defaults.get('ldap_tls_reqcert')
         c.tls_kind_cur = defaults.get('ldap_tls_kind')
@@ -107,7 +107,7 b' class LdapSettingsController(BaseControl'
 
                 for k, v in form_result.items():
                     if k.startswith('ldap_'):
-                        setting = RhodeCodeSettings.get_by_name(k)
+                        setting = RhodeCodeSetting.get_by_name(k)
                         setting.app_settings_value = v
                         self.sa.add(setting)
 

rhodecode/controllers/admin/permissions.py

@@ -7,7 +7,7 b''
 
     :created_on: Apr 27, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -38,6 +38,7 b' from rhodecode.lib.base import BaseContr'
 from rhodecode.model.forms import DefaultPermissionsForm
 from rhodecode.model.permission import PermissionModel
 from rhodecode.model.db import User
+from rhodecode.model.meta import Session
 
 log = logging.getLogger(__name__)
 
@@ -101,6 +102,7 b' class PermissionsController(BaseControll'
             form_result = _form.to_python(dict(request.POST))
             form_result.update({'perm_user_name': id})
             permission_model.update(form_result)
+            Session.commit()
             h.flash(_('Default permissions updated successfully'),
                     category='success')
 

rhodecode/controllers/admin/repos.py

@@ -3,11 +3,11 b''
     rhodecode.controllers.admin.repos
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    Admin controller for RhodeCode
+    Repositories controller for RhodeCode
 
     :created_on: Apr 7, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -29,9 +29,10 b' import formencode'
 from formencode import htmlfill
 
 from paste.httpexceptions import HTTPInternalServerError
-from pylons import request, response, session, tmpl_context as c, url
-from pylons.controllers.util import abort, redirect
+from pylons import request, session, tmpl_context as c, url
+from pylons.controllers.util import redirect
 from pylons.i18n.translation import _
+from sqlalchemy.exc import IntegrityError
 
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator, \
@@ -39,11 +40,11 b' from rhodecode.lib.auth import LoginRequ'
 from rhodecode.lib.base import BaseController, render
 from rhodecode.lib.utils import invalidate_cache, action_logger, repo_name_slug
 from rhodecode.lib.helpers import get_token
-from rhodecode.model.db import User, Repository, UserFollowing, Group
+from rhodecode.model.meta import Session
+from rhodecode.model.db import User, Repository, UserFollowing, RepoGroup
 from rhodecode.model.forms import RepoForm
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.repo import RepoModel
-from sqlalchemy.exc import IntegrityError
 
 log = logging.getLogger(__name__)
 
@@ -63,9 +64,9 b' class ReposController(BaseController):'
         super(ReposController, self).__before__()
 
     def __load_defaults(self):
-        c.repo_groups = Group.groups_choices()
+        c.repo_groups = RepoGroup.groups_choices()
         c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
-        
+
         repo_model = RepoModel()
         c.users_array = repo_model.get_users_js()
         c.users_groups_array = repo_model.get_users_groups_js()
@@ -96,12 +97,13 b' class ReposController(BaseController):'
             .filter(UserFollowing.follows_repository == c.repo_info).scalar()
 
         if c.repo_info.stats:
-            last_rev = c.repo_info.stats.stat_on_revision
+            # this is on what revision we ended up so we add +1 for count
+            last_rev = c.repo_info.stats.stat_on_revision + 1
         else:
             last_rev = 0
         c.stats_revision = last_rev
 
-        c.repo_last_rev = repo.count() - 1 if repo.revisions else 0
+        c.repo_last_rev = repo.count() if repo.revisions else 0
 
         if last_rev == 0 or c.repo_last_rev == 0:
             c.stats_percentage = 0
@@ -110,6 +112,10 b' class ReposController(BaseController):'
                                             c.repo_last_rev) * 100)
 
         defaults = RepoModel()._get_defaults(repo_name)
+
+        c.repos_list = [('', _('--REMOVE FORK--'))]
+        c.repos_list += [(x.repo_id, x.repo_name) for x in
+                   Repository.query().order_by(Repository.repo_name).all()]
         return defaults
 
     @HasPermissionAllDecorator('hg.admin')
@@ -127,13 +133,13 b' class ReposController(BaseController):'
         """
         POST /repos: Create a new item"""
         # url('repos')
-        repo_model = RepoModel()
+
         self.__load_defaults()
         form_result = {}
         try:
             form_result = RepoForm(repo_groups=c.repo_groups_choices)()\
                             .to_python(dict(request.POST))
-            repo_model.create(form_result, self.rhodecode_user)
+            RepoModel().create(form_result, self.rhodecode_user)
             if form_result['clone_uri']:
                 h.flash(_('created repository %s from %s') \
                     % (form_result['repo_name'], form_result['clone_uri']),
@@ -143,13 +149,13 b' class ReposController(BaseController):'
                     category='success')
 
             if request.POST.get('user_created'):
-                #created by regular non admin user
+                # created by regular non admin user
                 action_logger(self.rhodecode_user, 'user_created_repo',
                               form_result['repo_name_full'], '', self.sa)
             else:
                 action_logger(self.rhodecode_user, 'admin_created_repo',
                               form_result['repo_name_full'], '', self.sa)
-
+            Session.commit()
         except formencode.Invalid, errors:
 
             c.new_repo = errors.value['repo_name']
@@ -207,7 +213,7 b' class ReposController(BaseController):'
             changed_name = repo.repo_name
             action_logger(self.rhodecode_user, 'admin_updated_repo',
                               changed_name, '', self.sa)
-
+            Session.commit()
         except formencode.Invalid, errors:
             defaults = self.__load_data(repo_name)
             defaults.update(errors.value)
@@ -251,9 +257,9 b' class ReposController(BaseController):'
             repo_model.delete(repo)
             invalidate_cache('get_repo_cached_%s' % repo_name)
             h.flash(_('deleted repository %s') % repo_name, category='success')
-
+            Session.commit()
         except IntegrityError, e:
-            if e.message.find('repositories_fork_id_fkey'):
+            if e.message.find('repositories_fork_id_fkey') != -1:
                 log.error(traceback.format_exc())
                 h.flash(_('Cannot delete %s it still contains attached '
                           'forks') % repo_name,
@@ -271,8 +277,7 b' class ReposController(BaseController):'
 
         return redirect(url('repos'))
 
-
-    @HasRepoPermissionAllDecorator('repository.admin')   
+    @HasRepoPermissionAllDecorator('repository.admin')
     def delete_perm_user(self, repo_name):
         """
         DELETE an existing repository permission user
@@ -281,9 +286,11 b' class ReposController(BaseController):'
         """
 
         try:
-            repo_model = RepoModel()
-            repo_model.delete_perm_user(request.POST, repo_name)
-        except Exception, e:
+            RepoModel().revoke_user_permission(repo=repo_name,
+                                               user=request.POST['user_id'])
+            Session.commit()
+        except Exception:
+            log.error(traceback.format_exc())
             h.flash(_('An error occurred during deletion of repository user'),
                     category='error')
             raise HTTPInternalServerError()
@@ -295,10 +302,14 b' class ReposController(BaseController):'
 
         :param repo_name:
         """
+
         try:
-            repo_model = RepoModel()
-            repo_model.delete_perm_users_group(request.POST, repo_name)
-        except Exception, e:
+            RepoModel().revoke_users_group_permission(
+                repo=repo_name, group_name=request.POST['users_group_id']
+            )
+            Session.commit()
+        except Exception:
+            log.error(traceback.format_exc())
             h.flash(_('An error occurred during deletion of repository'
                       ' users groups'),
                     category='error')
@@ -313,8 +324,8 b' class ReposController(BaseController):'
         """
 
         try:
-            repo_model = RepoModel()
-            repo_model.delete_stats(repo_name)
+            RepoModel().delete_stats(repo_name)
+            Session.commit()
         except Exception, e:
             h.flash(_('An error occurred during deletion of repository stats'),
                     category='error')
@@ -330,6 +341,7 b' class ReposController(BaseController):'
 
         try:
             ScmModel().mark_for_invalidation(repo_name)
+            Session.commit()
         except Exception, e:
             h.flash(_('An error occurred during cache invalidation'),
                     category='error')
@@ -353,6 +365,7 b' class ReposController(BaseController):'
                 self.scm_model.toggle_following_repo(repo_id, user_id)
                 h.flash(_('Updated repository visibility in public journal'),
                         category='success')
+                Session.commit()
             except:
                 h.flash(_('An error occurred during setting this'
                           ' repository in public journal'),
@@ -380,6 +393,28 b' class ReposController(BaseController):'
         return redirect(url('edit_repo', repo_name=repo_name))
 
     @HasPermissionAllDecorator('hg.admin')
+    def repo_as_fork(self, repo_name):
+        """
+        Mark given repository as a fork of another
+
+        :param repo_name:
+        """
+        try:
+            fork_id = request.POST.get('id_fork_of')
+            repo = ScmModel().mark_as_fork(repo_name, fork_id,
+                                    self.rhodecode_user.username)
+            fork = repo.fork.repo_name if repo.fork else _('Nothing')
+            Session.commit()
+            h.flash(_('Marked repo %s as fork of %s' % (repo_name,fork)),
+                    category='success')
+        except Exception, e:
+            raise
+            h.flash(_('An error occurred during this operation'),
+                    category='error')
+
+        return redirect(url('edit_repo', repo_name=repo_name))
+
+    @HasPermissionAllDecorator('hg.admin')
     def show(self, repo_name, format='html'):
         """GET /repos/repo_name: Show a specific item"""
         # url('repo', repo_name=ID)

rhodecode/controllers/admin/repos_groups.py

@@ -1,22 +1,50 b''
+# -*- coding: utf-8 -*-
+"""
+    rhodecode.controllers.admin.repos_groups
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Repositories groups controller for RhodeCode
+
+    :created_on: Mar 23, 2010
+    :author: marcink
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
+    :license: GPLv3, see COPYING for more details.
+"""
+# 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, either version 3 of the License, or
+# (at your option) any later version.
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
 import logging
 import traceback
 import formencode
 
 from formencode import htmlfill
-from operator import itemgetter
 
-from pylons import request, response, session, tmpl_context as c, url
-from pylons.controllers.util import abort, redirect
+from pylons import request, tmpl_context as c, url
+from pylons.controllers.util import redirect
 from pylons.i18n.translation import _
 
 from sqlalchemy.exc import IntegrityError
 
 from rhodecode.lib import helpers as h
-from rhodecode.lib.auth import LoginRequired, HasPermissionAnyDecorator
+from rhodecode.lib.auth import LoginRequired, HasPermissionAnyDecorator,\
+    HasReposGroupPermissionAnyDecorator
 from rhodecode.lib.base import BaseController, render
-from rhodecode.model.db import Group
+from rhodecode.model.db import RepoGroup
 from rhodecode.model.repos_group import ReposGroupModel
 from rhodecode.model.forms import ReposGroupForm
+from rhodecode.model.meta import Session
+from rhodecode.model.repo import RepoModel
+from webob.exc import HTTPInternalServerError
 
 log = logging.getLogger(__name__)
 
@@ -32,9 +60,13 b' class ReposGroupsController(BaseControll'
         super(ReposGroupsController, self).__before__()
 
     def __load_defaults(self):
-        c.repo_groups = Group.groups_choices()
+        c.repo_groups = RepoGroup.groups_choices()
         c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
 
+        repo_model = RepoModel()
+        c.users_array = repo_model.get_users_js()
+        c.users_groups_array = repo_model.get_users_groups_js()
+
     def __load_data(self, group_id):
         """
         Load defaults settings for edit, and update
@@ -43,21 +75,30 b' class ReposGroupsController(BaseControll'
         """
         self.__load_defaults()
 
-        repo_group = Group.get(group_id)
+        repo_group = RepoGroup.get(group_id)
 
         data = repo_group.get_dict()
 
         data['group_name'] = repo_group.name
 
+        # fill repository users
+        for p in repo_group.repo_group_to_perm:
+            data.update({'u_perm_%s' % p.user.username:
+                             p.permission.permission_name})
+
+        # fill repository groups
+        for p in repo_group.users_group_to_perm:
+            data.update({'g_perm_%s' % p.users_group.users_group_name:
+                             p.permission.permission_name})
+
         return data
 
     @HasPermissionAnyDecorator('hg.admin')
     def index(self, format='html'):
         """GET /repos_groups: All items in the collection"""
         # url('repos_groups')
-
-        sk = lambda g:g.parents[0].group_name if g.parents else g.group_name
-        c.groups = sorted(Group.query().all(), key=sk)
+        sk = lambda g: g.parents[0].group_name if g.parents else g.group_name
+        c.groups = sorted(RepoGroup.query().all(), key=sk)
         return render('admin/repos_groups/repos_groups_show.html')
 
     @HasPermissionAnyDecorator('hg.admin')
@@ -65,12 +106,16 b' class ReposGroupsController(BaseControll'
         """POST /repos_groups: Create a new item"""
         # url('repos_groups')
         self.__load_defaults()
-        repos_group_model = ReposGroupModel()
-        repos_group_form = ReposGroupForm(available_groups=
+        repos_group_form = ReposGroupForm(available_groups =
                                           c.repo_groups_choices)()
         try:
             form_result = repos_group_form.to_python(dict(request.POST))
-            repos_group_model.create(form_result)
+            ReposGroupModel().create(
+                    group_name=form_result['group_name'],
+                    group_description=form_result['group_description'],
+                    parent=form_result['group_parent_id']
+            )
+            Session.commit()
             h.flash(_('created repos group %s') \
                     % form_result['group_name'], category='success')
             #TODO: in futureaction_logger(, '', '', '', self.sa)
@@ -89,7 +134,6 b' class ReposGroupsController(BaseControll'
 
         return redirect(url('repos_groups'))
 
-
     @HasPermissionAnyDecorator('hg.admin')
     def new(self, format='html'):
         """GET /repos_groups/new: Form to create a new item"""
@@ -108,16 +152,17 b' class ReposGroupsController(BaseControll'
         # url('repos_group', id=ID)
 
         self.__load_defaults()
-        c.repos_group = Group.get(id)
+        c.repos_group = RepoGroup.get(id)
 
-        repos_group_model = ReposGroupModel()
-        repos_group_form = ReposGroupForm(edit=True,
-                                          old_data=c.repos_group.get_dict(),
-                                          available_groups=
-                                            c.repo_groups_choices)()
+        repos_group_form = ReposGroupForm(
+            edit=True,
+            old_data=c.repos_group.get_dict(),
+            available_groups=c.repo_groups_choices
+        )()
         try:
             form_result = repos_group_form.to_python(dict(request.POST))
-            repos_group_model.update(id, form_result)
+            ReposGroupModel().update(id, form_result)
+            Session.commit()
             h.flash(_('updated repos group %s') \
                     % form_result['group_name'], category='success')
             #TODO: in futureaction_logger(, '', '', '', self.sa)
@@ -136,7 +181,6 b' class ReposGroupsController(BaseControll'
 
         return redirect(url('repos_groups'))
 
-
     @HasPermissionAnyDecorator('hg.admin')
     def delete(self, id):
         """DELETE /repos_groups/id: Delete an existing item"""
@@ -147,8 +191,7 b' class ReposGroupsController(BaseControll'
         #           method='delete')
         # url('repos_group', id=ID)
 
-        repos_group_model = ReposGroupModel()
-        gr = Group.get(id)
+        gr = RepoGroup.get(id)
         repos = gr.repositories.all()
         if repos:
             h.flash(_('This group contains %s repositores and cannot be '
@@ -157,11 +200,12 b' class ReposGroupsController(BaseControll'
             return redirect(url('repos_groups'))
 
         try:
-            repos_group_model.delete(id)
+            ReposGroupModel().delete(id)
+            Session.commit()
             h.flash(_('removed repos group %s' % gr.group_name), category='success')
             #TODO: in future action_logger(, '', '', '', self.sa)
         except IntegrityError, e:
-            if e.message.find('groups_group_parent_id_fkey'):
+            if e.message.find('groups_group_parent_id_fkey') != -1:
                 log.error(traceback.format_exc())
                 h.flash(_('Cannot delete this group it still contains '
                           'subgroups'),
@@ -178,15 +222,57 b' class ReposGroupsController(BaseControll'
 
         return redirect(url('repos_groups'))
 
+    @HasReposGroupPermissionAnyDecorator('group.admin')
+    def delete_repos_group_user_perm(self, group_name):
+        """
+        DELETE an existing repositories group permission user
+
+        :param group_name:
+        """
+
+        try:
+            ReposGroupModel().revoke_user_permission(
+                repos_group=group_name, user=request.POST['user_id']
+            )
+            Session.commit()
+        except Exception:
+            log.error(traceback.format_exc())
+            h.flash(_('An error occurred during deletion of group user'),
+                    category='error')
+            raise HTTPInternalServerError()
+
+    @HasReposGroupPermissionAnyDecorator('group.admin')
+    def delete_repos_group_users_group_perm(self, group_name):
+        """
+        DELETE an existing repositories group permission users group
+
+        :param group_name:
+        """
+
+        try:
+            ReposGroupModel().revoke_users_group_permission(
+                repos_group=group_name,
+                group_name=request.POST['users_group_id']
+            )
+            Session.commit()
+        except Exception:
+            log.error(traceback.format_exc())
+            h.flash(_('An error occurred during deletion of group'
+                      ' users groups'),
+                    category='error')
+            raise HTTPInternalServerError()
+
     def show_by_name(self, group_name):
-        id_ = Group.get_by_group_name(group_name).group_id
+        id_ = RepoGroup.get_by_group_name(group_name).group_id
         return self.show(id_)
 
+    @HasReposGroupPermissionAnyDecorator('group.read', 'group.write',
+                                         'group.admin')
     def show(self, id, format='html'):
         """GET /repos_groups/id: Show a specific item"""
         # url('repos_group', id=ID)
 
-        c.group = Group.get(id)
+        c.group = RepoGroup.get(id)
 
         if c.group:
             c.group_repos = c.group.repositories.all()
@@ -201,8 +287,8 b' class ReposGroupsController(BaseControll'
 
         c.repo_cnt = 0
 
-        c.groups = self.sa.query(Group).order_by(Group.group_name)\
-            .filter(Group.group_parent_id == id).all()
+        c.groups = self.sa.query(RepoGroup).order_by(RepoGroup.group_name)\
+            .filter(RepoGroup.group_parent_id == id).all()
 
         return render('admin/repos_groups/repos_groups.html')
 
@@ -213,11 +299,11 b' class ReposGroupsController(BaseControll'
 
         id_ = int(id)
 
-        c.repos_group = Group.get(id_)
+        c.repos_group = RepoGroup.get(id_)
         defaults = self.__load_data(id_)
 
         # we need to exclude this group from the group list for editing
-        c.repo_groups = filter(lambda x:x[0] != id_, c.repo_groups)
+        c.repo_groups = filter(lambda x: x[0] != id_, c.repo_groups)
 
         return htmlfill.render(
             render('admin/repos_groups/repos_groups_edit.html'),
@@ -225,5 +311,3 b' class ReposGroupsController(BaseControll'
             encoding="UTF-8",
             force_defaults=False
         )
-
-

rhodecode/controllers/admin/settings.py

@@ -7,7 +7,7 b''
 
     :created_on: Jul 14, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -40,13 +40,15 b' from rhodecode.lib.base import BaseContr'
 from rhodecode.lib.celerylib import tasks, run_task
 from rhodecode.lib.utils import repo2db_mapper, invalidate_cache, \
     set_rhodecode_config, repo_name_slug
-from rhodecode.model.db import RhodeCodeUi, Repository, Group, \
-    RhodeCodeSettings
+from rhodecode.model.db import RhodeCodeUi, Repository, RepoGroup, \
+    RhodeCodeSetting
 from rhodecode.model.forms import UserForm, ApplicationSettingsForm, \
     ApplicationUiSettingsForm
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.user import UserModel
 from rhodecode.model.db import User
+from rhodecode.model.notification import EmailNotificationModel
+from rhodecode.model.meta import Session
 
 log = logging.getLogger(__name__)
 
@@ -69,7 +71,7 b' class SettingsController(BaseController)'
         """GET /admin/settings: All items in the collection"""
         # url('admin_settings')
 
-        defaults = RhodeCodeSettings.get_app_settings()
+        defaults = RhodeCodeSetting.get_app_settings()
         defaults.update(self.get_hg_ui_settings())
         return htmlfill.render(
             render('admin/settings/settings.html'),
@@ -99,7 +101,7 b' class SettingsController(BaseController)'
         # url('admin_setting', setting_id=ID)
         if setting_id == 'mapping':
             rm_obsolete = request.POST.get('destroy', False)
-            log.debug('Rescanning directories with destroy=%s', rm_obsolete)
+            log.debug('Rescanning directories with destroy=%s' % rm_obsolete)
             initial = ScmModel().repo_scan()
             log.debug('invalidating all repositories')
             for repo_name in initial.keys():
@@ -124,15 +126,15 b' class SettingsController(BaseController)'
                 form_result = application_form.to_python(dict(request.POST))
 
                 try:
-                    hgsettings1 = RhodeCodeSettings.get_by_name('title')
+                    hgsettings1 = RhodeCodeSetting.get_by_name('title')
                     hgsettings1.app_settings_value = \
                         form_result['rhodecode_title']
 
-                    hgsettings2 = RhodeCodeSettings.get_by_name('realm')
+                    hgsettings2 = RhodeCodeSetting.get_by_name('realm')
                     hgsettings2.app_settings_value = \
                         form_result['rhodecode_realm']
 
-                    hgsettings3 = RhodeCodeSettings.get_by_name('ga_code')
+                    hgsettings3 = RhodeCodeSetting.get_by_name('ga_code')
                     hgsettings3.app_settings_value = \
                         form_result['rhodecode_ga_code']
 
@@ -226,12 +228,11 b' class SettingsController(BaseController)'
                      prefix_error=False,
                      encoding="UTF-8")
 
-
         if setting_id == 'hooks':
             ui_key = request.POST.get('new_hook_ui_key')
             ui_value = request.POST.get('new_hook_ui_value')
             try:
-                
+
                 if ui_value and ui_key:
                     RhodeCodeUi.create_or_update_hook(ui_key, ui_value)
                     h.flash(_('Added new hook'),
@@ -240,13 +241,14 b' class SettingsController(BaseController)'
                 # check for edits
                 update = False
                 _d = request.POST.dict_of_lists()
-                for k, v in zip(_d.get('hook_ui_key',[]), _d.get('hook_ui_value_new',[])):
+                for k, v in zip(_d.get('hook_ui_key', []),
+                                _d.get('hook_ui_value_new', [])):
                     RhodeCodeUi.create_or_update_hook(k, v)
                     update = True
 
                 if update:
                     h.flash(_('Updated hooks'), category='success')
-
+                Session.commit()
             except:
                 log.error(traceback.format_exc())
                 h.flash(_('error occurred during hook creation'),
@@ -254,6 +256,21 b' class SettingsController(BaseController)'
 
             return redirect(url('admin_edit_setting', setting_id='hooks'))
 
+        if setting_id == 'email':
+            test_email = request.POST.get('test_email')
+            test_email_subj = 'RhodeCode TestEmail'
+            test_email_body = 'RhodeCode Email test'
+
+            test_email_html_body = EmailNotificationModel()\
+                .get_email_tmpl(EmailNotificationModel.TYPE_DEFAULT,
+                                body=test_email_body)
+
+            recipients = [test_email] if [test_email] else None
+
+            run_task(tasks.send_email, recipients, test_email_subj,
+                     test_email_body, test_email_html_body)
+
+            h.flash(_('Email task created'), category='success')
         return redirect(url('admin_settings'))
 
     @HasPermissionAllDecorator('hg.admin')
@@ -268,8 +285,8 b' class SettingsController(BaseController)'
         if setting_id == 'hooks':
             hook_id = request.POST.get('hook_id')
             RhodeCodeUi.delete(hook_id)
-            
-            
+
+
     @HasPermissionAllDecorator('hg.admin')
     def show(self, setting_id, format='html'):
         """
@@ -339,7 +356,7 b' class SettingsController(BaseController)'
             user_model.update_my_account(uid, form_result)
             h.flash(_('Your account was updated successfully'),
                     category='success')
-
+            Session.commit()
         except formencode.Invalid, errors:
             c.user = User.get(self.rhodecode_user.user_id)
             all_repos = self.sa.query(Repository)\
@@ -366,7 +383,7 b' class SettingsController(BaseController)'
     def create_repository(self):
         """GET /_admin/create_repository: Form to create a new item"""
 
-        c.repo_groups = Group.groups_choices()
+        c.repo_groups = RepoGroup.groups_choices()
         c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
 
         new_repo = request.GET.get('repo', '')

rhodecode/controllers/admin/users.py

@@ -7,7 +7,7 b''
 
     :created_on: Apr 4, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -29,7 +29,7 b' import formencode'
 
 from formencode import htmlfill
 from pylons import request, session, tmpl_context as c, url, config
-from pylons.controllers.util import abort, redirect
+from pylons.controllers.util import redirect
 from pylons.i18n.translation import _
 
 from rhodecode.lib.exceptions import DefaultUserException, \
@@ -38,9 +38,10 b' from rhodecode.lib import helpers as h'
 from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator
 from rhodecode.lib.base import BaseController, render
 
-from rhodecode.model.db import User, RepoToPerm, UserToPerm, Permission
+from rhodecode.model.db import User, Permission
 from rhodecode.model.forms import UserForm
 from rhodecode.model.user import UserModel
+from rhodecode.model.meta import Session
 
 log = logging.getLogger(__name__)
 
@@ -71,12 +72,13 b' class UsersController(BaseController):'
         # url('users')
 
         user_model = UserModel()
-        login_form = UserForm()()
+        user_form = UserForm()()
         try:
-            form_result = login_form.to_python(dict(request.POST))
+            form_result = user_form.to_python(dict(request.POST))
             user_model.create(form_result)
             h.flash(_('created user %s') % form_result['username'],
                     category='success')
+            Session.commit()
             #action_logger(self.rhodecode_user, 'new_user', '', '', self.sa)
         except formencode.Invalid, errors:
             return htmlfill.render(
@@ -114,11 +116,11 b' class UsersController(BaseController):'
             form_result = _form.to_python(dict(request.POST))
             user_model.update(id, form_result)
             h.flash(_('User updated successfully'), category='success')
-
+            Session.commit()
         except formencode.Invalid, errors:
             e = errors.error_dict or {}
             perm = Permission.get_by_key('hg.create.repository')
-            e.update({'create_repo_perm': UserToPerm.has_perm(id, perm)})
+            e.update({'create_repo_perm': user_model.has_perm(id, perm)})
             return htmlfill.render(
                 render('admin/users/user_edit.html'),
                 defaults=errors.value,
@@ -144,6 +146,7 b' class UsersController(BaseController):'
         try:
             user_model.delete(id)
             h.flash(_('successfully deleted user'), category='success')
+            Session.commit()
         except (UserOwnsReposException, DefaultUserException), e:
             h.flash(str(e), category='warning')
         except Exception:
@@ -158,20 +161,19 b' class UsersController(BaseController):'
     def edit(self, id, format='html'):
         """GET /users/id/edit: Form to edit an existing item"""
         # url('edit_user', id=ID)
-        user_model = UserModel()
-        c.user = user_model.get(id)
+        c.user = User.get(id)
         if not c.user:
             return redirect(url('users'))
         if c.user.username == 'default':
             h.flash(_("You can't edit this user"), category='warning')
             return redirect(url('users'))
         c.user.permissions = {}
-        c.granted_permissions = user_model.fill_perms(c.user)\
+        c.granted_permissions = UserModel().fill_perms(c.user)\
             .permissions['global']
 
         defaults = c.user.get_dict()
         perm = Permission.get_by_key('hg.create.repository')
-        defaults.update({'create_repo_perm': UserToPerm.has_perm(id, perm)})
+        defaults.update({'create_repo_perm': UserModel().has_perm(id, perm)})
 
         return htmlfill.render(
             render('admin/users/user_edit.html'),
@@ -185,23 +187,24 b' class UsersController(BaseController):'
         # url('user_perm', id=ID, method='put')
 
         grant_perm = request.POST.get('create_repo_perm', False)
+        user_model = UserModel()
 
         if grant_perm:
             perm = Permission.get_by_key('hg.create.none')
-            UserToPerm.revoke_perm(id, perm)
+            user_model.revoke_perm(id, perm)
 
             perm = Permission.get_by_key('hg.create.repository')
-            UserToPerm.grant_perm(id, perm)
+            user_model.grant_perm(id, perm)
             h.flash(_("Granted 'repository create' permission to user"),
                     category='success')
-
+            Session.commit()
         else:
             perm = Permission.get_by_key('hg.create.repository')
-            UserToPerm.revoke_perm(id, perm)
+            user_model.revoke_perm(id, perm)
 
             perm = Permission.get_by_key('hg.create.none')
-            UserToPerm.grant_perm(id, perm)
+            user_model.grant_perm(id, perm)
             h.flash(_("Revoked 'repository create' permission to user"),
                     category='success')
-
+            Session.commit()
         return redirect(url('edit_user', id=id))

rhodecode/controllers/admin/users_groups.py

@@ -7,7 +7,7 b''
 
     :created_on: Jan 25, 2011
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -33,12 +33,15 b' from pylons.controllers.util import abor'
 from pylons.i18n.translation import _
 
 from rhodecode.lib.exceptions import UsersGroupsAssignedException
-from rhodecode.lib import helpers as h
+from rhodecode.lib import helpers as h, safe_unicode
 from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator
 from rhodecode.lib.base import BaseController, render
 
+from rhodecode.model.users_group import UsersGroupModel
+
 from rhodecode.model.db import User, UsersGroup, Permission, UsersGroupToPerm
-from rhodecode.model.forms import UserForm, UsersGroupForm
+from rhodecode.model.forms import UsersGroupForm
+from rhodecode.model.meta import Session
 
 log = logging.getLogger(__name__)
 
@@ -70,10 +73,12 b' class UsersGroupsController(BaseControll'
         users_group_form = UsersGroupForm()()
         try:
             form_result = users_group_form.to_python(dict(request.POST))
-            UsersGroup.create(form_result)
+            UsersGroupModel().create(name=form_result['users_group_name'],
+                                     active=form_result['users_group_active'])
             h.flash(_('created users group %s') \
                     % form_result['users_group_name'], category='success')
             #action_logger(self.rhodecode_user, 'new_user', '', '', self.sa)
+            Session.commit()
         except formencode.Invalid, errors:
             return htmlfill.render(
                 render('admin/users_groups/users_group_add.html'),
@@ -103,29 +108,33 b' class UsersGroupsController(BaseControll'
         # url('users_group', id=ID)
 
         c.users_group = UsersGroup.get(id)
-        c.group_members = [(x.user_id, x.user.username) for x in
-                           c.users_group.members]
+        c.group_members_obj = [x.user for x in c.users_group.members]
+        c.group_members = [(x.user_id, x.username) for x in
+                           c.group_members_obj]
 
         c.available_members = [(x.user_id, x.username) for x in
                                self.sa.query(User).all()]
+
+        available_members = [safe_unicode(x[0]) for x in c.available_members]
+
         users_group_form = UsersGroupForm(edit=True,
                                           old_data=c.users_group.get_dict(),
-                                          available_members=[str(x[0]) for x
-                                                in c.available_members])()
+                                          available_members=available_members)()
 
         try:
             form_result = users_group_form.to_python(request.POST)
-            UsersGroup.update(id, form_result)
+            UsersGroupModel().update(c.users_group, form_result)
             h.flash(_('updated users group %s') \
                         % form_result['users_group_name'],
                     category='success')
             #action_logger(self.rhodecode_user, 'new_user', '', '', self.sa)
+            Session.commit()
         except formencode.Invalid, errors:
             e = errors.error_dict or {}
 
             perm = Permission.get_by_key('hg.create.repository')
             e.update({'create_repo_perm':
-                         UsersGroupToPerm.has_perm(id, perm)})
+                         UsersGroupModel().has_perm(id, perm)})
 
             return htmlfill.render(
                 render('admin/users_groups/users_group_edit.html'),
@@ -150,8 +159,9 b' class UsersGroupsController(BaseControll'
         # url('users_group', id=ID)
 
         try:
-            UsersGroup.delete(id)
+            UsersGroupModel().delete(id)
             h.flash(_('successfully deleted users group'), category='success')
+            Session.commit()
         except UsersGroupsAssignedException, e:
             h.flash(e, category='error')
         except Exception:
@@ -172,14 +182,15 b' class UsersGroupsController(BaseControll'
             return redirect(url('users_groups'))
 
         c.users_group.permissions = {}
-        c.group_members = [(x.user_id, x.user.username) for x in
-                           c.users_group.members]
+        c.group_members_obj = [x.user for x in c.users_group.members]
+        c.group_members = [(x.user_id, x.username) for x in
+                           c.group_members_obj]
         c.available_members = [(x.user_id, x.username) for x in
                                self.sa.query(User).all()]
         defaults = c.users_group.get_dict()
         perm = Permission.get_by_key('hg.create.repository')
         defaults.update({'create_repo_perm':
-                         UsersGroupToPerm.has_perm(id, perm)})
+                         UsersGroupModel().has_perm(c.users_group, perm)})
         return htmlfill.render(
             render('admin/users_groups/users_group_edit.html'),
             defaults=defaults,
@@ -195,20 +206,21 b' class UsersGroupsController(BaseControll'
 
         if grant_perm:
             perm = Permission.get_by_key('hg.create.none')
-            UsersGroupToPerm.revoke_perm(id, perm)
+            UsersGroupModel().revoke_perm(id, perm)
 
             perm = Permission.get_by_key('hg.create.repository')
-            UsersGroupToPerm.grant_perm(id, perm)
+            UsersGroupModel().grant_perm(id, perm)
             h.flash(_("Granted 'repository create' permission to user"),
                     category='success')
 
+            Session.commit()
         else:
             perm = Permission.get_by_key('hg.create.repository')
-            UsersGroupToPerm.revoke_perm(id, perm)
+            UsersGroupModel().revoke_perm(id, perm)
 
             perm = Permission.get_by_key('hg.create.none')
-            UsersGroupToPerm.grant_perm(id, perm)
+            UsersGroupModel().grant_perm(id, perm)
             h.flash(_("Revoked 'repository create' permission to user"),
                     category='success')
-
+            Session.commit()
         return redirect(url('edit_users_group', id=id))

rhodecode/controllers/api/__init__.py

@@ -7,19 +7,19 b''
 
     :created_on: Aug 20, 2011
     :author: marcink
-    :copyright: (C) 2009-2010 Marcin Kuzminski <[e-mail]>    
+    :copyright: (C) 2011-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # 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,
@@ -62,7 +62,7 b' def jsonrpc_error(message, code=None):'
     Generate a Response object with a JSON-RPC error body
     """
     from pylons.controllers.util import Response
-    resp = Response(body=json.dumps(dict(result=None, error=message)),
+    resp = Response(body=json.dumps(dict(id=None, result=None, error=message)),
                     status=code,
                     content_type='application/json')
     return resp
@@ -100,7 +100,7 b' class JSONRPCController(WSGIController):'
         else:
             length = environ['CONTENT_LENGTH'] or 0
             length = int(environ['CONTENT_LENGTH'])
-            log.debug('Content-Length: %s', length)
+            log.debug('Content-Length: %s' % length)
 
         if length == 0:
             log.debug("Content-Length is 0")
@@ -118,11 +118,13 b' class JSONRPCController(WSGIController):'
         # check AUTH based on API KEY
         try:
             self._req_api_key = json_body['api_key']
+            self._req_id = json_body['id']
             self._req_method = json_body['method']
             self._request_params = json_body['args']
-            log.debug('method: %s, params: %s',
-                      self._req_method,
-                      self._request_params)
+            log.debug(
+                'method: %s, params: %s' % (self._req_method,
+                                            self._request_params)
+            )
         except KeyError, e:
             return jsonrpc_error(message='Incorrect JSON query missing %s' % e)
 
@@ -225,21 +227,26 b' class JSONRPCController(WSGIController):'
         if self._error is not None:
             raw_response = None
 
-        response = dict(result=raw_response,
+        response = dict(id=self._req_id, result=raw_response,
                         error=self._error)
 
         try:
             return json.dumps(response)
         except TypeError, e:
-            log.debug('Error encoding response: %s', e)
-            return json.dumps(dict(result=None,
-                                   error="Error encoding response"))
+            log.debug('Error encoding response: %s' % e)
+            return json.dumps(
+                dict(
+                    self._req_id,
+                    result=None,
+                    error="Error encoding response"
+                )
+            )
 
     def _find_method(self):
         """
         Return method named by `self._req_method` in controller if able
         """
-        log.debug('Trying to find JSON-RPC method: %s', self._req_method)
+        log.debug('Trying to find JSON-RPC method: %s' % self._req_method)
         if self._req_method.startswith('_'):
             raise AttributeError("Method not allowed")
 
@@ -253,4 +260,3 b' class JSONRPCController(WSGIController):'
             return func
         else:
             raise AttributeError("No such method: %s" % self._req_method)
-

rhodecode/controllers/api/api.py

@@ -30,17 +30,15 b' import logging'
 
 from rhodecode.controllers.api import JSONRPCController, JSONRPCError
 from rhodecode.lib.auth import HasPermissionAllDecorator, \
-    HasPermissionAnyDecorator
+    HasPermissionAnyDecorator, PasswordGenerator
+
+from rhodecode.model.meta import Session
 from rhodecode.model.scm import ScmModel
-
-from rhodecode.model.db import User, UsersGroup, Group, Repository
+from rhodecode.model.db import User, UsersGroup, RepoGroup, Repository
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.user import UserModel
-from rhodecode.model.repo_permission import RepositoryPermissionModel
 from rhodecode.model.users_group import UsersGroupModel
-from rhodecode.model import users_group
 from rhodecode.model.repos_group import ReposGroupModel
-from sqlalchemy.orm.exc import NoResultFound
 
 
 log = logging.getLogger(__name__)
@@ -63,26 +61,26 b' class ApiController(JSONRPCController):'
     """
 
     @HasPermissionAllDecorator('hg.admin')
-    def pull(self, apiuser, repo):
+    def pull(self, apiuser, repo_name):
         """
         Dispatch pull action on given repo
 
 
         :param user:
-        :param repo:
+        :param repo_name:
         """
 
-        if Repository.is_valid(repo) is False:
-            raise JSONRPCError('Unknown repo "%s"' % repo)
+        if Repository.is_valid(repo_name) is False:
+            raise JSONRPCError('Unknown repo "%s"' % repo_name)
 
         try:
-            ScmModel().pull_changes(repo, self.rhodecode_user.username)
-            return 'Pulled from %s' % repo
+            ScmModel().pull_changes(repo_name, self.rhodecode_user.username)
+            return 'Pulled from %s' % repo_name
         except Exception:
-            raise JSONRPCError('Unable to pull changes from "%s"' % repo)
+            raise JSONRPCError('Unable to pull changes from "%s"' % repo_name)
 
     @HasPermissionAllDecorator('hg.admin')
-    def get_user(self, apiuser, username):
+    def get_user(self, apiuser, userid):
         """"
         Get a user by username
 
@@ -90,9 +88,9 b' class ApiController(JSONRPCController):'
         :param username:
         """
 
-        user = User.get_by_username(username)
-        if not user:
-            return None
+        user = UserModel().get_user(userid)
+        if user is None:
+            return user
 
         return dict(
             id=user.user_id,
@@ -102,7 +100,7 b' class ApiController(JSONRPCController):'
             email=user.email,
             active=user.active,
             admin=user.admin,
-            ldap=user.ldap_dn
+            ldap_dn=user.ldap_dn
         )
 
     @HasPermissionAllDecorator('hg.admin')
@@ -124,47 +122,85 b' class ApiController(JSONRPCController):'
                     email=user.email,
                     active=user.active,
                     admin=user.admin,
-                    ldap=user.ldap_dn
+                    ldap_dn=user.ldap_dn
                 )
             )
         return result
 
     @HasPermissionAllDecorator('hg.admin')
-    def create_user(self, apiuser, username, password, firstname,
-                    lastname, email, active=True, admin=False, ldap_dn=None):
+    def create_user(self, apiuser, username, email, password, firstname=None,
+                    lastname=None, active=True, admin=False, ldap_dn=None):
         """
         Create new user
 
         :param apiuser:
         :param username:
         :param password:
+        :param email:
         :param name:
         :param lastname:
-        :param email:
         :param active:
         :param admin:
         :param ldap_dn:
         """
-
         if User.get_by_username(username):
             raise JSONRPCError("user %s already exist" % username)
 
+        if User.get_by_email(email, case_insensitive=True):
+            raise JSONRPCError("email %s already exist" % email)
+
+        if ldap_dn:
+            # generate temporary password if ldap_dn
+            password = PasswordGenerator().gen_password(length=8)
+
         try:
-            form_data = dict(username=username,
-                             password=password,
-                             active=active,
-                             admin=admin,
-                             name=firstname,
-                             lastname=lastname,
-                             email=email,
-                             ldap_dn=ldap_dn)
-            UserModel().create_ldap(username, password, ldap_dn, form_data)
-            return dict(msg='created new user %s' % username)
+            usr = UserModel().create_or_update(
+                username, password, email, firstname,
+                lastname, active, admin, ldap_dn
+            )
+            Session.commit()
+            return dict(
+                id=usr.user_id,
+                msg='created new user %s' % username
+            )
         except Exception:
             log.error(traceback.format_exc())
             raise JSONRPCError('failed to create user %s' % username)
 
     @HasPermissionAllDecorator('hg.admin')
+    def update_user(self, apiuser, userid, username, password, email,
+                    firstname, lastname, active, admin, ldap_dn):
+        """
+        Updates given user
+
+        :param apiuser:
+        :param username:
+        :param password:
+        :param email:
+        :param name:
+        :param lastname:
+        :param active:
+        :param admin:
+        :param ldap_dn:
+        """
+        if not UserModel().get_user(userid):
+            raise JSONRPCError("user %s does not exist" % username)
+
+        try:
+            usr = UserModel().create_or_update(
+                username, password, email, firstname,
+                lastname, active, admin, ldap_dn
+            )
+            Session.commit()
+            return dict(
+                id=usr.user_id,
+                msg='updated user %s' % username
+            )
+        except Exception:
+            log.error(traceback.format_exc())
+            raise JSONRPCError('failed to update user %s' % username)
+
+    @HasPermissionAllDecorator('hg.admin')
     def get_users_group(self, apiuser, group_name):
         """"
         Get users group by name
@@ -190,7 +226,7 b' class ApiController(JSONRPCController):'
                             ldap=user.ldap_dn))
 
         return dict(id=users_group.users_group_id,
-                    name=users_group.users_group_name,
+                    group_name=users_group.users_group_name,
                     active=users_group.users_group_active,
                     members=members)
 
@@ -217,41 +253,40 b' class ApiController(JSONRPCController):'
                                 ldap=user.ldap_dn))
 
             result.append(dict(id=users_group.users_group_id,
-                                name=users_group.users_group_name,
+                                group_name=users_group.users_group_name,
                                 active=users_group.users_group_active,
                                 members=members))
         return result
 
     @HasPermissionAllDecorator('hg.admin')
-    def create_users_group(self, apiuser, name, active=True):
+    def create_users_group(self, apiuser, group_name, active=True):
         """
         Creates an new usergroup
 
-        :param name:
+        :param group_name:
         :param active:
         """
 
-        if self.get_users_group(apiuser, name):
-            raise JSONRPCError("users group %s already exist" % name)
+        if self.get_users_group(apiuser, group_name):
+            raise JSONRPCError("users group %s already exist" % group_name)
 
         try:
-            form_data = dict(users_group_name=name,
-                             users_group_active=active)
-            ug = UsersGroup.create(form_data)
+            ug = UsersGroupModel().create(name=group_name, active=active)
+            Session.commit()
             return dict(id=ug.users_group_id,
-                        msg='created new users group %s' % name)
+                        msg='created new users group %s' % group_name)
         except Exception:
             log.error(traceback.format_exc())
-            raise JSONRPCError('failed to create group %s' % name)
+            raise JSONRPCError('failed to create group %s' % group_name)
 
     @HasPermissionAllDecorator('hg.admin')
-    def add_user_to_users_group(self, apiuser, group_name, user_name):
+    def add_user_to_users_group(self, apiuser, group_name, username):
         """"
         Add a user to a group
 
-        :param apiuser
-        :param group_name
-        :param user_name
+        :param apiuser:
+        :param group_name:
+        :param username:
         """
 
         try:
@@ -259,32 +294,65 b' class ApiController(JSONRPCController):'
             if not users_group:
                 raise JSONRPCError('unknown users group %s' % group_name)
 
-            try:
-                user = User.get_by_username(user_name)
-            except NoResultFound:
-                raise JSONRPCError('unknown user %s' % user_name)
+            user = User.get_by_username(username)
+            if user is None:
+                raise JSONRPCError('unknown user %s' % username)
 
             ugm = UsersGroupModel().add_user_to_group(users_group, user)
+            success = True if ugm != True else False
+            msg = 'added member %s to users group %s' % (username, group_name)
+            msg = msg if success else 'User is already in that group'
+            Session.commit()
 
-            return dict(id=ugm.users_group_member_id,
-                        msg='created new users group member')
+            return dict(
+                id=ugm.users_group_member_id if ugm != True else None,
+                success=success,
+                msg=msg
+            )
         except Exception:
             log.error(traceback.format_exc())
-            raise JSONRPCError('failed to create users group member')
+            raise JSONRPCError('failed to add users group member')
+
+    @HasPermissionAllDecorator('hg.admin')
+    def remove_user_from_users_group(self, apiuser, group_name, username):
+        """
+        Remove user from a group
+
+        :param apiuser
+        :param group_name
+        :param username
+        """
+
+        try:
+            users_group = UsersGroup.get_by_group_name(group_name)
+            if not users_group:
+                raise JSONRPCError('unknown users group %s' % group_name)
+
+            user = User.get_by_username(username)
+            if user is None:
+                raise JSONRPCError('unknown user %s' % username)
+
+            success = UsersGroupModel().remove_user_from_group(users_group, user)
+            msg = 'removed member %s from users group %s' % (username, group_name)
+            msg = msg if success else "User wasn't in group"
+            Session.commit()
+            return dict(success=success, msg=msg)
+        except Exception:
+            log.error(traceback.format_exc())
+            raise JSONRPCError('failed to remove user from group')
 
     @HasPermissionAnyDecorator('hg.admin')
-    def get_repo(self, apiuser, name):
+    def get_repo(self, apiuser, repoid):
         """"
         Get repository by name
 
-        :param apiuser
-        :param repo_name
+        :param apiuser:
+        :param repo_name:
         """
 
-        try:
-            repo = Repository.get_by_repo_name(name)
-        except NoResultFound:
-            return None
+        repo = RepoModel().get_repo(repoid)
+        if repo is None:
+            raise JSONRPCError('unknown repository %s' % repo)
 
         members = []
         for user in repo.repo_to_perm:
@@ -319,7 +387,7 b' class ApiController(JSONRPCController):'
 
         return dict(
             id=repo.repo_id,
-            name=repo.repo_name,
+            repo_name=repo.repo_name,
             type=repo.repo_type,
             description=repo.description,
             members=members
@@ -330,7 +398,7 b' class ApiController(JSONRPCController):'
         """"
         Get all repositories
 
-        :param apiuser
+        :param apiuser:
         """
 
         result = []
@@ -338,85 +406,255 b' class ApiController(JSONRPCController):'
             result.append(
                 dict(
                     id=repository.repo_id,
-                    name=repository.repo_name,
+                    repo_name=repository.repo_name,
                     type=repository.repo_type,
                     description=repository.description
                 )
             )
         return result
 
-    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')
-    def create_repo(self, apiuser, name, owner_name, description='', 
-                    repo_type='hg', private=False):
+    @HasPermissionAnyDecorator('hg.admin')
+    def get_repo_nodes(self, apiuser, repo_name, revision, root_path,
+                       ret_type='all'):
         """
-        Create a repository
+        returns a list of nodes and it's children
+        for a given path at given revision. It's possible to specify ret_type
+        to show only files or dirs
 
-        :param apiuser
-        :param name
-        :param description
-        :param type
-        :param private
-        :param owner_name
+        :param apiuser:
+        :param repo_name: name of repository
+        :param revision: revision for which listing should be done
+        :param root_path: path from which start displaying
+        :param ret_type: return type 'all|files|dirs' nodes
+        """
+        try:
+            _d, _f = ScmModel().get_nodes(repo_name, revision, root_path,
+                                          flat=False)
+            _map = {
+                'all': _d + _f,
+                'files': _f,
+                'dirs': _d,
+            }
+            return _map[ret_type]
+        except KeyError:
+            raise JSONRPCError('ret_type must be one of %s' % _map.keys())
+        except Exception, e:
+            raise JSONRPCError(e)
+
+    @HasPermissionAnyDecorator('hg.admin', 'hg.create.repository')
+    def create_repo(self, apiuser, repo_name, owner_name, description='',
+                    repo_type='hg', private=False, clone_uri=None):
+        """
+        Create repository, if clone_url is given it makes a remote clone
+
+        :param apiuser:
+        :param repo_name:
+        :param owner_name:
+        :param description:
+        :param repo_type:
+        :param private:
+        :param clone_uri:
         """
 
         try:
-            try:
-                owner = User.get_by_username(owner_name)
-            except NoResultFound:
-                raise JSONRPCError('unknown user %s' % owner)
+            owner = User.get_by_username(owner_name)
+            if owner is None:
+                raise JSONRPCError('unknown user %s' % owner_name)
 
-            if self.get_repo(apiuser, name):
-                raise JSONRPCError("repo %s already exist" % name)
+            if Repository.get_by_repo_name(repo_name):
+                raise JSONRPCError("repo %s already exist" % repo_name)
 
-            groups = name.split('/')
+            groups = repo_name.split('/')
             real_name = groups[-1]
             groups = groups[:-1]
             parent_id = None
             for g in groups:
-                group = Group.get_by_group_name(g)
+                group = RepoGroup.get_by_group_name(g)
                 if not group:
-                    group = ReposGroupModel().create(dict(group_name=g,
-                                                  group_description='',
-                                                  group_parent_id=parent_id))
+                    group = ReposGroupModel().create(g, '', parent_id)
                 parent_id = group.group_id
 
-            RepoModel().create(dict(repo_name=real_name,
-                                     repo_name_full=name,
-                                     description=description,
-                                     private=private,
-                                     repo_type=repo_type,
-                                     repo_group=parent_id,
-                                     clone_uri=None), owner)
+            repo = RepoModel().create(
+                dict(
+                    repo_name=real_name,
+                    repo_name_full=repo_name,
+                    description=description,
+                    private=private,
+                    repo_type=repo_type,
+                    repo_group=parent_id,
+                    clone_uri=clone_uri
+                ),
+                owner
+            )
+            Session.commit()
+
+            return dict(
+                id=repo.repo_id,
+                msg="Created new repository %s" % repo.repo_name
+            )
+
+        except Exception:
+            log.error(traceback.format_exc())
+            raise JSONRPCError('failed to create repository %s' % repo_name)
+
+    @HasPermissionAnyDecorator('hg.admin')
+    def delete_repo(self, apiuser, repo_name):
+        """
+        Deletes a given repository
+
+        :param repo_name:
+        """
+        if not Repository.get_by_repo_name(repo_name):
+            raise JSONRPCError("repo %s does not exist" % repo_name)
+        try:
+            RepoModel().delete(repo_name)
+            Session.commit()
+            return dict(
+                msg='Deleted repository %s' % repo_name
+            )
         except Exception:
             log.error(traceback.format_exc())
-            raise JSONRPCError('failed to create repository %s' % name)
+            raise JSONRPCError('failed to delete repository %s' % repo_name)
 
     @HasPermissionAnyDecorator('hg.admin')
-    def add_user_to_repo(self, apiuser, repo_name, user_name, perm):
+    def grant_user_permission(self, apiuser, repo_name, username, perm):
+        """
+        Grant permission for user on given repository, or update existing one
+        if found
+
+        :param repo_name:
+        :param username:
+        :param perm:
         """
-        Add permission for a user to a repository
+
+        try:
+            repo = Repository.get_by_repo_name(repo_name)
+            if repo is None:
+                raise JSONRPCError('unknown repository %s' % repo)
+
+            user = User.get_by_username(username)
+            if user is None:
+                raise JSONRPCError('unknown user %s' % username)
+
+            RepoModel().grant_user_permission(repo=repo, user=user, perm=perm)
 
-        :param apiuser
-        :param repo_name
-        :param user_name
-        :param perm
+            Session.commit()
+            return dict(
+                msg='Granted perm: %s for user: %s in repo: %s' % (
+                    perm, username, repo_name
+                )
+            )
+        except Exception:
+            log.error(traceback.format_exc())
+            raise JSONRPCError(
+                'failed to edit permission %(repo)s for %(user)s' % dict(
+                    user=username, repo=repo_name
+                )
+            )
+
+    @HasPermissionAnyDecorator('hg.admin')
+    def revoke_user_permission(self, apiuser, repo_name, username):
+        """
+        Revoke permission for user on given repository
+
+        :param repo_name:
+        :param username:
         """
 
         try:
-            try:
-                repo = Repository.get_by_repo_name(repo_name)
-            except NoResultFound:
+            repo = Repository.get_by_repo_name(repo_name)
+            if repo is None:
+                raise JSONRPCError('unknown repository %s' % repo)
+
+            user = User.get_by_username(username)
+            if user is None:
+                raise JSONRPCError('unknown user %s' % username)
+
+            RepoModel().revoke_user_permission(repo=repo_name, user=username)
+
+            Session.commit()
+            return dict(
+                msg='Revoked perm for user: %s in repo: %s' % (
+                    username, repo_name
+                )
+            )
+        except Exception:
+            log.error(traceback.format_exc())
+            raise JSONRPCError(
+                'failed to edit permission %(repo)s for %(user)s' % dict(
+                    user=username, repo=repo_name
+                )
+            )
+
+    @HasPermissionAnyDecorator('hg.admin')
+    def grant_users_group_permission(self, apiuser, repo_name, group_name, perm):
+        """
+        Grant permission for users group on given repository, or update
+        existing one if found
+
+        :param repo_name:
+        :param group_name:
+        :param perm:
+        """
+
+        try:
+            repo = Repository.get_by_repo_name(repo_name)
+            if repo is None:
                 raise JSONRPCError('unknown repository %s' % repo)
 
-            try:
-                user = User.get_by_username(user_name)
-            except NoResultFound:
-                raise JSONRPCError('unknown user %s' % user)
+            user_group = UsersGroup.get_by_group_name(group_name)
+            if user_group is None:
+                raise JSONRPCError('unknown users group %s' % user_group)
 
-            RepositoryPermissionModel()\
-                .update_or_delete_user_permission(repo, user, perm)
+            RepoModel().grant_users_group_permission(repo=repo_name,
+                                                     group_name=group_name,
+                                                     perm=perm)
+
+            Session.commit()
+            return dict(
+                msg='Granted perm: %s for group: %s in repo: %s' % (
+                    perm, group_name, repo_name
+                )
+            )
         except Exception:
             log.error(traceback.format_exc())
-            raise JSONRPCError('failed to edit permission %(repo)s for %(user)s'
-                            % dict(user=user_name, repo=repo_name))
+            raise JSONRPCError(
+                'failed to edit permission %(repo)s for %(usersgr)s' % dict(
+                    usersgr=group_name, repo=repo_name
+                )
+            )
+
+    @HasPermissionAnyDecorator('hg.admin')
+    def revoke_users_group_permission(self, apiuser, repo_name, group_name):
+        """
+        Revoke permission for users group on given repository
+
+        :param repo_name:
+        :param group_name:
+        """
+
+        try:
+            repo = Repository.get_by_repo_name(repo_name)
+            if repo is None:
+                raise JSONRPCError('unknown repository %s' % repo)
 
+            user_group = UsersGroup.get_by_group_name(group_name)
+            if user_group is None:
+                raise JSONRPCError('unknown users group %s' % user_group)
+
+            RepoModel().revoke_users_group_permission(repo=repo_name,
+                                                      group_name=group_name)
+
+            Session.commit()
+            return dict(
+                msg='Revoked perm for group: %s in repo: %s' % (
+                    group_name, repo_name
+                )
+            )
+        except Exception:
+            log.error(traceback.format_exc())
+            raise JSONRPCError(
+                'failed to edit permission %(repo)s for %(usersgr)s' % dict(
+                    usersgr=group_name, repo=repo_name
+                )
+            )

rhodecode/controllers/branches.py

@@ -7,7 +7,7 b''
 
     :created_on: Apr 21, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -46,33 +46,30 b' class BranchesController(BaseRepoControl'
     def index(self):
 
         def _branchtags(localrepo):
-
-            bt = {}
             bt_closed = {}
-
             for bn, heads in localrepo.branchmap().iteritems():
                 tip = heads[-1]
-                if 'close' not in localrepo.changelog.read(tip)[5]:
-                    bt[bn] = tip
-                else:
+                if 'close' in localrepo.changelog.read(tip)[5]:
                     bt_closed[bn] = tip
-            return bt, bt_closed
+            return bt_closed
 
+        cs_g = c.rhodecode_repo.get_changeset
 
-        bt, bt_closed = _branchtags(c.rhodecode_repo._repo)
-        cs_g = c.rhodecode_repo.get_changeset
-        _branches = [(safe_unicode(n), cs_g(binascii.hexlify(h)),) for n, h in
-                     bt.items()]
+        c.repo_closed_branches = {}
+        if c.rhodecode_db_repo.repo_type == 'hg':
+            bt_closed = _branchtags(c.rhodecode_repo._repo)
+            _closed_branches = [(safe_unicode(n), cs_g(binascii.hexlify(h)),)
+                                for n, h in bt_closed.items()]
 
-        _closed_branches = [(safe_unicode(n), cs_g(binascii.hexlify(h)),) for n, h in
-                     bt_closed.items()]
+            c.repo_closed_branches = OrderedDict(sorted(_closed_branches,
+                                                    key=lambda ctx: ctx[0],
+                                                    reverse=False))
 
+        _branches = [(safe_unicode(n), cs_g(h))
+                     for n, h in c.rhodecode_repo.branches.items()]
         c.repo_branches = OrderedDict(sorted(_branches,
                                              key=lambda ctx: ctx[0],
                                              reverse=False))
-        c.repo_closed_branches = OrderedDict(sorted(_closed_branches,
-                                                    key=lambda ctx: ctx[0],
-                                                    reverse=False))
 
 
         return render('branches/branches.html')

rhodecode/controllers/changelog.py

@@ -7,7 +7,7 b''
 
     :created_on: Apr 21, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -24,15 +24,22 b''
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import logging
+import traceback
 
 from mercurial import graphmod
-from pylons import request, session, tmpl_context as c
+from pylons import request, url, session, tmpl_context as c
+from pylons.controllers.util import redirect
+from pylons.i18n.translation import _
 
+import rhodecode.lib.helpers as h
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.helpers import RepoPage
 from rhodecode.lib.compat import json
 
+from rhodecode.lib.vcs.exceptions import RepositoryError, ChangesetDoesNotExistError
+from rhodecode.model.db import Repository
+
 log = logging.getLogger(__name__)
 
 
@@ -62,12 +69,32 b' class ChangelogController(BaseRepoContro'
 
         p = int(request.params.get('page', 1))
         branch_name = request.params.get('branch', None)
-        c.total_cs = len(c.rhodecode_repo)
-        c.pagination = RepoPage(c.rhodecode_repo, page=p,
-                                item_count=c.total_cs, items_per_page=c.size,
-                                branch_name=branch_name)
+        try:
+            if branch_name:
+                collection = [z for z in
+                              c.rhodecode_repo.get_changesets(start=0,
+                                                    branch_name=branch_name)]
+                c.total_cs = len(collection)
+            else:
+                collection = c.rhodecode_repo
+                c.total_cs = len(c.rhodecode_repo)
 
-        self._graph(c.rhodecode_repo, c.total_cs, c.size, p)
+            c.pagination = RepoPage(collection, page=p, item_count=c.total_cs,
+                                    items_per_page=c.size, branch=branch_name)
+            collection = list(c.pagination)
+            page_revisions = [x.raw_id for x in collection]
+            c.comments = c.rhodecode_db_repo.comments(page_revisions)
+
+        except (RepositoryError, ChangesetDoesNotExistError, Exception), e:
+            log.error(traceback.format_exc())
+            h.flash(str(e), category='warning')
+            return redirect(url('home'))
+
+        self._graph(c.rhodecode_repo, collection, c.total_cs, c.size, p)
+
+        c.branch_name = branch_name
+        c.branch_filters = [('', _('All Branches'))] + \
+            [(k, k) for k in c.rhodecode_repo.branches.keys()]
 
         return render('changelog/changelog.html')
 
@@ -76,7 +103,7 b' class ChangelogController(BaseRepoContro'
             c.cs = c.rhodecode_repo.get_changeset(cs)
             return render('changelog/changelog_details.html')
 
-    def _graph(self, repo, repo_size, size, p):
+    def _graph(self, repo, collection, repo_size, size, p):
         """
         Generates a DAG graph for mercurial
 
@@ -84,29 +111,20 b' class ChangelogController(BaseRepoContro'
         :param size: number of commits to show
         :param p: page number
         """
-        if not repo.revisions:
+        if not collection:
             c.jsdata = json.dumps([])
             return
 
-        revcount = min(repo_size, size)
-        offset = 1 if p == 1 else  ((p - 1) * revcount + 1)
-        try:
-            rev_end = repo.revisions.index(repo.revisions[(-1 * offset)])
-        except IndexError:
-            rev_end = repo.revisions.index(repo.revisions[-1])
-        rev_start = max(0, rev_end - revcount)
-
         data = []
-        rev_end += 1
+        revs = [x.revision for x in collection]
 
         if repo.alias == 'git':
-            for _ in xrange(rev_start, rev_end):
+            for _ in revs:
                 vtx = [0, 1]
                 edges = [[0, 0, 1]]
                 data.append(['', vtx, edges])
 
         elif repo.alias == 'hg':
-            revs = list(reversed(xrange(rev_start, rev_end)))
             c.dag = graphmod.colored(graphmod.dagwalker(repo._repo, revs))
             for (id, type, ctx, vtx, edges) in c.dag:
                 if type != graphmod.CHANGESET:

rhodecode/controllers/changeset.py

@@ -8,7 +8,7 b''
 
     :created_on: Apr 25, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -25,25 +25,129 b''
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import logging
 import traceback
+from collections import defaultdict
+from webob.exc import HTTPForbidden
 
 from pylons import tmpl_context as c, url, request, response
 from pylons.i18n.translation import _
 from pylons.controllers.util import redirect
+from pylons.decorators import jsonify
+
+from rhodecode.lib.vcs.exceptions import RepositoryError, ChangesetError, \
+    ChangesetDoesNotExistError
+from rhodecode.lib.vcs.nodes import FileNode
 
 import rhodecode.lib.helpers as h
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.utils import EmptyChangeset
 from rhodecode.lib.compat import OrderedDict
-
-from vcs.exceptions import RepositoryError, ChangesetError, \
-ChangesetDoesNotExistError
-from vcs.nodes import FileNode
-from vcs.utils import diffs as differ
+from rhodecode.lib import diffs
+from rhodecode.model.db import ChangesetComment
+from rhodecode.model.comment import ChangesetCommentsModel
+from rhodecode.model.meta import Session
+from rhodecode.lib.diffs import wrapped_diff
 
 log = logging.getLogger(__name__)
 
 
+def anchor_url(revision, path):
+    fid = h.FID(revision, path)
+    return h.url.current(anchor=fid, **request.GET)
+
+
+def get_ignore_ws(fid, GET):
+    ig_ws_global = request.GET.get('ignorews')
+    ig_ws = filter(lambda k: k.startswith('WS'), GET.getall(fid))
+    if ig_ws:
+        try:
+            return int(ig_ws[0].split(':')[-1])
+        except:
+            pass
+    return ig_ws_global
+
+
+def _ignorews_url(fileid=None):
+
+    params = defaultdict(list)
+    lbl = _('show white space')
+    ig_ws = get_ignore_ws(fileid, request.GET)
+    ln_ctx = get_line_ctx(fileid, request.GET)
+    # global option
+    if fileid is None:
+        if ig_ws is None:
+            params['ignorews'] += [1]
+            lbl = _('ignore white space')
+        ctx_key = 'context'
+        ctx_val = ln_ctx
+    # per file options
+    else:
+        if ig_ws is None:
+            params[fileid] += ['WS:1']
+            lbl = _('ignore white space')
+
+        ctx_key = fileid
+        ctx_val = 'C:%s' % ln_ctx
+    # if we have passed in ln_ctx pass it along to our params
+    if ln_ctx:
+        params[ctx_key] += [ctx_val]
+
+    params['anchor'] = fileid
+    img = h.image('/images/icons/text_strikethrough.png', lbl, class_='icon')
+    return h.link_to(img, h.url.current(**params), title=lbl, class_='tooltip')
+
+
+def get_line_ctx(fid, GET):
+    ln_ctx_global = request.GET.get('context')
+    ln_ctx = filter(lambda k: k.startswith('C'), GET.getall(fid))
+
+    if ln_ctx:
+        retval = ln_ctx[0].split(':')[-1]
+    else:
+        retval = ln_ctx_global
+
+    try:
+        return int(retval)
+    except:
+        return
+
+
+def _context_url(fileid=None):
+    """
+    Generates url for context lines
+
+    :param fileid:
+    """
+    ig_ws = get_ignore_ws(fileid, request.GET)
+    ln_ctx = (get_line_ctx(fileid, request.GET) or 3) * 2
+
+    params = defaultdict(list)
+
+    # global option
+    if fileid is None:
+        if ln_ctx > 0:
+            params['context'] += [ln_ctx]
+
+        if ig_ws:
+            ig_ws_key = 'ignorews'
+            ig_ws_val = 1
+
+    # per file option
+    else:
+        params[fileid] += ['C:%s' % ln_ctx]
+        ig_ws_key = fileid
+        ig_ws_val = 'WS:%s' % 1
+
+    if ig_ws:
+        params[ig_ws_key] += [ig_ws_val]
+
+    lbl = _('%s line context') % ln_ctx
+
+    params['anchor'] = fileid
+    img = h.image('/images/icons/table_add.png', lbl, class_='icon')
+    return h.link_to(img, h.url.current(**params), title=lbl, class_='tooltip')
+
+
 class ChangesetController(BaseRepoController):
 
     @LoginRequired()
@@ -55,20 +159,16 b' class ChangesetController(BaseRepoContro'
 
     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
+        c.anchor_url = anchor_url
+        c.ignorews_url = _ignorews_url
+        c.context_url = _context_url
 
         #get ranges of revisions if preset
         rev_range = revision.split('...')[:2]
-
+        enable_comments = True
         try:
             if len(rev_range) == 2:
+                enable_comments = False
                 rev_start = rev_range[0]
                 rev_end = rev_range[1]
                 rev_ranges = c.rhodecode_repo.get_changesets(start=rev_start,
@@ -77,6 +177,8 b' class ChangesetController(BaseRepoContro'
                 rev_ranges = [c.rhodecode_repo.get_changeset(revision)]
 
             c.cs_ranges = list(rev_ranges)
+            if not c.cs_ranges:
+                raise RepositoryError('Changeset range returned empty result')
 
         except (RepositoryError, ChangesetDoesNotExistError, Exception), e:
             log.error(traceback.format_exc())
@@ -84,14 +186,25 b' class ChangesetController(BaseRepoContro'
             return redirect(url('home'))
 
         c.changes = OrderedDict()
-        c.sum_added = 0
-        c.sum_removed = 0
-        c.lines_added = 0
-        c.lines_deleted = 0
+
+        c.lines_added = 0  # count of lines added
+        c.lines_deleted = 0  # count of lines removes
+
+        cumulative_diff = 0
         c.cut_off = False  # defines if cut off limit is reached
 
+        c.comments = []
+        c.inline_comments = []
+        c.inline_cnt = 0
         # Iterate over ranges (default changeset view is always one changeset)
         for changeset in c.cs_ranges:
+            c.comments.extend(ChangesetCommentsModel()\
+                              .get_comments(c.rhodecode_db_repo.repo_id,
+                                            changeset.raw_id))
+            inlines = ChangesetCommentsModel()\
+                        .get_inline_comments(c.rhodecode_db_repo.repo_id,
+                                             changeset.raw_id)
+            c.inline_comments.extend(inlines)
             c.changes[changeset.raw_id] = []
             try:
                 changeset_parent = changeset.parents[0]
@@ -102,32 +215,19 b' class ChangesetController(BaseRepoContro'
             # ADDED FILES
             #==================================================================
             for node in changeset.added:
-
-                filenode_old = FileNode(node.path, '', EmptyChangeset())
-                if filenode_old.is_binary or node.is_binary:
-                    diff = wrap_to_table(_('binary file'))
-                    st = (0, 0)
-                else:
-                    # in this case node.size is good parameter since those are
-                    # added nodes and their size defines how many changes were
-                    # made
-                    c.sum_added += node.size
-                    if c.sum_added < self.cut_off_limit:
-                        f_gitdiff = differ.get_gitdiff(filenode_old, node)
-                        d = differ.DiffProcessor(f_gitdiff, format='gitdiff')
-
-                        st = d.stat()
-                        diff = d.as_html()
-
-                    else:
-                        diff = wrap_to_table(_('Changeset is to big and '
-                                               'was cut off, see raw '
-                                               'changeset instead'))
-                        c.cut_off = True
-                        break
-
-                cs1 = None
-                cs2 = node.last_changeset.raw_id
+                fid = h.FID(revision, node.path)
+                line_context_lcl = get_line_ctx(fid, request.GET)
+                ign_whitespace_lcl = get_ignore_ws(fid, request.GET)
+                lim = self.cut_off_limit
+                if cumulative_diff > self.cut_off_limit:
+                    lim = -1
+                size, cs1, cs2, diff, st = wrapped_diff(filenode_old=None,
+                                         filenode_new=node,
+                                         cut_off_limit=lim,
+                                         ignore_whitespace=ign_whitespace_lcl,
+                                         line_context=line_context_lcl,
+                                         enable_comments=enable_comments)
+                cumulative_diff += size
                 c.lines_added += st[0]
                 c.lines_deleted += st[1]
                 c.changes[changeset.raw_id].append(('added', node, diff,
@@ -136,55 +236,42 b' class ChangesetController(BaseRepoContro'
             #==================================================================
             # CHANGED FILES
             #==================================================================
-            if not c.cut_off:
-                for node in changeset.changed:
-                    try:
-                        filenode_old = changeset_parent.get_node(node.path)
-                    except ChangesetError:
-                        log.warning('Unable to fetch parent node for diff')
-                        filenode_old = FileNode(node.path, '',
-                                                EmptyChangeset())
-
-                    if filenode_old.is_binary or node.is_binary:
-                        diff = wrap_to_table(_('binary file'))
-                        st = (0, 0)
-                    else:
+            for node in changeset.changed:
+                try:
+                    filenode_old = changeset_parent.get_node(node.path)
+                except ChangesetError:
+                    log.warning('Unable to fetch parent node for diff')
+                    filenode_old = FileNode(node.path, '', EmptyChangeset())
 
-                        if c.sum_removed < self.cut_off_limit:
-                            f_gitdiff = differ.get_gitdiff(filenode_old, node)
-                            d = differ.DiffProcessor(f_gitdiff,
-                                                     format='gitdiff')
-                            st = d.stat()
-                            if (st[0] + st[1]) * 256 > self.cut_off_limit:
-                                diff = wrap_to_table(_('Diff is to big '
-                                                       'and was cut off, see '
-                                                       'raw diff instead'))
-                            else:
-                                diff = d.as_html()
-
-                            if diff:
-                                c.sum_removed += len(diff)
-                        else:
-                            diff = wrap_to_table(_('Changeset is to big and '
-                                                   'was cut off, see raw '
-                                                   'changeset instead'))
-                            c.cut_off = True
-                            break
-
-                    cs1 = filenode_old.last_changeset.raw_id
-                    cs2 = node.last_changeset.raw_id
-                    c.lines_added += st[0]
-                    c.lines_deleted += st[1]
-                    c.changes[changeset.raw_id].append(('changed', node, diff,
-                                                        cs1, cs2, st))
+                fid = h.FID(revision, node.path)
+                line_context_lcl = get_line_ctx(fid, request.GET)
+                ign_whitespace_lcl = get_ignore_ws(fid, request.GET)
+                lim = self.cut_off_limit
+                if cumulative_diff > self.cut_off_limit:
+                    lim = -1
+                size, cs1, cs2, diff, st = wrapped_diff(filenode_old=filenode_old,
+                                         filenode_new=node,
+                                         cut_off_limit=lim,
+                                         ignore_whitespace=ign_whitespace_lcl,
+                                         line_context=line_context_lcl,
+                                         enable_comments=enable_comments)
+                cumulative_diff += size
+                c.lines_added += st[0]
+                c.lines_deleted += st[1]
+                c.changes[changeset.raw_id].append(('changed', node, diff,
+                                                    cs1, cs2, st))
 
             #==================================================================
             # REMOVED FILES
             #==================================================================
-            if not c.cut_off:
-                for node in changeset.removed:
-                    c.changes[changeset.raw_id].append(('removed', node, None,
-                                                        None, None, (0, 0)))
+            for node in changeset.removed:
+                c.changes[changeset.raw_id].append(('removed', node, None,
+                                                    None, None, (0, 0)))
+
+        # count inline comments
+        for path, lines in c.inline_comments:
+            for comments in lines.values():
+                c.inline_cnt += len(comments)
 
         if len(c.cs_ranges) == 1:
             c.changeset = c.cs_ranges[0]
@@ -197,6 +284,8 b' class ChangesetController(BaseRepoContro'
     def raw_changeset(self, revision):
 
         method = request.GET.get('diff', 'show')
+        ignore_whitespace = request.GET.get('ignorews') == '1'
+        line_context = request.GET.get('context', 3)
         try:
             c.scm_type = c.rhodecode_repo.alias
             c.changeset = c.rhodecode_repo.get_changeset(revision)
@@ -215,8 +304,10 b' class ChangesetController(BaseRepoContro'
                 if filenode_old.is_binary or node.is_binary:
                     diff = _('binary file') + '\n'
                 else:
-                    f_gitdiff = differ.get_gitdiff(filenode_old, node)
-                    diff = differ.DiffProcessor(f_gitdiff,
+                    f_gitdiff = diffs.get_gitdiff(filenode_old, node,
+                                           ignore_whitespace=ignore_whitespace,
+                                           context=line_context)
+                    diff = diffs.DiffProcessor(f_gitdiff,
                                                 format='gitdiff').raw_diff()
 
                 cs1 = None
@@ -228,8 +319,10 b' class ChangesetController(BaseRepoContro'
                 if filenode_old.is_binary or node.is_binary:
                     diff = _('binary file')
                 else:
-                    f_gitdiff = differ.get_gitdiff(filenode_old, node)
-                    diff = differ.DiffProcessor(f_gitdiff,
+                    f_gitdiff = diffs.get_gitdiff(filenode_old, node,
+                                           ignore_whitespace=ignore_whitespace,
+                                           context=line_context)
+                    diff = diffs.DiffProcessor(f_gitdiff,
                                                 format='gitdiff').raw_diff()
 
                 cs1 = filenode_old.last_changeset.raw_id
@@ -250,3 +343,25 b' class ChangesetController(BaseRepoContro'
             c.diffs += x[2]
 
         return render('changeset/raw_changeset.html')
+
+    def comment(self, repo_name, revision):
+        ChangesetCommentsModel().create(text=request.POST.get('text'),
+                                        repo_id=c.rhodecode_db_repo.repo_id,
+                                        user_id=c.rhodecode_user.user_id,
+                                        revision=revision,
+                                        f_path=request.POST.get('f_path'),
+                                        line_no=request.POST.get('line'))
+        Session.commit()
+        return redirect(h.url('changeset_home', repo_name=repo_name,
+                              revision=revision))
+
+    @jsonify
+    def delete_comment(self, repo_name, comment_id):
+        co = ChangesetComment.get(comment_id)
+        owner = lambda: co.author.user_id == c.rhodecode_user.user_id
+        if h.HasPermissionAny('hg.admin', 'repository.admin')() or owner:
+            ChangesetCommentsModel().delete(comment=co)
+            Session.commit()
+            return True
+        else:
+            raise HTTPForbidden()

rhodecode/controllers/error.py

@@ -7,7 +7,7 b''
 
     :created_on: Dec 8, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -54,7 +54,7 b' class ErrorController(BaseController):'
         resp = request.environ.get('pylons.original_response')
         c.rhodecode_name = config.get('rhodecode_title')
 
-        log.debug('### %s ###', resp.status)
+        log.debug('### %s ###' % resp.status)
 
         e = request.environ
         c.serv_p = r'%(protocol)s://%(host)s/' \

rhodecode/controllers/feed.py

@@ -7,7 +7,7 b''
 
     :created_on: Apr 23, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -51,6 +51,11 b' class FeedController(BaseRepoController)'
         self.ttl = "5"
         self.feed_nr = 10
 
+    def _get_title(self, cs):
+        return "R%s:%s - %s" % (
+            cs.revision, cs.short_id, cs.message
+        )
+
     def __changes(self, cs):
         changes = []
 
@@ -72,18 +77,21 b' class FeedController(BaseRepoController)'
 
     def atom(self, repo_name):
         """Produce an atom-1.0 feed via feedgenerator module"""
-        feed = Atom1Feed(title=self.title % repo_name,
-                         link=url('summary_home', repo_name=repo_name,
-                                  qualified=True),
-                         description=self.description % repo_name,
-                         language=self.language,
-                         ttl=self.ttl)
-        desc_msg = []
+        feed = Atom1Feed(
+             title=self.title % repo_name,
+             link=url('summary_home', repo_name=repo_name,
+                      qualified=True),
+             description=self.description % repo_name,
+             language=self.language,
+             ttl=self.ttl
+        )
+
         for cs in reversed(list(c.rhodecode_repo[-self.feed_nr:])):
+            desc_msg = []
             desc_msg.append('%s - %s<br/><pre>' % (cs.author, cs.date))
             desc_msg.append(self.__changes(cs))
 
-            feed.add_item(title=cs.message,
+            feed.add_item(title=self._get_title(cs),
                           link=url('changeset_home', repo_name=repo_name,
                                    revision=cs.raw_id, qualified=True),
                           author_name=cs.author,
@@ -94,18 +102,21 b' class FeedController(BaseRepoController)'
 
     def rss(self, repo_name):
         """Produce an rss2 feed via feedgenerator module"""
-        feed = Rss201rev2Feed(title=self.title % repo_name,
-                         link=url('summary_home', repo_name=repo_name,
-                                  qualified=True),
-                         description=self.description % repo_name,
-                         language=self.language,
-                         ttl=self.ttl)
-        desc_msg = []
+        feed = Rss201rev2Feed(
+            title=self.title % repo_name,
+            link=url('summary_home', repo_name=repo_name,
+                     qualified=True),
+            description=self.description % repo_name,
+            language=self.language,
+            ttl=self.ttl
+        )
+
         for cs in reversed(list(c.rhodecode_repo[-self.feed_nr:])):
+            desc_msg = []
             desc_msg.append('%s - %s<br/><pre>' % (cs.author, cs.date))
             desc_msg.append(self.__changes(cs))
 
-            feed.add_item(title=cs.message,
+            feed.add_item(title=self._get_title(cs),
                           link=url('changeset_home', repo_name=repo_name,
                                    revision=cs.raw_id, qualified=True),
                           author_name=cs.author,

rhodecode/controllers/files.py

@@ -27,25 +27,29 b' import os'
 import logging
 import traceback
 
-from os.path import join as jn
-
-from pylons import request, response, session, tmpl_context as c, url
+from pylons import request, response, tmpl_context as c, url
 from pylons.i18n.translation import _
 from pylons.controllers.util import redirect
 from pylons.decorators import jsonify
 
-from vcs.conf import settings
-from vcs.exceptions import RepositoryError, ChangesetDoesNotExistError, \
-    EmptyRepositoryError, ImproperArchiveTypeError, VCSError, NodeAlreadyExistsError
-from vcs.nodes import FileNode, NodeKind
-from vcs.utils import diffs as differ
+from rhodecode.lib.vcs.conf import settings
+from rhodecode.lib.vcs.exceptions import RepositoryError, ChangesetDoesNotExistError, \
+    EmptyRepositoryError, ImproperArchiveTypeError, VCSError, \
+    NodeAlreadyExistsError
+from rhodecode.lib.vcs.nodes import FileNode
 
+from rhodecode.lib.compat import OrderedDict
 from rhodecode.lib import convert_line_endings, detect_mode, safe_str
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.utils import EmptyChangeset
+from rhodecode.lib import diffs
 import rhodecode.lib.helpers as h
 from rhodecode.model.repo import RepoModel
+from rhodecode.controllers.changeset import anchor_url, _ignorews_url,\
+    _context_url, get_line_ctx, get_ignore_ws
+from rhodecode.lib.diffs import wrapped_diff
+from rhodecode.model.scm import ScmModel
 
 log = logging.getLogger(__name__)
 
@@ -104,26 +108,6 b' class FilesController(BaseRepoController'
 
         return file_node
 
-
-    def __get_paths(self, changeset, starting_path):
-        """recursive walk in root dir and return a set of all path in that dir
-        based on repository walk function
-        """
-        _files = list()
-        _dirs = list()
-
-        try:
-            tip = changeset
-            for topnode, dirs, files in tip.walk(starting_path):
-                for f in files:
-                    _files.append(f.path)
-                for d in dirs:
-                    _dirs.append(d.path)
-        except RepositoryError, e:
-            log.debug(traceback.format_exc())
-            pass
-        return _dirs, _files
-
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def index(self, repo_name, revision, f_path):
@@ -162,9 +146,9 b' class FilesController(BaseRepoController'
 
         # files or dirs
         try:
-            c.files_list = c.changeset.get_node(f_path)
+            c.file = c.changeset.get_node(f_path)
 
-            if c.files_list.is_file():
+            if c.file.is_file():
                 c.file_history = self._get_node_history(c.changeset, f_path)
             else:
                 c.file_history = []
@@ -405,13 +389,19 b' class FilesController(BaseRepoController'
     @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
                                    'repository.admin')
     def diff(self, repo_name, f_path):
-        diff1 = request.GET.get('diff1')
-        diff2 = request.GET.get('diff2')
+        ignore_whitespace = request.GET.get('ignorews') == '1'
+        line_context = request.GET.get('context', 3)
+        diff1 = request.GET.get('diff1', '')
+        diff2 = request.GET.get('diff2', '')
         c.action = request.GET.get('diff')
         c.no_changes = diff1 == diff2
         c.f_path = f_path
         c.big_diff = False
-
+        c.anchor_url = anchor_url
+        c.ignorews_url = _ignorews_url
+        c.context_url = _context_url
+        c.changes = OrderedDict()
+        c.changes[diff2] = []
         try:
             if diff1 not in ['', None, 'None', '0' * 12, '0' * 40]:
                 c.changeset_1 = c.rhodecode_repo.get_changeset(diff1)
@@ -427,12 +417,14 b' class FilesController(BaseRepoController'
                 c.changeset_2 = EmptyChangeset(repo=c.rhodecode_repo)
                 node2 = FileNode('.', '', changeset=c.changeset_2)
         except RepositoryError:
-            return redirect(url('files_home',
-                                repo_name=c.repo_name, f_path=f_path))
+            return redirect(url('files_home', repo_name=c.repo_name,
+                                f_path=f_path))
 
         if c.action == 'download':
-            diff = differ.DiffProcessor(differ.get_gitdiff(node1, node2),
-                                        format='gitdiff')
+            _diff = diffs.get_gitdiff(node1, node2,
+                                      ignore_whitespace=ignore_whitespace,
+                                      context=line_context)
+            diff = diffs.DiffProcessor(_diff, format='gitdiff')
 
             diff_name = '%s_vs_%s.diff' % (diff1, diff2)
             response.content_type = 'text/plain'
@@ -441,39 +433,28 b' class FilesController(BaseRepoController'
             return diff.raw_diff()
 
         elif c.action == 'raw':
-            diff = differ.DiffProcessor(differ.get_gitdiff(node1, node2),
-                                        format='gitdiff')
+            _diff = diffs.get_gitdiff(node1, node2,
+                                      ignore_whitespace=ignore_whitespace,
+                                      context=line_context)
+            diff = diffs.DiffProcessor(_diff, format='gitdiff')
             response.content_type = 'text/plain'
             return diff.raw_diff()
 
-        elif c.action == 'diff':
-            if node1.is_binary or node2.is_binary:
-                c.cur_diff = _('Binary file')
-            elif node1.size > self.cut_off_limit or \
-                    node2.size > self.cut_off_limit:
-                c.cur_diff = ''
-                c.big_diff = True
-            else:
-                diff = differ.DiffProcessor(differ.get_gitdiff(node1, node2),
-                                        format='gitdiff')
-                c.cur_diff = diff.as_html()
         else:
+            fid = h.FID(diff2, node2.path)
+            line_context_lcl = get_line_ctx(fid, request.GET)
+            ign_whitespace_lcl = get_ignore_ws(fid, request.GET)
 
-            #default option
-            if node1.is_binary or node2.is_binary:
-                c.cur_diff = _('Binary file')
-            elif node1.size > self.cut_off_limit or \
-                    node2.size > self.cut_off_limit:
-                c.cur_diff = ''
-                c.big_diff = True
+            lim = request.GET.get('fulldiff') or self.cut_off_limit
+            _, cs1, cs2, diff, st = wrapped_diff(filenode_old=node1,
+                                         filenode_new=node2,
+                                         cut_off_limit=lim,
+                                         ignore_whitespace=ign_whitespace_lcl,
+                                         line_context=line_context_lcl,
+                                         enable_comments=False)
 
-            else:
-                diff = differ.DiffProcessor(differ.get_gitdiff(node1, node2),
-                                        format='gitdiff')
-                c.cur_diff = diff.as_html()
+            c.changes = [('', node2, diff, cs1, cs2, st,)]
 
-        if not c.cur_diff and not c.big_diff:
-            c.no_changes = True
         return render('files/file_diff.html')
 
     def _get_node_history(self, cs, f_path):
@@ -485,18 +466,16 b' class FilesController(BaseRepoController'
         tags_group = ([], _("Tags"))
 
         for chs in changesets:
-            n_desc = 'r%s:%s' % (chs.revision, chs.short_id)
+            n_desc = 'r%s:%s (%s)' % (chs.revision, chs.short_id, chs.branch)
             changesets_group[0].append((chs.raw_id, n_desc,))
 
         hist_l.append(changesets_group)
 
         for name, chs in c.rhodecode_repo.branches.items():
-            #chs = chs.split(':')[-1]
             branches_group[0].append((chs, name),)
         hist_l.append(branches_group)
 
         for name, chs in c.rhodecode_repo.tags.items():
-            #chs = chs.split(':')[-1]
             tags_group[0].append((chs, name),)
         hist_l.append(tags_group)
 
@@ -508,6 +487,6 b' class FilesController(BaseRepoController'
     def nodelist(self, repo_name, revision, f_path):
         if request.environ.get('HTTP_X_PARTIAL_XHR'):
             cs = self.__get_cs_or_redirect(revision, repo_name)
-            _d, _f = self.__get_paths(cs, f_path)
+            _d, _f = ScmModel().get_nodes(repo_name, cs.raw_id, f_path,
+                                          flat=False)
             return _d + _f
-

rhodecode/controllers/followers.py

@@ -7,7 +7,7 b''
 
     :created_on: Apr 23, 2011
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2011-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify

rhodecode/controllers/forks.py

@@ -7,7 +7,7 b''
 
     :created_on: Apr 23, 2011
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2011-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -23,13 +23,23 b''
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import logging
+import formencode
+import traceback
+from formencode import htmlfill
 
-from pylons import tmpl_context as c, request
+from pylons import tmpl_context as c, request, url
+from pylons.controllers.util import redirect
+from pylons.i18n.translation import _
+
+import rhodecode.lib.helpers as h
 
 from rhodecode.lib.helpers import Page
-from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
+from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator, \
+    NotAnonymous
 from rhodecode.lib.base import BaseRepoController, render
-from rhodecode.model.db import Repository, User, UserFollowing
+from rhodecode.model.db import Repository, RepoGroup, UserFollowing, User
+from rhodecode.model.repo import RepoModel
+from rhodecode.model.forms import RepoForkForm
 
 log = logging.getLogger(__name__)
 
@@ -37,11 +47,59 b' log = logging.getLogger(__name__)'
 class ForksController(BaseRepoController):
 
     @LoginRequired()
-    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
-                                   'repository.admin')
     def __before__(self):
         super(ForksController, self).__before__()
 
+    def __load_defaults(self):
+        c.repo_groups = RepoGroup.groups_choices()
+        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
+
+    def __load_data(self, repo_name=None):
+        """
+        Load defaults settings for edit, and update
+
+        :param repo_name:
+        """
+        self.__load_defaults()
+
+        c.repo_info = db_repo = Repository.get_by_repo_name(repo_name)
+        repo = db_repo.scm_instance
+
+        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'))
+
+        c.default_user_id = User.get_by_username('default').user_id
+        c.in_public_journal = UserFollowing.query()\
+            .filter(UserFollowing.user_id == c.default_user_id)\
+            .filter(UserFollowing.follows_repository == c.repo_info).scalar()
+
+        if c.repo_info.stats:
+            last_rev = c.repo_info.stats.stat_on_revision+1
+        else:
+            last_rev = 0
+        c.stats_revision = last_rev
+
+        c.repo_last_rev = repo.count() if repo.revisions else 0
+
+        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)
+
+        defaults = RepoModel()._get_defaults(repo_name)
+        # add prefix to fork
+        defaults['repo_name'] = 'fork-' + defaults['repo_name']
+        return defaults
+
+    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
+                                   'repository.admin')
     def forks(self, repo_name):
         p = int(request.params.get('page', 1))
         repo_id = c.rhodecode_db_repo.repo_id
@@ -54,3 +112,63 b' class ForksController(BaseRepoController'
             return c.forks_data
 
         return render('/forks/forks.html')
+
+    @NotAnonymous()
+    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
+                                   'repository.admin')
+    def fork(self, repo_name):
+        c.repo_info = Repository.get_by_repo_name(repo_name)
+        if not c.repo_info:
+            h.flash(_('%s repository is not mapped to db perhaps'
+                      ' it was created or renamed from the file system'
+                      ' please run the application again'
+                      ' in order to rescan repositories') % repo_name,
+                      category='error')
+
+            return redirect(url('home'))
+
+        defaults = self.__load_data(repo_name)
+
+        return htmlfill.render(
+            render('forks/fork.html'),
+            defaults=defaults,
+            encoding="UTF-8",
+            force_defaults=False
+        )
+
+
+    @NotAnonymous()
+    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
+                                   'repository.admin')
+    def fork_create(self, repo_name):
+        self.__load_defaults()
+        c.repo_info = Repository.get_by_repo_name(repo_name)
+        _form = RepoForkForm(old_data={'repo_type': c.repo_info.repo_type},
+                             repo_groups=c.repo_groups_choices,)()
+        form_result = {}
+        try:
+            form_result = _form.to_python(dict(request.POST))
+            # add org_path of repo so we can do a clone from it later
+            form_result['org_path'] = c.repo_info.repo_name
+
+            # create fork is done sometimes async on celery, db transaction
+            # management is handled there.
+            RepoModel().create_fork(form_result, self.rhodecode_user)
+            h.flash(_('forked %s repository as %s') \
+                      % (repo_name, form_result['repo_name']),
+                    category='success')
+        except formencode.Invalid, errors:
+            c.new_repo = errors.value['repo_name']
+
+            return htmlfill.render(
+                render('forks/fork.html'),
+                defaults=errors.value,
+                errors=errors.error_dict or {},
+                prefix_error=False,
+                encoding="UTF-8")
+        except Exception:
+            log.error(traceback.format_exc())
+            h.flash(_('An error occurred during repository forking %s') %
+                    repo_name, category='error')
+
+        return redirect(url('home'))

rhodecode/controllers/home.py

@@ -7,7 +7,7 b''
 
     :created_on: Feb 18, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -24,14 +24,13 b''
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import logging
-from operator import itemgetter
 
 from pylons import tmpl_context as c, request
 from paste.httpexceptions import HTTPBadRequest
 
 from rhodecode.lib.auth import LoginRequired
 from rhodecode.lib.base import BaseController, render
-from rhodecode.model.db import Group, Repository
+from rhodecode.model.db import Repository
 
 log = logging.getLogger(__name__)
 
@@ -43,10 +42,8 b' class HomeController(BaseController):'
         super(HomeController, self).__before__()
 
     def index(self):
-
         c.repos_list = self.scm_model.get_repos()
-
-        c.groups = Group.query().filter(Group.group_parent_id == None).all()
+        c.groups = self.scm_model.get_repos_groups()
 
         return render('/index.html')
 
@@ -58,3 +55,11 b' class HomeController(BaseController):'
             return render('/repo_switcher_list.html')
         else:
             return HTTPBadRequest()
+
+    def branch_tag_switcher(self, repo_name):
+        if request.is_xhr:
+            c.rhodecode_db_repo = Repository.get_by_repo_name(c.repo_name)
+            c.rhodecode_repo = c.rhodecode_db_repo.scm_instance
+            return render('/switch_to_list.html')
+        else:
+            return HTTPBadRequest()

rhodecode/controllers/journal.py

@@ -7,7 +7,7 b''
 
     :created_on: Nov 21, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -23,21 +23,24 b''
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import logging
+from itertools import groupby
 
 from sqlalchemy import or_
-from sqlalchemy.orm import joinedload, make_transient
+from sqlalchemy.orm import joinedload
 from webhelpers.paginate import Page
-from itertools import groupby
+from webhelpers.feedgenerator import Atom1Feed, Rss201rev2Feed
 
 from paste.httpexceptions import HTTPBadRequest
 from pylons import request, tmpl_context as c, response, url
 from pylons.i18n.translation import _
-from webhelpers.feedgenerator import Atom1Feed, Rss201rev2Feed
 
 import rhodecode.lib.helpers as h
 from rhodecode.lib.auth import LoginRequired, NotAnonymous
 from rhodecode.lib.base import BaseController, render
-from rhodecode.model.db import UserLog, UserFollowing
+from rhodecode.model.db import UserLog, UserFollowing, Repository, User
+from rhodecode.model.meta import Session
+from sqlalchemy.sql.expression import func
+from rhodecode.model.scm import ScmModel
 
 log = logging.getLogger(__name__)
 
@@ -58,6 +61,13 b' class JournalController(BaseController):'
         # Return a rendered template
         p = int(request.params.get('page', 1))
 
+        c.user = User.get(self.rhodecode_user.user_id)
+        all_repos = self.sa.query(Repository)\
+                     .filter(Repository.user_id == c.user.user_id)\
+                     .order_by(func.lower(Repository.repo_name)).all()
+
+        c.user_repos = ScmModel().get_repos(all_repos)
+
         c.following = self.sa.query(UserFollowing)\
             .filter(UserFollowing.user_id == self.rhodecode_user.user_id)\
             .options(joinedload(UserFollowing.follows_repository))\
@@ -124,6 +134,7 b' class JournalController(BaseController):'
                 try:
                     self.scm_model.toggle_following_user(user_id,
                                                 self.rhodecode_user.user_id)
+                    Session.commit()
                     return 'ok'
                 except:
                     raise HTTPBadRequest()
@@ -133,11 +144,12 b' class JournalController(BaseController):'
                 try:
                     self.scm_model.toggle_following_repo(repo_id,
                                                 self.rhodecode_user.user_id)
+                    Session.commit()
                     return 'ok'
                 except:
                     raise HTTPBadRequest()
 
-        log.debug('token mismatch %s vs %s', cur_token, token)
+        log.debug('token mismatch %s vs %s' % (cur_token, token))
         raise HTTPBadRequest()
 
     @LoginRequired()

rhodecode/controllers/login.py

@@ -7,7 +7,7 b''
 
     :created_on: Apr 22, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -38,6 +38,7 b' from rhodecode.lib.base import BaseContr'
 from rhodecode.model.db import User
 from rhodecode.model.forms import LoginForm, RegisterForm, PasswordResetForm
 from rhodecode.model.user import UserModel
+from rhodecode.model.meta import Session
 
 
 log = logging.getLogger(__name__)
@@ -49,7 +50,7 b' class LoginController(BaseController):'
         super(LoginController, self).__before__()
 
     def index(self):
-        #redirect if already logged in
+        # redirect if already logged in
         c.came_from = request.GET.get('came_from', None)
 
         if self.rhodecode_user.is_authenticated \
@@ -58,21 +59,28 b' class LoginController(BaseController):'
             return redirect(url('home'))
 
         if request.POST:
-            #import Login Form validator class
+            # import Login Form validator class
             login_form = LoginForm()
             try:
                 c.form_result = login_form.to_python(dict(request.POST))
-                #form checks for username/password, now we're authenticated
+                # form checks for username/password, now we're authenticated
                 username = c.form_result['username']
                 user = User.get_by_username(username, case_insensitive=True)
                 auth_user = AuthUser(user.user_id)
                 auth_user.set_authenticated()
-                session['rhodecode_user'] = auth_user
+                cs = auth_user.get_cookie_store()
+                session['rhodecode_user'] = cs
+                # If they want to be remembered, update the cookie
+                if c.form_result['remember'] is not False:
+                    session.cookie_expires = False
+                    session._set_cookie_values()
+                session._update_cookie_out()
                 session.save()
 
-                log.info('user %s is now authenticated and stored in session',
-                         username)
+                log.info('user %s is now authenticated and stored in '
+                         'session, session attrs %s' % (username, cs))
                 user.update_lastlogin()
+                Session.commit()
 
                 if c.came_from:
                     return redirect(c.came_from)
@@ -92,7 +100,6 b' class LoginController(BaseController):'
     @HasPermissionAnyDecorator('hg.admin', 'hg.register.auto_activate',
                                'hg.register.manual_activate')
     def register(self):
-        user_model = UserModel()
         c.auto_active = False
         for perm in User.get_by_username('default').user_perms:
             if perm.permission.permission_name == 'hg.register.auto_activate':
@@ -105,9 +112,10 b' class LoginController(BaseController):'
             try:
                 form_result = register_form.to_python(dict(request.POST))
                 form_result['active'] = c.auto_active
-                user_model.create_registration(form_result)
+                UserModel().create_registration(form_result)
                 h.flash(_('You have successfully registered into rhodecode'),
                             category='success')
+                Session.commit()
                 return redirect(url('login_home'))
 
             except formencode.Invalid, errors:
@@ -121,13 +129,11 b' class LoginController(BaseController):'
         return render('/register.html')
 
     def password_reset(self):
-        user_model = UserModel()
         if request.POST:
-
             password_reset_form = PasswordResetForm()()
             try:
                 form_result = password_reset_form.to_python(dict(request.POST))
-                user_model.reset_password_link(form_result)
+                UserModel().reset_password_link(form_result)
                 h.flash(_('Your password reset link was sent'),
                             category='success')
                 return redirect(url('login_home'))
@@ -143,13 +149,11 b' class LoginController(BaseController):'
         return render('/password_reset.html')
 
     def password_reset_confirmation(self):
-
         if request.GET and request.GET.get('key'):
             try:
-                user_model = UserModel()
                 user = User.get_by_api_key(request.GET.get('key'))
                 data = dict(email=user.email)
-                user_model.reset_password(data)
+                UserModel().reset_password(data)
                 h.flash(_('Your password reset was successful, '
                           'new password has been sent to your email'),
                             category='success')
@@ -160,7 +164,6 b' class LoginController(BaseController):'
         return redirect(url('login_home'))
 
     def logout(self):
-        del session['rhodecode_user']
-        session.save()
-        log.info('Logging out and setting user as Empty')
+        session.delete()
+        log.info('Logging out and deleting session for user')
         redirect(url('home'))

rhodecode/controllers/search.py

@@ -7,7 +7,7 b''
 
     :created_on: Aug 7, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -26,7 +26,7 b' import logging'
 import traceback
 
 from pylons.i18n.translation import _
-from pylons import request, config, session, tmpl_context as c
+from pylons import request, config, tmpl_context as c
 
 from rhodecode.lib.auth import LoginRequired
 from rhodecode.lib.base import BaseController, render
@@ -76,7 +76,7 b' class SearchController(BaseController):'
                     cur_query = u'repository:%s %s' % (c.repo_name, cur_query)
                 try:
                     query = qp.parse(unicode(cur_query))
-
+                    # extract words for highlight
                     if isinstance(query, Phrase):
                         highlight_items.update(query.words)
                     elif isinstance(query, Prefix):
@@ -92,18 +92,22 b' class SearchController(BaseController):'
                     log.debug(highlight_items)
                     results = searcher.search(query)
                     res_ln = len(results)
-                    c.runtime = '%s results (%.3f seconds)' \
-                        % (res_ln, results.runtime)
+                    c.runtime = '%s results (%.3f seconds)' % (
+                        res_ln, results.runtime
+                    )
 
                     def url_generator(**kw):
                         return update_params("?q=%s&type=%s" \
                                            % (c.cur_query, c.cur_search), **kw)
 
                     c.formated_results = Page(
-                                ResultWrapper(search_type, searcher, matcher,
-                                              highlight_items),
-                                page=p, item_count=res_ln,
-                                items_per_page=10, url=url_generator)
+                        ResultWrapper(search_type, searcher, matcher,
+                                      highlight_items),
+                        page=p,
+                        item_count=res_ln,
+                        items_per_page=10,
+                        url=url_generator
+                    )
 
                 except QueryParserError:
                     c.runtime = _('Invalid search query. Try quoting it.')
@@ -117,5 +121,6 b' class SearchController(BaseController):'
                 log.error(traceback.format_exc())
                 c.runtime = _('An error occurred during this search operation')
 
+
         # Return a rendered template
         return render('/search/search.html')

rhodecode/controllers/settings.py

@@ -7,7 +7,7 b''
 
     :created_on: Jun 30, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -35,14 +35,14 b' from pylons.i18n.translation import _'
 
 import rhodecode.lib.helpers as h
 
-from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAllDecorator, \
-    HasRepoPermissionAnyDecorator, NotAnonymous
+from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAllDecorator
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.utils import invalidate_cache, action_logger
 
-from rhodecode.model.forms import RepoSettingsForm, RepoForkForm
+from rhodecode.model.forms import RepoSettingsForm
 from rhodecode.model.repo import RepoModel
-from rhodecode.model.db import Group
+from rhodecode.model.db import RepoGroup
+from rhodecode.model.meta import Session
 
 log = logging.getLogger(__name__)
 
@@ -52,15 +52,15 b' class SettingsController(BaseRepoControl'
     @LoginRequired()
     def __before__(self):
         super(SettingsController, self).__before__()
-    
+
     def __load_defaults(self):
-        c.repo_groups = Group.groups_choices()
+        c.repo_groups = RepoGroup.groups_choices()
         c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)
-        
+
         repo_model = RepoModel()
         c.users_array = repo_model.get_users_js()
         c.users_groups_array = repo_model.get_users_groups_js()
-        
+
     @HasRepoPermissionAllDecorator('repository.admin')
     def index(self, repo_name):
         repo_model = RepoModel()
@@ -89,15 +89,15 b' class SettingsController(BaseRepoControl'
     def update(self, repo_name):
         repo_model = RepoModel()
         changed_name = repo_name
-        
+
         self.__load_defaults()
-        
+
         _form = RepoSettingsForm(edit=True,
                                  old_data={'repo_name': repo_name},
                                  repo_groups=c.repo_groups_choices)()
         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),
@@ -105,6 +105,7 b' class SettingsController(BaseRepoControl'
             changed_name = form_result['repo_name_full']
             action_logger(self.rhodecode_user, 'user_updated_repo',
                           changed_name, '', self.sa)
+            Session.commit()
         except formencode.Invalid, errors:
             c.repo_info = repo_model.get_by_repo_name(repo_name)
             c.users_array = repo_model.get_users_js()
@@ -148,61 +149,10 b' class SettingsController(BaseRepoControl'
             repo_model.delete(repo)
             invalidate_cache('get_repo_cached_%s' % repo_name)
             h.flash(_('deleted repository %s') % repo_name, category='success')
+            Session.commit()
         except Exception:
             log.error(traceback.format_exc())
             h.flash(_('An error occurred during deletion of %s') % repo_name,
                     category='error')
 
         return redirect(url('home'))
-
-    @NotAnonymous()
-    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
-                                   'repository.admin')
-    def fork(self, repo_name):
-        repo_model = RepoModel()
-        c.repo_info = repo = repo_model.get_by_repo_name(repo_name)
-        if not repo:
-            h.flash(_('%s repository is not mapped to db perhaps'
-                      ' it was created or renamed from the file system'
-                      ' please run the application again'
-                      ' in order to rescan repositories') % repo_name,
-                      category='error')
-
-            return redirect(url('home'))
-
-        return render('settings/repo_fork.html')
-
-    @NotAnonymous()
-    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',
-                                   'repository.admin')
-    def fork_create(self, repo_name):
-        repo_model = RepoModel()
-        c.repo_info = repo_model.get_by_repo_name(repo_name)
-        _form = RepoForkForm(old_data={'repo_type': c.repo_info.repo_type})()
-        form_result = {}
-        try:
-            form_result = _form.to_python(dict(request.POST))
-            form_result.update({'repo_name': repo_name})
-            repo_model.create_fork(form_result, self.rhodecode_user)
-            h.flash(_('forked %s repository as %s') \
-                      % (repo_name, form_result['fork_name']),
-                    category='success')
-            action_logger(self.rhodecode_user,
-                          'user_forked_repo:%s' % form_result['fork_name'],
-                           repo_name, '', self.sa)
-        except formencode.Invalid, errors:
-            c.new_repo = errors.value['fork_name']
-            r = render('settings/repo_fork.html')
-
-            return htmlfill.render(
-                r,
-                defaults=errors.value,
-                errors=errors.error_dict or {},
-                prefix_error=False,
-                encoding="UTF-8")
-        except Exception:
-            log.error(traceback.format_exc())
-            h.flash(_('An error occurred during repository forking %s') %
-                    repo_name, category='error')
-
-        return redirect(url('home'))

rhodecode/controllers/shortlog.py

@@ -7,7 +7,7 b''
 
     :created_on: Apr 18, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -30,6 +30,7 b' from pylons import tmpl_context as c, re'
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.helpers import RepoPage
+from pylons.controllers.util import redirect
 
 log = logging.getLogger(__name__)
 
@@ -50,8 +51,11 b' class ShortlogController(BaseRepoControl'
             return url('shortlog_home', repo_name=repo_name, size=size, **kw)
 
         c.repo_changesets = RepoPage(c.rhodecode_repo, page=p,
-                                                       items_per_page=size,
-                                                       url=url_generator)
+                                    items_per_page=size, url=url_generator)
+
+        if not c.repo_changesets:
+            return redirect(url('summary_home', repo_name=repo_name))
+
         c.shortlog_data = render('shortlog/shortlog_data.html')
         if request.environ.get('HTTP_X_PARTIAL_XHR'):
             return c.shortlog_data

rhodecode/controllers/summary.py

@@ -7,7 +7,7 b''
 
     :created_on: Apr 18, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -23,23 +23,28 b''
 # You should have received a copy of the GNU General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+import traceback
 import calendar
 import logging
 from time import mktime
-from datetime import datetime, timedelta, date
+from datetime import timedelta, date
+from itertools import product
+from urlparse import urlparse
 
-from vcs.exceptions import ChangesetError
+from rhodecode.lib.vcs.exceptions import ChangesetError, EmptyRepositoryError, \
+    NodeDoesNotExistError
 
-from pylons import tmpl_context as c, request, url
+from pylons import tmpl_context as c, request, url, config
 from pylons.i18n.translation import _
 
-from rhodecode.model.db import Statistics, Repository
-from rhodecode.model.repo import RepoModel
+from beaker.cache import cache_region, region_invalidate
 
+from rhodecode.model.db import Statistics, CacheInvalidation
+from rhodecode.lib import ALL_READMES, ALL_EXTS
 from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator
 from rhodecode.lib.base import BaseRepoController, render
 from rhodecode.lib.utils import EmptyChangeset
-
+from rhodecode.lib.markup_renderer import MarkupRenderer
 from rhodecode.lib.celerylib import run_task
 from rhodecode.lib.celerylib.tasks import get_commits_stats, \
     LANGUAGES_EXTENSIONS_MAP
@@ -48,6 +53,10 b' from rhodecode.lib.compat import json, O'
 
 log = logging.getLogger(__name__)
 
+README_FILES = [''.join([x[0][0], x[1][0]]) for x in
+                    sorted(list(product(ALL_READMES, ALL_EXTS)),
+                           key=lambda y:y[0][1] + y[1][1])]
+
 
 class SummaryController(BaseRepoController):
 
@@ -58,10 +67,7 b' class SummaryController(BaseRepoControll'
         super(SummaryController, self).__before__()
 
     def index(self, repo_name):
-
-        e = request.environ
         c.dbrepo = dbrepo = c.rhodecode_db_repo
-
         c.following = self.scm_model.is_following_repo(repo_name,
                                                 self.rhodecode_user.user_id)
 
@@ -72,26 +78,34 b' class SummaryController(BaseRepoControll'
                                      items_per_page=10, url=url_generator)
 
         if self.rhodecode_user.username == 'default':
-            #for default(anonymous) user we don't need to pass credentials
+            # for default(anonymous) user we don't need to pass credentials
             username = ''
             password = ''
         else:
             username = str(self.rhodecode_user.username)
             password = '@'
 
-        if e.get('wsgi.url_scheme') == 'https':
-            split_s = 'https://'
-        else:
-            split_s = 'http://'
+        parsed_url = urlparse(url.current(qualified=True))
+
+        default_clone_uri = '{scheme}://{user}{pass}{netloc}{path}'
+
+        uri_tmpl = config.get('clone_uri', default_clone_uri)
+        uri_tmpl = uri_tmpl.replace('{', '%(').replace('}', ')s')
 
-        qualified_uri = [split_s] + [url.current(qualified=True)\
-                                     .split(split_s)[-1]]
-        uri = u'%(proto)s%(user)s%(pass)s%(rest)s' \
-                % {'user': username,
-                     'pass': password,
-                     'proto': qualified_uri[0],
-                     'rest': qualified_uri[1]}
+        uri_dict = {
+           'user': username,
+           'pass': password,
+           'scheme': parsed_url.scheme,
+           'netloc': parsed_url.netloc,
+           'path': parsed_url.path
+        }
+        uri = uri_tmpl % uri_dict
+        # generate another clone url by id
+        uri_dict.update({'path': '/_%s' % c.dbrepo.repo_id})
+        uri_id = uri_tmpl % uri_dict
+
         c.clone_repo_url = uri
+        c.clone_repo_url_id = uri_id
         c.repo_tags = OrderedDict()
         for name, hash in c.rhodecode_repo.tags.items()[:10]:
             try:
@@ -161,8 +175,44 b' class SummaryController(BaseRepoControll'
         if c.enable_downloads:
             c.download_options = self._get_download_links(c.rhodecode_repo)
 
+        c.readme_data, c.readme_file = self.__get_readme_data(c.rhodecode_repo)
         return render('summary/summary.html')
 
+    def __get_readme_data(self, repo):
+
+        @cache_region('long_term')
+        def _get_readme_from_cache(key):
+            readme_data = None
+            readme_file = None
+            log.debug('Fetching readme file')
+            try:
+                cs = repo.get_changeset('tip')
+                renderer = MarkupRenderer()
+                for f in README_FILES:
+                    try:
+                        readme = cs.get_node(f)
+                        readme_file = f
+                        readme_data = renderer.render(readme.content, f)
+                        log.debug('Found readme %s' % readme_file)
+                        break
+                    except NodeDoesNotExistError:
+                        continue
+            except ChangesetError:
+                pass
+            except EmptyRepositoryError:
+                pass
+            except Exception:
+                log.error(traceback.format_exc())
+
+            return readme_data, readme_file
+
+        key = repo.name + '_README'
+        inv = CacheInvalidation.invalidate(key)
+        if inv is not None:
+            region_invalidate(_get_readme_from_cache, None, key)
+            CacheInvalidation.set_valid(inv.cache_key)
+        return _get_readme_from_cache(key)
+
     def _get_download_links(self, repo):
 
         download_l = []

rhodecode/controllers/tags.py

@@ -7,7 +7,7 b''
 
     :created_on: Apr 21, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify

rhodecode/lib/__init__.py

@@ -24,6 +24,9 b''
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 import os
+import re
+from rhodecode.lib.vcs.utils.lazy import LazyProperty
+
 
 def __get_lem():
     from pygments import lexers
@@ -66,6 +69,34 b" ADDITIONAL_MAPPINGS = {'xaml': 'XAML'}"
 
 LANGUAGES_EXTENSIONS_MAP.update(ADDITIONAL_MAPPINGS)
 
+# list of readme files to search in file tree and display in summary
+# attached weights defines the search  order lower is first
+ALL_READMES = [
+    ('readme', 0), ('README', 0), ('Readme', 0),
+    ('doc/readme', 1), ('doc/README', 1), ('doc/Readme', 1),
+    ('Docs/readme', 2), ('Docs/README', 2), ('Docs/Readme', 2),
+    ('DOCS/readme', 2), ('DOCS/README', 2), ('DOCS/Readme', 2),
+    ('docs/readme', 2), ('docs/README', 2), ('docs/Readme', 2),
+]
+
+# extension together with weights to search lower is first
+RST_EXTS = [
+    ('', 0), ('.rst', 1), ('.rest', 1),
+    ('.RST', 2), ('.REST', 2),
+    ('.txt', 3), ('.TXT', 3)
+]
+
+MARKDOWN_EXTS = [
+    ('.md', 1), ('.MD', 1),
+    ('.mkdn', 2), ('.MKDN', 2),
+    ('.mdown', 3), ('.MDOWN', 3),
+    ('.markdown', 4), ('.MARKDOWN', 4)
+]
+
+PLAIN_EXTS = [('.text', 2), ('.TEXT', 2)]
+
+ALL_EXTS = MARKDOWN_EXTS + RST_EXTS + PLAIN_EXTS
+
 
 def str2bool(_str):
     """
@@ -107,7 +138,6 b' def convert_line_endings(line, mode):'
             line = replace(line, '\r\n', '\r')
             line = replace(line, '\n', '\r')
     elif mode == 2:
-            import re
             line = re.sub("\r(?!\n)|(?<!\r)\n", "\r\n", line)
     return line
 
@@ -151,7 +181,7 b' def generate_api_key(username, salt=None'
     return hashlib.sha1(username + salt).hexdigest()
 
 
-def safe_unicode(str_, from_encoding='utf8'):
+def safe_unicode(str_, from_encoding=None):
     """
     safe unicode function. Does few trick to turn str_ into unicode
 
@@ -165,6 +195,11 b" def safe_unicode(str_, from_encoding='ut"
     if isinstance(str_, unicode):
         return str_
 
+    if not from_encoding:
+        import rhodecode
+        DEFAULT_ENCODING = rhodecode.CONFIG.get('default_encoding','utf8')
+        from_encoding = DEFAULT_ENCODING
+
     try:
         return unicode(str_)
     except UnicodeDecodeError:
@@ -184,10 +219,11 b" def safe_unicode(str_, from_encoding='ut"
     except (ImportError, UnicodeDecodeError, Exception):
         return unicode(str_, from_encoding, 'replace')
 
-def safe_str(unicode_, to_encoding='utf8'):
+
+def safe_str(unicode_, to_encoding=None):
     """
     safe str function. Does few trick to turn unicode_ into string
-     
+
     In case of UnicodeEncodeError we try to return it with encoding detected
     by chardet library if it fails fallback to string with errors replaced
 
@@ -199,9 +235,17 b" def safe_str(unicode_, to_encoding='utf8"
     if not isinstance(unicode_, basestring):
         return str(unicode_)
 
+    if not isinstance(unicode_, basestring):
+        return str(unicode_)
+
     if isinstance(unicode_, str):
         return unicode_
 
+    if not to_encoding:
+        import rhodecode
+        DEFAULT_ENCODING = rhodecode.CONFIG.get('default_encoding','utf8')
+        to_encoding = DEFAULT_ENCODING
+
     try:
         return unicode_.encode(to_encoding)
     except UnicodeEncodeError:
@@ -221,11 +265,10 b" def safe_str(unicode_, to_encoding='utf8"
     return safe_str
 
 
-
 def engine_from_config(configuration, prefix='sqlalchemy.', **kwargs):
     """
     Custom engine_from_config functions that makes sure we use NullPool for
-    file based sqlite databases. This prevents errors on sqlite. This only 
+    file based sqlite databases. This prevents errors on sqlite. This only
     applies to sqlalchemy versions < 0.7.0
 
     """
@@ -284,7 +327,7 b' def engine_from_config(configuration, pr'
 def age(curdate):
     """
     turns a datetime into an age string.
-    
+
     :param curdate: datetime object
     :rtype: unicode
     :returns: unicode words describing age
@@ -293,7 +336,7 b' def age(curdate):'
     from datetime import datetime
     from webhelpers.date import time_ago_in_words
 
-    _ = lambda s:s
+    _ = lambda s: s
 
     if not curdate:
         return ''
@@ -310,7 +353,8 b' def age(curdate):'
     pos = 1
     for scale in agescales:
         if scale[1] <= age_seconds:
-            if pos == 6:pos = 5
+            if pos == 6:
+                pos = 5
             return '%s %s' % (time_ago_in_words(curdate,
                                                 agescales[pos][0]), _('ago'))
         pos += 1
@@ -321,10 +365,10 b' def age(curdate):'
 def uri_filter(uri):
     """
     Removes user:password from given url string
-    
+
     :param uri:
     :rtype: unicode
-    :returns: filtered list of strings  
+    :returns: filtered list of strings
     """
     if not uri:
         return ''
@@ -353,7 +397,7 b' def uri_filter(uri):'
 def credentials_filter(uri):
     """
     Returns a url with removed credentials
-    
+
     :param uri:
     """
 
@@ -364,16 +408,17 b' def credentials_filter(uri):'
 
     return ''.join(uri)
 
+
 def get_changeset_safe(repo, rev):
     """
-    Safe version of get_changeset if this changeset doesn't exists for a 
+    Safe version of get_changeset if this changeset doesn't exists for a
     repo it returns a Dummy one instead
-    
+
     :param repo:
     :param rev:
     """
-    from vcs.backends.base import BaseRepository
-    from vcs.exceptions import RepositoryError
+    from rhodecode.lib.vcs.backends.base import BaseRepository
+    from rhodecode.lib.vcs.exceptions import RepositoryError
     if not isinstance(repo, BaseRepository):
         raise Exception('You must pass an Repository '
                         'object as first argument got %s', type(repo))
@@ -390,13 +435,13 b' def get_current_revision(quiet=False):'
     """
     Returns tuple of (number, id) from repository containing this package
     or None if repository could not be found.
-    
+
     :param quiet: prints error for fetching revision if True
     """
 
     try:
-        from vcs import get_repo
-        from vcs.utils.helpers import get_scm
+        from rhodecode.lib.vcs import get_repo
+        from rhodecode.lib.vcs.utils.helpers import get_scm
         repopath = os.path.join(os.path.dirname(__file__), '..', '..')
         scm = get_scm(repopath)[0]
         repo = get_repo(path=repopath, alias=scm)
@@ -408,3 +453,15 b' def get_current_revision(quiet=False):'
                    "was: %s" % err)
         return None
 
+
+def extract_mentioned_users(s):
+    """
+    Returns unique usernames from given string s that have @mention
+
+    :param s: string to get mentions
+    """
+    usrs = {}
+    for username in re.findall(r'(?:^@|\s@)(\w+)', s):
+        usrs[username] = username
+
+    return sorted(usrs.keys())

rhodecode/lib/auth.py

@@ -6,7 +6,8 b''
     authentication and permission libraries
 
     :created_on: Apr 4, 2010
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :author: marcink
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -30,11 +31,12 b' import hashlib'
 from tempfile import _RandomNameSequence
 from decorator import decorator
 
-from pylons import config, session, url, request
+from pylons import config, url, request
 from pylons.controllers.util import abort, redirect
 from pylons.i18n.translation import _
 
 from rhodecode import __platform__, PLATFORM_WIN, PLATFORM_OTHERS
+from rhodecode.model.meta import Session
 
 if __platform__ in PLATFORM_WIN:
     from hashlib import sha256
@@ -43,20 +45,22 b' if __platform__ in PLATFORM_OTHERS:'
 
 from rhodecode.lib import str2bool, safe_unicode
 from rhodecode.lib.exceptions import LdapPasswordError, LdapUsernameError
-from rhodecode.lib.utils import get_repo_slug
+from rhodecode.lib.utils import get_repo_slug, get_repos_group_slug
 from rhodecode.lib.auth_ldap import AuthLdap
 
 from rhodecode.model import meta
 from rhodecode.model.user import UserModel
-from rhodecode.model.db import Permission, RhodeCodeSettings, User
+from rhodecode.model.db import Permission, RhodeCodeSetting, User
 
 log = logging.getLogger(__name__)
 
 
 class PasswordGenerator(object):
-    """This is a simple class for generating password from
-        different sets of characters
-        usage:
+    """
+    This is a simple class for generating password from different sets of
+    characters
+    usage::
+
         passwd_gen = PasswordGenerator()
         #print 8-letter password containing only big and small letters
             of alphabet
@@ -128,15 +132,24 b' def check_password(password, hashed):'
     return RhodeCodeCrypto.hash_check(password, hashed)
 
 
-def generate_api_key(username, salt=None):
+def generate_api_key(str_, salt=None):
+    """
+    Generates API KEY from given string
+
+    :param str_:
+    :param salt:
+    """
+
     if salt is None:
         salt = _RandomNameSequence().next()
 
-    return hashlib.sha1(username + salt).hexdigest()
+    return hashlib.sha1(str_ + salt).hexdigest()
 
 
 def authfunc(environ, username, password):
-    """Dummy authentication function used in Mercurial/Git/ and access control,
+    """
+    Dummy authentication wrapper function used in Mercurial and Git for
+    access control.
 
     :param environ: needed only for using in Basic auth
     """
@@ -144,7 +157,8 b' def authfunc(environ, username, password'
 
 
 def authenticate(username, password):
-    """Authentication function used for access control,
+    """
+    Authentication function used for access control,
     firstly checks for db authentication then if ldap is enabled for ldap
     authentication, also creates ldap user if not in database
 
@@ -159,16 +173,16 b' def authenticate(username, password):'
     if user is not None and not user.ldap_dn:
         if user.active:
             if user.username == 'default' and user.active:
-                log.info('user %s authenticated correctly as anonymous user',
+                log.info('user %s authenticated correctly as anonymous user' %
                          username)
                 return True
 
             elif user.username == username and check_password(password,
                                                               user.password):
-                log.info('user %s authenticated correctly', username)
+                log.info('user %s authenticated correctly' % username)
                 return True
         else:
-            log.warning('user %s is disabled', username)
+            log.warning('user %s tried auth but is disabled' % username)
 
     else:
         log.debug('Regular authentication failed')
@@ -178,7 +192,7 b' def authenticate(username, password):'
             log.debug('this user already exists as non ldap')
             return False
 
-        ldap_settings = RhodeCodeSettings.get_ldap_settings()
+        ldap_settings = RhodeCodeSetting.get_ldap_settings()
         #======================================================================
         # FALLBACK TO LDAP AUTH IF ENABLE
         #======================================================================
@@ -202,7 +216,7 b' def authenticate(username, password):'
                 aldap = AuthLdap(**kwargs)
                 (user_dn, ldap_attrs) = aldap.authenticate_ldap(username,
                                                                 password)
-                log.debug('Got ldap DN response %s', user_dn)
+                log.debug('Got ldap DN response %s' % user_dn)
 
                 get_ldap_attr = lambda k: ldap_attrs.get(ldap_settings\
                                                            .get(k), [''])[0]
@@ -222,6 +236,7 b' def authenticate(username, password):'
                                           user_attrs):
                     log.info('created new ldap user %s' % username)
 
+                Session.commit()
                 return True
             except (LdapUsernameError, LdapPasswordError,):
                 pass
@@ -231,6 +246,64 b' def authenticate(username, password):'
     return False
 
 
+def login_container_auth(username):
+    user = User.get_by_username(username)
+    if user is None:
+        user_attrs = {
+            'name': username,
+            'lastname': None,
+            'email': None,
+        }
+        user = UserModel().create_for_container_auth(username, user_attrs)
+        if not user:
+            return None
+        log.info('User %s was created by container authentication' % username)
+
+    if not user.active:
+        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):
+    username = None
+
+    if str2bool(config.get('container_auth_enabled', False)):
+        from paste.httpheaders import REMOTE_USER
+        username = REMOTE_USER(environ)
+
+    if not username and str2bool(config.get('proxypass_auth_enabled', False)):
+        username = environ.get('HTTP_X_FORWARDED_USER')
+
+    if username:
+        # Removing realm and domain from username
+        username = username.partition('@')[0]
+        username = username.rpartition('\\')[2]
+        log.debug('Received username %s from container' % username)
+
+    return username
+
+
+class CookieStoreWrapper(object):
+
+    def __init__(self, cookie_store):
+        self.cookie_store = cookie_store
+
+    def __repr__(self):
+        return 'CookieStore<%s>' % (self.cookie_store)
+
+    def get(self, key, other=None):
+        if isinstance(self.cookie_store, dict):
+            return self.cookie_store.get(key, other)
+        elif isinstance(self.cookie_store, AuthUser):
+            return self.cookie_store.__dict__.get(key, other)
+
+
 class  AuthUser(object):
     """
     A simple object that handles all attributes of user in RhodeCode
@@ -241,12 +314,12 b' class AuthUser(object):'
     in
     """
 
-    def __init__(self, user_id=None, api_key=None):
+    def __init__(self, user_id=None, api_key=None, username=None):
 
         self.user_id = user_id
         self.api_key = None
+        self.username = username
 
-        self.username = 'None'
         self.name = ''
         self.lastname = ''
         self.email = ''
@@ -255,51 +328,85 b' class AuthUser(object):'
         self.permissions = {}
         self._api_key = api_key
         self.propagate_data()
+        self._instance = None
 
     def propagate_data(self):
         user_model = UserModel()
-        self.anonymous_user = User.get_by_username('default')
+        self.anonymous_user = User.get_by_username('default', cache=True)
+        is_user_loaded = False
+
+        # try go get user by api key
         if self._api_key and self._api_key != self.anonymous_user.api_key:
-            #try go get user by api key
-            log.debug('Auth User lookup by API KEY %s', self._api_key)
-            user_model.fill_data(self, api_key=self._api_key)
-        else:
-            log.debug('Auth User lookup by USER ID %s', self.user_id)
-            if self.user_id is not None \
-                and self.user_id != self.anonymous_user.user_id:
-                user_model.fill_data(self, user_id=self.user_id)
+            log.debug('Auth User lookup by API KEY %s' % self._api_key)
+            is_user_loaded = user_model.fill_data(self, api_key=self._api_key)
+        # lookup by userid
+        elif (self.user_id is not None and
+              self.user_id != self.anonymous_user.user_id):
+            log.debug('Auth User lookup by USER ID %s' % self.user_id)
+            is_user_loaded = user_model.fill_data(self, user_id=self.user_id)
+        # lookup by username
+        elif self.username and \
+            str2bool(config.get('container_auth_enabled', False)):
+
+            log.debug('Auth User lookup by USER NAME %s' % self.username)
+            dbuser = login_container_auth(self.username)
+            if dbuser is not None:
+                for k, v in dbuser.get_dict().items():
+                    setattr(self, k, v)
+                self.set_authenticated()
+                is_user_loaded = True
+
+        if not is_user_loaded:
+            # if we cannot authenticate user try anonymous
+            if self.anonymous_user.active is True:
+                user_model.fill_data(self, user_id=self.anonymous_user.user_id)
+                # then we set this user is logged in
+                self.is_authenticated = True
             else:
-                if self.anonymous_user.active is True:
-                    user_model.fill_data(self,
-                                         user_id=self.anonymous_user.user_id)
-                    #then we set this user is logged in
-                    self.is_authenticated = True
-                else:
-                    self.is_authenticated = False
+                self.user_id = None
+                self.username = None
+                self.is_authenticated = False
 
-        log.debug('Auth User is now %s', self)
+        if not self.username:
+            self.username = 'None'
+
+        log.debug('Auth User is now %s' % self)
         user_model.fill_perms(self)
 
     @property
     def is_admin(self):
         return self.admin
 
-    @property
-    def full_contact(self):
-        return '%s %s <%s>' % (self.name, self.lastname, self.email)
-
     def __repr__(self):
         return "<AuthUser('id:%s:%s|%s')>" % (self.user_id, self.username,
                                               self.is_authenticated)
 
     def set_authenticated(self, authenticated=True):
-
         if self.user_id != self.anonymous_user.user_id:
             self.is_authenticated = authenticated
 
+    def get_cookie_store(self):
+        return {'username': self.username,
+                'user_id': self.user_id,
+                'is_authenticated': self.is_authenticated}
+
+    @classmethod
+    def from_cookie_store(cls, cookie_store):
+        """
+        Creates AuthUser from a cookie store
+
+        :param cls:
+        :param cookie_store:
+        """
+        user_id = cookie_store.get('user_id')
+        username = cookie_store.get('username')
+        api_key = cookie_store.get('api_key')
+        return AuthUser(user_id, api_key, username)
+
 
 def set_available_permissions(config):
-    """This function will propagate pylons globals with all available defined
+    """
+    This function will propagate pylons globals with all available defined
     permission given in db. We don't want to check each time from db for new
     permissions since adding a new permission also requires application restart
     ie. to decorate new views with the newly created permission
@@ -309,9 +416,9 b' def set_available_permissions(config):'
     """
     log.info('getting information about all available permissions')
     try:
-        sa = meta.Session()
+        sa = meta.Session
         all_perms = sa.query(Permission).all()
-    except:
+    except Exception:
         pass
     finally:
         meta.Session.remove()
@@ -343,26 +450,31 b' class LoginRequired(object):'
 
         api_access_ok = False
         if self.api_access:
-            log.debug('Checking API KEY access for %s', cls)
+            log.debug('Checking API KEY access for %s' % cls)
             if user.api_key == request.GET.get('api_key'):
                 api_access_ok = True
             else:
                 log.debug("API KEY token not valid")
-
-        log.debug('Checking if %s is authenticated @ %s', user.username, cls)
+        loc = "%s:%s" % (cls.__class__.__name__, func.__name__)
+        log.debug('Checking if %s is authenticated @ %s' % (user.username, loc))
         if user.is_authenticated or api_access_ok:
-            log.debug('user %s is authenticated', user.username)
+            log.info('user %s is authenticated and granted access to %s' % (
+                       user.username, loc)
+            )
             return func(*fargs, **fkwargs)
         else:
-            log.warn('user %s NOT authenticated', user.username)
+            log.warn('user %s NOT authenticated on func: %s' % (
+                user, loc)
+            )
             p = url.current()
 
-            log.debug('redirecting to login page with %s', p)
+            log.debug('redirecting to login page with %s' % p)
             return redirect(url('login_home', came_from=p))
 
 
 class NotAnonymous(object):
-    """Must be logged in to execute this function else
+    """
+    Must be logged in to execute this function else
     redirect to login page"""
 
     def __call__(self, func):
@@ -372,7 +484,7 b' class NotAnonymous(object):'
         cls = fargs[0]
         self.user = cls.rhodecode_user
 
-        log.debug('Checking if user is not anonymous @%s', cls)
+        log.debug('Checking if user is not anonymous @%s' % cls)
 
         anonymous = self.user.username == 'default'
 
@@ -411,13 +523,11 b' class PermsDecorator(object):'
                self.user)
 
         if self.check_permissions():
-            log.debug('Permission granted for %s %s', cls, self.user)
+            log.debug('Permission granted for %s %s' % (cls, self.user))
             return func(*fargs, **fkwargs)
 
         else:
-            log.warning('Permission denied for %s %s', cls, self.user)
-
-
+            log.debug('Permission denied for %s %s' % (cls, self.user))
             anonymous = self.user.username == 'default'
 
             if anonymous:
@@ -430,7 +540,7 b' class PermsDecorator(object):'
                 return redirect(url('login_home', came_from=p))
 
             else:
-                #redirect with forbidden ret code
+                # redirect with forbidden ret code
                 return abort(403)
 
     def check_permissions(self):
@@ -439,7 +549,8 b' class PermsDecorator(object):'
 
 
 class HasPermissionAllDecorator(PermsDecorator):
-    """Checks for access permission for all given predicates. All of them
+    """
+    Checks for access permission for all given predicates. All of them
     have to be meet in order to fulfill the request
     """
 
@@ -450,7 +561,8 b' class HasPermissionAllDecorator(PermsDec'
 
 
 class HasPermissionAnyDecorator(PermsDecorator):
-    """Checks for access permission for any of given predicates. In order to
+    """
+    Checks for access permission for any of given predicates. In order to
     fulfill the request any of predicates must be meet
     """
 
@@ -461,7 +573,8 b' class HasPermissionAnyDecorator(PermsDec'
 
 
 class HasRepoPermissionAllDecorator(PermsDecorator):
-    """Checks for access permission for all given predicates for specific
+    """
+    Checks for access permission for all given predicates for specific
     repository. All of them have to be meet in order to fulfill the request
     """
 
@@ -477,7 +590,8 b' class HasRepoPermissionAllDecorator(Perm'
 
 
 class HasRepoPermissionAnyDecorator(PermsDecorator):
-    """Checks for access permission for any of given predicates for specific
+    """
+    Checks for access permission for any of given predicates for specific
     repository. In order to fulfill the request any of predicates must be meet
     """
 
@@ -493,6 +607,41 b' class HasRepoPermissionAnyDecorator(Perm'
         return False
 
 
+class HasReposGroupPermissionAllDecorator(PermsDecorator):
+    """
+    Checks for access permission for all given predicates for specific
+    repository. All of them have to be meet in order to fulfill the request
+    """
+
+    def check_permissions(self):
+        group_name = get_repos_group_slug(request)
+        try:
+            user_perms = set([self.user_perms['repositories_groups'][group_name]])
+        except KeyError:
+            return False
+        if self.required_perms.issubset(user_perms):
+            return True
+        return False
+
+
+class HasReposGroupPermissionAnyDecorator(PermsDecorator):
+    """
+    Checks for access permission for any of given predicates for specific
+    repository. In order to fulfill the request any of predicates must be meet
+    """
+
+    def check_permissions(self):
+        group_name = get_repos_group_slug(request)
+
+        try:
+            user_perms = set([self.user_perms['repositories_groups'][group_name]])
+        except KeyError:
+            return False
+        if self.required_perms.intersection(user_perms):
+            return True
+        return False
+
+
 #==============================================================================
 # CHECK FUNCTIONS
 #==============================================================================
@@ -511,7 +660,7 b' class PermsFunction(object):'
         self.repo_name = None
 
     def __call__(self, check_Location=''):
-        user = session.get('rhodecode_user', False)
+        user = request.user
         if not user:
             return False
         self.user_perms = user.permissions
@@ -525,7 +674,7 b' class PermsFunction(object):'
             return True
 
         else:
-            log.warning('Permission denied for %s @ %s', self.granted_for,
+            log.debug('Permission denied for %s @ %s', self.granted_for,
                         check_Location or 'unspecified location')
             return False
 
@@ -559,8 +708,9 b' class HasRepoPermissionAll(PermsFunction'
             self.repo_name = get_repo_slug(request)
 
         try:
-            self.user_perms = set([self.user_perms['reposit'
-                                                   'ories'][self.repo_name]])
+            self.user_perms = set(
+                [self.user_perms['repositories'][self.repo_name]]
+            )
         except KeyError:
             return False
         self.granted_for = self.repo_name
@@ -580,8 +730,9 b' class HasRepoPermissionAny(PermsFunction'
             self.repo_name = get_repo_slug(request)
 
         try:
-            self.user_perms = set([self.user_perms['reposi'
-                                                   'tories'][self.repo_name]])
+            self.user_perms = set(
+                [self.user_perms['repositories'][self.repo_name]]
+            )
         except KeyError:
             return False
         self.granted_for = self.repo_name
@@ -590,6 +741,42 b' class HasRepoPermissionAny(PermsFunction'
         return False
 
 
+class HasReposGroupPermissionAny(PermsFunction):
+    def __call__(self, group_name=None, check_Location=''):
+        self.group_name = group_name
+        return super(HasReposGroupPermissionAny, self).__call__(check_Location)
+
+    def check_permissions(self):
+        try:
+            self.user_perms = set(
+                [self.user_perms['repositories_groups'][self.group_name]]
+            )
+        except KeyError:
+            return False
+        self.granted_for = self.repo_name
+        if self.required_perms.intersection(self.user_perms):
+            return True
+        return False
+
+
+class HasReposGroupPermissionAll(PermsFunction):
+    def __call__(self, group_name=None, check_Location=''):
+        self.group_name = group_name
+        return super(HasReposGroupPermissionAny, self).__call__(check_Location)
+
+    def check_permissions(self):
+        try:
+            self.user_perms = set(
+                [self.user_perms['repositories_groups'][self.group_name]]
+            )
+        except KeyError:
+            return False
+        self.granted_for = self.repo_name
+        if self.required_perms.issubset(self.user_perms):
+            return True
+        return False
+
+
 #==============================================================================
 # SPECIAL VERSION TO HANDLE MIDDLEWARE AUTH
 #==============================================================================

rhodecode/lib/auth_ldap.py

@@ -7,7 +7,7 b''
 
     :created_on: Created on Nov 17, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -43,8 +43,7 b' class AuthLdap(object):'
     def __init__(self, server, base_dn, port=389, bind_dn='', bind_pass='',
                  tls_kind='PLAIN', tls_reqcert='DEMAND', ldap_version=3,
                  ldap_filter='(&(objectClass=user)(!(objectClass=computer)))',
-                 search_scope='SUBTREE',
-                 attr_login='uid'):
+                 search_scope='SUBTREE', attr_login='uid'):
         self.ldap_version = ldap_version
         ldap_server_type = 'ldap'
 
@@ -53,14 +52,14 b' class AuthLdap(object):'
         if self.TLS_KIND == 'LDAPS':
             port = port or 689
             ldap_server_type = ldap_server_type + 's'
-        
+
         OPT_X_TLS_DEMAND = 2
-        self.TLS_REQCERT = getattr(ldap, 'OPT_X_TLS_%s' % tls_reqcert, 
+        self.TLS_REQCERT = getattr(ldap, 'OPT_X_TLS_%s' % tls_reqcert,
                                    OPT_X_TLS_DEMAND)
         self.LDAP_SERVER_ADDRESS = server
         self.LDAP_SERVER_PORT = port
 
-        #USE FOR READ ONLY BIND TO LDAP SERVER
+        # USE FOR READ ONLY BIND TO LDAP SERVER
         self.LDAP_BIND_DN = bind_dn
         self.LDAP_BIND_PASS = bind_pass
 
@@ -74,7 +73,8 b' class AuthLdap(object):'
         self.attr_login = attr_login
 
     def authenticate_ldap(self, username, password):
-        """Authenticate a user via LDAP and return his/her LDAP properties.
+        """
+        Authenticate a user via LDAP and return his/her LDAP properties.
 
         Raises AuthenticationError if the credentials are rejected, or
         EnvironmentError if the LDAP server can't be reached.
@@ -87,11 +87,15 b' class AuthLdap(object):'
 
         uid = chop_at(username, "@%s" % self.LDAP_SERVER_ADDRESS)
 
+        if not password:
+            log.debug("Attempt to authenticate LDAP user "
+                      "with blank password rejected.")
+            raise LdapPasswordError()
         if "," in username:
             raise LdapUsernameError("invalid character in username: ,")
         try:
-            if hasattr(ldap,'OPT_X_TLS_CACERTDIR'):
-                ldap.set_option(ldap.OPT_X_TLS_CACERTDIR, 
+            if hasattr(ldap, 'OPT_X_TLS_CACERTDIR'):
+                ldap.set_option(ldap.OPT_X_TLS_CACERTDIR,
                                 '/etc/openldap/cacerts')
             ldap.set_option(ldap.OPT_REFERRALS, ldap.OPT_OFF)
             ldap.set_option(ldap.OPT_RESTART, ldap.OPT_ON)
@@ -112,12 +116,12 b' class AuthLdap(object):'
             if self.LDAP_BIND_DN and self.LDAP_BIND_PASS:
                 server.simple_bind_s(self.LDAP_BIND_DN, self.LDAP_BIND_PASS)
 
-            filt = '(&%s(%s=%s))' % (self.LDAP_FILTER, self.attr_login,
+            filter_ = '(&%s(%s=%s))' % (self.LDAP_FILTER, self.attr_login,
                                      username)
-            log.debug("Authenticating %r filt %s at %s", self.BASE_DN,
-                      filt, self.LDAP_SERVER)
+            log.debug("Authenticating %r filter %s at %s", self.BASE_DN,
+                      filter_, self.LDAP_SERVER)
             lobjects = server.search_ext_s(self.BASE_DN, self.SEARCH_SCOPE,
-                                           filt)
+                                           filter_)
 
             if not lobjects:
                 raise ldap.NO_SUCH_OBJECT()
@@ -127,24 +131,28 b' class AuthLdap(object):'
                     continue
 
                 try:
+                    log.debug('Trying simple bind with %s' % dn)
                     server.simple_bind_s(dn, password)
                     attrs = server.search_ext_s(dn, ldap.SCOPE_BASE,
                                                 '(objectClass=*)')[0][1]
                     break
 
-                except ldap.INVALID_CREDENTIALS, e:
-                    log.debug("LDAP rejected password for user '%s' (%s): %s",
-                              uid, username, dn)
+                except ldap.INVALID_CREDENTIALS:
+                    log.debug(
+                        "LDAP rejected password for user '%s' (%s): %s" % (
+                            uid, username, dn
+                        )
+                    )
 
             else:
                 log.debug("No matching LDAP objects for authentication "
                           "of '%s' (%s)", uid, username)
                 raise LdapPasswordError()
 
-        except ldap.NO_SUCH_OBJECT, e:
-            log.debug("LDAP says no such user '%s' (%s)", uid, username)
+        except ldap.NO_SUCH_OBJECT:
+            log.debug("LDAP says no such user '%s' (%s)" % (uid, username))
             raise LdapUsernameError()
-        except ldap.SERVER_DOWN, e:
+        except ldap.SERVER_DOWN:
             raise LdapConnectionError("LDAP can't access "
                                       "authentication server")
 

rhodecode/lib/backup_manager.py

@@ -3,11 +3,12 b''
     rhodecode.lib.backup_manager
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    Mercurial repositories backup manager, it allows to backups all 
+    Mercurial repositories backup manager, it allows to backups all
     repositories and send it to backup server using RSA key via ssh.
 
     :created_on: Feb 28, 2010
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :author: marcink
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify

rhodecode/lib/base.py

@@ -3,35 +3,125 b''
 Provides the BaseController class for subclassing.
 """
 import logging
+import time
+import traceback
+
+from paste.auth.basic import AuthBasicAuthenticator
 
 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__
-from rhodecode.lib import str2bool
-from rhodecode.lib.auth import AuthUser
-from rhodecode.lib.utils import get_repo_slug
+from rhodecode import __version__, BACKENDS
+
+from rhodecode.lib import str2bool, safe_unicode
+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.db import Repository
+from rhodecode.model.notification import NotificationModel
 from rhodecode.model.scm import ScmModel
-from rhodecode import BACKENDS
-from rhodecode.model.db import Repository
 
 log = logging.getLogger(__name__)
 
+
+class BaseVCSController(object):
+
+    def __init__(self, application, config):
+        self.application = application
+        self.config = config
+        # base path of repo locations
+        self.basepath = self.config['base_path']
+        #authenticate this mercurial request using authfunc
+        self.authenticate = AuthBasicAuthenticator('', authfunc)
+        self.ipaddr = '0.0.0.0'
+
+    def _handle_request(self, environ, start_response):
+        raise NotImplementedError()
+
+    def _get_by_id(self, repo_name):
+        """
+        Get's a special pattern _<ID> from clone url and tries to replace it
+        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:
+            log.debug('Failed to extract repo_name from id %s' % (
+                      traceback.format_exc()
+                      )
+            )
+
+        return '/'.join(data)
+
+    def _invalidate_cache(self, repo_name):
+        """
+        Set's cache for this repository for invalidation on next access
+
+        :param repo_name: full repo name, also a cache key
+        """
+        invalidate_cache('get_repo_cached_%s' % repo_name)
+
+    def _check_permission(self, action, user, repo_name):
+        """
+        Checks permissions using action (push/pull) user and repository
+        name
+
+        :param action: push or pull action
+        :param user: user instance
+        :param repo_name: repository name
+        """
+        if action == 'push':
+            if not HasPermissionAnyMiddleware('repository.write',
+                                              'repository.admin')(user,
+                                                                  repo_name):
+                return False
+
+        else:
+            #any other action need at least read permission
+            if not HasPermissionAnyMiddleware('repository.read',
+                                              'repository.write',
+                                              'repository.admin')(user,
+                                                                  repo_name):
+                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__)
+            log.debug('Request time: %.3fs' % (time.time() - start))
+            meta.Session.remove()
+
+
 class BaseController(WSGIController):
 
     def __before__(self):
         c.rhodecode_version = __version__
+        c.rhodecode_instanceid = config.get('instance_id')
         c.rhodecode_name = config.get('rhodecode_title')
         c.use_gravatar = str2bool(config.get('use_gravatar'))
         c.ga_code = config.get('rhodecode_ga_code')
         c.repo_name = get_repo_slug(request)
         c.backends = BACKENDS.keys()
+        c.unread_notifications = NotificationModel()\
+                        .get_unread_cnt_for_user(c.rhodecode_user.user_id)
         self.cut_off_limit = int(config.get('cut_off_limit'))
 
-        self.sa = meta.Session()
+        self.sa = meta.Session
         self.scm_model = ScmModel(self.sa)
 
     def __call__(self, environ, start_response):
@@ -39,18 +129,30 b' class BaseController(WSGIController):'
         # WSGIController.__call__ dispatches to the Controller method
         # the request is routed to. This routing information is
         # available in environ['pylons.routes_dict']
+        start = time.time()
         try:
-            # putting this here makes sure that we update permissions each time
+            # make sure that we update permissions each time we call controller
             api_key = request.GET.get('api_key')
-            user_id = getattr(session.get('rhodecode_user'), 'user_id', None)
-            self.rhodecode_user = c.rhodecode_user = AuthUser(user_id, api_key)
-            self.rhodecode_user.set_authenticated(
-                                        getattr(session.get('rhodecode_user'),
-                                       'is_authenticated', False))
-            session['rhodecode_user'] = self.rhodecode_user
-            session.save()
+            cookie_store = CookieStoreWrapper(session.get('rhodecode_user'))
+            user_id = cookie_store.get('user_id', None)
+            username = get_container_username(environ, config)
+
+            auth_user = AuthUser(user_id, api_key, username)
+            request.user = auth_user
+            self.rhodecode_user = c.rhodecode_user = auth_user
+            if not self.rhodecode_user.is_authenticated and \
+                       self.rhodecode_user.user_id is not None:
+                self.rhodecode_user.set_authenticated(
+                    cookie_store.get('is_authenticated')
+                )
+            log.info('User: %s accessed %s' % (
+                auth_user, safe_unicode(environ.get('PATH_INFO')))
+            )
             return WSGIController.__call__(self, environ, start_response)
         finally:
+            log.info('Request to %s time: %.3fs' % (
+                safe_unicode(environ.get('PATH_INFO')), time.time() - start)
+            )
             meta.Session.remove()
 
 
@@ -80,4 +182,3 b' class BaseRepoController(BaseController)'
 
             c.repository_followers = self.scm_model.get_followers(c.repo_name)
             c.repository_forks = self.scm_model.get_forks(c.repo_name)
-

rhodecode/lib/caching_query.py

@@ -137,8 +137,13 b' def _get_cache_parameters(query):'
 
     if cache_key is None:
         # cache key - the value arguments from this query's parameters.
-        args = _params_from_query(query)
-        cache_key = " ".join([str(x) for x in args])
+        args = [str(x) for x in _params_from_query(query)]
+        args.extend(filter(lambda k:k not in ['None', None, u'None'],
+                           [str(query._limit), str(query._offset)]))
+        cache_key = " ".join(args)
+
+    if cache_key is None:
+        raise Exception('Cache key cannot be None')
 
     # get cache
     #cache = query.cache_manager.get_cache_region(namespace, region)
@@ -275,15 +280,20 b' def _params_from_query(query):'
     """
     v = []
     def visit_bindparam(bind):
-        value = query._params.get(bind.key, bind.value)
 
-        # lazyloader may dig a callable in here, intended
-        # to late-evaluate params after autoflush is called.
-        # convert to a scalar value.
-        if callable(value):
-            value = value()
+        if bind.key in query._params:
+            value = query._params[bind.key]
+        elif bind.callable:
+            # lazyloader may dig a callable in here, intended
+            # to late-evaluate params after autoflush is called.
+            # convert to a scalar value.
+            value = bind.callable()
+        else:
+            value = bind.value
 
         v.append(value)
     if query._criterion is not None:
         visitors.traverse(query._criterion, {}, {'bindparam':visit_bindparam})
+    for f in query._from_obj:
+        visitors.traverse(f, {}, {'bindparam':visit_bindparam})
     return v

rhodecode/lib/celerylib/__init__.py

@@ -34,8 +34,8 b' from pylons import config'
 from hashlib import md5
 from decorator import decorator
 
-from vcs.utils.lazy import LazyProperty
-
+from rhodecode.lib.vcs.utils.lazy import LazyProperty
+from rhodecode import CELERY_ON
 from rhodecode.lib import str2bool, safe_str
 from rhodecode.lib.pidlock import DaemonLock, LockHeld
 from rhodecode.model import init_model
@@ -48,11 +48,6 b' from celery.messaging import establish_c'
 
 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):
@@ -67,7 +62,7 b' 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)
+            log.info('running task %s:%s' % (t.task_id, task))
             return t
 
         except socket.error, e:
@@ -80,7 +75,7 b' def run_task(task, *args, **kwargs):'
         except Exception, e:
             log.error(traceback.format_exc())
 
-    log.debug('executing task %s in sync mode', task)
+    log.debug('executing task %s in sync mode' % task)
     return ResultWrapper(task(*args, **kwargs))
 
 
@@ -100,7 +95,7 b' def locked_task(func):'
         lockkey = __get_lockkey(func, *fargs, **fkwargs)
         lockkey_path = config['here']
 
-        log.info('running task with lockkey %s', lockkey)
+        log.info('running task with lockkey %s' % lockkey)
         try:
             l = DaemonLock(file_=jn(lockkey_path, lockkey))
             ret = func(*fargs, **fkwargs)

rhodecode/lib/celerylib/tasks.py

@@ -28,7 +28,7 b' from celery.decorators import task'
 import os
 import traceback
 import logging
-from os.path import dirname as dn, join as jn
+from os.path import join as jn
 
 from time import mktime
 from operator import itemgetter
@@ -37,69 +37,76 b' from string import lower'
 from pylons import config, url
 from pylons.i18n.translation import _
 
+from rhodecode.lib.vcs import get_backend
+
+from rhodecode import CELERY_ON
 from rhodecode.lib import LANGUAGES_EXTENSIONS_MAP, safe_str
-from rhodecode.lib.celerylib import run_task, locked_task, str2bool, \
-    __get_lockkey, LockHeld, DaemonLock, get_session, dbsession
+from rhodecode.lib.celerylib import run_task, locked_task, dbsession, \
+    str2bool, __get_lockkey, LockHeld, DaemonLock, get_session
 from rhodecode.lib.helpers import person
-from rhodecode.lib.smtp_mailer import SmtpMailer
-from rhodecode.lib.utils import add_cache
+from rhodecode.lib.rcmail.smtp_mailer import SmtpMailer
+from rhodecode.lib.utils import add_cache, action_logger
 from rhodecode.lib.compat import json, OrderedDict
 
-from rhodecode.model.db import RhodeCodeUi, Statistics, Repository, User
+from rhodecode.model.db import Statistics, Repository, User
 
-from vcs.backends import get_repo
-from vcs import get_backend
 
 add_cache(config)
 
 __all__ = ['whoosh_index', 'get_commits_stats',
            'reset_user_password', 'send_email']
 
-CELERY_ON = str2bool(config['app_conf'].get('use_celery'))
-
 
-def get_repos_path():
-    sa = get_session()
-    q = sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()
-    return q.ui_value
+def get_logger(cls):
+    if CELERY_ON:
+        try:
+            log = cls.get_logger()
+        except:
+            log = logging.getLogger(__name__)
+    else:
+        log = logging.getLogger(__name__)
+
+    return log
 
 
 @task(ignore_result=True)
 @locked_task
 @dbsession
 def whoosh_index(repo_location, full_index):
-    #log = whoosh_index.get_logger()
     from rhodecode.lib.indexers.daemon import WhooshIndexingDaemon
+    log = whoosh_index.get_logger(whoosh_index)
+    DBS = get_session()
+
     index_location = config['index_dir']
     WhooshIndexingDaemon(index_location=index_location,
-                         repo_location=repo_location, sa=get_session())\
+                         repo_location=repo_location, sa=DBS)\
                          .run(full_index=full_index)
 
 
 @task(ignore_result=True)
 @dbsession
 def get_commits_stats(repo_name, ts_min_y, ts_max_y):
-    try:
-        log = get_commits_stats.get_logger()
-    except:
-        log = logging.getLogger(__name__)
-
+    log = get_logger(get_commits_stats)
+    DBS = get_session()
     lockkey = __get_lockkey('get_commits_stats', repo_name, ts_min_y,
                             ts_max_y)
     lockkey_path = config['here']
 
-    log.info('running task with lockkey %s', lockkey)
+    log.info('running task with lockkey %s' % lockkey)
+
     try:
-        sa = get_session()
         lock = l = DaemonLock(file_=jn(lockkey_path, lockkey))
 
-        # for js data compatibilty cleans the key for person from '
+        # for js data compatibility cleans the key for person from '
         akc = lambda k: person(k).replace('"', "")
 
         co_day_auth_aggr = {}
         commits_by_day_aggregate = {}
-        repos_path = get_repos_path()
-        repo = get_repo(safe_str(os.path.join(repos_path, repo_name)))
+        repo = Repository.get_by_repo_name(repo_name)
+        if repo is None:
+            return True
+
+        repo = repo.scm_instance
         repo_size = repo.count()
         # return if repo have no revisions
         if repo_size < 1:
@@ -112,9 +119,9 b' def get_commits_stats(repo_name, ts_min_'
         last_cs = None
         timegetter = itemgetter('time')
 
-        dbrepo = sa.query(Repository)\
+        dbrepo = DBS.query(Repository)\
             .filter(Repository.repo_name == repo_name).scalar()
-        cur_stats = sa.query(Statistics)\
+        cur_stats = DBS.query(Statistics)\
             .filter(Statistics.repository == dbrepo).scalar()
 
         if cur_stats is not None:
@@ -132,7 +139,7 b' def get_commits_stats(repo_name, ts_min_'
                                         cur_stats.commit_activity_combined))
             co_day_auth_aggr = json.loads(cur_stats.commit_activity)
 
-        log.debug('starting parsing %s', parse_limit)
+        log.debug('starting parsing %s' % parse_limit)
         lmktime = mktime
 
         last_rev = last_rev + 1 if last_rev >= 0 else 0
@@ -207,9 +214,9 b' def get_commits_stats(repo_name, ts_min_'
         stats.commit_activity = json.dumps(co_day_auth_aggr)
         stats.commit_activity_combined = json.dumps(overview_data)
 
-        log.debug('last revison %s', last_rev)
+        log.debug('last revison %s' % last_rev)
         leftovers = len(repo.revisions[last_rev:])
-        log.debug('revisions to parse %s', leftovers)
+        log.debug('revisions to parse %s' % leftovers)
 
         if last_rev == 0 or leftovers < parse_limit:
             log.debug('getting code trending stats')
@@ -218,18 +225,18 b' def get_commits_stats(repo_name, ts_min_'
         try:
             stats.repository = dbrepo
             stats.stat_on_revision = last_cs.revision if last_cs else 0
-            sa.add(stats)
-            sa.commit()
+            DBS.add(stats)
+            DBS.commit()
         except:
             log.error(traceback.format_exc())
-            sa.rollback()
+            DBS.rollback()
             lock.release()
             return False
 
-        # final release
+        #final release
         lock.release()
 
-        # execute another task if celery is enabled
+        #execute another task if celery is enabled
         if len(repo.revisions) > 1 and CELERY_ON:
             run_task(get_commits_stats, repo_name, ts_min_y, ts_max_y)
         return True
@@ -240,38 +247,28 b' def get_commits_stats(repo_name, ts_min_'
 @task(ignore_result=True)
 @dbsession
 def send_password_link(user_email):
-    try:
-        log = reset_user_password.get_logger()
-    except:
-        log = logging.getLogger(__name__)
+    from rhodecode.model.notification import EmailNotificationModel
 
-    from rhodecode.lib import auth
+    log = get_logger(send_password_link)
+    DBS = get_session()
 
     try:
-        sa = get_session()
-        user = sa.query(User).filter(User.email == user_email).scalar()
-
+        user = User.get_by_email(user_email)
         if user:
+            log.debug('password reset user found %s' % user)
             link = url('reset_password_confirmation', key=user.api_key,
                        qualified=True)
-            tmpl = """
-Hello %s
-
-We received a request to create a new password for your account.
-
-You can generate it by clicking following URL:
-
-%s
-
-If you didn't request new password please ignore this email.
-            """
+            reg_type = EmailNotificationModel.TYPE_PASSWORD_RESET
+            body = EmailNotificationModel().get_email_tmpl(reg_type,
+                                                **{'user':user.short_contact,
+                                                   'reset_url':link})
+            log.debug('sending email')
             run_task(send_email, user_email,
-                     "RhodeCode password reset link",
-                     tmpl % (user.short_contact, link))
-            log.info('send new password mail to %s', user_email)
-
+                     _("password reset link"), body)
+            log.info('send new password mail to %s' % user_email)
+        else:
+            log.debug("password reset email %s not found" % user_email)
     except:
-        log.error('Failed to update user password')
         log.error(traceback.format_exc())
         return False
 
@@ -280,36 +277,32 b" If you didn't request new password pleas"
 @task(ignore_result=True)
 @dbsession
 def reset_user_password(user_email):
-    try:
-        log = reset_user_password.get_logger()
-    except:
-        log = logging.getLogger(__name__)
+    from rhodecode.lib import auth
 
-    from rhodecode.lib import auth
+    log = get_logger(reset_user_password)
+    DBS = get_session()
 
     try:
         try:
-            sa = get_session()
-            user = sa.query(User).filter(User.email == user_email).scalar()
+            user = User.get_by_email(user_email)
             new_passwd = auth.PasswordGenerator().gen_password(8,
                              auth.PasswordGenerator.ALPHABETS_BIG_SMALL)
             if user:
                 user.password = auth.get_crypt_password(new_passwd)
                 user.api_key = auth.generate_api_key(user.username)
-                sa.add(user)
-                sa.commit()
-                log.info('change password for %s', user_email)
+                DBS.add(user)
+                DBS.commit()
+                log.info('change password for %s' % user_email)
             if new_passwd is None:
                 raise Exception('unable to generate new password')
-
         except:
             log.error(traceback.format_exc())
-            sa.rollback()
+            DBS.rollback()
 
         run_task(send_email, user_email,
-                 "Your new RhodeCode password",
+                 'Your new password',
                  'Your new RhodeCode password:%s' % (new_passwd))
-        log.info('send new password mail to %s', user_email)
+        log.info('send new password mail to %s' % user_email)
 
     except:
         log.error('Failed to update user password')
@@ -320,7 +313,7 b' def reset_user_password(user_email):'
 
 @task(ignore_result=True)
 @dbsession
-def send_email(recipients, subject, body):
+def send_email(recipients, subject, body, html_body=''):
     """
     Sends an email with defined parameters from the .ini files.
 
@@ -328,23 +321,20 b' def send_email(recipients, subject, body'
         address from field 'email_to' is used instead
     :param subject: subject of the mail
     :param body: body of the mail
+    :param html_body: html version of body
     """
-    try:
-        log = send_email.get_logger()
-    except:
-        log = logging.getLogger(__name__)
-    
-    sa = get_session()
+    log = get_logger(send_email)
+    DBS = get_session()
+
     email_config = config
-
+    subject = "%s %s" % (email_config.get('email_prefix'), subject)
     if not recipients:
         # if recipients are not defined we send to email_config + all admins
-        admins = [
-            u.email for u in sa.query(User).filter(User.admin==True).all()
-        ]
+        admins = [u.email for u in User.query()
+                  .filter(User.admin == True).all()]
         recipients = [email_config.get('email_to')] + admins
 
-    mail_from = email_config.get('app_email_from')
+    mail_from = email_config.get('app_email_from', 'RhodeCode')
     user = email_config.get('smtp_username')
     passwd = email_config.get('smtp_password')
     mail_server = email_config.get('smtp_server')
@@ -355,9 +345,9 b' def send_email(recipients, subject, body'
     smtp_auth = email_config.get('smtp_auth')
 
     try:
-        m = SmtpMailer(mail_from, user, passwd, mail_server,smtp_auth,
+        m = SmtpMailer(mail_from, user, passwd, mail_server, smtp_auth,
                        mail_port, ssl, tls, debug=debug)
-        m.send(recipients, subject, body)
+        m.send(recipients, subject, body, html_body)
     except:
         log.error('Mail sending failed')
         log.error(traceback.format_exc())
@@ -368,29 +358,45 b' def send_email(recipients, subject, body'
 @task(ignore_result=True)
 @dbsession
 def create_repo_fork(form_data, cur_user):
+    """
+    Creates a fork of repository using interval VCS methods
+
+    :param form_data:
+    :param cur_user:
+    """
     from rhodecode.model.repo import RepoModel
 
-    try:
-        log = create_repo_fork.get_logger()
-    except:
-        log = logging.getLogger(__name__)
+    log = get_logger(create_repo_fork)
+    DBS = get_session()
+
+    base_path = Repository.base_path()
+
+    RepoModel(DBS).create(form_data, cur_user, just_db=True, fork=True)
+
+    alias = form_data['repo_type']
+    org_repo_name = form_data['org_path']
+    fork_name = form_data['repo_name_full']
+    update_after_clone = form_data['update_after_clone']
+    source_repo_path = os.path.join(base_path, org_repo_name)
+    destination_fork_path = os.path.join(base_path, fork_name)
 
-    repo_model = RepoModel(get_session())
-    repo_model.create(form_data, cur_user, just_db=True, fork=True)
-    repo_name = form_data['repo_name']
-    repos_path = get_repos_path()
-    repo_path = os.path.join(repos_path, repo_name)
-    repo_fork_path = os.path.join(repos_path, form_data['fork_name'])
-    alias = form_data['repo_type']
+    log.info('creating fork of %s as %s', source_repo_path,
+             destination_fork_path)
+    backend = get_backend(alias)
+    backend(safe_str(destination_fork_path), create=True,
+            src_url=safe_str(source_repo_path),
+            update_after_clone=update_after_clone)
+    action_logger(cur_user, 'user_forked_repo:%s' % fork_name,
+                   org_repo_name, '', DBS)
 
-    log.info('creating repo fork %s as %s', repo_name, repo_path)
-    backend = get_backend(alias)
-    backend(str(repo_fork_path), create=True, src_url=str(repo_path))
-
+    action_logger(cur_user, 'user_created_fork:%s' % fork_name,
+                   fork_name, '', DBS)
+    # finally commit at latest possible stage
+    DBS.commit()
 
 def __get_codes_stats(repo_name):
-    repos_path = get_repos_path()
-    repo = get_repo(safe_str(os.path.join(repos_path, repo_name)))
+    repo = Repository.get_by_repo_name(repo_name).scm_instance
+
     tip = repo.get_changeset()
     code_stats = {}
 

rhodecode/lib/celerypylons/commands.py

@@ -1,7 +1,10 b''
+import rhodecode
 from rhodecode.lib.utils import BasePasterCommand, Command
 from celery.app import app_or_default
 from celery.bin import camqadm, celerybeat, celeryd, celeryev
 
+from rhodecode.lib import str2bool
+
 __all__ = ['CeleryDaemonCommand', 'CeleryBeatCommand',
            'CAMQPAdminCommand', 'CeleryEventCommand']
 
@@ -26,6 +29,16 b' class CeleryCommand(BasePasterCommand):'
             self.parser.add_option(x)
 
     def command(self):
+        from pylons import config
+        try:
+            CELERY_ON = str2bool(config['app_conf'].get('use_celery'))
+        except KeyError:
+            CELERY_ON = False
+
+        if CELERY_ON == False:
+            raise Exception('Please enable celery_on in .ini config '
+                            'file before running celeryd')
+        rhodecode.CELERY_ON = CELERY_ON
         cmd = self.celery_command(app_or_default())
         return cmd.run(**vars(self.options))
 

rhodecode/lib/compat.py

@@ -4,11 +4,11 b''
     ~~~~~~~~~~~~~~~~~~~~
 
     Python backward compatibility functions and common libs
-    
-    
+
+
     :created_on: Oct 7, 2011
     :author: marcink
-    :copyright: (C) 2009-2010 Marcin Kuzminski <[e-mail]>    
+    :copyright: (C) 2010-2010 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -87,10 +87,11 b' class _Nil(object):'
 
 _nil = _Nil()
 
+
 class _odict(object):
     """Ordered dict data structure, with O(1) complexity for dict operations
     that modify one element.
-    
+
     Overwriting values doesn't change their original sequential order.
     """
 
@@ -146,7 +147,7 b' class _odict(object):'
         dict_impl = self._dict_impl()
         try:
             dict_impl.__getitem__(self, key)[1] = val
-        except KeyError, e:
+        except KeyError:
             new = [dict_impl.__getattribute__(self, 'lt'), val, _nil]
             dict_impl.__setitem__(self, key, new)
             if dict_impl.__getattribute__(self, 'lt') == _nil:
@@ -158,7 +159,7 b' class _odict(object):'
 
     def __delitem__(self, key):
         dict_impl = self._dict_impl()
-        pred, _ , succ = self._dict_impl().__getitem__(self, key)
+        pred, _, succ = self._dict_impl().__getitem__(self, key)
         if pred == _nil:
             dict_impl.__setattr__(self, 'lh', succ)
         else:
@@ -351,6 +352,7 b' class _odict(object):'
                        dict_impl.__getattribute__(self, 'lt'),
                        dict_impl.__repr__(self))
 
+
 class OrderedDict(_odict, dict):
 
     def _dict_impl(self):

rhodecode/lib/db_manage.py

@@ -8,7 +8,7 b''
 
     :created_on: Apr 10, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -33,13 +33,15 b' from os.path import dirname as dn, join '
 from rhodecode import __dbversion__
 from rhodecode.model import meta
 
-from rhodecode.lib.auth import get_crypt_password, generate_api_key
+from rhodecode.model.user import UserModel
 from rhodecode.lib.utils import ask_ok
 from rhodecode.model import init_model
 from rhodecode.model.db import User, Permission, RhodeCodeUi, \
-    RhodeCodeSettings, UserToPerm, DbMigrateVersion
+    RhodeCodeSetting, UserToPerm, DbMigrateVersion, RepoGroup,\
+    UserRepoGroupToPerm
 
 from sqlalchemy.engine import create_engine
+from rhodecode.model.repos_group import ReposGroupModel
 
 log = logging.getLogger(__name__)
 
@@ -57,10 +59,11 b' class DbManage(object):'
     def init_db(self):
         engine = create_engine(self.dburi, echo=self.log_sql)
         init_model(engine)
-        self.sa = meta.Session()
+        self.sa = meta.Session
 
     def create_tables(self, override=False):
-        """Create a auth database
+        """
+        Create a auth database
         """
 
         log.info("Any existing database is going to be destroyed")
@@ -75,23 +78,19 b' class DbManage(object):'
 
         checkfirst = not override
         meta.Base.metadata.create_all(checkfirst=checkfirst)
-        log.info('Created tables for %s', self.dbname)
+        log.info('Created tables for %s' % self.dbname)
 
     def set_db_version(self):
-        try:
-            ver = DbMigrateVersion()
-            ver.version = __dbversion__
-            ver.repository_id = 'rhodecode_db_migrations'
-            ver.repository_path = 'versions'
-            self.sa.add(ver)
-            self.sa.commit()
-        except:
-            self.sa.rollback()
-            raise
-        log.info('db version set to: %s', __dbversion__)
+        ver = DbMigrateVersion()
+        ver.version = __dbversion__
+        ver.repository_id = 'rhodecode_db_migrations'
+        ver.repository_path = 'versions'
+        self.sa.add(ver)
+        log.info('db version set to: %s' % __dbversion__)
 
     def upgrade(self):
-        """Upgrades given database schema to given revision following
+        """
+        Upgrades given database schema to given revision following
         all needed steps, to perform the upgrade
 
         """
@@ -146,7 +145,7 b' class DbManage(object):'
                 self.klass = klass
 
             def step_0(self):
-                #step 0 is the schema upgrade, and than follow proper upgrades
+                # step 0 is the schema upgrade, and than follow proper upgrades
                 print ('attempting to do database upgrade to version %s' \
                                 % __dbversion__)
                 api.upgrade(db_uri, repository_path, __dbversion__)
@@ -170,16 +169,26 b' class DbManage(object):'
                 self.klass.fix_settings()
                 print ('Adding ldap defaults')
                 self.klass.create_ldap_options(skip_existing=True)
-                
+
+            def step_4(self):
+                print ('create permissions and fix groups')
+                self.klass.create_permissions()
+                self.klass.fixup_groups()
+
+            def step_5(self):
+                pass
+
         upgrade_steps = [0] + range(curr_version + 1, __dbversion__ + 1)
 
-        #CALL THE PROPER ORDER OF STEPS TO PERFORM FULL UPGRADE
+        # CALL THE PROPER ORDER OF STEPS TO PERFORM FULL UPGRADE
         for step in upgrade_steps:
             print ('performing upgrade step %s' % step)
             getattr(UpgradeSteps(self), 'step_%s' % step)()
+            self.sa.commit()
 
     def fix_repo_paths(self):
-        """Fixes a old rhodecode version path into new one without a '*'
+        """
+        Fixes a old rhodecode version path into new one without a '*'
         """
 
         paths = self.sa.query(RhodeCodeUi)\
@@ -196,7 +205,8 b' class DbManage(object):'
             raise
 
     def fix_default_user(self):
-        """Fixes a old default user with some 'nicer' default values,
+        """
+        Fixes a old default user with some 'nicer' default values,
         used mostly for anonymous access
         """
         def_user = self.sa.query(User)\
@@ -215,10 +225,11 b' class DbManage(object):'
             raise
 
     def fix_settings(self):
-        """Fixes rhodecode settings adds ga_code key for google analytics
+        """
+        Fixes rhodecode settings adds ga_code key for google analytics
         """
 
-        hgsettings3 = RhodeCodeSettings('ga_code', '')
+        hgsettings3 = RhodeCodeSetting('ga_code', '')
 
         try:
             self.sa.add(hgsettings3)
@@ -258,18 +269,27 b' class DbManage(object):'
             self.create_user(username, password, email, True)
         else:
             log.info('creating admin and regular test users')
-            self.create_user('test_admin', 'test12',
-                             '[e-mail]', True)
-            self.create_user('test_regular', 'test12',
-                             '[e-mail]', False)
-            self.create_user('test_regular2', 'test12',
-                             '[e-mail]', False)
+            from rhodecode.tests import TEST_USER_ADMIN_LOGIN,\
+            TEST_USER_ADMIN_PASS, TEST_USER_ADMIN_EMAIL,\
+            TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS,\
+            TEST_USER_REGULAR_EMAIL, TEST_USER_REGULAR2_LOGIN, \
+            TEST_USER_REGULAR2_PASS, TEST_USER_REGULAR2_EMAIL
+
+            self.create_user(TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS,
+                             TEST_USER_ADMIN_EMAIL, True)
+
+            self.create_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS,
+                             TEST_USER_REGULAR_EMAIL, False)
+
+            self.create_user(TEST_USER_REGULAR2_LOGIN, TEST_USER_REGULAR2_PASS,
+                             TEST_USER_REGULAR2_EMAIL, False)
 
     def create_ui_settings(self):
-        """Creates ui settings, fills out hooks
+        """
+        Creates ui settings, fills out hooks
         and disables dotencode
+        """
 
-        """
         #HOOKS
         hooks1_key = RhodeCodeUi.HOOK_UPDATE
         hooks1_ = self.sa.query(RhodeCodeUi)\
@@ -300,7 +320,7 b' class DbManage(object):'
         hooks4.ui_key = RhodeCodeUi.HOOK_PULL
         hooks4.ui_value = 'python:rhodecode.lib.hooks.log_pull_action'
 
-        #For mercurial 1.7 set backward comapatibility with format
+        # For mercurial 1.7 set backward comapatibility with format
         dotencode_disable = RhodeCodeUi()
         dotencode_disable.ui_section = 'format'
         dotencode_disable.ui_key = 'dotencode'
@@ -312,39 +332,43 b' class DbManage(object):'
         largefiles.ui_key = 'largefiles'
         largefiles.ui_value = ''
 
-        try:
-            self.sa.add(hooks1)
-            self.sa.add(hooks2)
-            self.sa.add(hooks3)
-            self.sa.add(hooks4)
-            self.sa.add(dotencode_disable)
-            self.sa.add(largefiles)
-            self.sa.commit()
-        except:
-            self.sa.rollback()
-            raise
+        self.sa.add(hooks1)
+        self.sa.add(hooks2)
+        self.sa.add(hooks3)
+        self.sa.add(hooks4)
+        self.sa.add(largefiles)
 
-    def create_ldap_options(self,skip_existing=False):
+    def create_ldap_options(self, skip_existing=False):
         """Creates ldap settings"""
 
-        try:
-            for k, v in [('ldap_active', 'false'), ('ldap_host', ''),
-                        ('ldap_port', '389'), ('ldap_tls_kind', 'PLAIN'),
-                        ('ldap_tls_reqcert', ''), ('ldap_dn_user', ''),
-                        ('ldap_dn_pass', ''), ('ldap_base_dn', ''),
-                        ('ldap_filter', ''), ('ldap_search_scope', ''),
-                        ('ldap_attr_login', ''), ('ldap_attr_firstname', ''),
-                        ('ldap_attr_lastname', ''), ('ldap_attr_email', '')]:
+        for k, v in [('ldap_active', 'false'), ('ldap_host', ''),
+                    ('ldap_port', '389'), ('ldap_tls_kind', 'PLAIN'),
+                    ('ldap_tls_reqcert', ''), ('ldap_dn_user', ''),
+                    ('ldap_dn_pass', ''), ('ldap_base_dn', ''),
+                    ('ldap_filter', ''), ('ldap_search_scope', ''),
+                    ('ldap_attr_login', ''), ('ldap_attr_firstname', ''),
+                    ('ldap_attr_lastname', ''), ('ldap_attr_email', '')]:
+
+            if skip_existing and RhodeCodeSetting.get_by_name(k) != None:
+                log.debug('Skipping option %s' % k)
+                continue
+            setting = RhodeCodeSetting(k, v)
+            self.sa.add(setting)
 
-                if skip_existing and RhodeCodeSettings.get_by_name(k) != None:
-                    log.debug('Skipping option %s' % k)
-                    continue
-                setting = RhodeCodeSettings(k, v)
-                self.sa.add(setting)
-            self.sa.commit()
-        except:
-            self.sa.rollback()
-            raise
+    def fixup_groups(self):
+        def_usr = User.get_by_username('default')
+        for g in RepoGroup.query().all():
+            g.group_name = g.get_new_name(g.name)
+            self.sa.add(g)
+            # get default perm
+            default = UserRepoGroupToPerm.query()\
+                .filter(UserRepoGroupToPerm.group == g)\
+                .filter(UserRepoGroupToPerm.user == def_usr)\
+                .scalar()
+
+            if default is None:
+                log.debug('missing default permission for group %s adding' % g)
+                ReposGroupModel()._create_default_perms(g)
 
     def config_prompt(self, test_repo_path='', retries=3):
         if retries == 3:
@@ -359,16 +383,15 b' class DbManage(object):'
             path = test_repo_path
         path_ok = True
 
-        #check proper dir
+        # check proper dir
         if not os.path.isdir(path):
             path_ok = False
-            log.error('Given path %s is not a valid directory', path)
+            log.error('Given path %s is not a valid directory' % path)
 
-        #check write access
+        # check write access
         if not os.access(path, os.W_OK) and path_ok:
             path_ok = False
-            log.error('No write permission to given path %s', path)
-
+            log.error('No write permission to given path %s' % path)
 
         if retries == 0:
             sys.exit('max retries reached')
@@ -408,85 +431,68 b' class DbManage(object):'
         paths.ui_key = '/'
         paths.ui_value = path
 
-        hgsettings1 = RhodeCodeSettings('realm', 'RhodeCode authentication')
-        hgsettings2 = RhodeCodeSettings('title', 'RhodeCode')
-        hgsettings3 = RhodeCodeSettings('ga_code', '')
+        hgsettings1 = RhodeCodeSetting('realm', 'RhodeCode authentication')
+        hgsettings2 = RhodeCodeSetting('title', 'RhodeCode')
+        hgsettings3 = RhodeCodeSetting('ga_code', '')
 
-        try:
-            self.sa.add(web1)
-            self.sa.add(web2)
-            self.sa.add(web3)
-            self.sa.add(web4)
-            self.sa.add(paths)
-            self.sa.add(hgsettings1)
-            self.sa.add(hgsettings2)
-            self.sa.add(hgsettings3)
-
-            self.sa.commit()
-        except:
-            self.sa.rollback()
-            raise
+        self.sa.add(web1)
+        self.sa.add(web2)
+        self.sa.add(web3)
+        self.sa.add(web4)
+        self.sa.add(paths)
+        self.sa.add(hgsettings1)
+        self.sa.add(hgsettings2)
+        self.sa.add(hgsettings3)
 
         self.create_ldap_options()
 
         log.info('created ui config')
 
     def create_user(self, username, password, email='', admin=False):
-        log.info('creating administrator user %s', username)
-        
-        form_data = dict(username=username,
-                         password=password,
-                         active=True,
-                         admin=admin,
-                         name='RhodeCode',
-                         lastname='Admin',
-                         email=email)
-        User.create(form_data)
-
+        log.info('creating user %s' % username)
+        UserModel().create_or_update(username, password, email,
+                                     name='RhodeCode', lastname='Admin',
+                                     active=True, admin=admin)
 
     def create_default_user(self):
         log.info('creating default user')
-        #create default user for handling default permissions.
+        # create default user for handling default permissions.
+        UserModel().create_or_update(username='default',
+                              password=str(uuid.uuid1())[:8],
+                              email='[e-mail]',
+                              name='Anonymous', lastname='User')
 
-        form_data = dict(username='default',
-                         password=str(uuid.uuid1())[:8],
-                         active=False,
-                         admin=False,
-                         name='Anonymous',
-                         lastname='User',
-                         email='[e-mail]')
-        User.create(form_data)
-        
     def create_permissions(self):
-        #module.(access|create|change|delete)_[name]
-        #module.(read|write|owner)
-        perms = [('repository.none', 'Repository no access'),
-                 ('repository.read', 'Repository read access'),
-                 ('repository.write', 'Repository write access'),
-                 ('repository.admin', 'Repository admin access'),
-                 ('hg.admin', 'Hg Administrator'),
-                 ('hg.create.repository', 'Repository create'),
-                 ('hg.create.none', 'Repository creation disabled'),
-                 ('hg.register.none', 'Register disabled'),
-                 ('hg.register.manual_activate', 'Register new user with '
-                                                 'RhodeCode without manual'
-                                                 'activation'),
+        # module.(access|create|change|delete)_[name]
+        # module.(none|read|write|admin)
+        perms = [
+         ('repository.none', 'Repository no access'),
+         ('repository.read', 'Repository read access'),
+         ('repository.write', 'Repository write access'),
+         ('repository.admin', 'Repository admin access'),
 
-                 ('hg.register.auto_activate', 'Register new user with '
-                                               'RhodeCode without auto '
-                                               'activation'),
-                ]
+         ('group.none', 'Repositories Group no access'),
+         ('group.read', 'Repositories Group read access'),
+         ('group.write', 'Repositories Group write access'),
+         ('group.admin', 'Repositories Group admin access'),
+
+         ('hg.admin', 'Hg Administrator'),
+         ('hg.create.repository', 'Repository create'),
+         ('hg.create.none', 'Repository creation disabled'),
+         ('hg.register.none', 'Register disabled'),
+         ('hg.register.manual_activate', 'Register new user with RhodeCode '
+                                         'without manual activation'),
+
+         ('hg.register.auto_activate', 'Register new user with RhodeCode '
+                                        'without auto activation'),
+        ]
 
         for p in perms:
-            new_perm = Permission()
-            new_perm.permission_name = p[0]
-            new_perm.permission_longname = p[1]
-            try:
+            if not Permission.get_by_key(p[0]):
+                new_perm = Permission()
+                new_perm.permission_name = p[0]
+                new_perm.permission_longname = p[1]
                 self.sa.add(new_perm)
-                self.sa.commit()
-            except:
-                self.sa.rollback()
-                raise
 
     def populate_default_permissions(self):
         log.info('creating default user permissions')
@@ -512,11 +518,6 b' class DbManage(object):'
         .filter(Permission.permission_name == 'repository.read')\
         .scalar()
 
-        try:
-            self.sa.add(reg_perm)
-            self.sa.add(create_repo_perm)
-            self.sa.add(default_repo_perm)
-            self.sa.commit()
-        except:
-            self.sa.rollback()
-            raise
+        self.sa.add(reg_perm)
+        self.sa.add(create_repo_perm)
+        self.sa.add(default_repo_perm)

rhodecode/lib/dbmigrate/__init__.py

@@ -7,7 +7,7 b''
 
     :created_on: Dec 11, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify

rhodecode/lib/dbmigrate/migrate/__init__.py

@@ -8,4 +8,4 b''
 from rhodecode.lib.dbmigrate.migrate.versioning import *
 from rhodecode.lib.dbmigrate.migrate.changeset import *
 
-__version__ = '0.7.2.dev'
  No newline at end of file
+__version__ = '0.7.3.dev'

rhodecode/lib/dbmigrate/migrate/changeset/__init__.py

@@ -12,7 +12,7 b' from sqlalchemy import __version__ as _s'
 
 warnings.simplefilter('always', DeprecationWarning)
 
-_sa_version = tuple(int(re.match("\d+", x).group(0)) 
+_sa_version = tuple(int(re.match("\d+", x).group(0))
                     for x in _sa_version.split("."))
 SQLA_06 = _sa_version >= (0, 6)
 SQLA_07 = _sa_version >= (0, 7)

rhodecode/lib/dbmigrate/migrate/changeset/ansisql.py

@@ -17,23 +17,19 b' from sqlalchemy.schema import (ForeignKe'
                                Index)
 
 from rhodecode.lib.dbmigrate.migrate import exceptions
-from rhodecode.lib.dbmigrate.migrate.changeset import constraint, SQLA_06
+from rhodecode.lib.dbmigrate.migrate.changeset import constraint
 
-if not SQLA_06:
-    from sqlalchemy.sql.compiler import SchemaGenerator, SchemaDropper
-else:
-    from sqlalchemy.schema import AddConstraint, DropConstraint
-    from sqlalchemy.sql.compiler import DDLCompiler
-    SchemaGenerator = SchemaDropper = DDLCompiler
+from sqlalchemy.schema import AddConstraint, DropConstraint
+from sqlalchemy.sql.compiler import DDLCompiler
+SchemaGenerator = SchemaDropper = DDLCompiler
 
 
 class AlterTableVisitor(SchemaVisitor):
     """Common operations for ``ALTER TABLE`` statements."""
 
-    if SQLA_06:
-        # engine.Compiler looks for .statement
-        # when it spawns off a new compiler
-        statement = ClauseElement()
+    # engine.Compiler looks for .statement
+    # when it spawns off a new compiler
+    statement = ClauseElement()
 
     def append(self, s):
         """Append content to the SchemaIterator's query buffer."""
@@ -123,9 +119,8 b' class ANSIColumnGenerator(AlterTableVisi'
                                                    name=column.primary_key_name)
             cons.create()
 
-    if SQLA_06:
-        def add_foreignkey(self, fk):
-            self.connection.execute(AddConstraint(fk))
+    def add_foreignkey(self, fk):
+        self.connection.execute(AddConstraint(fk))
 
 class ANSIColumnDropper(AlterTableVisitor, SchemaDropper):
     """Extends ANSI SQL dropper for column dropping (``ALTER TABLE
@@ -232,10 +227,7 b' class ANSISchemaChanger(AlterTableVisito'
 
     def _visit_column_type(self, table, column, delta):
         type_ = delta['type']
-        if SQLA_06:
-            type_text = str(type_.compile(dialect=self.dialect))
-        else:
-            type_text = type_.dialect_impl(self.dialect).get_col_spec()
+        type_text = str(type_.compile(dialect=self.dialect))
         self.append("TYPE %s" % type_text)
 
     def _visit_column_name(self, table, column, delta):
@@ -279,75 +271,17 b' class ANSIConstraintCommon(AlterTableVis'
     def visit_migrate_unique_constraint(self, *p, **k):
         self._visit_constraint(*p, **k)
 
-if SQLA_06:
-    class ANSIConstraintGenerator(ANSIConstraintCommon, SchemaGenerator):
-        def _visit_constraint(self, constraint):
-            constraint.name = self.get_constraint_name(constraint)
-            self.append(self.process(AddConstraint(constraint)))
-            self.execute()
-
-    class ANSIConstraintDropper(ANSIConstraintCommon, SchemaDropper):
-        def _visit_constraint(self, constraint):
-            constraint.name = self.get_constraint_name(constraint)
-            self.append(self.process(DropConstraint(constraint, cascade=constraint.cascade)))
-            self.execute()
-
-else:
-    class ANSIConstraintGenerator(ANSIConstraintCommon, SchemaGenerator):
-
-        def get_constraint_specification(self, cons, **kwargs):
-            """Constaint SQL generators.
-
-            We cannot use SA visitors because they append comma.
-            """
+class ANSIConstraintGenerator(ANSIConstraintCommon, SchemaGenerator):
+    def _visit_constraint(self, constraint):
+        constraint.name = self.get_constraint_name(constraint)
+        self.append(self.process(AddConstraint(constraint)))
+        self.execute()
 
-            if isinstance(cons, PrimaryKeyConstraint):
-                if cons.name is not None:
-                    self.append("CONSTRAINT %s " % self.preparer.format_constraint(cons))
-                self.append("PRIMARY KEY ")
-                self.append("(%s)" % ', '.join(self.preparer.quote(c.name, c.quote)
-                                               for c in cons))
-                self.define_constraint_deferrability(cons)
-            elif isinstance(cons, ForeignKeyConstraint):
-                self.define_foreign_key(cons)
-            elif isinstance(cons, CheckConstraint):
-                if cons.name is not None:
-                    self.append("CONSTRAINT %s " %
-                                self.preparer.format_constraint(cons))
-                self.append("CHECK (%s)" % cons.sqltext)
-                self.define_constraint_deferrability(cons)
-            elif isinstance(cons, UniqueConstraint):
-                if cons.name is not None:
-                    self.append("CONSTRAINT %s " %
-                                self.preparer.format_constraint(cons))
-                self.append("UNIQUE (%s)" % \
-                    (', '.join(self.preparer.quote(c.name, c.quote) for c in cons)))
-                self.define_constraint_deferrability(cons)
-            else:
-                raise exceptions.InvalidConstraintError(cons)
-
-        def _visit_constraint(self, constraint):
-
-            table = self.start_alter_table(constraint)
-            constraint.name = self.get_constraint_name(constraint)
-            self.append("ADD ")
-            self.get_constraint_specification(constraint)
-            self.execute()
-
-
-    class ANSIConstraintDropper(ANSIConstraintCommon, SchemaDropper):
-
-        def _visit_constraint(self, constraint):
-            self.start_alter_table(constraint)
-            self.append("DROP CONSTRAINT ")
-            constraint.name = self.get_constraint_name(constraint)
-            self.append(self.preparer.format_constraint(constraint))
-            if constraint.cascade:
-                self.cascade_constraint(constraint)
-            self.execute()
-
-        def cascade_constraint(self, constraint):
-            self.append(" CASCADE")
+class ANSIConstraintDropper(ANSIConstraintCommon, SchemaDropper):
+    def _visit_constraint(self, constraint):
+        constraint.name = self.get_constraint_name(constraint)
+        self.append(self.process(DropConstraint(constraint, cascade=constraint.cascade)))
+        self.execute()
 
 
 class ANSIDialect(DefaultDialect):

rhodecode/lib/dbmigrate/migrate/changeset/constraint.py

@@ -4,7 +4,7 b''
 from sqlalchemy import schema
 
 from rhodecode.lib.dbmigrate.migrate.exceptions import *
-from rhodecode.lib.dbmigrate.migrate.changeset import SQLA_06
+
 
 class ConstraintChangeset(object):
     """Base class for Constraint classes."""
@@ -85,7 +85,6 b' class PrimaryKeyConstraint(ConstraintCha'
         if table is not None:
             self._set_parent(table)
 
-
     def autoname(self):
         """Mimic the database's automatic constraint names"""
         return "%s_pkey" % self.table.name
@@ -111,8 +110,9 b' class ForeignKeyConstraint(ConstraintCha'
         table = kwargs.pop('table', table)
         refcolnames, reftable = self._normalize_columns(refcolumns,
                                                         table_name=True)
-        super(ForeignKeyConstraint, self).__init__(colnames, refcolnames, *args,
-                                                   **kwargs)
+        super(ForeignKeyConstraint, self).__init__(
+            colnames, refcolnames, *args,**kwargs
+        )
         if table is not None:
             self._set_parent(table)
 
@@ -165,8 +165,6 b' class CheckConstraint(ConstraintChangese'
         table = kwargs.pop('table', table)
         schema.CheckConstraint.__init__(self, sqltext, *args, **kwargs)
         if table is not None:
-            if not SQLA_06:
-                self.table = table
             self._set_parent(table)
         self.colnames = colnames
 
@@ -199,4 +197,4 b' class UniqueConstraint(ConstraintChanges'
 
     def autoname(self):
         """Mimic the database's automatic constraint names"""
-        return "%s_%s_key" % (self.table.name, self.colnames[0])
+        return "%s_%s_key" % (self.table.name, '_'.join(self.colnames))

rhodecode/lib/dbmigrate/migrate/changeset/databases/firebird.py

@@ -4,13 +4,10 b''
 from sqlalchemy.databases import firebird as sa_base
 from sqlalchemy.schema import PrimaryKeyConstraint
 from rhodecode.lib.dbmigrate.migrate import exceptions
-from rhodecode.lib.dbmigrate.migrate.changeset import ansisql, SQLA_06
+from rhodecode.lib.dbmigrate.migrate.changeset import ansisql
 
 
-if SQLA_06:
-    FBSchemaGenerator = sa_base.FBDDLCompiler
-else:
-    FBSchemaGenerator = sa_base.FBSchemaGenerator
+FBSchemaGenerator = sa_base.FBDDLCompiler
 
 class FBColumnGenerator(FBSchemaGenerator, ansisql.ANSIColumnGenerator):
     """Firebird column generator implementation."""
@@ -41,10 +38,7 b' class FBColumnDropper(ansisql.ANSIColumn'
                 # is deleted!
                 continue
 
-            if SQLA_06:
-                should_drop = column.name in cons.columns
-            else:
-                should_drop = cons.contains_column(column) and cons.name
+            should_drop = column.name in cons.columns
             if should_drop:
                 self.start_alter_table(column)
                 self.append("DROP CONSTRAINT ")

rhodecode/lib/dbmigrate/migrate/changeset/databases/mysql.py

@@ -6,13 +6,10 b' from sqlalchemy.databases import mysql a'
 from sqlalchemy import types as sqltypes
 
 from rhodecode.lib.dbmigrate.migrate import exceptions
-from rhodecode.lib.dbmigrate.migrate.changeset import ansisql, SQLA_06
+from rhodecode.lib.dbmigrate.migrate.changeset import ansisql
 
 
-if not SQLA_06:
-    MySQLSchemaGenerator = sa_base.MySQLSchemaGenerator
-else:
-    MySQLSchemaGenerator = sa_base.MySQLDDLCompiler
+MySQLSchemaGenerator = sa_base.MySQLDDLCompiler
 
 class MySQLColumnGenerator(MySQLSchemaGenerator, ansisql.ANSIColumnGenerator):
     pass
@@ -53,37 +50,11 b' class MySQLSchemaChanger(MySQLSchemaGene'
 class MySQLConstraintGenerator(ansisql.ANSIConstraintGenerator):
     pass
 
-if SQLA_06:
-    class MySQLConstraintDropper(MySQLSchemaGenerator, ansisql.ANSIConstraintDropper):
-        def visit_migrate_check_constraint(self, *p, **k):
-            raise exceptions.NotSupportedError("MySQL does not support CHECK"
-                " constraints, use triggers instead.")
 
-else:
-    class MySQLConstraintDropper(ansisql.ANSIConstraintDropper):
-
-        def visit_migrate_primary_key_constraint(self, constraint):
-            self.start_alter_table(constraint)
-            self.append("DROP PRIMARY KEY")
-            self.execute()
-
-        def visit_migrate_foreign_key_constraint(self, constraint):
-            self.start_alter_table(constraint)
-            self.append("DROP FOREIGN KEY ")
-            constraint.name = self.get_constraint_name(constraint)
-            self.append(self.preparer.format_constraint(constraint))
-            self.execute()
-
-        def visit_migrate_check_constraint(self, *p, **k):
-            raise exceptions.NotSupportedError("MySQL does not support CHECK"
-                " constraints, use triggers instead.")
-
-        def visit_migrate_unique_constraint(self, constraint, *p, **k):
-            self.start_alter_table(constraint)
-            self.append('DROP INDEX ')
-            constraint.name = self.get_constraint_name(constraint)
-            self.append(self.preparer.format_constraint(constraint))
-            self.execute()
+class MySQLConstraintDropper(MySQLSchemaGenerator, ansisql.ANSIConstraintDropper):
+    def visit_migrate_check_constraint(self, *p, **k):
+        raise exceptions.NotSupportedError("MySQL does not support CHECK"
+            " constraints, use triggers instead.")
 
 
 class MySQLDialect(ansisql.ANSIDialect):

rhodecode/lib/dbmigrate/migrate/changeset/databases/postgres.py

@@ -3,14 +3,11 b''
 
    .. _`PostgreSQL`: http://www.postgresql.org/
 """
-from rhodecode.lib.dbmigrate.migrate.changeset import ansisql, SQLA_06
+from rhodecode.lib.dbmigrate.migrate.changeset import ansisql
+
 
-if not SQLA_06:
-    from sqlalchemy.databases import postgres as sa_base
-    PGSchemaGenerator = sa_base.PGSchemaGenerator
-else:
-    from sqlalchemy.databases import postgresql as sa_base
-    PGSchemaGenerator = sa_base.PGDDLCompiler
+from sqlalchemy.databases import postgresql as sa_base
+PGSchemaGenerator = sa_base.PGDDLCompiler
 
 
 class PGColumnGenerator(PGSchemaGenerator, ansisql.ANSIColumnGenerator):

rhodecode/lib/dbmigrate/migrate/changeset/databases/sqlite.py

@@ -11,11 +11,8 b' from sqlalchemy.databases import sqlite '
 from rhodecode.lib.dbmigrate.migrate import exceptions
 from rhodecode.lib.dbmigrate.migrate.changeset import ansisql, SQLA_06
 
+SQLiteSchemaGenerator = sa_base.SQLiteDDLCompiler
 
-if not SQLA_06:
-    SQLiteSchemaGenerator = sa_base.SQLiteSchemaGenerator
-else:
-    SQLiteSchemaGenerator = sa_base.SQLiteDDLCompiler
 
 class SQLiteCommon(object):
 
@@ -39,7 +36,7 b' class SQLiteHelper(SQLiteCommon):'
 
         insertion_string = self._modify_table(table, column, delta)
 
-        table.create()
+        table.create(bind=self.connection)
         self.append(insertion_string % {'table_name': table_name})
         self.execute()
         self.append('DROP TABLE migration_tmp')

rhodecode/lib/dbmigrate/migrate/changeset/schema.py

@@ -349,10 +349,7 b' class ColumnDelta(DictMixin, sqlalchemy.'
     def process_column(self, column):
         """Processes default values for column"""
         # XXX: this is a snippet from SA processing of positional parameters
-        if not SQLA_06 and column.args:
-            toinit = list(column.args)
-        else:
-            toinit = list()
+        toinit = list()
 
         if column.server_default is not None:
             if isinstance(column.server_default, sqlalchemy.FetchedValue):
@@ -368,9 +365,6 b' class ColumnDelta(DictMixin, sqlalchemy.'
         if toinit:
             column._init_items(*toinit)
 
-        if not SQLA_06:
-            column.args = []
-
     def _get_table(self):
         return getattr(self, '_table', None)
 
@@ -469,14 +463,18 b' class ChangesetTable(object):'
         self._set_parent(self.metadata)
 
     def _meta_key(self):
+        """Get the meta key for this table."""
         return sqlalchemy.schema._get_table_key(self.name, self.schema)
 
     def deregister(self):
         """Remove this table from its metadata"""
-        key = self._meta_key()
-        meta = self.metadata
-        if key in meta.tables:
-            del meta.tables[key]
+        if SQLA_07:
+            self.metadata._remove_table(self.name, self.schema)
+        else:
+            key = self._meta_key()
+            meta = self.metadata
+            if key in meta.tables:
+                del meta.tables[key]
 
 
 class ChangesetColumn(object):

rhodecode/lib/dbmigrate/migrate/exceptions.py

@@ -83,6 +83,5 b' class NotSupportedError(Error):'
 class InvalidConstraintError(Error):
     """Invalid constraint error"""
 
-
 class MigrateDeprecationWarning(DeprecationWarning):
     """Warning for deprecated features in Migrate"""

rhodecode/lib/dbmigrate/migrate/versioning/api.py

@@ -119,7 +119,7 b' def script_sql(database, description, re'
 
     For instance, manage.py script_sql postgresql description creates:
     repository/versions/001_description_postgresql_upgrade.sql and
-    repository/versions/001_description_postgresql_postgres.sql
+    repository/versions/001_description_postgresql_downgrade.sql
     """
     repo = Repository(repository)
     repo.create_script_sql(database, description, **opts)
@@ -212,14 +212,15 b' def test(url, repository, **opts):'
     """
     engine = opts.pop('engine')
     repos = Repository(repository)
-    script = repos.version(None).script()
 
     # Upgrade
     log.info("Upgrading...")
+    script = repos.version(None).script(engine.name, 'upgrade')
     script.run(engine, 1)
     log.info("done")
 
     log.info("Downgrading...")
+    script = repos.version(None).script(engine.name, 'downgrade')
     script.run(engine, -1)
     log.info("done")
     log.info("Success")

rhodecode/lib/dbmigrate/migrate/versioning/genmodel.py

@@ -282,4 +282,3 b' class ModelGenerator(object):'
                 except:
                     trans.rollback()
                     raise
-

rhodecode/lib/dbmigrate/migrate/versioning/repository.py

@@ -115,7 +115,7 b' class Repository(pathed.Pathed):'
         options.setdefault('version_table', 'migrate_version')
         options.setdefault('repository_id', name)
         options.setdefault('required_dbs', [])
-        options.setdefault('use_timestamp_numbering', '0')
+        options.setdefault('use_timestamp_numbering', False)
 
         tmpl = open(os.path.join(tmpl_dir, cls._config)).read()
         ret = TempitaTemplate(tmpl).substitute(options)
@@ -153,7 +153,7 b' class Repository(pathed.Pathed):'
 
     def create_script(self, description, **k):
         """API to :meth:`migrate.versioning.version.Collection.create_new_python_version`"""
-        
+
         k['use_timestamp_numbering'] = self.use_timestamp_numbering
         self.versions.create_new_python_version(description, **k)
 
@@ -180,9 +180,9 b' class Repository(pathed.Pathed):'
     @property
     def use_timestamp_numbering(self):
         """Returns use_timestamp_numbering specified in config"""
-        ts_numbering = self.config.get('db_settings', 'use_timestamp_numbering', raw=True)
-        
-        return ts_numbering
+        if self.config.has_option('db_settings', 'use_timestamp_numbering'):
+            return self.config.getboolean('db_settings', 'use_timestamp_numbering')
+        return False
 
     def version(self, *p, **k):
         """API to :attr:`migrate.versioning.version.Collection.version`"""

rhodecode/lib/dbmigrate/migrate/versioning/schemadiff.py

@@ -17,8 +17,16 b' def getDiffOfModelAgainstDatabase(metada'
     :return: object which will evaluate to :keyword:`True` if there \
       are differences else :keyword:`False`.
     """
-    return SchemaDiff(metadata,
-                      sqlalchemy.MetaData(engine, reflect=True),
+    db_metadata = sqlalchemy.MetaData(engine, reflect=True)
+
+    # sqlite will include a dynamically generated 'sqlite_sequence' table if
+    # there are autoincrement sequences in the database; this should not be
+    # compared.
+    if engine.dialect.name == 'sqlite':
+        if 'sqlite_sequence' in db_metadata.tables:
+            db_metadata.remove(db_metadata.tables['sqlite_sequence'])
+
+    return SchemaDiff(metadata, db_metadata,
                       labelA='model',
                       labelB='database',
                       excludeTables=excludeTables)
@@ -31,7 +39,7 b' def getDiffOfModelAgainstModel(metadataA'
     :return: object which will evaluate to :keyword:`True` if there \
       are differences else :keyword:`False`.
     """
-    return SchemaDiff(metadataA, metadataB, excludeTables)
+    return SchemaDiff(metadataA, metadataB, excludeTables=excludeTables)
 
 
 class ColDiff(object):

rhodecode/lib/dbmigrate/migrate/versioning/templates/manage/default.py_tmpl

@@ -7,4 +7,6 b" del _vars['__template_name__']"
 _vars.pop('repository_name', None)
 defaults = ", ".join(["%s='%s'" % var for var in _vars.iteritems()])
 }}
-main({{ defaults }})
+
+if __name__ == '__main__':
+    main({{ defaults }})

rhodecode/lib/dbmigrate/migrate/versioning/templates/manage/pylons.py_tmpl

@@ -26,4 +26,5 b' conf_dict = ConfigLoader(conf_path).pars'
 
 # migrate supports passing url as an existing Engine instance (since 0.6.0)
 # usage: migrate -c path/to/config.ini COMMANDS
-main(url=engine_from_config(conf_dict), repository=migrations.__path__[0],{{ defaults }})
+if __name__ == '__main__':
+    main(url=engine_from_config(conf_dict), repository=migrations.__path__[0],{{ defaults }})

rhodecode/lib/dbmigrate/migrate/versioning/util/__init__.py

@@ -158,7 +158,7 b' def with_engine(f, *a, **kw):'
         kw['engine'] = engine
         return f(*a, **kw)
     finally:
-        if isinstance(engine, Engine):
+        if isinstance(engine, Engine) and engine is not url:
             log.debug('Disposing SQLAlchemy engine %s', engine)
             engine.dispose()
 

rhodecode/lib/dbmigrate/migrate/versioning/version.py

@@ -60,7 +60,7 b' class Collection(pathed.Pathed):'
         and store them in self.versions
         """
         super(Collection, self).__init__(path)
-        
+
         # Create temporary list of files, allowing skipped version numbers.
         files = os.listdir(path)
         if '1' in files:
@@ -90,9 +90,7 b' class Collection(pathed.Pathed):'
         return max([VerNum(0)] + self.versions.keys())
 
     def _next_ver_num(self, use_timestamp_numbering):
-        print use_timestamp_numbering
         if use_timestamp_numbering == True:
-            print "Creating new timestamp version!"
             return VerNum(int(datetime.utcnow().strftime('%Y%m%d%H%M%S')))
         else:
             return self.latest + 1
@@ -113,7 +111,7 b' class Collection(pathed.Pathed):'
 
         script.PythonScript.create(filepath, **k)
         self.versions[ver] = Version(ver, self.path, [filename])
-        
+
     def create_new_sql_version(self, database, description, **k):
         """Create SQL files for new version"""
         ver = self._next_ver_num(k.pop('use_timestamp_numbering', False))
@@ -133,7 +131,7 b' class Collection(pathed.Pathed):'
             filepath = self._version_path(filename)
             script.SqlScript.create(filepath, **k)
             self.versions[ver].add_script(filepath)
-        
+
     def version(self, vernum=None):
         """Returns latest Version if vernum is not given.
         Otherwise, returns wanted version"""
@@ -152,7 +150,7 b' class Collection(pathed.Pathed):'
 
 class Version(object):
     """A single version in a collection
-    :param vernum: Version Number 
+    :param vernum: Version Number
     :param path: Path to script files
     :param filelist: List of scripts
     :type vernum: int, VerNum
@@ -169,7 +167,7 b' class Version(object):'
 
         for script in filelist:
             self.add_script(os.path.join(path, script))
-    
+
     def script(self, database=None, operation=None):
         """Returns SQL or Python Script"""
         for db in (database, 'default'):
@@ -198,7 +196,7 b' class Version(object):'
     def _add_script_sql(self, path):
         basename = os.path.basename(path)
         match = self.SQL_FILENAME.match(basename)
-        
+
         if match:
             basename = basename.replace('.sql', '')
             parts = basename.split('_')

rhodecode/lib/dbmigrate/versions/001_initial_release.py

@@ -14,7 +14,7 b' from rhodecode.lib.dbmigrate.migrate imp'
 
 log = logging.getLogger(__name__)
 
-class RhodeCodeSettings(Base):
+class RhodeCodeSetting(Base):
     __tablename__ = 'rhodecode_settings'
     __table_args__ = (UniqueConstraint('app_settings_name'), {'useexisting':True})
     app_settings_id = Column("app_settings_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
@@ -74,7 +74,7 b' class User(Base):'
             self.last_login = datetime.datetime.now()
             session.add(self)
             session.commit()
-            log.debug('updated user %s lastlogin', self.username)
+            log.debug('updated user %s lastlogin' % self.username)
         except (DatabaseError,):
             session.rollback()
 
@@ -107,7 +107,7 b' class Repository(Base):'
 
     user = relation('User')
     fork = relation('Repository', remote_side=repo_id)
-    repo_to_perm = relation('RepoToPerm', cascade='all')
+    repo_to_perm = relation('UserRepoToPerm', cascade='all')
     stats = relation('Statistics', cascade='all', uselist=False)
 
     repo_followers = relation('UserFollowing', primaryjoin='UserFollowing.follows_repo_id==Repository.repo_id', cascade='all')
@@ -126,7 +126,7 b' class Permission(Base):'
     def __repr__(self):
         return "<Permission('%s:%s')>" % (self.permission_id, self.permission_name)
 
-class RepoToPerm(Base):
+class UserRepoToPerm(Base):
     __tablename__ = 'repo_to_perm'
     __table_args__ = (UniqueConstraint('user_id', 'repository_id'), {'useexisting':True})
     repo_to_perm_id = Column("repo_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

rhodecode/lib/dbmigrate/versions/002_version_1_1_0.py

@@ -12,6 +12,7 b' from rhodecode.lib.dbmigrate.migrate.cha'
 
 log = logging.getLogger(__name__)
 
+
 def upgrade(migrate_engine):
     """ Upgrade operations go here.
     Don't create your own engine; bind migrate_engine to your metadata
@@ -44,8 +45,6 b' def upgrade(migrate_engine):'
                       nullable=True, unique=None, default=None)
     revision.create(tbl)
 
-
-
     #==========================================================================
     # Upgrade of `repositories` table
     #==========================================================================
@@ -69,47 +68,18 b' def upgrade(migrate_engine):'
     #==========================================================================
     # Add table `user_followings`
     #==========================================================================
-    class UserFollowing(Base, BaseModel):
-        __tablename__ = 'user_followings'
-        __table_args__ = (UniqueConstraint('user_id', 'follows_repository_id'),
-                          UniqueConstraint('user_id', 'follows_user_id')
-                          , {'useexisting':True})
-
-        user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
-        user_id = Column("user_id", Integer(), ForeignKey(u'users.user_id'), nullable=False, unique=None, default=None)
-        follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey(u'repositories.repo_id'), nullable=True, unique=None, default=None)
-        follows_user_id = Column("follows_user_id", Integer(), ForeignKey(u'users.user_id'), nullable=True, unique=None, default=None)
-
-        user = relation('User', primaryjoin='User.user_id==UserFollowing.user_id')
-
-        follows_user = relation('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')
-        follows_repository = relation('Repository')
-
+    from rhodecode.lib.dbmigrate.schema.db_1_1_0 import UserFollowing
     UserFollowing().__table__.create()
 
     #==========================================================================
     # Add table `cache_invalidation`
     #==========================================================================
-    class CacheInvalidation(Base, BaseModel):
-        __tablename__ = 'cache_invalidation'
-        __table_args__ = (UniqueConstraint('cache_key'), {'useexisting':True})
-        cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)
-        cache_key = Column("cache_key", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
-        cache_args = Column("cache_args", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
-        cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)
-
-
-        def __init__(self, cache_key, cache_args=''):
-            self.cache_key = cache_key
-            self.cache_args = cache_args
-            self.cache_active = False
-
-        def __repr__(self):
-            return "<CacheInvalidation('%s:%s')>" % (self.cache_id, self.cache_key)
+    from rhodecode.lib.dbmigrate.schema.db_1_1_0 import CacheInvalidation
     CacheInvalidation().__table__.create()
 
     return
 
+
 def downgrade(migrate_engine):
     meta = MetaData()
     meta.bind = migrate_engine

rhodecode/lib/dbmigrate/versions/003_version_1_2_0.py

@@ -13,6 +13,7 b' from rhodecode.model.meta import Base'
 
 log = logging.getLogger(__name__)
 
+
 def upgrade(migrate_engine):
     """ Upgrade operations go here.
     Don't create your own engine; bind migrate_engine to your metadata
@@ -21,46 +22,46 b' def upgrade(migrate_engine):'
     #==========================================================================
     # Add table `groups``
     #==========================================================================
-    from rhodecode.model.db import Group
+    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import RepoGroup as Group
     Group().__table__.create()
 
     #==========================================================================
     # Add table `group_to_perm`
     #==========================================================================
-    from rhodecode.model.db import GroupToPerm
-    GroupToPerm().__table__.create()
+    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import UserRepoGroupToPerm
+    UserRepoGroupToPerm().__table__.create()
 
     #==========================================================================
     # Add table `users_groups`
     #==========================================================================
-    from rhodecode.model.db import UsersGroup
+    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import UsersGroup
     UsersGroup().__table__.create()
 
     #==========================================================================
     # Add table `users_groups_members`
     #==========================================================================
-    from rhodecode.model.db import UsersGroupMember
+    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import UsersGroupMember
     UsersGroupMember().__table__.create()
 
     #==========================================================================
     # Add table `users_group_repo_to_perm`
     #==========================================================================
-    from rhodecode.model.db import UsersGroupRepoToPerm
+    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import UsersGroupRepoToPerm
     UsersGroupRepoToPerm().__table__.create()
 
     #==========================================================================
     # Add table `users_group_to_perm`
     #==========================================================================
-    from rhodecode.model.db import UsersGroupToPerm
+    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import UsersGroupToPerm
     UsersGroupToPerm().__table__.create()
 
     #==========================================================================
     # Upgrade of `users` table
     #==========================================================================
-    from rhodecode.model.db import User
+    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import User
 
     #add column
-    ldap_dn = Column("ldap_dn", String(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
+    ldap_dn = Column("ldap_dn", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
     ldap_dn.create(User().__table__)
 
     api_key = Column("api_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)
@@ -74,7 +75,7 b' def upgrade(migrate_engine):'
     #==========================================================================
     # Upgrade of `repositories` table
     #==========================================================================
-    from rhodecode.model.db import Repository
+    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import Repository
 
     #ADD clone_uri column#
 
@@ -83,7 +84,7 b' def upgrade(migrate_engine):'
                         nullable=True, unique=False, default=None)
 
     clone_uri.create(Repository().__table__)
-    
+
     #ADD downloads column#
     enable_downloads = Column("downloads", Boolean(), nullable=True, unique=None, default=True)
     enable_downloads.create(Repository().__table__)
@@ -104,10 +105,10 b' def upgrade(migrate_engine):'
     # Upgrade of `user_followings` table
     #==========================================================================
 
-    from rhodecode.model.db import UserFollowing
+    from rhodecode.lib.dbmigrate.schema.db_1_2_0 import UserFollowing
 
-    follows_from = Column('follows_from', DateTime(timezone=False), 
-                          nullable=True, unique=None, 
+    follows_from = Column('follows_from', DateTime(timezone=False),
+                          nullable=True, unique=None,
                           default=datetime.datetime.now)
     follows_from.create(UserFollowing().__table__)
 

rhodecode/lib/dbmigrate/versions/__init__.py

@@ -7,7 +7,7 b''
 
     :created_on: Dec 11, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify

rhodecode/lib/exceptions.py

@@ -6,7 +6,8 b''
     Set of custom exceptions used in RhodeCode
 
     :created_on: Nov 17, 2010
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :author: marcink
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -46,5 +47,6 b' class DefaultUserException(Exception):'
 class UserOwnsReposException(Exception):
     pass
 
+
 class UsersGroupsAssignedException(Exception):
     pass

rhodecode/lib/helpers.py

@@ -8,22 +8,24 b' import hashlib'
 import StringIO
 import urllib
 import math
+import logging
 
 from datetime import datetime
-from pygments.formatters import HtmlFormatter
+from pygments.formatters.html import HtmlFormatter
 from pygments import highlight as code_highlight
 from pylons import url, request, config
 from pylons.i18n.translation import _, ungettext
+from hashlib import md5
 
 from webhelpers.html import literal, HTML, escape
 from webhelpers.html.tools import *
 from webhelpers.html.builder import make_tag
 from webhelpers.html.tags import auto_discovery_link, checkbox, css_classes, \
-    end_form, file, form, hidden, image, javascript_link, link_to, link_to_if, \
-    link_to_unless, ol, required_legend, select, stylesheet_link, submit, text, \
-    password, textarea, title, ul, xml_declaration, radio
-from webhelpers.html.tools import auto_link, button_to, highlight, js_obfuscate, \
-    mail_to, strip_links, strip_tags, tag_re
+    end_form, file, form, hidden, image, javascript_link, link_to, \
+    link_to_if, link_to_unless, ol, required_legend, select, stylesheet_link, \
+    submit, text, password, textarea, title, ul, xml_declaration, radio
+from webhelpers.html.tools import auto_link, button_to, highlight, \
+    js_obfuscate, mail_to, strip_links, strip_tags, tag_re
 from webhelpers.number import format_byte_size, format_bit_size
 from webhelpers.pylonslib import Flash as _Flash
 from webhelpers.pylonslib.secure_form import secure_form
@@ -33,11 +35,15 b' from webhelpers.text import chop_at, col'
 from webhelpers.date import time_ago_in_words
 from webhelpers.paginate import Page
 from webhelpers.html.tags import _set_input_attrs, _set_id_attr, \
-    convert_boolean_attrs, NotGiven
+    convert_boolean_attrs, NotGiven, _make_safe_id_component
 
-from vcs.utils.annotate import annotate_highlight
+from rhodecode.lib.annotate import annotate_highlight
 from rhodecode.lib.utils import repo_name_slug
-from rhodecode.lib import str2bool, safe_unicode, safe_str,get_changeset_safe
+from rhodecode.lib import str2bool, safe_unicode, safe_str, get_changeset_safe
+from rhodecode.lib.markup_renderer import MarkupRenderer
+
+log = logging.getLogger(__name__)
+
 
 def _reset(name, value=None, id=NotGiven, type="reset", **attrs):
     """
@@ -49,6 +55,19 b' def _reset(name, value=None, id=NotGiven'
     return HTML.input(**attrs)
 
 reset = _reset
+safeid = _make_safe_id_component
+
+
+def FID(raw_id, path):
+    """
+    Creates a uniqe ID for filenode based on it's hash of path and revision
+    it's safe to use in urls
+
+    :param raw_id:
+    :param path:
+    """
+
+    return 'C-%s-%s' % (short_id(raw_id), md5(path).hexdigest()[:12])
 
 
 def get_token():
@@ -104,10 +123,14 b' class _FilesBreadCrumbs(object):'
         paths_l = paths.split('/')
         for cnt, p in enumerate(paths_l):
             if p != '':
-                url_l.append(link_to(p, url('files_home',
-                                            repo_name=repo_name,
-                                            revision=rev,
-                                            f_path='/'.join(paths_l[:cnt + 1]))))
+                url_l.append(link_to(p,
+                                     url('files_home',
+                                         repo_name=repo_name,
+                                         revision=rev,
+                                         f_path='/'.join(paths_l[:cnt + 1])
+                                         )
+                                     )
+                             )
 
         return literal('/'.join(url_l))
 
@@ -198,13 +221,16 b' def pygmentize(filenode, **kwargs):'
     return literal(code_highlight(filenode.content,
                                   filenode.lexer, CodeHtmlFormatter(**kwargs)))
 
+
 def pygmentize_annotation(repo_name, filenode, **kwargs):
-    """pygmentize function for annotation
+    """
+    pygmentize function for annotation
 
     :param filenode:
     """
 
     color_dict = {}
+
     def gen_color(n=10000):
         """generator for getting n of evenly distributed colors using
         hsv color and golden ratio. It always return same order of colors
@@ -213,19 +239,26 b' def pygmentize_annotation(repo_name, fil'
         """
 
         def hsv_to_rgb(h, s, v):
-            if s == 0.0: return v, v, v
-            i = int(h * 6.0) # XXX assume int() truncates!
+            if s == 0.0:
+                return v, v, v
+            i = int(h * 6.0)  # XXX assume int() truncates!
             f = (h * 6.0) - i
             p = v * (1.0 - s)
             q = v * (1.0 - s * f)
             t = v * (1.0 - s * (1.0 - f))
             i = i % 6
-            if i == 0: return v, t, p
-            if i == 1: return q, v, p
-            if i == 2: return p, v, t
-            if i == 3: return p, q, v
-            if i == 4: return t, p, v
-            if i == 5: return v, p, q
+            if i == 0:
+                return v, t, p
+            if i == 1:
+                return q, v, p
+            if i == 2:
+                return p, v, t
+            if i == 3:
+                return p, q, v
+            if i == 4:
+                return t, p, v
+            if i == 5:
+                return v, p, q
 
         golden_ratio = 0.618033988749895
         h = 0.22717784590367374
@@ -235,12 +268,12 b' def pygmentize_annotation(repo_name, fil'
             h %= 1
             HSV_tuple = [h, 0.95, 0.95]
             RGB_tuple = hsv_to_rgb(*HSV_tuple)
-            yield map(lambda x:str(int(x * 256)), RGB_tuple)
+            yield map(lambda x: str(int(x * 256)), RGB_tuple)
 
     cgenerator = gen_color()
 
     def get_color_string(cs):
-        if color_dict.has_key(cs):
+        if cs in color_dict:
             col = color_dict[cs]
         else:
             col = color_dict[cs] = cgenerator.next()
@@ -275,6 +308,7 b' def pygmentize_annotation(repo_name, fil'
 
     return literal(annotate_highlight(filenode, url_func(repo_name), **kwargs))
 
+
 def is_following_repo(repo_name, user_id):
     from rhodecode.model.scm import ScmModel
     return ScmModel().is_following_repo(repo_name, user_id)
@@ -284,17 +318,75 b' flash = _Flash()'
 #==============================================================================
 # SCM FILTERS available via h.
 #==============================================================================
-from vcs.utils import author_name, author_email
+from rhodecode.lib.vcs.utils import author_name, author_email
 from rhodecode.lib import credentials_filter, age as _age
+from rhodecode.model.db import User
 
-age = lambda  x:_age(x)
+age = lambda  x: _age(x)
 capitalize = lambda x: x.capitalize()
 email = author_email
-email_or_none = lambda x: email(x) if email(x) != x else None
-person = lambda x: author_name(x)
 short_id = lambda x: x[:12]
 hide_credentials = lambda x: ''.join(credentials_filter(x))
 
+
+def is_git(repository):
+    if hasattr(repository, 'alias'):
+        _type = repository.alias
+    elif hasattr(repository, 'repo_type'):
+        _type = repository.repo_type
+    else:
+        _type = repository
+    return _type == 'git'
+
+
+def is_hg(repository):
+    if hasattr(repository, 'alias'):
+        _type = repository.alias
+    elif hasattr(repository, 'repo_type'):
+        _type = repository.repo_type
+    else:
+        _type = repository
+    return _type == 'hg'
+
+
+def email_or_none(author):
+    _email = email(author)
+    if _email != '':
+        return _email
+
+    # See if it contains a username we can get an email from
+    user = User.get_by_username(author_name(author), case_insensitive=True,
+                                cache=True)
+    if user is not None:
+        return user.email
+
+    # No valid email, not a valid user in the system, none!
+    return None
+
+
+def person(author):
+    # attr to return from fetched user
+    person_getter = lambda usr: usr.username
+
+    # Valid email in the attribute passed, see if they're in the system
+    _email = email(author)
+    if _email != '':
+        user = User.get_by_email(_email, case_insensitive=True, cache=True)
+        if user is not None:
+            return person_getter(user)
+        return _email
+
+    # Maybe it's a username?
+    _author = author_name(author)
+    user = User.get_by_username(_author, case_insensitive=True,
+                                cache=True)
+    if user is not None:
+        return person_getter(user)
+
+    # Still nothing?  Just pass back the author name then
+    return _author
+
+
 def bool2icon(value):
     """Returns True/False values represented as small html image of true/false
     icons
@@ -314,7 +406,8 b' def bool2icon(value):'
 
 
 def action_parser(user_log, feed=False):
-    """This helper will action_map the specified string action into translated
+    """
+    This helper will action_map the specified string action into translated
     fancy names with icons and links
 
     :param user_log: user log instance
@@ -330,52 +423,84 b' def action_parser(user_log, feed=False):'
         action, action_params = x
 
     def get_cs_links():
-        revs_limit = 3 #display this amount always
-        revs_top_limit = 50 #show upto this amount of changesets hidden
-        revs = action_params.split(',')
+        revs_limit = 3  # display this amount always
+        revs_top_limit = 50  # show upto this amount of changesets hidden
+        revs_ids = action_params.split(',')
+        deleted = user_log.repository is None
+        if deleted:
+            return ','.join(revs_ids)
+
         repo_name = user_log.repository.repo_name
 
-        from rhodecode.model.scm import ScmModel
         repo = user_log.repository.scm_instance
 
-        message = lambda rev: get_changeset_safe(repo, rev).message
+        message = lambda rev: rev.message
+        lnk = lambda rev, repo_name: (
+            link_to('r%s:%s' % (rev.revision, rev.short_id),
+                    url('changeset_home', repo_name=repo_name,
+                        revision=rev.raw_id),
+                    title=tooltip(message(rev)), class_='tooltip')
+        )
+        # get only max revs_top_limit of changeset for performance/ui reasons
+        revs = [
+            x for x in repo.get_changesets(revs_ids[0],
+                                           revs_ids[:revs_top_limit][-1])
+        ]
+
         cs_links = []
-        cs_links.append(" " + ', '.join ([link_to(rev,
-                url('changeset_home',
-                repo_name=repo_name,
-                revision=rev), title=tooltip(message(rev)),
-                class_='tooltip') for rev in revs[:revs_limit] ]))
+        cs_links.append(" " + ', '.join(
+            [lnk(rev, repo_name) for rev in revs[:revs_limit]]
+            )
+        )
 
-        compare_view = (' <div class="compare_view tooltip" title="%s">'
-                        '<a href="%s">%s</a> '
-                        '</div>' % (_('Show all combined changesets %s->%s' \
-                                      % (revs[0], revs[-1])),
-                                    url('changeset_home', repo_name=repo_name,
-                                        revision='%s...%s' % (revs[0], revs[-1])
-                                    ),
-                                    _('compare view'))
-                        )
+        compare_view = (
+            ' <div class="compare_view tooltip" title="%s">'
+            '<a href="%s">%s</a> </div>' % (
+                _('Show all combined changesets %s->%s') % (
+                    revs_ids[0], revs_ids[-1]
+                ),
+                url('changeset_home', repo_name=repo_name,
+                    revision='%s...%s' % (revs_ids[0], revs_ids[-1])
+                ),
+                _('compare view')
+            )
+        )
 
-        if len(revs) > revs_limit:
-            uniq_id = revs[0]
-            html_tmpl = ('<span> %s '
-            '<a class="show_more" id="_%s" href="#more">%s</a> '
-            '%s</span>')
+        # if we have exactly one more than normally displayed
+        # just display it, takes less space than displaying
+        # "and 1 more revisions"
+        if len(revs_ids) == revs_limit + 1:
+            rev = revs[revs_limit]
+            cs_links.append(", " + lnk(rev, repo_name))
+
+        # hidden-by-default ones
+        if len(revs_ids) > revs_limit + 1:
+            uniq_id = revs_ids[0]
+            html_tmpl = (
+                '<span> %s <a class="show_more" id="_%s" '
+                'href="#more">%s</a> %s</span>'
+            )
             if not feed:
-                cs_links.append(html_tmpl % (_('and'), uniq_id, _('%s more') \
-                                        % (len(revs) - revs_limit),
-                                        _('revisions')))
+                cs_links.append(html_tmpl % (
+                      _('and'),
+                      uniq_id, _('%s more') % (len(revs_ids) - revs_limit),
+                      _('revisions')
+                    )
+                )
 
             if not feed:
-                html_tmpl = '<span id="%s" style="display:none"> %s </span>'
+                html_tmpl = '<span id="%s" style="display:none">, %s </span>'
             else:
                 html_tmpl = '<span id="%s"> %s </span>'
 
-            cs_links.append(html_tmpl % (uniq_id, ', '.join([link_to(rev,
-                url('changeset_home',
-                repo_name=repo_name, revision=rev),
-                title=message(rev), class_='tooltip')
-                for rev in revs[revs_limit:revs_top_limit]])))
+            morelinks = ', '.join(
+              [lnk(rev, repo_name) for rev in revs[revs_limit:]]
+            )
+
+            if len(revs_ids) > revs_top_limit:
+                morelinks += ', ...'
+
+            cs_links.append(html_tmpl % (uniq_id, morelinks))
         if len(revs) > 1:
             cs_links.append(compare_view)
         return ''.join(cs_links)
@@ -385,36 +510,39 b' def action_parser(user_log, feed=False):'
         return _('fork name ') + str(link_to(action_params, url('summary_home',
                                           repo_name=repo_name,)))
 
-    action_map = {'user_deleted_repo':(_('[deleted] repository'), None),
-           'user_created_repo':(_('[created] repository'), None),
-           'user_forked_repo':(_('[forked] repository'), get_fork_name),
-           'user_updated_repo':(_('[updated] repository'), None),
-           'admin_deleted_repo':(_('[delete] repository'), None),
-           'admin_created_repo':(_('[created] repository'), None),
-           'admin_forked_repo':(_('[forked] repository'), None),
-           'admin_updated_repo':(_('[updated] repository'), None),
-           'push':(_('[pushed] into'), get_cs_links),
-           'push_local':(_('[committed via RhodeCode] into'), get_cs_links),
-           'push_remote':(_('[pulled from remote] into'), get_cs_links),
-           'pull':(_('[pulled] from'), None),
-           'started_following_repo':(_('[started following] repository'), None),
-           'stopped_following_repo':(_('[stopped following] repository'), None),
+    action_map = {'user_deleted_repo': (_('[deleted] repository'), None),
+           'user_created_repo': (_('[created] repository'), None),
+           'user_created_fork': (_('[created] repository as fork'), None),
+           'user_forked_repo': (_('[forked] repository'), get_fork_name),
+           'user_updated_repo': (_('[updated] repository'), None),
+           'admin_deleted_repo': (_('[delete] repository'), None),
+           'admin_created_repo': (_('[created] repository'), None),
+           'admin_forked_repo': (_('[forked] repository'), None),
+           'admin_updated_repo': (_('[updated] repository'), None),
+           'push': (_('[pushed] into'), get_cs_links),
+           'push_local': (_('[committed via RhodeCode] into'), get_cs_links),
+           'push_remote': (_('[pulled from remote] into'), get_cs_links),
+           'pull': (_('[pulled] from'), None),
+           'started_following_repo': (_('[started following] repository'), None),
+           'stopped_following_repo': (_('[stopped following] repository'), None),
             }
 
     action_str = action_map.get(action, action)
     if feed:
         action = action_str[0].replace('[', '').replace(']', '')
     else:
-        action = action_str[0].replace('[', '<span class="journal_highlight">')\
-                   .replace(']', '</span>')
+        action = action_str[0]\
+            .replace('[', '<span class="journal_highlight">')\
+            .replace(']', '</span>')
 
-    action_params_func = lambda :""
+    action_params_func = lambda: ""
 
     if callable(action_str[1]):
         action_params_func = action_str[1]
 
     return [literal(action), action_params_func]
 
+
 def action_parser_icon(user_log):
     action = user_log.action
     action_params = None
@@ -426,6 +554,7 b' def action_parser_icon(user_log):'
     tmpl = """<img src="%s%s" alt="%s"/>"""
     map = {'user_deleted_repo':'database_delete.png',
            'user_created_repo':'database_add.png',
+           'user_created_fork':'arrow_divide.png',
            'user_forked_repo':'arrow_divide.png',
            'user_updated_repo':'database_edit.png',
            'admin_deleted_repo':'database_delete.png',
@@ -449,6 +578,7 b' def action_parser_icon(user_log):'
 from rhodecode.lib.auth import HasPermissionAny, HasPermissionAll, \
 HasRepoPermissionAny, HasRepoPermissionAll
 
+
 #==============================================================================
 # GRAVATAR URL
 #==============================================================================
@@ -456,7 +586,8 b' HasRepoPermissionAny, HasRepoPermissionA'
 def gravatar_url(email_address, size=30):
     if (not str2bool(config['app_conf'].get('use_gravatar')) or
         not email_address or email_address == '[e-mail]'):
-        return url("/images/user%s.png" % size)
+        f = lambda a, l: min(l, key=lambda x: abs(x - a))
+        return url("/images/user%s.png" % f(size, [14, 16, 20, 24, 30]))
 
     ssl_enabled = 'https' == request.environ.get('wsgi.url_scheme')
     default = 'identicon'
@@ -469,7 +600,7 b' def gravatar_url(email_address, size=30)'
         email_address = safe_str(email_address)
     # construct the url
     gravatar_url = baseurl + hashlib.md5(email_address.lower()).hexdigest() + "?"
-    gravatar_url += urllib.urlencode({'d':default, 's':str(size)})
+    gravatar_url += urllib.urlencode({'d': default, 's': str(size)})
 
     return gravatar_url
 
@@ -480,7 +611,7 b' def gravatar_url(email_address, size=30)'
 class RepoPage(Page):
 
     def __init__(self, collection, page=1, items_per_page=20,
-        item_count=None, url=None, branch_name=None, **kwargs):
+                 item_count=None, url=None, **kwargs):
 
         """Create a "RepoPage" instance. special pager for paging
         repository
@@ -498,7 +629,7 b' class RepoPage(Page):'
         # The self.page is the number of the current page.
         # The first page has the number 1!
         try:
-            self.page = int(page) # make it int() if we get it as a string
+            self.page = int(page)  # make it int() if we get it as a string
         except (ValueError, TypeError):
             self.page = 1
 
@@ -518,7 +649,8 b' class RepoPage(Page):'
                                             self.items_per_page))
             self.last_page = self.first_page + self.page_count - 1
 
-            # Make sure that the requested page number is the range of valid pages
+            # Make sure that the requested page number is the range of
+            # valid pages
             if self.page > self.last_page:
                 self.page = self.last_page
             elif self.page < self.first_page:
@@ -531,11 +663,7 b' class RepoPage(Page):'
             self.last_item = ((self.item_count - 1) - items_per_page *
                               (self.page - 1))
 
-            iterator = self.collection.get_changesets(start=self.first_item,
-                                                      end=self.last_item,
-                                                      reverse=True,
-                                                      branch_name=branch_name)
-            self.items = list(iterator)
+            self.items = list(self.collection[self.first_item:self.last_item + 1])
 
             # Links to previous and next page
             if self.page > self.first_page:
@@ -560,14 +688,14 b' class RepoPage(Page):'
             self.items = []
 
         # This is a subclass of the 'list' type. Initialise the list now.
-        list.__init__(self, self.items)
+        list.__init__(self, reversed(self.items))
 
 
 def changed_tooltip(nodes):
     """
     Generates a html string for changed nodes in changeset page.
     It limits the output to 30 entries
-    
+
     :param nodes: LazyNodesGenerator
     """
     if nodes:
@@ -581,15 +709,14 b' def changed_tooltip(nodes):'
         return ': ' + _('No Files')
 
 
-
 def repo_link(groups_and_repos):
     """
     Makes a breadcrumbs link to repo within a group
     joins &raquo; on each group to create a fancy link
-    
+
     ex::
         group >> subgroup >> repo
-    
+
     :param groups_and_repos:
     """
     groups, repo_name = groups_and_repos
@@ -603,11 +730,12 b' def repo_link(groups_and_repos):'
         return literal(' &raquo; '.join(map(make_link, groups)) + \
                        " &raquo; " + repo_name)
 
+
 def fancy_file_stats(stats):
     """
     Displays a fancy two colored bar for number of added/deleted
     lines of code on file
-    
+
     :param stats: two element list of added/deleted lines of code
     """
 
@@ -630,13 +758,12 b' def fancy_file_stats(stats):'
     a_v = a if a > 0 else ''
     d_v = d if d > 0 else ''
 
-
     def cgen(l_type):
-        mapping = {'tr':'top-right-rounded-corner',
-                   'tl':'top-left-rounded-corner',
-                   'br':'bottom-right-rounded-corner',
-                   'bl':'bottom-left-rounded-corner'}
-        map_getter = lambda x:mapping[x]
+        mapping = {'tr': 'top-right-rounded-corner',
+                   'tl': 'top-left-rounded-corner',
+                   'br': 'bottom-right-rounded-corner',
+                   'bl': 'bottom-left-rounded-corner'}
+        map_getter = lambda x: mapping[x]
 
         if l_type == 'a' and d_v:
             #case when added and deleted are present
@@ -651,22 +778,137 b' def fancy_file_stats(stats):'
         if l_type == 'd' and not a_v:
             return ' '.join(map(map_getter, ['tr', 'br', 'tl', 'bl']))
 
-
-
-    d_a = '<div class="added %s" style="width:%s%%">%s</div>' % (cgen('a'),
-                                                                 a_p, a_v)
-    d_d = '<div class="deleted %s" style="width:%s%%">%s</div>' % (cgen('d'),
-                                                                   d_p, d_v)
+    d_a = '<div class="added %s" style="width:%s%%">%s</div>' % (
+        cgen('a'), a_p, a_v
+    )
+    d_d = '<div class="deleted %s" style="width:%s%%">%s</div>' % (
+        cgen('d'), d_p, d_v
+    )
     return literal('<div style="width:%spx">%s%s</div>' % (width, d_a, d_d))
 
 
-def urlify_text(text):
+def urlify_text(text_):
     import re
 
-    url_pat = re.compile(r'(http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+)')
+    url_pat = re.compile(r'''(http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]'''
+                         '''|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+)''')
 
     def url_func(match_obj):
         url_full = match_obj.groups()[0]
-        return '<a href="%(url)s">%(url)s</a>' % ({'url':url_full})
+        return '<a href="%(url)s">%(url)s</a>' % ({'url': url_full})
+
+    return literal(url_pat.sub(url_func, text_))
+
+
+def urlify_changesets(text_, repository):
+    import re
+    URL_PAT = re.compile(r'([0-9a-fA-F]{12,})')
+
+    def url_func(match_obj):
+        rev = match_obj.groups()[0]
+        pref = ''
+        if match_obj.group().startswith(' '):
+            pref = ' '
+        tmpl = (
+        '%(pref)s<a class="%(cls)s" href="%(url)s">'
+        '%(rev)s'
+        '</a>'
+        )
+        return tmpl % {
+         'pref': pref,
+         'cls': 'revision-link',
+         'url': url('changeset_home', repo_name=repository, revision=rev),
+         'rev': rev,
+        }
+
+    newtext = URL_PAT.sub(url_func, text_)
+
+    return newtext
+
+
+def urlify_commit(text_, repository=None, link_=None):
+    """
+    Parses given text message and makes proper links.
+    issues are linked to given issue-server, and rest is a changeset link
+    if link_ is given, in other case it's a plain text
+
+    :param text_:
+    :param repository:
+    :param link_: changeset link
+    """
+    import re
+    import traceback
+
+    # urlify changesets
+    text_ = urlify_changesets(text_, repository)
+
+    def linkify_others(t, l):
+        urls = re.compile(r'(\<a.*?\<\/a\>)',)
+        links = []
+        for e in urls.split(t):
+            if not urls.match(e):
+                links.append('<a class="message-link" href="%s">%s</a>' % (l, e))
+            else:
+                links.append(e)
 
-    return literal(url_pat.sub(url_func, text))
+        return ''.join(links)
+    try:
+        conf = config['app_conf']
+
+        URL_PAT = re.compile(r'%s' % conf.get('issue_pat'))
+
+        if URL_PAT:
+            ISSUE_SERVER_LNK = conf.get('issue_server_link')
+            ISSUE_PREFIX = conf.get('issue_prefix')
+
+            def url_func(match_obj):
+                pref = ''
+                if match_obj.group().startswith(' '):
+                    pref = ' '
+
+                issue_id = ''.join(match_obj.groups())
+                tmpl = (
+                '%(pref)s<a class="%(cls)s" href="%(url)s">'
+                '%(issue-prefix)s%(id-repr)s'
+                '</a>'
+                )
+                url = ISSUE_SERVER_LNK.replace('{id}', issue_id)
+                if repository:
+                    url = url.replace('{repo}', repository)
+
+                return tmpl % {
+                     'pref': pref,
+                     'cls': 'issue-tracker-link',
+                     'url': url,
+                     'id-repr': issue_id,
+                     'issue-prefix': ISSUE_PREFIX,
+                     'serv': ISSUE_SERVER_LNK,
+                }
+
+            newtext = URL_PAT.sub(url_func, text_)
+
+            if link_:
+                # wrap not links into final link => link_
+                newtext = linkify_others(newtext, link_)
+
+            return literal(newtext)
+    except:
+        log.error(traceback.format_exc())
+        pass
+
+    return text_
+
+
+def rst(source):
+    return literal('<div class="rst-block">%s</div>' %
+                   MarkupRenderer.rst(source))
+
+
+def rst_w_mentions(source):
+    """
+    Wrapped rst renderer with @mention highlighting
+
+    :param source:
+    """
+    return literal('<div class="rst-block">%s</div>' %
+                   MarkupRenderer.rst_with_mentions(source))

rhodecode/lib/hooks.py

@@ -7,7 +7,7 b''
 
     :created_on: Aug 6, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -33,15 +33,14 b' from rhodecode.lib.utils import action_l'
 
 
 def repo_size(ui, repo, hooktype=None, **kwargs):
-    """Presents size of repository after push
+    """
+    Presents size of repository after push
 
     :param ui:
     :param repo:
     :param hooktype:
     """
 
-    if hooktype != 'changegroup':
-        return False
     size_hg, size_root = 0, 0
     for path, dirs, files in os.walk(repo.root):
         if path.find('.hg') != -1:
@@ -60,12 +59,20 b' def repo_size(ui, repo, hooktype=None, *'
     size_hg_f = h.format_byte_size(size_hg)
     size_root_f = h.format_byte_size(size_root)
     size_total_f = h.format_byte_size(size_root + size_hg)
-    sys.stdout.write('Repository size .hg:%s repo:%s total:%s\n' \
-                     % (size_hg_f, size_root_f, size_total_f))
+
+    last_cs = repo[len(repo) - 1]
+
+    msg = ('Repository size .hg:%s repo:%s total:%s\n'
+           'Last revision is now r%s:%s\n') % (
+        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
+    """
+    Logs user last pull action
 
     :param ui:
     :param repo:
@@ -76,13 +83,15 b' def log_pull_action(ui, repo, **kwargs):'
     repository = extra_params['repository']
     action = 'pull'
 
-    action_logger(username, action, repository, extra_params['ip'])
+    action_logger(username, action, repository, extra_params['ip'],
+                  commit=True)
 
     return 0
 
 
 def log_push_action(ui, repo, **kwargs):
-    """Maps user last push action to new changeset id, from mercurial
+    """
+    Maps user last push action to new changeset id, from mercurial
 
     :param ui:
     :param repo:
@@ -110,6 +119,37 b' def log_push_action(ui, repo, **kwargs):'
 
     action = action % ','.join(revs)
 
-    action_logger(username, action, repository, extra_params['ip'])
+    action_logger(username, action, repository, extra_params['ip'],
+                  commit=True)
 
     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
+    if needed
+
+    :param repository: dict dump of repository object
+    :param created_by: username who created repository
+    :param created_date: date of creation
+
+    available keys of repository_dict:
+
+     'repo_type',
+     'description',
+     'private',
+     'created_on',
+     'enable_downloads',
+     'repo_id',
+     'user_id',
+     'enable_statistics',
+     'clone_uri',
+     'fork_id',
+     'group_id',
+     'repo_name'
+
+    """
+
+
+    return 0

rhodecode/lib/indexers/__init__.py

@@ -7,7 +7,7 b''
 
     :created_on: Aug 17, 2010
     :author: marcink
-    :copyright: (C) 2009-2010 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -37,38 +37,39 b' from whoosh.analysis import RegexTokeniz'
 from whoosh.fields import TEXT, ID, STORED, Schema, FieldType
 from whoosh.index import create_in, open_dir
 from whoosh.formats import Characters
-from whoosh.highlight import highlight, SimpleFragmenter, HtmlFormatter
+from whoosh.highlight import highlight, HtmlFormatter, ContextFragmenter
 
 from webhelpers.html.builder import escape
 from sqlalchemy import engine_from_config
-from vcs.utils.lazy import LazyProperty
 
 from rhodecode.model import init_model
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.config.environment import load_environment
-from rhodecode.lib import LANGUAGES_EXTENSIONS_MAP
+from rhodecode.lib import LANGUAGES_EXTENSIONS_MAP, LazyProperty
 from rhodecode.lib.utils import BasePasterCommand, Command, add_cache
 
-#EXTENSIONS WE WANT TO INDEX CONTENT OFF
+# EXTENSIONS WE WANT TO INDEX CONTENT OFF
 INDEX_EXTENSIONS = LANGUAGES_EXTENSIONS_MAP.keys()
 
-#CUSTOM ANALYZER wordsplit + lowercase filter
+# CUSTOM ANALYZER wordsplit + lowercase filter
 ANALYZER = RegexTokenizer(expression=r"\w+") | LowercaseFilter()
 
 
 #INDEX SCHEMA DEFINITION
-SCHEMA = Schema(owner=TEXT(),
-                repository=TEXT(stored=True),
-                path=TEXT(stored=True),
-                content=FieldType(format=Characters(ANALYZER),
-                             scorable=True, stored=True),
-                modtime=STORED(), extension=TEXT(stored=True))
-
+SCHEMA = Schema(
+    owner=TEXT(),
+    repository=TEXT(stored=True),
+    path=TEXT(stored=True),
+    content=FieldType(format=Characters(), analyzer=ANALYZER,
+                      scorable=True, stored=True),
+    modtime=STORED(),
+    extension=TEXT(stored=True)
+)
 
 IDX_NAME = 'HG_INDEX'
 FORMATTER = HtmlFormatter('span', between='\n<span class="break">...</span>\n')
-FRAGMENTER = SimpleFragmenter(200)
+FRAGMENTER = ContextFragmenter(200)
 
 
 class MakeIndex(BasePasterCommand):
@@ -129,13 +130,14 b' class MakeIndex(BasePasterCommand):'
                                 " destroy old and build from scratch",
                           default=False)
 
+
 class ResultWrapper(object):
     def __init__(self, search_type, searcher, matcher, highlight_items):
         self.search_type = search_type
         self.searcher = searcher
         self.matcher = matcher
         self.highlight_items = highlight_items
-        self.fragment_size = 200 / 2
+        self.fragment_size = 200
 
     @LazyProperty
     def doc_ids(self):
@@ -171,11 +173,10 b' class ResultWrapper(object):'
         """
         i, j = key.start, key.stop
 
-        slice = []
+        slices = []
         for docid in self.doc_ids[i:j]:
-            slice.append(self.get_full_content(docid))
-        return slice
-
+            slices.append(self.get_full_content(docid))
+        return slices
 
     def get_full_content(self, docid):
         res = self.searcher.stored_fields(docid[0])
@@ -183,9 +184,9 b' class ResultWrapper(object):'
                              + len(res['repository']):].lstrip('/')
 
         content_short = self.get_short_content(res, docid[1])
-        res.update({'content_short':content_short,
-                    'content_short_hl':self.highlight(content_short),
-                    'f_path':f_path})
+        res.update({'content_short': content_short,
+                    'content_short_hl': self.highlight(content_short),
+                    'f_path': f_path})
 
         return res
 
@@ -198,7 +199,7 b' class ResultWrapper(object):'
         Smart function that implements chunking the content
         but not overlap chunks so it doesn't highlight the same
         close occurrences twice.
-        
+
         :param matcher:
         :param size:
         """
@@ -217,10 +218,12 b' class ResultWrapper(object):'
     def highlight(self, content, top=5):
         if self.search_type != 'content':
             return ''
-        hl = highlight(escape(content),
-                 self.highlight_items,
-                 analyzer=ANALYZER,
-                 fragmenter=FRAGMENTER,
-                 formatter=FORMATTER,
-                 top=top)
+        hl = highlight(
+            text=escape(content),
+            terms=self.highlight_items,
+            analyzer=ANALYZER,
+            fragmenter=FRAGMENTER,
+            formatter=FORMATTER,
+            top=top
+        )
         return hl

rhodecode/lib/indexers/daemon.py

@@ -7,7 +7,7 b''
 
     :created_on: Jan 26, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -43,12 +43,12 b' from rhodecode.model.scm import ScmModel'
 from rhodecode.lib import safe_unicode
 from rhodecode.lib.indexers import INDEX_EXTENSIONS, SCHEMA, IDX_NAME
 
-from vcs.exceptions import ChangesetError, RepositoryError
+from rhodecode.lib.vcs.exceptions import ChangesetError, RepositoryError, \
+    NodeDoesNotExistError
 
 from whoosh.index import create_in, open_dir
 
 
-
 log = logging.getLogger('whooshIndexer')
 # create logger
 log.setLevel(logging.DEBUG)
@@ -67,12 +67,13 b' ch.setFormatter(formatter)'
 # add ch to logger
 log.addHandler(ch)
 
+
 class WhooshIndexingDaemon(object):
     """
     Daemon for atomic jobs
     """
 
-    def __init__(self, indexname='HG_INDEX', index_location=None,
+    def __init__(self, indexname=IDX_NAME, index_location=None,
                  repo_location=None, sa=None, repo_list=None):
         self.indexname = indexname
 
@@ -94,7 +95,6 b' class WhooshIndexingDaemon(object):'
 
             self.repo_paths = filtered_repo_paths
 
-
         self.initial = False
         if not os.path.isdir(self.index_location):
             os.makedirs(self.index_location)
@@ -154,7 +154,6 b' class WhooshIndexingDaemon(object):'
                         modtime=self.get_node_mtime(node),
                         extension=node.extension)
 
-
     def build_index(self):
         if os.path.exists(self.index_location):
             log.debug('removing previous index')
@@ -176,7 +175,6 b' class WhooshIndexingDaemon(object):'
         writer.commit(merge=True)
         log.debug('>>> FINISHED BUILDING INDEX <<<')
 
-
     def update_index(self):
         log.debug('STARTING INCREMENTAL INDEXING UPDATE')
 
@@ -198,7 +196,7 b' class WhooshIndexingDaemon(object):'
 
             try:
                 node = self.get_node(repo, indexed_path)
-            except ChangesetError:
+            except (ChangesetError, NodeDoesNotExistError):
                 # This file was deleted since it was indexed
                 log.debug('removing from index %s' % indexed_path)
                 writer.delete_by_term('path', indexed_path)

rhodecode/lib/middleware/https_fixup.py

@@ -7,7 +7,7 b''
 
     :created_on: May 23, 2010
     :author: marcink
-    :copyright: (C) 2009-2011 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify

rhodecode/lib/middleware/simplegit.py

@@ -8,7 +8,7 b''
 
     :created_on: Apr 28, 2010
     :author: marcink
-    :copyright: (C) 2009-2010 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -27,7 +27,6 b''
 import os
 import logging
 import traceback
-import time
 
 from dulwich import server as dulserver
 
@@ -67,13 +66,12 b' dulserver.DEFAULT_HANDLERS = {'
 from dulwich.repo import Repo
 from dulwich.web import HTTPGitApplication
 
-from paste.auth.basic import AuthBasicAuthenticator
 from paste.httpheaders import REMOTE_USER, AUTH_TYPE
 
 from rhodecode.lib import safe_str
-from rhodecode.lib.auth import authfunc, HasPermissionAnyMiddleware
-from rhodecode.lib.utils import invalidate_cache, is_valid_repo
-from rhodecode.model import meta
+from rhodecode.lib.base import BaseVCSController
+from rhodecode.lib.auth import get_container_username
+from rhodecode.lib.utils import is_valid_repo
 from rhodecode.model.db import User
 
 from webob.exc import HTTPNotFound, HTTPForbidden, HTTPInternalServerError
@@ -93,24 +91,7 b' def is_git(environ):'
     return False
 
 
-class SimpleGit(object):
-
-    def __init__(self, application, config):
-        self.application = application
-        self.config = config
-        # base path of repo locations
-        self.basepath = self.config['base_path']
-        #authenticate this mercurial request using authfunc
-        self.authenticate = AuthBasicAuthenticator('', authfunc)
-
-    def __call__(self, environ, start_response):
-        start = time.time()
-        try:
-            return self._handle_request(environ, start_response)
-        finally:
-            log = logging.getLogger(self.__class__.__name__)
-            log.debug('Request time: %.3fs' % (time.time() - start))
-            meta.Session.remove()
+class SimpleGit(BaseVCSController):
 
     def _handle_request(self, environ, start_response):
         if not is_git(environ):
@@ -143,9 +124,8 b' class SimpleGit(object):'
         if action in ['pull', 'push']:
             anonymous_user = self.__get_user('default')
             username = anonymous_user.username
-            anonymous_perm = self.__check_permission(action,
-                                                     anonymous_user,
-                                                     repo_name)
+            anonymous_perm = self._check_permission(action, anonymous_user,
+                                                    repo_name)
 
             if anonymous_perm is not True or anonymous_user.active is False:
                 if anonymous_perm is not True:
@@ -159,27 +139,29 b' class SimpleGit(object):'
                 # NEED TO AUTHENTICATE AND ASK FOR AUTH USER PERMISSIONS
                 #==============================================================
 
-                if not REMOTE_USER(environ):
+                # Attempting to retrieve username from the container
+                username = get_container_username(environ, self.config)
+
+                # If not authenticated by the container, running basic auth
+                if not username:
                     self.authenticate.realm = \
                         safe_str(self.config['rhodecode_realm'])
                     result = self.authenticate(environ)
                     if isinstance(result, str):
                         AUTH_TYPE.update(environ, 'basic')
                         REMOTE_USER.update(environ, result)
+                        username = result
                     else:
                         return result.wsgi_application(environ, start_response)
 
                 #==============================================================
-                # CHECK PERMISSIONS FOR THIS REQUEST USING GIVEN USERNAME FROM
-                # BASIC AUTH
+                # CHECK PERMISSIONS FOR THIS REQUEST USING GIVEN USERNAME
                 #==============================================================
-
                 if action in ['pull', 'push']:
-                    username = REMOTE_USER(environ)
                     try:
                         user = self.__get_user(username)
-                        if user is None:
-                            return HTTPForbidden()(environ, start_response)                        
+                        if user is None or not user.active:
+                            return HTTPForbidden()(environ, start_response)
                         username = user.username
                     except:
                         log.error(traceback.format_exc())
@@ -187,16 +169,11 b' class SimpleGit(object):'
                                                          start_response)
 
                     #check permissions for this repository
-                    perm = self.__check_permission(action, user,
+                    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}
-
         #===================================================================
         # GIT REQUEST HANDLING
         #===================================================================
@@ -211,8 +188,8 b' class SimpleGit(object):'
         try:
             #invalidate cache on push
             if action == 'push':
-                self.__invalidate_cache(repo_name)
-
+                self._invalidate_cache(repo_name)
+            log.info('%s action on GIT repo "%s"' % (action, repo_name))
             app = self.__make_app(repo_name, repo_path)
             return app(environ, start_response)
         except Exception:
@@ -222,7 +199,7 b' class SimpleGit(object):'
     def __make_app(self, repo_name, repo_path):
         """
         Make an wsgi application using dulserver
-        
+
         :param repo_name: name of the repository
         :param repo_path: full path to the repository
         """
@@ -233,31 +210,6 b' class SimpleGit(object):'
 
         return gitserve
 
-    def __check_permission(self, action, user, repo_name):
-        """
-        Checks permissions using action (push/pull) user and repository
-        name
-
-        :param action: push or pull action
-        :param user: user instance
-        :param repo_name: repository name
-        """
-        if action == 'push':
-            if not HasPermissionAnyMiddleware('repository.write',
-                                              'repository.admin')(user,
-                                                                  repo_name):
-                return False
-
-        else:
-            #any other action need at least read permission
-            if not HasPermissionAnyMiddleware('repository.read',
-                                              'repository.write',
-                                              'repository.admin')(user,
-                                                                  repo_name):
-                return False
-
-        return True
-
     def __get_repository(self, environ):
         """
         Get's repository name out of PATH_INFO header
@@ -265,6 +217,7 b' class SimpleGit(object):'
         :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('/')
@@ -293,10 +246,3 b' class SimpleGit(object):'
                                service_cmd if service_cmd else 'other')
         else:
             return 'other'
-
-    def __invalidate_cache(self, repo_name):
-        """we know that some change was made to repositories and we should
-        invalidate the cache to see the changes right away but only for
-        push requests"""
-        invalidate_cache('get_repo_cached_%s' % repo_name)
-

rhodecode/lib/middleware/simplehg.py

@@ -8,7 +8,7 b''
 
     :created_on: Apr 28, 2010
     :author: marcink
-    :copyright: (C) 2009-2010 Marcin Kuzminski <[e-mail]>
+    :copyright: (C) 2010-2012 Marcin Kuzminski <[e-mail]>
     :license: GPLv3, see COPYING for more details.
 """
 # This program is free software: you can redistribute it and/or modify
@@ -27,19 +27,16 b''
 import os
 import logging
 import traceback
-import time
 
 from mercurial.error import RepoError
 from mercurial.hgweb import hgweb_mod
 
-from paste.auth.basic import AuthBasicAuthenticator
 from paste.httpheaders import REMOTE_USER, AUTH_TYPE
 
 from rhodecode.lib import safe_str
-from rhodecode.lib.auth import authfunc, HasPermissionAnyMiddleware
-from rhodecode.lib.utils import make_ui, invalidate_cache, \
-    is_valid_repo, ui_sections
-from rhodecode.model import meta
+from rhodecode.lib.base import BaseVCSController
+from rhodecode.lib.auth import get_container_username
+from rhodecode.lib.utils import make_ui, is_valid_repo, ui_sections
 from rhodecode.model.db import User
 
 from webob.exc import HTTPNotFound, HTTPForbidden, HTTPInternalServerError
@@ -57,25 +54,7 b' def is_mercurial(environ):'
     return False
 
 
-class SimpleHg(object):
-
-    def __init__(self, application, config):
-        self.application = application
-        self.config = config
-        # base path of repo locations
-        self.basepath = self.config['base_path']
-        #authenticate this mercurial request using authfunc
-        self.authenticate = AuthBasicAuthenticator('', authfunc)
-        self.ipaddr = '0.0.0.0'
-
-    def __call__(self, environ, start_response):
-        start = time.time()
-        try:
-            return self._handle_request(environ, start_response)
-        finally:
-            log = logging.getLogger(self.__class__.__name__)
-            log.debug('Request time: %.3fs' % (time.time() - start))
-            meta.Session.remove()
+class SimpleHg(BaseVCSController):
 
     def _handle_request(self, environ, start_response):
         if not is_mercurial(environ):
@@ -101,7 +80,6 b' class SimpleHg(object):'
         # GET ACTION PULL or PUSH
         #======================================================================
         action = self.__get_action(environ)
-
         #======================================================================
         # CHECK ANONYMOUS PERMISSION
         #======================================================================
@@ -109,9 +87,8 b' class SimpleHg(object):'
             anonymous_user = self.__get_user('default')
 
             username = anonymous_user.username
-            anonymous_perm = self.__check_permission(action,
-                                                     anonymous_user,
-                                                     repo_name)
+            anonymous_perm = self._check_permission(action, anonymous_user,
+                                                    repo_name)
 
             if anonymous_perm is not True or anonymous_user.active is False:
                 if anonymous_perm is not True:
@@ -125,26 +102,28 b' class SimpleHg(object):'
                 # NEED TO AUTHENTICATE AND ASK FOR AUTH USER PERMISSIONS
                 #==============================================================
 
-                if not REMOTE_USER(environ):
+                # Attempting to retrieve username from the container
+                username = get_container_username(environ, self.config)
+
+                # If not authenticated by the container, running basic auth
+                if not username:
                     self.authenticate.realm = \
                         safe_str(self.config['rhodecode_realm'])
                     result = self.authenticate(environ)
                     if isinstance(result, str):
                         AUTH_TYPE.update(environ, 'basic')
                         REMOTE_USER.update(environ, result)
+                        username = result
                     else:
                         return result.wsgi_application(environ, start_response)
 
                 #==============================================================
-                # CHECK PERMISSIONS FOR THIS REQUEST USING GIVEN USERNAME FROM
-                # BASIC AUTH
+                # CHECK PERMISSIONS FOR THIS REQUEST USING GIVEN USERNAME
                 #==============================================================
-
                 if action in ['pull', 'push']:
-                    username = REMOTE_USER(environ)
                     try:
                         user = self.__get_user(username)
-                        if user is None:
+                        if user is None or not user.active:
                             return HTTPForbidden()(environ, start_response)
                         username = user.username
                     except:
@@ -153,7 +132,7 b' class SimpleHg(object):'
                                                          start_response)
 
                     #check permissions for this repository
-                    perm = self.__check_permission(action, user,
+                    perm = self._check_permission(action, user,
                                                    repo_name)
                     if perm is not True:
                         return HTTPForbidden()(environ, start_response)
@@ -173,16 +152,15 b' class SimpleHg(object):'
         baseui = make_ui('db')
         self.__inject_extras(repo_path, baseui, extras)
 
-
         # quick check if that dir exists...
         if is_valid_repo(repo_name, self.basepath) is False:
             return HTTPNotFound()(environ, start_response)
 
         try:
-            #invalidate cache on push
+            # invalidate cache on push
             if action == 'push':
-                self.__invalidate_cache(repo_name)
-
+                self._invalidate_cache(repo_name)
+            log.info('%s action on HG repo "%s"' % (action, repo_name))
             app = self.__make_app(repo_path, baseui, extras)
             return app(environ, start_response)
         except RepoError, e:
@@ -199,32 +177,6 b' class SimpleHg(object):'
         """
         return hgweb_mod.hgweb(repo_name, name=repo_name, baseui=baseui)
 
-
-    def __check_permission(self, action, user, repo_name):
-        """
-        Checks permissions using action (push/pull) user and repository
-        name
-
-        :param action: push or pull action
-        :param user: user instance
-        :param repo_name: repository name
-        """
-        if action == 'push':
-            if not HasPermissionAnyMiddleware('repository.write',
-                                              'repository.admin')(user,
-                                                                  repo_name):
-                return False
-
-        else:
-            #any other action need at least read permission
-            if not HasPermissionAnyMiddleware('repository.read',
-                                              'repository.write',
-                                              'repository.admin')(user,
-                                                                  repo_name):
-                return False
-
-        return True
-
     def __get_repository(self, environ):
         """
         Get's repository name out of PATH_INFO header
@@ -232,6 +184,7 b' class SimpleHg(object):'
         :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('/')
@@ -265,18 +218,12 b' class SimpleHg(object):'
                 else:
                     return 'pull'
 
-    def __invalidate_cache(self, repo_name):
-        """we know that some change was made to repositories and we should
-        invalidate the cache to see the changes right away but only for
-        push requests"""
-        invalidate_cache('get_repo_cached_%s' % repo_name)
-
     def __inject_extras(self, repo_path, baseui, extras={}):
         """
         Injects some extra params into baseui instance
-        
+
         also overwrites global settings with those takes from local hgrc file
-        
+
         :param baseui: baseui instance
         :param extras: dict with extra params to put into baseui
         """
@@ -298,4 +245,3 b' class SimpleHg(object):'
             for section in ui_sections:
                 for k, v in repoui.configitems(section):
                     baseui.setconfig(section, k, v)
-