1.4.1 (**2012-09-07**)

----------------------

:status: in-progress

:branch: beta

news

++++

- always put a comment about code-review status change even if user send

  empty data 

- modified_on column saves repository update and it's going to be used

  later for light version of main page ref #500

- pull request notifications send much nicer emails with details about pull

  request

- #551 show breadcrumbs in summary view for repositories inside a group

fixes

+++++

- fixed migrations of permissions that can lead to inconsistency.

  Some users sent feedback that after upgrading from older versions issues 

  with updating default permissions occurred. RhodeCode detects that now and

  resets default user permission to initial state if there is a need for that.

  Also forces users to set the default value for new forking permission. 

- #535 improved apache wsgi example configuration in docs

- fixes #550 mercurial repositories comparision failed when origin repo had

  additional not-common changesets

- fixed status of code-review in preview windows of pull request

- git forks were not initialized at bare repos

- fixes #555 fixes issues with comparing non-related repositories

- fixes #557 follower counter always counts up

- fixed issue #560 require push ssl checkbox wasn't shown when option was

  enabled

- fixed #559

- fixed issue #559 fixed bug in routing that mapped repo names with <name>_<num> in name as

  if it was a request to url by repository ID

Installing RhodeCode from PyPI (aka "Cheeseshop")

-------------------------------------------------

.. _rabbitmq: http://www.rabbitmq.com/

    WSGIDaemonProcess pylons \

.. note::

   when running apache as root please add: `user=www-data group=www-data` 

   into above configuration

.. note::

   RhodeCode cannot be runned in multiprocess mode in apache, make sure

   you don't specify `processes=num` directive in the config

Upgrading from PyPI (aka "Cheeseshop")

---------------------------------------

   Firstly, it is recommended that you **always** perform a database and 

   configuration backup before doing an upgrade.

   (These directions will use '{version}' to note that this is the version of 

   Rhodecode that these files were used with.  If backing up your RhodeCode 

   instance from version 1.3.6 to 1.4.0, the ``production.ini`` file would be 

   backed up to ``production.ini.1-3-6``.)

If using a sqlite database, stop the Rhodecode process/daemon/service, and

then make a copy of the database file::

 service rhodecode stop

 cp rhodecode.db rhodecode.db.{version}

Back up your configuration file::

 cp production.ini production.ini.{version}

Ensure that you are using the Python Virtual Environment that you'd originally

installed Rhodecode in::

 pip freeze

will list all packages installed in the current environment.  If Rhodecode 

isn't listed, change virtual environments to your venv location::

 source /opt/rhodecode-venv/bin/activate

Once you have verified the environment you can upgrade ``Rhodecode`` with::

Then run the following command from the installation directory::

current configuration. It will try to perform an automerge. It's recommended 

that you re-check the content after the automerge.

You may find it helpful to clear out your log file so that new errors are 

readily apparent::

 echo > rhodecode.log

Once that is complete, you may now start your upgraded Rhodecode Instance::

 service rhodecode start

Or::

 paster serve /var/www/rhodecode/production.ini

.. _rabbitmq: http://www.rabbitmq.com/

VERSION = (1, 4, 1)

__dbversion__ = 7  # defines current db version for migrations

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

from rhodecode.lib.utils2 import str2bool

            recursive = str2bool(request.POST.get('recursive', False))

            ReposGroupModel().delete_permission(

                repos_group=group_name, obj=request.POST['user_id'],

                obj_type='user', recursive=recursive

            recursive = str2bool(request.POST.get('recursive', False))

            ReposGroupModel().delete_permission(

                repos_group=group_name, obj=request.POST['users_group_id'],

                obj_type='users_group', recursive=recursive

from rhodecode.lib.utils2 import str2bool

            if k == 'push_ssl':

                v = str2bool(v)

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

        if status and change_status:

            text = text or (_('Status change -> %s')

                            % ChangesetStatus.get_status_lbl(status))

            text=text,

        c.statuses = org_repo.statuses([x.raw_id for x in c.cs_ranges])

        c.target_repo = c.pull_request.org_repo.repo_name

        try:

            cur_status = c.statuses[c.pull_request.revisions[0]][0]

        except:

            log.error(traceback.format_exc())

            cur_status = 'undefined'

        if c.pull_request.is_closed() and 0:

            c.current_changeset_status = cur_status

        else:

            # changeset(pull-request) status calulation based on reviewers

                                            c.pull_request_reviewers,

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

        if status and change_status:

            text = text or (_('Status change -> %s')

                            % ChangesetStatus.get_status_lbl(status))

            text=text,

    if repo_type == 'git':

        backend(safe_str(destination_fork_path), create=True,

                src_url=safe_str(source_repo_path),

                update_after_clone=update_after_clone,

                bare=True)

    elif repo_type == 'hg':

    else:

        raise Exception('Unknown backend type %s' % repo_type)

                default_user = User.get_by_username(User.DEFAULT_USER)

                perm = Permission.get_by_key('hg.fork.repository')

                reg_perm = UserToPerm()

                reg_perm.user = default_user

                reg_perm.permission = perm

                Session().add(reg_perm)

            def step_7(self):

                perm_fixes = self.klass.reset_permissions(User.DEFAULT_USER)

                Session().commit()

                if perm_fixes:

                    notify('There was an inconsistent state of permissions '

                           'detected for default user. Permissions are now '

                           'reset to the default value for default user. '

                           'Please validate and check default permissions '

                           'in admin panel')

    def reset_permissions(self, username):

        """

        Resets permissions to default state, usefull when old systems had

        bad permissions, we must clean them up

        :param username:

        :type username:

        """

        default_user = User.get_by_username(username)

        if not default_user:

            return

        u2p = UserToPerm.query()\

            .filter(UserToPerm.user == default_user).all()

        fixed = False

        if len(u2p) != len(User.DEFAULT_PERMISSIONS):

            for p in u2p:

                Session().delete(p)

            fixed = True

            self.populate_default_permissions()

        return fixed

        real_path = os.path.realpath(path)

        if real_path != path:

            if not ask_ok(('Path looks like a symlink, Rhodecode will store '

                           'given path as %s ? [y/n]') % (real_path)):

                log.error('Canceled by user')

                sys.exit(-1)

        return real_path

        for def_perm in User.DEFAULT_PERMISSIONS:

    other_ref = Column('other_ref', Unicode(256), nullable=False)

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 sqlalchemy.ext.declarative import declarative_base

from rhodecode.lib.dbmigrate.migrate import *

from rhodecode.lib.dbmigrate.migrate.changeset import *

from rhodecode.model.meta import Base

from rhodecode.model import meta

log = logging.getLogger(__name__)

def upgrade(migrate_engine):

    """

    Upgrade operations go here.

    Don't create your own engine; bind migrate_engine to your metadata

    """

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

    # CHANGESET_COMMENTS

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

    from rhodecode.lib.dbmigrate.schema.db_1_4_0 import ChangesetComment

    tbl_name = ChangesetComment.__tablename__

    tbl = Table(tbl_name,

                MetaData(bind=migrate_engine), autoload=True,

                autoload_with=migrate_engine)

    col = tbl.columns.revision

    # remove nullability from revision field

    col.alter(nullable=True)

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

    # REPOSITORY

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

    from rhodecode.lib.dbmigrate.schema.db_1_4_0 import Repository

    tbl = Repository.__table__

    updated_on = Column('updated_on', DateTime(timezone=False),

                        nullable=True, unique=None)

    # create created on column for future lightweight main page

    updated_on.create(table=tbl)

def downgrade(migrate_engine):

    meta = MetaData()

    meta.bind = migrate_engine

                                            heads=None)

            raise TypeError("%r is not JSON serializable" % (obj,))

from rhodecode.lib.exceptions import HTTPLockedRC

from rhodecode.model.db import Repository, User

    if not repo:

        raise OSError('Repository %s not found in database'

                      % (safe_str(repo_path)))

#    # clear cache keys

#    log.debug("Clearing cache keys now...")

#    CacheInvalidation.clear_cache()

#    sa.commit()

        # during starting install all cache keys for all repositories in the

        # system, this will register all repos and multiple instances

        key, _prefix, _org_key = CacheInvalidation._get_key(name)

        log.debug("Creating cache key for %s instance_id:`%s`" % (name, _prefix))

        CacheInvalidation._get_or_create_key(key, _prefix, _org_key, commit=False)

from mercurial import scmutil

from mercurial.discovery import findcommonoutgoing

        leading one wins, if number of occurrences are equal than weaker wins

            email_kwargs = {

                'status_change': status_change,

            }

            _url = h.url('pullrequest_show',

            subj = safe_unicode(

                h.link_to('Re pull request: %(desc)s %(line)s' % \

                          {'desc': desc, 'line': line}, _url)

            # add the reviewers to notification

            recipients += [x.user for x in pull_request.reviewers]

            #set some variables for email notification

            email_kwargs = {

                'pr_id': pull_request.pull_request_id,

                'status_change': status_change,

                'pr_comment_url': _url,

                'pr_comment_user': h.person(user.email),

                'pr_target_repo': h.url('summary_home',

                                   repo_name=pull_request.other_repo.repo_name,

                                   qualified=True)

            }

            email_kwargs=email_kwargs

            email_kwargs.update({'pr_mention': True})

                email_kwargs=email_kwargs

    def __repr__(self):

        return '<DB:%s[%s:%s]>' % (self.__class__.__name__, self.ui_key,

                                   self.ui_value)

    DEFAULT_PERMISSIONS = [

        'hg.register.manual_activate', 'hg.create.repository',

        'hg.fork.repository', 'repository.read'

    ]

    updated_on = Column('updated_on', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)

    @property

    def cache_keys(self):

        """

        Returns associated cache keys for that repo

        """

        return CacheInvalidation.query()\

            .filter(CacheInvalidation.cache_args == self.repo_name)\

            .order_by(CacheInvalidation.cache_key)\

            .all()

    @property

    def prefix(self):

        _split = self.cache_key.split(self.cache_args, 1)

        if _split and len(_split) == 2:

            return _split[0]

        return ''

    def _get_or_create_key(cls, key, prefix, org_key, commit=True):

                if commit:

        recursive = v.StringBoolean(if_missing=False)

    return _PullRequestForm

    TYPE_PULL_REQUEST_COMMENT = Notification.TYPE_PULL_REQUEST_COMMENT

         self.TYPE_DEFAULT: 'email_templates/default.html',