| Server IP : 185.124.137.173 / Your IP : 216.73.217.93 Web Server : LiteSpeed System : Linux id-dci-web1986.main-hosting.eu 5.14.0-611.26.1.el9_7.x86_64 #1 SMP PREEMPT_DYNAMIC Thu Jan 29 05:24:47 EST 2026 x86_64 User : u686484674 ( 686484674) PHP Version : 8.0.30 Disable Function : system, exec, shell_exec, passthru, mysql_list_dbs, ini_alter, dl, symlink, link, chgrp, leak, popen, apache_child_terminate, virtual, mb_send_mail MySQL : OFF | cURL : ON | WGET : ON | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /./proc/thread-self/root/proc/thread-self/root/opt/golang/1.22.0/src/cmd/go/internal/vcweb/ |
Upload File : |
// 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"
"context"
"errors"
"io"
"log"
"net/http"
"net/http/httputil"
"net/url"
"os"
"os/exec"
"slices"
"strings"
"sync"
"time"
)
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.
ctx, cancel := context.WithCancel(req.Context())
defer cancel()
cmd := exec.CommandContext(ctx, h.hgPath, "serve", "--port", "0", "--address", "localhost", "--accesslog", os.DevNull, "--name", "vcweb", "--print-url")
cmd.Dir = dir
cmd.Env = append(slices.Clip(env), "PWD="+dir)
cmd.Cancel = func() error {
err := cmd.Process.Signal(os.Interrupt)
if err != nil && !errors.Is(err, os.ErrProcessDone) {
err = cmd.Process.Kill()
}
return err
}
// This WaitDelay is arbitrary. After 'hg serve' prints its URL, any further
// I/O is only for debugging. (The actual output goes through the HTTP URL,
// not the standard I/O streams.)
cmd.WaitDelay = 10 * time.Second
stderr := new(strings.Builder)
cmd.Stderr = stderr
stdout, err := cmd.StdoutPipe()
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if err := cmd.Start(); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
var wg sync.WaitGroup
defer func() {
cancel()
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)
}
wg.Wait()
}()
r := bufio.NewReader(stdout)
line, err := r.ReadString('\n')
if err != nil {
return
}
// We have read what should be the server URL. 'hg serve' shouldn't need to
// write anything else to stdout, but it's not a big deal if it does anyway.
// Keep the stdout pipe open so that 'hg serve' won't get a SIGPIPE, but
// actively discard its output so that it won't hang on a blocking write.
wg.Add(1)
go func() {
io.Copy(io.Discard, r)
wg.Done()
}()
u, err := url.Parse(strings.TrimSpace(line))
if err != nil {
logger.Printf("%v: %v", cmd, err)
http.Error(w, err.Error(), http.StatusBadGateway)
return
}
logger.Printf("proxying hg request to %s", u)
httputil.NewSingleHostReverseProxy(u).ServeHTTP(w, req)
})
return handler, nil
}