From 5bf57d6426a625ebb1ba00fcbeb3d926a9f52305 Mon Sep 17 00:00:00 2001 From: Andrew Gerrand Date: Wed, 17 Dec 2014 15:49:59 +1100 Subject: [PATCH] cmd/tipgodoc: new tip.golang.org server Rough work in progress. Don't hate. Change-Id: I9d8247005724a21bdb5d4760cc6135bceb49f2d4 Reviewed-on: https://go-review.googlesource.com/1704 Reviewed-by: Andrew Gerrand --- cmd/tipgodoc/tip.go | 264 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 264 insertions(+) create mode 100644 cmd/tipgodoc/tip.go diff --git a/cmd/tipgodoc/tip.go b/cmd/tipgodoc/tip.go new file mode 100644 index 00000000..96ca21c6 --- /dev/null +++ b/cmd/tipgodoc/tip.go @@ -0,0 +1,264 @@ +// Copyright 2014 The Go AUTHORS. All rights reserved. +// Use of this source code is governed by the Apache 2.0 +// license that can be found in the LICENSE file. + +// Command tipgodoc is the beginning of the new tip.golang.org server, +// serving the latest HEAD straight from the Git oven. +package main + +import ( + "bufio" + "encoding/json" + "flag" + "fmt" + "io" + "io/ioutil" + "log" + "net/http" + "net/http/httputil" + "net/url" + "os" + "os/exec" + "path/filepath" + "sync" + "time" +) + +const metaURL = "https://go.googlesource.com/?b=master&format=JSON" + +var ( + pollInterval = flag.Duration("poll", 10*time.Second, "Remote repo poll interval") + listenAddr = flag.String("listen", "localhost:8080", "HTTP listen address") +) + +func main() { + flag.Parse() + p := new(Proxy) + go p.run() + http.Handle("/", p) + log.Fatal(http.ListenAndServe(*listenAddr, nil)) +} + +type Proxy struct { + mu sync.Mutex // owns the followin' + proxy *httputil.ReverseProxy + last string // signature of gorepo+toolsrepo + side string +} + +// run runs in its own goroutine. +func (p *Proxy) run() { + p.side = "a" + for { + p.poll() + time.Sleep(*pollInterval) + } +} + +// poll runs from the run loop goroutine. +func (p *Proxy) poll() { + heads := gerritMetaMap() + if heads == nil { + return + } + + p.mu.Lock() + curSide := p.side + lastSig := p.last + p.mu.Unlock() + + sig := heads["go"] + "-" + heads["tools"] + if sig == lastSig { + return + } + newSide := "b" + if curSide == "b" { + newSide = "a" + } + + hostport, err := initSide(newSide, heads["go"], heads["tools"]) + if err != nil { + log.Println(err) + return + } + + p.mu.Lock() + defer p.mu.Unlock() + u, err := url.Parse(fmt.Sprintf("http://%v/", hostport)) + if err != nil { + log.Println(err) + return + } + p.side = newSide + p.proxy = httputil.NewSingleHostReverseProxy(u) + p.last = sig +} + +func initSide(side, goHash, toolsHash string) (hostport string, err error) { + dir := filepath.Join(os.TempDir(), "tipgodoc", side) + if err := os.MkdirAll(dir, 0755); err != nil { + return "", err + } + + goDir := filepath.Join(dir, "go") + toolsDir := filepath.Join(dir, "gopath/src/golang.org/x/tools") + if err := checkout("https://go.googlesource.com/go", goHash, goDir); err != nil { + return "", err + } + if err := checkout("https://go.googlesource.com/tools", toolsHash, toolsDir); err != nil { + return "", err + + } + + env := []string{"GOROOT=" + goDir, "GOPATH=" + filepath.Join(dir, "gopath")} + + make := exec.Command("./make.bash") + make.Stdout = os.Stdout + make.Stderr = os.Stderr + make.Dir = filepath.Join(goDir, "src") + if err := make.Run(); err != nil { + return "", err + } + goBin := filepath.Join(goDir, "bin/go") + install := exec.Command(goBin, "install", "golang.org/x/tools/cmd/godoc") + install.Stdout = os.Stdout + install.Stderr = os.Stderr + install.Env = env + if err := install.Run(); err != nil { + return "", err + } + + godocBin := filepath.Join(goDir, "bin/godoc") + hostport = "localhost:8081" + if side == "b" { + hostport = "localhost:8082" + } + godoc := exec.Command(godocBin, "-http="+hostport) + godoc.Env = env + godoc.Stdout = os.Stdout + godoc.Stderr = os.Stderr + if err := godoc.Start(); err != nil { + return "", err + } + go func() { + // TODO(bradfitz): tell the proxy that this side is dead + if err := godoc.Wait(); err != nil { + log.Printf("side %v exited: %v", side, err) + } + }() + + for i := 0; i < 15; i++ { + time.Sleep(time.Second) + var res *http.Response + res, err = http.Get(fmt.Sprintf("http://%v/", hostport)) + if err != nil { + continue + } + res.Body.Close() + if res.StatusCode == http.StatusOK { + return hostport, nil + } + } + return "", fmt.Errorf("timed out waiting for side %v at %v (%v)", side, hostport, err) +} + +func checkout(repo, hash, path string) error { + // Clone git repo if it doesn't exist. + if _, err := os.Stat(filepath.Join(path, ".git")); os.IsNotExist(err) { + if err := os.MkdirAll(filepath.Base(path), 0755); err != nil { + return err + } + cmd := exec.Command("git", "clone", repo, path) + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + if err := cmd.Run(); err != nil { + // TODO(bradfitz): capture the standard error output + return err + } + } else if err != nil { + return err + } + + cmd := exec.Command("git", "fetch") + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + cmd.Dir = path + if err := cmd.Run(); err != nil { + return err + } + cmd = exec.Command("git", "reset", "--hard", hash) + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + cmd.Dir = path + if err := cmd.Run(); err != nil { + return err + } + cmd = exec.Command("git", "clean", "-d", "-f", "-x") + cmd.Stdout = os.Stdout + cmd.Stderr = os.Stderr + cmd.Dir = path + return cmd.Run() +} + +func (p *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) { + if r.URL.Path == "/_tipstatus" { + p.serveStatus(w, r) + return + } + p.mu.Lock() + proxy := p.proxy + p.mu.Unlock() + if proxy == nil { + http.Error(w, "not ready", http.StatusInternalServerError) + return + } + proxy.ServeHTTP(w, r) +} + +func (p *Proxy) serveStatus(w http.ResponseWriter, r *http.Request) { + p.mu.Lock() + defer p.mu.Unlock() + fmt.Fprintf(w, "side=%v\nlast=%v\n", p.side, p.last) +} + +// gerritMetaMap returns the map from repo name (e.g. "go") to its +// latest master hash. +// The returned map is nil on any transient error. +func gerritMetaMap() map[string]string { + res, err := http.Get(metaURL) + if err != nil { + return nil + } + defer res.Body.Close() + defer io.Copy(ioutil.Discard, res.Body) // ensure EOF for keep-alive + if res.StatusCode != 200 { + return nil + } + var meta map[string]struct { + Branches map[string]string + } + br := bufio.NewReader(res.Body) + // For security reasons or something, this URL starts with ")]}'\n" before + // the JSON object. So ignore that. + // Shawn Pearce says it's guaranteed to always be just one line, ending in '\n'. + for { + b, err := br.ReadByte() + if err != nil { + return nil + } + if b == '\n' { + break + } + } + if err := json.NewDecoder(br).Decode(&meta); err != nil { + log.Printf("JSON decoding error from %v: %s", metaURL, err) + return nil + } + m := map[string]string{} + for repo, v := range meta { + if master, ok := v.Branches["master"]; ok { + m[repo] = master + } + } + return m +}