diff --git a/NEWS b/NEWS
index 6924a420..d5b55389 100644
--- a/NEWS
+++ b/NEWS
@@ -1,1691 +1,1693 @@
 0.18.7	UNRELEASED
 
  BUG FIXES
 
   * Make `dulwich.archive` set the gzip header file modification time so that
     archives created from the same Git tree are always identical.
     (#577, Jonas Haag)
 
   * Allow comment characters (#, ;) within configuration file strings
     (Daniel Andersson, #579)
 
  IMPROVEMENTS
 
   * Add a fastimport ``extra``. (Jelmer Vernooij)
 
+  * Start writing reflog entries. (Jelmer Vernooij)
+
  API CHANGES
 
   * ``GitClient.send_pack`` now accepts a ``generate_pack_data``
     rather than a ``generate_pack_contents`` function for
     performance reasons. (Jelmer Vernooij)
 
 0.18.6	2017-11-11
 
  BUG FIXES
 
   * Fix handling of empty repositories in ``porcelain.clone``.
    (#570, Jelmer Vernooij)
 
   * Raise an error when attempting to add paths that are not under the
     repository. (Jelmer Vernooij)
 
   * Fix error message for missing trailing ]. (Daniel Andersson)
 
   * Raise EmptyFileException when corruption (in the form of an empty
     file) is detected. (Antoine R. Dumont, #582)
 
   IMPROVEMENTS
 
   * Enforce date field parsing consistency. This also add checks on
     those date fields for potential overflow.
     (Antoine R. Dumont, #567)
 
 0.18.5	2017-10-29
 
  BUG FIXES
 
   * Fix cwd for hooks. (Fabian Grünbichler)
 
   * Fix setting of origin in config when non-standard origin is passed into
     ``Repo.clone``. (Kenneth Lareau, #565)
 
   * Prevent setting SSH arguments from SSH URLs when using SSH through a
     subprocess. Note that Dulwich doesn't support cloning submodules.
     (CVE-2017-16228) (Jelmer Vernooij)
 
  IMPROVEMENTS
 
   * Silently ignored directories in ``Repo.stage``.
     (Jelmer Vernooij, #564)
 
  API CHANGES
 
   * GitFile now raises ``FileLocked`` when encountering a lock
     rather than OSError(EEXIST). (Jelmer Vernooij)
 
 0.18.4	2017-10-01
 
  BUG FIXES
 
   * Make default User-Agent start with "git/" because GitHub won't response to
     HTTP smart server requests otherwise (and reply with a 404).
     (Jelmer vernooij, #562)
 
 0.18.3	2017-09-03
 
  BUG FIXES
 
   * Read config during porcelain operations that involve remotes.
     (Jelmer Vernooij, #545)
 
   * Fix headers of empty chunks in unified diffs. (Taras Postument, #543)
 
   * Properly follow redirects over HTTP. (Jelmer Vernooij, #117)
 
  IMPROVEMENTS
 
   * Add ``dulwich.porcelain.update_head``. (Jelmer Vernooij, #439)
 
   * ``GitClient.fetch_pack`` now returns symrefs.
     (Jelmer Vernooij, #485)
 
   * The server now supports providing symrefs.
     (Jelmer Vernooij, #485)
 
   * Add ``dulwich.object_store.commit_tree_changes`` to incrementally
     commit changes to a tree structure. (Jelmer Vernooij)
 
   * Add basic ``PackBasedObjectStore.repack`` method.
     (Jelmer Vernooij, Earl Chew, #296, #549, #552)
 
 0.18.2	2017-08-01
 
  TEST FIXES
 
   * Use constant timestamp so tests pass in all timezones, not just BST.
     (Jelmer Vernooij)
 
 0.18.1	2017-07-31
 
  BUG FIXES
 
   * Fix syntax error in dulwich.contrib.test_swift_smoke.
     (Jelmer Vernooij)
 
 0.18.0	2017-07-31
 
  BUG FIXES
 
   * Fix remaining tests on Windows. (Jelmer Vernooij, #493)
 
   * Fix build of C extensions with Python 3 on Windows.
     (Jelmer Vernooij)
 
   * Pass 'mkdir' argument onto Repo.init_bare in Repo.clone.
     (Jelmer Vernooij, #504)
 
   * In ``dulwich.porcelain.add``, if no files are specified,
     add from current working directory rather than repository root.
     (Jelmer Vernooij, #521)
 
   * Properly deal with submodules in 'porcelain.status'.
     (Jelmer Vernooij, #517)
 
   * ``dulwich.porcelain.remove`` now actually removes files from
     disk, not just from the index. (Jelmer Vernooij, #488)
 
   * Fix handling of "reset" command with markers and without
     "from". (Antoine Pietri)
 
   * Fix handling of "merge" command with markers. (Antoine Pietri)
 
   * Support treeish argument to porcelain.reset(), rather than
     requiring a ref/commit id. (Jelmer Vernooij)
 
   * Handle race condition when mtime doesn't change between writes/reads.
     (Jelmer Vernooij, #541)
 
   * Fix ``dulwich.porcelain.show`` on commits with Python 3.
     (Jelmer Vernooij, #532)
 
  IMPROVEMENTS
 
   * Add basic support for reading ignore files in ``dulwich.ignore``.
     ``dulwich.porcelain.add`` and ``dulwich.porcelain.status`` now honor
     ignores. (Jelmer Vernooij, Segev Finer, #524, #526)
 
   * New ``dulwich.porcelain.check_ignore`` command.
     (Jelmer Vernooij)
 
   * ``dulwich.porcelain.status`` now supports a ``ignored`` argument.
     (Jelmer Vernooij)
 
  DOCUMENTATION
 
   * Clarified docstrings for Client.{send_pack,fetch_pack} implementations.
     (Jelmer Vernooij, #523)
 
 0.17.3	2017-03-20
 
  PLATFORM SUPPORT
 
   * List Python 3.3 as supported. (Jelmer Vernooij, #513)
 
  BUG FIXES
 
   * Fix compatibility with pypy 3. (Jelmer Vernooij)
 
 0.17.2	2017-03-19
 
  BUG FIXES
 
   * Add workaround for
     https://bitbucket.org/pypy/pypy/issues/2499/cpyext-pystring_asstring-doesnt-work,
     fixing Dulwich when used with C extensions on pypy < 5.6. (Victor Stinner)
 
   * Properly quote config values with a '#' character in them.
     (Jelmer Vernooij, #511)
 
 0.17.1	2017-03-01
 
  IMPROVEMENTS
 
   * Add basic 'dulwich pull' command. (Jelmer Vernooij)
 
  BUG FIXES
 
   * Cope with existing submodules during pull.
     (Jelmer Vernooij, #505)
 
 0.17.0	2017-03-01
 
  TEST FIXES
 
   * Skip test that requires sync to synchronize filesystems if os.sync is
     not available. (Koen Martens)
 
  IMPROVEMENTS
 
   * Implement MemoryRepo.{set_description,get_description}.
     (Jelmer Vernooij)
 
   * Raise exception in Repo.stage() when absolute paths are
     passed in. Allow passing in relative paths to
     porcelain.add().(Jelmer Vernooij)
 
  BUG FIXES
 
   * Handle multi-line quoted values in config files.
     (Jelmer Vernooij, #495)
 
   * Allow porcelain.clone of repository without HEAD.
     (Jelmer Vernooij, #501)
 
   * Support passing tag ids to Walker()'s include argument.
     (Jelmer Vernooij)
 
   * Don't strip trailing newlines from extra headers.
     (Nicolas Dandrimont)
 
   * Set bufsize=0 for subprocess interaction with SSH client.
     Fixes hangs on Python 3. (René Stern, #434)
 
   * Don't drop first slash for SSH paths, except for those
     starting with "~". (Jelmer Vernooij, René Stern, #463)
 
   * Properly log off after retrieving just refs.
     (Jelmer Vernooij)
 
 0.16.3	2016-01-14
 
  TEST FIXES
 
   * Remove racy check that relies on clock time changing between writes.
     (Jelmer Vernooij)
 
  IMPROVEMENTS
 
   * Add porcelain.remote_add. (Jelmer Vernooij)
 
 0.16.2	2016-01-14
 
  IMPROVEMENTS
 
   * Fixed failing test-cases on windows.
     (Koen Martens)
 
  API CHANGES
 
   * Repo is now a context manager, so that it can be easily
     closed using a ``with`` statement. (Søren Løvborg)
 
  TEST FIXES
 
   * Only run worktree list compat tests against git 2.7.0,
     when 'git worktree list' was introduced. (Jelmer Vernooij)
 
  BUG FIXES
 
   * Ignore filemode when building index when core.filemode
     is false.
     (Koen Martens)
 
   * Initialize core.filemode configuration setting by
     probing the filesystem for trustable permissions.
     (Koen Martens)
 
   * Fix ``porcelain.reset`` to respect the comittish argument.
     (Koen Martens)
 
   * Fix dulwich.porcelain.ls_remote() on Python 3.
     (#471, Jelmer Vernooij)
 
   * Allow both unicode and byte strings for host paths
     in dulwich.client. (#435, Jelmer Vernooij)
 
   * Add remote from porcelain.clone. (#466, Jelmer Vernooij)
 
   * Fix unquoting of credentials before passing to urllib2.
     (#475, Volodymyr Holovko)
 
   * Cope with submodules in `build_index_from_tree`.
     (#477, Jelmer Vernooij)
 
   * Handle deleted files in `get_unstaged_changes`.
     (#483, Doug Hellmann)
 
   * Don't overwrite files when they haven't changed in
     `build_file_from_blob`.
     (#479, Benoît HERVIER)
 
   * Check for existence of index file before opening pack.
     Fixes a race when new packs are being added.
     (#482, wme)
 
 0.16.1	2016-12-25
 
  BUG FIXES
 
   * Fix python3 compatibility for dulwich.contrib.release_robot.
     (Jelmer Vernooij)
 
 0.16.0	2016-12-24
 
  IMPROVEMENTS
 
   * Add support for worktrees. See `git-worktree(1)` and
     `gitrepository-layout(5)`. (Laurent Rineau)
 
   * Add support for `commondir` file in Git control
     directories. (Laurent Rineau)
 
   * Add support for passwords in HTTP URLs.
     (Jon Bain, Mika Mäenpää)
 
   * Add `release_robot` script to contrib,
     allowing easy finding of current version based on Git tags.
     (Mark Mikofski)
 
   * Add ``Blob.splitlines`` method.
     (Jelmer Vernooij)
 
  BUG FIXES
 
   * Fix handling of ``Commit.tree`` being set to an actual
     tree object rather than a tree id. (Jelmer Vernooij)
 
   * Return remote refs from LocalGitClient.fetch_pack(),
     consistent with the documentation for that method.
     (#461, Jelmer Vernooij)
 
   * Fix handling of unknown URL schemes in get_transport_and_path.
     (#465, Jelmer Vernooij)
 
 0.15.0	2016-10-09
 
  BUG FIXES
 
   * Allow missing trailing LF when reading service name from
     HTTP servers. (Jelmer Vernooij, Andrew Shadura, #442)
 
   * Fix dulwich.porcelain.pull() on Python3. (Jelmer Vernooij, #451)
 
   * Properly pull in tags during dulwich.porcelain.clone.
     (Jelmer Vernooij, #408)
 
  CHANGES
 
   * Changed license from "GNU General Public License, version 2.0 or later"
     to "Apache License, version 2.0 or later or GNU General Public License,
     version 2.0 or later". (#153)
 
  IMPROVEMENTS
 
   * Add ``dulwich.porcelain.ls_tree`` implementation. (Jelmer Vernooij)
 
 0.14.1	2016-07-05
 
  BUG FIXES
 
   * Fix regression removing untouched refs when pushing over SSH.
     (Jelmer Vernooij #441)
 
   * Skip Python3 tests for SWIFT contrib module, as it has not yet
     been ported.
 
 0.14.0	2016-07-03
 
  BUG FIXES
 
   * Fix ShaFile.id after modification of a copied ShaFile.
     (Félix Mattrat, Jelmer Vernooij)
 
   * Support removing refs from porcelain.push.
     (Jelmer Vernooij, #437)
 
   * Stop magic protocol ref `capabilities^{}` from leaking out
     to clients. (Jelmer Vernooij, #254)
 
  IMPROVEMENTS
 
   * Add `dulwich.config.parse_submodules` function.
 
   * Add `RefsContainer.follow` method. (#438)
 
 0.13.0	2016-04-24
 
  IMPROVEMENTS
 
   * Support `ssh://` URLs in get_transport_and_path_from_url().
     (Jelmer Vernooij, #402)
 
   * Support missing empty line after headers in Git commits and tags.
     (Nicolas Dandrimont, #413)
 
   * Fix `dulwich.porcelain.status` when used in empty trees.
     (Jelmer Vernooij, #415)
 
   * Return copies of objects in MemoryObjectStore rather than
     references, making the behaviour more consistent with that of
     DiskObjectStore. (Félix Mattrat, Jelmer Vernooij)
 
   * Fix ``dulwich.web`` on Python3. (#295, Jonas Haag)
 
  CHANGES
 
   * Drop support for Python 2.6.
 
   * Fix python3 client web support. (Jelmer Vernooij)
 
  BUG FIXES
 
   * Fix hang on Gzip decompression. (Jonas Haag)
 
   * Don't rely on working tell() and seek() methods
     on wsgi.input. (Jonas Haag)
 
   * Support fastexport/fastimport functionality on python3 with newer
     versions of fastimport (>= 0.9.5). (Jelmer Vernooij, Félix Mattrat)
 
 0.12.0	2015-12-13
 
  IMPROVEMENTS
 
   * Add a `dulwich.archive` module that can create tarballs.
     Based on code from Jonas Haag in klaus.
 
   * Add a `dulwich.reflog` module for reading and writing reflogs.
     (Jelmer Vernooij)
 
   * Fix handling of ambiguous refs in `parse_ref` to make
     it match the behaviour described in https://git-scm.com/docs/gitrevisions.
     (Chris Bunney)
 
   * Support Python3 in C modules. (Lele Gaifax)
 
  BUG FIXES
 
   * Simplify handling of SSH command invocation.
     Fixes quoting of paths. Thanks, Thomas Liebetraut. (#384)
 
   * Fix inconsistent handling of trailing slashes for DictRefsContainer. (#383)
 
   * Add hack to support thin packs duing fetch(), albeit while requiring the
     entire pack file to be loaded into memory. (jsbain)
 
  CHANGES
 
   * This will be the last release to support Python 2.6.
 
 0.11.2	2015-09-18
 
  IMPROVEMENTS
 
   * Add support for agent= capability. (Jelmer Vernooij, #298)
 
   * Add support for quiet capability. (Jelmer Vernooij)
 
  CHANGES
 
   * The ParamikoSSHVendor class has been moved to
   * dulwich.contrib.paramiko_vendor, as it's currently untested.
     (Jelmer Vernooij, #364)
 
 0.11.1	2015-09-13
 
  Fix-up release to exclude broken blame.py file.
 
 0.11.0	2015-09-13
 
  IMPROVEMENTS
 
   * Extended Python3 support to most of the codebase.
     (Gary van der Merwe, Jelmer Vernooij)
   * The `Repo` object has a new `close` method that can be called to close any
     open resources. (Gary van der Merwe)
   * Support 'git.bat' in SubprocessGitClient on Windows.
     (Stefan Zimmermann)
   * Advertise 'ofs-delta' capability in receive-pack server side
     capabilities. (Jelmer Vernooij)
   * Switched `default_local_git_client_cls` to `LocalGitClient`.
     (Gary van der Merwe)
   * Add `porcelain.ls_remote` and `GitClient.get_refs`.
     (Michael Edgar)
   * Add `Repo.discover` method. (B. M. Corser)
   * Add `dulwich.objectspec.parse_refspec`. (Jelmer Vernooij)
   * Add `porcelain.pack_objects` and `porcelain.repack`.
     (Jelmer Vernooij)
 
  BUG FIXES
 
   * Fix handling of 'done' in graph walker and implement the
     'no-done' capability. (Tommy Yu, #88)
 
   * Avoid recursion limit issues resolving deltas. (William Grant, #81)
 
   * Allow arguments in local client binary path overrides.
     (Jelmer Vernooij)
 
   * Fix handling of commands with arguments in paramiko SSH
     client. (Andreas Klöckner, Jelmer Vernooij, #363)
 
   * Fix parsing of quoted strings in configs. (Jelmer Vernooij, #305)
 
 0.10.1  2015-03-25
 
  BUG FIXES
 
   * Return `ApplyDeltaError` when encountering delta errors
     in both C extensions and native delta application code.
     (Jelmer Vernooij, #259)
 
 0.10.0	2015-03-22
 
  BUG FIXES
 
   * In dulwich.index.build_index_from_tree, by default
     refuse to create entries that start with .git/.
 
   * Fix running of testsuite when installed.
     (Jelmer Vernooij, #223)
 
   * Use a block cache in _find_content_rename_candidates(),
     improving performance. (Mike Williams)
 
   * Add support for ``core.protectNTFS`` setting.
     (Jelmer Vernooij)
 
   * Fix TypeError when fetching empty updates.
     (Hwee Miin Koh)
 
   * Resolve delta refs when pulling into a MemoryRepo.
     (Max Shawabkeh, #256)
 
   * Fix handling of tags of non-commits in missing object finder.
     (Augie Fackler, #211)
 
   * Explicitly disable mmap on plan9 where it doesn't work.
     (Jeff Sickel)
 
  IMPROVEMENTS
 
   * New public method `Repo.reset_index`. (Jelmer Vernooij)
 
   * Prevent duplicate parsing of loose files in objects
     directory when reading. Thanks to David Keijser for the
     report. (Jelmer Vernooij, #231)
 
 0.9.9	2015-03-20
 
  SECURITY BUG FIXES
 
   * Fix buffer overflow in C implementation of pack apply_delta().
     (CVE-2015-0838)
 
     Thanks to Ivan Fratric of the Google Security Team for
     reporting this issue.
     (Jelmer Vernooij)
 
 0.9.8	2014-11-30
 
  BUG FIXES
 
   * Various fixes to improve test suite running on Windows.
     (Gary van der Merwe)
 
   * Limit delta copy length to 64K in v2 pack files. (Robert Brown)
 
   * Strip newline from final ACKed SHA while fetching packs.
     (Michael Edgar)
 
   * Remove assignment to PyList_SIZE() that was causing segfaults on
     pypy. (Jelmer Vernooij, #196)
 
  IMPROVEMENTS
 
   * Add porcelain 'receive-pack' and 'upload-pack'. (Jelmer Vernooij)
 
   * Handle SIGINT signals in bin/dulwich. (Jelmer Vernooij)
 
   * Add 'status' support to bin/dulwich. (Jelmer Vernooij)
 
   * Add 'branch_create', 'branch_list', 'branch_delete' porcelain.
     (Jelmer Vernooij)
 
   * Add 'fetch' porcelain. (Jelmer Vernooij)
 
   * Add 'tag_delete' porcelain. (Jelmer Vernooij)
 
   * Add support for serializing/deserializing 'gpgsig' attributes in Commit.
     (Jelmer Vernooij)
 
  CHANGES
 
   * dul-web is now available as 'dulwich web-daemon'.
     (Jelmer Vernooij)
 
   * dulwich.porcelain.tag has been renamed to tag_create.
     dulwich.porcelain.list_tags has been renamed to tag_list.
     (Jelmer Vernooij)
 
  API CHANGES
 
   * Restore support for Python 2.6. (Jelmer Vernooij, Gary van der Merwe)
 
 
 0.9.7	2014-06-08
 
  BUG FIXES
 
   * Fix tests dependent on hash ordering. (Michael Edgar)
 
   * Support staging symbolic links in Repo.stage.
     (Robert Brown)
 
   * Ensure that all files object are closed when running the test suite.
     (Gary van der Merwe)
 
   * When writing OFS_DELTA pack entries, write correct offset.
     (Augie Fackler)
 
   * Fix handler of larger copy operations in packs. (Augie Fackler)
 
   * Various fixes to improve test suite running on Windows.
     (Gary van der Merwe)
 
   * Fix logic for extra adds of identical files in rename detector.
     (Robert Brown)
 
  IMPROVEMENTS
 
   * Add porcelain 'status'. (Ryan Faulkner)
 
   * Add porcelain 'daemon'. (Jelmer Vernooij)
 
   * Add `dulwich.greenthreads` module which provides support
     for concurrency of some object store operations.
     (Fabien Boucher)
 
   * Various changes to improve compatibility with Python 3.
     (Gary van der Merwe, Hannu Valtonen, michael-k)
 
   * Add OpenStack Swift backed repository implementation
     in dulwich.contrib. See README.swift for details. (Fabien Boucher)
 
 API CHANGES
 
   * An optional close function can be passed to the Protocol class. This will
     be called by its close method. (Gary van der Merwe)
 
   * All classes with close methods are now context managers, so that they can
     be easily closed using a `with` statement. (Gary van der Merwe)
 
   * Remove deprecated `num_objects` argument to `write_pack` methods.
     (Jelmer Vernooij)
 
  OTHER CHANGES
 
   * The 'dul-daemon' script has been removed. The same functionality
     is now available as 'dulwich daemon'. (Jelmer Vernooij)
 
 0.9.6	2014-04-23
 
  IMPROVEMENTS
 
   * Add support for recursive add in 'git add'.
     (Ryan Faulkner, Jelmer Vernooij)
 
   * Add porcelain 'list_tags'. (Ryan Faulkner)
 
   * Add porcelain 'push'. (Ryan Faulkner)
 
   * Add porcelain 'pull'. (Ryan Faulkner)
 
   * Support 'http.proxy' in HttpGitClient.
     (Jelmer Vernooij, #1096030)
 
   * Support 'http.useragent' in HttpGitClient.
     (Jelmer Vernooij)
 
   * In server, wait for clients to send empty list of
     wants when talking to empty repository.
     (Damien Tournoud)
 
   * Various changes to improve compatibility with
     Python 3. (Gary van der Merwe)
 
  BUG FIXES
 
   * Support unseekable 'wsgi.input' streams.
     (Jonas Haag)
 
   * Raise TypeError when passing unicode() object
     to Repo.__getitem__.
     (Jonas Haag)
 
   * Fix handling of `reset` command in dulwich.fastexport.
     (Jelmer Vernooij, #1249029)
 
   * In client, don't wait for server to close connection
     first. Fixes hang when used against GitHub
     server implementation. (Siddharth Agarwal)
 
   * DeltaChainIterator: fix a corner case where an object is inflated as an
     object already in the repository.
     (Damien Tournoud, #135)
 
   * Stop leaking file handles during pack reload. (Damien Tournoud)
 
   * Avoid reopening packs during pack cache reload. (Jelmer Vernooij)
 
  API CHANGES
 
   * Drop support for Python 2.6. (Jelmer Vernooij)
 
 0.9.5	2014-02-23
 
  IMPROVEMENTS
 
   * Add porcelain 'tag'. (Ryan Faulkner)
 
   * New module `dulwich.objectspec` for parsing strings referencing
     objects and commit ranges. (Jelmer Vernooij)
 
   * Add shallow branch support. (milki)
 
   * Allow passing urllib2 `opener` into HttpGitClient.
     (Dov Feldstern, #909037)
 
  CHANGES
 
   * Drop support for Python 2.4 and 2.5. (Jelmer Vernooij)
 
  API CHANGES
 
   * Remove long deprecated ``Repo.commit``, ``Repo.get_blob``,
     ``Repo.tree`` and ``Repo.tag``. (Jelmer Vernooij)
 
   * Remove long deprecated ``Repo.revision_history`` and ``Repo.ref``.
     (Jelmer Vernooij)
 
   * Remove long deprecated ``Tree.entries``. (Jelmer Vernooij)
 
  BUG FIXES
 
   * Raise KeyError rather than TypeError when passing in
     unicode object of length 20 or 40 to Repo.__getitem__.
     (Jelmer Vernooij)
 
   * Use 'rm' rather than 'unlink' in tests, since the latter
     does not exist on OpenBSD and other platforms.
     (Dmitrij D. Czarkoff)
 
 0.9.4	2013-11-30
 
  IMPROVEMENTS
 
   * Add ssh_kwargs attribute to ParamikoSSHVendor. (milki)
 
   * Add Repo.set_description(). (Víðir Valberg Guðmundsson)
 
   * Add a basic `dulwich.porcelain` module. (Jelmer Vernooij, Marcin Kuzminski)
 
   * Various performance improvements for object access.
     (Jelmer Vernooij)
 
   * New function `get_transport_and_path_from_url`,
     similar to `get_transport_and_path` but only
     supports URLs.
     (Jelmer Vernooij)
 
   * Add support for file:// URLs in `get_transport_and_path_from_url`.
     (Jelmer Vernooij)
 
   * Add LocalGitClient implementation.
     (Jelmer Vernooij)
 
  BUG FIXES
 
   * Support filesystems with 64bit inode and device numbers.
     (André Roth)
 
  CHANGES
 
   * Ref handling has been moved to dulwich.refs.
     (Jelmer Vernooij)
 
  API CHANGES
 
   * Remove long deprecated RefsContainer.set_ref().
     (Jelmer Vernooij)
 
   * Repo.ref() is now deprecated in favour of Repo.refs[].
     (Jelmer Vernooij)
 
 FEATURES
 
   * Add support for graftpoints. (milki)
 
 0.9.3	2013-09-27
 
  BUG FIXES
 
   * Fix path for stdint.h in MANIFEST.in. (Jelmer Vernooij)
 
 0.9.2	2013-09-26
 
  BUG FIXES
 
   * Include stdint.h in MANIFEST.in (Mark Mikofski)
 
 0.9.1	2013-09-22
 
  BUG FIXES
 
   * Support lookups of 40-character refs in BaseRepo.__getitem__. (Chow Loong Jin, Jelmer Vernooij)
 
   * Fix fetching packs with side-band-64k capability disabled. (David Keijser, Jelmer Vernooij)
 
   * Several fixes in send-pack protocol behaviour - handling of empty pack files and deletes.
     (milki, #1063087)
 
   * Fix capability negotiation when fetching packs over HTTP.
     (#1072461, William Grant)
 
   * Enforce determine_wants returning an empty list rather than None. (Fabien Boucher, Jelmer Vernooij)
 
   * In the server, support pushes just removing refs. (Fabien Boucher, Jelmer Vernooij)
 
  IMPROVEMENTS
 
   * Support passing a single revision to BaseRepo.get_walker() rather than a list of revisions. 
     (Alberto Ruiz)
 
   * Add `Repo.get_description` method. (Jelmer Vernooij)
 
   * Support thin packs in Pack.iterobjects() and Pack.get_raw().
     (William Grant)
 
   * Add `MemoryObjectStore.add_pack` and `MemoryObjectStore.add_thin_pack` methods.
     (David Bennett)
 
   * Add paramiko-based SSH vendor. (Aaron O'Mullan)
 
   * Support running 'dulwich.server' and 'dulwich.web' using 'python -m'.
     (Jelmer Vernooij)
 
   * Add ObjectStore.close(). (Jelmer Vernooij)
 
   * Raise appropriate NotImplementedError when encountering dumb HTTP servers.
     (Jelmer Vernooij)
 
  API CHANGES
 
   * SSHVendor.connect_ssh has been renamed to SSHVendor.run_command.
     (Jelmer Vernooij)
 
   * ObjectStore.add_pack() now returns a 3-tuple. The last element will be an
     abort() method that can be used to cancel the pack operation.
     (Jelmer Vernooij)
 
 0.9.0	2013-05-31
 
  BUG FIXES
 
   * Push efficiency - report missing objects only. (#562676, Artem Tikhomirov)
 
   * Use indentation consistent with C Git in config files.
     (#1031356, Curt Moore, Jelmer Vernooij)
 
   * Recognize and skip binary files in diff function.
     (Takeshi Kanemoto)
 
   * Fix handling of relative paths in dulwich.client.get_transport_and_path.
     (Brian Visel, #1169368)
 
   * Preserve ordering of entries in configuration.
     (Benjamin Pollack)
 
   * Support ~ expansion in SSH client paths. (milki, #1083439)
 
   * Support relative paths in alternate paths.
     (milki, Michel Lespinasse, #1175007)
 
   * Log all error messages from wsgiref server to the logging module. This
     makes the test suit quiet again. (Gary van der Merwe)
 
   * Support passing None for empty tree in changes_from_tree.
     (Kevin Watters)
 
   * Support fetching empty repository in client. (milki, #1060462)
 
  IMPROVEMENTS:
 
   * Add optional honor_filemode flag to build_index_from_tree.
     (Mark Mikofski)
 
   * Support core/filemode setting when building trees. (Jelmer Vernooij)
 
   * Add chapter on tags in tutorial. (Ryan Faulkner)
 
  FEATURES
 
   * Add support for mergetags. (milki, #963525)
 
   * Add support for posix shell hooks. (milki)
 
 0.8.7	2012-11-27
 
  BUG FIXES
 
   * Fix use of alternates in ``DiskObjectStore``.{__contains__,__iter__}.
     (Dmitriy)
 
   * Fix compatibility with Python 2.4. (David Carr)
 
 0.8.6	2012-11-09
 
  API CHANGES
 
   * dulwich.__init__ no longer imports client, protocol, repo and
     server modules. (Jelmer Vernooij)
 
  FEATURES
 
   * ConfigDict now behaves more like a dictionary.
     (Adam 'Cezar' Jenkins, issue #58)
 
   * HTTPGitApplication now takes an optional
     `fallback_app` argument. (Jonas Haag, issue #67)
 
   * Support for large pack index files. (Jameson Nash)
 
  TESTING
 
   * Make index entry tests a little bit less strict, to cope with
     slightly different behaviour on various platforms.
     (Jelmer Vernooij)
 
   * ``setup.py test`` (available when setuptools is installed) now
     runs all tests, not just the basic unit tests.
     (Jelmer Vernooij)
 
  BUG FIXES
 
   * Commit._deserialize now actually deserializes the current state rather than
     the previous one. (Yifan Zhang, issue #59)
 
   * Handle None elements in lists of TreeChange objects. (Alex Holmes)
 
   * Support cloning repositories without HEAD set.
     (D-Key, Jelmer Vernooij, issue #69)
 
   * Support ``MemoryRepo.get_config``. (Jelmer Vernooij)
 
   * In ``get_transport_and_path``, pass extra keyword arguments on to
     HttpGitClient. (Jelmer Vernooij)
 
 0.8.5	2012-03-29
 
  BUG FIXES
 
   * Avoid use of 'with' in dulwich.index. (Jelmer Vernooij)
 
   * Be a little bit strict about OS behaviour in index tests.
     Should fix the tests on Debian GNU/kFreeBSD. (Jelmer Vernooij)
 
 0.8.4	2012-03-28
 
  BUG FIXES
 
   * Options on the same line as sections in config files are now supported.
     (Jelmer Vernooij, #920553)
 
   * Only negotiate capabilities that are also supported by the server.
     (Rod Cloutier, Risto Kankkunen)
 
   * Fix parsing of invalid timezone offsets with two minus signs.
     (Jason R. Coombs, #697828)
 
   * Reset environment variables during tests, to avoid
     test isolation leaks reading ~/.gitconfig. (Risto Kankkunen)
 
  TESTS
 
   * $HOME is now explicitly specified for tests that use it to read
     ``~/.gitconfig``, to prevent test isolation issues.
     (Jelmer Vernooij, #920330)
 
  FEATURES
 
   * Additional arguments to get_transport_and_path are now passed
     on to the constructor of the transport. (Sam Vilain)
 
   * The WSGI server now transparently handles when a git client submits data
     using Content-Encoding: gzip.
     (David Blewett, Jelmer Vernooij)
 
   * Add dulwich.index.build_index_from_tree(). (milki)
 
 0.8.3	2012-01-21
 
  FEATURES
 
   * The config parser now supports the git-config file format as
     described in git-config(1) and can write git config files.
     (Jelmer Vernooij, #531092, #768687)
 
   * ``Repo.do_commit`` will now use the user identity from
     .git/config or ~/.gitconfig if none was explicitly specified.
     (Jelmer Vernooij)
 
  BUG FIXES
 
   * Allow ``determine_wants`` methods to include the zero sha in their
     return value. (Jelmer Vernooij)
 
 0.8.2	2011-12-18
 
  BUG FIXES
 
   * Cope with different zlib buffer sizes in sha1 file parser.
     (Jelmer Vernooij)
 
   * Fix get_transport_and_path for HTTP/HTTPS URLs.
     (Bruno Renié)
 
   * Avoid calling free_objects() on NULL in error cases. (Chris Eberle)
 
   * Fix use --bare argument to 'dulwich init'. (Chris Eberle)
 
   * Properly abort connections when the determine_wants function
     raises an exception. (Jelmer Vernooij, #856769)
 
   * Tweak xcodebuild hack to deal with more error output.
     (Jelmer Vernooij, #903840)
 
  FEATURES
 
   * Add support for retrieving tarballs from remote servers.
     (Jelmer Vernooij, #379087)
 
   * New method ``update_server_info`` which generates data
     for dumb server access. (Jelmer Vernooij, #731235)
 
 0.8.1	2011-10-31
 
  FEATURES
 
   * Repo.do_commit has a new argument 'ref'.
 
   * Repo.do_commit has a new argument 'merge_heads'. (Jelmer Vernooij)
 
   * New ``Repo.get_walker`` method. (Jelmer Vernooij)
 
   * New ``Repo.clone`` method. (Jelmer Vernooij, #725369)
 
   * ``GitClient.send_pack`` now supports the 'side-band-64k' capability.
     (Jelmer Vernooij)
 
   * ``HttpGitClient`` which supports the smart server protocol over
     HTTP. "dumb" access is not yet supported. (Jelmer Vernooij, #373688)
 
   * Add basic support for alternates. (Jelmer Vernooij, #810429)
 
  CHANGES
 
   * unittest2 or python >= 2.7 is now required for the testsuite.
     testtools is no longer supported. (Jelmer Vernooij, #830713)
 
  BUG FIXES
 
   * Fix compilation with older versions of MSVC.  (Martin gz)
 
   * Special case 'refs/stash' as a valid ref. (Jelmer Vernooij, #695577)
 
   * Smart protocol clients can now change refs even if they are
     not uploading new data. (Jelmer Vernooij, #855993)
 
   * Don't compile C extensions when running in pypy.
     (Ronny Pfannschmidt, #881546)
 
   * Use different name for strnlen replacement function to avoid clashing
     with system strnlen. (Jelmer Vernooij, #880362)
 
  API CHANGES
 
   * ``Repo.revision_history`` is now deprecated in favor of ``Repo.get_walker``.
     (Jelmer Vernooij)
 
 0.8.0	2011-08-07
 
  FEATURES
 
   * New DeltaChainIterator abstract class for quickly iterating all objects in
     a pack, with implementations for pack indexing and inflation.
     (Dave Borowitz)
 
   * New walk module with a Walker class for customizable commit walking.
     (Dave Borowitz)
 
   * New tree_changes_for_merge function in diff_tree. (Dave Borowitz)
 
   * Easy rename detection in RenameDetector even without find_copies_harder.
     (Dave Borowitz)
 
  BUG FIXES
 
   * Avoid storing all objects in memory when writing pack.
     (Jelmer Vernooij, #813268)
 
   * Support IPv6 for git:// connections. (Jelmer Vernooij, #801543)
 
   * Improve performance of Repo.revision_history(). (Timo Schmid, #535118)
 
   * Fix use of SubprocessWrapper on Windows. (Paulo Madeira, #670035)
 
   * Fix compilation on newer versions of Mac OS X (Lion and up). (Ryan McKern, #794543)
 
   * Prevent raising ValueError for correct refs in RefContainer.__delitem__.
 
   * Correctly return a tuple from MemoryObjectStore.get_raw. (Dave Borowitz)
 
   * Fix a bug in reading the pack checksum when there are fewer than 20 bytes
     left in the buffer. (Dave Borowitz)
 
   * Support ~ in git:// URL paths. (Jelmer Vernooij, #813555)
 
   * Make ShaFile.__eq__ work when other is not a ShaFile. (Dave Borowitz)
 
   * ObjectStore.get_graph_walker() now no longer yields the same
     revision more than once. This has a significant improvement for
     performance when wide revision graphs are involved.
     (Jelmer Vernooij, #818168)
 
   * Teach ReceivePackHandler how to read empty packs. (Dave Borowitz)
 
   * Don't send a pack with duplicates of the same object. (Dave Borowitz)
 
   * Teach the server how to serve a clone of an empty repo. (Dave Borowitz)
 
   * Correctly advertise capabilities during receive-pack. (Dave Borowitz)
 
   * Fix add/add and add/rename conflicts in tree_changes_for_merge.
     (Dave Borowitz)
 
   * Use correct MIME types in web server. (Dave Borowitz)
 
  API CHANGES
 
   * write_pack no longer takes the num_objects argument and requires an object
     to be passed in that is iterable (rather than an iterator) and that
     provides __len__.  (Jelmer Vernooij)
 
   * write_pack_data has been renamed to write_pack_objects and no longer takes a
     num_objects argument. (Jelmer Vernooij)
 
   * take_msb_bytes, read_zlib_chunks, unpack_objects, and
     PackStreamReader.read_objects now take an additional argument indicating a
     crc32 to compute. (Dave Borowitz)
 
   * PackObjectIterator was removed; its functionality is still exposed by
     PackData.iterobjects. (Dave Borowitz)
 
   * Add a sha arg to write_pack_object to incrementally compute a SHA.
     (Dave Borowitz)
 
   * Include offset in PackStreamReader results. (Dave Borowitz)
 
   * Move PackStreamReader from server to pack. (Dave Borowitz)
 
   * Extract a check_length_and_checksum, compute_file_sha, and
     pack_object_header pack helper functions. (Dave Borowitz)
 
   * Extract a compute_file_sha function. (Dave Borowitz)
 
   * Remove move_in_thin_pack as a separate method; add_thin_pack now completes
     the thin pack and moves it in in one step. Remove ThinPackData as well.
     (Dave Borowitz)
 
   * Custom buffer size in read_zlib_chunks. (Dave Borowitz)
 
   * New UnpackedObject data class that replaces ad-hoc tuples in the return
     value of unpack_object and various DeltaChainIterator methods.
     (Dave Borowitz)
 
   * Add a lookup_path convenience method to Tree. (Dave Borowitz)
 
   * Optionally create RenameDetectors without passing in tree SHAs.
     (Dave Borowitz)
 
   * Optionally include unchanged entries in RenameDetectors. (Dave Borowitz)
 
   * Optionally pass a RenameDetector to tree_changes. (Dave Borowitz)
 
   * Optionally pass a request object through to server handlers. (Dave Borowitz)
 
  TEST CHANGES
 
   * If setuptools is installed, "python setup.py test" will now run the testsuite.
     (Jelmer Vernooij)
 
   * Add a new build_pack test utility for building packs from a simple spec.
     (Dave Borowitz)
 
   * Add a new build_commit_graph test utility for building commits from a
     simple spec. (Dave Borowitz)
 
 0.7.1	2011-04-12
 
  BUG FIXES
 
   * Fix double decref in _diff_tree.c. (Ted Horst, #715528)
 
   * Fix the build on Windows. (Pascal Quantin)
 
   * Fix get_transport_and_path compatibility with pre-2.6.5 versions of Python.
     (Max Bowsher, #707438)
 
   * BaseObjectStore.determine_wants_all no longer breaks on zero SHAs.
     (Jelmer Vernooij)
 
   * write_tree_diff() now supports submodules.
     (Jelmer Vernooij)
 
   * Fix compilation for XCode 4 and older versions of distutils.sysconfig.
     (Daniele Sluijters)
 
  IMPROVEMENTS
 
   * Sphinxified documentation. (Lukasz Balcerzak)
 
   * Add Pack.keep.(Marc Brinkmann)
 
  API CHANGES
 
   * The order of the parameters to Tree.add(name, mode, sha) has changed, and
     is now consistent with the rest of Dulwich. Existing code will still
     work but print a DeprecationWarning. (Jelmer Vernooij, #663550)
 
   * Tree.entries() is now deprecated in favour of Tree.items() and
     Tree.iteritems(). (Jelmer Vernooij)
 
 0.7.0	2011-01-21
 
  FEATURES
 
   * New `dulwich.diff_tree` module for simple content-based rename detection.
     (Dave Borowitz)
 
   * Add Tree.items(). (Jelmer Vernooij)
 
   * Add eof() and unread_pkt_line() methods to Protocol. (Dave Borowitz)
 
   * Add write_tree_diff(). (Jelmer Vernooij)
 
   * Add `serve_command` function for git server commands as executables.
     (Jelmer Vernooij)
 
   * dulwich.client.get_transport_and_path now supports rsync-style repository URLs.
     (Dave Borowitz, #568493)
 
  BUG FIXES
 
   * Correct short-circuiting operation for no-op fetches in the server.
     (Dave Borowitz)
 
   * Support parsing git mbox patches without a version tail, as generated by
     Mercurial.  (Jelmer Vernooij)
 
   * Fix dul-receive-pack and dul-upload-pack. (Jelmer Vernooij)
 
   * Zero-padded file modes in Tree objects no longer trigger an exception but
     the check code warns about them. (Augie Fackler, #581064)
 
   * Repo.init() now honors the mkdir flag. (#671159)
 
   * The ref format is now checked when setting a ref rather than when reading it back.
     (Dave Borowitz, #653527)
 
   * Make sure pack files are closed correctly. (Tay Ray Chuan)
 
  DOCUMENTATION
 
   * Run the tutorial inside the test suite. (Jelmer Vernooij)
 
   * Reorganized and updated the tutorial. (Jelmer Vernooij, Dave Borowitz, #610550,
      #610540)
 
 
 0.6.2	2010-10-16
 
  BUG FIXES
 
   * HTTP server correctly handles empty CONTENT_LENGTH. (Dave Borowitz)
 
   * Don't error when creating GitFiles with the default mode. (Dave Borowitz)
 
   * ThinPackData.from_file now works with resolve_ext_ref callback.
     (Dave Borowitz)
 
   * Provide strnlen() on mingw32 which doesn't have it. (Hans Kolek)
 
   * Set bare=true in the configuratin for bare repositories. (Dirk Neumann)
 
  FEATURES
 
   * Use slots for core objects to save up on memory. (Jelmer Vernooij)
 
   * Web server supports streaming progress/pack output. (Dave Borowitz)
 
   * New public function dulwich.pack.write_pack_header. (Dave Borowitz)
 
   * Distinguish between missing files and read errors in HTTP server.
     (Dave Borowitz)
 
   * Initial work on support for fastimport using python-fastimport.
     (Jelmer Vernooij)
 
   * New dulwich.pack.MemoryPackIndex class. (Jelmer Vernooij)
 
   * Delegate SHA peeling to the object store.  (Dave Borowitz)
 
  TESTS
 
   * Use GitFile when modifying packed-refs in tests. (Dave Borowitz)
 
   * New tests in test_web with better coverage and fewer ad-hoc mocks.
     (Dave Borowitz)
 
   * Standardize quote delimiters in test_protocol. (Dave Borowitz)
 
   * Fix use when testtools is installed. (Jelmer Vernooij)
 
   * Add trivial test for write_pack_header. (Jelmer Vernooij)
 
   * Refactor some of dulwich.tests.compat.server_utils. (Dave Borowitz)
 
   * Allow overwriting id property of objects in test utils. (Dave Borowitz)
 
   * Use real in-memory objects rather than stubs for server tests.
     (Dave Borowitz)
 
   * Clean up MissingObjectFinder. (Dave Borowitz)
 
  API CHANGES
 
   * ObjectStore.iter_tree_contents now walks contents in depth-first, sorted
     order. (Dave Borowitz)
 
   * ObjectStore.iter_tree_contents can optionally yield tree objects as well.
     (Dave Borowitz).
 
   * Add side-band-64k support to ReceivePackHandler. (Dave Borowitz)
 
   * Change server capabilities methods to classmethods. (Dave Borowitz)
 
   * Tweak server handler injection. (Dave Borowitz)
 
   * PackIndex1 and PackIndex2 now subclass FilePackIndex, which is 
     itself a subclass of PackIndex. (Jelmer Vernooij)
 
  DOCUMENTATION
 
   * Add docstrings for various functions in dulwich.objects. (Jelmer Vernooij)
 
   * Clean up docstrings in dulwich.protocol. (Dave Borowitz)
 
   * Explicitly specify allowed protocol commands to
     ProtocolGraphWalker.read_proto_line.  (Dave Borowitz)
 
   * Add utility functions to DictRefsContainer. (Dave Borowitz)
 
 
 0.6.1	2010-07-22
 
  BUG FIXES
 
   * Fix memory leak in C implementation of sorted_tree_items. (Dave Borowitz)
 
   * Use correct path separators for named repo files. (Dave Borowitz)
 
   * python > 2.7 and testtools-based test runners will now also pick up skipped
     tests correctly. (Jelmer Vernooij)
 
  FEATURES
 
   * Move named file initilization to BaseRepo. (Dave Borowitz)
 
   * Add logging utilities and git/HTTP server logging. (Dave Borowitz)
 
   * The GitClient interface has been cleaned up and instances are now reusable.
     (Augie Fackler)
 
   * Allow overriding paths to executables in GitSSHClient. 
     (Ross Light, Jelmer Vernooij, #585204)
 
   * Add PackBasedObjectStore.pack_loose_objects(). (Jelmer Vernooij)
 
  TESTS
 
   * Add tests for sorted_tree_items and C implementation. (Dave Borowitz)
 
   * Add a MemoryRepo that stores everything in memory. (Dave Borowitz)
 
   * Quiet logging output from web tests. (Dave Borowitz)
 
   * More flexible version checking for compat tests. (Dave Borowitz)
 
   * Compat tests for servers with and without side-band-64k. (Dave Borowitz)
 
  CLEANUP
 
   * Clean up file headers. (Dave Borowitz)
 
  TESTS
 
   * Use GitFile when modifying packed-refs in tests. (Dave Borowitz)
 
  API CHANGES
 
   * dulwich.pack.write_pack_index_v{1,2} now take a file-like object
     rather than a filename. (Jelmer Vernooij)
 
   * Make dul-daemon/dul-web trivial wrappers around server functionality.
     (Dave Borowitz)
 
   * Move reference WSGI handler to web.py. (Dave Borowitz)
 
   * Factor out _report_status in ReceivePackHandler. (Dave Borowitz)
 
   * Factor out a function to convert a line to a pkt-line. (Dave Borowitz)
 
 
 0.6.0	2010-05-22
 
 note: This list is most likely incomplete for 0.6.0.
 
  BUG FIXES
  
   * Fix ReceivePackHandler to disallow removing refs without delete-refs.
     (Dave Borowitz)
 
   * Deal with capabilities required by the client, even if they 
     can not be disabled in the server. (Dave Borowitz)
 
   * Fix trailing newlines in generated patch files.
     (Jelmer Vernooij)
 
   * Implement RefsContainer.__contains__. (Jelmer Vernooij)
 
   * Cope with \r in ref files on Windows. (
     http://github.com/jelmer/dulwich/issues/#issue/13, Jelmer Vernooij)
 
   * Fix GitFile breakage on Windows. (Anatoly Techtonik, #557585)
 
   * Support packed ref deletion with no peeled refs. (Augie Fackler)
 
   * Fix send pack when there is nothing to fetch. (Augie Fackler)
 
   * Fix fetch if no progress function is specified. (Augie Fackler)
 
   * Allow double-staging of files that are deleted in the index. 
     (Dave Borowitz)
 
   * Fix RefsContainer.add_if_new to support dangling symrefs.
     (Dave Borowitz)
 
   * Non-existant index files in non-bare repositories are now treated as 
     empty. (Dave Borowitz)
 
   * Always update ShaFile.id when the contents of the object get changed. 
     (Jelmer Vernooij)
 
   * Various Python2.4-compatibility fixes. (Dave Borowitz)
 
   * Fix thin pack handling. (Dave Borowitz)
  
  FEATURES
 
   * Add include-tag capability to server. (Dave Borowitz)
 
   * New dulwich.fastexport module that can generate fastexport 
     streams. (Jelmer Vernooij)
 
   * Implemented BaseRepo.__contains__. (Jelmer Vernooij)
 
   * Add __setitem__ to DictRefsContainer. (Dave Borowitz)
 
   * Overall improvements checking Git objects. (Dave Borowitz)
 
   * Packs are now verified while they are received. (Dave Borowitz)
 
  TESTS
 
   * Add framework for testing compatibility with C Git. (Dave Borowitz)
 
   * Add various tests for the use of non-bare repositories. (Dave Borowitz)
 
   * Cope with diffstat not being available on all platforms. 
     (Tay Ray Chuan, Jelmer Vernooij)
 
   * Add make_object and make_commit convenience functions to test utils.
     (Dave Borowitz)
 
  API BREAKAGES
 
   * The 'committer' and 'message' arguments to Repo.do_commit() have 
     been swapped. 'committer' is now optional. (Jelmer Vernooij)
 
   * Repo.get_blob, Repo.commit, Repo.tag and Repo.tree are now deprecated.
     (Jelmer Vernooij)
 
   * RefsContainer.set_ref() was renamed to RefsContainer.set_symbolic_ref(),
     for clarity. (Jelmer Vernooij)
 
  API CHANGES
 
   * The primary serialization APIs in dulwich.objects now work 
     with chunks of strings rather than with full-text strings. 
     (Jelmer Vernooij)
 
 0.5.02010-03-03
 
  BUG FIXES
 
   * Support custom fields in commits (readonly). (Jelmer Vernooij)
 
   * Improved ref handling. (Dave Borowitz)
 
   * Rework server protocol to be smarter and interoperate with cgit client.
     (Dave Borowitz)
 
   * Add a GitFile class that uses the same locking protocol for writes as 
     cgit. (Dave Borowitz)
 
   * Cope with forward slashes correctly in the index on Windows.
     (Jelmer Vernooij, #526793)
 
  FEATURES
 
   * --pure option to setup.py to allow building/installing without the C 
     extensions. (Hal Wine, Anatoly Techtonik, Jelmer Vernooij, #434326)
 
   * Implement Repo.get_config(). (Jelmer Vernooij, Augie Fackler)
 
   * HTTP dumb and smart server. (Dave Borowitz)
 
   * Add abstract baseclass for Repo that does not require file system 
     operations. (Dave Borowitz)
 
 0.4.1	2010-01-03
 
  FEATURES
 
   * Add ObjectStore.iter_tree_contents(). (Jelmer Vernooij)
 
   * Add Index.changes_from_tree(). (Jelmer Vernooij)
 
   * Add ObjectStore.tree_changes(). (Jelmer Vernooij)
 
   * Add functionality for writing patches in dulwich.patch.
     (Jelmer Vernooij)
 
 0.4.0	2009-10-07
 
  DOCUMENTATION
 
   * Added tutorial.
 
  API CHANGES
 
   * dulwich.object_store.tree_lookup_path will now return the mode and 
     sha of the object found rather than the object itself.
 
  BUG FIXES
 
   * Use binascii.hexlify / binascii.unhexlify for better performance.
 
   * Cope with extra unknown data in index files by ignoring it (for now).
 
   * Add proper error message when server unexpectedly hangs up. (#415843)
 
   * Correctly write opcode for equal in create_delta.
 
 0.3.3	2009-07-23
 
  FEATURES
 
   * Implement ShaFile.__hash__().
 
   * Implement Tree.__len__()
 
  BUG FIXES
   
   * Check for 'objects' and 'refs' directories
     when looking for a Git repository. (#380818)
 
 0.3.2	2009-05-20
 
  BUG FIXES
 
   * Support the encoding field in Commits.
   
   * Some Windows compatibility fixes.
 
   * Fixed several issues in commit support.
 
  FEATURES
 
   * Basic support for handling submodules.
 
 0.3.1	2009-05-13
 
  FEATURES
 
   * Implemented Repo.__getitem__, Repo.__setitem__ and Repo.__delitem__ to 
     access content.
 
  API CHANGES
 
   * Removed Repo.set_ref, Repo.remove_ref, Repo.tags, Repo.get_refs and 
     Repo.heads in favor of Repo.refs, a dictionary-like object for accessing
     refs.
 
  BUG FIXES
 
   * Removed import of 'sha' module in objects.py, which was causing 
     deprecation warnings on Python 2.6.
 
 0.3.0	2009-05-10
 
  FEATURES
 
   * A new function 'commit_tree' has been added that can commit a tree 
     based on an index.
 
  BUG FIXES
 
   * The memory usage when generating indexes has been significantly reduced.
  
   * A memory leak in the C implementation of parse_tree has been fixed.
 
   * The send-pack smart server command now works. (Thanks Scott Chacon)
 
   * The handling of short timestamps (less than 10 digits) has been fixed.
 
   * The handling of timezones has been fixed.
 
 0.2.1	2009-04-30
 
  BUG FIXES
 
   * Fix compatibility with Python2.4.
 
 0.2.0	2009-04-30
 
  FEATURES
 
   * Support for activity reporting in smart protocol client.
 
   * Optional C extensions for better performance in a couple of 
     places that are performance-critical.
 
 0.1.1	2009-03-13
 
  BUG FIXES
 
   * Fixed regression in Repo.find_missing_objects()
 
   * Don't fetch ^{} objects from remote hosts, as requesting them 
     causes a hangup.
 
   * Always write pack to disk completely before calculating checksum.
 
  FEATURES
 
   * Allow disabling thin packs when talking to remote hosts.
 
 0.1.0	2009-01-24
 
   * Initial release.
diff --git a/dulwich/porcelain.py b/dulwich/porcelain.py
index d0666f38..35216d3c 100644
--- a/dulwich/porcelain.py
+++ b/dulwich/porcelain.py
@@ -1,1190 +1,1196 @@
 # porcelain.py -- Porcelain-like layer on top of Dulwich
 # Copyright (C) 2013 Jelmer Vernooij <jelmer@samba.org>
 #
 # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
 # General Public License as public by the Free Software Foundation; version 2.0
 # or (at your option) any later version. You can redistribute it and/or
 # modify it under the terms of either of these two licenses.
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # You should have received a copy of the licenses; if not, see
 # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
 # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
 # License, Version 2.0.
 #
 
 """Simple wrapper that provides porcelain-like functions on top of Dulwich.
 
 Currently implemented:
  * archive
  * add
  * branch{_create,_delete,_list}
  * check-ignore
  * checkout
  * clone
  * commit
  * commit-tree
  * daemon
  * diff-tree
  * fetch
  * init
  * ls-remote
  * ls-tree
  * pull
  * push
  * rm
  * remote{_add}
  * receive-pack
  * reset
  * rev-list
  * tag{_create,_delete,_list}
  * upload-pack
  * update-server-info
  * status
  * symbolic-ref
 
 These functions are meant to behave similarly to the git subcommands.
 Differences in behaviour are considered bugs.
 """
 
 from collections import namedtuple
 from contextlib import (
     closing,
     contextmanager,
 )
 from io import BytesIO
 import os
 import posixpath
 import stat
 import sys
 import time
 
 from dulwich.archive import (
     tar_stream,
     )
 from dulwich.client import (
     get_transport_and_path,
     )
 from dulwich.config import (
     StackedConfig,
     )
 from dulwich.diff_tree import (
     CHANGE_ADD,
     CHANGE_DELETE,
     CHANGE_MODIFY,
     CHANGE_RENAME,
     CHANGE_COPY,
     RENAME_CHANGE_TYPES,
     )
 from dulwich.errors import (
     SendPackError,
     UpdateRefsError,
     )
 from dulwich.ignore import IgnoreFilterManager
 from dulwich.index import (
     blob_from_path_and_stat,
     get_unstaged_changes,
     )
 from dulwich.object_store import (
     tree_lookup_path,
     )
 from dulwich.objects import (
     Commit,
     Tag,
     format_timezone,
     parse_timezone,
     pretty_format_tree_entry,
     )
 from dulwich.objectspec import (
     parse_commit,
     parse_object,
     parse_ref,
     parse_reftuples,
     parse_tree,
     )
 from dulwich.pack import (
     write_pack_index,
     write_pack_objects,
     )
 from dulwich.patch import write_tree_diff
 from dulwich.protocol import (
     Protocol,
     ZERO_SHA,
     )
 from dulwich.refs import ANNOTATED_TAG_SUFFIX
 from dulwich.repo import (BaseRepo, Repo)
 from dulwich.server import (
     FileSystemBackend,
     TCPGitServer,
     ReceivePackHandler,
     UploadPackHandler,
     update_server_info as server_update_server_info,
     )
 
 
 # Module level tuple definition for status output
 GitStatus = namedtuple('GitStatus', 'staged unstaged untracked')
 
 
 default_bytes_out_stream = getattr(sys.stdout, 'buffer', sys.stdout)
 default_bytes_err_stream = getattr(sys.stderr, 'buffer', sys.stderr)
 
 
 DEFAULT_ENCODING = 'utf-8'
 
 
 class RemoteExists(Exception):
     """Raised when the remote already exists."""
 
 
 def open_repo(path_or_repo):
     """Open an argument that can be a repository or a path for a repository."""
     if isinstance(path_or_repo, BaseRepo):
         return path_or_repo
     return Repo(path_or_repo)
 
 
 @contextmanager
 def _noop_context_manager(obj):
     """Context manager that has the same api as closing but does nothing."""
     yield obj
 
 
 def open_repo_closing(path_or_repo):
     """Open an argument that can be a repository or a path for a repository.
     returns a context manager that will close the repo on exit if the argument
     is a path, else does nothing if the argument is a repo.
     """
     if isinstance(path_or_repo, BaseRepo):
         return _noop_context_manager(path_or_repo)
     return closing(Repo(path_or_repo))
 
 
 def path_to_tree_path(repopath, path):
     """Convert a path to a path usable in e.g. an index.
 
     :param repo: Repository
     :param path: A path
     :return: A path formatted for use in e.g. an index
     """
     os.path.relpath(path, repopath)
     if os.path.sep != '/':
         path = path.replace(os.path.sep, '/')
     return path.encode(sys.getfilesystemencoding())
 
 
 def archive(repo, committish=None, outstream=default_bytes_out_stream,
             errstream=default_bytes_err_stream):
     """Create an archive.
 
     :param repo: Path of repository for which to generate an archive.
     :param committish: Commit SHA1 or ref to use
     :param outstream: Output stream (defaults to stdout)
     :param errstream: Error stream (defaults to stderr)
     """
 
     if committish is None:
         committish = "HEAD"
     with open_repo_closing(repo) as repo_obj:
         c = repo_obj[committish]
         for chunk in tar_stream(
                 repo_obj.object_store, repo_obj.object_store[c.tree],
                 c.commit_time):
             outstream.write(chunk)
 
 
 def update_server_info(repo="."):
     """Update server info files for a repository.
 
     :param repo: path to the repository
     """
     with open_repo_closing(repo) as r:
         server_update_server_info(r)
 
 
 def symbolic_ref(repo, ref_name, force=False):
     """Set git symbolic ref into HEAD.
 
     :param repo: path to the repository
     :param ref_name: short name of the new ref
     :param force: force settings without checking if it exists in refs/heads
     """
     with open_repo_closing(repo) as repo_obj:
         ref_path = b'refs/heads/' + ref_name
         if not force and ref_path not in repo_obj.refs.keys():
             raise ValueError('fatal: ref `%s` is not a ref' % ref_name)
         repo_obj.refs.set_symbolic_ref(b'HEAD', ref_path)
 
 
 def commit(repo=".", message=None, author=None, committer=None):
     """Create a new commit.
 
     :param repo: Path to repository
     :param message: Optional commit message
     :param author: Optional author name and email
     :param committer: Optional committer name and email
     :return: SHA1 of the new commit
     """
     # FIXME: Support --all argument
     # FIXME: Support --signoff argument
     with open_repo_closing(repo) as r:
         return r.do_commit(message=message, author=author, committer=committer)
 
 
 def commit_tree(repo, tree, message=None, author=None, committer=None):
     """Create a new commit object.
 
     :param repo: Path to repository
     :param tree: An existing tree object
     :param author: Optional author name and email
     :param committer: Optional committer name and email
     """
     with open_repo_closing(repo) as r:
         return r.do_commit(
             message=message, tree=tree, committer=committer, author=author)
 
 
 def init(path=".", bare=False):
     """Create a new git repository.
 
     :param path: Path to repository.
     :param bare: Whether to create a bare repository.
     :return: A Repo instance
     """
     if not os.path.exists(path):
         os.mkdir(path)
 
     if bare:
         return Repo.init_bare(path)
     else:
         return Repo.init(path)
 
 
 def clone(source, target=None, bare=False, checkout=None,
           errstream=default_bytes_err_stream, outstream=None,
           origin=b"origin", **kwargs):
     """Clone a local or remote git repository.
 
     :param source: Path or URL for source repository
     :param target: Path to target repository (optional)
     :param bare: Whether or not to create a bare repository
     :param checkout: Whether or not to check-out HEAD after cloning
     :param errstream: Optional stream to write progress to
     :param outstream: Optional stream to write progress to (deprecated)
     :param origin: Name of remote from the repository used to clone
     :return: The new repository
     """
     if outstream is not None:
         import warnings
         warnings.warn(
             "outstream= has been deprecated in favour of errstream=.",
             DeprecationWarning, stacklevel=3)
         errstream = outstream
 
     if checkout is None:
         checkout = (not bare)
     if checkout and bare:
         raise ValueError("checkout and bare are incompatible")
 
     config = StackedConfig.default()
     client, host_path = get_transport_and_path(source, config=config, **kwargs)
 
     if target is None:
         target = host_path.split("/")[-1]
 
     if not os.path.exists(target):
         os.mkdir(target)
 
     if bare:
         r = Repo.init_bare(target)
     else:
         r = Repo.init(target)
     try:
         fetch_result = client.fetch(
             host_path, r, determine_wants=r.object_store.determine_wants_all,
             progress=errstream.write)
+        ref_message = b"clone: from " + source.encode('utf-8')
         r.refs.import_refs(
             b'refs/remotes/' + origin,
             {n[len(b'refs/heads/'):]: v for (n, v) in fetch_result.refs.items()
-                if n.startswith(b'refs/heads/')})
+                if n.startswith(b'refs/heads/')},
+            message=ref_message)
         r.refs.import_refs(
             b'refs/tags',
             {n[len(b'refs/tags/'):]: v for (n, v) in fetch_result.refs.items()
                 if n.startswith(b'refs/tags/') and
-                not n.endswith(ANNOTATED_TAG_SUFFIX)})
+                not n.endswith(ANNOTATED_TAG_SUFFIX)},
+            message=ref_message)
         target_config = r.get_config()
         if not isinstance(source, bytes):
             source = source.encode(DEFAULT_ENCODING)
         target_config.set((b'remote', origin), b'url', source)
         target_config.set(
             (b'remote', origin), b'fetch',
             b'+refs/heads/*:refs/remotes/' + origin + b'/*')
         target_config.write_to_path()
         # TODO(jelmer): Support symref capability,
         # https://github.com/jelmer/dulwich/issues/485
         try:
             head = r[fetch_result.refs[b"HEAD"]]
         except KeyError:
             head = None
         else:
             r[b'HEAD'] = head.id
         if checkout and not bare and head is not None:
             errstream.write(b'Checking out ' + head.id + b'\n')
             r.reset_index(head.tree)
     except BaseException:
         r.close()
         raise
 
     return r
 
 
 def add(repo=".", paths=None):
     """Add files to the staging area.
 
     :param repo: Repository for the files
     :param paths: Paths to add.  No value passed stages all modified files.
     :return: Tuple with set of added files and ignored files
     """
     ignored = set()
     with open_repo_closing(repo) as r:
         ignore_manager = IgnoreFilterManager.from_repo(r)
         if not paths:
             paths = list(
                 get_untracked_paths(os.getcwd(), r.path, r.open_index()))
         relpaths = []
         if not isinstance(paths, list):
             paths = [paths]
         for p in paths:
             relpath = os.path.relpath(p, r.path)
             if relpath.startswith('../'):
                 raise ValueError('path %r is not in repo' % relpath)
             # FIXME: Support patterns, directories.
             if ignore_manager.is_ignored(relpath):
                 ignored.add(relpath)
                 continue
             relpaths.append(relpath)
         r.stage(relpaths)
     return (relpaths, ignored)
 
 
 def remove(repo=".", paths=None, cached=False):
     """Remove files from the staging area.
 
     :param repo: Repository for the files
     :param paths: Paths to remove
     """
     with open_repo_closing(repo) as r:
         index = r.open_index()
         for p in paths:
             full_path = os.path.abspath(p).encode(sys.getfilesystemencoding())
             tree_path = path_to_tree_path(r.path, p)
             try:
                 index_sha = index[tree_path].sha
             except KeyError:
                 raise Exception('%s did not match any files' % p)
 
             if not cached:
                 try:
                     st = os.lstat(full_path)
                 except OSError:
                     pass
                 else:
                     try:
                         blob = blob_from_path_and_stat(full_path, st)
                     except IOError:
                         pass
                     else:
                         try:
                             committed_sha = tree_lookup_path(
                                 r.__getitem__, r[r.head()].tree, tree_path)[1]
                         except KeyError:
                             committed_sha = None
 
                         if blob.id != index_sha and index_sha != committed_sha:
                             raise Exception(
                                 'file has staged content differing '
                                 'from both the file and head: %s' % p)
 
                         if index_sha != committed_sha:
                             raise Exception(
                                 'file has staged changes: %s' % p)
                         os.remove(full_path)
             del index[tree_path]
         index.write()
 
 
 rm = remove
 
 
 def commit_decode(commit, contents, default_encoding=DEFAULT_ENCODING):
     if commit.encoding is not None:
         return contents.decode(commit.encoding, "replace")
     return contents.decode(default_encoding, "replace")
 
 
 def print_commit(commit, decode, outstream=sys.stdout):
     """Write a human-readable commit log entry.
 
     :param commit: A `Commit` object
     :param outstream: A stream file to write to
     """
     outstream.write("-" * 50 + "\n")
     outstream.write("commit: " + commit.id.decode('ascii') + "\n")
     if len(commit.parents) > 1:
         outstream.write(
             "merge: " +
             "...".join([c.decode('ascii') for c in commit.parents[1:]]) + "\n")
     outstream.write("Author: " + decode(commit.author) + "\n")
     if commit.author != commit.committer:
         outstream.write("Committer: " + decode(commit.committer) + "\n")
 
     time_tuple = time.gmtime(commit.author_time + commit.author_timezone)
     time_str = time.strftime("%a %b %d %Y %H:%M:%S", time_tuple)
     timezone_str = format_timezone(commit.author_timezone).decode('ascii')
     outstream.write("Date:   " + time_str + " " + timezone_str + "\n")
     outstream.write("\n")
     outstream.write(decode(commit.message) + "\n")
     outstream.write("\n")
 
 
 def print_tag(tag, decode, outstream=sys.stdout):
     """Write a human-readable tag.
 
     :param tag: A `Tag` object
     :param decode: Function for decoding bytes to unicode string
     :param outstream: A stream to write to
     """
     outstream.write("Tagger: " + decode(tag.tagger) + "\n")
     outstream.write("Date:   " + decode(tag.tag_time) + "\n")
     outstream.write("\n")
     outstream.write(decode(tag.message) + "\n")
     outstream.write("\n")
 
 
 def show_blob(repo, blob, decode, outstream=sys.stdout):
     """Write a blob to a stream.
 
     :param repo: A `Repo` object
     :param blob: A `Blob` object
     :param decode: Function for decoding bytes to unicode string
     :param outstream: A stream file to write to
     """
     outstream.write(decode(blob.data))
 
 
 def show_commit(repo, commit, decode, outstream=sys.stdout):
     """Show a commit to a stream.
 
     :param repo: A `Repo` object
     :param commit: A `Commit` object
     :param decode: Function for decoding bytes to unicode string
     :param outstream: Stream to write to
     """
     print_commit(commit, decode=decode, outstream=outstream)
     if commit.parents:
         parent_commit = repo[commit.parents[0]]
         base_tree = parent_commit.tree
     else:
         base_tree = None
     diffstream = BytesIO()
     write_tree_diff(
         diffstream,
         repo.object_store, base_tree, commit.tree)
     diffstream.seek(0)
     outstream.write(
         diffstream.getvalue().decode(
                 commit.encoding or DEFAULT_ENCODING, 'replace'))
 
 
 def show_tree(repo, tree, decode, outstream=sys.stdout):
     """Print a tree to a stream.
 
     :param repo: A `Repo` object
     :param tree: A `Tree` object
     :param decode: Function for decoding bytes to unicode string
     :param outstream: Stream to write to
     """
     for n in tree:
         outstream.write(decode(n) + "\n")
 
 
 def show_tag(repo, tag, decode, outstream=sys.stdout):
     """Print a tag to a stream.
 
     :param repo: A `Repo` object
     :param tag: A `Tag` object
     :param decode: Function for decoding bytes to unicode string
     :param outstream: Stream to write to
     """
     print_tag(tag, decode, outstream)
     show_object(repo, repo[tag.object[1]], outstream)
 
 
 def show_object(repo, obj, decode, outstream):
     return {
         b"tree": show_tree,
         b"blob": show_blob,
         b"commit": show_commit,
         b"tag": show_tag,
             }[obj.type_name](repo, obj, decode, outstream)
 
 
 def print_name_status(changes):
     """Print a simple status summary, listing changed files.
     """
     for change in changes:
         if not change:
             continue
         if isinstance(change, list):
             change = change[0]
         if change.type == CHANGE_ADD:
             path1 = change.new.path
             path2 = ''
             kind = 'A'
         elif change.type == CHANGE_DELETE:
             path1 = change.old.path
             path2 = ''
             kind = 'D'
         elif change.type == CHANGE_MODIFY:
             path1 = change.new.path
             path2 = ''
             kind = 'M'
         elif change.type in RENAME_CHANGE_TYPES:
             path1 = change.old.path
             path2 = change.new.path
             if change.type == CHANGE_RENAME:
                 kind = 'R'
             elif change.type == CHANGE_COPY:
                 kind = 'C'
         yield '%-8s%-20s%-20s' % (kind, path1, path2)
 
 
 def log(repo=".", paths=None, outstream=sys.stdout, max_entries=None,
         reverse=False, name_status=False):
     """Write commit logs.
 
     :param repo: Path to repository
     :param paths: Optional set of specific paths to print entries for
     :param outstream: Stream to write log output to
     :param reverse: Reverse order in which entries are printed
     :param name_status: Print name status
     :param max_entries: Optional maximum number of entries to display
     """
     with open_repo_closing(repo) as r:
         walker = r.get_walker(
             max_entries=max_entries, paths=paths, reverse=reverse)
         for entry in walker:
             def decode(x):
                 return commit_decode(entry.commit, x)
             print_commit(entry.commit, decode, outstream)
             if name_status:
                 outstream.writelines(
                     [l+'\n' for l in print_name_status(entry.changes())])
 
 
 # TODO(jelmer): better default for encoding?
 def show(repo=".", objects=None, outstream=sys.stdout,
          default_encoding=DEFAULT_ENCODING):
     """Print the changes in a commit.
 
     :param repo: Path to repository
     :param objects: Objects to show (defaults to [HEAD])
     :param outstream: Stream to write to
     :param default_encoding: Default encoding to use if none is set in the
         commit
     """
     if objects is None:
         objects = ["HEAD"]
     if not isinstance(objects, list):
         objects = [objects]
     with open_repo_closing(repo) as r:
         for objectish in objects:
             o = parse_object(r, objectish)
             if isinstance(o, Commit):
                 def decode(x):
                     return commit_decode(o, x, default_encoding)
             else:
                 def decode(x):
                     return x.decode(default_encoding)
             show_object(r, o, decode, outstream)
 
 
 def diff_tree(repo, old_tree, new_tree, outstream=sys.stdout):
     """Compares the content and mode of blobs found via two tree objects.
 
     :param repo: Path to repository
     :param old_tree: Id of old tree
     :param new_tree: Id of new tree
     :param outstream: Stream to write to
     """
     with open_repo_closing(repo) as r:
         write_tree_diff(outstream, r.object_store, old_tree, new_tree)
 
 
 def rev_list(repo, commits, outstream=sys.stdout):
     """Lists commit objects in reverse chronological order.
 
     :param repo: Path to repository
     :param commits: Commits over which to iterate
     :param outstream: Stream to write to
     """
     with open_repo_closing(repo) as r:
         for entry in r.get_walker(include=[r[c].id for c in commits]):
             outstream.write(entry.commit.id + b"\n")
 
 
 def tag(*args, **kwargs):
     import warnings
     warnings.warn("tag has been deprecated in favour of tag_create.",
                   DeprecationWarning)
     return tag_create(*args, **kwargs)
 
 
 def tag_create(
         repo, tag, author=None, message=None, annotated=False,
         objectish="HEAD", tag_time=None, tag_timezone=None):
     """Creates a tag in git via dulwich calls:
 
     :param repo: Path to repository
     :param tag: tag string
     :param author: tag author (optional, if annotated is set)
     :param message: tag message (optional)
     :param annotated: whether to create an annotated tag
     :param objectish: object the tag should point at, defaults to HEAD
     :param tag_time: Optional time for annotated tag
     :param tag_timezone: Optional timezone for annotated tag
     """
 
     with open_repo_closing(repo) as r:
         object = parse_object(r, objectish)
 
         if annotated:
             # Create the tag object
             tag_obj = Tag()
             if author is None:
                 # TODO(jelmer): Don't use repo private method.
                 author = r._get_user_identity()
             tag_obj.tagger = author
             tag_obj.message = message
             tag_obj.name = tag
             tag_obj.object = (type(object), object.id)
             if tag_time is None:
                 tag_time = int(time.time())
             tag_obj.tag_time = tag_time
             if tag_timezone is None:
                 # TODO(jelmer) Use current user timezone rather than UTC
                 tag_timezone = 0
             elif isinstance(tag_timezone, str):
                 tag_timezone = parse_timezone(tag_timezone)
             tag_obj.tag_timezone = tag_timezone
             r.object_store.add_object(tag_obj)
             tag_id = tag_obj.id
         else:
             tag_id = object.id
 
         r.refs[b'refs/tags/' + tag] = tag_id
 
 
 def list_tags(*args, **kwargs):
     import warnings
     warnings.warn("list_tags has been deprecated in favour of tag_list.",
                   DeprecationWarning)
     return tag_list(*args, **kwargs)
 
 
 def tag_list(repo, outstream=sys.stdout):
     """List all tags.
 
     :param repo: Path to repository
     :param outstream: Stream to write tags to
     """
     with open_repo_closing(repo) as r:
         tags = sorted(r.refs.as_dict(b"refs/tags"))
         return tags
 
 
 def tag_delete(repo, name):
     """Remove a tag.
 
     :param repo: Path to repository
     :param name: Name of tag to remove
     """
     with open_repo_closing(repo) as r:
         if isinstance(name, bytes):
             names = [name]
         elif isinstance(name, list):
             names = name
         else:
             raise TypeError("Unexpected tag name type %r" % name)
         for name in names:
             del r.refs[b"refs/tags/" + name]
 
 
 def reset(repo, mode, treeish="HEAD"):
     """Reset current HEAD to the specified state.
 
     :param repo: Path to repository
     :param mode: Mode ("hard", "soft", "mixed")
     :param treeish: Treeish to reset to
     """
 
     if mode != "hard":
         raise ValueError("hard is the only mode currently supported")
 
     with open_repo_closing(repo) as r:
         tree = parse_tree(r, treeish)
         r.reset_index(tree.id)
 
 
 def push(repo, remote_location, refspecs,
          outstream=default_bytes_out_stream,
          errstream=default_bytes_err_stream, **kwargs):
     """Remote push with dulwich via dulwich.client
 
     :param repo: Path to repository
     :param remote_location: Location of the remote
     :param refspecs: Refs to push to remote
     :param outstream: A stream file to write output
     :param errstream: A stream file to write errors
     """
 
     # Open the repo
     with open_repo_closing(repo) as r:
 
         # Get the client and path
         client, path = get_transport_and_path(
                 remote_location, config=r.get_config_stack(), **kwargs)
 
         selected_refs = []
 
         def update_refs(refs):
             selected_refs.extend(parse_reftuples(r.refs, refs, refspecs))
             new_refs = {}
             # TODO: Handle selected_refs == {None: None}
             for (lh, rh, force) in selected_refs:
                 if lh is None:
                     new_refs[rh] = ZERO_SHA
                 else:
                     new_refs[rh] = r.refs[lh]
             return new_refs
 
         err_encoding = getattr(errstream, 'encoding', None) or DEFAULT_ENCODING
         remote_location_bytes = client.get_url(path).encode(err_encoding)
         try:
             client.send_pack(
                 path, update_refs,
                 generate_pack_data=r.object_store.generate_pack_data,
                 progress=errstream.write)
             errstream.write(
                 b"Push to " + remote_location_bytes + b" successful.\n")
         except (UpdateRefsError, SendPackError) as e:
             errstream.write(b"Push to " + remote_location_bytes +
                             b" failed -> " + e.message.encode(err_encoding) +
                             b"\n")
 
 
 def pull(repo, remote_location=None, refspecs=None,
          outstream=default_bytes_out_stream,
          errstream=default_bytes_err_stream, **kwargs):
     """Pull from remote via dulwich.client
 
     :param repo: Path to repository
     :param remote_location: Location of the remote
     :param refspec: refspecs to fetch
     :param outstream: A stream file to write to output
     :param errstream: A stream file to write to errors
     """
     # Open the repo
     with open_repo_closing(repo) as r:
         if remote_location is None:
             # TODO(jelmer): Lookup 'remote' for current branch in config
             raise NotImplementedError(
                 "looking up remote from branch config not supported yet")
         if refspecs is None:
             refspecs = [b"HEAD"]
         selected_refs = []
 
         def determine_wants(remote_refs):
             selected_refs.extend(
                 parse_reftuples(remote_refs, r.refs, refspecs))
             return [remote_refs[lh] for (lh, rh, force) in selected_refs]
         client, path = get_transport_and_path(
                 remote_location, config=r.get_config_stack(), **kwargs)
         fetch_result = client.fetch(
             path, r, progress=errstream.write, determine_wants=determine_wants)
         for (lh, rh, force) in selected_refs:
             r.refs[rh] = fetch_result.refs[lh]
         if selected_refs:
             r[b'HEAD'] = fetch_result.refs[selected_refs[0][1]]
 
         # Perform 'git checkout .' - syncs staged changes
         tree = r[b"HEAD"].tree
         r.reset_index(tree=tree)
 
 
 def status(repo=".", ignored=False):
     """Returns staged, unstaged, and untracked changes relative to the HEAD.
 
     :param repo: Path to repository or repository object
     :param ignored: Whether to include ignoed files in `untracked`
     :return: GitStatus tuple,
         staged -    list of staged paths (diff index/HEAD)
         unstaged -  list of unstaged paths (diff index/working-tree)
         untracked - list of untracked, un-ignored & non-.git paths
     """
     with open_repo_closing(repo) as r:
         # 1. Get status of staged
         tracked_changes = get_tree_changes(r)
         # 2. Get status of unstaged
         index = r.open_index()
         unstaged_changes = list(get_unstaged_changes(index, r.path))
         ignore_manager = IgnoreFilterManager.from_repo(r)
         untracked_paths = get_untracked_paths(r.path, r.path, index)
         if ignored:
             untracked_changes = list(untracked_paths)
         else:
             untracked_changes = [
                     p for p in untracked_paths
                     if not ignore_manager.is_ignored(p)]
         return GitStatus(tracked_changes, unstaged_changes, untracked_changes)
 
 
 def get_untracked_paths(frompath, basepath, index):
     """Get untracked paths.
 
     ;param frompath: Path to walk
     :param basepath: Path to compare to
     :param index: Index to check against
     """
     # If nothing is specified, add all non-ignored files.
     for dirpath, dirnames, filenames in os.walk(frompath):
         # Skip .git and below.
         if '.git' in dirnames:
             dirnames.remove('.git')
             if dirpath != basepath:
                 continue
         if '.git' in filenames:
             filenames.remove('.git')
             if dirpath != basepath:
                 continue
         for filename in filenames:
             ap = os.path.join(dirpath, filename)
             ip = path_to_tree_path(basepath, ap)
             if ip not in index:
                 yield os.path.relpath(ap, frompath)
 
 
 def get_tree_changes(repo):
     """Return add/delete/modify changes to tree by comparing index to HEAD.
 
     :param repo: repo path or object
     :return: dict with lists for each type of change
     """
     with open_repo_closing(repo) as r:
         index = r.open_index()
 
         # Compares the Index to the HEAD & determines changes
         # Iterate through the changes and report add/delete/modify
         # TODO: call out to dulwich.diff_tree somehow.
         tracked_changes = {
             'add': [],
             'delete': [],
             'modify': [],
         }
         try:
             tree_id = r[b'HEAD'].tree
         except KeyError:
             tree_id = None
 
         for change in index.changes_from_tree(r.object_store, tree_id):
             if not change[0][0]:
                 tracked_changes['add'].append(change[0][1])
             elif not change[0][1]:
                 tracked_changes['delete'].append(change[0][0])
             elif change[0][0] == change[0][1]:
                 tracked_changes['modify'].append(change[0][0])
             else:
                 raise AssertionError('git mv ops not yet supported')
         return tracked_changes
 
 
 def daemon(path=".", address=None, port=None):
     """Run a daemon serving Git requests over TCP/IP.
 
     :param path: Path to the directory to serve.
     :param address: Optional address to listen on (defaults to ::)
     :param port: Optional port to listen on (defaults to TCP_GIT_PORT)
     """
     # TODO(jelmer): Support git-daemon-export-ok and --export-all.
     backend = FileSystemBackend(path)
     server = TCPGitServer(backend, address, port)
     server.serve_forever()
 
 
 def web_daemon(path=".", address=None, port=None):
     """Run a daemon serving Git requests over HTTP.
 
     :param path: Path to the directory to serve
     :param address: Optional address to listen on (defaults to ::)
     :param port: Optional port to listen on (defaults to 80)
     """
     from dulwich.web import (
         make_wsgi_chain,
         make_server,
         WSGIRequestHandlerLogger,
         WSGIServerLogger)
 
     backend = FileSystemBackend(path)
     app = make_wsgi_chain(backend)
     server = make_server(address, port, app,
                          handler_class=WSGIRequestHandlerLogger,
                          server_class=WSGIServerLogger)
     server.serve_forever()
 
 
 def upload_pack(path=".", inf=None, outf=None):
     """Upload a pack file after negotiating its contents using smart protocol.
 
     :param path: Path to the repository
     :param inf: Input stream to communicate with client
     :param outf: Output stream to communicate with client
     """
     if outf is None:
         outf = getattr(sys.stdout, 'buffer', sys.stdout)
     if inf is None:
         inf = getattr(sys.stdin, 'buffer', sys.stdin)
     path = os.path.expanduser(path)
     backend = FileSystemBackend(path)
 
     def send_fn(data):
         outf.write(data)
         outf.flush()
     proto = Protocol(inf.read, send_fn)
     handler = UploadPackHandler(backend, [path], proto)
     # FIXME: Catch exceptions and write a single-line summary to outf.
     handler.handle()
     return 0
 
 
 def receive_pack(path=".", inf=None, outf=None):
     """Receive a pack file after negotiating its contents using smart protocol.
 
     :param path: Path to the repository
     :param inf: Input stream to communicate with client
     :param outf: Output stream to communicate with client
     """
     if outf is None:
         outf = getattr(sys.stdout, 'buffer', sys.stdout)
     if inf is None:
         inf = getattr(sys.stdin, 'buffer', sys.stdin)
     path = os.path.expanduser(path)
     backend = FileSystemBackend(path)
 
     def send_fn(data):
         outf.write(data)
         outf.flush()
     proto = Protocol(inf.read, send_fn)
     handler = ReceivePackHandler(backend, [path], proto)
     # FIXME: Catch exceptions and write a single-line summary to outf.
     handler.handle()
     return 0
 
 
 def branch_delete(repo, name):
     """Delete a branch.
 
     :param repo: Path to the repository
     :param name: Name of the branch
     """
     with open_repo_closing(repo) as r:
         if isinstance(name, bytes):
             names = [name]
         elif isinstance(name, list):
             names = name
         else:
             raise TypeError("Unexpected branch name type %r" % name)
         for name in names:
             del r.refs[b"refs/heads/" + name]
 
 
 def branch_create(repo, name, objectish=None, force=False):
     """Create a branch.
 
     :param repo: Path to the repository
     :param name: Name of the new branch
     :param objectish: Target object to point new branch at (defaults to HEAD)
     :param force: Force creation of branch, even if it already exists
     """
     with open_repo_closing(repo) as r:
         if objectish is None:
             objectish = "HEAD"
         object = parse_object(r, objectish)
         refname = b"refs/heads/" + name
-        if refname in r.refs and not force:
-            raise KeyError("Branch with name %s already exists." % name)
-        r.refs[refname] = object.id
+        ref_message = b"branch: Created from " + objectish.encode('utf-8')
+        if force:
+            r.refs.set_if_equals(refname, None, object.id, message=ref_message)
+        else:
+            if not r.refs.add_if_new(refname, object.id, message=ref_message):
+                raise KeyError("Branch with name %s already exists." % name)
 
 
 def branch_list(repo):
     """List all branches.
 
     :param repo: Path to the repository
     """
     with open_repo_closing(repo) as r:
         return r.refs.keys(base=b"refs/heads/")
 
 
 def fetch(repo, remote_location, outstream=sys.stdout,
           errstream=default_bytes_err_stream, **kwargs):
     """Fetch objects from a remote server.
 
     :param repo: Path to the repository
     :param remote_location: String identifying a remote server
     :param outstream: Output stream (defaults to stdout)
     :param errstream: Error stream (defaults to stderr)
     :return: Dictionary with refs on the remote
     """
     with open_repo_closing(repo) as r:
         client, path = get_transport_and_path(
                 remote_location, config=r.get_config_stack(), **kwargs)
         remote_refs = client.fetch(path, r, progress=errstream.write)
     return remote_refs
 
 
 def ls_remote(remote, config=None, **kwargs):
     """List the refs in a remote.
 
     :param remote: Remote repository location
     :param config: Configuration to use
     :return: Dictionary with remote refs
     """
     if config is None:
         config = StackedConfig.default()
     client, host_path = get_transport_and_path(remote, config=config, **kwargs)
     return client.get_refs(host_path)
 
 
 def repack(repo):
     """Repack loose files in a repository.
 
     Currently this only packs loose objects.
 
     :param repo: Path to the repository
     """
     with open_repo_closing(repo) as r:
         r.object_store.pack_loose_objects()
 
 
 def pack_objects(repo, object_ids, packf, idxf, delta_window_size=None):
     """Pack objects into a file.
 
     :param repo: Path to the repository
     :param object_ids: List of object ids to write
     :param packf: File-like object to write to
     :param idxf: File-like object to write to (can be None)
     """
     with open_repo_closing(repo) as r:
         entries, data_sum = write_pack_objects(
             packf,
             r.object_store.iter_shas((oid, None) for oid in object_ids),
             delta_window_size=delta_window_size)
     if idxf is not None:
         entries = sorted([(k, v[0], v[1]) for (k, v) in entries.items()])
         write_pack_index(idxf, entries, data_sum)
 
 
 def ls_tree(repo, treeish=b"HEAD", outstream=sys.stdout, recursive=False,
             name_only=False):
     """List contents of a tree.
 
     :param repo: Path to the repository
     :param tree_ish: Tree id to list
     :param outstream: Output stream (defaults to stdout)
     :param recursive: Whether to recursively list files
     :param name_only: Only print item name
     """
     def list_tree(store, treeid, base):
         for (name, mode, sha) in store[treeid].iteritems():
             if base:
                 name = posixpath.join(base, name)
             if name_only:
                 outstream.write(name + b"\n")
             else:
                 outstream.write(pretty_format_tree_entry(name, mode, sha))
             if stat.S_ISDIR(mode):
                 list_tree(store, sha, name)
     with open_repo_closing(repo) as r:
         tree = parse_tree(r, treeish)
         list_tree(r.object_store, tree.id, "")
 
 
 def remote_add(repo, name, url):
     """Add a remote.
 
     :param repo: Path to the repository
     :param name: Remote name
     :param url: Remote URL
     """
     if not isinstance(name, bytes):
         name = name.encode(DEFAULT_ENCODING)
     if not isinstance(url, bytes):
         url = url.encode(DEFAULT_ENCODING)
     with open_repo_closing(repo) as r:
         c = r.get_config()
         section = (b'remote', name)
         if c.has_section(section):
             raise RemoteExists(section)
         c.set(section, b"url", url)
         c.write_to_path()
 
 
 def check_ignore(repo, paths, no_index=False):
     """Debug gitignore files.
 
     :param repo: Path to the repository
     :param paths: List of paths to check for
     :param no_index: Don't check index
     :return: List of ignored files
     """
     with open_repo_closing(repo) as r:
         index = r.open_index()
         ignore_manager = IgnoreFilterManager.from_repo(r)
         for path in paths:
             if os.path.isabs(path):
                 path = os.path.relpath(path, r.path)
             if not no_index and path_to_tree_path(r.path, path) in index:
                 continue
             if ignore_manager.is_ignored(path):
                 yield path
 
 
 def update_head(repo, target, detached=False, new_branch=None):
     """Update HEAD to point at a new branch/commit.
 
     Note that this does not actually update the working tree.
 
     :param repo: Path to the repository
     :param detach: Create a detached head
     :param target: Branch or committish to switch to
     :param new_branch: New branch to create
     """
     with open_repo_closing(repo) as r:
         if new_branch is not None:
             to_set = b"refs/heads/" + new_branch.encode(DEFAULT_ENCODING)
         else:
             to_set = b"HEAD"
         if detached:
             # TODO(jelmer): Provide some way so that the actual ref gets
             # updated rather than what it points to, so the delete isn't
             # necessary.
             del r.refs[to_set]
             r.refs[to_set] = parse_commit(r, target).id
         else:
             r.refs.set_symbolic_ref(to_set, parse_ref(r, target))
         if new_branch is not None:
             r.refs.set_symbolic_ref(b"HEAD", to_set)
diff --git a/dulwich/reflog.py b/dulwich/reflog.py
index 488a23ae..aec32e60 100644
--- a/dulwich/reflog.py
+++ b/dulwich/reflog.py
@@ -1,76 +1,76 @@
 # reflog.py -- Parsing and writing reflog files
 # Copyright (C) 2015 Jelmer Vernooij and others.
 #
 # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
 # General Public License as public by the Free Software Foundation; version 2.0
 # or (at your option) any later version. You can redistribute it and/or
 # modify it under the terms of either of these two licenses.
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # You should have received a copy of the licenses; if not, see
 # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
 # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
 # License, Version 2.0.
 #
 
 """Utilities for reading and generating reflogs.
 """
 
 import collections
 
 from dulwich.objects import (
     format_timezone,
     parse_timezone,
     ZERO_SHA,
     )
 
 Entry = collections.namedtuple(
     'Entry', ['old_sha', 'new_sha', 'committer', 'timestamp', 'timezone',
               'message'])
 
 
 def format_reflog_line(old_sha, new_sha, committer, timestamp, timezone,
                        message):
     """Generate a single reflog line.
 
     :param old_sha: Old Commit SHA
     :param new_sha: New Commit SHA
     :param committer: Committer name and e-mail
     :param timestamp: Timestamp
     :param timezone: Timezone
     :param message: Message
     """
     if old_sha is None:
         old_sha = ZERO_SHA
     return (old_sha + b' ' + new_sha + b' ' + committer + b' ' +
-            str(timestamp).encode('ascii') + b' ' +
+            str(int(timestamp)).encode('ascii') + b' ' +
             format_timezone(timezone) + b'\t' + message)
 
 
 def parse_reflog_line(line):
     """Parse a reflog line.
 
     :param line: Line to parse
     :return: Tuple of (old_sha, new_sha, committer, timestamp, timezone,
         message)
     """
     (begin, message) = line.split(b'\t', 1)
     (old_sha, new_sha, rest) = begin.split(b' ', 2)
     (committer, timestamp_str, timezone_str) = rest.rsplit(b' ', 2)
     return Entry(old_sha, new_sha, committer, int(timestamp_str),
                  parse_timezone(timezone_str)[0], message)
 
 
 def read_reflog(f):
     """Read reflog.
 
     :param f: File-like object
     :returns: Iterator over Entry objects
     """
     for l in f:
         yield parse_reflog_line(l)
diff --git a/dulwich/refs.py b/dulwich/refs.py
index ba00a8a2..2fc7b14c 100644
--- a/dulwich/refs.py
+++ b/dulwich/refs.py
@@ -1,821 +1,883 @@
 # refs.py -- For dealing with git refs
 # Copyright (C) 2008-2013 Jelmer Vernooij <jelmer@samba.org>
 #
 # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
 # General Public License as public by the Free Software Foundation; version 2.0
 # or (at your option) any later version. You can redistribute it and/or
 # modify it under the terms of either of these two licenses.
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # You should have received a copy of the licenses; if not, see
 # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
 # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
 # License, Version 2.0.
 #
 
 
 """Ref handling.
 
 """
 import errno
 import os
 import sys
 
 from dulwich.errors import (
     PackedRefsException,
     RefFormatError,
     )
 from dulwich.objects import (
     git_line,
     valid_hexsha,
     ZERO_SHA,
     )
 from dulwich.file import (
     GitFile,
     ensure_dir_exists,
     )
 
 
 SYMREF = b'ref: '
 LOCAL_BRANCH_PREFIX = b'refs/heads/'
 BAD_REF_CHARS = set(b'\177 ~^:?*[')
 ANNOTATED_TAG_SUFFIX = b'^{}'
 
 
 def parse_symref_value(contents):
     """Parse a symref value.
 
     :param contents: Contents to parse
     :return: Destination
     """
     if contents.startswith(SYMREF):
         return contents[len(SYMREF):].rstrip(b'\r\n')
     raise ValueError(contents)
 
 
 def check_ref_format(refname):
     """Check if a refname is correctly formatted.
 
     Implements all the same rules as git-check-ref-format[1].
 
     [1]
     http://www.kernel.org/pub/software/scm/git/docs/git-check-ref-format.html
 
     :param refname: The refname to check
     :return: True if refname is valid, False otherwise
     """
     # These could be combined into one big expression, but are listed
     # separately to parallel [1].
     if b'/.' in refname or refname.startswith(b'.'):
         return False
     if b'/' not in refname:
         return False
     if b'..' in refname:
         return False
     for i, c in enumerate(refname):
         if ord(refname[i:i+1]) < 0o40 or c in BAD_REF_CHARS:
             return False
     if refname[-1] in b'/.':
         return False
     if refname.endswith(b'.lock'):
         return False
     if b'@{' in refname:
         return False
     if b'\\' in refname:
         return False
     return True
 
 
 class RefsContainer(object):
     """A container for refs."""
 
-    def set_symbolic_ref(self, name, other):
+    def __init__(self, logger=None):
+        self._logger = logger
+
+    def _log(self, ref, old_sha, new_sha, committer=None, timestamp=None,
+             timezone=None, message=None):
+        if self._logger is None:
+            return
+        if message is None:
+            return
+        self._logger(ref, old_sha, new_sha, committer, timestamp,
+                     timezone, message)
+
+    def set_symbolic_ref(self, name, other, committer=None, timestamp=None,
+                         timezone=None, message=None):
         """Make a ref point at another ref.
 
         :param name: Name of the ref to set
         :param other: Name of the ref to point at
+        :param message: Optional message
         """
         raise NotImplementedError(self.set_symbolic_ref)
 
     def get_packed_refs(self):
         """Get contents of the packed-refs file.
 
         :return: Dictionary mapping ref names to SHA1s
 
         :note: Will return an empty dictionary when no packed-refs file is
             present.
         """
         raise NotImplementedError(self.get_packed_refs)
 
     def get_peeled(self, name):
         """Return the cached peeled value of a ref, if available.
 
         :param name: Name of the ref to peel
         :return: The peeled value of the ref. If the ref is known not point to
             a tag, this will be the SHA the ref refers to. If the ref may point
             to a tag, but no cached information is available, None is returned.
         """
         return None
 
-    def import_refs(self, base, other):
+    def import_refs(self, base, other, committer=None, timestamp=None,
+                    timezone=None, message=None):
         for name, value in other.items():
-            self[b'/'.join((base, name))] = value
+            self.set_if_equals(b'/'.join((base, name)), None, value, message=message)
 
     def allkeys(self):
         """All refs present in this container."""
         raise NotImplementedError(self.allkeys)
 
     def keys(self, base=None):
         """Refs present in this container.
 
         :param base: An optional base to return refs under.
         :return: An unsorted set of valid refs in this container, including
             packed refs.
         """
         if base is not None:
             return self.subkeys(base)
         else:
             return self.allkeys()
 
     def subkeys(self, base):
         """Refs present in this container under a base.
 
         :param base: The base to return refs under.
         :return: A set of valid refs in this container under the base; the base
             prefix is stripped from the ref names returned.
         """
         keys = set()
         base_len = len(base) + 1
         for refname in self.allkeys():
             if refname.startswith(base):
                 keys.add(refname[base_len:])
         return keys
 
     def as_dict(self, base=None):
         """Return the contents of this container as a dictionary.
 
         """
         ret = {}
         keys = self.keys(base)
         if base is None:
             base = b''
         else:
             base = base.rstrip(b'/')
         for key in keys:
             try:
                 ret[key] = self[(base + b'/' + key).strip(b'/')]
             except KeyError:
                 continue  # Unable to resolve
 
         return ret
 
     def _check_refname(self, name):
         """Ensure a refname is valid and lives in refs or is HEAD.
 
         HEAD is not a valid refname according to git-check-ref-format, but this
         class needs to be able to touch HEAD. Also, check_ref_format expects
         refnames without the leading 'refs/', but this class requires that
         so it cannot touch anything outside the refs dir (or HEAD).
 
         :param name: The name of the reference.
         :raises KeyError: if a refname is not HEAD or is otherwise not valid.
         """
         if name in (b'HEAD', b'refs/stash'):
             return
         if not name.startswith(b'refs/') or not check_ref_format(name[5:]):
             raise RefFormatError(name)
 
     def read_ref(self, refname):
         """Read a reference without following any references.
 
         :param refname: The name of the reference
         :return: The contents of the ref file, or None if it does
             not exist.
         """
         contents = self.read_loose_ref(refname)
         if not contents:
             contents = self.get_packed_refs().get(refname, None)
         return contents
 
     def read_loose_ref(self, name):
         """Read a loose reference and return its contents.
 
         :param name: the refname to read
         :return: The contents of the ref file, or None if it does
             not exist.
         """
         raise NotImplementedError(self.read_loose_ref)
 
     def follow(self, name):
         """Follow a reference name.
 
         :return: a tuple of (refnames, sha), wheres refnames are the names of
             references in the chain
         """
         contents = SYMREF + name
         depth = 0
         refnames = []
         while contents.startswith(SYMREF):
             refname = contents[len(SYMREF):]
             refnames.append(refname)
             contents = self.read_ref(refname)
             if not contents:
                 break
             depth += 1
             if depth > 5:
                 raise KeyError(name)
         return refnames, contents
 
     def _follow(self, name):
         import warnings
         warnings.warn(
             "RefsContainer._follow is deprecated. Use RefsContainer.follow "
             "instead.", DeprecationWarning)
         refnames, contents = self.follow(name)
         if not refnames:
             return (None, contents)
         return (refnames[-1], contents)
 
     def __contains__(self, refname):
         if self.read_ref(refname):
             return True
         return False
 
     def __getitem__(self, name):
         """Get the SHA1 for a reference name.
 
         This method follows all symbolic references.
         """
         _, sha = self.follow(name)
         if sha is None:
             raise KeyError(name)
         return sha
 
-    def set_if_equals(self, name, old_ref, new_ref):
+    def set_if_equals(self, name, old_ref, new_ref, committer=None,
+                      timestamp=None, timezone=None, message=None):
         """Set a refname to new_ref only if it currently equals old_ref.
 
         This method follows all symbolic references if applicable for the
         subclass, and can be used to perform an atomic compare-and-swap
         operation.
 
         :param name: The refname to set.
         :param old_ref: The old sha the refname must refer to, or None to set
             unconditionally.
         :param new_ref: The new sha the refname will refer to.
+        :param message: Message for reflog
         :return: True if the set was successful, False otherwise.
         """
         raise NotImplementedError(self.set_if_equals)
 
     def add_if_new(self, name, ref):
-        """Add a new reference only if it does not already exist."""
+        """Add a new reference only if it does not already exist.
+
+        :param name: Ref name
+        :param ref: Ref value
+        :param message: Message for reflog
+        """
         raise NotImplementedError(self.add_if_new)
 
     def __setitem__(self, name, ref):
         """Set a reference name to point to the given SHA1.
 
         This method follows all symbolic references if applicable for the
         subclass.
 
         :note: This method unconditionally overwrites the contents of a
             reference. To update atomically only if the reference has not
             changed, use set_if_equals().
         :param name: The refname to set.
         :param ref: The new sha the refname will refer to.
         """
         self.set_if_equals(name, None, ref)
 
-    def remove_if_equals(self, name, old_ref):
+    def remove_if_equals(self, name, old_ref, committer=None,
+                         timestamp=None, timezone=None, message=None):
         """Remove a refname only if it currently equals old_ref.
 
         This method does not follow symbolic references, even if applicable for
         the subclass. It can be used to perform an atomic compare-and-delete
         operation.
 
         :param name: The refname to delete.
         :param old_ref: The old sha the refname must refer to, or None to
             delete unconditionally.
+        :param message: Message for reflog
         :return: True if the delete was successful, False otherwise.
         """
         raise NotImplementedError(self.remove_if_equals)
 
     def __delitem__(self, name):
         """Remove a refname.
 
         This method does not follow symbolic references, even if applicable for
         the subclass.
 
         :note: This method unconditionally deletes the contents of a reference.
             To delete atomically only if the reference has not changed, use
             remove_if_equals().
 
         :param name: The refname to delete.
         """
         self.remove_if_equals(name, None)
 
     def get_symrefs(self):
         """Get a dict with all symrefs in this container.
 
         :return: Dictionary mapping source ref to target ref
         """
         ret = {}
         for src in self.allkeys():
             try:
                 dst = parse_symref_value(self.read_ref(src))
             except ValueError:
                 pass
             else:
                 ret[src] = dst
         return ret
 
 
 class DictRefsContainer(RefsContainer):
     """RefsContainer backed by a simple dict.
 
     This container does not support symbolic or packed references and is not
     threadsafe.
     """
 
-    def __init__(self, refs):
+    def __init__(self, refs, logger=None):
+        super(DictRefsContainer, self).__init__(logger=logger)
         self._refs = refs
         self._peeled = {}
 
     def allkeys(self):
         return self._refs.keys()
 
     def read_loose_ref(self, name):
         return self._refs.get(name, None)
 
     def get_packed_refs(self):
         return {}
 
-    def set_symbolic_ref(self, name, other):
+    def set_symbolic_ref(self, name, other, committer=None,
+                         timestamp=None, timezone=None, message=None):
+        old = self.follow(name)[-1]
         self._refs[name] = SYMREF + other
+        self._log(name, old, old, committer=committer, timestamp=timestamp,
+                  timezone=timezone, message=message)
 
-    def set_if_equals(self, name, old_ref, new_ref):
+    def set_if_equals(self, name, old_ref, new_ref, committer=None,
+                      timestamp=None, timezone=None, message=None):
         if old_ref is not None and self._refs.get(name, ZERO_SHA) != old_ref:
             return False
         realnames, _ = self.follow(name)
         for realname in realnames:
             self._check_refname(realname)
+            old = self._refs.get(realname)
             self._refs[realname] = new_ref
+            self._log(realname, old, new_ref, committer=committer,
+                      timestamp=timestamp, timezone=timezone, message=message)
         return True
 
-    def add_if_new(self, name, ref):
+    def add_if_new(self, name, ref, committer=None, timestamp=None,
+                   timezone=None, message=None):
         if name in self._refs:
             return False
         self._refs[name] = ref
+        self._log(name, None, ref, committer=committer, timestamp=timestamp,
+                  timezone=timezone, message=message)
         return True
 
-    def remove_if_equals(self, name, old_ref):
+    def remove_if_equals(self, name, old_ref, committer=None, timestamp=None,
+                         timezone=None, message=None):
         if old_ref is not None and self._refs.get(name, ZERO_SHA) != old_ref:
             return False
         try:
-            del self._refs[name]
+            old = self._refs.pop(name)
         except KeyError:
             pass
+        else:
+            self._log(name, old, None, committer=committer,
+                      timestamp=timestamp, timezone=timezone, message=message)
         return True
 
     def get_peeled(self, name):
         return self._peeled.get(name)
 
     def _update(self, refs):
         """Update multiple refs; intended only for testing."""
         # TODO(dborowitz): replace this with a public function that uses
         # set_if_equal.
         self._refs.update(refs)
 
     def _update_peeled(self, peeled):
         """Update cached peeled refs; intended only for testing."""
         self._peeled.update(peeled)
 
 
 class InfoRefsContainer(RefsContainer):
     """Refs container that reads refs from a info/refs file."""
 
     def __init__(self, f):
         self._refs = {}
         self._peeled = {}
         for l in f.readlines():
             sha, name = l.rstrip(b'\n').split(b'\t')
             if name.endswith(ANNOTATED_TAG_SUFFIX):
                 name = name[:-3]
                 if not check_ref_format(name):
                     raise ValueError("invalid ref name %r" % name)
                 self._peeled[name] = sha
             else:
                 if not check_ref_format(name):
                     raise ValueError("invalid ref name %r" % name)
                 self._refs[name] = sha
 
     def allkeys(self):
         return self._refs.keys()
 
     def read_loose_ref(self, name):
         return self._refs.get(name, None)
 
     def get_packed_refs(self):
         return {}
 
     def get_peeled(self, name):
         try:
             return self._peeled[name]
         except KeyError:
             return self._refs[name]
 
 
 class DiskRefsContainer(RefsContainer):
     """Refs container that reads refs from disk."""
 
-    def __init__(self, path, worktree_path=None):
+    def __init__(self, path, worktree_path=None, logger=None):
+        super(DiskRefsContainer, self).__init__(logger=logger)
         self.path = path
         self.worktree_path = worktree_path or path
         self._packed_refs = None
         self._peeled_refs = None
 
     def __repr__(self):
         return "%s(%r)" % (self.__class__.__name__, self.path)
 
     def subkeys(self, base):
         subkeys = set()
         path = self.refpath(base)
         for root, dirs, files in os.walk(path):
             dir = root[len(path):].strip(os.path.sep).replace(os.path.sep, "/")
             for filename in files:
                 refname = (("%s/%s" % (dir, filename))
                            .strip("/").encode(sys.getfilesystemencoding()))
                 # check_ref_format requires at least one /, so we prepend the
                 # base before calling it.
                 if check_ref_format(base + b'/' + refname):
                     subkeys.add(refname)
         for key in self.get_packed_refs():
             if key.startswith(base):
                 subkeys.add(key[len(base):].strip(b'/'))
         return subkeys
 
     def allkeys(self):
         allkeys = set()
         if os.path.exists(self.refpath(b'HEAD')):
             allkeys.add(b'HEAD')
         path = self.refpath(b'')
         for root, dirs, files in os.walk(self.refpath(b'refs')):
             dir = root[len(path):].strip(os.path.sep).replace(os.path.sep, "/")
             for filename in files:
                 refname = (
                     "%s/%s" % (dir, filename)).encode(
                             sys.getfilesystemencoding())
                 if check_ref_format(refname):
                     allkeys.add(refname)
         allkeys.update(self.get_packed_refs())
         return allkeys
 
     def refpath(self, name):
         """Return the disk path of a ref.
 
         """
         if (getattr(self.path, "encode", None) and
                 getattr(name, "decode", None)):
             name = name.decode(sys.getfilesystemencoding())
         if os.path.sep != "/":
             name = name.replace("/", os.path.sep)
         # TODO: as the 'HEAD' reference is working tree specific, it
         # should actually not be a part of RefsContainer
         if name == 'HEAD':
             return os.path.join(self.worktree_path, name)
         else:
             return os.path.join(self.path, name)
 
     def get_packed_refs(self):
         """Get contents of the packed-refs file.
 
         :return: Dictionary mapping ref names to SHA1s
 
         :note: Will return an empty dictionary when no packed-refs file is
             present.
         """
         # TODO: invalidate the cache on repacking
         if self._packed_refs is None:
             # set both to empty because we want _peeled_refs to be
             # None if and only if _packed_refs is also None.
             self._packed_refs = {}
             self._peeled_refs = {}
             path = os.path.join(self.path, 'packed-refs')
             try:
                 f = GitFile(path, 'rb')
             except IOError as e:
                 if e.errno == errno.ENOENT:
                     return {}
                 raise
             with f:
                 first_line = next(iter(f)).rstrip()
                 if (first_line.startswith(b'# pack-refs') and b' peeled' in
                         first_line):
                     for sha, name, peeled in read_packed_refs_with_peeled(f):
                         self._packed_refs[name] = sha
                         if peeled:
                             self._peeled_refs[name] = peeled
                 else:
                     f.seek(0)
                     for sha, name in read_packed_refs(f):
                         self._packed_refs[name] = sha
         return self._packed_refs
 
     def get_peeled(self, name):
         """Return the cached peeled value of a ref, if available.
 
         :param name: Name of the ref to peel
         :return: The peeled value of the ref. If the ref is known not point to
             a tag, this will be the SHA the ref refers to. If the ref may point
             to a tag, but no cached information is available, None is returned.
         """
         self.get_packed_refs()
         if self._peeled_refs is None or name not in self._packed_refs:
             # No cache: no peeled refs were read, or this ref is loose
             return None
         if name in self._peeled_refs:
             return self._peeled_refs[name]
         else:
             # Known not peelable
             return self[name]
 
     def read_loose_ref(self, name):
         """Read a reference file and return its contents.
 
         If the reference file a symbolic reference, only read the first line of
         the file. Otherwise, only read the first 40 bytes.
 
         :param name: the refname to read, relative to refpath
         :return: The contents of the ref file, or None if the file does not
             exist.
         :raises IOError: if any other error occurs
         """
         filename = self.refpath(name)
         try:
             with GitFile(filename, 'rb') as f:
                 header = f.read(len(SYMREF))
                 if header == SYMREF:
                     # Read only the first line
                     return header + next(iter(f)).rstrip(b'\r\n')
                 else:
                     # Read only the first 40 bytes
                     return header + f.read(40 - len(SYMREF))
         except IOError as e:
             if e.errno in (errno.ENOENT, errno.EISDIR):
                 return None
             raise
 
     def _remove_packed_ref(self, name):
         if self._packed_refs is None:
             return
         filename = os.path.join(self.path, 'packed-refs')
         # reread cached refs from disk, while holding the lock
         f = GitFile(filename, 'wb')
         try:
             self._packed_refs = None
             self.get_packed_refs()
 
             if name not in self._packed_refs:
                 return
 
             del self._packed_refs[name]
             if name in self._peeled_refs:
                 del self._peeled_refs[name]
             write_packed_refs(f, self._packed_refs, self._peeled_refs)
             f.close()
         finally:
             f.abort()
 
-    def set_symbolic_ref(self, name, other):
+    def set_symbolic_ref(self, name, other, committer=None, timestamp=None,
+                         timezone=None, message=None):
         """Make a ref point at another ref.
 
         :param name: Name of the ref to set
         :param other: Name of the ref to point at
+        :param message: Optional message to describe the change
         """
         self._check_refname(name)
         self._check_refname(other)
         filename = self.refpath(name)
         try:
             f = GitFile(filename, 'wb')
             try:
                 f.write(SYMREF + other + b'\n')
             except (IOError, OSError):
                 f.abort()
                 raise
+            else:
+                sha = self.follow(name)[-1]
+                self._log(name, sha, sha, committer=committer,
+                          timestamp=timestamp, timezone=timezone,
+                          message=message)
         finally:
             f.close()
 
-    def set_if_equals(self, name, old_ref, new_ref):
+    def set_if_equals(self, name, old_ref, new_ref, committer=None,
+                      timestamp=None, timezone=None, message=None):
         """Set a refname to new_ref only if it currently equals old_ref.
 
         This method follows all symbolic references, and can be used to perform
         an atomic compare-and-swap operation.
 
         :param name: The refname to set.
         :param old_ref: The old sha the refname must refer to, or None to set
             unconditionally.
         :param new_ref: The new sha the refname will refer to.
+        :param message: Set message for reflog
         :return: True if the set was successful, False otherwise.
         """
         self._check_refname(name)
         try:
             realnames, _ = self.follow(name)
             realname = realnames[-1]
         except (KeyError, IndexError):
             realname = name
         filename = self.refpath(realname)
         ensure_dir_exists(os.path.dirname(filename))
         with GitFile(filename, 'wb') as f:
             if old_ref is not None:
                 try:
                     # read again while holding the lock
                     orig_ref = self.read_loose_ref(realname)
                     if orig_ref is None:
                         orig_ref = self.get_packed_refs().get(
                                 realname, ZERO_SHA)
                     if orig_ref != old_ref:
                         f.abort()
                         return False
                 except (OSError, IOError):
                     f.abort()
                     raise
             try:
                 f.write(new_ref + b'\n')
             except (OSError, IOError):
                 f.abort()
                 raise
+            self._log(realname, old_ref, new_ref, committer=committer,
+                      timestamp=timestamp, timezone=timezone, message=message)
         return True
 
-    def add_if_new(self, name, ref):
+    def add_if_new(self, name, ref, committer=None, timestamp=None,
+                   timezone=None, message=None):
         """Add a new reference only if it does not already exist.
 
         This method follows symrefs, and only ensures that the last ref in the
         chain does not exist.
 
         :param name: The refname to set.
         :param ref: The new sha the refname will refer to.
+        :param message: Optional message for reflog
         :return: True if the add was successful, False otherwise.
         """
         try:
             realnames, contents = self.follow(name)
             if contents is not None:
                 return False
             realname = realnames[-1]
         except (KeyError, IndexError):
             realname = name
         self._check_refname(realname)
         filename = self.refpath(realname)
         ensure_dir_exists(os.path.dirname(filename))
         with GitFile(filename, 'wb') as f:
             if os.path.exists(filename) or name in self.get_packed_refs():
                 f.abort()
                 return False
             try:
                 f.write(ref + b'\n')
             except (OSError, IOError):
                 f.abort()
                 raise
+            else:
+                self._log(name, None, ref, committer=committer,
+                          timestamp=timestamp, timezone=timezone,
+                          message=message)
         return True
 
-    def remove_if_equals(self, name, old_ref):
+    def remove_if_equals(self, name, old_ref, committer=None, timestamp=None,
+                         timezone=None, message=None):
         """Remove a refname only if it currently equals old_ref.
 
         This method does not follow symbolic references. It can be used to
         perform an atomic compare-and-delete operation.
 
         :param name: The refname to delete.
         :param old_ref: The old sha the refname must refer to, or None to
             delete unconditionally.
+        :param message: Optional message
         :return: True if the delete was successful, False otherwise.
         """
         self._check_refname(name)
         filename = self.refpath(name)
         ensure_dir_exists(os.path.dirname(filename))
         f = GitFile(filename, 'wb')
         try:
             if old_ref is not None:
                 orig_ref = self.read_loose_ref(name)
                 if orig_ref is None:
                     orig_ref = self.get_packed_refs().get(name, ZERO_SHA)
                 if orig_ref != old_ref:
                     return False
             # may only be packed
             try:
                 os.remove(filename)
             except OSError as e:
                 if e.errno != errno.ENOENT:
                     raise
             self._remove_packed_ref(name)
+            self._log(name, old_ref, None, committer=committer,
+                      timestamp=timestamp, timezone=timezone, message=message)
         finally:
             # never write, we just wanted the lock
             f.abort()
         return True
 
 
 def _split_ref_line(line):
     """Split a single ref line into a tuple of SHA1 and name."""
     fields = line.rstrip(b'\n\r').split(b' ')
     if len(fields) != 2:
         raise PackedRefsException("invalid ref line %r" % line)
     sha, name = fields
     if not valid_hexsha(sha):
         raise PackedRefsException("Invalid hex sha %r" % sha)
     if not check_ref_format(name):
         raise PackedRefsException("invalid ref name %r" % name)
     return (sha, name)
 
 
 def read_packed_refs(f):
     """Read a packed refs file.
 
     :param f: file-like object to read from
     :return: Iterator over tuples with SHA1s and ref names.
     """
     for l in f:
         if l.startswith(b'#'):
             # Comment
             continue
         if l.startswith(b'^'):
             raise PackedRefsException(
               "found peeled ref in packed-refs without peeled")
         yield _split_ref_line(l)
 
 
 def read_packed_refs_with_peeled(f):
     """Read a packed refs file including peeled refs.
 
     Assumes the "# pack-refs with: peeled" line was already read. Yields tuples
     with ref names, SHA1s, and peeled SHA1s (or None).
 
     :param f: file-like object to read from, seek'ed to the second line
     """
     last = None
     for line in f:
         if line[0] == b'#':
             continue
         line = line.rstrip(b'\r\n')
         if line.startswith(b'^'):
             if not last:
                 raise PackedRefsException("unexpected peeled ref line")
             if not valid_hexsha(line[1:]):
                 raise PackedRefsException("Invalid hex sha %r" % line[1:])
             sha, name = _split_ref_line(last)
             last = None
             yield (sha, name, line[1:])
         else:
             if last:
                 sha, name = _split_ref_line(last)
                 yield (sha, name, None)
             last = line
     if last:
         sha, name = _split_ref_line(last)
         yield (sha, name, None)
 
 
 def write_packed_refs(f, packed_refs, peeled_refs=None):
     """Write a packed refs file.
 
     :param f: empty file-like object to write to
     :param packed_refs: dict of refname to sha of packed refs to write
     :param peeled_refs: dict of refname to peeled value of sha
     """
     if peeled_refs is None:
         peeled_refs = {}
     else:
         f.write(b'# pack-refs with: peeled\n')
     for refname in sorted(packed_refs.keys()):
         f.write(git_line(packed_refs[refname], refname))
         if refname in peeled_refs:
             f.write(b'^' + peeled_refs[refname] + b'\n')
 
 
 def read_info_refs(f):
     ret = {}
     for l in f.readlines():
         (sha, name) = l.rstrip(b"\r\n").split(b"\t", 1)
         ret[name] = sha
     return ret
 
 
 def write_info_refs(refs, store):
     """Generate info refs."""
     for name, sha in sorted(refs.items()):
         # get_refs() includes HEAD as a special case, but we don't want to
         # advertise it
         if name == b'HEAD':
             continue
         try:
             o = store[sha]
         except KeyError:
             continue
         peeled = store.peel_sha(sha)
         yield o.id + b'\t' + name + b'\n'
         if o.id != peeled.id:
             yield peeled.id + b'\t' + name + ANNOTATED_TAG_SUFFIX + b'\n'
 
 
 def is_local_branch(x):
     return x.startswith(b'refs/heads/')
diff --git a/dulwich/repo.py b/dulwich/repo.py
index 25b6c2fc..0c73873e 100644
--- a/dulwich/repo.py
+++ b/dulwich/repo.py
@@ -1,1166 +1,1219 @@
 # repo.py -- For dealing with git repositories.
 # Copyright (C) 2007 James Westby <jw+debian@jameswestby.net>
 # Copyright (C) 2008-2013 Jelmer Vernooij <jelmer@samba.org>
 #
 # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
 # General Public License as public by the Free Software Foundation; version 2.0
 # or (at your option) any later version. You can redistribute it and/or
 # modify it under the terms of either of these two licenses.
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # You should have received a copy of the licenses; if not, see
 # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
 # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
 # License, Version 2.0.
 #
 
 
 """Repository access.
 
 This module contains the base class for git repositories
 (BaseRepo) and an implementation which uses a repository on
 local disk (Repo).
 
 """
 
 from io import BytesIO
 import errno
 import os
 import sys
 import stat
+import time
 
 from dulwich.errors import (
     NoIndexPresent,
     NotBlobError,
     NotCommitError,
     NotGitRepository,
     NotTreeError,
     NotTagError,
     CommitError,
     RefFormatError,
     HookError,
     )
 from dulwich.file import (
     GitFile,
     )
 from dulwich.object_store import (
     DiskObjectStore,
     MemoryObjectStore,
     ObjectStoreGraphWalker,
     )
 from dulwich.objects import (
     check_hexsha,
     Blob,
     Commit,
     ShaFile,
     Tag,
     Tree,
     )
 
 from dulwich.hooks import (
     PreCommitShellHook,
     PostCommitShellHook,
     CommitMsgShellHook,
     )
 
 from dulwich.refs import (  # noqa: F401
     check_ref_format,
     RefsContainer,
     DictRefsContainer,
     InfoRefsContainer,
     DiskRefsContainer,
     read_packed_refs,
     read_packed_refs_with_peeled,
     write_packed_refs,
     SYMREF,
     )
 
 
 import warnings
 
 
 CONTROLDIR = '.git'
 OBJECTDIR = 'objects'
 REFSDIR = 'refs'
 REFSDIR_TAGS = 'tags'
 REFSDIR_HEADS = 'heads'
 INDEX_FILENAME = "index"
 COMMONDIR = 'commondir'
 GITDIR = 'gitdir'
 WORKTREES = 'worktrees'
 
 BASE_DIRECTORIES = [
     ["branches"],
     [REFSDIR],
     [REFSDIR, REFSDIR_TAGS],
     [REFSDIR, REFSDIR_HEADS],
     ["hooks"],
     ["info"]
     ]
 
 DEFAULT_REF = b'refs/heads/master'
 
 
 def parse_graftpoints(graftpoints):
     """Convert a list of graftpoints into a dict
 
     :param graftpoints: Iterator of graftpoint lines
 
     Each line is formatted as:
         <commit sha1> <parent sha1> [<parent sha1>]*
 
     Resulting dictionary is:
         <commit sha1>: [<parent sha1>*]
 
     https://git.wiki.kernel.org/index.php/GraftPoint
     """
     grafts = {}
     for l in graftpoints:
         raw_graft = l.split(None, 1)
 
         commit = raw_graft[0]
         if len(raw_graft) == 2:
             parents = raw_graft[1].split()
         else:
             parents = []
 
         for sha in [commit] + parents:
             check_hexsha(sha, 'Invalid graftpoint')
 
         grafts[commit] = parents
     return grafts
 
 
 def serialize_graftpoints(graftpoints):
     """Convert a dictionary of grafts into string
 
     The graft dictionary is:
         <commit sha1>: [<parent sha1>*]
 
     Each line is formatted as:
         <commit sha1> <parent sha1> [<parent sha1>]*
 
     https://git.wiki.kernel.org/index.php/GraftPoint
 
     """
     graft_lines = []
     for commit, parents in graftpoints.items():
         if parents:
             graft_lines.append(commit + b' ' + b' '.join(parents))
         else:
             graft_lines.append(commit)
     return b'\n'.join(graft_lines)
 
 
 class BaseRepo(object):
     """Base class for a git repository.
 
     :ivar object_store: Dictionary-like object for accessing
         the objects
     :ivar refs: Dictionary-like object with the refs in this
         repository
     """
 
     def __init__(self, object_store, refs):
         """Open a repository.
 
         This shouldn't be called directly, but rather through one of the
         base classes, such as MemoryRepo or Repo.
 
         :param object_store: Object store to use
         :param refs: Refs container to use
         """
         self.object_store = object_store
         self.refs = refs
 
         self._graftpoints = {}
         self.hooks = {}
 
     def _determine_file_mode(self):
         """Probe the file-system to determine whether permissions can be trusted.
 
         :return: True if permissions can be trusted, False otherwise.
         """
         raise NotImplementedError(self._determine_file_mode)
 
     def _init_files(self, bare):
         """Initialize a default set of named files."""
         from dulwich.config import ConfigFile
         self._put_named_file('description', b"Unnamed repository")
         f = BytesIO()
         cf = ConfigFile()
         cf.set(b"core", b"repositoryformatversion", b"0")
         if self._determine_file_mode():
             cf.set(b"core", b"filemode", True)
         else:
             cf.set(b"core", b"filemode", False)
 
         cf.set(b"core", b"bare", bare)
         cf.set(b"core", b"logallrefupdates", True)
         cf.write_to_file(f)
         self._put_named_file('config', f.getvalue())
         self._put_named_file(os.path.join('info', 'exclude'), b'')
 
     def get_named_file(self, path):
         """Get a file from the control dir with a specific name.
 
         Although the filename should be interpreted as a filename relative to
         the control dir in a disk-based Repo, the object returned need not be
         pointing to a file in that location.
 
         :param path: The path to the file, relative to the control dir.
         :return: An open file object, or None if the file does not exist.
         """
         raise NotImplementedError(self.get_named_file)
 
     def _put_named_file(self, path, contents):
         """Write a file to the control dir with the given name and contents.
 
         :param path: The path to the file, relative to the control dir.
         :param contents: A string to write to the file.
         """
         raise NotImplementedError(self._put_named_file)
 
     def open_index(self):
         """Open the index for this repository.
 
         :raise NoIndexPresent: If no index is present
         :return: The matching `Index`
         """
         raise NotImplementedError(self.open_index)
 
     def fetch(self, target, determine_wants=None, progress=None):
         """Fetch objects into another repository.
 
         :param target: The target repository
         :param determine_wants: Optional function to determine what refs to
             fetch.
         :param progress: Optional progress function
         :return: The local refs
         """
         if determine_wants is None:
             determine_wants = target.object_store.determine_wants_all
         target.object_store.add_objects(
             self.fetch_objects(determine_wants, target.get_graph_walker(),
                                progress))
         return self.get_refs()
 
     def fetch_objects(self, determine_wants, graph_walker, progress,
                       get_tagged=None):
         """Fetch the missing objects required for a set of revisions.
 
         :param determine_wants: Function that takes a dictionary with heads
             and returns the list of heads to fetch.
         :param graph_walker: Object that can iterate over the list of revisions
             to fetch and has an "ack" method that will be called to acknowledge
             that a revision is present.
         :param progress: Simple progress function that will be called with
             updated progress strings.
         :param get_tagged: Function that returns a dict of pointed-to sha ->
             tag sha for including tags.
         :return: iterator over objects, with __len__ implemented
         """
         wants = determine_wants(self.get_refs())
         if not isinstance(wants, list):
             raise TypeError("determine_wants() did not return a list")
 
         shallows = getattr(graph_walker, 'shallow', frozenset())
         unshallows = getattr(graph_walker, 'unshallow', frozenset())
 
         if wants == []:
             # TODO(dborowitz): find a way to short-circuit that doesn't change
             # this interface.
 
             if shallows or unshallows:
                 # Do not send a pack in shallow short-circuit path
                 return None
 
             return []
 
         # If the graph walker is set up with an implementation that can
         # ACK/NAK to the wire, it will write data to the client through
         # this call as a side-effect.
         haves = self.object_store.find_common_revisions(graph_walker)
 
         # Deal with shallow requests separately because the haves do
         # not reflect what objects are missing
         if shallows or unshallows:
             # TODO: filter the haves commits from iter_shas. the specific
             # commits aren't missing.
             haves = []
 
         def get_parents(commit):
             if commit.id in shallows:
                 return []
             return self.get_parents(commit.id, commit)
 
         return self.object_store.iter_shas(
           self.object_store.find_missing_objects(
               haves, wants, progress,
               get_tagged,
               get_parents=get_parents))
 
     def get_graph_walker(self, heads=None):
         """Retrieve a graph walker.
 
         A graph walker is used by a remote repository (or proxy)
         to find out which objects are present in this repository.
 
         :param heads: Repository heads to use (optional)
         :return: A graph walker object
         """
         if heads is None:
             heads = self.refs.as_dict(b'refs/heads').values()
         return ObjectStoreGraphWalker(heads, self.get_parents)
 
     def get_refs(self):
         """Get dictionary with all refs.
 
         :return: A ``dict`` mapping ref names to SHA1s
         """
         return self.refs.as_dict()
 
     def head(self):
         """Return the SHA1 pointed at by HEAD."""
         return self.refs[b'HEAD']
 
     def _get_object(self, sha, cls):
         assert len(sha) in (20, 40)
         ret = self.get_object(sha)
         if not isinstance(ret, cls):
             if cls is Commit:
                 raise NotCommitError(ret)
             elif cls is Blob:
                 raise NotBlobError(ret)
             elif cls is Tree:
                 raise NotTreeError(ret)
             elif cls is Tag:
                 raise NotTagError(ret)
             else:
                 raise Exception("Type invalid: %r != %r" % (
                   ret.type_name, cls.type_name))
         return ret
 
     def get_object(self, sha):
         """Retrieve the object with the specified SHA.
 
         :param sha: SHA to retrieve
         :return: A ShaFile object
         :raise KeyError: when the object can not be found
         """
         return self.object_store[sha]
 
     def get_parents(self, sha, commit=None):
         """Retrieve the parents of a specific commit.
 
         If the specific commit is a graftpoint, the graft parents
         will be returned instead.
 
         :param sha: SHA of the commit for which to retrieve the parents
         :param commit: Optional commit matching the sha
         :return: List of parents
         """
 
         try:
             return self._graftpoints[sha]
         except KeyError:
             if commit is None:
                 commit = self[sha]
             return commit.parents
 
     def get_config(self):
         """Retrieve the config object.
 
         :return: `ConfigFile` object for the ``.git/config`` file.
         """
         raise NotImplementedError(self.get_config)
 
     def get_description(self):
         """Retrieve the description for this repository.
 
         :return: String with the description of the repository
             as set by the user.
         """
         raise NotImplementedError(self.get_description)
 
     def set_description(self, description):
         """Set the description for this repository.
 
         :param description: Text to set as description for this repository.
         """
         raise NotImplementedError(self.set_description)
 
     def get_config_stack(self):
         """Return a config stack for this repository.
 
         This stack accesses the configuration for both this repository
         itself (.git/config) and the global configuration, which usually
         lives in ~/.gitconfig.
 
         :return: `Config` instance for this repository
         """
         from dulwich.config import StackedConfig
         backends = [self.get_config()] + StackedConfig.default_backends()
         return StackedConfig(backends, writable=backends[0])
 
     def get_peeled(self, ref):
         """Get the peeled value of a ref.
 
         :param ref: The refname to peel.
         :return: The fully-peeled SHA1 of a tag object, after peeling all
             intermediate tags; if the original ref does not point to a tag,
             this will equal the original SHA1.
         """
         cached = self.refs.get_peeled(ref)
         if cached is not None:
             return cached
         return self.object_store.peel_sha(self.refs[ref]).id
 
     def get_walker(self, include=None, *args, **kwargs):
         """Obtain a walker for this repository.
 
         :param include: Iterable of SHAs of commits to include along with their
             ancestors. Defaults to [HEAD]
         :param exclude: Iterable of SHAs of commits to exclude along with their
             ancestors, overriding includes.
         :param order: ORDER_* constant specifying the order of results.
             Anything other than ORDER_DATE may result in O(n) memory usage.
         :param reverse: If True, reverse the order of output, requiring O(n)
             memory.
         :param max_entries: The maximum number of entries to yield, or None for
             no limit.
         :param paths: Iterable of file or subtree paths to show entries for.
         :param rename_detector: diff.RenameDetector object for detecting
             renames.
         :param follow: If True, follow path across renames/copies. Forces a
             default rename_detector.
         :param since: Timestamp to list commits after.
         :param until: Timestamp to list commits before.
         :param queue_cls: A class to use for a queue of commits, supporting the
             iterator protocol. The constructor takes a single argument, the
             Walker.
         :return: A `Walker` object
         """
         from dulwich.walk import Walker
         if include is None:
             include = [self.head()]
         if isinstance(include, str):
             include = [include]
 
         kwargs['get_parents'] = lambda commit: self.get_parents(
             commit.id, commit)
 
         return Walker(self.object_store, include, *args, **kwargs)
 
     def __getitem__(self, name):
         """Retrieve a Git object by SHA1 or ref.
 
         :param name: A Git object SHA1 or a ref name
         :return: A `ShaFile` object, such as a Commit or Blob
         :raise KeyError: when the specified ref or object does not exist
         """
         if not isinstance(name, bytes):
             raise TypeError("'name' must be bytestring, not %.80s" %
                             type(name).__name__)
         if len(name) in (20, 40):
             try:
                 return self.object_store[name]
             except (KeyError, ValueError):
                 pass
         try:
             return self.object_store[self.refs[name]]
         except RefFormatError:
             raise KeyError(name)
 
     def __contains__(self, name):
         """Check if a specific Git object or ref is present.
 
         :param name: Git object SHA1 or ref name
         """
         if len(name) in (20, 40):
             return name in self.object_store or name in self.refs
         else:
             return name in self.refs
 
     def __setitem__(self, name, value):
         """Set a ref.
 
         :param name: ref name
         :param value: Ref value - either a ShaFile object, or a hex sha
         """
         if name.startswith(b"refs/") or name == b'HEAD':
             if isinstance(value, ShaFile):
                 self.refs[name] = value.id
             elif isinstance(value, bytes):
                 self.refs[name] = value
             else:
                 raise TypeError(value)
         else:
             raise ValueError(name)
 
     def __delitem__(self, name):
         """Remove a ref.
 
         :param name: Name of the ref to remove
         """
         if name.startswith(b"refs/") or name == b"HEAD":
             del self.refs[name]
         else:
             raise ValueError(name)
 
     def _get_user_identity(self):
         """Determine the identity to use for new commits.
         """
+        user = os.environ.get("GIT_COMMITTER_NAME")
+        email = os.environ.get("GIT_COMMITTER_EMAIL")
         config = self.get_config_stack()
-        return (config.get((b"user", ), b"name") + b" <" +
-                config.get((b"user", ), b"email") + b">")
+        if user is None:
+            try:
+                user = config.get((b"user", ), b"name")
+            except KeyError:
+                user = None
+        if email is None:
+            try:
+                email = config.get((b"user", ), b"email")
+            except KeyError:
+                email = None
+        if user is None:
+            import getpass
+            user = getpass.getuser()
+        if email is None:
+            import getpass, socket
+            email = b"%s@%s" % (getpass.getuser(), socket.gethostname())
+        return (user + b" <" + email + b">")
 
     def _add_graftpoints(self, updated_graftpoints):
         """Add or modify graftpoints
 
         :param updated_graftpoints: Dict of commit shas to list of parent shas
         """
 
         # Simple validation
         for commit, parents in updated_graftpoints.items():
             for sha in [commit] + parents:
                 check_hexsha(sha, 'Invalid graftpoint')
 
         self._graftpoints.update(updated_graftpoints)
 
     def _remove_graftpoints(self, to_remove=[]):
         """Remove graftpoints
 
         :param to_remove: List of commit shas
         """
         for sha in to_remove:
             del self._graftpoints[sha]
 
     def do_commit(self, message=None, committer=None,
                   author=None, commit_timestamp=None,
                   commit_timezone=None, author_timestamp=None,
                   author_timezone=None, tree=None, encoding=None,
                   ref=b'HEAD', merge_heads=None):
         """Create a new commit.
 
         :param message: Commit message
         :param committer: Committer fullname
         :param author: Author fullname (defaults to committer)
         :param commit_timestamp: Commit timestamp (defaults to now)
         :param commit_timezone: Commit timestamp timezone (defaults to GMT)
         :param author_timestamp: Author timestamp (defaults to commit
             timestamp)
         :param author_timezone: Author timestamp timezone
             (defaults to commit timestamp timezone)
         :param tree: SHA1 of the tree root to use (if not specified the
             current index will be committed).
         :param encoding: Encoding
         :param ref: Optional ref to commit to (defaults to current branch)
         :param merge_heads: Merge heads (defaults to .git/MERGE_HEADS)
         :return: New commit SHA1
         """
         import time
         c = Commit()
         if tree is None:
             index = self.open_index()
             c.tree = index.commit(self.object_store)
         else:
             if len(tree) != 40:
                 raise ValueError("tree must be a 40-byte hex sha string")
             c.tree = tree
 
         try:
             self.hooks['pre-commit'].execute()
         except HookError as e:
             raise CommitError(e)
         except KeyError:  # no hook defined, silent fallthrough
             pass
 
         if merge_heads is None:
             # FIXME: Read merge heads from .git/MERGE_HEADS
             merge_heads = []
         if committer is None:
-            # FIXME: Support GIT_COMMITTER_NAME/GIT_COMMITTER_EMAIL environment
-            # variables
             committer = self._get_user_identity()
         c.committer = committer
         if commit_timestamp is None:
             # FIXME: Support GIT_COMMITTER_DATE environment variable
             commit_timestamp = time.time()
         c.commit_time = int(commit_timestamp)
         if commit_timezone is None:
             # FIXME: Use current user timezone rather than UTC
             commit_timezone = 0
         c.commit_timezone = commit_timezone
         if author is None:
             # FIXME: Support GIT_AUTHOR_NAME/GIT_AUTHOR_EMAIL environment
             # variables
             author = committer
         c.author = author
         if author_timestamp is None:
             # FIXME: Support GIT_AUTHOR_DATE environment variable
             author_timestamp = commit_timestamp
         c.author_time = int(author_timestamp)
         if author_timezone is None:
             author_timezone = commit_timezone
         c.author_timezone = author_timezone
         if encoding is not None:
             c.encoding = encoding
         if message is None:
             # FIXME: Try to read commit message from .git/MERGE_MSG
             raise ValueError("No commit message specified")
 
         try:
             c.message = self.hooks['commit-msg'].execute(message)
             if c.message is None:
                 c.message = message
         except HookError as e:
             raise CommitError(e)
         except KeyError:  # no hook defined, message not modified
             c.message = message
 
         if ref is None:
             # Create a dangling commit
             c.parents = merge_heads
             self.object_store.add_object(c)
         else:
             try:
                 old_head = self.refs[ref]
                 c.parents = [old_head] + merge_heads
                 self.object_store.add_object(c)
-                ok = self.refs.set_if_equals(ref, old_head, c.id)
+                ok = self.refs.set_if_equals(
+                    ref, old_head, c.id, message=b"commit: " + message,
+                    committer=committer, timestamp=commit_timestamp,
+                    timezone=commit_timezone)
             except KeyError:
                 c.parents = merge_heads
                 self.object_store.add_object(c)
-                ok = self.refs.add_if_new(ref, c.id)
+                ok = self.refs.add_if_new(ref, c.id,
+                        message=b"commit: " + message,
+                        committer=committer, timestamp=commit_timestamp,
+                        timezone=commit_timezone)
             if not ok:
                 # Fail if the atomic compare-and-swap failed, leaving the
                 # commit and all its objects as garbage.
                 raise CommitError("%s changed during commit" % (ref,))
 
         try:
             self.hooks['post-commit'].execute()
         except HookError as e:  # silent failure
             warnings.warn("post-commit hook failed: %s" % e, UserWarning)
         except KeyError:  # no hook defined, silent fallthrough
             pass
 
         return c.id
 
 
 def read_gitfile(f):
     """Read a ``.git`` file.
 
     The first line of the file should start with "gitdir: "
 
     :param f: File-like object to read from
     :return: A path
     """
     cs = f.read()
     if not cs.startswith("gitdir: "):
         raise ValueError("Expected file to start with 'gitdir: '")
     return cs[len("gitdir: "):].rstrip("\n")
 
 
 class Repo(BaseRepo):
     """A git repository backed by local disk.
 
     To open an existing repository, call the contructor with
     the path of the repository.
 
     To create a new repository, use the Repo.init class method.
     """
 
     def __init__(self, root):
         hidden_path = os.path.join(root, CONTROLDIR)
         if os.path.isdir(os.path.join(hidden_path, OBJECTDIR)):
             self.bare = False
             self._controldir = hidden_path
         elif (os.path.isdir(os.path.join(root, OBJECTDIR)) and
               os.path.isdir(os.path.join(root, REFSDIR))):
             self.bare = True
             self._controldir = root
         elif os.path.isfile(hidden_path):
             self.bare = False
             with open(hidden_path, 'r') as f:
                 path = read_gitfile(f)
             self.bare = False
             self._controldir = os.path.join(root, path)
         else:
             raise NotGitRepository(
                 "No git repository was found at %(path)s" % dict(path=root)
             )
         commondir = self.get_named_file(COMMONDIR)
         if commondir is not None:
             with commondir:
                 self._commondir = os.path.join(
                     self.controldir(),
                     commondir.read().rstrip(b"\r\n").decode(
                         sys.getfilesystemencoding()))
         else:
             self._commondir = self._controldir
         self.path = root
         object_store = DiskObjectStore(
             os.path.join(self.commondir(), OBJECTDIR))
-        refs = DiskRefsContainer(self.commondir(), self._controldir)
+        refs = DiskRefsContainer(self.commondir(), self._controldir,
+                                 logger=self._write_reflog)
         BaseRepo.__init__(self, object_store, refs)
 
         self._graftpoints = {}
         graft_file = self.get_named_file(os.path.join("info", "grafts"),
                                          basedir=self.commondir())
         if graft_file:
             with graft_file:
                 self._graftpoints.update(parse_graftpoints(graft_file))
         graft_file = self.get_named_file("shallow",
                                          basedir=self.commondir())
         if graft_file:
             with graft_file:
                 self._graftpoints.update(parse_graftpoints(graft_file))
 
         self.hooks['pre-commit'] = PreCommitShellHook(self.controldir())
         self.hooks['commit-msg'] = CommitMsgShellHook(self.controldir())
         self.hooks['post-commit'] = PostCommitShellHook(self.controldir())
 
+    def _write_reflog(self, ref, old_sha, new_sha, committer, timestamp,
+                      timezone, message):
+        from .reflog import format_reflog_line
+        path = os.path.join(self.controldir(), 'logs', ref)
+        try:
+            os.makedirs(os.path.dirname(path))
+        except OSError, e:
+            if e.errno != errno.EEXIST:
+                raise
+        if committer is None:
+            committer = self._get_user_identity()
+        if timestamp is None:
+            timestamp = int(time.time())
+        if timezone is None:
+            timezone = 0  # FIXME
+        with open(path, 'ab') as f:
+            f.write(format_reflog_line(old_sha, new_sha, committer,
+                    timestamp, timezone, message) + b'\n')
+
     @classmethod
     def discover(cls, start='.'):
         """Iterate parent directories to discover a repository
 
         Return a Repo object for the first parent directory that looks like a
         Git repository.
 
         :param start: The directory to start discovery from (defaults to '.')
         """
         remaining = True
         path = os.path.abspath(start)
         while remaining:
             try:
                 return cls(path)
             except NotGitRepository:
                 path, remaining = os.path.split(path)
         raise NotGitRepository(
             "No git repository was found at %(path)s" % dict(path=start)
         )
 
     def controldir(self):
         """Return the path of the control directory."""
         return self._controldir
 
     def commondir(self):
         """Return the path of the common directory.
 
         For a main working tree, it is identical to controldir().
 
         For a linked working tree, it is the control directory of the
         main working tree."""
 
         return self._commondir
 
     def _determine_file_mode(self):
         """Probe the file-system to determine whether permissions can be trusted.
 
         :return: True if permissions can be trusted, False otherwise.
         """
         fname = os.path.join(self.path, '.probe-permissions')
         with open(fname, 'w') as f:
             f.write('')
 
         st1 = os.lstat(fname)
         os.chmod(fname, st1.st_mode ^ stat.S_IXUSR)
         st2 = os.lstat(fname)
 
         os.unlink(fname)
 
         mode_differs = st1.st_mode != st2.st_mode
         st2_has_exec = (st2.st_mode & stat.S_IXUSR) != 0
 
         return mode_differs and st2_has_exec
 
     def _put_named_file(self, path, contents):
         """Write a file to the control dir with the given name and contents.
 
         :param path: The path to the file, relative to the control dir.
         :param contents: A string to write to the file.
         """
         path = path.lstrip(os.path.sep)
         with GitFile(os.path.join(self.controldir(), path), 'wb') as f:
             f.write(contents)
 
     def get_named_file(self, path, basedir=None):
         """Get a file from the control dir with a specific name.
 
         Although the filename should be interpreted as a filename relative to
         the control dir in a disk-based Repo, the object returned need not be
         pointing to a file in that location.
 
         :param path: The path to the file, relative to the control dir.
         :param basedir: Optional argument that specifies an alternative to the
             control dir.
         :return: An open file object, or None if the file does not exist.
         """
         # TODO(dborowitz): sanitize filenames, since this is used directly by
         # the dumb web serving code.
         if basedir is None:
             basedir = self.controldir()
         path = path.lstrip(os.path.sep)
         try:
             return open(os.path.join(basedir, path), 'rb')
         except (IOError, OSError) as e:
             if e.errno == errno.ENOENT:
                 return None
             raise
 
     def index_path(self):
         """Return path to the index file."""
         return os.path.join(self.controldir(), INDEX_FILENAME)
 
     def open_index(self):
         """Open the index for this repository.
 
         :raise NoIndexPresent: If no index is present
         :return: The matching `Index`
         """
         from dulwich.index import Index
         if not self.has_index():
             raise NoIndexPresent()
         return Index(self.index_path())
 
     def has_index(self):
         """Check if an index is present."""
         # Bare repos must never have index files; non-bare repos may have a
         # missing index file, which is treated as empty.
         return not self.bare
 
     def stage(self, fs_paths):
         """Stage a set of paths.
 
         :param fs_paths: List of paths, relative to the repository path
         """
 
         root_path_bytes = self.path.encode(sys.getfilesystemencoding())
 
         if not isinstance(fs_paths, list):
             fs_paths = [fs_paths]
         from dulwich.index import (
             blob_from_path_and_stat,
             index_entry_from_stat,
             _fs_to_tree_path,
             )
         index = self.open_index()
         for fs_path in fs_paths:
             if not isinstance(fs_path, bytes):
                 fs_path = fs_path.encode(sys.getfilesystemencoding())
             if os.path.isabs(fs_path):
                 raise ValueError(
                     "path %r should be relative to "
                     "repository root, not absolute" % fs_path)
             tree_path = _fs_to_tree_path(fs_path)
             full_path = os.path.join(root_path_bytes, fs_path)
             try:
                 st = os.lstat(full_path)
             except OSError:
                 # File no longer exists
                 try:
                     del index[tree_path]
                 except KeyError:
                     pass  # already removed
             else:
                 if not stat.S_ISDIR(st.st_mode):
                     blob = blob_from_path_and_stat(full_path, st)
                     self.object_store.add_object(blob)
                     index[tree_path] = index_entry_from_stat(st, blob.id, 0)
                 else:
                     try:
                         del index[tree_path]
                     except KeyError:
                         pass
         index.write()
 
     def clone(self, target_path, mkdir=True, bare=False,
               origin=b"origin"):
         """Clone this repository.
 
         :param target_path: Target path
         :param mkdir: Create the target directory
         :param bare: Whether to create a bare repository
         :param origin: Base name for refs in target repository
             cloned from this repository
         :return: Created repository as `Repo`
         """
         if not bare:
             target = self.init(target_path, mkdir=mkdir)
         else:
             target = self.init_bare(target_path, mkdir=mkdir)
         self.fetch(target)
+        encoded_path = self.path
+        if not isinstance(encoded_path, bytes):
+            encoded_path = encoded_path.encode(sys.getfilesystemencoding())
+        ref_message = b"clone: from " + encoded_path
         target.refs.import_refs(
-            b'refs/remotes/' + origin, self.refs.as_dict(b'refs/heads'))
+            b'refs/remotes/' + origin, self.refs.as_dict(b'refs/heads'),
+            message=ref_message)
         target.refs.import_refs(
-            b'refs/tags', self.refs.as_dict(b'refs/tags'))
+            b'refs/tags', self.refs.as_dict(b'refs/tags'),
+            message=ref_message)
         try:
-            target.refs.add_if_new(DEFAULT_REF, self.refs[DEFAULT_REF])
+            target.refs.add_if_new(
+                    DEFAULT_REF, self.refs[DEFAULT_REF],
+                    message=ref_message)
         except KeyError:
             pass
         target_config = target.get_config()
-        encoded_path = self.path
-        if not isinstance(encoded_path, bytes):
-            encoded_path = encoded_path.encode(sys.getfilesystemencoding())
         target_config.set((b'remote', b'origin'), b'url', encoded_path)
         target_config.set((b'remote', b'origin'), b'fetch',
                           b'+refs/heads/*:refs/remotes/origin/*')
         target_config.write_to_path()
 
         # Update target head
         head_chain, head_sha = self.refs.follow(b'HEAD')
         if head_chain and head_sha is not None:
-            target.refs.set_symbolic_ref(b'HEAD', head_chain[-1])
+            target.refs.set_symbolic_ref(b'HEAD', head_chain[-1],
+                                         message=ref_message)
             target[b'HEAD'] = head_sha
 
             if not bare:
                 # Checkout HEAD to target dir
                 target.reset_index()
 
         return target
 
     def reset_index(self, tree=None):
         """Reset the index back to a specific tree.
 
         :param tree: Tree SHA to reset to, None for current HEAD tree.
         """
         from dulwich.index import (
             build_index_from_tree,
             validate_path_element_default,
             validate_path_element_ntfs,
             )
         if tree is None:
             tree = self[b'HEAD'].tree
         config = self.get_config()
         honor_filemode = config.get_boolean(
             b'core', b'filemode', os.name != "nt")
         if config.get_boolean(b'core', b'core.protectNTFS', os.name == "nt"):
             validate_path_element = validate_path_element_ntfs
         else:
             validate_path_element = validate_path_element_default
         return build_index_from_tree(
             self.path, self.index_path(), self.object_store, tree,
             honor_filemode=honor_filemode,
             validate_path_element=validate_path_element)
 
     def get_config(self):
         """Retrieve the config object.
 
         :return: `ConfigFile` object for the ``.git/config`` file.
         """
         from dulwich.config import ConfigFile
         path = os.path.join(self._controldir, 'config')
         try:
             return ConfigFile.from_path(path)
         except (IOError, OSError) as e:
             if e.errno != errno.ENOENT:
                 raise
             ret = ConfigFile()
             ret.path = path
             return ret
 
     def get_description(self):
         """Retrieve the description of this repository.
 
         :return: A string describing the repository or None.
         """
         path = os.path.join(self._controldir, 'description')
         try:
             with GitFile(path, 'rb') as f:
                 return f.read()
         except (IOError, OSError) as e:
             if e.errno != errno.ENOENT:
                 raise
             return None
 
     def __repr__(self):
         return "<Repo at %r>" % self.path
 
     def set_description(self, description):
         """Set the description for this repository.
 
         :param description: Text to set as description for this repository.
         """
 
         self._put_named_file('description', description)
 
     @classmethod
     def _init_maybe_bare(cls, path, bare):
         for d in BASE_DIRECTORIES:
             os.mkdir(os.path.join(path, *d))
         DiskObjectStore.init(os.path.join(path, OBJECTDIR))
         ret = cls(path)
         ret.refs.set_symbolic_ref(b'HEAD', DEFAULT_REF)
         ret._init_files(bare)
         return ret
 
     @classmethod
     def init(cls, path, mkdir=False):
         """Create a new repository.
 
         :param path: Path in which to create the repository
         :param mkdir: Whether to create the directory
         :return: `Repo` instance
         """
         if mkdir:
             os.mkdir(path)
         controldir = os.path.join(path, CONTROLDIR)
         os.mkdir(controldir)
         cls._init_maybe_bare(controldir, False)
         return cls(path)
 
     @classmethod
     def _init_new_working_directory(cls, path, main_repo, identifier=None,
                                     mkdir=False):
         """Create a new working directory linked to a repository.
 
         :param path: Path in which to create the working tree.
         :param main_repo: Main repository to reference
         :param identifier: Worktree identifier
         :param mkdir: Whether to create the directory
         :return: `Repo` instance
         """
         if mkdir:
             os.mkdir(path)
         if identifier is None:
             identifier = os.path.basename(path)
         main_worktreesdir = os.path.join(main_repo.controldir(), WORKTREES)
         worktree_controldir = os.path.join(main_worktreesdir, identifier)
         gitdirfile = os.path.join(path, CONTROLDIR)
         with open(gitdirfile, 'wb') as f:
             f.write(b'gitdir: ' +
                     worktree_controldir.encode(sys.getfilesystemencoding()) +
                     b'\n')
         try:
             os.mkdir(main_worktreesdir)
         except OSError as e:
             if e.errno != errno.EEXIST:
                 raise
         try:
             os.mkdir(worktree_controldir)
         except OSError as e:
             if e.errno != errno.EEXIST:
                 raise
         with open(os.path.join(worktree_controldir, GITDIR), 'wb') as f:
             f.write(gitdirfile.encode(sys.getfilesystemencoding()) + b'\n')
         with open(os.path.join(worktree_controldir, COMMONDIR), 'wb') as f:
             f.write(b'../..\n')
         with open(os.path.join(worktree_controldir, 'HEAD'), 'wb') as f:
             f.write(main_repo.head() + b'\n')
         r = cls(path)
         r.reset_index()
         return r
 
     @classmethod
     def init_bare(cls, path, mkdir=False):
         """Create a new bare repository.
 
         ``path`` should already exist and be an empty directory.
 
         :param path: Path to create bare repository in
         :return: a `Repo` instance
         """
         if mkdir:
             os.mkdir(path)
         return cls._init_maybe_bare(path, True)
 
     create = init_bare
 
     def close(self):
         """Close any files opened by this repository."""
         self.object_store.close()
 
     def __enter__(self):
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
 
 
 class MemoryRepo(BaseRepo):
     """Repo that stores refs, objects, and named files in memory.
 
     MemoryRepos are always bare: they have no working tree and no index, since
     those have a stronger dependency on the filesystem.
     """
 
     def __init__(self):
         from dulwich.config import ConfigFile
-        BaseRepo.__init__(self, MemoryObjectStore(), DictRefsContainer({}))
+        self._reflog = []
+        refs_container = DictRefsContainer({}, logger=self._append_reflog)
+        BaseRepo.__init__(self, MemoryObjectStore(), refs_container)
         self._named_files = {}
         self.bare = True
         self._config = ConfigFile()
         self._description = None
 
+    def _append_reflog(self, *args):
+        self._reflog.append(args)
+
     def set_description(self, description):
         self._description = description
 
     def get_description(self):
         return self._description
 
     def _determine_file_mode(self):
         """Probe the file-system to determine whether permissions can be trusted.
 
         :return: True if permissions can be trusted, False otherwise.
         """
         return sys.platform != 'win32'
 
     def _put_named_file(self, path, contents):
         """Write a file to the control dir with the given name and contents.
 
         :param path: The path to the file, relative to the control dir.
         :param contents: A string to write to the file.
         """
         self._named_files[path] = contents
 
     def get_named_file(self, path):
         """Get a file from the control dir with a specific name.
 
         Although the filename should be interpreted as a filename relative to
         the control dir in a disk-baked Repo, the object returned need not be
         pointing to a file in that location.
 
         :param path: The path to the file, relative to the control dir.
         :return: An open file object, or None if the file does not exist.
         """
         contents = self._named_files.get(path, None)
         if contents is None:
             return None
         return BytesIO(contents)
 
     def open_index(self):
         """Fail to open index for this repo, since it is bare.
 
         :raise NoIndexPresent: Raised when no index is present
         """
         raise NoIndexPresent()
 
     def get_config(self):
         """Retrieve the config object.
 
         :return: `ConfigFile` object.
         """
         return self._config
 
     @classmethod
     def init_bare(cls, objects, refs):
         """Create a new bare repository in memory.
 
         :param objects: Objects for the new repository,
             as iterable
         :param refs: Refs as dictionary, mapping names
             to object SHA1s
         """
         ret = cls()
         for obj in objects:
             ret.object_store.add_object(obj)
         for refname, sha in refs.items():
-            ret.refs[refname] = sha
+            ret.refs.add_if_new(refname, sha)
         ret._init_files(bare=True)
         return ret
diff --git a/dulwich/tests/test_repository.py b/dulwich/tests/test_repository.py
index 3b361be0..14758f30 100644
--- a/dulwich/tests/test_repository.py
+++ b/dulwich/tests/test_repository.py
@@ -1,929 +1,929 @@
 # -*- coding: utf-8 -*-
 # test_repository.py -- tests for repository.py
 # Copyright (C) 2007 James Westby <jw+debian@jameswestby.net>
 #
 # Dulwich is dual-licensed under the Apache License, Version 2.0 and the GNU
 # General Public License as public by the Free Software Foundation; version 2.0
 # or (at your option) any later version. You can redistribute it and/or
 # modify it under the terms of either of these two licenses.
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 # You should have received a copy of the licenses; if not, see
 # <http://www.gnu.org/licenses/> for a copy of the GNU General Public License
 # and <http://www.apache.org/licenses/LICENSE-2.0> for a copy of the Apache
 # License, Version 2.0.
 #
 
 """Tests for the repository."""
 
 import locale
 import os
 import stat
 import shutil
 import sys
 import tempfile
 import warnings
 
 from dulwich import errors
 from dulwich.object_store import (
     tree_lookup_path,
     )
 from dulwich import objects
 from dulwich.config import Config
 from dulwich.errors import NotGitRepository
 from dulwich.repo import (
     Repo,
     MemoryRepo,
     )
 from dulwich.tests import (
     TestCase,
     skipIf,
     )
 from dulwich.tests.utils import (
     open_repo,
     tear_down_repo,
     setup_warning_catcher,
     )
 
 missing_sha = b'b91fa4d900e17e99b433218e988c4eb4a3e9a097'
 
 
 class CreateRepositoryTests(TestCase):
 
     def assertFileContentsEqual(self, expected, repo, path):
         f = repo.get_named_file(path)
         if not f:
             self.assertEqual(expected, None)
         else:
             with f:
                 self.assertEqual(expected, f.read())
 
     def _check_repo_contents(self, repo, expect_bare):
         self.assertEqual(expect_bare, repo.bare)
         self.assertFileContentsEqual(
             b'Unnamed repository', repo, 'description')
         self.assertFileContentsEqual(
             b'', repo, os.path.join('info', 'exclude'))
         self.assertFileContentsEqual(None, repo, 'nonexistent file')
         barestr = b'bare = ' + str(expect_bare).lower().encode('ascii')
         with repo.get_named_file('config') as f:
             config_text = f.read()
             self.assertTrue(barestr in config_text, "%r" % config_text)
         expect_filemode = sys.platform != 'win32'
         barestr = b'filemode = ' + str(expect_filemode).lower().encode('ascii')
         with repo.get_named_file('config') as f:
             config_text = f.read()
             self.assertTrue(barestr in config_text, "%r" % config_text)
 
     def test_create_memory(self):
         repo = MemoryRepo.init_bare([], {})
         self._check_repo_contents(repo, True)
 
     def test_create_disk_bare(self):
         tmp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo = Repo.init_bare(tmp_dir)
         self.assertEqual(tmp_dir, repo._controldir)
         self._check_repo_contents(repo, True)
 
     def test_create_disk_non_bare(self):
         tmp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo = Repo.init(tmp_dir)
         self.assertEqual(os.path.join(tmp_dir, '.git'), repo._controldir)
         self._check_repo_contents(repo, False)
 
     def test_create_disk_non_bare_mkdir(self):
         tmp_dir = tempfile.mkdtemp()
         target_dir = os.path.join(tmp_dir, "target")
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo = Repo.init(target_dir, mkdir=True)
         self.assertEqual(os.path.join(target_dir, '.git'), repo._controldir)
         self._check_repo_contents(repo, False)
 
     def test_create_disk_bare_mkdir(self):
         tmp_dir = tempfile.mkdtemp()
         target_dir = os.path.join(tmp_dir, "target")
         self.addCleanup(shutil.rmtree, tmp_dir)
         repo = Repo.init_bare(target_dir, mkdir=True)
         self.assertEqual(target_dir, repo._controldir)
         self._check_repo_contents(repo, True)
 
 
 class MemoryRepoTests(TestCase):
 
     def test_set_description(self):
         r = MemoryRepo.init_bare([], {})
         description = b"Some description"
         r.set_description(description)
         self.assertEqual(description, r.get_description())
 
 
 class RepositoryRootTests(TestCase):
 
     def mkdtemp(self):
         return tempfile.mkdtemp()
 
     def open_repo(self, name):
         temp_dir = self.mkdtemp()
         repo = open_repo(name, temp_dir)
         self.addCleanup(tear_down_repo, repo)
         return repo
 
     def test_simple_props(self):
         r = self.open_repo('a.git')
         self.assertEqual(r.controldir(), r.path)
 
     def test_setitem(self):
         r = self.open_repo('a.git')
         r[b"refs/tags/foo"] = b'a90fa2d900a17e99b433217e988c4eb4a2e9a097'
         self.assertEqual(b'a90fa2d900a17e99b433217e988c4eb4a2e9a097',
                          r[b"refs/tags/foo"].id)
 
     def test_getitem_unicode(self):
         r = self.open_repo('a.git')
 
         test_keys = [
             (b'refs/heads/master', True),
             (b'a90fa2d900a17e99b433217e988c4eb4a2e9a097', True),
             (b'11' * 19 + b'--', False),
         ]
 
         for k, contained in test_keys:
             self.assertEqual(k in r, contained)
 
         # Avoid deprecation warning under Py3.2+
         if getattr(self, 'assertRaisesRegex', None):
             assertRaisesRegexp = self.assertRaisesRegex
         else:
             assertRaisesRegexp = self.assertRaisesRegexp
         for k, _ in test_keys:
             assertRaisesRegexp(
                 TypeError, "'name' must be bytestring, not int",
                 r.__getitem__, 12
             )
 
     def test_delitem(self):
         r = self.open_repo('a.git')
 
         del r[b'refs/heads/master']
         self.assertRaises(KeyError, lambda: r[b'refs/heads/master'])
 
         del r[b'HEAD']
         self.assertRaises(KeyError, lambda: r[b'HEAD'])
 
         self.assertRaises(ValueError, r.__delitem__, b'notrefs/foo')
 
     def test_get_refs(self):
         r = self.open_repo('a.git')
         self.assertEqual({
             b'HEAD': b'a90fa2d900a17e99b433217e988c4eb4a2e9a097',
             b'refs/heads/master': b'a90fa2d900a17e99b433217e988c4eb4a2e9a097',
             b'refs/tags/mytag': b'28237f4dc30d0d462658d6b937b08a0f0b6ef55a',
             b'refs/tags/mytag-packed':
                 b'b0931cadc54336e78a1d980420e3268903b57a50',
             }, r.get_refs())
 
     def test_head(self):
         r = self.open_repo('a.git')
         self.assertEqual(r.head(), b'a90fa2d900a17e99b433217e988c4eb4a2e9a097')
 
     def test_get_object(self):
         r = self.open_repo('a.git')
         obj = r.get_object(r.head())
         self.assertEqual(obj.type_name, b'commit')
 
     def test_get_object_non_existant(self):
         r = self.open_repo('a.git')
         self.assertRaises(KeyError, r.get_object, missing_sha)
 
     def test_contains_object(self):
         r = self.open_repo('a.git')
         self.assertTrue(r.head() in r)
 
     def test_contains_ref(self):
         r = self.open_repo('a.git')
         self.assertTrue(b"HEAD" in r)
 
     def test_get_no_description(self):
         r = self.open_repo('a.git')
         self.assertIs(None, r.get_description())
 
     def test_get_description(self):
         r = self.open_repo('a.git')
         with open(os.path.join(r.path, 'description'), 'wb') as f:
             f.write(b"Some description")
         self.assertEqual(b"Some description", r.get_description())
 
     def test_set_description(self):
         r = self.open_repo('a.git')
         description = b"Some description"
         r.set_description(description)
         self.assertEqual(description, r.get_description())
 
     def test_contains_missing(self):
         r = self.open_repo('a.git')
         self.assertFalse(b"bar" in r)
 
     def test_get_peeled(self):
         # unpacked ref
         r = self.open_repo('a.git')
         tag_sha = b'28237f4dc30d0d462658d6b937b08a0f0b6ef55a'
         self.assertNotEqual(r[tag_sha].sha().hexdigest(), r.head())
         self.assertEqual(r.get_peeled(b'refs/tags/mytag'), r.head())
 
         # packed ref with cached peeled value
         packed_tag_sha = b'b0931cadc54336e78a1d980420e3268903b57a50'
         parent_sha = r[r.head()].parents[0]
         self.assertNotEqual(r[packed_tag_sha].sha().hexdigest(), parent_sha)
         self.assertEqual(r.get_peeled(b'refs/tags/mytag-packed'), parent_sha)
 
         # TODO: add more corner cases to test repo
 
     def test_get_peeled_not_tag(self):
         r = self.open_repo('a.git')
         self.assertEqual(r.get_peeled(b'HEAD'), r.head())
 
     def test_get_walker(self):
         r = self.open_repo('a.git')
         # include defaults to [r.head()]
         self.assertEqual(
             [e.commit.id for e in r.get_walker()],
             [r.head(), b'2a72d929692c41d8554c07f6301757ba18a65d91'])
         self.assertEqual(
             [e.commit.id for e in
                 r.get_walker([b'2a72d929692c41d8554c07f6301757ba18a65d91'])],
             [b'2a72d929692c41d8554c07f6301757ba18a65d91'])
         self.assertEqual(
             [e.commit.id for e in
                 r.get_walker(b'2a72d929692c41d8554c07f6301757ba18a65d91')],
             [b'2a72d929692c41d8554c07f6301757ba18a65d91'])
 
     def test_clone(self):
         r = self.open_repo('a.git')
         tmp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         with r.clone(tmp_dir, mkdir=False) as t:
             self.assertEqual({
                 b'HEAD': b'a90fa2d900a17e99b433217e988c4eb4a2e9a097',
                 b'refs/remotes/origin/master':
                     b'a90fa2d900a17e99b433217e988c4eb4a2e9a097',
                 b'refs/heads/master':
                     b'a90fa2d900a17e99b433217e988c4eb4a2e9a097',
                 b'refs/tags/mytag':
                     b'28237f4dc30d0d462658d6b937b08a0f0b6ef55a',
                 b'refs/tags/mytag-packed':
                     b'b0931cadc54336e78a1d980420e3268903b57a50',
                 }, t.refs.as_dict())
             shas = [e.commit.id for e in r.get_walker()]
             self.assertEqual(shas, [t.head(),
                              b'2a72d929692c41d8554c07f6301757ba18a65d91'])
             c = t.get_config()
             encoded_path = r.path
             if not isinstance(encoded_path, bytes):
                 encoded_path = encoded_path.encode(sys.getfilesystemencoding())
             self.assertEqual(encoded_path,
                              c.get((b'remote', b'origin'), b'url'))
             self.assertEqual(
                 b'+refs/heads/*:refs/remotes/origin/*',
                 c.get((b'remote', b'origin'), b'fetch'))
 
     def test_clone_no_head(self):
         temp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, temp_dir)
         repo_dir = os.path.join(os.path.dirname(__file__), 'data', 'repos')
         dest_dir = os.path.join(temp_dir, 'a.git')
         shutil.copytree(os.path.join(repo_dir, 'a.git'),
                         dest_dir, symlinks=True)
         r = Repo(dest_dir)
         del r.refs[b"refs/heads/master"]
         del r.refs[b"HEAD"]
         t = r.clone(os.path.join(temp_dir, 'b.git'), mkdir=True)
         self.assertEqual({
             b'refs/tags/mytag': b'28237f4dc30d0d462658d6b937b08a0f0b6ef55a',
             b'refs/tags/mytag-packed':
                 b'b0931cadc54336e78a1d980420e3268903b57a50',
             }, t.refs.as_dict())
 
     def test_clone_empty(self):
         """Test clone() doesn't crash if HEAD points to a non-existing ref.
 
         This simulates cloning server-side bare repository either when it is
         still empty or if user renames master branch and pushes private repo
         to the server.
         Non-bare repo HEAD always points to an existing ref.
         """
         r = self.open_repo('empty.git')
         tmp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         r.clone(tmp_dir, mkdir=False, bare=True)
 
     def test_merge_history(self):
         r = self.open_repo('simple_merge.git')
         shas = [e.commit.id for e in r.get_walker()]
         self.assertEqual(shas, [b'5dac377bdded4c9aeb8dff595f0faeebcc8498cc',
                                 b'ab64bbdcc51b170d21588e5c5d391ee5c0c96dfd',
                                 b'4cffe90e0a41ad3f5190079d7c8f036bde29cbe6',
                                 b'60dacdc733de308bb77bb76ce0fb0f9b44c9769e',
                                 b'0d89f20333fbb1d2f3a94da77f4981373d8f4310'])
 
     def test_out_of_order_merge(self):
         """Test that revision history is ordered by date, not parent order."""
         r = self.open_repo('ooo_merge.git')
         shas = [e.commit.id for e in r.get_walker()]
         self.assertEqual(shas, [b'7601d7f6231db6a57f7bbb79ee52e4d462fd44d1',
                                 b'f507291b64138b875c28e03469025b1ea20bc614',
                                 b'fb5b0425c7ce46959bec94d54b9a157645e114f5',
                                 b'f9e39b120c68182a4ba35349f832d0e4e61f485c'])
 
     def test_get_tags_empty(self):
         r = self.open_repo('ooo_merge.git')
         self.assertEqual({}, r.refs.as_dict(b'refs/tags'))
 
     def test_get_config(self):
         r = self.open_repo('ooo_merge.git')
         self.assertIsInstance(r.get_config(), Config)
 
     def test_get_config_stack(self):
         r = self.open_repo('ooo_merge.git')
         self.assertIsInstance(r.get_config_stack(), Config)
 
     @skipIf(not getattr(os, 'symlink', None), 'Requires symlink support')
     def test_submodule(self):
         temp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, temp_dir)
         repo_dir = os.path.join(os.path.dirname(__file__), 'data', 'repos')
         shutil.copytree(os.path.join(repo_dir, 'a.git'),
                         os.path.join(temp_dir, 'a.git'), symlinks=True)
         rel = os.path.relpath(os.path.join(repo_dir, 'submodule'), temp_dir)
         os.symlink(os.path.join(rel, 'dotgit'), os.path.join(temp_dir, '.git'))
         with Repo(temp_dir) as r:
             self.assertEqual(r.head(),
                              b'a90fa2d900a17e99b433217e988c4eb4a2e9a097')
 
     def test_common_revisions(self):
         """
         This test demonstrates that ``find_common_revisions()`` actually
         returns common heads, not revisions; dulwich already uses
         ``find_common_revisions()`` in such a manner (see
         ``Repo.fetch_objects()``).
         """
 
         expected_shas = set([b'60dacdc733de308bb77bb76ce0fb0f9b44c9769e'])
 
         # Source for objects.
         r_base = self.open_repo('simple_merge.git')
 
         # Re-create each-side of the merge in simple_merge.git.
         #
         # Since the trees and blobs are missing, the repository created is
         # corrupted, but we're only checking for commits for the purpose of
         # this test, so it's immaterial.
         r1_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, r1_dir)
         r1_commits = [b'ab64bbdcc51b170d21588e5c5d391ee5c0c96dfd',  # HEAD
                       b'60dacdc733de308bb77bb76ce0fb0f9b44c9769e',
                       b'0d89f20333fbb1d2f3a94da77f4981373d8f4310']
 
         r2_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, r2_dir)
         r2_commits = [b'4cffe90e0a41ad3f5190079d7c8f036bde29cbe6',  # HEAD
                       b'60dacdc733de308bb77bb76ce0fb0f9b44c9769e',
                       b'0d89f20333fbb1d2f3a94da77f4981373d8f4310']
 
         r1 = Repo.init_bare(r1_dir)
         for c in r1_commits:
             r1.object_store.add_object(r_base.get_object(c))
         r1.refs[b'HEAD'] = r1_commits[0]
 
         r2 = Repo.init_bare(r2_dir)
         for c in r2_commits:
             r2.object_store.add_object(r_base.get_object(c))
         r2.refs[b'HEAD'] = r2_commits[0]
 
         # Finally, the 'real' testing!
         shas = r2.object_store.find_common_revisions(r1.get_graph_walker())
         self.assertEqual(set(shas), expected_shas)
 
         shas = r1.object_store.find_common_revisions(r2.get_graph_walker())
         self.assertEqual(set(shas), expected_shas)
 
     def test_shell_hook_pre_commit(self):
         if os.name != 'posix':
             self.skipTest('shell hook tests requires POSIX shell')
 
         pre_commit_fail = """#!/bin/sh
 exit 1
 """
 
         pre_commit_success = """#!/bin/sh
 exit 0
 """
 
         repo_dir = os.path.join(self.mkdtemp())
         self.addCleanup(shutil.rmtree, repo_dir)
         r = Repo.init(repo_dir)
         self.addCleanup(r.close)
 
         pre_commit = os.path.join(r.controldir(), 'hooks', 'pre-commit')
 
         with open(pre_commit, 'w') as f:
             f.write(pre_commit_fail)
         os.chmod(pre_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         self.assertRaises(errors.CommitError, r.do_commit, 'failed commit',
                           committer='Test Committer <test@nodomain.com>',
                           author='Test Author <test@nodomain.com>',
                           commit_timestamp=12345, commit_timezone=0,
                           author_timestamp=12345, author_timezone=0)
 
         with open(pre_commit, 'w') as f:
             f.write(pre_commit_success)
         os.chmod(pre_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         commit_sha = r.do_commit(
             b'empty commit',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12395, commit_timezone=0,
             author_timestamp=12395, author_timezone=0)
         self.assertEqual([], r[commit_sha].parents)
 
     def test_shell_hook_commit_msg(self):
         if os.name != 'posix':
             self.skipTest('shell hook tests requires POSIX shell')
 
         commit_msg_fail = """#!/bin/sh
 exit 1
 """
 
         commit_msg_success = """#!/bin/sh
 exit 0
 """
 
         repo_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, repo_dir)
         r = Repo.init(repo_dir)
         self.addCleanup(r.close)
 
         commit_msg = os.path.join(r.controldir(), 'hooks', 'commit-msg')
 
         with open(commit_msg, 'w') as f:
             f.write(commit_msg_fail)
         os.chmod(commit_msg, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         self.assertRaises(errors.CommitError, r.do_commit, b'failed commit',
                           committer=b'Test Committer <test@nodomain.com>',
                           author=b'Test Author <test@nodomain.com>',
                           commit_timestamp=12345, commit_timezone=0,
                           author_timestamp=12345, author_timezone=0)
 
         with open(commit_msg, 'w') as f:
             f.write(commit_msg_success)
         os.chmod(commit_msg, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         commit_sha = r.do_commit(
             b'empty commit',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12395, commit_timezone=0,
             author_timestamp=12395, author_timezone=0)
         self.assertEqual([], r[commit_sha].parents)
 
     def test_shell_hook_post_commit(self):
         if os.name != 'posix':
             self.skipTest('shell hook tests requires POSIX shell')
 
         repo_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, repo_dir)
 
         r = Repo.init(repo_dir)
         self.addCleanup(r.close)
 
         (fd, path) = tempfile.mkstemp(dir=repo_dir)
         os.close(fd)
         post_commit_msg = """#!/bin/sh
 rm """ + path + """
 """
 
         root_sha = r.do_commit(
             b'empty commit',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12345, commit_timezone=0,
             author_timestamp=12345, author_timezone=0)
         self.assertEqual([], r[root_sha].parents)
 
         post_commit = os.path.join(r.controldir(), 'hooks', 'post-commit')
 
         with open(post_commit, 'wb') as f:
             f.write(post_commit_msg.encode(locale.getpreferredencoding()))
         os.chmod(post_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         commit_sha = r.do_commit(
             b'empty commit',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12345, commit_timezone=0,
             author_timestamp=12345, author_timezone=0)
         self.assertEqual([root_sha], r[commit_sha].parents)
 
         self.assertFalse(os.path.exists(path))
 
         post_commit_msg_fail = """#!/bin/sh
 exit 1
 """
         with open(post_commit, 'w') as f:
             f.write(post_commit_msg_fail)
         os.chmod(post_commit, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
 
         warnings.simplefilter("always", UserWarning)
         self.addCleanup(warnings.resetwarnings)
         warnings_list, restore_warnings = setup_warning_catcher()
         self.addCleanup(restore_warnings)
 
         commit_sha2 = r.do_commit(
             b'empty commit',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12345, commit_timezone=0,
             author_timestamp=12345, author_timezone=0)
         expected_warning = UserWarning(
             'post-commit hook failed: Hook post-commit exited with '
             'non-zero status',)
         for w in warnings_list:
             if (type(w) == type(expected_warning) and
                     w.args == expected_warning.args):
                 break
         else:
             raise AssertionError(
                 'Expected warning %r not in %r' %
                 (expected_warning, warnings_list))
         self.assertEqual([commit_sha], r[commit_sha2].parents)
 
     def test_as_dict(self):
         def check(repo):
             self.assertEqual(
                 repo.refs.subkeys(b'refs/tags'),
                 repo.refs.subkeys(b'refs/tags/'))
             self.assertEqual(
                 repo.refs.as_dict(b'refs/tags'),
                 repo.refs.as_dict(b'refs/tags/'))
             self.assertEqual(
                 repo.refs.as_dict(b'refs/heads'),
                 repo.refs.as_dict(b'refs/heads/'))
 
         bare = self.open_repo('a.git')
         tmp_dir = self.mkdtemp()
         self.addCleanup(shutil.rmtree, tmp_dir)
         with bare.clone(tmp_dir, mkdir=False) as nonbare:
             check(nonbare)
             check(bare)
 
     def test_working_tree(self):
         temp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, temp_dir)
         worktree_temp_dir = tempfile.mkdtemp()
         self.addCleanup(shutil.rmtree, worktree_temp_dir)
         r = Repo.init(temp_dir)
         self.addCleanup(r.close)
         root_sha = r.do_commit(
                 b'empty commit',
                 committer=b'Test Committer <test@nodomain.com>',
                 author=b'Test Author <test@nodomain.com>',
                 commit_timestamp=12345, commit_timezone=0,
                 author_timestamp=12345, author_timezone=0)
         r.refs[b'refs/heads/master'] = root_sha
         w = Repo._init_new_working_directory(worktree_temp_dir, r)
         self.addCleanup(w.close)
         new_sha = w.do_commit(
                 b'new commit',
                 committer=b'Test Committer <test@nodomain.com>',
                 author=b'Test Author <test@nodomain.com>',
                 commit_timestamp=12345, commit_timezone=0,
                 author_timestamp=12345, author_timezone=0)
         w.refs[b'HEAD'] = new_sha
         self.assertEqual(os.path.abspath(r.controldir()),
                          os.path.abspath(w.commondir()))
         self.assertEqual(r.refs.keys(), w.refs.keys())
         self.assertNotEqual(r.head(), w.head())
 
 
 class BuildRepoRootTests(TestCase):
     """Tests that build on-disk repos from scratch.
 
     Repos live in a temp dir and are torn down after each test. They start with
     a single commit in master having single file named 'a'.
     """
 
     def get_repo_dir(self):
         return os.path.join(tempfile.mkdtemp(), 'test')
 
     def setUp(self):
         super(BuildRepoRootTests, self).setUp()
         self._repo_dir = self.get_repo_dir()
         os.makedirs(self._repo_dir)
         r = self._repo = Repo.init(self._repo_dir)
         self.addCleanup(tear_down_repo, r)
         self.assertFalse(r.bare)
         self.assertEqual(b'ref: refs/heads/master', r.refs.read_ref(b'HEAD'))
         self.assertRaises(KeyError, lambda: r.refs[b'refs/heads/master'])
 
         with open(os.path.join(r.path, 'a'), 'wb') as f:
             f.write(b'file contents')
         r.stage(['a'])
         commit_sha = r.do_commit(
                 b'msg',
                 committer=b'Test Committer <test@nodomain.com>',
                 author=b'Test Author <test@nodomain.com>',
                 commit_timestamp=12345, commit_timezone=0,
                 author_timestamp=12345, author_timezone=0)
         self.assertEqual([], r[commit_sha].parents)
         self._root_commit = commit_sha
 
     def test_build_repo(self):
         r = self._repo
         self.assertEqual(b'ref: refs/heads/master', r.refs.read_ref(b'HEAD'))
         self.assertEqual(self._root_commit, r.refs[b'refs/heads/master'])
         expected_blob = objects.Blob.from_string(b'file contents')
         self.assertEqual(expected_blob.data, r[expected_blob.id].data)
         actual_commit = r[self._root_commit]
         self.assertEqual(b'msg', actual_commit.message)
 
     def test_commit_modified(self):
         r = self._repo
         with open(os.path.join(r.path, 'a'), 'wb') as f:
             f.write(b'new contents')
         r.stage(['a'])
         commit_sha = r.do_commit(
             b'modified a',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12395, commit_timezone=0,
             author_timestamp=12395, author_timezone=0)
         self.assertEqual([self._root_commit], r[commit_sha].parents)
         a_mode, a_id = tree_lookup_path(r.get_object, r[commit_sha].tree, b'a')
         self.assertEqual(stat.S_IFREG | 0o644, a_mode)
         self.assertEqual(b'new contents', r[a_id].data)
 
     @skipIf(not getattr(os, 'symlink', None), 'Requires symlink support')
     def test_commit_symlink(self):
         r = self._repo
         os.symlink('a', os.path.join(r.path, 'b'))
         r.stage(['a', 'b'])
         commit_sha = r.do_commit(
             b'Symlink b',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12395, commit_timezone=0,
             author_timestamp=12395, author_timezone=0)
         self.assertEqual([self._root_commit], r[commit_sha].parents)
         b_mode, b_id = tree_lookup_path(r.get_object, r[commit_sha].tree, b'b')
         self.assertTrue(stat.S_ISLNK(b_mode))
         self.assertEqual(b'a', r[b_id].data)
 
     def test_commit_deleted(self):
         r = self._repo
         os.remove(os.path.join(r.path, 'a'))
         r.stage(['a'])
         commit_sha = r.do_commit(
             b'deleted a',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12395, commit_timezone=0,
             author_timestamp=12395, author_timezone=0)
         self.assertEqual([self._root_commit], r[commit_sha].parents)
         self.assertEqual([], list(r.open_index()))
         tree = r[r[commit_sha].tree]
         self.assertEqual([], list(tree.iteritems()))
 
     def test_commit_follows(self):
         r = self._repo
         r.refs.set_symbolic_ref(b'HEAD', b'refs/heads/bla')
         commit_sha = r.do_commit(
             b'commit with strange character',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12395, commit_timezone=0,
             author_timestamp=12395, author_timezone=0,
             ref=b'HEAD')
         self.assertEqual(commit_sha, r[b'refs/heads/bla'].id)
 
     def test_commit_encoding(self):
         r = self._repo
         commit_sha = r.do_commit(
             b'commit with strange character \xee',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12395, commit_timezone=0,
             author_timestamp=12395, author_timezone=0,
             encoding=b"iso8859-1")
         self.assertEqual(b"iso8859-1", r[commit_sha].encoding)
 
     def test_commit_config_identity(self):
         # commit falls back to the users' identity if it wasn't specified
         r = self._repo
         c = r.get_config()
         c.set((b"user", ), b"name", b"Jelmer")
         c.set((b"user", ), b"email", b"jelmer@apache.org")
         c.write_to_path()
         commit_sha = r.do_commit(b'message')
         self.assertEqual(
             b"Jelmer <jelmer@apache.org>",
             r[commit_sha].author)
         self.assertEqual(
             b"Jelmer <jelmer@apache.org>",
             r[commit_sha].committer)
 
     def test_commit_config_identity_in_memoryrepo(self):
         # commit falls back to the users' identity if it wasn't specified
         r = MemoryRepo.init_bare([], {})
         c = r.get_config()
         c.set((b"user", ), b"name", b"Jelmer")
         c.set((b"user", ), b"email", b"jelmer@apache.org")
 
         commit_sha = r.do_commit(b'message', tree=objects.Tree().id)
         self.assertEqual(
             b"Jelmer <jelmer@apache.org>",
             r[commit_sha].author)
         self.assertEqual(
             b"Jelmer <jelmer@apache.org>",
             r[commit_sha].committer)
 
     def test_commit_fail_ref(self):
         r = self._repo
 
-        def set_if_equals(name, old_ref, new_ref):
+        def set_if_equals(name, old_ref, new_ref, **kwargs):
             return False
         r.refs.set_if_equals = set_if_equals
 
-        def add_if_new(name, new_ref):
+        def add_if_new(name, new_ref, **kwargs):
             self.fail('Unexpected call to add_if_new')
         r.refs.add_if_new = add_if_new
 
         old_shas = set(r.object_store)
         self.assertRaises(errors.CommitError, r.do_commit, b'failed commit',
                           committer=b'Test Committer <test@nodomain.com>',
                           author=b'Test Author <test@nodomain.com>',
                           commit_timestamp=12345, commit_timezone=0,
                           author_timestamp=12345, author_timezone=0)
         new_shas = set(r.object_store) - old_shas
         self.assertEqual(1, len(new_shas))
         # Check that the new commit (now garbage) was added.
         new_commit = r[new_shas.pop()]
         self.assertEqual(r[self._root_commit].tree, new_commit.tree)
         self.assertEqual(b'failed commit', new_commit.message)
 
     def test_commit_branch(self):
         r = self._repo
 
         commit_sha = r.do_commit(
             b'commit to branch',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12395, commit_timezone=0,
             author_timestamp=12395, author_timezone=0,
             ref=b"refs/heads/new_branch")
         self.assertEqual(self._root_commit, r[b"HEAD"].id)
         self.assertEqual(commit_sha, r[b"refs/heads/new_branch"].id)
         self.assertEqual([], r[commit_sha].parents)
         self.assertTrue(b"refs/heads/new_branch" in r)
 
         new_branch_head = commit_sha
 
         commit_sha = r.do_commit(
             b'commit to branch 2',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12395, commit_timezone=0,
             author_timestamp=12395, author_timezone=0,
             ref=b"refs/heads/new_branch")
         self.assertEqual(self._root_commit, r[b"HEAD"].id)
         self.assertEqual(commit_sha, r[b"refs/heads/new_branch"].id)
         self.assertEqual([new_branch_head], r[commit_sha].parents)
 
     def test_commit_merge_heads(self):
         r = self._repo
         merge_1 = r.do_commit(
             b'commit to branch 2',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12395, commit_timezone=0,
             author_timestamp=12395, author_timezone=0,
             ref=b"refs/heads/new_branch")
         commit_sha = r.do_commit(
             b'commit with merge',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12395, commit_timezone=0,
             author_timestamp=12395, author_timezone=0,
             merge_heads=[merge_1])
         self.assertEqual(
             [self._root_commit, merge_1],
             r[commit_sha].parents)
 
     def test_commit_dangling_commit(self):
         r = self._repo
 
         old_shas = set(r.object_store)
         old_refs = r.get_refs()
         commit_sha = r.do_commit(
             b'commit with no ref',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12395, commit_timezone=0,
             author_timestamp=12395, author_timezone=0,
             ref=None)
         new_shas = set(r.object_store) - old_shas
 
         # New sha is added, but no new refs
         self.assertEqual(1, len(new_shas))
         new_commit = r[new_shas.pop()]
         self.assertEqual(r[self._root_commit].tree, new_commit.tree)
         self.assertEqual([], r[commit_sha].parents)
         self.assertEqual(old_refs, r.get_refs())
 
     def test_commit_dangling_commit_with_parents(self):
         r = self._repo
 
         old_shas = set(r.object_store)
         old_refs = r.get_refs()
         commit_sha = r.do_commit(
             b'commit with no ref',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12395, commit_timezone=0,
             author_timestamp=12395, author_timezone=0,
             ref=None, merge_heads=[self._root_commit])
         new_shas = set(r.object_store) - old_shas
 
         # New sha is added, but no new refs
         self.assertEqual(1, len(new_shas))
         new_commit = r[new_shas.pop()]
         self.assertEqual(r[self._root_commit].tree, new_commit.tree)
         self.assertEqual([self._root_commit], r[commit_sha].parents)
         self.assertEqual(old_refs, r.get_refs())
 
     def test_stage_absolute(self):
         r = self._repo
         os.remove(os.path.join(r.path, 'a'))
         self.assertRaises(ValueError, r.stage, [os.path.join(r.path, 'a')])
 
     def test_stage_deleted(self):
         r = self._repo
         os.remove(os.path.join(r.path, 'a'))
         r.stage(['a'])
         r.stage(['a'])  # double-stage a deleted path
 
     def test_stage_directory(self):
         r = self._repo
         os.mkdir(os.path.join(r.path, 'c'))
         r.stage(['c'])
         self.assertEqual([b'a'], list(r.open_index()))
 
     @skipIf(sys.platform == 'win32' and sys.version_info[:2] >= (3, 6),
             'tries to implicitly decode as utf8')
     def test_commit_no_encode_decode(self):
         r = self._repo
         repo_path_bytes = r.path.encode(sys.getfilesystemencoding())
         encodings = ('utf8', 'latin1')
         names = [u'À'.encode(encoding) for encoding in encodings]
         for name, encoding in zip(names, encodings):
             full_path = os.path.join(repo_path_bytes, name)
             with open(full_path, 'wb') as f:
                 f.write(encoding.encode('ascii'))
             # These files are break tear_down_repo, so cleanup these files
             # ourselves.
             self.addCleanup(os.remove, full_path)
 
         r.stage(names)
         commit_sha = r.do_commit(
             b'Files with different encodings',
             committer=b'Test Committer <test@nodomain.com>',
             author=b'Test Author <test@nodomain.com>',
             commit_timestamp=12395, commit_timezone=0,
             author_timestamp=12395, author_timezone=0,
             ref=None, merge_heads=[self._root_commit])
 
         for name, encoding in zip(names, encodings):
             mode, id = tree_lookup_path(r.get_object, r[commit_sha].tree, name)
             self.assertEqual(stat.S_IFREG | 0o644, mode)
             self.assertEqual(encoding.encode('ascii'), r[id].data)
 
     def test_discover_intended(self):
         path = os.path.join(self._repo_dir, 'b/c')
         r = Repo.discover(path)
         self.assertEqual(r.head(), self._repo.head())
 
     def test_discover_isrepo(self):
         r = Repo.discover(self._repo_dir)
         self.assertEqual(r.head(), self._repo.head())
 
     def test_discover_notrepo(self):
         with self.assertRaises(NotGitRepository):
             Repo.discover('/')