.. _changelog:

Changelog

=========

1.1.8 (**2011-04-XX**)

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

news

----

fixes

-----

- fixed #140 freeze of python dateutil library, since new version is python2.x

  incompatible

- setup-app will check for write permission in given path

- cleaned up license info issue #149

- fixes for issues #137 and #116

- fixes crashes on gravatar, when passed in email as unicode

- fixed tooltip flickering problems

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

- 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

1.1.4 (**2011-02-19**)

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

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

"""

    rhodecode.__init__

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

    RhodeCode, a web based repository management based on pylons

    versioning implementation: http://semver.org/

    :created_on: Apr 9, 2010

    :author: marcink

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

    :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 platform

VERSION = (1, 1, 8)

__version__ = '.'.join((str(each) for each in VERSION[:4]))

__dbversion__ = 2  # defines current db version for migrations

__platform__ = platform.system()

__license__ = 'GPLv3'

try:

    from rhodecode.lib.utils import get_current_revision

    _rev = get_current_revision()

except ImportError:

    #this is needed when doing some setup.py operations

    _rev = False

if len(VERSION) > 3 and _rev:

    __version__ += ' [rev:%s]' % _rev[0]

def get_version():

    """Returns shorter version (digit parts only) as string."""

    return '.'.join((str(each) for each in VERSION[:3]))

BACKENDS = {

    'hg': 'Mercurial repository',

}

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

"""

    rhodecode.lib.__init__

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

    Some simple helper functions

    :created_on: Jan 5, 2011

    :author: marcink

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

    :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/>.

        return False

def generate_api_key(username, salt=None):

    """

    :param username: username as string

    :param salt: salt to hash generate KEY

    """

    from tempfile import _RandomNameSequence

    import hashlib

    if salt is None:

        salt = _RandomNameSequence().next()

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

    """

    safe unicode function. In case of UnicodeDecode error we try to return

    """

    if isinstance(_str, unicode):

        return _str

    try:

    except UnicodeDecodeError:

            user.permissions['repositories'][perm.RepoToPerm.repository.repo_name] = p

    meta.Session.remove()

    return user

def get_user(session):

    """

    Gets user from session, and wraps permissions into user

    :param session:

    """

    user = session.get('rhodecode_user', AuthUser())

    #if the user is not logged in we check for anonymous access

    #if user is logged and it's a default user check if we still have anonymous

    #access enabled

    if user.user_id is None or user.username == 'default':

        anonymous_user = UserModel().get_by_username('default', cache=True)

        if anonymous_user.active is True:

            #then we set this user is logged in

            user.is_authenticated = True

            user.user_id = anonymous_user.user_id

        else:

            user.is_authenticated = False

    if user.is_authenticated:

        user = UserModel().fill_data(user)

    user = fill_perms(user)

    session['rhodecode_user'] = user

    session.save()

    return user

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

# CHECK DECORATORS

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

class LoginRequired(object):

    """Must be logged in to execute this function else 

    redirect to login page"""

    def __call__(self, func):

        return decorator(self.__wrapper, func)

    def __wrapper(self, func, *fargs, **fkwargs):

        user = session.get('rhodecode_user', AuthUser())

        log.debug('Checking login required for user:%s', user.username)

        if user.is_authenticated:

            log.debug('user %s is authenticated', user.username)

            return func(*fargs, **fkwargs)

        else:

            log.warn('user %s not authenticated', user.username)

            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 

    redirect to login page"""

    def __call__(self, func):

        return decorator(self.__wrapper, func)

    def __wrapper(self, func, *fargs, **fkwargs):

        user = session.get('rhodecode_user', AuthUser())

        log.debug('Checking if user is not anonymous')

        anonymous = user.username == 'default'

        if anonymous:

            p = ''

            if request.environ.get('SCRIPT_NAME') != '/':

                p += request.environ.get('SCRIPT_NAME')

            p += request.environ.get('PATH_INFO')

            if request.environ.get('QUERY_STRING'):

                p += '?' + request.environ.get('QUERY_STRING')

            return redirect(url('login_home', came_from=p))

        else:

            return func(*fargs, **fkwargs)

class PermsDecorator(object):

    """Base class for decorators"""

    def __init__(self, *required_perms):

        available_perms = config['available_permissions']

        for perm in required_perms:

            if perm not in available_perms:

                raise Exception("'%s' permission is not defined" % perm)

        self.required_perms = set(required_perms)

        self.user_perms = None

    def __call__(self, func):

        return decorator(self.__wrapper, func)

    def __wrapper(self, func, *fargs, **fkwargs):

#        _wrapper.__name__ = func.__name__

#        _wrapper.__dict__.update(func.__dict__)

#        _wrapper.__doc__ = func.__doc__

import logging

BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = xrange(30, 38)

RESET_SEQ = "\033[0m"

COLOR_SEQ = "\033[1;%dm"

BOLD_SEQ = "\033[1m"

COLORS = {

    'CRITICAL': MAGENTA, # level 50

    'ERROR': RED, # level 40

    'WARNING': CYAN, # level 30

    'INFO': GREEN, # level 20

    'DEBUG': BLUE, # level 10

}

class ColorFormatter(logging.Formatter):

    def __init__(self, *args, **kwargs):

        # can't do super(...) here because Formatter is an old school class

        logging.Formatter.__init__(self, *args, **kwargs)

    def format(self, record):

        """

        Changes record's levelname to use with COLORS enum

        """

        levelname = record.levelname

        start = COLOR_SEQ % (COLORS[levelname])

        def_record = logging.Formatter.format(self, record)

        end = RESET_SEQ

        colored_record = start + def_record + end

        return colored_record

# 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, time

import sys

from warnings import warn

from multiprocessing.util import Finalize

import errno

class LockHeld(Exception):pass

class DaemonLock(object):

    """daemon locking

    USAGE:

    try:

        l = DaemonLock(desc='test lock')

        main()

        l.release()

    except LockHeld:

        sys.exit(1)

    """

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

                 desc='daemon lock', debug=False):

        self.pidfile = file if file else os.path.join(os.path.dirname(__file__),

                                                      'running.lock')

        self.callbackfn = callbackfn

        self.desc = desc

        self.debug = debug

        self.held = False

        #run the lock automatically !

        self.lock()

        self._finalize = Finalize(self, DaemonLock._on_finalize,

                                    args=(self, debug), exitpriority=10)

    @staticmethod

    def _on_finalize(lock, debug):

        if lock.held:

            if debug:

                print 'leck held finilazing and running lock.release()'

            lock.release()

    def lock(self):

        """locking function, if lock is present it will raise LockHeld exception

        """

        lockname = '%s' % (os.getpid())

        if self.debug:

            print 'running lock'

        self.trylock()

        self.makelock(lockname, self.pidfile)

        return True

    def trylock(self):

        running_pid = False

        if self.debug:

            print 'checking for already running process'

        try:

            pidfile = open(self.pidfile, "r")

            pidfile.seek(0)

            running_pid = int(pidfile.readline())

            pidfile.close()

            if self.debug:

                print 'lock file present running_pid: %s, checking for execution'\

                % running_pid

            # Now we check the PID from lock file matches to the current

            # process PID

            if running_pid:

                try:

                except OSError, exc:

                    if exc.errno in (errno.ESRCH, errno.EPERM):

                        print "Lock File is there but the program is not running"

                        self.release()

                    else:

                        raise

                else:

                    print "You already have an instance of the program running"

                    raise LockHeld()

        except IOError, e:

            if e.errno != 2:

                raise

    def release(self):

        """releases the pid by removing the pidfile

        """

        if self.debug:

            print 'trying to release the pidlock'

        if self.callbackfn:

            #execute callback function on release

            if self.debug:

                print 'executing callback function %s' % self.callbackfn

            self.callbackfn()

        try:

            if self.debug:

                print 'removing pidfile %s' % self.pidfile

            os.remove(self.pidfile)

            self.held = False

        except OSError, e:

            if self.debug:

                print 'removing pidfile failed %s' % e

            pass

    def makelock(self, lockname, pidfile):

        """

        this function will make an actual lock

        :param lockname: acctual pid of file

        :param pidfile: the file to write the pid in

        """

        if self.debug:

            print 'creating a file %s and pid: %s' % (pidfile, lockname)

        pidfile = open(self.pidfile, "wb")

        pidfile.write(lockname)

        pidfile.close

        self.held = True

from sqlalchemy.interfaces import ConnectionProxy

import time

BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = xrange(30, 38)

def color_sql(sql):

    COLOR_SEQ = "\033[1;%dm"

    COLOR_SQL = YELLOW

    normal = '\x1b[0m'

class TimerProxy(ConnectionProxy):

    def __init__(self):

        super(TimerProxy, self).__init__()

        now = time.time()

        try:

            return execute(cursor, statement, parameters, context)

        finally:

            total = time.time() - now