diff --git a/dulwich/cli.py b/dulwich/cli.py
index cf1074a3..bcdd094b 100755
--- a/dulwich/cli.py
+++ b/dulwich/cli.py
@@ -1,755 +1,755 @@
 #!/usr/bin/python3 -u
 #
 # dulwich - Simple command-line interface to Dulwich
 # Copyright (C) 2008-2011 Jelmer Vernooij <jelmer@jelmer.uk>
 # vim: expandtab
 #
 # 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 command-line interface to Dulwich>
 
 This is a very simple command-line wrapper for Dulwich. It is by
 no means intended to be a full-blown Git command-line interface but just
 a way to test Dulwich.
 """
 
 import os
 import sys
 from getopt import getopt
 import argparse
 import optparse
 import signal
 from typing import Dict, Type
 
 from dulwich import porcelain
 from dulwich.client import get_transport_and_path
 from dulwich.errors import ApplyDeltaError
 from dulwich.index import Index
 from dulwich.pack import Pack, sha_to_hex
 from dulwich.patch import write_tree_diff
 from dulwich.repo import Repo
 
 
 def signal_int(signal, frame):
     sys.exit(1)
 
 
 def signal_quit(signal, frame):
     import pdb
 
     pdb.set_trace()
 
 
 class Command(object):
     """A Dulwich subcommand."""
 
     def run(self, args):
         """Run the command."""
         raise NotImplementedError(self.run)
 
 
 class cmd_archive(Command):
     def run(self, args):
         parser = argparse.ArgumentParser()
         parser.add_argument(
             "--remote",
             type=str,
             help="Retrieve archive from specified remote repo",
         )
         parser.add_argument('committish', type=str, nargs='?')
         args = parser.parse_args(args)
         if args.remote:
             client, path = get_transport_and_path(args.remote)
             client.archive(
                 path,
                 args.committish,
                 sys.stdout.write,
                 write_error=sys.stderr.write,
             )
         else:
             porcelain.archive(
                 ".", args.committish, outstream=sys.stdout.buffer,
                 errstream=sys.stderr
             )
 
 
 class cmd_add(Command):
     def run(self, argv):
         parser = argparse.ArgumentParser()
         args = parser.parse_args(argv)
 
         porcelain.add(".", paths=args)
 
 
 class cmd_rm(Command):
     def run(self, argv):
         parser = argparse.ArgumentParser()
         args = parser.parse_args(argv)
 
         porcelain.rm(".", paths=args)
 
 
 class cmd_fetch_pack(Command):
     def run(self, argv):
         parser = argparse.ArgumentParser()
         parser.add_argument('--all', action='store_true')
         parser.add_argument('location', nargs='?', type=str)
         args = parser.parse_args(argv)
         client, path = get_transport_and_path(args.location)
         r = Repo(".")
         if args.all:
             determine_wants = r.object_store.determine_wants_all
         else:
 
-            def determine_wants(x):
+            def determine_wants(x, **kwargs):
                 return [y for y in args if y not in r.object_store]
 
         client.fetch(path, r, determine_wants)
 
 
 class cmd_fetch(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
         opts = dict(opts)
         client, path = get_transport_and_path(args.pop(0))
         r = Repo(".")
         refs = client.fetch(path, r, progress=sys.stdout.write)
         print("Remote refs:")
         for item in refs.items():
             print("%s -> %s" % item)
 
 
 class cmd_fsck(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
         opts = dict(opts)
         for (obj, msg) in porcelain.fsck("."):
             print("%s: %s" % (obj, msg))
 
 
 class cmd_log(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         parser.add_option(
             "--reverse",
             dest="reverse",
             action="store_true",
             help="Reverse order in which entries are printed",
         )
         parser.add_option(
             "--name-status",
             dest="name_status",
             action="store_true",
             help="Print name/status for each changed file",
         )
         options, args = parser.parse_args(args)
 
         porcelain.log(
             ".",
             paths=args,
             reverse=options.reverse,
             name_status=options.name_status,
             outstream=sys.stdout,
         )
 
 
 class cmd_diff(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
 
         if args == []:
             print("Usage: dulwich diff COMMITID")
             sys.exit(1)
 
         r = Repo(".")
         commit_id = args[0]
         commit = r[commit_id]
         parent_commit = r[commit.parents[0]]
         write_tree_diff(sys.stdout, r.object_store, parent_commit.tree, commit.tree)
 
 
 class cmd_dump_pack(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
 
         if args == []:
             print("Usage: dulwich dump-pack FILENAME")
             sys.exit(1)
 
         basename, _ = os.path.splitext(args[0])
         x = Pack(basename)
         print("Object names checksum: %s" % x.name())
         print("Checksum: %s" % sha_to_hex(x.get_stored_checksum()))
         if not x.check():
             print("CHECKSUM DOES NOT MATCH")
         print("Length: %d" % len(x))
         for name in x:
             try:
                 print("\t%s" % x[name])
             except KeyError as k:
                 print("\t%s: Unable to resolve base %s" % (name, k))
             except ApplyDeltaError as e:
                 print("\t%s: Unable to apply delta: %r" % (name, e))
 
 
 class cmd_dump_index(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
 
         if args == []:
             print("Usage: dulwich dump-index FILENAME")
             sys.exit(1)
 
         filename = args[0]
         idx = Index(filename)
 
         for o in idx:
             print(o, idx[o])
 
 
 class cmd_init(Command):
     def run(self, args):
         opts, args = getopt(args, "", ["bare"])
         opts = dict(opts)
 
         if args == []:
             path = os.getcwd()
         else:
             path = args[0]
 
         porcelain.init(path, bare=("--bare" in opts))
 
 
 class cmd_clone(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         parser.add_option(
             "--bare",
             dest="bare",
             help="Whether to create a bare repository.",
             action="store_true",
         )
         parser.add_option(
             "--depth", dest="depth", type=int, help="Depth at which to fetch"
         )
         options, args = parser.parse_args(args)
 
         if args == []:
             print("usage: dulwich clone host:path [PATH]")
             sys.exit(1)
 
         source = args.pop(0)
         if len(args) > 0:
             target = args.pop(0)
         else:
             target = None
 
         porcelain.clone(source, target, bare=options.bare, depth=options.depth)
 
 
 class cmd_commit(Command):
     def run(self, args):
         opts, args = getopt(args, "", ["message"])
         opts = dict(opts)
         porcelain.commit(".", message=opts["--message"])
 
 
 class cmd_commit_tree(Command):
     def run(self, args):
         opts, args = getopt(args, "", ["message"])
         if args == []:
             print("usage: dulwich commit-tree tree")
             sys.exit(1)
         opts = dict(opts)
         porcelain.commit_tree(".", tree=args[0], message=opts["--message"])
 
 
 class cmd_update_server_info(Command):
     def run(self, args):
         porcelain.update_server_info(".")
 
 
 class cmd_symbolic_ref(Command):
     def run(self, args):
         opts, args = getopt(args, "", ["ref-name", "force"])
         if not args:
             print("Usage: dulwich symbolic-ref REF_NAME [--force]")
             sys.exit(1)
 
         ref_name = args.pop(0)
         porcelain.symbolic_ref(".", ref_name=ref_name, force="--force" in args)
 
 
 class cmd_show(Command):
     def run(self, argv):
         parser = argparse.ArgumentParser()
         parser.add_argument('objectish', type=str, nargs='*')
         args = parser.parse_args(argv)
         porcelain.show(".", args.objectish or None)
 
 
 class cmd_diff_tree(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
         if len(args) < 2:
             print("Usage: dulwich diff-tree OLD-TREE NEW-TREE")
             sys.exit(1)
         porcelain.diff_tree(".", args[0], args[1])
 
 
 class cmd_rev_list(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
         if len(args) < 1:
             print("Usage: dulwich rev-list COMMITID...")
             sys.exit(1)
         porcelain.rev_list(".", args)
 
 
 class cmd_tag(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         parser.add_option(
             "-a",
             "--annotated",
             help="Create an annotated tag.",
             action="store_true",
         )
         parser.add_option(
             "-s", "--sign", help="Sign the annotated tag.", action="store_true"
         )
         options, args = parser.parse_args(args)
         porcelain.tag_create(
             ".", args[0], annotated=options.annotated, sign=options.sign
         )
 
 
 class cmd_repack(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
         opts = dict(opts)
         porcelain.repack(".")
 
 
 class cmd_reset(Command):
     def run(self, args):
         opts, args = getopt(args, "", ["hard", "soft", "mixed"])
         opts = dict(opts)
         mode = ""
         if "--hard" in opts:
             mode = "hard"
         elif "--soft" in opts:
             mode = "soft"
         elif "--mixed" in opts:
             mode = "mixed"
         porcelain.reset(".", mode=mode, *args)
 
 
 class cmd_daemon(Command):
     def run(self, args):
         from dulwich import log_utils
         from dulwich.protocol import TCP_GIT_PORT
 
         parser = optparse.OptionParser()
         parser.add_option(
             "-l",
             "--listen_address",
             dest="listen_address",
             default="localhost",
             help="Binding IP address.",
         )
         parser.add_option(
             "-p",
             "--port",
             dest="port",
             type=int,
             default=TCP_GIT_PORT,
             help="Binding TCP port.",
         )
         options, args = parser.parse_args(args)
 
         log_utils.default_logging_config()
         if len(args) >= 1:
             gitdir = args[0]
         else:
             gitdir = "."
 
         porcelain.daemon(gitdir, address=options.listen_address, port=options.port)
 
 
 class cmd_web_daemon(Command):
     def run(self, args):
         from dulwich import log_utils
 
         parser = optparse.OptionParser()
         parser.add_option(
             "-l",
             "--listen_address",
             dest="listen_address",
             default="",
             help="Binding IP address.",
         )
         parser.add_option(
             "-p",
             "--port",
             dest="port",
             type=int,
             default=8000,
             help="Binding TCP port.",
         )
         options, args = parser.parse_args(args)
 
         log_utils.default_logging_config()
         if len(args) >= 1:
             gitdir = args[0]
         else:
             gitdir = "."
 
         porcelain.web_daemon(gitdir, address=options.listen_address, port=options.port)
 
 
 class cmd_write_tree(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         sys.stdout.write("%s\n" % porcelain.write_tree("."))
 
 
 class cmd_receive_pack(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         if len(args) >= 1:
             gitdir = args[0]
         else:
             gitdir = "."
         porcelain.receive_pack(gitdir)
 
 
 class cmd_upload_pack(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         if len(args) >= 1:
             gitdir = args[0]
         else:
             gitdir = "."
         porcelain.upload_pack(gitdir)
 
 
 class cmd_status(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         if len(args) >= 1:
             gitdir = args[0]
         else:
             gitdir = "."
         status = porcelain.status(gitdir)
         if any(names for (kind, names) in status.staged.items()):
             sys.stdout.write("Changes to be committed:\n\n")
             for kind, names in status.staged.items():
                 for name in names:
                     sys.stdout.write(
                         "\t%s: %s\n" % (kind, name.decode(sys.getfilesystemencoding()))
                     )
             sys.stdout.write("\n")
         if status.unstaged:
             sys.stdout.write("Changes not staged for commit:\n\n")
             for name in status.unstaged:
                 sys.stdout.write("\t%s\n" % name.decode(sys.getfilesystemencoding()))
             sys.stdout.write("\n")
         if status.untracked:
             sys.stdout.write("Untracked files:\n\n")
             for name in status.untracked:
                 sys.stdout.write("\t%s\n" % name)
             sys.stdout.write("\n")
 
 
 class cmd_ls_remote(Command):
     def run(self, args):
         opts, args = getopt(args, "", [])
         if len(args) < 1:
             print("Usage: dulwich ls-remote URL")
             sys.exit(1)
         refs = porcelain.ls_remote(args[0])
         for ref in sorted(refs):
             sys.stdout.write("%s\t%s\n" % (ref, refs[ref]))
 
 
 class cmd_ls_tree(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         parser.add_option(
             "-r",
             "--recursive",
             action="store_true",
             help="Recusively list tree contents.",
         )
         parser.add_option("--name-only", action="store_true", help="Only display name.")
         options, args = parser.parse_args(args)
         try:
             treeish = args.pop(0)
         except IndexError:
             treeish = None
         porcelain.ls_tree(
             ".",
             treeish,
             outstream=sys.stdout,
             recursive=options.recursive,
             name_only=options.name_only,
         )
 
 
 class cmd_pack_objects(Command):
     def run(self, args):
         opts, args = getopt(args, "", ["stdout"])
         opts = dict(opts)
         if len(args) < 1 and "--stdout" not in args:
             print("Usage: dulwich pack-objects basename")
             sys.exit(1)
         object_ids = [line.strip() for line in sys.stdin.readlines()]
         basename = args[0]
         if "--stdout" in opts:
             packf = getattr(sys.stdout, "buffer", sys.stdout)
             idxf = None
             close = []
         else:
             packf = open(basename + ".pack", "w")
             idxf = open(basename + ".idx", "w")
             close = [packf, idxf]
         porcelain.pack_objects(".", object_ids, packf, idxf)
         for f in close:
             f.close()
 
 
 class cmd_pull(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         try:
             from_location = args[0]
         except IndexError:
             from_location = None
         porcelain.pull(".", from_location)
 
 
 class cmd_push(Command):
 
     def run(self, argv):
         parser = argparse.ArgumentParser()
         parser.add_argument('to_location', type=str)
         parser.add_argument('refspec', type=str, nargs='*')
         args = parser.parse_args(argv)
         porcelain.push('.', args.to_location, args.refspec or None)
 
 
 class cmd_remote_add(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         porcelain.remote_add(".", args[0], args[1])
 
 
 class SuperCommand(Command):
 
     subcommands = {}  # type: Dict[str, Type[Command]]
 
     def run(self, args):
         if not args:
             print("Supported subcommands: %s" % ", ".join(self.subcommands.keys()))
             return False
         cmd = args[0]
         try:
             cmd_kls = self.subcommands[cmd]
         except KeyError:
             print("No such subcommand: %s" % args[0])
             return False
         return cmd_kls().run(args[1:])
 
 
 class cmd_remote(SuperCommand):
 
     subcommands = {
         "add": cmd_remote_add,
     }
 
 
 class cmd_check_ignore(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         ret = 1
         for path in porcelain.check_ignore(".", args):
             print(path)
             ret = 0
         return ret
 
 
 class cmd_check_mailmap(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         for arg in args:
             canonical_identity = porcelain.check_mailmap(".", arg)
             print(canonical_identity)
 
 
 class cmd_stash_list(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         for i, entry in porcelain.stash_list("."):
             print("stash@{%d}: %s" % (i, entry.message.rstrip("\n")))
 
 
 class cmd_stash_push(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         porcelain.stash_push(".")
         print("Saved working directory and index state")
 
 
 class cmd_stash_pop(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         porcelain.stash_pop(".")
         print("Restrored working directory and index state")
 
 
 class cmd_stash(SuperCommand):
 
     subcommands = {
         "list": cmd_stash_list,
         "pop": cmd_stash_pop,
         "push": cmd_stash_push,
     }
 
 
 class cmd_ls_files(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         for name in porcelain.ls_files("."):
             print(name)
 
 
 class cmd_describe(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         options, args = parser.parse_args(args)
         print(porcelain.describe("."))
 
 
 class cmd_help(Command):
     def run(self, args):
         parser = optparse.OptionParser()
         parser.add_option(
             "-a",
             "--all",
             dest="all",
             action="store_true",
             help="List all commands.",
         )
         options, args = parser.parse_args(args)
 
         if options.all:
             print("Available commands:")
             for cmd in sorted(commands):
                 print("  %s" % cmd)
         else:
             print(
                 """\
 The dulwich command line tool is currently a very basic frontend for the
 Dulwich python module. For full functionality, please see the API reference.
 
 For a list of supported commands, see 'dulwich help -a'.
 """
             )
 
 
 commands = {
     "add": cmd_add,
     "archive": cmd_archive,
     "check-ignore": cmd_check_ignore,
     "check-mailmap": cmd_check_mailmap,
     "clone": cmd_clone,
     "commit": cmd_commit,
     "commit-tree": cmd_commit_tree,
     "describe": cmd_describe,
     "daemon": cmd_daemon,
     "diff": cmd_diff,
     "diff-tree": cmd_diff_tree,
     "dump-pack": cmd_dump_pack,
     "dump-index": cmd_dump_index,
     "fetch-pack": cmd_fetch_pack,
     "fetch": cmd_fetch,
     "fsck": cmd_fsck,
     "help": cmd_help,
     "init": cmd_init,
     "log": cmd_log,
     "ls-files": cmd_ls_files,
     "ls-remote": cmd_ls_remote,
     "ls-tree": cmd_ls_tree,
     "pack-objects": cmd_pack_objects,
     "pull": cmd_pull,
     "push": cmd_push,
     "receive-pack": cmd_receive_pack,
     "remote": cmd_remote,
     "repack": cmd_repack,
     "reset": cmd_reset,
     "rev-list": cmd_rev_list,
     "rm": cmd_rm,
     "show": cmd_show,
     "stash": cmd_stash,
     "status": cmd_status,
     "symbolic-ref": cmd_symbolic_ref,
     "tag": cmd_tag,
     "update-server-info": cmd_update_server_info,
     "upload-pack": cmd_upload_pack,
     "web-daemon": cmd_web_daemon,
     "write-tree": cmd_write_tree,
 }
 
 
 def main(argv=None):
     if argv is None:
         argv = sys.argv
 
     if len(argv) < 1:
         print("Usage: dulwich <%s> [OPTIONS...]" % ("|".join(commands.keys())))
         return 1
 
     cmd = argv[0]
     try:
         cmd_kls = commands[cmd]
     except KeyError:
         print("No such subcommand: %s" % cmd)
         return 1
     # TODO(jelmer): Return non-0 on errors
     return cmd_kls().run(argv[1:])
 
 
 if __name__ == "__main__":
     if "DULWICH_PDB" in os.environ and getattr(signal, "SIGQUIT", None):
         signal.signal(signal.SIGQUIT, signal_quit)  # type: ignore
     signal.signal(signal.SIGINT, signal_int)
 
     sys.exit(main(sys.argv[1:]))
diff --git a/dulwich/porcelain.py b/dulwich/porcelain.py
index 3fcae712..08fa288f 100644
--- a/dulwich/porcelain.py
+++ b/dulwich/porcelain.py
@@ -1,1890 +1,1890 @@
 # porcelain.py -- Porcelain-like layer on top of Dulwich
 # Copyright (C) 2013 Jelmer Vernooij <jelmer@jelmer.uk>
 #
 # 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
  * describe
  * diff-tree
  * fetch
  * init
  * ls-files
  * 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.
 
 Functions should generally accept both unicode strings and bytestrings
 """
 
 from collections import namedtuple
 from contextlib import (
     closing,
     contextmanager,
 )
 from io import BytesIO, RawIOBase
 import datetime
 import os
 from pathlib import Path
 import posixpath
 import shutil
 import stat
 import sys
 import time
 from typing import (
     Dict,
     Optional,
     Tuple,
     Union,
 )
 
 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,
 )
 from dulwich.graph import (
     can_fast_forward,
 )
 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,
     LOCAL_BRANCH_PREFIX,
     strip_peeled_refs,
     RefsContainer,
 )
 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")
 
 
 class NoneStream(RawIOBase):
     """Fallback if stdout or stderr are unavailable, does nothing."""
 
     def read(self, size=-1):
         return None
 
     def readall(self):
         return None
 
     def readinto(self, b):
         return None
 
     def write(self, b):
         return None
 
 
 default_bytes_out_stream = getattr(sys.stdout, "buffer", None) or NoneStream()
 default_bytes_err_stream = getattr(sys.stderr, "buffer", None) or NoneStream()
 
 
 DEFAULT_ENCODING = "utf-8"
 
 
 class Error(Exception):
     """Porcelain-based error. """
 
     def __init__(self, msg, inner=None):
         super(Error, self).__init__(msg)
         self.inner = inner
 
 
 class RemoteExists(Error):
     """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, tree_encoding=DEFAULT_ENCODING):
     """Convert a path to a path usable in an index, e.g. bytes and relative to
     the repository root.
 
     Args:
       repopath: Repository path, absolute or relative to the cwd
       path: A path, absolute or relative to the cwd
     Returns: A path formatted for use in e.g. an index
     """
     # Pathlib resolve before Python 3.6 could raises FileNotFoundError in case
     # there is no file matching the path so we reuse the old implementation for
     # Python 3.5
     if sys.version_info < (3, 6):
         if not isinstance(path, bytes):
             path = os.fsencode(path)
         if not isinstance(repopath, bytes):
             repopath = os.fsencode(repopath)
         treepath = os.path.relpath(path, repopath)
         if treepath.startswith(b".."):
             err_msg = "Path %r not in repo path (%r)" % (path, repopath)
             raise ValueError(err_msg)
         if os.path.sep != "/":
             treepath = treepath.replace(os.path.sep.encode("ascii"), b"/")
         return treepath
     else:
         # Resolve might returns a relative path on Windows
         # https://bugs.python.org/issue38671
         if sys.platform == "win32":
             path = os.path.abspath(path)
 
         path = Path(path)
         resolved_path = path.resolve()
 
         # Resolve and abspath seems to behave differently regarding symlinks,
         # as we are doing abspath on the file path, we need to do the same on
         # the repo path or they might not match
         if sys.platform == "win32":
             repopath = os.path.abspath(repopath)
 
         repopath = Path(repopath).resolve()
 
         try:
             relpath = resolved_path.relative_to(repopath)
         except ValueError:
             # If path is a symlink that points to a file outside the repo, we
             # want the relpath for the link itself, not the resolved target
             if path.is_symlink():
                 parent = path.parent.resolve()
                 relpath = (parent / path.name).relative_to(repopath)
             else:
                 raise
         if sys.platform == "win32":
             return str(relpath).replace(os.path.sep, "/").encode(tree_encoding)
         else:
             return bytes(relpath)
 
 
 class DivergedBranches(Error):
     """Branches have diverged and fast-forward is not possible."""
 
 
 def check_diverged(repo, current_sha, new_sha):
     """Check if updating to a sha can be done with fast forwarding.
 
     Args:
       repo: Repository object
       current_sha: Current head sha
       new_sha: New head sha
     """
     try:
         can = can_fast_forward(repo, current_sha, new_sha)
     except KeyError:
         can = False
     if not can:
         raise DivergedBranches(current_sha, new_sha)
 
 
 def archive(
     repo,
     committish=None,
     outstream=default_bytes_out_stream,
     errstream=default_bytes_err_stream,
 ):
     """Create an archive.
 
     Args:
       repo: Path of repository for which to generate an archive.
       committish: Commit SHA1 or ref to use
       outstream: Output stream (defaults to stdout)
       errstream: Error stream (defaults to stderr)
     """
 
     if committish is None:
         committish = "HEAD"
     with open_repo_closing(repo) as repo_obj:
         c = parse_commit(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.
 
     Args:
       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.
 
     Args:
       repo: path to the repository
       ref_name: short name of the new ref
       force: force settings without checking if it exists in refs/heads
     """
     with open_repo_closing(repo) as repo_obj:
         ref_path = _make_branch_ref(ref_name)
         if not force and ref_path not in repo_obj.refs.keys():
             raise Error("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,
     encoding=None,
     no_verify=False,
 ):
     """Create a new commit.
 
     Args:
       repo: Path to repository
       message: Optional commit message
       author: Optional author name and email
       committer: Optional committer name and email
       no_verify: Skip pre-commit and commit-msg hooks
     Returns: SHA1 of the new commit
     """
     # FIXME: Support --all argument
     # FIXME: Support --signoff argument
     if getattr(message, "encode", None):
         message = message.encode(encoding or DEFAULT_ENCODING)
     if getattr(author, "encode", None):
         author = author.encode(encoding or DEFAULT_ENCODING)
     if getattr(committer, "encode", None):
         committer = committer.encode(encoding or DEFAULT_ENCODING)
     with open_repo_closing(repo) as r:
         return r.do_commit(
             message=message,
             author=author,
             committer=committer,
             encoding=encoding,
             no_verify=no_verify,
         )
 
 
 def commit_tree(repo, tree, message=None, author=None, committer=None):
     """Create a new commit object.
 
     Args:
       repo: Path to repository
       tree: An existing tree object
       author: Optional author name and email
       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.
 
     Args:
       path: Path to repository.
       bare: Whether to create a bare repository.
     Returns: 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",
     depth=None,
     **kwargs
 ):
     """Clone a local or remote git repository.
 
     Args:
       source: Path or URL for source repository
       target: Path to target repository (optional)
       bare: Whether or not to create a bare repository
       checkout: Whether or not to check-out HEAD after cloning
       errstream: Optional stream to write progress to
       outstream: Optional stream to write progress to (deprecated)
       origin: Name of remote from the repository used to clone
       depth: Depth to fetch at
     Returns: The new repository
     """
     # TODO(jelmer): This code overlaps quite a bit with Repo.clone
     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 Error("checkout and bare are incompatible")
 
     if target is None:
         target = source.split("/")[-1]
 
     if not os.path.exists(target):
         os.mkdir(target)
 
     if bare:
         r = Repo.init_bare(target)
     else:
         r = Repo.init(target)
 
     reflog_message = b"clone: from " + source.encode("utf-8")
     try:
         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()
         fetch_result = fetch(
             r,
             origin,
             errstream=errstream,
             message=reflog_message,
             depth=depth,
             **kwargs
         )
         for key, target in fetch_result.symrefs.items():
             r.refs.set_symbolic_ref(key, target)
         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:
         shutil.rmtree(target)
         r.close()
         raise
 
     return r
 
 
 def add(repo=".", paths=None):
     """Add files to the staging area.
 
     Args:
       repo: Repository for the files
       paths: Paths to add.  No value passed stages all modified files.
     Returns: Tuple with set of added files and ignored files
     """
     ignored = set()
     with open_repo_closing(repo) as r:
         repo_path = Path(r.path).resolve()
         ignore_manager = IgnoreFilterManager.from_repo(r)
         if not paths:
             paths = list(
                 get_untracked_paths(
                     str(Path(os.getcwd()).resolve()),
                     str(repo_path),
                     r.open_index(),
                 )
             )
         relpaths = []
         if not isinstance(paths, list):
             paths = [paths]
         for p in paths:
             relpath = str(Path(p).resolve().relative_to(repo_path))
             # FIXME: Support patterns, directories.
             if ignore_manager.is_ignored(relpath):
                 ignored.add(relpath)
                 continue
             relpaths.append(relpath)
         r.stage(relpaths)
     return (relpaths, ignored)
 
 
 def _is_subdir(subdir, parentdir):
     """Check whether subdir is parentdir or a subdir of parentdir
 
     If parentdir or subdir is a relative path, it will be disamgibuated
     relative to the pwd.
     """
     parentdir_abs = os.path.realpath(parentdir) + os.path.sep
     subdir_abs = os.path.realpath(subdir) + os.path.sep
     return subdir_abs.startswith(parentdir_abs)
 
 
 # TODO: option to remove ignored files also, in line with `git clean -fdx`
 def clean(repo=".", target_dir=None):
     """Remove any untracked files from the target directory recursively
 
     Equivalent to running `git clean -fd` in target_dir.
 
     Args:
       repo: Repository where the files may be tracked
       target_dir: Directory to clean - current directory if None
     """
     if target_dir is None:
         target_dir = os.getcwd()
 
     with open_repo_closing(repo) as r:
         if not _is_subdir(target_dir, r.path):
             raise Error("target_dir must be in the repo's working dir")
 
         config = r.get_config_stack()
         require_force = config.get_boolean(  # noqa: F841
             (b"clean",), b"requireForce", True
         )
 
         # TODO(jelmer): if require_force is set, then make sure that -f, -i or
         # -n is specified.
 
         index = r.open_index()
         ignore_manager = IgnoreFilterManager.from_repo(r)
 
         paths_in_wd = _walk_working_dir_paths(target_dir, r.path)
         # Reverse file visit order, so that files and subdirectories are
         # removed before containing directory
         for ap, is_dir in reversed(list(paths_in_wd)):
             if is_dir:
                 # All subdirectories and files have been removed if untracked,
                 # so dir contains no tracked files iff it is empty.
                 is_empty = len(os.listdir(ap)) == 0
                 if is_empty:
                     os.rmdir(ap)
             else:
                 ip = path_to_tree_path(r.path, ap)
                 is_tracked = ip in index
 
                 rp = os.path.relpath(ap, r.path)
                 is_ignored = ignore_manager.is_ignored(rp)
 
                 if not is_tracked and not is_ignored:
                     os.remove(ap)
 
 
 def remove(repo=".", paths=None, cached=False):
     """Remove files from the staging area.
 
     Args:
       repo: Repository for the files
       paths: Paths to remove
     """
     with open_repo_closing(repo) as r:
         index = r.open_index()
         for p in paths:
             full_path = os.fsencode(os.path.abspath(p))
             tree_path = path_to_tree_path(r.path, p)
             try:
                 index_sha = index[tree_path].sha
             except KeyError:
                 raise Error("%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 Error(
                                 "file has staged content differing "
                                 "from both the file and head: %s" % p
                             )
 
                         if index_sha != committed_sha:
                             raise Error("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:
         encoding = commit.encoding.decode("ascii")
     else:
         encoding = default_encoding
     return contents.decode(encoding, "replace")
 
 
 def commit_encode(commit, contents, default_encoding=DEFAULT_ENCODING):
     if commit.encoding:
         encoding = commit.encoding.decode("ascii")
     else:
         encoding = default_encoding
     return contents.encode(encoding)
 
 
 def print_commit(commit, decode, outstream=sys.stdout):
     """Write a human-readable commit log entry.
 
     Args:
       commit: A `Commit` object
       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.
 
     Args:
       tag: A `Tag` object
       decode: Function for decoding bytes to unicode string
       outstream: A stream to write to
     """
     outstream.write("Tagger: " + decode(tag.tagger) + "\n")
     time_tuple = time.gmtime(tag.tag_time + tag.tag_timezone)
     time_str = time.strftime("%a %b %d %Y %H:%M:%S", time_tuple)
     timezone_str = format_timezone(tag.tag_timezone).decode("ascii")
     outstream.write("Date:   " + time_str + " " + timezone_str + "\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.
 
     Args:
       repo: A `Repo` object
       blob: A `Blob` object
       decode: Function for decoding bytes to unicode string
       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.
 
     Args:
       repo: A `Repo` object
       commit: A `Commit` object
       decode: Function for decoding bytes to unicode string
       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(commit_decode(commit, diffstream.getvalue()))
 
 
 def show_tree(repo, tree, decode, outstream=sys.stdout):
     """Print a tree to a stream.
 
     Args:
       repo: A `Repo` object
       tree: A `Tree` object
       decode: Function for decoding bytes to unicode string
       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.
 
     Args:
       repo: A `Repo` object
       tag: A `Tag` object
       decode: Function for decoding bytes to unicode string
       outstream: Stream to write to
     """
     print_tag(tag, decode, outstream)
     show_object(repo, repo[tag.object[1]], decode, 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.
 
     Args:
       repo: Path to repository
       paths: Optional set of specific paths to print entries for
       outstream: Stream to write log output to
       reverse: Reverse order in which entries are printed
       name_status: Print name status
       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(
                     [line + "\n" for line 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.
 
     Args:
       repo: Path to repository
       objects: Objects to show (defaults to [HEAD])
       outstream: Stream to write to
       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.
 
     Args:
       repo: Path to repository
       old_tree: Id of old tree
       new_tree: Id of new tree
       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.
 
     Args:
       repo: Path to repository
       commits: Commits over which to iterate
       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,
     sign=False,
 ):
     """Creates a tag in git via dulwich calls:
 
     Args:
       repo: Path to repository
       tag: tag string
       author: tag author (optional, if annotated is set)
       message: tag message (optional)
       annotated: whether to create an annotated tag
       objectish: object the tag should point at, defaults to HEAD
       tag_time: Optional time for annotated tag
       tag_timezone: Optional timezone for annotated tag
       sign: GPG Sign the 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(r.get_config_stack())
             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
             if sign:
                 import gpg
 
                 with gpg.Context(armor=True) as c:
                     tag_obj.signature, unused_result = c.sign(tag_obj.as_raw_string())
             r.object_store.add_object(tag_obj)
             tag_id = tag_obj.id
         else:
             tag_id = object.id
 
         r.refs[_make_tag_ref(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.
 
     Args:
       repo: Path to repository
       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.
 
     Args:
       repo: Path to repository
       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 Error("Unexpected tag name type %r" % name)
         for name in names:
             del r.refs[_make_tag_ref(name)]
 
 
 def reset(repo, mode, treeish="HEAD"):
     """Reset current HEAD to the specified state.
 
     Args:
       repo: Path to repository
       mode: Mode ("hard", "soft", "mixed")
       treeish: Treeish to reset to
     """
 
     if mode != "hard":
         raise Error("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 get_remote_repo(
     repo: Repo, remote_location: Optional[Union[str, bytes]] = None
 ) -> Tuple[Optional[str], str]:
     config = repo.get_config()
     if remote_location is None:
         remote_location = get_branch_remote(repo)
     if isinstance(remote_location, str):
         encoded_location = remote_location.encode()
     else:
         encoded_location = remote_location
 
     section = (b"remote", encoded_location)
 
     remote_name = None  # type: Optional[str]
 
     if config.has_section(section):
         remote_name = encoded_location.decode()
         url = config.get(section, "url")
         encoded_location = url
     else:
         remote_name = None
 
     return (remote_name, encoded_location.decode())
 
 
 def push(
     repo,
     remote_location=None,
     refspecs=None,
     outstream=default_bytes_out_stream,
     errstream=default_bytes_err_stream,
     force=False,
     **kwargs
 ):
     """Remote push with dulwich via dulwich.client
 
     Args:
       repo: Path to repository
       remote_location: Location of the remote
       refspecs: Refs to push to remote
       outstream: A stream file to write output
       errstream: A stream file to write errors
       force: Force overwriting refs
     """
 
     # Open the repo
     with open_repo_closing(repo) as r:
         if refspecs is None:
             refspecs = [active_branch(r)]
         (remote_name, remote_location) = get_remote_repo(r, remote_location)
 
         # Get the client and path
         client, path = get_transport_and_path(
             remote_location, config=r.get_config_stack(), **kwargs
         )
 
         selected_refs = []
         remote_changed_refs = {}
 
         def update_refs(refs):
             selected_refs.extend(parse_reftuples(r.refs, refs, refspecs, force=force))
             new_refs = {}
             # TODO: Handle selected_refs == {None: None}
             for (lh, rh, force_ref) in selected_refs:
                 if lh is None:
                     new_refs[rh] = ZERO_SHA
                     remote_changed_refs[rh] = None
                 else:
                     try:
                         localsha = r.refs[lh]
                     except KeyError:
                         raise Error("No valid ref %s in local repository" % lh)
                     if not force_ref and rh in refs:
                         check_diverged(r, refs[rh], localsha)
                     new_refs[rh] = localsha
                     remote_changed_refs[rh] = localsha
             return new_refs
 
         err_encoding = getattr(errstream, "encoding", None) or DEFAULT_ENCODING
         remote_location = client.get_url(path)
         try:
             result = client.send_pack(
                 path,
                 update_refs,
                 generate_pack_data=r.generate_pack_data,
                 progress=errstream.write,
             )
         except SendPackError as e:
             raise Error(
                 "Push to " + remote_location + " failed -> " + e.args[0].decode(),
                 inner=e,
             )
         else:
             errstream.write(
                 b"Push to " + remote_location.encode(err_encoding) + b" successful.\n"
             )
 
         for ref, error in (result.ref_status or {}).items():
             if error is not None:
                 errstream.write(
                     b"Push of ref %s failed: %s\n" % (ref, error.encode(err_encoding))
                 )
             else:
                 errstream.write(b"Ref %s updated\n" % ref)
 
         if remote_name is not None:
             _import_remote_refs(r.refs, remote_name, remote_changed_refs)
 
 
 def pull(
     repo,
     remote_location=None,
     refspecs=None,
     outstream=default_bytes_out_stream,
     errstream=default_bytes_err_stream,
     fast_forward=True,
     force=False,
     **kwargs
 ):
     """Pull from remote via dulwich.client
 
     Args:
       repo: Path to repository
       remote_location: Location of the remote
       refspec: refspecs to fetch
       outstream: A stream file to write to output
       errstream: A stream file to write to errors
     """
     # Open the repo
     with open_repo_closing(repo) as r:
         (remote_name, remote_location) = get_remote_repo(r, remote_location)
 
         if refspecs is None:
             refspecs = [b"HEAD"]
         selected_refs = []
 
-        def determine_wants(remote_refs):
+        def determine_wants(remote_refs, **kwargs):
             selected_refs.extend(
                 parse_reftuples(remote_refs, r.refs, refspecs, force=force)
             )
             return [
                 remote_refs[lh]
                 for (lh, rh, force_ref) in selected_refs
                 if remote_refs[lh] not in r.object_store
             ]
 
         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_ref) in selected_refs:
             try:
                 check_diverged(r, r.refs[rh], fetch_result.refs[lh])
             except DivergedBranches:
                 if fast_forward:
                     raise
                 else:
                     raise NotImplementedError("merge is not yet supported")
             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)
         if remote_name is not None:
             _import_remote_refs(r.refs, remote_name, fetch_result.refs)
 
 
 def status(repo=".", ignored=False):
     """Returns staged, unstaged, and untracked changes relative to the HEAD.
 
     Args:
       repo: Path to repository or repository object
       ignored: Whether to include ignored files in `untracked`
     Returns: GitStatus tuple,
         staged -  dict with lists 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()
         normalizer = r.get_blob_normalizer()
         filter_callback = normalizer.checkin_normalize
         unstaged_changes = list(get_unstaged_changes(index, r.path, filter_callback))
 
         untracked_paths = get_untracked_paths(
             r.path, r.path, index, exclude_ignored=not ignored
         )
         untracked_changes = list(untracked_paths)
 
         return GitStatus(tracked_changes, unstaged_changes, untracked_changes)
 
 
 def _walk_working_dir_paths(frompath, basepath):
     """Get path, is_dir for files in working dir from frompath
 
     Args:
       frompath: Path to begin walk
       basepath: Path to compare to
     """
     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
 
         if dirpath != frompath:
             yield dirpath, True
 
         for filename in filenames:
             filepath = os.path.join(dirpath, filename)
             yield filepath, False
 
 
 def get_untracked_paths(frompath, basepath, index, exclude_ignored=False):
     """Get untracked paths.
 
     Args:
       frompath: Path to walk
       basepath: Path to compare to
       index: Index to check against
       exclude_ignored: Whether to exclude ignored paths
     """
     if exclude_ignored:
         with open_repo_closing(frompath) as r:
             ignore_manager = IgnoreFilterManager.from_repo(r)
     else:
         ignore_manager = None
 
     for ap, is_dir in _walk_working_dir_paths(frompath, basepath):
         if ignore_manager is not None and ignore_manager.is_ignored(
             os.path.relpath(ap, frompath)
         ):
             continue
         if not is_dir:
             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.
 
     Args:
       repo: repo path or object
     Returns: 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 NotImplementedError("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.
 
     Args:
       path: Path to the directory to serve.
       address: Optional address to listen on (defaults to ::)
       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.
 
     Args:
       path: Path to the directory to serve
       address: Optional address to listen on (defaults to ::)
       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.
 
     Args:
       path: Path to the repository
       inf: Input stream to communicate with client
       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.
 
     Args:
       path: Path to the repository
       inf: Input stream to communicate with client
       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 _make_branch_ref(name):
     if getattr(name, "encode", None):
         name = name.encode(DEFAULT_ENCODING)
     return LOCAL_BRANCH_PREFIX + name
 
 
 def _make_tag_ref(name):
     if getattr(name, "encode", None):
         name = name.encode(DEFAULT_ENCODING)
     return b"refs/tags/" + name
 
 
 def branch_delete(repo, name):
     """Delete a branch.
 
     Args:
       repo: Path to the repository
       name: Name of the branch
     """
     with open_repo_closing(repo) as r:
         if isinstance(name, list):
             names = name
         else:
             names = [name]
         for name in names:
             del r.refs[_make_branch_ref(name)]
 
 
 def branch_create(repo, name, objectish=None, force=False):
     """Create a branch.
 
     Args:
       repo: Path to the repository
       name: Name of the new branch
       objectish: Target object to point new branch at (defaults to HEAD)
       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 = _make_branch_ref(name)
         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 Error("Branch with name %s already exists." % name)
 
 
 def branch_list(repo):
     """List all branches.
 
     Args:
       repo: Path to the repository
     """
     with open_repo_closing(repo) as r:
         return r.refs.keys(base=LOCAL_BRANCH_PREFIX)
 
 
 def active_branch(repo):
     """Return the active branch in the repository, if any.
 
     Args:
       repo: Repository to open
     Returns:
       branch name
     Raises:
       KeyError: if the repository does not have a working tree
       IndexError: if HEAD is floating
     """
     with open_repo_closing(repo) as r:
         active_ref = r.refs.follow(b"HEAD")[0][1]
         if not active_ref.startswith(LOCAL_BRANCH_PREFIX):
             raise ValueError(active_ref)
         return active_ref[len(LOCAL_BRANCH_PREFIX) :]
 
 
 def get_branch_remote(repo):
     """Return the active branch's remote name, if any.
 
     Args:
       repo: Repository to open
     Returns:
       remote name
     Raises:
       KeyError: if the repository does not have a working tree
     """
     with open_repo_closing(repo) as r:
         branch_name = active_branch(r.path)
         config = r.get_config()
         try:
             remote_name = config.get((b"branch", branch_name), b"remote")
         except KeyError:
             remote_name = b"origin"
     return remote_name
 
 
 def _import_remote_refs(
     refs_container: RefsContainer,
     remote_name: str,
     refs: Dict[str, str],
     message: Optional[bytes] = None,
     prune: bool = False,
     prune_tags: bool = False,
 ):
     stripped_refs = strip_peeled_refs(refs)
     branches = {
         n[len(LOCAL_BRANCH_PREFIX) :]: v
         for (n, v) in stripped_refs.items()
         if n.startswith(LOCAL_BRANCH_PREFIX)
     }
     refs_container.import_refs(
         b"refs/remotes/" + remote_name.encode(),
         branches,
         message=message,
         prune=prune,
     )
     tags = {
         n[len(b"refs/tags/") :]: v
         for (n, v) in stripped_refs.items()
         if n.startswith(b"refs/tags/") and not n.endswith(ANNOTATED_TAG_SUFFIX)
     }
     refs_container.import_refs(b"refs/tags", tags, message=message, prune=prune_tags)
 
 
 def fetch(
     repo,
     remote_location=None,
     outstream=sys.stdout,
     errstream=default_bytes_err_stream,
     message=None,
     depth=None,
     prune=False,
     prune_tags=False,
     force=False,
     **kwargs
 ):
     """Fetch objects from a remote server.
 
     Args:
       repo: Path to the repository
       remote_location: String identifying a remote server
       outstream: Output stream (defaults to stdout)
       errstream: Error stream (defaults to stderr)
       message: Reflog message (defaults to b"fetch: from <remote_name>")
       depth: Depth to fetch at
       prune: Prune remote removed refs
       prune_tags: Prune reomte removed tags
     Returns:
       Dictionary with refs on the remote
     """
     with open_repo_closing(repo) as r:
         (remote_name, remote_location) = get_remote_repo(r, remote_location)
         if message is None:
             message = b"fetch: from " + remote_location.encode("utf-8")
         client, path = get_transport_and_path(
             remote_location, config=r.get_config_stack(), **kwargs
         )
         fetch_result = client.fetch(path, r, progress=errstream.write, depth=depth)
         if remote_name is not None:
             _import_remote_refs(
                 r.refs,
                 remote_name,
                 fetch_result.refs,
                 message,
                 prune=prune,
                 prune_tags=prune_tags,
             )
     return fetch_result
 
 
 def ls_remote(remote, config=None, **kwargs):
     """List the refs in a remote.
 
     Args:
       remote: Remote repository location
       config: Configuration to use
     Returns:
       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.
 
     Args:
       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.
 
     Args:
       repo: Path to the repository
       object_ids: List of object ids to write
       packf: File-like object to write to
       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.
 
     Args:
       repo: Path to the repository
       tree_ish: Tree id to list
       outstream: Output stream (defaults to stdout)
       recursive: Whether to recursively list files
       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) and recursive:
                 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.
 
     Args:
       repo: Path to the repository
       name: Remote name
       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.
 
     Args:
       repo: Path to the repository
       paths: List of paths to check for
       no_index: Don't check index
     Returns: 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 not no_index and path_to_tree_path(r.path, path) in index:
                 continue
             if os.path.isabs(path):
                 path = os.path.relpath(path, r.path)
             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.
 
     Args:
       repo: Path to the repository
       detach: Create a detached head
       target: Branch or committish to switch to
       new_branch: New branch to create
     """
     with open_repo_closing(repo) as r:
         if new_branch is not None:
             to_set = _make_branch_ref(new_branch)
         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)
 
 
 def check_mailmap(repo, contact):
     """Check canonical name and email of contact.
 
     Args:
       repo: Path to the repository
       contact: Contact name and/or email
     Returns: Canonical contact data
     """
     with open_repo_closing(repo) as r:
         from dulwich.mailmap import Mailmap
 
         try:
             mailmap = Mailmap.from_path(os.path.join(r.path, ".mailmap"))
         except FileNotFoundError:
             mailmap = Mailmap()
         return mailmap.lookup(contact)
 
 
 def fsck(repo):
     """Check a repository.
 
     Args:
       repo: A path to the repository
     Returns: Iterator over errors/warnings
     """
     with open_repo_closing(repo) as r:
         # TODO(jelmer): check pack files
         # TODO(jelmer): check graph
         # TODO(jelmer): check refs
         for sha in r.object_store:
             o = r.object_store[sha]
             try:
                 o.check()
             except Exception as e:
                 yield (sha, e)
 
 
 def stash_list(repo):
     """List all stashes in a repository."""
     with open_repo_closing(repo) as r:
         from dulwich.stash import Stash
 
         stash = Stash.from_repo(r)
         return enumerate(list(stash.stashes()))
 
 
 def stash_push(repo):
     """Push a new stash onto the stack."""
     with open_repo_closing(repo) as r:
         from dulwich.stash import Stash
 
         stash = Stash.from_repo(r)
         stash.push()
 
 
 def stash_pop(repo):
     """Pop a new stash from the stack."""
     with open_repo_closing(repo) as r:
         from dulwich.stash import Stash
 
         stash = Stash.from_repo(r)
         stash.pop()
 
 
 def ls_files(repo):
     """List all files in an index."""
     with open_repo_closing(repo) as r:
         return sorted(r.open_index())
 
 
 def describe(repo):
     """Describe the repository version.
 
     Args:
       projdir: git repository root
     Returns: a string description of the current git revision
 
     Examples: "gabcdefh", "v0.1" or "v0.1-5-gabcdefh".
     """
     # Get the repository
     with open_repo_closing(repo) as r:
         # Get a list of all tags
         refs = r.get_refs()
         tags = {}
         for key, value in refs.items():
             key = key.decode()
             obj = r.get_object(value)
             if u"tags" not in key:
                 continue
 
             _, tag = key.rsplit(u"/", 1)
 
             try:
                 commit = obj.object
             except AttributeError:
                 continue
             else:
                 commit = r.get_object(commit[1])
             tags[tag] = [
                 datetime.datetime(*time.gmtime(commit.commit_time)[:6]),
                 commit.id.decode("ascii"),
             ]
 
         sorted_tags = sorted(tags.items(), key=lambda tag: tag[1][0], reverse=True)
 
         # If there are no tags, return the current commit
         if len(sorted_tags) == 0:
             return "g{}".format(r[r.head()].id.decode("ascii")[:7])
 
         # We're now 0 commits from the top
         commit_count = 0
 
         # Get the latest commit
         latest_commit = r[r.head()]
 
         # Walk through all commits
         walker = r.get_walker()
         for entry in walker:
             # Check if tag
             commit_id = entry.commit.id.decode("ascii")
             for tag in sorted_tags:
                 tag_name = tag[0]
                 tag_commit = tag[1][1]
                 if commit_id == tag_commit:
                     if commit_count == 0:
                         return tag_name
                     else:
                         return "{}-{}-g{}".format(
                             tag_name,
                             commit_count,
                             latest_commit.id.decode("ascii")[:7],
                         )
 
             commit_count += 1
 
         # Return plain commit if no parent tag can be found
         return "g{}".format(latest_commit.id.decode("ascii")[:7])
 
 
 def get_object_by_path(repo, path, committish=None):
     """Get an object by path.
 
     Args:
       repo: A path to the repository
       path: Path to look up
       committish: Commit to look up path in
     Returns: A `ShaFile` object
     """
     if committish is None:
         committish = "HEAD"
     # Get the repository
     with open_repo_closing(repo) as r:
         commit = parse_commit(r, committish)
         base_tree = commit.tree
         if not isinstance(path, bytes):
             path = commit_encode(commit, path)
         (mode, sha) = tree_lookup_path(r.object_store.__getitem__, base_tree, path)
         return r[sha]
 
 
 def write_tree(repo):
     """Write a tree object from the index.
 
     Args:
       repo: Repository for which to write tree
     Returns: tree id for the tree that was written
     """
     with open_repo_closing(repo) as r:
         return r.open_index().commit(r.object_store)
diff --git a/dulwich/server.py b/dulwich/server.py
index 0cff125d..7e8da3c9 100644
--- a/dulwich/server.py
+++ b/dulwich/server.py
@@ -1,1278 +1,1278 @@
 # server.py -- Implementation of the server side git protocols
 # Copyright (C) 2008 John Carr <john.carr@unrouted.co.uk>
 # Coprygith (C) 2011-2012 Jelmer Vernooij <jelmer@jelmer.uk>
 #
 # 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.
 #
 
 """Git smart network protocol server implementation.
 
 For more detailed implementation on the network protocol, see the
 Documentation/technical directory in the cgit distribution, and in particular:
 
 * Documentation/technical/protocol-capabilities.txt
 * Documentation/technical/pack-protocol.txt
 
 Currently supported capabilities:
 
  * include-tag
  * thin-pack
  * multi_ack_detailed
  * multi_ack
  * side-band-64k
  * ofs-delta
  * no-progress
  * report-status
  * delete-refs
  * shallow
  * symref
 """
 
 import collections
 import os
 import socket
 import sys
 import time
 from typing import List, Tuple, Dict, Optional, Iterable
 import zlib
 
 import socketserver
 
 from dulwich.archive import tar_stream
 from dulwich.errors import (
     ApplyDeltaError,
     ChecksumMismatch,
     GitProtocolError,
     HookError,
     NotGitRepository,
     UnexpectedCommandError,
     ObjectFormatException,
 )
 from dulwich import log_utils
 from dulwich.objects import (
     Commit,
     valid_hexsha,
 )
 from dulwich.pack import (
     write_pack_objects,
 )
 from dulwich.protocol import (  # noqa: F401
     BufferedPktLineWriter,
     capability_agent,
     CAPABILITIES_REF,
     CAPABILITY_AGENT,
     CAPABILITY_DELETE_REFS,
     CAPABILITY_INCLUDE_TAG,
     CAPABILITY_MULTI_ACK_DETAILED,
     CAPABILITY_MULTI_ACK,
     CAPABILITY_NO_DONE,
     CAPABILITY_NO_PROGRESS,
     CAPABILITY_OFS_DELTA,
     CAPABILITY_QUIET,
     CAPABILITY_REPORT_STATUS,
     CAPABILITY_SHALLOW,
     CAPABILITY_SIDE_BAND_64K,
     CAPABILITY_THIN_PACK,
     COMMAND_DEEPEN,
     COMMAND_DONE,
     COMMAND_HAVE,
     COMMAND_SHALLOW,
     COMMAND_UNSHALLOW,
     COMMAND_WANT,
     MULTI_ACK,
     MULTI_ACK_DETAILED,
     Protocol,
     ProtocolFile,
     ReceivableProtocol,
     SIDE_BAND_CHANNEL_DATA,
     SIDE_BAND_CHANNEL_PROGRESS,
     SIDE_BAND_CHANNEL_FATAL,
     SINGLE_ACK,
     TCP_GIT_PORT,
     ZERO_SHA,
     ack_type,
     extract_capabilities,
     extract_want_line_capabilities,
     symref_capabilities,
 )
 from dulwich.refs import (
     ANNOTATED_TAG_SUFFIX,
     write_info_refs,
 )
 from dulwich.repo import (
     BaseRepo,
     Repo,
 )
 
 
 logger = log_utils.getLogger(__name__)
 
 
 class Backend(object):
     """A backend for the Git smart server implementation."""
 
     def open_repository(self, path):
         """Open the repository at a path.
 
         Args:
           path: Path to the repository
         Raises:
           NotGitRepository: no git repository was found at path
         Returns: Instance of BackendRepo
         """
         raise NotImplementedError(self.open_repository)
 
 
 class BackendRepo(object):
     """Repository abstraction used by the Git server.
 
     The methods required here are a subset of those provided by
     dulwich.repo.Repo.
     """
 
     object_store = None
     refs = None
 
     def get_refs(self) -> Dict[bytes, bytes]:
         """
         Get all the refs in the repository
 
         Returns: dict of name -> sha
         """
         raise NotImplementedError
 
     def get_peeled(self, name: bytes) -> Optional[bytes]:
         """Return the cached peeled value of a ref, if available.
 
         Args:
           name: Name of the ref to peel
         Returns: 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 no cached
             information about a tag is available, this method may return None,
             but it should attempt to peel the tag if possible.
         """
         return None
 
     def fetch_objects(self, determine_wants, graph_walker, progress, get_tagged=None):
         """
         Yield the objects required for a list of commits.
 
         Args:
           progress: is a callback to send progress messages to the client
           get_tagged: Function that returns a dict of pointed-to sha ->
             tag sha for including tags.
         """
         raise NotImplementedError
 
 
 class DictBackend(Backend):
     """Trivial backend that looks up Git repositories in a dictionary."""
 
     def __init__(self, repos):
         self.repos = repos
 
     def open_repository(self, path: str) -> BaseRepo:
         logger.debug("Opening repository at %s", path)
         try:
             return self.repos[path]
         except KeyError:
             raise NotGitRepository(
                 "No git repository was found at %(path)s" % dict(path=path)
             )
 
 
 class FileSystemBackend(Backend):
     """Simple backend looking up Git repositories in the local file system."""
 
     def __init__(self, root=os.sep):
         super(FileSystemBackend, self).__init__()
         self.root = (os.path.abspath(root) + os.sep).replace(os.sep * 2, os.sep)
 
     def open_repository(self, path):
         logger.debug("opening repository at %s", path)
         abspath = os.path.abspath(os.path.join(self.root, path)) + os.sep
         normcase_abspath = os.path.normcase(abspath)
         normcase_root = os.path.normcase(self.root)
         if not normcase_abspath.startswith(normcase_root):
             raise NotGitRepository("Path %r not inside root %r" % (path, self.root))
         return Repo(abspath)
 
 
 class Handler(object):
     """Smart protocol command handler base class."""
 
     def __init__(self, backend, proto, stateless_rpc=None):
         self.backend = backend
         self.proto = proto
         self.stateless_rpc = stateless_rpc
 
     def handle(self):
         raise NotImplementedError(self.handle)
 
 
 class PackHandler(Handler):
     """Protocol handler for packs."""
 
     def __init__(self, backend, proto, stateless_rpc=None):
         super(PackHandler, self).__init__(backend, proto, stateless_rpc)
         self._client_capabilities = None
         # Flags needed for the no-done capability
         self._done_received = False
 
     @classmethod
     def capability_line(cls, capabilities):
         logger.info("Sending capabilities: %s", capabilities)
         return b"".join([b" " + c for c in capabilities])
 
     @classmethod
     def capabilities(cls) -> Iterable[bytes]:
         raise NotImplementedError(cls.capabilities)
 
     @classmethod
     def innocuous_capabilities(cls) -> Iterable[bytes]:
         return [
             CAPABILITY_INCLUDE_TAG,
             CAPABILITY_THIN_PACK,
             CAPABILITY_NO_PROGRESS,
             CAPABILITY_OFS_DELTA,
             capability_agent(),
         ]
 
     @classmethod
     def required_capabilities(cls) -> Iterable[bytes]:
         """Return a list of capabilities that we require the client to have."""
         return []
 
     def set_client_capabilities(self, caps: Iterable[bytes]) -> None:
         allowable_caps = set(self.innocuous_capabilities())
         allowable_caps.update(self.capabilities())
         for cap in caps:
             if cap.startswith(CAPABILITY_AGENT + b"="):
                 continue
             if cap not in allowable_caps:
                 raise GitProtocolError(
                     "Client asked for capability %r that " "was not advertised." % cap
                 )
         for cap in self.required_capabilities():
             if cap not in caps:
                 raise GitProtocolError(
                     "Client does not support required " "capability %r." % cap
                 )
         self._client_capabilities = set(caps)
         logger.info("Client capabilities: %s", caps)
 
     def has_capability(self, cap: bytes) -> bool:
         if self._client_capabilities is None:
             raise GitProtocolError(
                 "Server attempted to access capability %r " "before asking client" % cap
             )
         return cap in self._client_capabilities
 
     def notify_done(self) -> None:
         self._done_received = True
 
 
 class UploadPackHandler(PackHandler):
     """Protocol handler for uploading a pack to the client."""
 
     def __init__(self, backend, args, proto, stateless_rpc=None, advertise_refs=False):
         super(UploadPackHandler, self).__init__(
             backend, proto, stateless_rpc=stateless_rpc
         )
         self.repo = backend.open_repository(args[0])
         self._graph_walker = None
         self.advertise_refs = advertise_refs
         # A state variable for denoting that the have list is still
         # being processed, and the client is not accepting any other
         # data (such as side-band, see the progress method here).
         self._processing_have_lines = False
 
     @classmethod
     def capabilities(cls):
         return [
             CAPABILITY_MULTI_ACK_DETAILED,
             CAPABILITY_MULTI_ACK,
             CAPABILITY_SIDE_BAND_64K,
             CAPABILITY_THIN_PACK,
             CAPABILITY_OFS_DELTA,
             CAPABILITY_NO_PROGRESS,
             CAPABILITY_INCLUDE_TAG,
             CAPABILITY_SHALLOW,
             CAPABILITY_NO_DONE,
         ]
 
     @classmethod
     def required_capabilities(cls):
         return (
             CAPABILITY_SIDE_BAND_64K,
             CAPABILITY_THIN_PACK,
             CAPABILITY_OFS_DELTA,
         )
 
     def progress(self, message):
         if self.has_capability(CAPABILITY_NO_PROGRESS) or self._processing_have_lines:
             return
         self.proto.write_sideband(SIDE_BAND_CHANNEL_PROGRESS, message)
 
     def get_tagged(self, refs=None, repo=None):
         """Get a dict of peeled values of tags to their original tag shas.
 
         Args:
           refs: dict of refname -> sha of possible tags; defaults to all
             of the backend's refs.
           repo: optional Repo instance for getting peeled refs; defaults
             to the backend's repo, if available
         Returns: dict of peeled_sha -> tag_sha, where tag_sha is the sha of a
             tag whose peeled value is peeled_sha.
         """
         if not self.has_capability(CAPABILITY_INCLUDE_TAG):
             return {}
         if refs is None:
             refs = self.repo.get_refs()
         if repo is None:
             repo = getattr(self.repo, "repo", None)
             if repo is None:
                 # Bail if we don't have a Repo available; this is ok since
                 # clients must be able to handle if the server doesn't include
                 # all relevant tags.
                 # TODO: fix behavior when missing
                 return {}
         # TODO(jelmer): Integrate this with the refs logic in
         # Repo.fetch_objects
         tagged = {}
         for name, sha in refs.items():
             peeled_sha = repo.get_peeled(name)
             if peeled_sha != sha:
                 tagged[peeled_sha] = sha
         return tagged
 
     def handle(self):
         def write(x):
             return self.proto.write_sideband(SIDE_BAND_CHANNEL_DATA, x)
 
         graph_walker = _ProtocolGraphWalker(
             self,
             self.repo.object_store,
             self.repo.get_peeled,
             self.repo.refs.get_symrefs,
         )
         wants = []
 
-        def wants_wrapper(refs):
-            wants.extend(graph_walker.determine_wants(refs))
+        def wants_wrapper(refs, **kwargs):
+            wants.extend(graph_walker.determine_wants(refs, **kwargs))
             return wants
 
         objects_iter = self.repo.fetch_objects(
             wants_wrapper,
             graph_walker,
             self.progress,
             get_tagged=self.get_tagged,
         )
 
         # Note the fact that client is only processing responses related
         # to the have lines it sent, and any other data (including side-
         # band) will be be considered a fatal error.
         self._processing_have_lines = True
 
         # Did the process short-circuit (e.g. in a stateless RPC call)? Note
         # that the client still expects a 0-object pack in most cases.
         # Also, if it also happens that the object_iter is instantiated
         # with a graph walker with an implementation that talks over the
         # wire (which is this instance of this class) this will actually
         # iterate through everything and write things out to the wire.
         if len(wants) == 0:
             return
 
         # The provided haves are processed, and it is safe to send side-
         # band data now.
         self._processing_have_lines = False
 
         if not graph_walker.handle_done(
             not self.has_capability(CAPABILITY_NO_DONE), self._done_received
         ):
             return
 
         self.progress(
             ("counting objects: %d, done.\n" % len(objects_iter)).encode("ascii")
         )
         write_pack_objects(ProtocolFile(None, write), objects_iter)
         # we are done
         self.proto.write_pkt_line(None)
 
 
 def _split_proto_line(line, allowed):
     """Split a line read from the wire.
 
     Args:
       line: The line read from the wire.
       allowed: An iterable of command names that should be allowed.
         Command names not listed below as possible return values will be
         ignored.  If None, any commands from the possible return values are
         allowed.
     Returns: a tuple having one of the following forms:
         ('want', obj_id)
         ('have', obj_id)
         ('done', None)
         (None, None)  (for a flush-pkt)
 
     Raises:
       UnexpectedCommandError: if the line cannot be parsed into one of the
         allowed return values.
     """
     if not line:
         fields = [None]
     else:
         fields = line.rstrip(b"\n").split(b" ", 1)
     command = fields[0]
     if allowed is not None and command not in allowed:
         raise UnexpectedCommandError(command)
     if len(fields) == 1 and command in (COMMAND_DONE, None):
         return (command, None)
     elif len(fields) == 2:
         if command in (
             COMMAND_WANT,
             COMMAND_HAVE,
             COMMAND_SHALLOW,
             COMMAND_UNSHALLOW,
         ):
             if not valid_hexsha(fields[1]):
                 raise GitProtocolError("Invalid sha")
             return tuple(fields)
         elif command == COMMAND_DEEPEN:
             return command, int(fields[1])
     raise GitProtocolError("Received invalid line from client: %r" % line)
 
 
 def _find_shallow(store, heads, depth):
     """Find shallow commits according to a given depth.
 
     Args:
       store: An ObjectStore for looking up objects.
       heads: Iterable of head SHAs to start walking from.
       depth: The depth of ancestors to include. A depth of one includes
         only the heads themselves.
     Returns: A tuple of (shallow, not_shallow), sets of SHAs that should be
         considered shallow and unshallow according to the arguments. Note that
         these sets may overlap if a commit is reachable along multiple paths.
     """
     parents = {}
 
     def get_parents(sha):
         result = parents.get(sha, None)
         if not result:
             result = store[sha].parents
             parents[sha] = result
         return result
 
     todo = []  # stack of (sha, depth)
     for head_sha in heads:
         obj = store.peel_sha(head_sha)
         if isinstance(obj, Commit):
             todo.append((obj.id, 1))
 
     not_shallow = set()
     shallow = set()
     while todo:
         sha, cur_depth = todo.pop()
         if cur_depth < depth:
             not_shallow.add(sha)
             new_depth = cur_depth + 1
             todo.extend((p, new_depth) for p in get_parents(sha))
         else:
             shallow.add(sha)
 
     return shallow, not_shallow
 
 
 def _want_satisfied(store, haves, want, earliest):
     o = store[want]
     pending = collections.deque([o])
     known = set([want])
     while pending:
         commit = pending.popleft()
         if commit.id in haves:
             return True
         if commit.type_name != b"commit":
             # non-commit wants are assumed to be satisfied
             continue
         for parent in commit.parents:
             if parent in known:
                 continue
             known.add(parent)
             parent_obj = store[parent]
             # TODO: handle parents with later commit times than children
             if parent_obj.commit_time >= earliest:
                 pending.append(parent_obj)
     return False
 
 
 def _all_wants_satisfied(store, haves, wants):
     """Check whether all the current wants are satisfied by a set of haves.
 
     Args:
       store: Object store to retrieve objects from
       haves: A set of commits we know the client has.
       wants: A set of commits the client wants
     Note: Wants are specified with set_wants rather than passed in since
         in the current interface they are determined outside this class.
     """
     haves = set(haves)
     if haves:
         earliest = min([store[h].commit_time for h in haves])
     else:
         earliest = 0
     for want in wants:
         if not _want_satisfied(store, haves, want, earliest):
             return False
 
     return True
 
 
 class _ProtocolGraphWalker(object):
     """A graph walker that knows the git protocol.
 
     As a graph walker, this class implements ack(), next(), and reset(). It
     also contains some base methods for interacting with the wire and walking
     the commit tree.
 
     The work of determining which acks to send is passed on to the
     implementation instance stored in _impl. The reason for this is that we do
     not know at object creation time what ack level the protocol requires. A
     call to set_ack_type() is required to set up the implementation, before
     any calls to next() or ack() are made.
     """
 
     def __init__(self, handler, object_store, get_peeled, get_symrefs):
         self.handler = handler
         self.store = object_store
         self.get_peeled = get_peeled
         self.get_symrefs = get_symrefs
         self.proto = handler.proto
         self.stateless_rpc = handler.stateless_rpc
         self.advertise_refs = handler.advertise_refs
         self._wants = []
         self.shallow = set()
         self.client_shallow = set()
         self.unshallow = set()
         self._cached = False
         self._cache = []
         self._cache_index = 0
         self._impl = None
 
-    def determine_wants(self, heads):
+    def determine_wants(self, heads, depth=None):
         """Determine the wants for a set of heads.
 
         The given heads are advertised to the client, who then specifies which
         refs they want using 'want' lines. This portion of the protocol is the
         same regardless of ack type, and in fact is used to set the ack type of
         the ProtocolGraphWalker.
 
         If the client has the 'shallow' capability, this method also reads and
         responds to the 'shallow' and 'deepen' lines from the client. These are
         not part of the wants per se, but they set up necessary state for
         walking the graph. Additionally, later code depends on this method
         consuming everything up to the first 'have' line.
 
         Args:
           heads: a dict of refname->SHA1 to advertise
         Returns: a list of SHA1s requested by the client
         """
         symrefs = self.get_symrefs()
         values = set(heads.values())
         if self.advertise_refs or not self.stateless_rpc:
             for i, (ref, sha) in enumerate(sorted(heads.items())):
                 try:
                     peeled_sha = self.get_peeled(ref)
                 except KeyError:
                     # Skip refs that are inaccessible
                     # TODO(jelmer): Integrate with Repo.fetch_objects refs
                     # logic.
                     continue
                 line = sha + b" " + ref
                 if not i:
                     line += b"\x00" + self.handler.capability_line(
                         self.handler.capabilities()
                         + symref_capabilities(symrefs.items())
                     )
                 self.proto.write_pkt_line(line + b"\n")
                 if peeled_sha != sha:
                     self.proto.write_pkt_line(
                         peeled_sha + b" " + ref + ANNOTATED_TAG_SUFFIX + b"\n"
                     )
 
             # i'm done..
             self.proto.write_pkt_line(None)
 
             if self.advertise_refs:
                 return []
 
         # Now client will sending want want want commands
         want = self.proto.read_pkt_line()
         if not want:
             return []
         line, caps = extract_want_line_capabilities(want)
         self.handler.set_client_capabilities(caps)
         self.set_ack_type(ack_type(caps))
         allowed = (COMMAND_WANT, COMMAND_SHALLOW, COMMAND_DEEPEN, None)
         command, sha = _split_proto_line(line, allowed)
 
         want_revs = []
         while command == COMMAND_WANT:
             if sha not in values:
                 raise GitProtocolError("Client wants invalid object %s" % sha)
             want_revs.append(sha)
             command, sha = self.read_proto_line(allowed)
 
         self.set_wants(want_revs)
         if command in (COMMAND_SHALLOW, COMMAND_DEEPEN):
             self.unread_proto_line(command, sha)
             self._handle_shallow_request(want_revs)
 
         if self.stateless_rpc and self.proto.eof():
             # The client may close the socket at this point, expecting a
             # flush-pkt from the server. We might be ready to send a packfile
             # at this point, so we need to explicitly short-circuit in this
             # case.
             return []
 
         return want_revs
 
     def unread_proto_line(self, command, value):
         if isinstance(value, int):
             value = str(value).encode("ascii")
         self.proto.unread_pkt_line(command + b" " + value)
 
     def ack(self, have_ref):
         if len(have_ref) != 40:
             raise ValueError("invalid sha %r" % have_ref)
         return self._impl.ack(have_ref)
 
     def reset(self):
         self._cached = True
         self._cache_index = 0
 
     def next(self):
         if not self._cached:
             if not self._impl and self.stateless_rpc:
                 return None
             return next(self._impl)
         self._cache_index += 1
         if self._cache_index > len(self._cache):
             return None
         return self._cache[self._cache_index]
 
     __next__ = next
 
     def read_proto_line(self, allowed):
         """Read a line from the wire.
 
         Args:
           allowed: An iterable of command names that should be allowed.
         Returns: A tuple of (command, value); see _split_proto_line.
         Raises:
           UnexpectedCommandError: If an error occurred reading the line.
         """
         return _split_proto_line(self.proto.read_pkt_line(), allowed)
 
     def _handle_shallow_request(self, wants):
         while True:
             command, val = self.read_proto_line((COMMAND_DEEPEN, COMMAND_SHALLOW))
             if command == COMMAND_DEEPEN:
                 depth = val
                 break
             self.client_shallow.add(val)
         self.read_proto_line((None,))  # consume client's flush-pkt
 
         shallow, not_shallow = _find_shallow(self.store, wants, depth)
 
         # Update self.shallow instead of reassigning it since we passed a
         # reference to it before this method was called.
         self.shallow.update(shallow - not_shallow)
         new_shallow = self.shallow - self.client_shallow
         unshallow = self.unshallow = not_shallow & self.client_shallow
 
         for sha in sorted(new_shallow):
             self.proto.write_pkt_line(COMMAND_SHALLOW + b" " + sha)
         for sha in sorted(unshallow):
             self.proto.write_pkt_line(COMMAND_UNSHALLOW + b" " + sha)
 
         self.proto.write_pkt_line(None)
 
     def notify_done(self):
         # relay the message down to the handler.
         self.handler.notify_done()
 
     def send_ack(self, sha, ack_type=b""):
         if ack_type:
             ack_type = b" " + ack_type
         self.proto.write_pkt_line(b"ACK " + sha + ack_type + b"\n")
 
     def send_nak(self):
         self.proto.write_pkt_line(b"NAK\n")
 
     def handle_done(self, done_required, done_received):
         # Delegate this to the implementation.
         return self._impl.handle_done(done_required, done_received)
 
     def set_wants(self, wants):
         self._wants = wants
 
     def all_wants_satisfied(self, haves):
         """Check whether all the current wants are satisfied by a set of haves.
 
         Args:
           haves: A set of commits we know the client has.
         Note: Wants are specified with set_wants rather than passed in since
             in the current interface they are determined outside this class.
         """
         return _all_wants_satisfied(self.store, haves, self._wants)
 
     def set_ack_type(self, ack_type):
         impl_classes = {
             MULTI_ACK: MultiAckGraphWalkerImpl,
             MULTI_ACK_DETAILED: MultiAckDetailedGraphWalkerImpl,
             SINGLE_ACK: SingleAckGraphWalkerImpl,
         }
         self._impl = impl_classes[ack_type](self)
 
 
 _GRAPH_WALKER_COMMANDS = (COMMAND_HAVE, COMMAND_DONE, None)
 
 
 class SingleAckGraphWalkerImpl(object):
     """Graph walker implementation that speaks the single-ack protocol."""
 
     def __init__(self, walker):
         self.walker = walker
         self._common = []
 
     def ack(self, have_ref):
         if not self._common:
             self.walker.send_ack(have_ref)
             self._common.append(have_ref)
 
     def next(self):
         command, sha = self.walker.read_proto_line(_GRAPH_WALKER_COMMANDS)
         if command in (None, COMMAND_DONE):
             # defer the handling of done
             self.walker.notify_done()
             return None
         elif command == COMMAND_HAVE:
             return sha
 
     __next__ = next
 
     def handle_done(self, done_required, done_received):
         if not self._common:
             self.walker.send_nak()
 
         if done_required and not done_received:
             # we are not done, especially when done is required; skip
             # the pack for this request and especially do not handle
             # the done.
             return False
 
         if not done_received and not self._common:
             # Okay we are not actually done then since the walker picked
             # up no haves.  This is usually triggered when client attempts
             # to pull from a source that has no common base_commit.
             # See: test_server.MultiAckDetailedGraphWalkerImplTestCase.\
             #          test_multi_ack_stateless_nodone
             return False
 
         return True
 
 
 class MultiAckGraphWalkerImpl(object):
     """Graph walker implementation that speaks the multi-ack protocol."""
 
     def __init__(self, walker):
         self.walker = walker
         self._found_base = False
         self._common = []
 
     def ack(self, have_ref):
         self._common.append(have_ref)
         if not self._found_base:
             self.walker.send_ack(have_ref, b"continue")
             if self.walker.all_wants_satisfied(self._common):
                 self._found_base = True
         # else we blind ack within next
 
     def next(self):
         while True:
             command, sha = self.walker.read_proto_line(_GRAPH_WALKER_COMMANDS)
             if command is None:
                 self.walker.send_nak()
                 # in multi-ack mode, a flush-pkt indicates the client wants to
                 # flush but more have lines are still coming
                 continue
             elif command == COMMAND_DONE:
                 self.walker.notify_done()
                 return None
             elif command == COMMAND_HAVE:
                 if self._found_base:
                     # blind ack
                     self.walker.send_ack(sha, b"continue")
                 return sha
 
     __next__ = next
 
     def handle_done(self, done_required, done_received):
         if done_required and not done_received:
             # we are not done, especially when done is required; skip
             # the pack for this request and especially do not handle
             # the done.
             return False
 
         if not done_received and not self._common:
             # Okay we are not actually done then since the walker picked
             # up no haves.  This is usually triggered when client attempts
             # to pull from a source that has no common base_commit.
             # See: test_server.MultiAckDetailedGraphWalkerImplTestCase.\
             #          test_multi_ack_stateless_nodone
             return False
 
         # don't nak unless no common commits were found, even if not
         # everything is satisfied
         if self._common:
             self.walker.send_ack(self._common[-1])
         else:
             self.walker.send_nak()
         return True
 
 
 class MultiAckDetailedGraphWalkerImpl(object):
     """Graph walker implementation speaking the multi-ack-detailed protocol."""
 
     def __init__(self, walker):
         self.walker = walker
         self._common = []
 
     def ack(self, have_ref):
         # Should only be called iff have_ref is common
         self._common.append(have_ref)
         self.walker.send_ack(have_ref, b"common")
 
     def next(self):
         while True:
             command, sha = self.walker.read_proto_line(_GRAPH_WALKER_COMMANDS)
             if command is None:
                 if self.walker.all_wants_satisfied(self._common):
                     self.walker.send_ack(self._common[-1], b"ready")
                 self.walker.send_nak()
                 if self.walker.stateless_rpc:
                     # The HTTP version of this request a flush-pkt always
                     # signifies an end of request, so we also return
                     # nothing here as if we are done (but not really, as
                     # it depends on whether no-done capability was
                     # specified and that's handled in handle_done which
                     # may or may not call post_nodone_check depending on
                     # that).
                     return None
             elif command == COMMAND_DONE:
                 # Let the walker know that we got a done.
                 self.walker.notify_done()
                 break
             elif command == COMMAND_HAVE:
                 # return the sha and let the caller ACK it with the
                 # above ack method.
                 return sha
         # don't nak unless no common commits were found, even if not
         # everything is satisfied
 
     __next__ = next
 
     def handle_done(self, done_required, done_received):
         if done_required and not done_received:
             # we are not done, especially when done is required; skip
             # the pack for this request and especially do not handle
             # the done.
             return False
 
         if not done_received and not self._common:
             # Okay we are not actually done then since the walker picked
             # up no haves.  This is usually triggered when client attempts
             # to pull from a source that has no common base_commit.
             # See: test_server.MultiAckDetailedGraphWalkerImplTestCase.\
             #          test_multi_ack_stateless_nodone
             return False
 
         # don't nak unless no common commits were found, even if not
         # everything is satisfied
         if self._common:
             self.walker.send_ack(self._common[-1])
         else:
             self.walker.send_nak()
         return True
 
 
 class ReceivePackHandler(PackHandler):
     """Protocol handler for downloading a pack from the client."""
 
     def __init__(self, backend, args, proto, stateless_rpc=None, advertise_refs=False):
         super(ReceivePackHandler, self).__init__(
             backend, proto, stateless_rpc=stateless_rpc
         )
         self.repo = backend.open_repository(args[0])
         self.advertise_refs = advertise_refs
 
     @classmethod
     def capabilities(cls) -> Iterable[bytes]:
         return [
             CAPABILITY_REPORT_STATUS,
             CAPABILITY_DELETE_REFS,
             CAPABILITY_QUIET,
             CAPABILITY_OFS_DELTA,
             CAPABILITY_SIDE_BAND_64K,
             CAPABILITY_NO_DONE,
         ]
 
     def _apply_pack(
         self, refs: List[Tuple[bytes, bytes, bytes]]
     ) -> List[Tuple[bytes, bytes]]:
         all_exceptions = (
             IOError,
             OSError,
             ChecksumMismatch,
             ApplyDeltaError,
             AssertionError,
             socket.error,
             zlib.error,
             ObjectFormatException,
         )
         status = []
         will_send_pack = False
 
         for command in refs:
             if command[1] != ZERO_SHA:
                 will_send_pack = True
 
         if will_send_pack:
             # TODO: more informative error messages than just the exception
             # string
             try:
                 recv = getattr(self.proto, "recv", None)
                 self.repo.object_store.add_thin_pack(self.proto.read, recv)
                 status.append((b"unpack", b"ok"))
             except all_exceptions as e:
                 status.append((b"unpack", str(e).replace("\n", "").encode("utf-8")))
                 # The pack may still have been moved in, but it may contain
                 # broken objects. We trust a later GC to clean it up.
         else:
             # The git protocol want to find a status entry related to unpack
             # process even if no pack data has been sent.
             status.append((b"unpack", b"ok"))
 
         for oldsha, sha, ref in refs:
             ref_status = b"ok"
             try:
                 if sha == ZERO_SHA:
                     if CAPABILITY_DELETE_REFS not in self.capabilities():
                         raise GitProtocolError(
                             "Attempted to delete refs without delete-refs "
                             "capability."
                         )
                     try:
                         self.repo.refs.remove_if_equals(ref, oldsha)
                     except all_exceptions:
                         ref_status = b"failed to delete"
                 else:
                     try:
                         self.repo.refs.set_if_equals(ref, oldsha, sha)
                     except all_exceptions:
                         ref_status = b"failed to write"
             except KeyError:
                 ref_status = b"bad ref"
             status.append((ref, ref_status))
 
         return status
 
     def _report_status(self, status: List[Tuple[bytes, bytes]]) -> None:
         if self.has_capability(CAPABILITY_SIDE_BAND_64K):
             writer = BufferedPktLineWriter(
                 lambda d: self.proto.write_sideband(SIDE_BAND_CHANNEL_DATA, d)
             )
             write = writer.write
 
             def flush():
                 writer.flush()
                 self.proto.write_pkt_line(None)
 
         else:
             write = self.proto.write_pkt_line
 
             def flush():
                 pass
 
         for name, msg in status:
             if name == b"unpack":
                 write(b"unpack " + msg + b"\n")
             elif msg == b"ok":
                 write(b"ok " + name + b"\n")
             else:
                 write(b"ng " + name + b" " + msg + b"\n")
         write(None)
         flush()
 
     def _on_post_receive(self, client_refs):
         hook = self.repo.hooks.get("post-receive", None)
         if not hook:
             return
         try:
             output = hook.execute(client_refs)
             if output:
                 self.proto.write_sideband(SIDE_BAND_CHANNEL_PROGRESS, output)
         except HookError as err:
             self.proto.write_sideband(SIDE_BAND_CHANNEL_FATAL, str(err).encode('utf-8'))
 
     def handle(self) -> None:
         if self.advertise_refs or not self.stateless_rpc:
             refs = sorted(self.repo.get_refs().items())
             symrefs = sorted(self.repo.refs.get_symrefs().items())
 
             if not refs:
                 refs = [(CAPABILITIES_REF, ZERO_SHA)]
             self.proto.write_pkt_line(
                 refs[0][1]
                 + b" "
                 + refs[0][0]
                 + b"\0"
                 + self.capability_line(
                     self.capabilities() + symref_capabilities(symrefs)
                 )
                 + b"\n"
             )
             for i in range(1, len(refs)):
                 ref = refs[i]
                 self.proto.write_pkt_line(ref[1] + b" " + ref[0] + b"\n")
 
             self.proto.write_pkt_line(None)
             if self.advertise_refs:
                 return
 
         client_refs = []
         ref = self.proto.read_pkt_line()
 
         # if ref is none then client doesnt want to send us anything..
         if ref is None:
             return
 
         ref, caps = extract_capabilities(ref)
         self.set_client_capabilities(caps)
 
         # client will now send us a list of (oldsha, newsha, ref)
         while ref:
             client_refs.append(ref.split())
             ref = self.proto.read_pkt_line()
 
         # backend can now deal with this refs and read a pack using self.read
         status = self._apply_pack(client_refs)
 
         self._on_post_receive(client_refs)
 
         # when we have read all the pack from the client, send a status report
         # if the client asked for it
         if self.has_capability(CAPABILITY_REPORT_STATUS):
             self._report_status(status)
 
 
 class UploadArchiveHandler(Handler):
     def __init__(self, backend, args, proto, stateless_rpc=None):
         super(UploadArchiveHandler, self).__init__(backend, proto, stateless_rpc)
         self.repo = backend.open_repository(args[0])
 
     def handle(self):
         def write(x):
             return self.proto.write_sideband(SIDE_BAND_CHANNEL_DATA, x)
 
         arguments = []
         for pkt in self.proto.read_pkt_seq():
             (key, value) = pkt.split(b" ", 1)
             if key != b"argument":
                 raise GitProtocolError("unknown command %s" % key)
             arguments.append(value.rstrip(b"\n"))
         prefix = b""
         format = "tar"
         i = 0
         store = self.repo.object_store
         while i < len(arguments):
             argument = arguments[i]
             if argument == b"--prefix":
                 i += 1
                 prefix = arguments[i]
             elif argument == b"--format":
                 i += 1
                 format = arguments[i].decode("ascii")
             else:
                 commit_sha = self.repo.refs[argument]
                 tree = store[store[commit_sha].tree]
             i += 1
         self.proto.write_pkt_line(b"ACK")
         self.proto.write_pkt_line(None)
         for chunk in tar_stream(
             store, tree, mtime=time.time(), prefix=prefix, format=format
         ):
             write(chunk)
         self.proto.write_pkt_line(None)
 
 
 # Default handler classes for git services.
 DEFAULT_HANDLERS = {
     b"git-upload-pack": UploadPackHandler,
     b"git-receive-pack": ReceivePackHandler,
     b"git-upload-archive": UploadArchiveHandler,
 }
 
 
 class TCPGitRequestHandler(socketserver.StreamRequestHandler):
     def __init__(self, handlers, *args, **kwargs):
         self.handlers = handlers
         socketserver.StreamRequestHandler.__init__(self, *args, **kwargs)
 
     def handle(self):
         proto = ReceivableProtocol(self.connection.recv, self.wfile.write)
         command, args = proto.read_cmd()
         logger.info("Handling %s request, args=%s", command, args)
 
         cls = self.handlers.get(command, None)
         if not callable(cls):
             raise GitProtocolError("Invalid service %s" % command)
         h = cls(self.server.backend, args, proto)
         h.handle()
 
 
 class TCPGitServer(socketserver.TCPServer):
 
     allow_reuse_address = True
     serve = socketserver.TCPServer.serve_forever
 
     def _make_handler(self, *args, **kwargs):
         return TCPGitRequestHandler(self.handlers, *args, **kwargs)
 
     def __init__(self, backend, listen_addr, port=TCP_GIT_PORT, handlers=None):
         self.handlers = dict(DEFAULT_HANDLERS)
         if handlers is not None:
             self.handlers.update(handlers)
         self.backend = backend
         logger.info("Listening for TCP connections on %s:%d", listen_addr, port)
         socketserver.TCPServer.__init__(self, (listen_addr, port), self._make_handler)
 
     def verify_request(self, request, client_address):
         logger.info("Handling request from %s", client_address)
         return True
 
     def handle_error(self, request, client_address):
         logger.exception(
             "Exception happened during processing of request " "from %s",
             client_address,
         )
 
 
 def main(argv=sys.argv):
     """Entry point for starting a TCP git server."""
     import optparse
 
     parser = optparse.OptionParser()
     parser.add_option(
         "-l",
         "--listen_address",
         dest="listen_address",
         default="localhost",
         help="Binding IP address.",
     )
     parser.add_option(
         "-p",
         "--port",
         dest="port",
         type=int,
         default=TCP_GIT_PORT,
         help="Binding TCP port.",
     )
     options, args = parser.parse_args(argv)
 
     log_utils.default_logging_config()
     if len(args) > 1:
         gitdir = args[1]
     else:
         gitdir = "."
     # TODO(jelmer): Support git-daemon-export-ok and --export-all.
     backend = FileSystemBackend(gitdir)
     server = TCPGitServer(backend, options.listen_address, options.port)
     server.serve_forever()
 
 
 def serve_command(
     handler_cls, argv=sys.argv, backend=None, inf=sys.stdin, outf=sys.stdout
 ):
     """Serve a single command.
 
     This is mostly useful for the implementation of commands used by e.g.
     git+ssh.
 
     Args:
       handler_cls: `Handler` class to use for the request
       argv: execv-style command-line arguments. Defaults to sys.argv.
       backend: `Backend` to use
       inf: File-like object to read from, defaults to standard input.
       outf: File-like object to write to, defaults to standard output.
     Returns: Exit code for use with sys.exit. 0 on success, 1 on failure.
     """
     if backend is None:
         backend = FileSystemBackend()
 
     def send_fn(data):
         outf.write(data)
         outf.flush()
 
     proto = Protocol(inf.read, send_fn)
     handler = handler_cls(backend, argv[1:], proto)
     # FIXME: Catch exceptions and write a single-line summary to outf.
     handler.handle()
     return 0
 
 
 def generate_info_refs(repo):
     """Generate an info refs file."""
     refs = repo.get_refs()
     return write_info_refs(refs, repo.object_store)
 
 
 def generate_objects_info_packs(repo):
     """Generate an index for for packs."""
     for pack in repo.object_store.packs:
         yield (b"P " + os.fsencode(pack.data.filename) + b"\n")
 
 
 def update_server_info(repo):
     """Generate server info for dumb file access.
 
     This generates info/refs and objects/info/packs,
     similar to "git update-server-info".
     """
     repo._put_named_file(
         os.path.join("info", "refs"), b"".join(generate_info_refs(repo))
     )
 
     repo._put_named_file(
         os.path.join("objects", "info", "packs"),
         b"".join(generate_objects_info_packs(repo)),
     )
 
 
 if __name__ == "__main__":
     main()