Thomas Waldmann <tw-public@gmx.de>

    Les Peabody <lpeabody@gmail.com>

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

- #258 RhodeCode 1.2 assumes egg folder is writable (lockfiles problems)

- #265 ldap save fails sometimes on converting attributes to booleans, 

  added getter and setter into model that will prevent from this on db model level

- fixed problems with timestamps issues #251 and #213

- fixes #266 Rhodecode allows to create repo with the same name and in 

  the same parent as group

- fixes #245 Rescan of the repositories on Windows

- fixes #248 cannot edit repos inside a group on windows

- fixes #219 forking problems on windows

Apache virtual host reverse proxy example

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

Alternatively, RhodeCode can be set up with Apache under mod_wsgi. For

that, you'll need to:

- Install mod_wsgi. If using a Debian-based distro, you can install

  the package libapache2-mod-wsgi::

    aptitude install libapache2-mod-wsgi

- Enable mod_wsgi::

    a2enmod wsgi

- Create a wsgi dispatch script, like the one below. Make sure you

  check the paths correctly point to where you installed RhodeCode

  and its Python Virtual Environment.

- Enable the WSGIScriptAlias directive for the wsgi dispatch script,

  as in the following example. Once again, check the paths are

  correctly specified.

Here is a sample excerpt from an Apache Virtual Host configuration file::

    WSGIDaemonProcess pylons user=www-data group=www-data processes=1 \

        threads=4 \

        python-path=/home/web/rhodecode/pyenv/lib/python2.6/site-packages

    WSGIScriptAlias / /home/web/rhodecode/dispatch.wsgi

    import site

    site.addsitedir("/home/web/rhodecode/pyenv/lib/python2.6/site-packages")

Note: when using mod_wsgi you'll need to install the same version of

Mercurial that's inside RhodeCode's virtualenv also on the system's Python

environment.

#!/bin/sh

########################################

#### THIS IS A REDHAT INIT.D SCRIPT ####

########################################

##################################################

#

# RhodeCode server startup script

# Recommended default-startup: 2 3 4 5

# Recommended default-stop: 0 1 6

#

##################################################

APP_NAME="rhodecode"

# the location of your app

# since this is a web app, it should go in /var/www

APP_PATH="/var/www/$APP_NAME"

CONF_NAME="production.ini"

# write to wherever the PID should be stored, just ensure

# that the user you run paster as has the appropriate permissions

# same goes for the log file

PID_PATH="/var/run/rhodecode/pid"

LOG_PATH="/var/log/rhodecode/rhodecode.log"

# replace this with the path to the virtual environment you

# made for RhodeCode

PYTHON_PATH="/opt/python_virtualenvironments/rhodecode-venv"

RUN_AS="rhodecode"

DAEMON="$PYTHON_PATH/bin/paster"

DAEMON_OPTS="serve --daemon \

    --user=$RUN_AS \

    --group=$RUN_AS \

    --pid-file=$PID_PATH \

    --log-file=$LOG_PATH $APP_PATH/$CONF_NAME"

DESC="rhodecode-server"

LOCK_FILE="/var/lock/subsys/$APP_NAME"

# source CentOS init functions

. /etc/init.d/functions

RETVAL=0

remove_pid () {

  rm -f ${PID_PATH}

  rmdir `dirname ${PID_PATH}`

}

ensure_pid_dir () {

  PID_DIR=`dirname ${PID_PATH}`

  if [ ! -d ${PID_DIR} ] ; then

    mkdir -p ${PID_DIR}

    chown -R ${RUN_AS}:${RUN_AS} ${PID_DIR}

    chmod 755 ${PID_DIR}

  fi

}

start_rhodecode () {

    ensure_pid_dir

    PYTHON_EGG_CACHE="/tmp" daemon --pidfile $PID_PATH \

        --user $RUN_AS "$DAEMON $DAEMON_OPTS"

    RETVAL=$?

    [ $RETVAL -eq 0 ] && touch $LOCK_FILE

    return $RETVAL

}

stop_rhodecode () {

    if [ -e $LOCK_FILE ]; then

      killproc -p $PID_PATH

      RETVAL=$?

      rm -f $LOCK_FILE

      rm -f $PID_PATH

    else

      RETVAL=1

    fi

    return $RETVAL

}

status_rhodecode() {

  if [ -e $LOCK_FILE ]; then

    # exit with non-zero to indicate failure

    RETVAL=1

  else

    RETVAL=0

  fi

  return $RETVAL

}

restart_rhodecode () {

    stop_rhodecode

    start_rhodecode

    RETVAL=$?

}

case "$1" in

  start)

    echo -n $"Starting $DESC: "

    start_rhodecode

    echo

    ;;

  stop)

    echo -n $"Stopping $DESC: "

    stop_rhodecode

    echo

    ;;

  status)

    status_rhodecode

    RETVAL=$?

    if [ ! $RETVAL -eq 0 ]; then

      echo "RhodeCode server is running..."

    else

      echo "RhodeCode server is stopped."

    fi

    ;;

  restart)

    echo -n $"Restarting $DESC: "

    restart_rhodecode

    echo

    ;;

  *)

    echo $"Usage: $0 {start|stop|restart|status}"

    RETVAL=1

    ;;

esac

exit $RETVAL

    from rhodecode.lib import get_current_revision

                controller='summary',

    rmap.connect('repos_group_home', '/{group_name:.*}',

                controller='admin/repos_groups', action="show_by_name",

                conditions=dict(function=check_group))

        c.repo_groups = Group.groups_choices()

        c.repo_groups_choices = map(lambda k: unicode(k[0]), c.repo_groups)

        repo = db_repo.scm_instance

            repo = repo_model.update(repo_name, form_result)

            changed_name = repo.repo_name

from sqlalchemy.exc import IntegrityError

from rhodecode.lib.auth import LoginRequired, HasPermissionAnyDecorator

        c.repo_groups = Group.groups_choices()

        data['group_name'] = repo_group.name

        except IntegrityError, e:

            if e.message.find('groups_group_parent_id_fkey'):

                log.error(traceback.format_exc())

                h.flash(_('Cannot delete this group it still contains '

                          'subgroups'),

                        category='warning')

            else:

                log.error(traceback.format_exc())

                h.flash(_('error occurred during deletion of repos '

                          'group %s' % gr.group_name), category='error')

            h.flash(_('error occurred during deletion of repos '

                      'group %s' % gr.group_name), category='error')

    def show_by_name(self, group_name):

        id_ = Group.get_by_group_name(group_name).group_id

        return self.show(id_)

        c.repo_groups = Group.groups_choices()

import os

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 vcs.exceptions import RepositoryError, VCSError

        repopath = os.path.join(os.path.dirname(__file__), '..', '..')

        scm = get_scm(repopath)[0]

        repo = get_repo(path=repopath, alias=scm)

        tip = repo.get_changeset()

        return (tip.revision, tip.short_id)

    except (ImportError, RepositoryError, VCSError), err:

        if not quiet:

            print ("Cannot retrieve rhodecode's revision. Original error "

                   "was: %s" % err)

        return None

        lockkey_path = config['here']

            l = DaemonLock(file_=jn(lockkey_path, lockkey))

    lockkey_path = config['here']

        lock = l = DaemonLock(file_=jn(lockkey_path, lockkey))

import os

from rhodecode import __platform__, PLATFORM_WIN

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

# kill FUNCTIONS

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

if __platform__ in PLATFORM_WIN:

    import ctypes

    def kill(pid, sig):

        """kill function for Win32"""

        kernel32 = ctypes.windll.kernel32

        handle = kernel32.OpenProcess(1, 0, pid)

        return (0 != kernel32.TerminateProcess(handle, 0))

else:

    kill = os.kill

            return link_to(group.name, url('repos_group_home',

                                           group_name=group.group_name))

            l = DaemonLock(file_=jn(dn(dn(index_location)), 'make_index.lock'))

from rhodecode.lib.compat import kill

        l = DaemonLock(file_='/path/tolockfile',desc='test lock')

    def __init__(self, file_=None, callbackfn=None,

        self.pidfile = file_ if file_ else os.path.join(

    # last element is repo in nested groups structure

    groups = groups[:-1]

    for lvl, group_name in enumerate(groups):

        group_name = '/'.join(groups[:lvl] + [group_name])

    # fixup groups paths to new format on the fly

    # TODO: remove this in future

    for g in Group.query().all():

        g.group_name = g.get_new_name(g.name)

        sa.add(g)    

        group = map_groups(name.split(Repository.url_sep()))

        l = DaemonLock(file_=jn(dn(index_location), 'make_index.lock'))

from sqlalchemy.ext.hybrid import hybrid_property

from sqlalchemy.orm import relationship, backref, joinedload, class_mapper, \

    validates

    generate_api_key, safe_unicode

        if id_:

            return Session.query(cls).get(id_)

    _app_settings_value = Column("app_settings_value", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

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

                .filter(cls.app_settings_name.startswith('ldap_')).all()

            return Session.query(cls).filter(cls.username.ilike(username)).scalar()