Re: Proposal: object negotiation for partial clones

Thanks. Let me try to summarize: The issue is that, during a fetch, normally the client can say "have" to inform the server that it has a commit and all its referenced objects (barring shallow lines), but we can't do the same if the client is a partial clone (because having a commit doesn't necessarily mean that we have all referenced objects). And not doing this means that the server sends a lot of unnecessary objects in the sent packfile. The solution is to do the fetch in 2 parts: one to get the list of objects that would be sent, and after the client filters that, one to get the objects themselves.

It was unclear to me whether this is meant for (1) fetches directly initiated by the user that fetch commits (e.g. "git fetch origin", reusing the configured "core.partialclonefilter") and/or for (2) lazy fetching of missing objects. My assumption is that this is only for (2).

My main question is: we can get the same list of objects (in the form of tree objects) if we fetch with "blob:none" filter. Admittedly, we will get extra data (file names, etc.) - if the extra bandwidth saving is necessary, this should be called out. (And some of the savings will be offset by the fact that we will actually need some of those tree objects.)

Assuming that we do need that bandwidth saving, here's my review of that document.

The document describes the 1st request exactly as I envision - a specific parameter sent by the client, and the server responds with a list of object names.

For the 2nd request, the document describes it as repeating the original query of the 1st request while also giving the full list of objects wanted as "choose-refs". I'm still not convinced that repeating the original query is necessary - I would just give the list of objects as wants. The rationale given for repeating the original query is:

But this omits the fact that, if doing it the document's way, the server needs to perform an object walk in addition to the "single reachability check", and it is not true that if doing it my way, "many separate ones" need to be done because the server can check reachability of all objects at once.

Also, my way means that supporting the 2nd request does not require any code or protocol change - it already works today. Assuming we follow my approach, the discussion thus lies in supporting the 1st request.

Some more thoughts:

- Changes in server and client scalability: Currently, the server checks
  reachability of all wants, then enumerates, then sends all objects.
  With this change, the server checks reachability of all wants, then
  enumerates, then sends an object list, then checks reachability of all
  objects in the filtered list, then sends some objects. There is
  additional overhead in the extra reachability check and lists of
  objects being sent twice (once by server and once by client), but
  sending fewer objects means that I/O (server, network, client) and
  disk space usage (client) is reduced.

- Usefulness outside partial clone: If the user ever wants a list of
  objects referenced by an object but without their file names, the user
  could use this, but I can't think of such a scenario.