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

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

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

# 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: [])

    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

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

            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

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

    """

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

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

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

        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'

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

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

        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)

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

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

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:

    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:

    """

    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:

    """

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:

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

    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)

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

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

            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.

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

                output = StringIO()

                pprint.pprint(environ, output, depth=3)

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

from email.mime.audio import MIMEAudio

from email.mime.base import MIMEBase

from email.mime.text import MIMEText

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

    :param attachment_files is a dict of {filename:location}

        it tries to guess the mimetype and attach the file

        #if server requires authorization you must provide login and password

        #but only if we have them

        if self.user and self.passwd:

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

        date_ = formatdate(localtime=True)

        msg = MIMEMultipart()

        msg['From'] = self.mail_from

        msg['To'] = ','.join(recipients)

        msg['Date'] = date_

        msg['Subject'] = subject

        try:

            smtp_serv.quit()

        except sslerror:

            # 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':

                    # Note: we should handle calculating the charset

                    file_part = MIMEText(self.get_content(msg_file),

                                         _subtype=subtype)

import time

import logging

log = logging.getLogger('timerproxy')

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

        super(TimerProxy, self).__init__()

    def cursor_execute(self, execute, cursor, statement, parameters,