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

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

"""

kallithea.lib.celerylib

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

celery libs for Kallithea

This file was forked by the Kallithea project in July 2014.

Original author and date, and relevant copyright and licensing information is below:

:created_on: Nov 27, 2010

:author: marcink

:copyright: (c) 2013 RhodeCode GmbH, and others.

:license: GPLv3, see LICENSE.md for more details.

"""

import logging

import os

from decorator import decorator

from tg import config

import kallithea

from kallithea.lib.pidlock import DaemonLock, LockHeld

from kallithea.lib.utils2 import safe_bytes

from kallithea.model import meta

log = logging.getLogger(__name__)

class FakeTask(object):

    """Fake a sync result to make it look like a finished task"""

    def __init__(self, result):

        self.result = result

    def failed(self):

        return False

    traceback = None # if failed

    task_id = None

def task(f_org):

    """Wrapper of celery.task.task, running async if CELERY_APP

    """

    if kallithea.CELERY_APP:

        def f_async(*args, **kwargs):

            log.info('executing %s task', f_org.__name__)

            try:

                f_org(*args, **kwargs)

            finally:

                log.info('executed %s task', f_org.__name__)

        f_async.__name__ = f_org.__name__

        runner = kallithea.CELERY_APP.task(ignore_result=True)(f_async)

        def f_wrapped(*args, **kwargs):

            t = runner.apply_async(args=args, kwargs=kwargs)

            log.info('executing task %s in async mode - id %s', f_org, t.task_id)

            return t

    else:

        def f_wrapped(*args, **kwargs):

            log.info('executing task %s in sync', f_org.__name__)

            try:

                result = f_org(*args, **kwargs)

            except Exception as e:

                log.error('exception executing sync task %s in sync: %r', f_org.__name__, e)

                raise # TODO: return this in FakeTask as with async tasks?

            return FakeTask(result)

    return f_wrapped

def __get_lockkey(func, *fargs, **fkwargs):

    params = list(fargs)

    params.extend(['%s-%s' % ar for ar in fkwargs.items()])

    func_name = str(func.__name__) if hasattr(func, '__name__') else str(func)

    lockkey = 'task_%s.lock' % \

    return lockkey

def locked_task(func):

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

        lockkey = __get_lockkey(func, *fargs, **fkwargs)

        lockkey_path = config.get('cache_dir') or config['app_conf']['cache_dir']  # Backward compatibility for TurboGears < 2.4

        log.info('running task with lockkey %s', lockkey)

        try:

            l = DaemonLock(os.path.join(lockkey_path, lockkey))

            ret = func(*fargs, **fkwargs)

            l.release()

            return ret

        except LockHeld:

            log.info('LockHeld')

            return 'Task with key %s already running' % lockkey

    return decorator(__wrapper, func)

def get_session():

    sa = meta.Session()

    return sa

def dbsession(func):

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

        try:

            ret = func(*fargs, **fkwargs)

            return ret

        finally:

            if kallithea.CELERY_APP and not kallithea.CELERY_EAGER:

                meta.Session.remove()

    return decorator(__wrapper, func)

import logging

import re

import traceback

import bleach

import markdown as markdown_mod

from kallithea.lib.utils2 import MENTIONS_REGEX, safe_str

log = logging.getLogger(__name__)

url_re = re.compile(r'''\bhttps?://(?:[\da-zA-Z0-9@:.-]+)'''

                    r'''(?:[/a-zA-Z0-9_=@#~&+%.,:;?!*()-]*[/a-zA-Z0-9_=@#~])?''')

class MarkupRenderer(object):

    RESTRUCTUREDTEXT_DISALLOWED_DIRECTIVES = ['include', 'meta', 'raw']

    MARKDOWN_PAT = re.compile(r'md|mkdn?|mdown|markdown', re.IGNORECASE)

    RST_PAT = re.compile(r're?st', re.IGNORECASE)

    PLAIN_PAT = re.compile(r'readme', re.IGNORECASE)

    @classmethod

    def _detect_renderer(cls, source, filename):

        """

        runs detection of what renderer should be used for generating html

        from a markup language

        filename can be also explicitly a renderer name

        """

        if cls.MARKDOWN_PAT.findall(filename):

            return cls.markdown

        elif cls.RST_PAT.findall(filename):

            return cls.rst

        elif cls.PLAIN_PAT.findall(filename):

            return cls.rst

        return cls.plain

    @classmethod

    def _flavored_markdown(cls, text):

        """

        Github style flavored markdown

        :param text:

        """

        # Extract pre blocks.

        extractions = {}

        def pre_extraction_callback(matchobj):

            extractions[digest] = matchobj.group(0)

            return "{gfm-extraction-%s}" % digest

        pattern = re.compile(r'<pre>.*?</pre>', re.MULTILINE | re.DOTALL)

        text = re.sub(pattern, pre_extraction_callback, text)

        # Prevent foo_bar_baz from ending up with an italic word in the middle.

        def italic_callback(matchobj):

            s = matchobj.group(0)

            if list(s).count('_') >= 2:

                return s.replace('_', r'\_')

            return s

        text = re.sub(r'^(?! {4}|\t)\w+_\w+_\w[\w_]*', italic_callback, text)

        # In very clear cases, let newlines become <br /> tags.

        def newline_callback(matchobj):

            if len(matchobj.group(1)) == 1:

                return matchobj.group(0).rstrip() + '  \n'

            else:

                return matchobj.group(0)

        pattern = re.compile(r'^[\w\<][^\n]*(\n+)', re.MULTILINE)

        text = re.sub(pattern, newline_callback, text)

        # Insert pre block extractions.

        def pre_insert_callback(matchobj):

            return '\n\n' + extractions[matchobj.group(1)]

        text = re.sub(r'{gfm-extraction-([0-9a-f]{32})\}',

                      pre_insert_callback, text)

        return text

    @classmethod

    def render(cls, source, filename=None):

        """

        Renders a given filename using detected renderer

        it detects renderers based on file extension or mimetype.

        At last it will just do a simple html replacing new lines with <br/>

        >>> MarkupRenderer.render('''<img id="a" style="margin-top:-1000px;color:red" src="http://example.com/test.jpg">''', '.md')

        '<p><img id="a" src="http://example.com/test.jpg" style="color: red;"></p>'

        >>> MarkupRenderer.render('''<img class="c d" src="file://localhost/test.jpg">''', 'b.mkd')

        '<p><img class="c d"></p>'

        >>> MarkupRenderer.render('''<a href="foo">foo</a>''', 'c.mkdn')

        '<p><a href="foo">foo</a></p>'

        >>> MarkupRenderer.render('''<script>alert(1)</script>''', 'd.mdown')

        '<script>alert(1)</script>'

        >>> MarkupRenderer.render('''<div onclick="alert(2)">yo</div>''', 'markdown')

        '<div>yo</div>'

        >>> MarkupRenderer.render('''<a href="javascript:alert(3)">yo</a>''', 'md')