.. _tutorial-remote:

Most of the tests in this file require a Dulwich server, so let's start one:

    >>> from dulwich.repo import Repo
    >>> from dulwich.server import DictBackend, TCPGitServer
    >>> import threading
    >>> repo = Repo.init("remote", mkdir=True)
    >>> cid = repo.get_worktree().commit(b"message", committer=b"Jelmer <jelmer@samba.org>")
    >>> backend = DictBackend({b'/': repo})
    >>> dul_server = TCPGitServer(backend, b'localhost', 0)
    >>> server_thread = threading.Thread(target=dul_server.serve)
    >>> server_thread.start()
    >>> server_address, server_port=dul_server.socket.getsockname()

Remote repositories
===================

The interface for remote Git repositories is different from that
for local repositories.

The Git smart server protocol provides three basic operations:

 * upload-pack - provides a pack with objects requested by the client
 * receive-pack - imports a pack with objects provided by the client
 * upload-archive - provides a tarball with the contents of a specific revision

The smart server protocol can be accessed over either plain TCP (git://),
SSH (git+ssh://) or tunneled over HTTP (http://).

Dulwich provides support for accessing remote repositories in
``dulwich.client``. To create a new client, you can construct
one manually::

   >>> from dulwich.client import TCPGitClient
   >>> client = TCPGitClient(server_address, server_port)

Retrieving raw pack files
-------------------------

The client object can then be used to retrieve a pack. The ``fetch_pack``
method takes a ``determine_wants`` callback argument, which allows the
client to determine which objects it wants to end up with::

   >>> def determine_wants(refs, depth=None):
   ...    # retrieve all objects
   ...    return refs.values()

Note that the ``depth`` keyword argument will contain an optional requested
shallow fetch depth.

Another required object is a "graph walker", which is used to determine
which objects that the client already has should not be sent again
by the server. Here in the tutorial we'll just use a dummy graph walker
which claims that the client doesn't have any objects::

   >>> class DummyGraphWalker(object):
   ...     def __init__(self):
   ...         self.shallow = set()
   ...     def ack(self, sha): pass
   ...     def nak(self): pass
   ...     def next(self): pass
   ...     def __next__(self): pass

With the ``determine_wants`` function in place, we can now fetch a pack,
which we will write to a ``BytesIO`` object::

   >>> from io import BytesIO
   >>> f = BytesIO()
   >>> result = client.fetch_pack(b"/", determine_wants,
   ...    DummyGraphWalker(), pack_data=f.write)

``f`` will now contain a full pack file::

   >>> print(f.getvalue()[:4].decode('ascii'))
   PACK

Fetching objects into a local repository
----------------------------------------

It is also possible to fetch from a remote repository into a local repository,
in which case Dulwich takes care of providing the right graph walker, and
importing the received pack file into the local repository::

   >>> from dulwich.repo import Repo
   >>> local = Repo.init("local", mkdir=True)
   >>> remote_refs = client.fetch(b"/", local)
   >>> local.close()

Let's shut down the server now that all tests have been run::

   >>> client.close()
   >>> dul_server.shutdown()
   >>> dul_server.server_close()
   >>> repo.close()
