commit d67e7d071d332d746382dfa602ea474b0ca2e865 · veryroundbird.house/core

+7 -5

knotserver/git.go

···

       31
       31
        
       	}

     

       32
       32
        
       

     

       33
       33
        
       	cmd := service.ServiceCommand{

     

       34
       34
       -
       		Dir:    repoPath,

     

       35
       35
       -
       		Stdout: w,

     

       34
       34
       +
       		GitProtocol: r.Header.Get("Git-Protocol"),

     

       35
       35
       +
       		Dir:         repoPath,

     

       36
       36
       +
       		Stdout:      w,

     

       36
       37
        
       	}

     

       37
       38
        
       

     

       38
       39
        
       	serviceName := r.URL.Query().Get("service")

     
···

       81
       82
        
       	d.l.Info("git: executing git-upload-pack", "handler", "UploadPack", "repo", repo)

     

       82
       83
        
       

     

       83
       84
        
       	cmd := service.ServiceCommand{

     

       84
       84
       -
       		Dir:    repo,

     

       85
       85
       -
       		Stdout: w,

     

       86
       86
       -
       		Stdin:  bodyReader,

     

       85
       85
       +
       		GitProtocol: r.Header.Get("Git-Protocol"),

     

       86
       86
       +
       		Dir:         repo,

     

       87
       87
       +
       		Stdout:      w,

     

       88
       88
       +
       		Stdin:       bodyReader,

     

       87
       89
        
       	}

     

       88
       90
        
       

     

       89
       91
        
       	w.WriteHeader(http.StatusOK)

+23 -14

knotserver/git/service/service.go

···

       15
       15
        
       // Mostly from charmbracelet/soft-serve and sosedoff/gitkit.

     

       16
       16
        
       

     

       17
       17
        
       type ServiceCommand struct {

     

       18
       18
       -
       	Dir    string

     

       19
       19
       -
       	Stdin  io.Reader

     

       20
       20
       -
       	Stdout http.ResponseWriter

     

       18
       18
       +
       	GitProtocol string

     

       19
       19
       +
       	Dir         string

     

       20
       20
       +
       	Stdin       io.Reader

     

       21
       21
       +
       	Stdout      http.ResponseWriter

     

       21
       22
        
       }

     

       22
       23
        
       

     

       23
       24
        
       func (c *ServiceCommand) InfoRefs() error {

     

       24
       25
        
       	cmd := exec.Command("git", []string{

     

       25
       26
        
       		"upload-pack",

     

       26
       27
        
       		"--stateless-rpc",

     

       27
       27
       -
       		"--advertise-refs",

     

       28
       28
       +
       		"--http-backend-info-refs",

     

       28
       29
        
       		".",

     

       29
       30
        
       	}...)

     

       30
       30
       -
       

     

       31
       31
       +
       	cmd.Env = append(cmd.Env, fmt.Sprintf("GIT_PROTOCOL=%s", c.GitProtocol))

     

       31
       32
        
       	cmd.Dir = c.Dir

     

       32
       33
        
       	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}

     

       33
       34
        
       	stdoutPipe, _ := cmd.StdoutPipe()

     
···

       38
       39
        
       		return err

     

       39
       40
        
       	}

     

       40
       41
        
       

     

       41
       41
       -
       	if err := packLine(c.Stdout, "# service=git-upload-pack\n"); err != nil {

     

       42
       42
       -
       		log.Printf("git: failed to write pack line: %s", err)

     

       43
       43
       -
       		return err

     

       44
       44
       -
       	}

     

       42
       42
       +
       	if !strings.Contains(c.GitProtocol, "version=2") {

     

       43
       43
       +
       		if err := packLine(c.Stdout, "# service=git-upload-pack\n"); err != nil {

     

       44
       44
       +
       			log.Printf("git: failed to write pack line: %s", err)

     

       45
       45
       +
       			return err

     

       46
       46
       +
       		}

     

       45
       47
        
       

     

       46
       46
       -
       	if err := packFlush(c.Stdout); err != nil {

     

       47
       47
       -
       		log.Printf("git: failed to flush pack: %s", err)

     

       48
       48
       -
       		return err

     

       48
       48
       +
       		if err := packFlush(c.Stdout); err != nil {

     

       49
       49
       +
       			log.Printf("git: failed to flush pack: %s", err)

     

       50
       50
       +
       			return err

     

       51
       51
       +
       		}

     

       49
       52
        
       	}

     

       50
       53
        
       

     

       51
       54
        
       	buf := bytes.Buffer{}

     
···

       71
       74
        
       func (c *ServiceCommand) UploadPack() error {

     

       72
       75
        
       	var stderr bytes.Buffer

     

       73
       76
        
       

     

       74
       74
       -
       	cmd := exec.Command("git", "-c", "uploadpack.allowFilter=true",

     

       75
       75
       -
       		"upload-pack", "--stateless-rpc", ".")

     

       77
       77
       +
       	cmd := exec.Command("git", []string{

     

       78
       78
       +
       		"-c", "uploadpack.allowFilter=true",

     

       79
       79
       +
       		"upload-pack",

     

       80
       80
       +
       		"--stateless-rpc",

     

       81
       81
       +
       		".",

     

       82
       82
       +
       	}...)

     

       83
       83
       +
       

     

       76
       84
        
       	cmd.Dir = c.Dir

     

       77
       85
        
       	cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}

     

       86
       86
       +
       	cmd.Env = append(cmd.Env, fmt.Sprintf("GIT_PROTOCOL=%s", c.GitProtocol))

     

       78
       87
        
       

     

       79
       88
        
       	stdoutPipe, err := cmd.StdoutPipe()

     

       80
       89
        
       	if err != nil {