Fix numerous style issues.

This largely fixes whitespace and imports, with a few typo fixes as
well. I only touched code that was previously touched by me, except in
the case of imports, where blame data is less useful.

Change-Id: Ie34063eb5abb3283a5b9b80fc902efca39159a97

Add __setitem__ to DictRefsContainer.

BaseRefsContainer assumes __setitem__, but it is not defined in the base
class. This was not a problem previously because DictRefsContainer was
not widely used, but that will change.

Change-Id: Ica0786e63ed2ef301c63671a5f3637048c0338f9

Add make_object and make_commit convenience functions to test utils.

These functions reduce typing needed to create objects for testing.
Instead of
    test_object = Object()
    test_object.attr1 = foo
    test_object.attr2 = bar
we can now write
    test_object = make_object(Object, attr1=foo, attr2=bar)

This is even more simplified for Commit objects, which have many
attributes, most of which we usually don't care about. Using make_commit
pre-populates attributes with some arbitrary default values, ensuring
commit objects can be serialized.

Updated relevant test code to use the new methods.

Change-Id: Id8266774efb56ef92a3db6cca42d3ec9d81fd2a0

Allow non-os file-like objects passed to ShaFile.from_file.

Distinguish between ShaFile.from_file and ShaFile.from_path.

Pass external object resolve function rather than full object store to ThinPackData constructor.

Merge Dave, highlights:

* fix thin pack handling
* more object checking
* test cleanups
* code cleanups

Merge use of constants for OFS/REF delta's.

Merge fix to write info/exclude rather than info/excludes file.

Fixed filename of initial .git/info/exclude

Do simple pack checking during receive-pack.

Call obj.check() for each object in a pack. This requires passing the
Pack object back from the various commit callbacks.

In the future, we might consider not even moving the pack in until after
has been checked. At the moment, however, the only way to complete a
thin pack is to move it in, so we must do that first. This results in a
garbage pack if the check fails, which would have to be cleaned up by
an eventual GC. However, since only corrupt objects (not packs) can be
written to disk, with the SHA of their corrupt contents, the chances of
actually hitting a corrupt object in practice are very small.

Change-Id: Ib6c6ae2846f77f6a6cd4849b9608c29886258673

Clean up index tests.

-Fix trailing whitespace.
-Fix SimpleIndexTestCase capitalization.
-Fix long line.
-Write files into temp dir instead of working directory.

This is the last of the tests that wrote into the working directory.

Change-Id: If8c194f645c93a68ff8493371ea712d7ca2da6dd

Clean up pack tests.

-Remove trailing whitespace.
-Fix long lines.
-Hard-code SHAs in their hexlified forms.
-Use '' consistently.
-Always write to temp directories instead of working directory.
-Various indentation and local var refactoring fixes.
-Moved TestHexToSha to test_objects.py, since those functions are from
 objects.py.
-While we're in there, also removed trailing whitespace in pack.py.

Change-Id: I19f133e3d867f31fa75e28142593f84807fbc746

Clean up object store tests.

-Moved SpecificDiskObjectStoreTests into DiskObjectStoreTests.
-Use pythonic syntax instead of calling __methods__ directory.
-Whitespace cleanup.

Change-Id: I484954ec00e7319c42fdd2d5762af0b38a45b6c3

Change check() methods in pack.py to raise rather than return bools.

This makes Pack, PackIndex, and PackData consistent with the rest of
the check() methods recently added. Raising rather than returning makes
factoring out methods easier and exposes more information about the kind
of error that occurred. Moreover, in many cases, the correct default
behavior is probably to die anyway.

Change-Id: I87ab2b1e165c3c9e55727b25a49b1754c0ac4534

Hash packed objects without creating ShaFiles.

Recent changes to ShaFile result in parsing files when created from
strings. Since the packed object code was just using ShaFile for
computing a SHA, this change elminates that and hashes file contents
directly.

Change-Id: I70a14104fa896c248189f0839c24d02c48a43c4d

Simplify and fix thin pack resolving.

This change cuts down on passing around callbacks to resolve external
references by creating a ThinPackData class that has different semantics
for resolving ref deltas. In all cases except thin packs, PackData
objects have associated pack objects (added as a member variable in
this change), so we can use the index to resolve ref deltas if they
exist. ThinPackDatas, on the other hand, are constructed with an
ObjectStore that is used for external ref resolving. Since we now
make use of the pack index, we only have to deal with postponing shas
in ThinPackData.iterentries. Since this is the only method used for
constructing an index, we still have to be able to handle ref deltas to
objects later in the file.

Modified the compat tests (and one small error in server.py) to
successfully exercise this code, but still missing unit tests.

Change-Id: I244b92c00cbae8e30883c5de4dbf47a9195bd174

Replace ref delta/ofs delta magic numbers with constants.

Change-Id: I49dc3fd7897b2748e4b355ee4ae1345a87431733

Add PackStreamReader.{offset,__len__}, extract PackObjectIterator.

Move PackStreamReader to dulwich.pack.

Split generic pack reading code out of PackStreamVerifier.

Fix ordering of imports.

Remove unused imports.

Attempt to close index files properly.

Merge various pack improvements from Dave.

Clean up pack.py.

-Removed trailing whitespace.
-Fixed long lines.
-Various docstring cleanup.

Change-Id: I2ccde03bc56d0f69ba2e3be7e11b3effce2d30ed

Make the server decode a pack as it streams.

This, in combination with using recv() instead of read(), makes it so we
never do blocking reads past the end of the pack stream, even when the
client doesn't close the connection.

This is done via a PackStreamVerifier class that reads from a Protocol,
unpacks and counts objects, writes through to a file, and computes the
SHA-1 checksum on the fly. It is necessary because the only way we know
when the pack is supposed to end is by parsing the header and reading
the correct number of objects; otherwise, any further reads from the
client would hang.

Changed the Handler constructors to take a Protocol instead of taking
read and write callbacks separately. Modified some interfaces to utility
functions in pack.py so they can be used by the server-side code.

Change-Id: Id4d11e34658d1f00ad06e45330d0d128b367d8e5

Fix read_zlib_chunks to avoid appending junk data.

Adding junk data to the end of data fed to the zlib.decompressobj
creates the potential for zlib errors if a read doesn't fill the entire
buffer. This implementation is cleaner, and only requires the assumption
that there is some data in the read source after the zlib stream. Since
compressed streams in packfiles are always followed by either a new
packed object or the SHA-1 trailer, this assumption should be safe.

Added more robust tests for zlib reading with various buffer sizes.

Change-Id: I813d30997edf3e0c924eceac05675e0eb121b96c

Add ReceivableProtocol that supports recv() as well as read().

There are two different ways of dealing with reads beyond the end of a
TCP stream buffer. The usual rfile.read method blocks until exactly the
number of bytes (or EOF) are read. This causes deadlocks when we try to
do buffered reads from the stream. When reading a packfile. the cgit
client leaves the connection open, so EOF is never read.

The other method is to use the socket.recv method, which blocks until
at least one byte is read, then returns whatever is available (up to
bufsize).

ReceivableProtocol supports both ways of dealing with reads past the
end of a stream, which should be used in different contexts. Note that
currently the ReceivePackHandler code still deadlocks, since it doesn't
know when to stop calling recv.

Change-Id: I77bfea72bb09326d9946f64426637296d0389714

Strip excess whitespace from capabilities lines.

C git separates client capabilities during send-pack with both \0 and a
space, so we need to handle that as well. This change is significantly
more lenient, but the cgit behavior is not well-documented, so there may
be more corner cases. It's hard to imagine that the extra strip() will
actually result in capabilities lists being parsed incorrectly.

Change-Id: I74b734e146add683b4c1e4ea6b575f458ec25de7

Prevent server stack trace when the client request is a no-op.

The exception was not killing the server, just the connection, and was
technically correct since the server is supposed to close the connection
anyway when the client sends no wants. As a result, the compat tests
weren't failing.

A better long-term solution would be to modify the server used during
testing to stop serving if one request generates an exception.

Change-Id: I065463803f38175a50f364b11588929094a28aab

fix bug #557585 GitFile breaks dulwich on Windows
fix is to add os.O_BINARY flag as os.open doesn't open files as binary
on this platform by default

Cope with diffstat not being present in test_patch.

Add basic test for write_commit_patch.

Fix fastexport commit exporter, add test.

Add some basic tests for fastexport.

Correctly avoid parsing ShaFiles with fixed SHAs when calling sha().

This required some reworking of the _needs_* and _sha ivars. Improved
check() to force computing the SHA and verifying that it matches the
previously-set value. Added a test for this check.

Change-Id: I6782693d7d7708bc7c28f357c27419d51409b884

Initial work on a fastexport module.

Avoid double close when file has already gone away in abort().

Skip test_dest_opened on non-Windows platforms.

fix bug #557585 GitFile breaks dulwich on Windows
fix non-atomic os.rename() behavior on Windows that fails if target exists
added file.fancy_rename() that preserves source file is case rename fails

Avoid mixing iterators/readline.

add git_am_patch_split.

fix bug #557585 GitFile breaks dulwich on Windows
fix is to add os.O_BINARY flag as os.open doesn't open files as binary
on this platform by default

Cope with diffstat not being present in test_patch.

Add basic test for write_commit_patch.

merge support for generating fastexport streams.

Fix fastexport commit exporter, add test.

Add some basic tests for fastexport.

Merge trunk.

Correctly avoid parsing ShaFiles with fixed SHAs when calling sha().

This required some reworking of the _needs_* and _sha ivars. Improved
check() to force computing the SHA and verifying that it matches the
previously-set value. Added a test for this check.

Change-Id: I6782693d7d7708bc7c28f357c27419d51409b884

Fix Blob._deserialize.

Make ShaFiles created from files trust their filenames.

This adds a dummy FixedSha class that implements the read-only part
of hashlib's hash interface but does not actually compute a SHA-1
digest. This allows us to assign ids to file objects based on their
filename rather than requiring a read of the whole file; SHA-1s will
soon be checked during check().

Added a filename_to_sha helper function to objects.py; refactored the
opposite sha_to_filename functionality into this file as well for
parallelism and testing. As a side effect, reorganized some files in
tests/data to have the normal 2/38 filename structure.

Change-Id: Ic459628aec32a92e29ea49cfd6cbe685053971ef

Lazily read the contents of ShaFiles from disk.

Previously, ShaFile.from_file read and inflated the entire contents of a
ShaFile, storing the inflated text in memory. Parsing that text was done
lazily, but this resulted in a confusing performance profile, since the
"lazy" part was in fact faster (memory/CPU-bound) than the eager part
(I/O-bound).

This change ensures that a file is only read fully from disk right
before it is about to be parsed. The first few bytes are still read
from disk to get the file type, but there is no need to slurp the
whole file. Moreover, we now maintain a distinction between ShaFiles
that are initialized from (possibly raw) strings and files initialized
with filenames. In order to parse the contents of a file, we need to
have one or the other. There is a third category of ShaFiles that
should never be parsed, where all the properties are intended to be set
explicitly (usually (but not always) during testing). These objects are
created as usual via __init__.

The tests all pass, but we do not currently have a way of testing the
point at which the implementation reads the whole file from disk.

Also, note that a call to foo.id still results in reading the whole file
and calculating its SHA-1; this behavior may change in the future.

Change-Id: Ib9f67ead0d2a812a2e43cffa54c37a1c4a219841

Check tag and commit objects for duplicate and out-of-order headers.

This requires factoring out the commit/tag parsing code so it can be
used directly from both the _parse_text and check methods. The parse
methods yield tuples, which can either be used to set members or
check for ordering.

Change-Id: I5ffe47100273912eaa283d03332286287b109a13

Add TESTFLAGS variable to Makefile to make running nosetests easier.

Change-Id: I7d94577883ad0805281bcac0003df964bfd05cdc

Add launchpad link.

Fix whitespace bug in dul-web.

Had a tab that was syntactically correct, but since python treats tabs
as 8 spaces rather than 4 it resulted in incorrect behavior.

Merge pack protocol receiver fix.

Add DiskObjectStore.init.

test_object_store: use temp dirs instead of 'foo'

client: don't assume server response is of length 20

We do not for sure the length; it is safer to use
Protocol.read_pkt_line().

Also, handle HangupException if read_pkt_line() raises it. This happens
when talking to old versions of git-daemon (v1.6.6.1-26-g38a81b4), where
there won't be anything to read.

ObjectStoreGraphWalker.ack: use non-recursive implementation

We were recursively removing from self.heads; rewrite this such we try
removing heads this in a loop.

This gives a nice performance boost.

Use datetime.utcfromtimestamp() in tests.

datetime.fromtimestamp() has the confusing behavior of treating the
timestamp as a UTC time and then converting to local time, but not
setting the tzinfo member. As a result, the function returns different
values depending on the local timezone, which makes it hard to write a
test that passes everywhere.

The output of datetime.utcfromtimestamp() is stable across all
timezones, which is all we really need for tests. (Returning sensible
datetime objects from the Commit/Tag API would require substantially
more work, but that is not fixed in this change.)

Tested in both US-Pacific and US-Eastern.

Preserve '-' sign when -0000 is stored for the timezone in a commit/tag.

Add Tree.__iter__.

Cope with \r in ref files on Windows.

Avoid relying on PST for passing the testsuite.

Ensure we don't run past the end of the tree text.

We use strnlen so we can find namelen even if the buffer is truncated
in the name. This is not necessary for Python string objects, which are
guaranteed to be null-terminated, but some buffer objects (e.g. mmap)
may not be.

Remove unused import, always ensure that objects is serialized before running check().

Add check() methods to object classes for consistency checking.

These roughly mirror the parts of git fsck that deal with object
well-formedness, including checking the presence of required headers,
formatting of author/committer names, tree ordering, and so on. This
change does *not* include consistency checks that require touching other
objects; those will go in ObjectStore.

Note that currently many types of errors will still be raised during
object parsing proper, such as ValueErrors when trying to parse invalid
integers. In the check() method, any such exceptions are caught and
wrapped in an ObjectFormatException. The separate codepath also gives
us a place to put these checks if we decide to optimize them out of the
main object-parsing codepath.

Rename set_ref -> set_symbolic_ref.

Avoid writing to stdout.

Fix import of NotTagError.

Define common TestSkipped exception so it's easier to swap out later for
something nose-specific.

Change parse_tree to return a list rather than a dict.

For future consistency checks, we will need to ensure that objects in
the tree are stored in sorted order when we parse the tree, so it makes
sense to be able to reuse parse_tree for this purpose.

Also added tests for both the C and Python versions of parse_tree. To
do this in one test run, we also need to hold onto the pure-python
implementation before importing the C version if available.

cgi.parse_qs is deprecated in favor of urlparse.parse_qs in python 2.6,
but the function in urlparse doesn't exist in earlier versions.

Fix imports.

Merge Dave's fixes for the compatibility tests and web.

Update servers and compat tests to work with DictBackends.

Avoid seek when loading pack index files.

Simplify apply_pack call.

Remove GitBackendRepo, use plain Repo's instead.

Move apply_pack to ReceivePackHandler, so a server backend repo is a strict subset of Repo.

Use property to access commit parents.

Fix dul-daemon.

If git is available on the local machine, always run the compatibility tests so I don't break stuff again.

Fix use of git backend.

Some trivial formatting fixes.

merge support for custom get_peeled function in server.

implement chunked version of ShaFile.as_legacy_object.

Use open_repository to find repository for get_peeled.

Support progress argument to generate_pack_contents.

Add RefsContainer.read_ref.

Support opening git repositories by path.

Always require a Git repository object to be passed into
dulwich.server.GitBackend.

Previously, the word "type" was massively overloaded in objects.py. It
could refer to the numeric type of an object (obj.type or
obj._num_type), the type name of the object (obj._type or FOO_ID), or
the actual class (python type) of the object. This could get quite
confusing.

This change does the following:
 -Replace obj._type and obj._num_type with type_name and type_num. (The
  type property is retained for client compatibility, but is marked as
  deprecated.) Change the various type maps and callers to use the
  object's public members as keys.
 -Add a convenience function object_class that takes either a string or
  an int and dispatches to the appropriate type map.
 -Rename the FOO_ID constants as _FOO_HEADER, since those constants
  were previously overloaded to mean both header field names and type
  names. There is some overlap, but this is intentional.
 -Use isinstance for type comparisons rather than type, which is common
  python practice and avoids the problematic word altogether.

Previously, serialize() expected the object type to be numeric, and
_parse_text() set it to be an object class. Surprisingly, there were
no code paths that perform a round-trip parse-serialize-parse or
serialize-parse-serialize on tags; put a TODO in test_objects.py to add
such tests.

Pass command-line arguments on to command implementation.

Fix import.