1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package vcweb
import (
"bufio"
"errors"
"io"
"log"
"net/http"
"net/http/httputil"
"net/url"
"os"
"os/exec"
"strings"
"sync"
)
type hgHandler struct {
once sync.Once
hgPath string
hgPathErr error
}
func (h *hgHandler) Available() bool {
h.once.Do(func() {
h.hgPath, h.hgPathErr = exec.LookPath("hg")
})
return h.hgPathErr == nil
}
func (h *hgHandler) Handler(dir string, env []string, logger *log.Logger) (http.Handler, error) {
if !h.Available() {
return nil, ServerNotInstalledError{name: "hg"}
}
handler := http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
// Mercurial has a CGI server implementation (called hgweb). In theory we
// could use that — however, assuming that hgweb is even installed, the
// configuration for hgweb varies by Python version (2 vs 3), and we would
// rather not go rooting around trying to find the right Python version to
// run.
//
// Instead, we'll take a somewhat more roundabout approach: we assume that
// if "hg" works at all then "hg serve" works too, and we'll execute that as
// a subprocess, using a reverse proxy to forward the request and response.
cmd := exec.Command(h.hgPath, "serve", "--port", "0", "--address", "localhost", "--accesslog", os.DevNull, "--name", "vcweb", "--print-url")
cmd.Dir = dir
cmd.Env = append(env[:len(env):len(env)], "PWD="+dir)
stderr := new(strings.Builder)
cmd.Stderr = stderr
stdout, err := cmd.StdoutPipe()
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
readDone := make(chan struct{})
defer func() {
stdout.Close()
<-readDone
}()
hgURL := make(chan *url.URL, 1)
hgURLError := make(chan error, 1)
go func() {
defer close(readDone)
r := bufio.NewReader(stdout)
for {
line, err := r.ReadString('\n')
if err != nil {
return
}
u, err := url.Parse(strings.TrimSpace(line))
if err == nil {
hgURL <- u
} else {
hgURLError <- err
}
break
}
io.Copy(io.Discard, r)
}()
if err := cmd.Start(); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
defer func() {
if err := cmd.Process.Signal(os.Interrupt); err != nil && !errors.Is(err, os.ErrProcessDone) {
cmd.Process.Kill()
}
err := cmd.Wait()
if out := strings.TrimSuffix(stderr.String(), "interrupted!\n"); out != "" {
logger.Printf("%v: %v\n%s", cmd, err, out)
} else {
logger.Printf("%v", cmd)
}
}()
select {
case <-req.Context().Done():
logger.Printf("%v: %v", req.Context().Err(), cmd)
http.Error(w, req.Context().Err().Error(), http.StatusBadGateway)
return
case err := <-hgURLError:
logger.Printf("%v: %v", cmd, err)
http.Error(w, err.Error(), http.StatusBadGateway)
return
case url := <-hgURL:
logger.Printf("proxying hg request to %s", url)
httputil.NewSingleHostReverseProxy(url).ServeHTTP(w, req)
}
})
return handler, nil
}
|
