knotserver: git: do not pass HEAD as a default arg to rev-list #229

merged

opened by

oppi.li 6 months ago targeting master from push-ovrqrxnpvroz

when calling rev-list, HEAD was passed as a default argument:

git rev-list HEAD --count

but HEAD is only populated when we perform git.Open; it is zeroed out when we perform git.PlainOpen:

git rev-list 00000... --count

this causes rev-list to exit with an error, when used in repos that are git.PlainOpen'd.

Signed-off-by: oppiliappan me@oppi.li

options

unified split

Changed files

+11 -2

knotserver

git

git.go

+11 -2

knotserver/git/git.go

···

       128
       128
        
       	commits := []*object.Commit{}

     

       129
       129
        
       

     

       130
       130
        
       	output, err := g.revList(

     

       131
       131
       +
       		g.h.String(),

     

       131
       132
        
       		fmt.Sprintf("--skip=%d", offset),

     

       132
       133
        
       		fmt.Sprintf("--max-count=%d", limit),

     

       133
       134
        
       	)

     
···

       153
       154
        
       

     

       154
       155
        
       func (g *GitRepo) TotalCommits() (int, error) {

     

       155
       156
        
       	output, err := g.revList(

     

       157
       157
       +
       		g.h.String(),

     

       156
       158
        
       		fmt.Sprintf("--count"),

     

       157
       159
        
       	)

     

       158
       160
        
       	if err != nil {

     
···

       170
       172
        
       func (g *GitRepo) revList(extraArgs ...string) ([]byte, error) {

     

       171
       173
        
       	var args []string

     

       172
       174
        
       	args = append(args, "rev-list")

     

       173
       173
       -
       	args = append(args, g.h.String())

     

       174
       175
        
       	args = append(args, extraArgs...)

     

       175
       176
        
       

     

       176
       177
        
       	cmd := exec.Command("git", args...)

     

       177
       178
        
       	cmd.Dir = g.path

     

       178
       179
        
       

     

       179
       179
       -
       	return cmd.Output()

     

       180
       180
       +
       	out, err := cmd.Output()

     

       181
       181
       +
       	if err != nil {

     

       182
       182
       +
       		if exitErr, ok := err.(*exec.ExitError); ok {

     

       183
       183
       +
       			return nil, fmt.Errorf("%w, stderr: %s", err, string(exitErr.Stderr))

     

       184
       184
       +
       		}

     

       185
       185
       +
       		return nil, err

     

       186
       186
       +
       	}

     

       187
       187
       +
       

     

       188
       188
       +
       	return out, nil

     

       180
       189
        
       }

     

       181
       190
        
       

     

       182
       191
        
       func (g *GitRepo) Commit(h plumbing.Hash) (*object.Commit, error) {