The ErrorDocuments middleware forwards to ErrorController when error

    related status codes are returned from the application.

    This behavior can be altered by changing the parameters to the

    ErrorDocuments middleware in your config/middleware.py file.

    """

    def __before__(self):

        #disable all base actions since we don't need them here

        pass

    def document(self):

        resp = request.environ.get('pylons.original_response')

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

        log.debug('### %s ###' % resp.status)

        e = request.environ

        c.serv_p = r'%(protocol)s://%(host)s/' \

                                    % {'protocol': e.get('wsgi.url_scheme'),

                                       'host': e.get('HTTP_HOST'), }

        c.error_message = cgi.escape(request.GET.get('code', str(resp.status)))

        c.error_explanation = self.get_error_explanation(resp.status_int)

        #  redirect to when error with given seconds

        c.redirect_time = 0

        c.redirect_module = _('Home page')

        c.url_redirect = "/"

        return render('/errors/error_document.html')

    def img(self, id):

        """Serve Pylons' stock images"""

        return self._serve_file(os.path.join(media_path, 'img', id))

    def style(self, id):

        """Serve Pylons' stock stylesheets"""

        return self._serve_file(os.path.join(media_path, 'style', id))

    def _serve_file(self, path):

        """Call Paste's FileApp (a WSGI application) to serve the file

        at the specified path

        """

        fapp = paste.fileapp.FileApp(path)

        return fapp(request.environ, self.start_response)

    def get_error_explanation(self, code):

        try:

            code = int(code)

        except Exception:

            code = 500

        if code == 400:

            return _('The request could not be understood by the server'

                     ' due to malformed syntax.')

        if code == 401:

            return _('Unauthorized access to resource')

        if code == 403:

            return _("You don't have permission to view this page")

        if code == 404:

            return _('The resource could not be found')

        if code == 500:

            return _('The server encountered an unexpected condition'

                     ' which prevented it from fulfilling the request.')

    def _getTableDefn(self, table, metaName='meta'):

        out = []

        tableName = table.name

        if self.declarative:

            out.append("class %(table)s(Base):" % {'table': tableName})

            out.append("    __tablename__ = '%(table)s'\n" %

                            {'table': tableName})

            for col in table.columns:

                out.append("    %s" % self.column_repr(col))

            out.append('\n')

        else:

            out.append("%(table)s = Table('%(table)s', %(meta)s," %

                       {'table': tableName, 'meta': metaName})

            for col in table.columns:

                out.append("    %s," % self.column_repr(col))

            out.append(")\n")

        return out

    def _get_tables(self,missingA=False,missingB=False,modified=False):

        to_process = []

        for bool_,names,metadata in (

            (missingA,self.diff.tables_missing_from_A,self.diff.metadataB),

            (missingB,self.diff.tables_missing_from_B,self.diff.metadataA),

            (modified,self.diff.tables_different,self.diff.metadataA),

                ):

            if bool_:

                for name in names:

                    yield metadata.tables.get(name)

    def genBDefinition(self):

        """Generates the source code for a definition of B.

        Assumes a diff where A is empty.

        Was: toPython. Assume database (B) is current and model (A) is empty.

        """

        out = []

        if self.declarative:

            out.append(DECLARATIVE_HEADER)

        else:

            out.append(HEADER)

        out.append("")

        for table in self._get_tables(missingA=True):

            out.extend(self._getTableDefn(table))

        return '\n'.join(out)

    def genB2AMigration(self, indent='    '):

        Was: toUpgradeDowngradePython

        Assume model (A) is most current and database (B) is out-of-date.

        decls = ['from migrate.changeset import schema',

                 'pre_meta = MetaData()',

                 'post_meta = MetaData()',

                ]

        upgradeCommands = ['pre_meta.bind = migrate_engine',

                           'post_meta.bind = migrate_engine']

        downgradeCommands = list(upgradeCommands)

        for tn in self.diff.tables_missing_from_A:

            pre_table = self.diff.metadataB.tables[tn]

            decls.extend(self._getTableDefn(pre_table, metaName='pre_meta'))

            upgradeCommands.append(

                "pre_meta.tables[%(table)r].drop()" % {'table': tn})

            downgradeCommands.append(

                "pre_meta.tables[%(table)r].create()" % {'table': tn})

        for tn in self.diff.tables_missing_from_B:

            post_table = self.diff.metadataA.tables[tn]

            decls.extend(self._getTableDefn(post_table, metaName='post_meta'))

            upgradeCommands.append(

                "post_meta.tables[%(table)r].create()" % {'table': tn})

            downgradeCommands.append(

                "post_meta.tables[%(table)r].drop()" % {'table': tn})

        for (tn, td) in self.diff.tables_different.iteritems():

            if td.columns_missing_from_A or td.columns_different:

                pre_table = self.diff.metadataB.tables[tn]

                decls.extend(self._getTableDefn(

                    pre_table, metaName='pre_meta'))

            if td.columns_missing_from_B or td.columns_different:

                post_table = self.diff.metadataA.tables[tn]

                decls.extend(self._getTableDefn(

                    post_table, metaName='post_meta'))

            for col in td.columns_missing_from_A:

                upgradeCommands.append(

                    'pre_meta.tables[%r].columns[%r].drop()' % (tn, col))

                downgradeCommands.append(

                    'pre_meta.tables[%r].columns[%r].create()' % (tn, col))

            for col in td.columns_missing_from_B:

                upgradeCommands.append(

                    'post_meta.tables[%r].columns[%r].create()' % (tn, col))

                downgradeCommands.append(

                    'post_meta.tables[%r].columns[%r].drop()' % (tn, col))

            for modelCol, databaseCol, modelDecl, databaseDecl in td.columns_different:

                upgradeCommands.append(

                    'assert False, "Can\'t alter columns: %s:%s=>%s"' % (

        A_table_names = set(metadataA.tables.keys())

        B_table_names = set(metadataB.tables.keys())

        self.tables_missing_from_A = sorted(

            B_table_names - A_table_names - excludeTables

            )

        self.tables_missing_from_B = sorted(

            A_table_names - B_table_names - excludeTables

            )

        self.tables_different = {}

        for table_name in A_table_names.intersection(B_table_names):

            td = TableDiff()

            A_table = metadataA.tables[table_name]

            B_table = metadataB.tables[table_name]

            A_column_names = set(A_table.columns.keys())

            B_column_names = set(B_table.columns.keys())

            td.columns_missing_from_A = sorted(

                B_column_names - A_column_names

                )

            td.columns_missing_from_B = sorted(

                A_column_names - B_column_names

                )

            td.columns_different = {}

            for col_name in A_column_names.intersection(B_column_names):

                cd = ColDiff(

                    A_table.columns.get(col_name),

                    B_table.columns.get(col_name)

                    )

                if cd:

                    td.columns_different[col_name]=cd

            # XXX - index and constraint differences should

            #       be checked for here

            if td:

                self.tables_different[table_name]=td

    def __str__(self):

        out = []

        column_template ='      %%%is: %%r' % self.label_width

        for names,label in (

            (self.tables_missing_from_A,self.labelA),

            (self.tables_missing_from_B,self.labelB),

            ):

            if names:

                out.append(

                    '  tables missing from %s: %s' % (

                        label,', '.join(sorted(names))

                        )

                    )

        for name,td in sorted(self.tables_different.items()):

            out.append(

               '  table with differences: %s' % name

               )

            for names,label in (

                (td.columns_missing_from_A,self.labelA),

                (td.columns_missing_from_B,self.labelB),

                ):

                if names:

                    out.append(

                        '    %s missing these columns: %s' % (

                            label,', '.join(sorted(names))

                            )

                        )

            for name,cd in td.columns_different.items():

                out.append('    column with differences: %s' % name)

                out.append(column_template % (self.labelA,cd.col_A))

                out.append(column_template % (self.labelB,cd.col_B))

        if out:

            out.insert(0, 'Schema diffs:')

            return '\n'.join(out)

        else:

            return 'No schema diffs'

    def __len__(self):

        """

        Used in bool evaluation, return of 0 means no diffs.

        """

        return (

            len(self.tables_missing_from_A) +

            len(self.tables_missing_from_B) +

            len(self.tables_different)

            )

Module provides a class allowing to wrap communication over subprocess.Popen

input, output, error streams into a meaningfull, non-blocking, concurrent

stream processor exposing the output data as an iterator fitting to be a

return value passed by a WSGI applicaiton to a WSGI server per PEP 3333.

Copyright (c) 2011  Daniel Dotsenko <dotsa@hotmail.com>

This file is part of git_http_backend.py Project.

git_http_backend.py Project is free software: you can redistribute it and/or

modify it under the terms of the GNU Lesser General Public License as

published by the Free Software Foundation, either version 2.1 of the License,

or (at your option) any later version.

git_http_backend.py Project 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 Lesser General Public License for more details.

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

along with git_http_backend.py Project.

If not, see <http://www.gnu.org/licenses/>.

import os

import subprocess

from rhodecode.lib.vcs.utils.compat import deque, Event, Thread, _bytes, _bytearray

class StreamFeeder(Thread):

    """

    Normal writing into pipe-like is blocking once the buffer is filled.

    This thread allows a thread to seep data from a file-like into a pipe

    without blocking the main thread.

    We close inpipe once the end of the source stream is reached.

    """

    def __init__(self, source):

        super(StreamFeeder, self).__init__()

        self.daemon = True

        filelike = False

        self.bytes = _bytes()

        if type(source) in (type(''), _bytes, _bytearray):  # string-like

            self.bytes = _bytes(source)

        else:  # can be either file pointer or file-like

            if type(source) in (int, long):  # file pointer it is

                ## converting file descriptor (int) stdin into file-like

                try:

                    source = os.fdopen(source, 'rb', 16384)

                except Exception:

                    pass

            # let's see if source is file-like by now

            try:

                filelike = source.read

            except Exception:

                pass

        if not filelike and not self.bytes:

            raise TypeError("StreamFeeder's source object must be a readable "

                            "file-like, a file descriptor, or a string-like.")

        self.source = source

        self.readiface, self.writeiface = os.pipe()

    def run(self):

        t = self.writeiface

        if self.bytes:

            os.write(t, self.bytes)

        else:

            s = self.source

            b = s.read(4096)

            while b:

                os.write(t, b)

                b = s.read(4096)

        os.close(t)

        self.EOF.clear()

        self.go = Event()

        self.go.set()

    def stop(self):

        self.go.clear()

        self.EOF.set()

        try:

            # this is not proper, but is done to force the reader thread let

            # go of the input because, if successful, .close() will send EOF

            # down the pipe.

            self.source.close()

        except:

            pass

    def run(self):

        s = self.source

        t = self.target

        cs = self.chunk_size

        ccm = self.chunk_count_max

        kr = self.keep_reading

        da = self.data_added

        go = self.go

        try:

            b = s.read(cs)

        except ValueError:

            b = ''

        while b and go.is_set():

            if len(t) > ccm:

                kr.clear()

                kr.wait(2)

#                # this only works on 2.7.x and up

#                if not kr.wait(10):

#                    raise Exception("Timed out while waiting for input to be read.")

                # instead we'll use this

                if len(t) > ccm + 3:

                    raise IOError("Timed out while waiting for input from subprocess.")

            t.append(b)

            da.set()

            b = s.read(cs)

        self.EOF.set()

        da.set()  # for cases when done but there was no input.

class BufferedGenerator():

    Class behaves as a non-blocking, buffered pipe reader.

    Reads chunks of data (through a thread)

    from a blocking pipe, and attaches these to an array (Deque) of chunks.

    Reading is halted in the thread when max chunks is internally buffered.

    The .next() may operate in blocking or non-blocking fashion by yielding

    '' if no data is ready

    to be sent or by not returning until there is some data to send

    When we get EOF from underlying source pipe we raise the marker to raise

    StopIteration after the last chunk of data is yielded.

    def __init__(self, source, buffer_size=65536, chunk_size=4096,

                 starting_values=[], bottomless=False):

        if bottomless:

            maxlen = int(buffer_size / chunk_size)

        else:

            maxlen = None

        self.data = deque(starting_values, maxlen)

        self.worker = InputStreamChunker(source, self.data, buffer_size,

                                         chunk_size)

        if starting_values:

            self.worker.data_added.set()

        self.worker.start()

    ####################

    # Generator's methods

    ####################

    def __iter__(self):

        return self

    def next(self):

        while not len(self.data) and not self.worker.EOF.is_set():

            self.worker.data_added.clear()

            self.worker.data_added.wait(0.2)

        if len(self.data):

            self.worker.keep_reading.set()

            return _bytes(self.data.popleft())

        elif self.worker.EOF.is_set():

            raise StopIteration

    def throw(self, type, value=None, traceback=None):

        if not self.worker.EOF.is_set():

            raise type(value)

    def start(self):

        self.worker.start()

    def stop(self):

        self.worker.stop()

    def close(self):

        try:

            self.worker.stop()

            self.throw(GeneratorExit)

        except (GeneratorExit, StopIteration):

            pass

    def __del__(self):

        self.close()

    ####################

    # Threaded reader's infrastructure.

    ####################

    @property

    def input(self):

        return self.worker.w

    @property

    def data_added_event(self):

        return self.worker.data_added

    @property

    def data_added(self):

        return self.worker.data_added.is_set()

    @property

    def reading_paused(self):

        return not self.worker.keep_reading.is_set()

    @property

    def done_reading_event(self):

        Done_reding does not mean that the iterator's buffer is empty.

        Iterator might have done reading from underlying source, but the read

        chunks might still be available for serving through .next() method.

        @return An Event class instance.

        return self.worker.EOF

    @property

    def done_reading(self):

        Done_reding does not mean that the iterator's buffer is empty.

        Iterator might have done reading from underlying source, but the read

        chunks might still be available for serving through .next() method.

        @return An Bool value.

        return self.worker.EOF.is_set()

    @property

    def length(self):

        returns int.

        This is the lenght of the que of chunks, not the length of

        the combined contents in those chunks.

        __len__() cannot be meaningfully implemented because this

        reader is just flying throuh a bottomless pit content and

        can only know the lenght of what it already saw.

        If __len__() on WSGI server per PEP 3333 returns a value,

        the responce's length will be set to that. In order not to

        confuse WSGI PEP3333 servers, we will not implement __len__

        at all.

        return len(self.data)

    def prepend(self, x):

        self.data.appendleft(x)

    def append(self, x):

        self.data.append(x)

    def extend(self, o):

        self.data.extend(o)

    def __getitem__(self, i):

        return self.data[i]

class SubprocessIOChunker(object):

    Processor class wrapping handling of subprocess IO.

    In a way, this is a "communicate()" replacement with a twist.

    - We are multithreaded. Writing in and reading out, err are all sep threads.

    - We support concurrent (in and out) stream processing.

    - The output is not a stream. It's a queue of read string (bytes, not unicode)

      chunks. The object behaves as an iterable. You can "for chunk in obj:" us.

    - We are non-blocking in more respects than communicate()

      (reading from subprocess out pauses when internal buffer is full, but

       does not block the parent calling code. On the flip side, reading from

       slow-yielding subprocess may block the iteration until data shows up. This

       does not block the parallel inpipe reading occurring parallel thread.)

    The purpose of the object is to allow us to wrap subprocess interactions into

    and interable that can be passed to a WSGI server as the application's return

    value. Because of stream-processing-ability, WSGI does not have to read ALL

    of the subprocess's output and buffer it, before handing it to WSGI server for

    HTTP response. Instead, the class initializer reads just a bit of the stream

    to figure out if error ocurred or likely to occur and if not, just hands the

    further iteration over subprocess output to the server for completion of HTTP

    response.

    The real or perceived subprocess error is trapped and raised as one of

    EnvironmentError family of exceptions

    Example usage:

    #    try:

    #        answer = SubprocessIOChunker(

    #            cmd,

    #            input,

    #            buffer_size = 65536,

    #            chunk_size = 4096

    #            )

    #    except (EnvironmentError) as e:

    #        print str(e)

    #        raise e

    #

    #    return answer

    def __init__(self, cmd, inputstream=None, buffer_size=65536,

                 chunk_size=4096, starting_values=[], **kwargs):

        Initializes SubprocessIOChunker

        :param cmd: A Subprocess.Popen style "cmd". Can be string or array of strings

        :param inputstream: (Default: None) A file-like, string, or file pointer.

        :param buffer_size: (Default: 65536) A size of total buffer per stream in bytes.

        :param chunk_size: (Default: 4096) A max size of a chunk. Actual chunk may be smaller.

        :param starting_values: (Default: []) An array of strings to put in front of output que.

        if inputstream:

            input_streamer = StreamFeeder(inputstream)

            input_streamer.start()

            inputstream = input_streamer.output

        _shell = kwargs.get('shell', True)

        if isinstance(cmd, (list, tuple)):

            cmd = ' '.join(cmd)

        kwargs['shell'] = _shell

        _p = subprocess.Popen(cmd,

            bufsize=-1,

            stdin=inputstream,

            stdout=subprocess.PIPE,

            stderr=subprocess.PIPE,

            **kwargs

        )

        bg_out = BufferedGenerator(_p.stdout, buffer_size, chunk_size, starting_values)

        bg_err = BufferedGenerator(_p.stderr, 16000, 1, bottomless=True)

        while not bg_out.done_reading and not bg_out.reading_paused and not bg_err.length:

            # doing this until we reach either end of file, or end of buffer.

            bg_out.data_added_event.wait(1)

            bg_out.data_added_event.clear()

        # at this point it's still ambiguous if we are done reading or just full buffer.

        # Either way, if error (returned by ended process, or implied based on

        # presence of stuff in stderr output) we error out.

        # Else, we are happy.

        _returncode = _p.poll()

        if _returncode or (_returncode == None and bg_err.length):

            try:

                _p.terminate()

            except:

                pass

            bg_out.stop()

            bg_err.stop()

            err = '%s' % ''.join(bg_err)

            if err:

                raise EnvironmentError("Subprocess exited due to an error:\n" + err)

            raise EnvironmentError("Subprocess exited with non 0 ret code:%s" % _returncode)

        self.process = _p

        self.output = bg_out

        self.error = bg_err

    def test_root_node(self):

        tip = self.repo.get_changeset()

        self.assertTrue(tip.root is tip.get_node(''))

    def test_lazy_fetch(self):

        """

        Test if changeset's nodes expands and are cached as we walk through

        the revision. This test is somewhat hard to write as order of tests

        is a key here. Written by running command after command in a shell.

        """

        hex = '2a13f185e4525f9d4b59882791a2d397b90d5ddc'

        self.assertTrue(hex in self.repo.revisions)

        chset = self.repo.get_changeset(hex)

        self.assertTrue(len(chset.nodes) == 0)

        root = chset.root

        self.assertTrue(len(chset.nodes) == 1)

        self.assertTrue(len(root.nodes) == 8)

        # accessing root.nodes updates chset.nodes

        self.assertTrue(len(chset.nodes) == 9)

        docs = root.get_node('docs')

        # we haven't yet accessed anything new as docs dir was already cached

        self.assertTrue(len(chset.nodes) == 9)

        self.assertTrue(len(docs.nodes) == 8)

        # accessing docs.nodes updates chset.nodes

        self.assertTrue(len(chset.nodes) == 17)

        self.assertTrue(docs is chset.get_node('docs'))

        self.assertTrue(docs is root.nodes[0])

        self.assertTrue(docs is root.dirs[0])

        self.assertTrue(docs is chset.get_node('docs'))

    def test_nodes_with_changeset(self):

        hex = '2a13f185e4525f9d4b59882791a2d397b90d5ddc'

        chset = self.repo.get_changeset(hex)

        root = chset.root

        docs = root.get_node('docs')

        self.assertTrue(docs is chset.get_node('docs'))

        api = docs.get_node('api')

        self.assertTrue(api is chset.get_node('docs/api'))

        index = api.get_node('index.rst')

        self.assertTrue(index is chset.get_node('docs/api/index.rst'))

        self.assertTrue(index is chset.get_node('docs')\

            .get_node('api')\

            .get_node('index.rst'))

    def test_branch_and_tags(self):

        rev0 = self.repo.revisions[0]

        chset0 = self.repo.get_changeset(rev0)

        self.assertEqual(chset0.branch, 'master')

        self.assertEqual(chset0.tags, [])

        rev10 = self.repo.revisions[10]

        chset10 = self.repo.get_changeset(rev10)

        self.assertEqual(chset10.branch, 'master')

        self.assertEqual(chset10.tags, [])

        rev44 = self.repo.revisions[44]

        chset44 = self.repo.get_changeset(rev44)

        self.assertEqual(chset44.branch, 'web-branch')

        tip = self.repo.get_changeset('tip')

        self.assertTrue('tip' in tip.tags)

        # Those tests would fail - branches are now going

        # to be changed at main API in order to support git backend

        pass

    def _test_slices(self, limit, offset):

        count = self.repo.count()

        changesets = self.repo.get_changesets(limit=limit, offset=offset)

        idx = 0

        for changeset in changesets:

            rev = offset + idx

            idx += 1

            rev_id = self.repo.revisions[rev]

            if idx > limit:

                self.fail("Exceeded limit already (getting revision %s, "

                    "there are %s total revisions, offset=%s, limit=%s)"

                    % (rev_id, count, offset, limit))

            self.assertEqual(changeset, self.repo.get_changeset(rev_id))

        result = list(self.repo.get_changesets(limit=limit, offset=offset))

        start = offset

        end = limit and offset + limit or None

        sliced = list(self.repo[start:end])

        self.failUnlessEqual(result, sliced,

            msg="Comparison failed for limit=%s, offset=%s"

            "(get_changeset returned: %s and sliced: %s"

            % (limit, offset, result, sliced))

    def _test_file_size(self, revision, path, size):

        node = self.repo.get_changeset(revision).get_node(path)

        self.assertTrue(node.is_file())

        self.assertEqual(node.size, size)

    def test_file_size(self):

        to_check = (

            ('c1214f7e79e02fc37156ff215cd71275450cffc3',

                'vcs/backends/BaseRepository.py', 502),

            ('d7e0d30fbcae12c90680eb095a4f5f02505ce501',

                'vcs/backends/hg.py', 854),

            ('6e125e7c890379446e98980d8ed60fba87d0f6d1',

                'setup.py', 1068),

            ('d955cd312c17b02143c04fa1099a352b04368118',

                'vcs/backends/base.py', 2921),

            ('ca1eb7957a54bce53b12d1a51b13452f95bc7c7e',

                'vcs/backends/base.py', 3936),

            ('f50f42baeed5af6518ef4b0cb2f1423f3851a941',

                'vcs/backends/base.py', 6189),

        )

        for revision, path, size in to_check: