0.3.5 - Bugfixes

* push/pull/fetch operations will not block anymore

* A list of all fixed issues can be found here: https://github.com/gitpython-developers/GitPython/issues?q=milestone%3A%22v0.3.5+-+bugfixes%22+

import select

def handle_process_output(process, stdout_handler, stderr_handler, finalizer):

"""Registers for notifications to lean that process output is ready to read, and dispatches lines to

def read_line_fast(stream):

return stream.readline()

def read_line_slow(stream):

line = b''

while True:

char = stream.read(1) # reads individual single byte strings

if not char:

break

if char in (b'\r', b'\n') and line:

break

else:

line += char

# END process parsed line

# END while file is not done reading

return line

# end

fdmap = { process.stdout.fileno() : (process.stdout, stdout_handler, read_line_fast),

process.stderr.fileno() : (process.stderr, stderr_handler, read_line_slow) }

if hasattr(select, 'poll'):

def dispatch_line(fd):

stream, handler, readline = fdmap[fd]

# this can possibly block for a while, but since we wake-up with at least one or more lines to handle,

# we are good ...

line = readline(stream).decode(defenc)

if line and handler:

handler(line)

return line

# end dispatch helper

# poll is preferred, as select is limited to file handles up to 1024 ... . Not an issue for us though,

# as we deal with relatively blank processes

poll = select.poll()

READ_ONLY = select.POLLIN | select.POLLPRI | select.POLLHUP | select.POLLERR

CLOSED = select.POLLHUP | select.POLLERR

poll.register(process.stdout, READ_ONLY)

poll.register(process.stderr, READ_ONLY)

closed_streams = set()

while True:

# no timeout

poll_result = poll.poll()

for fd, result in poll_result:

if result & CLOSED:

closed_streams.add(fd)

else:

dispatch_line(fd)

# end handle closed stream

# end for each poll-result tuple

if len(closed_streams) == len(fdmap):

break

# end its all done

# end endless loop

# Depelete all remaining buffers

for fno, _ in fdmap.items():

while True:

line = dispatch_line(fno)

if not line:

break

# end deplete buffer

# end for each file handle

else:

# Oh ... probably we are on windows. select.select() can only handle sockets, we have files

# The only reliable way to do this now is to use threads and wait for both to finish

# Since the finalizer is expected to wait, we don't have to introduce our own wait primitive

raise NotImplementedError()

# end

return finalizer(process)

from git.cmd import handle_process_output

progress_handler = progress.new_message_handler()

def my_progress_handler(line):

for pline in progress_handler(line):

if line.startswith('fatal:'):

raise GitCommandError(("Error when fetching: %s" % line,), 2)

# END handle special messages

for cmd in cmds:

if line[1] == cmd:

fetch_info_lines.append(line)

continue

# end find command code

# end for each comand code we know

# end for each line progress didn't handle

# end

# We are only interested in stderr here ...

handle_process_output(proc, None, my_progress_handler, finalize_process)

progress_handler = progress.new_message_handler()

def stdout_handler(line):

handle_process_output(proc, stdout_handler, progress_handler, finalize_process)

from git.cmd import (

Git,

handle_process_output

)

handle_process_output(proc, None, progress.new_message_handler(), finalize_process)

else:

finalize_process(proc)

# end handle progress

def new_message_handler(self):

""":return: a progress handler suitable for handle_process_output(), passing lines on to this Progress

def handler(line):

return self._parse_progress_line(line.rstrip())

# end

return handler