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:

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

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

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>

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

            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)

    @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

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

    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.

    #        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

        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]

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