On Tue, 01 Aug 2017 10:11:38 -0700 Junio C Hamano <gitster@xxxxxxxxx> wrote: > Let's step back a bit and think what already happens in the pre- > lazy-object world. We record cut-off commits when a depth limited > clone is created in "shallow". These essentially are promises, > saying something like: > > Rest assured that everything in the history behind these commits > are on the other side and you can retrieve them by unshallowing. > > If you traverse from your local tips and find no missing objects > before reaching one of these commits, then you do not have any > local corruption you need to worry about. > > the other end made to us, when the shallow clone was made. And we > take this promise and build more commits on top, and then we adjust > these cut-off commits incrementally as we deepen our clone or make > it even shallower. For this assurance to work, we of course need to > assume a bit more than what we assume for a complete clone, namely, > the "other side" will hold onto the history behind these, i.e. does > not remind the tips it already has shown to us, or even if it does, > the objects that are reachable from these cut-off points will > somehow always be available to us on demand. > > Can we do something similar, i.e. maintain minimum set of cut-off > points and adjust that set incrementally, just sufficient to ensure > the integrity of objects locally created and not yet safely stored > away by pushing them the "other side"? This suggestion (the "frontier" of what we have) does seem to incur less overhead than the original promise suggestion (the "frontier" of what we don't have), but after some in-office discussion, I'm convinced that it might not be the case - for example, one tree (that we have) might reference many blobs (that we don't have), but at the same time, many trees (that we have) might have the same blob (that we don't have). And the promise overhead was already decided to be too much - which is why we moved away from it. One possibility to conceptually have the same thing without the overhead of the list is to put the obtained-from-elsewhere objects into its own alternate object store, so that we can distinguish the two. I mentioned this in my e-mail but rejected it, but after some more thought, this might be sufficient - we might still need to iterate through every object to know exactly what we can assume the remote to have, but the "frontier" solution also needs this iteration, so we are no worse off. Going back to the original use cases that motivated this (the monorepo like Microsoft's repo and the large-blob repo like Android's repo), it might be better just to disable the connectivity check when extensions.lazyObject is set (as you mentioned). This does change the meaning of fsck, but it may be fine since the "meaning" of the repo (a view of another repo, and no longer a full repo) has changed too. Then this patch set will be more about ensuring that the lazy object loader is not inadvertently run. As future work, we could add diagnostics that, for example, attempt a walk anyway and print a list of missing SHA-1s. (I suspect that we will also need to disable the connectivity check for things like "git fetch", which means that we won't be able to tell locally if the server sent us all the objects that we requested for. This might not be a problem, though, since the local repo already has some measure of trust for the server.)
