except formencode.Invalid, errors:

            e = errors.error_dict or {}

            return htmlfill.render(

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

                defaults=errors.value,

                                    revision='tip'))

            try:

                content = content.encode('utf8')

                message = message.encode('utf8')

                path = f_path.encode('utf8')

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

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

def __get_lem():

    from pygments import lexers

    from string import lower

# 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

    _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

def detect_mode(line, default):

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

        return 2

    elif line.endswith('\n'):

    else:

        return default

def generate_api_key(username, salt=None):

    """

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

    """

    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)

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

                                                                password)

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

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

                user_attrs = {

# 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

# 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

        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)

        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,

        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'

from rhodecode.model.scm import ScmModel

from rhodecode import BACKENDS

class BaseController(WSGIController):

    def __before__(self):

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

            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

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

BOLD_SEQ = "\033[1m"

COLORS = {

}

def one_space_trim(s):

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

        return s

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

        return one_space_trim(s)

def format_sql(sql):

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

    sql = one_space_trim(sql)

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

    return sql

class ColorFormatter(logging.Formatter):

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

# 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

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

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

    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

    return 0

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

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

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

else:

    kill = os.kill

class DaemonLock(object):

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

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

        self.callbackfn = callbackfn

        self.desc = desc

        self.debug = debug

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

            lock.release()

    def lock(self):

        """

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

        if self.debug:

            pidfile.close()

            if self.debug:

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

            # process PID

            if running_pid:

                    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:

    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

        """

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)

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

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

                ##  Browsers don't mind this.

                resp += cgi.escape(out.getvalue(), True)

                output = StringIO()

from email.utils import formatdate

from email import encoders

class SmtpMailer(object):

    """SMTP mailer class

    mailer.send(recipients, subject, body, attachment_files)

    :param recipients might be a list of string or single string

        if self.user and self.passwd:

            smtp_serv.login(self.user, self.passwd)

        date_ = formatdate(localtime=True)

        msg = MIMEMultipart()

        msg['From'] = self.mail_from

            # sslerror is raised in tls connections on closing sometimes

            pass

    def __atach_files(self, msg, attachment_files):

        if isinstance(attachment_files, dict):

            for f_name, msg_file in attachment_files.items():

                ctype, encoding = mimetypes.guess_type(f_name)

                if ctype is None or encoding is not None:

                    ctype = 'application/octet-stream'

                maintype, subtype = ctype.split('/', 1)

                if maintype == 'text':

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'

    return COLOR_SEQ % COLOR_SQL + sql + normal

class TimerProxy(ConnectionProxy):

    def __init__(self):