self.sa.commit()

                h.flash(_('Ldap settings updated successfully'),

                    category='success')

            except (DatabaseError,):

                raise

        except LdapImportError:

            h.flash(_('Unable to activate ldap. The "python-ldap" library '

                      'is missing.'), category='warning')

        except formencode.Invalid, errors:

            e = errors.error_dict or {}

            return htmlfill.render(

                render('admin/ldap/ldap.html'),

                defaults=errors.value,

                errors=e,

                prefix_error=False,

                encoding="UTF-8")

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('error occurred during update of ldap settings'),

                    category='error')

        return redirect(url('ldap_home'))

            content = convert_line_endings(r_post.get('content'), mode)

            message = r_post.get('message') or (_('Edited %s via RhodeCode')

                                                % (f_path))

            if content == old_content:

                h.flash(_('No changes'),

                    category='warning')

                return redirect(url('changeset_home', repo_name=c.repo_name,

                                    revision='tip'))

            try:

                content = content.encode('utf8')

                message = message.encode('utf8')

                path = f_path.encode('utf8')

                author = self.rhodecode_user.full_contact.encode('utf8')

                m = IMC(c.rhodecode_repo)

                m.change(FileNode(path, content))

                m.commit(message=message,

                         author=author,

                         parents=[c.cs], branch=c.cs.branch)

                h.flash(_('Successfully committed to %s' % f_path),

                        category='success')

            except Exception, e:

                log.error(traceback.format_exc())

                h.flash(_('Error occurred during commit'), category='error')

            return redirect(url('changeset_home',

                                repo_name=c.repo_name, revision='tip'))

        return render('files/files_edit.html')

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')

    def archivefile(self, repo_name, fname):

        fileformat = None

        revision = None

        ext = None

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

def __get_lem():

    from pygments import lexers

    from string import lower

    from collections import defaultdict

    d = defaultdict(lambda: [])

    def __clean(s):

        s = s.lstrip('*')

        s = s.lstrip('.')

        if s.find('[') != -1:

        if m:

            m = reduce(lambda x, y: x + y, m)

            for ext in m:

                desc = lx.replace('Lexer', '')

                d[ext].append(desc)

    return dict(d)

# language map is also used by whoosh indexer, which for those specified

# extensions will index it's content

LANGUAGES_EXTENSIONS_MAP = __get_lem()

# NOTE: that this will overide any mappings in LANGUAGES_EXTENSIONS_MAP

ADDITIONAL_MAPPINGS = {'xaml': 'XAML'}

LANGUAGES_EXTENSIONS_MAP.update(ADDITIONAL_MAPPINGS)

def str2bool(_str):

    """

    returs True/False value from given string, it tries to translate the

    string into boolean

    :param _str: string value to translate into boolean

    :rtype: boolean

    :returns: boolean from given string

    """

    if _str is None:

        return False

    if _str in (True, False):

        return _str

    _str = str(_str).strip().lower()

    return _str in ('t', 'true', 'y', 'yes', 'on', '1')

def convert_line_endings(temp, mode):

    from string import replace

    #modes:  0 - Unix, 1 - Mac, 2 - DOS

    if mode == 0:

            temp = replace(temp, '\r\n', '\n')

            temp = replace(temp, '\r', '\n')

    elif mode == 1:

            temp = replace(temp, '\r\n', '\r')

            temp = replace(temp, '\n', '\r')

    elif mode == 2:

            import re

            temp = re.sub("\r(?!\n)|(?<!\r)\n", "\r\n", temp)

    return temp

def detect_mode(line, default):

    if line.endswith('\r\n'):

        return 2

    elif line.endswith('\n'):

        return 0

    elif line.endswith('\r'):

        return 1

    else:

        return default

def generate_api_key(username, salt=None):

    """

    Generates unique API key for given username,if salt is not given

    it'll be generated from some random string

    :param username: username as string

    :param salt: salt to hash generate KEY

    :rtype: str

    :returns: sha1 hash from username+salt

    """

    from tempfile import _RandomNameSequence

    import hashlib

    try:

        u_str = unicode(_str, from_encoding)

    except UnicodeDecodeError:

        u_str = unicode(_str, from_encoding, 'replace')

    return u_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.

    """

    from sqlalchemy import engine_from_config as efc

    from sqlalchemy.pool import NullPool

    url = configuration[prefix + 'url']

    if url.startswith('sqlite'):

    return efc(configuration, prefix, **kwargs)

"""The application's Globals object"""

from beaker.cache import CacheManager

from beaker.util import parse_cache_config_options

class Globals(object):

    """Globals acts as a container for objects available throughout the

    life of the application

    """

    def __init__(self, config):

        """One instance of Globals is created during application

        initialization and is available during requests via the

        'app_globals' variable

        """

                  'ldap_filter': ldap_settings.get('ldap_filter'),

                  'search_scope': ldap_settings.get('ldap_search_scope'),

                  'attr_login': ldap_settings.get('ldap_attr_login'),

                  'ldap_version': 3,

                  }

            log.debug('Checking for ldap authentication')

            try:

                aldap = AuthLdap(**kwargs)

                (user_dn, ldap_attrs) = aldap.authenticate_ldap(username,

                                                                password)

                log.debug('Got ldap DN response %s', user_dn)

                                                           .get(k), [''])[0]

                user_attrs = {

                    'name': get_ldap_attr('ldap_attr_firstname'),

                    'lastname': get_ldap_attr('ldap_attr_lastname'),

                    'email': get_ldap_attr('ldap_attr_email'),

                    }

                if user_model.create_ldap(username, password, user_dn,

                                          user_attrs):

                    log.info('created new ldap user %s', username)

# 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 tarfile

import datetime

import subprocess

logging.basicConfig(level=logging.DEBUG,

                    format="%(asctime)s %(levelname)-5.5s %(message)s")

class BackupManager(object):

    def __init__(self, repos_location, rsa_key, backup_server):

        today = datetime.datetime.now().weekday() + 1

        self.backup_file_name = "mercurial_repos.%s.tar.gz" % today

        self.id_rsa_path = self.get_id_rsa(rsa_key)

        self.repos_path = self.get_repos_path(repos_location)

        self.backup_server = backup_server

        self.backup_file_path = '/tmp'

        logging.info('starting backup for %s', self.repos_path)

        logging.info('backup target %s', self.backup_file_path)

    def get_id_rsa(self, rsa_key):

        if not os.path.isfile(rsa_key):

            logging.error('Could not load id_rsa key file in %s', rsa_key)

            sys.exit()

        return rsa_key

    def get_repos_path(self, path):

        if not os.path.isdir(path):

            logging.error('Wrong location for repositories in %s', path)

            sys.exit()

        return path

    def backup_repos(self):

        bckp_file = os.path.join(self.backup_file_path, self.backup_file_name)

        tar = tarfile.open(bckp_file, "w:gz")

        for dir_name in os.listdir(self.repos_path):

            logging.info('backing up %s', dir_name)

            tar.add(os.path.join(self.repos_path, dir_name), dir_name)

        tar.close()

        logging.info('finished backup of mercurial repositories')

    def transfer_files(self):

        params = {

                  'id_rsa_key': self.id_rsa_path,

                                             self.backup_file_name),

                  }

        cmd = ['scp', '-l', '40000', '-i', '%(id_rsa_key)s' % params,

               '%(backup_file)s' % params,

               '%(backup_server)s' % params]

        subprocess.call(cmd)

        logging.info('Transfered file %s to %s', self.backup_file_name, cmd[4])

    def rm_file(self):

        logging.info('Removing file %s', self.backup_file_name)

        os.remove(os.path.join(self.backup_file_path, self.backup_file_name))

if __name__ == "__main__":

    repo_location = '/home/repo_path'

    backup_server = 'root@192.168.1.100:/backups/mercurial'

    rsa_key = '/home/id_rsa'

    B_MANAGER = BackupManager(repo_location, rsa_key, backup_server)

    B_MANAGER.backup_repos()

    B_MANAGER.transfer_files()

    B_MANAGER.rm_file()

from pylons import config, tmpl_context as c, request, session

from pylons.controllers import WSGIController

from pylons.templating import render_mako as render

from rhodecode import __version__

from rhodecode.lib.auth import AuthUser

from rhodecode.lib.utils import get_repo_slug

from rhodecode.model import meta

from rhodecode.model.scm import ScmModel

from rhodecode import BACKENDS

class BaseController(WSGIController):

    def __before__(self):

        c.rhodecode_version = __version__

        c.rhodecode_name = config.get('rhodecode_title')

        c.ga_code = config.get('rhodecode_ga_code')

        c.repo_name = get_repo_slug(request)

        c.backends = BACKENDS.keys()

        self.cut_off_limit = int(config.get('cut_off_limit'))

        self.sa = meta.Session()

        self.scm_model = ScmModel(self.sa)

        c.cached_repo_list = self.scm_model.get_repos()

        #c.unread_journal = scm_model.get_unread_journal()

    def __call__(self, environ, start_response):

        """Invoke the Controller"""

        # WSGIController.__call__ dispatches to the Controller method

        # the request is routed to. This routing information is

        # available in environ['pylons.routes_dict']

        try:

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

            return WSGIController.__call__(self, environ, start_response)

        finally:

            meta.Session.remove()

    c.rhodecode_repo: instance of scm repository (taken from cache)

    """

    def __before__(self):

        super(BaseRepoController, self).__before__()

        if c.repo_name:

            r, dbrepo = self.scm_model.get(c.repo_name, retval='repo')

            if r is not None:

                c.repository_forks = self.scm_model.get_forks(c.repo_name)

            else:

                c.repository_followers = 0

                c.repository_forks = 0

            # Since RhodeCode uses heavy memory caching we make a deepcopy

            # of object taken from cache. This way we lose reference to cached

            # very large number of changesets

            c.rhodecode_repo = copy.copy(r)

import logging

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

# Sequences

RESET_SEQ = "\033[0m"

COLOR_SEQ = "\033[1;%dm"

BOLD_SEQ = "\033[1m"

COLORS = {

}

def one_space_trim(s):

    if s.find("  ") == -1:

        return s

    else:

        s = s.replace('  ', ' ')

        return one_space_trim(s)

def format_sql(sql):

    sql = sql.replace('\n', '')

    sql = one_space_trim(sql)

    sql = sql\

        .replace(',', ',\n\t')\

        .replace('SELECT', '\n\tSELECT \n\t')\

        .replace('UPDATE', '\n\tUPDATE \n\t')\

        .replace('DELETE', '\n\tDELETE \n\t')\

        .replace('FROM', '\n\tFROM')\

        .replace('ORDER BY', '\n\tORDER BY')\

        .replace('LIMIT', '\n\tLIMIT')\

        .replace('WHERE', '\n\tWHERE')\

        .replace('AND', '\n\tAND')\

        .replace('LEFT', '\n\tLEFT')\

        .replace('INNER', '\n\tINNER')\

        .replace('INSERT', '\n\tINSERT')\

        .replace('DELETE', '\n\tDELETE')

    return sql

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

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

# 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 sys

import getpass

from mercurial.cmdutil import revrange

from mercurial.node import nullrev

from rhodecode.lib import helpers as h

from rhodecode.lib.utils import action_logger

def repo_size(ui, repo, hooktype=None, **kwargs):

    """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):

            for f in files:

                try:

                    size_root += os.path.getsize(os.path.join(path, f))

                except OSError:

                    pass

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

def log_pull_action(ui, repo, **kwargs):

    """Logs user last pull action

    :param ui:

    :param repo:

    """

    extra_params = dict(repo.ui.configitems('rhodecode_extras'))

    username = extra_params['username']

    repository = extra_params['repository']

    action = 'pull'

    action_logger(username, action, repository, extra_params['ip'])

    return 0

def log_push_action(ui, repo, **kwargs):

    """Maps user last push action to new changeset id, from mercurial

    :param ui:

    :param repo:

    """

    extra_params = dict(repo.ui.configitems('rhodecode_extras'))

    username = extra_params['username']

    repository = extra_params['repository']

    action = extra_params['action'] + ':%s'

    node = kwargs['node']

import sys

from warnings import warn

from multiprocessing.util import Finalize

from rhodecode import __platform__, PLATFORM_WIN

if __platform__ in PLATFORM_WIN:

    import ctypes

    def kill(pid):

        """kill function for Win32"""

        kernel32 = ctypes.windll.kernel32

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

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

else:

    kill = os.kill

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

        """

        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:

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

            # process PID

            if running_pid:

                try:

                    kill(running_pid, 0)

                except OSError, exc:

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

                        print "Removing lock file for the: %s" % running_pid

                        self.release()

                    else:

                        raise

                else:

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

                    print "It is running as process %s" % running_pid

                    raise LockHeld()

        except IOError, e:

            if e.errno != 2:

                raise

            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 __future__ import with_statement

import cProfile

import pstats

import cgi

import pprint

import threading

from StringIO import StringIO

class ProfilingMiddleware(object):

    def __init__(self, app):

        self.lock = threading.Lock()

        self.app = app

    def __call__(self, environ, start_response):

        with self.lock:

            profiler = cProfile.Profile()

            def run_app(*a, **kw):

                self.response = self.app(environ, start_response)

            profiler.runcall(run_app, environ, start_response)

            profiler.snapshot_stats()

            stats = pstats.Stats(profiler)

            stats.sort_stats('cumulative')

            # Redirect output

            out = StringIO()

            stats.stream = out

            stats.print_stats()

            resp = ''.join(self.response)

            # Lets at least only put this on html-like responses.

            if resp.strip().startswith('<'):

                ## The profiling info is just appended to the response.

                ##  Browsers don't mind this.