RhodeCode is similar in some respects to github or bitbucket_, 

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. 

RhodeCode is powered by a vcs_ library that Lukasz Balcerzak and I created to 

handle multiple different version control systems.

http://demo.rhodecode.org

The latest source for RhodeCode can be obtained from official RhodeCode instance

https://hg.rhodecode.org 

.. _bitbucket: http://bitbucket.org/

1.1.5 (**2011-03-1X**)

======================

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

- fixed #131 problem with boolean values for LDAP

- fixed #122 mysql problems thanks to striker69 

- fixed problem with errors on calling raw/raw_files/annotate functions 

  with unknown revisions

- fixed returned rawfiles attachment names with international character

- cleaned out docs, big thanks to Jason Harris

RhodeCode repository on bitbucket_

your forked repository. Please post all fixes into **BETA** branch since your 

fix might be already fixed there and i try to merge all fixes from beta into

stable, and not the other way. Finally, when you are finished making a change, 

please send me a pull request.

|  Marcin

.. _bitbucket: http://bitbucket.org/

.. _bitbucket: http://bitbucket.org/

any third party applications. However, using Celery_ will give you a large 

speed improvement when using many big repositories. If you plan to use 

RhodeCode for say 7 to 10 small repositories, RhodeCode will perform perfectly 

well without celery running.

If you make the decision to run RhodeCode with celery make sure you run 

celeryd using paster and message broker together with the application.   

| 

| 

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

   before doing an upgrade.

to make a backup of your configuration file before hand and recheck the 

content after the automerge.

It is also recommended that you rebuild the whoosh index after upgrading since 

the new whoosh version could introduce some incompatible index changes.

and will always recheck the settings of the application, if there are no new 

options that need to be set.

import platform

VERSION = (1, 1, 5)

__platform__ = platform.system()

celeryd.max.tasks.per.child = 1

                    h.flash(_('error occurred during updating'

                              ' application settings'), category='error')

    :copyright: (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>    

    def __get_cs_or_redirect(self, rev, repo_name):

        """

        Safe way to get changeset if error occur it redirects to tip with

        proper message

        :param rev: revision to fetch

        :param repo_name: repo name to redirect after

        """

        _repo = ScmModel().get_repo(c.repo_name)

        try:

            return _repo.get_changeset(rev)

        except EmptyRepositoryError, e:

            h.flash(_('There are no files yet'), category='warning')

            redirect(h.url('summary_home', repo_name=repo_name))

        except RepositoryError, e:

            h.flash(str(e), category='warning')

            redirect(h.url('files_home', repo_name=repo_name, revision='tip'))

        cs = self.__get_cs_or_redirect(revision, repo_name)

        c.repo = ScmModel().get_repo(c.repo_name)

        c.changeset = cs

        cur_rev = c.changeset.revision

        prev_rev = c.repo.get_changeset(get_prev_rev(cur_rev)).raw_id

        next_rev = c.repo.get_changeset(get_next_rev(cur_rev)).raw_id

        c.url_prev = url('files_home', repo_name=c.repo_name,

                         revision=prev_rev, f_path=f_path)

        c.url_next = url('files_home', repo_name=c.repo_name,

                     revision=next_rev, f_path=f_path)

            c.files_list = c.changeset.get_node(f_path)

            c.file_history = self._get_history(c.repo, c.files_list, f_path)

            redirect(h.url('files_home', repo_name=repo_name,

                           revision=revision))

        cs = self.__get_cs_or_redirect(revision, repo_name)

        try:

            file_node = cs.get_node(f_path)

        except RepositoryError, e:

            h.flash(str(e), category='warning')

            redirect(h.url('files_home', repo_name=repo_name,

                           revision=cs.raw_id))

        fname = f_path.split('/')[-1].encode('utf8', 'replace')

        response.content_disposition = 'attachment; filename=%s' % fname

        cs = self.__get_cs_or_redirect(revision, repo_name)

        try:

            file_node = cs.get_node(f_path)

        except RepositoryError, e:

            h.flash(str(e), category='warning')

            redirect(h.url('files_home', repo_name=repo_name,

                           revision=cs.raw_id))

        cs = self.__get_cs_or_redirect(revision, repo_name)

            c.file = cs.get_node(f_path)

            redirect(h.url('files_home', repo_name=repo_name, revision=cs.raw_id))

        c.file_history = self._get_history(ScmModel().get_repo(c.repo_name), c.file, f_path)

        c.cs = cs

            if node1.is_binary or node2.is_binary:

                return _('binary file changed')

            if node1.is_binary or node2.is_binary:

                return _('binary file changed')

            elif node1.is_binary or node2.is_binary:

                c.cur_diff = _('Binary file')

            elif node1.is_binary or node2.is_binary:

                c.cur_diff = _('Binary file')

        if not c.cur_diff:

            c.no_changes = True

        sortables = ['name', 'description', 'last_change', 'tip', 'owner']

import traceback

from paste.httpexceptions import HTTPInternalServerError, HTTPBadRequest

from sqlalchemy import or_

                    log.error(traceback.format_exc())

                    log.error(traceback.format_exc())

        raise HTTPBadRequest()

    if isinstance(v, (str, unicode)):

        obj = v.strip().lower()

        if obj in ['true', 'yes', 'on', 'y', 't', '1']:

            return True

        elif obj in ['false', 'no', 'off', 'n', 'f', '0']:

            return False

        else:

            raise ValueError("String is not true/false: %r" % obj)

    return bool(obj)

def generate_api_key(username, salt=None):

    from tempfile import _RandomNameSequence

    import hashlib

    if salt is None:

        salt = _RandomNameSequence().next()

    return hashlib.sha1(username + salt).hexdigest()

# -*- coding: utf-8 -*-

"""

    rhodecode.lib.auth

    ~~~~~~~~~~~~~~~~~~

    authentication and permission libraries

    :created_on: Apr 4, 2010

    :copyright: (c) 2010 by marcink.

    :license: LICENSE_NAME, see LICENSE_FILE for more details.

"""

import random

import logging

import traceback

from decorator import decorator

from pylons.i18n.translation import _

from rhodecode import __platform__

if __platform__ == 'Windows':

    from hashlib import sha256

if __platform__ in ('Linux', 'Darwin'):

    import bcrypt

from rhodecode.lib import str2bool

from rhodecode.lib.exceptions import LdapPasswordError, LdapUsernameError

from rhodecode.model.db import Permission, RepoToPerm, Repository, \

    User, UserToPerm

class RhodeCodeCrypto(object):

    @classmethod

    def hash_string(cls, str_):

        """

        Cryptographic function used for password hashing based on pybcrypt

        or pycrypto in windows

        :param password: password to hash

        """

        if __platform__ == 'Windows':

            return sha256(str_).hexdigest()

        elif __platform__ in ('Linux', 'Darwin'):

            return bcrypt.hashpw(str_, bcrypt.gensalt(10))

        else:

            raise Exception('Unknown or unsupported platform %s' % __platform__)

    @classmethod

    def hash_check(cls, password, hashed):

        """

        Checks matching password with it's hashed value, runs different

        implementation based on platform it runs on

        :param password: password

        :param hashed: password in hashed form

        """

        if __platform__ == 'Windows':

            return sha256(password).hexdigest() == hashed

        elif __platform__ in ('Linux', 'Darwin'):

            return bcrypt.hashpw(password, hashed) == hashed

        else:

            raise Exception('Unknown or unsupported platform %s' % __platform__)

    return RhodeCodeCrypto.hash_string(password)

    return RhodeCodeCrypto.hash_check(password, hashed)

        if str2bool(ldap_settings.get('ldap_active')):

                  'use_ldaps':str2bool(ldap_settings.get('ldap_ldaps')),

# Copyright (C) 2009-2011 Marcin Kuzminski <marcin@python-works.com>

        log.info("Any existing database is going to be destroyed")

        if self.tests:

            destroy = True

        else:

            destroy = ask_ok('Are you sure to destroy old database ? [y/n]')

        if not destroy:

            sys.exit()

        if destroy:

            meta.Base.metadata.drop_all()

            for k, v in [('ldap_active', 'false'),

                        ('ldap_host', ''),

                        ('ldap_port', '389'),

                        ('ldap_ldaps', 'false'),

                        ('ldap_dn_user', ''), ('ldap_dn_pass', ''),

                        ('ldap_base_dn', '')]:

                setting = RhodeCodeSettings(k, v)

        if isinstance(paths, str):

            paths = paths.decode('utf-8', 'replace')

    tmpl = """<img src="%s%s" alt="%s"/>"""

        return literal(pref + '<br/> '.join([x.path.decode('utf-8', 'replace') for x in nodes[:30]]) + suf)

from sqlalchemy.orm import relationship, backref

from sqlalchemy.orm.interfaces import MapperExtension

from rhodecode.model.meta import Base, Session

class RhodeCodeSettings(Base):

    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)

class RhodeCodeUi(Base):

    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)