Fetch reports "already up-to-date" when trying to fetch greater depth on a shallow clone

[lucastheisen]

I have code that operates on a shallow clone and needs to progressively fetch greater depth until it finds the change it is looking for. Basically this:

func (repo *git.Repository) findVersionFrom(hash plumbing.Hash, baseParser func(string) (string, error)) (string, error) {
    // should probably use git rev-list instad of log
    //   https://github.com/src-d/go-git/issues/757
    entries, err := repo.Log(&git.LogOptions{From: hash})
    if err != nil {
        return "", fmt.Errorf("unable to read log: %v", err)
    }

    versionFile := "version.txt"
    current := ""
    depth := 0
    versionChanged := errors.New("")
    parent := plumbing.ZeroHash

    err = entries.ForEach(func(c *object.Commit) error {
        if len(c.ParentHashes) > 0 {
            parent = c.ParentHashes[0]
        }

        tree, err := c.Tree()
        if err != nil {
            return fmt.Errorf("cannot retrive tree for %v: %v", c, err)
        }

        file, err := tree.File(versionFile)
        if err != nil {
            return fmt.Errorf("unable to retrieve %s: %v", versionFile, err)
        }

        versionContent, err := file.Contents()
        if err != nil {
            return fmt.Errorf("unable to read %s: %v", versionFile, err)
        }

        versionBase, err := baseParser(versionContent)
        if err != nil {
            return fmt.Errorf("failed to parse version from [%s]: %v", versionContent, err)
        }

        if current == "" {
            current = versionBase
            depth = 0
            return nil
        }

        if versionBase != current {
            return versionChanged
        }

        depth = depth + 1

        return nil
    })
    if err == plumbing.ErrObjectNotFound {
        depth := 50
        err = repo.Fetch(&git.FetchOptions{Depth: depth})
        if err != nil {
            return "", fmt.Errorf("failed to fetch %d, parent %v: %v", depth, parent, err)
        }
    } else if err != nil && err != versionChanged {
        return "", err
    }

    return fmt.Sprintf("%s.%d", current, depth), nil
}

I walked through a lot of the fetch code and came across this code:

    req.Wants, err = getWants(r.s, refs)
    if len(req.Wants) > 0 {
        req.Haves, err = getHaves(localRefs, remoteRefs, r.s)
        if err != nil {
            return nil, err
        }

        if err = r.fetchPack(ctx, o, s, req); err != nil {
            return nil, err
        }
    }

It appears the r.fetchPack only occurs if getWants returns more than one. But getWants only seems to check the hash at the tip of each branch:

    wants := map[plumbing.Hash]bool{}
    for _, ref := range refs {
        hash := ref.Hash()
        exists, err := objectExists(localStorer, ref.Hash())
        if err != nil {
            return nil, err
        }

        if !exists {
            wants[hash] = true
        }
    }

So since its a shallow clone it has the same tip as the remote and no wants are detected.