internal: copy x/tools/godoc/{dl,env,proxy,redirect,short} packages
These files from x/tools commit
0a99049195aff55f007fc4dfd48e3ec2b4d5f602 are being added here
both as a step toward fixing the broken app engine build (using
go build -tags=golangorg requires access to memcache) and towards
the long term goal of removing files and packages that exist solely
to serve the website from x/tools. The next step will be changing
the import paths to get the build working again.
Updates golang/go#29206
Change-Id: Ie30b7776f30cda14c7fe9827941c623bc5c5c587
Reviewed-on: https://go-review.googlesource.com/c/159917
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Katie Hockman <katie@golang.org>
diff --git a/internal/dl/dl.go b/internal/dl/dl.go
new file mode 100644
index 0000000..aaa7af4
--- /dev/null
+++ b/internal/dl/dl.go
@@ -0,0 +1,353 @@
+// Copyright 2015 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.
+
+// Package dl implements a simple downloads frontend server.
+//
+// It accepts HTTP POST requests to create a new download metadata entity, and
+// lists entities with sorting and filtering.
+// It is designed to run only on the instance of godoc that serves golang.org.
+package dl
+
+import (
+ "fmt"
+ "html/template"
+ "regexp"
+ "sort"
+ "strconv"
+ "strings"
+ "time"
+)
+
+const (
+ downloadBaseURL = "https://dl.google.com/go/"
+ cacheKey = "download_list_3" // increment if listTemplateData changes
+ cacheDuration = time.Hour
+)
+
+// File represents a file on the golang.org downloads page.
+// It should be kept in sync with the upload code in x/build/cmd/release.
+type File struct {
+ Filename string `json:"filename"`
+ OS string `json:"os"`
+ Arch string `json:"arch"`
+ Version string `json:"version"`
+ Checksum string `json:"-" datastore:",noindex"` // SHA1; deprecated
+ ChecksumSHA256 string `json:"sha256" datastore:",noindex"`
+ Size int64 `json:"size" datastore:",noindex"`
+ Kind string `json:"kind"` // "archive", "installer", "source"
+ Uploaded time.Time `json:"-"`
+}
+
+func (f File) ChecksumType() string {
+ if f.ChecksumSHA256 != "" {
+ return "SHA256"
+ }
+ return "SHA1"
+}
+
+func (f File) PrettyChecksum() string {
+ if f.ChecksumSHA256 != "" {
+ return f.ChecksumSHA256
+ }
+ return f.Checksum
+}
+
+func (f File) PrettyOS() string {
+ if f.OS == "darwin" {
+ switch {
+ case strings.Contains(f.Filename, "osx10.8"):
+ return "OS X 10.8+"
+ case strings.Contains(f.Filename, "osx10.6"):
+ return "OS X 10.6+"
+ }
+ }
+ return pretty(f.OS)
+}
+
+func (f File) PrettySize() string {
+ const mb = 1 << 20
+ if f.Size == 0 {
+ return ""
+ }
+ if f.Size < mb {
+ // All Go releases are >1mb, but handle this case anyway.
+ return fmt.Sprintf("%v bytes", f.Size)
+ }
+ return fmt.Sprintf("%.0fMB", float64(f.Size)/mb)
+}
+
+var primaryPorts = map[string]bool{
+ "darwin/amd64": true,
+ "linux/386": true,
+ "linux/amd64": true,
+ "linux/armv6l": true,
+ "windows/386": true,
+ "windows/amd64": true,
+}
+
+func (f File) PrimaryPort() bool {
+ if f.Kind == "source" {
+ return true
+ }
+ return primaryPorts[f.OS+"/"+f.Arch]
+}
+
+func (f File) Highlight() bool {
+ switch {
+ case f.Kind == "source":
+ return true
+ case f.Arch == "amd64" && f.OS == "linux":
+ return true
+ case f.Arch == "amd64" && f.Kind == "installer":
+ switch f.OS {
+ case "windows":
+ return true
+ case "darwin":
+ if !strings.Contains(f.Filename, "osx10.6") {
+ return true
+ }
+ }
+ }
+ return false
+}
+
+func (f File) URL() string {
+ return downloadBaseURL + f.Filename
+}
+
+type Release struct {
+ Version string `json:"version"`
+ Stable bool `json:"stable"`
+ Files []File `json:"files"`
+ Visible bool `json:"-"` // show files on page load
+ SplitPortTable bool `json:"-"` // whether files should be split by primary/other ports.
+}
+
+type Feature struct {
+ // The File field will be filled in by the first stable File
+ // whose name matches the given fileRE.
+ File
+ fileRE *regexp.Regexp
+
+ Platform string // "Microsoft Windows", "Apple macOS", "Linux"
+ Requirements string // "Windows XP and above, 64-bit Intel Processor"
+}
+
+// featuredFiles lists the platforms and files to be featured
+// at the top of the downloads page.
+var featuredFiles = []Feature{
+ {
+ Platform: "Microsoft Windows",
+ Requirements: "Windows 7 or later, Intel 64-bit processor",
+ fileRE: regexp.MustCompile(`\.windows-amd64\.msi$`),
+ },
+ {
+ Platform: "Apple macOS",
+ Requirements: "macOS 10.10 or later, Intel 64-bit processor",
+ fileRE: regexp.MustCompile(`\.darwin-amd64(-osx10\.8)?\.pkg$`),
+ },
+ {
+ Platform: "Linux",
+ Requirements: "Linux 2.6.23 or later, Intel 64-bit processor",
+ fileRE: regexp.MustCompile(`\.linux-amd64\.tar\.gz$`),
+ },
+ {
+ Platform: "Source",
+ fileRE: regexp.MustCompile(`\.src\.tar\.gz$`),
+ },
+}
+
+// data to send to the template; increment cacheKey if you change this.
+type listTemplateData struct {
+ Featured []Feature
+ Stable, Unstable, Archive []Release
+}
+
+var (
+ listTemplate = template.Must(template.New("").Funcs(templateFuncs).Parse(templateHTML))
+ templateFuncs = template.FuncMap{"pretty": pretty}
+)
+
+func filesToFeatured(fs []File) (featured []Feature) {
+ for _, feature := range featuredFiles {
+ for _, file := range fs {
+ if feature.fileRE.MatchString(file.Filename) {
+ feature.File = file
+ featured = append(featured, feature)
+ break
+ }
+ }
+ }
+ return
+}
+
+func filesToReleases(fs []File) (stable, unstable, archive []Release) {
+ sort.Sort(fileOrder(fs))
+
+ var r *Release
+ var stableMaj, stableMin int
+ add := func() {
+ if r == nil {
+ return
+ }
+ if !r.Stable {
+ if len(unstable) != 0 {
+ // Only show one (latest) unstable version.
+ return
+ }
+ maj, min, _ := parseVersion(r.Version)
+ if maj < stableMaj || maj == stableMaj && min <= stableMin {
+ // Display unstable version only if newer than the
+ // latest stable release.
+ return
+ }
+ unstable = append(unstable, *r)
+ return
+ }
+
+ // Reports whether the release is the most recent minor version of the
+ // two most recent major versions.
+ shouldAddStable := func() bool {
+ if len(stable) >= 2 {
+ // Show up to two stable versions.
+ return false
+ }
+ if len(stable) == 0 {
+ // Most recent stable version.
+ stableMaj, stableMin, _ = parseVersion(r.Version)
+ return true
+ }
+ if maj, _, _ := parseVersion(r.Version); maj == stableMaj {
+ // Older minor version of most recent major version.
+ return false
+ }
+ // Second most recent stable version.
+ return true
+ }
+ if !shouldAddStable() {
+ archive = append(archive, *r)
+ return
+ }
+
+ // Split the file list into primary/other ports for the stable releases.
+ // NOTE(cbro): This is only done for stable releases because maintaining the historical
+ // nature of primary/other ports for older versions is infeasible.
+ // If freebsd is considered primary some time in the future, we'd not want to
+ // mark all of the older freebsd binaries as "primary".
+ // It might be better if we set that as a flag when uploading.
+ r.SplitPortTable = true
+ r.Visible = true // Toggle open all stable releases.
+ stable = append(stable, *r)
+ }
+ for _, f := range fs {
+ if r == nil || f.Version != r.Version {
+ add()
+ r = &Release{
+ Version: f.Version,
+ Stable: isStable(f.Version),
+ }
+ }
+ r.Files = append(r.Files, f)
+ }
+ add()
+ return
+}
+
+// isStable reports whether the version string v is a stable version.
+func isStable(v string) bool {
+ return !strings.Contains(v, "beta") && !strings.Contains(v, "rc")
+}
+
+type fileOrder []File
+
+func (s fileOrder) Len() int { return len(s) }
+func (s fileOrder) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+func (s fileOrder) Less(i, j int) bool {
+ a, b := s[i], s[j]
+ if av, bv := a.Version, b.Version; av != bv {
+ return versionLess(av, bv)
+ }
+ if a.OS != b.OS {
+ return a.OS < b.OS
+ }
+ if a.Arch != b.Arch {
+ return a.Arch < b.Arch
+ }
+ if a.Kind != b.Kind {
+ return a.Kind < b.Kind
+ }
+ return a.Filename < b.Filename
+}
+
+func versionLess(a, b string) bool {
+ // Put stable releases first.
+ if isStable(a) != isStable(b) {
+ return isStable(a)
+ }
+ maja, mina, ta := parseVersion(a)
+ majb, minb, tb := parseVersion(b)
+ if maja == majb {
+ if mina == minb {
+ return ta >= tb
+ }
+ return mina >= minb
+ }
+ return maja >= majb
+}
+
+func parseVersion(v string) (maj, min int, tail string) {
+ if i := strings.Index(v, "beta"); i > 0 {
+ tail = v[i:]
+ v = v[:i]
+ }
+ if i := strings.Index(v, "rc"); i > 0 {
+ tail = v[i:]
+ v = v[:i]
+ }
+ p := strings.Split(strings.TrimPrefix(v, "go1."), ".")
+ maj, _ = strconv.Atoi(p[0])
+ if len(p) < 2 {
+ return
+ }
+ min, _ = strconv.Atoi(p[1])
+ return
+}
+
+func validUser(user string) bool {
+ switch user {
+ case "adg", "bradfitz", "cbro", "andybons", "valsorda", "dmitshur", "katiehockman", "julieqiu":
+ return true
+ }
+ return false
+}
+
+var (
+ fileRe = regexp.MustCompile(`^go[0-9a-z.]+\.[0-9a-z.-]+\.(tar\.gz|pkg|msi|zip)$`)
+ goGetRe = regexp.MustCompile(`^go[0-9a-z.]+\.[0-9a-z.-]+$`)
+)
+
+// pretty returns a human-readable version of the given OS, Arch, or Kind.
+func pretty(s string) string {
+ t, ok := prettyStrings[s]
+ if !ok {
+ return s
+ }
+ return t
+}
+
+var prettyStrings = map[string]string{
+ "darwin": "macOS",
+ "freebsd": "FreeBSD",
+ "linux": "Linux",
+ "windows": "Windows",
+
+ "386": "x86",
+ "amd64": "x86-64",
+ "armv6l": "ARMv6",
+ "arm64": "ARMv8",
+
+ "archive": "Archive",
+ "installer": "Installer",
+ "source": "Source",
+}
diff --git a/internal/dl/dl_test.go b/internal/dl/dl_test.go
new file mode 100644
index 0000000..9ea5f62
--- /dev/null
+++ b/internal/dl/dl_test.go
@@ -0,0 +1,159 @@
+// Copyright 2015 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.
+
+package dl
+
+import (
+ "sort"
+ "strings"
+ "testing"
+)
+
+func TestParseVersion(t *testing.T) {
+ for _, c := range []struct {
+ in string
+ maj, min int
+ tail string
+ }{
+ {"go1.5", 5, 0, ""},
+ {"go1.5beta1", 5, 0, "beta1"},
+ {"go1.5.1", 5, 1, ""},
+ {"go1.5.1rc1", 5, 1, "rc1"},
+ } {
+ maj, min, tail := parseVersion(c.in)
+ if maj != c.maj || min != c.min || tail != c.tail {
+ t.Errorf("parseVersion(%q) = %v, %v, %q; want %v, %v, %q",
+ c.in, maj, min, tail, c.maj, c.min, c.tail)
+ }
+ }
+}
+
+func TestFileOrder(t *testing.T) {
+ fs := []File{
+ {Filename: "go1.3.src.tar.gz", Version: "go1.3", OS: "", Arch: "", Kind: "source"},
+ {Filename: "go1.3.1.src.tar.gz", Version: "go1.3.1", OS: "", Arch: "", Kind: "source"},
+ {Filename: "go1.3.linux-amd64.tar.gz", Version: "go1.3", OS: "linux", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.3.1.linux-amd64.tar.gz", Version: "go1.3.1", OS: "linux", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.3.darwin-amd64.tar.gz", Version: "go1.3", OS: "darwin", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.3.darwin-amd64.pkg", Version: "go1.3", OS: "darwin", Arch: "amd64", Kind: "installer"},
+ {Filename: "go1.3.darwin-386.tar.gz", Version: "go1.3", OS: "darwin", Arch: "386", Kind: "archive"},
+ {Filename: "go1.3beta1.linux-amd64.tar.gz", Version: "go1.3beta1", OS: "linux", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.3beta2.linux-amd64.tar.gz", Version: "go1.3beta2", OS: "linux", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.3rc1.linux-amd64.tar.gz", Version: "go1.3rc1", OS: "linux", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.2.linux-amd64.tar.gz", Version: "go1.2", OS: "linux", Arch: "amd64", Kind: "archive"},
+ {Filename: "go1.2.2.linux-amd64.tar.gz", Version: "go1.2.2", OS: "linux", Arch: "amd64", Kind: "archive"},
+ }
+ sort.Sort(fileOrder(fs))
+ var s []string
+ for _, f := range fs {
+ s = append(s, f.Filename)
+ }
+ got := strings.Join(s, "\n")
+ want := strings.Join([]string{
+ "go1.3.1.src.tar.gz",
+ "go1.3.1.linux-amd64.tar.gz",
+ "go1.3.src.tar.gz",
+ "go1.3.darwin-386.tar.gz",
+ "go1.3.darwin-amd64.tar.gz",
+ "go1.3.darwin-amd64.pkg",
+ "go1.3.linux-amd64.tar.gz",
+ "go1.2.2.linux-amd64.tar.gz",
+ "go1.2.linux-amd64.tar.gz",
+ "go1.3rc1.linux-amd64.tar.gz",
+ "go1.3beta2.linux-amd64.tar.gz",
+ "go1.3beta1.linux-amd64.tar.gz",
+ }, "\n")
+ if got != want {
+ t.Errorf("sort order is\n%s\nwant:\n%s", got, want)
+ }
+}
+
+func TestFilesToReleases(t *testing.T) {
+ fs := []File{
+ {Version: "go1.7.4", OS: "darwin"},
+ {Version: "go1.7.4", OS: "windows"},
+ {Version: "go1.7", OS: "darwin"},
+ {Version: "go1.7", OS: "windows"},
+ {Version: "go1.6.2", OS: "darwin"},
+ {Version: "go1.6.2", OS: "windows"},
+ {Version: "go1.6", OS: "darwin"},
+ {Version: "go1.6", OS: "windows"},
+ {Version: "go1.5.2", OS: "darwin"},
+ {Version: "go1.5.2", OS: "windows"},
+ {Version: "go1.5", OS: "darwin"},
+ {Version: "go1.5", OS: "windows"},
+ {Version: "go1.5beta1", OS: "windows"},
+ }
+ stable, unstable, archive := filesToReleases(fs)
+ if got, want := list(stable), "go1.7.4, go1.6.2"; got != want {
+ t.Errorf("stable = %q; want %q", got, want)
+ }
+ if got, want := list(unstable), ""; got != want {
+ t.Errorf("unstable = %q; want %q", got, want)
+ }
+ if got, want := list(archive), "go1.7, go1.6, go1.5.2, go1.5"; got != want {
+ t.Errorf("archive = %q; want %q", got, want)
+ }
+}
+
+func TestOldUnstableNotShown(t *testing.T) {
+ fs := []File{
+ {Version: "go1.7.4"},
+ {Version: "go1.7"},
+ {Version: "go1.7beta1"},
+ }
+ _, unstable, _ := filesToReleases(fs)
+ if len(unstable) != 0 {
+ t.Errorf("got unstable, want none")
+ }
+}
+
+// A new beta should show up under unstable, but not show up under archive. See golang.org/issue/29669.
+func TestNewUnstableShownOnce(t *testing.T) {
+ fs := []File{
+ {Version: "go1.12beta2"},
+ {Version: "go1.11.4"},
+ {Version: "go1.11"},
+ {Version: "go1.10.7"},
+ {Version: "go1.10"},
+ {Version: "go1.9"},
+ }
+ stable, unstable, archive := filesToReleases(fs)
+ if got, want := list(stable), "go1.11.4, go1.10.7"; got != want {
+ t.Errorf("stable = %q; want %q", got, want)
+ }
+ if got, want := list(unstable), "go1.12beta2"; got != want {
+ t.Errorf("unstable = %q; want %q", got, want)
+ }
+ if got, want := list(archive), "go1.11, go1.10, go1.9"; got != want {
+ t.Errorf("archive = %q; want %q", got, want)
+ }
+}
+
+func TestUnstableShown(t *testing.T) {
+ fs := []File{
+ {Version: "go1.8beta2"},
+ {Version: "go1.8rc1"},
+ {Version: "go1.7.4"},
+ {Version: "go1.7"},
+ {Version: "go1.7beta1"},
+ }
+ _, unstable, _ := filesToReleases(fs)
+ // Show RCs ahead of betas.
+ if got, want := list(unstable), "go1.8rc1"; got != want {
+ t.Errorf("unstable = %q; want %q", got, want)
+ }
+}
+
+// list returns a version list string for the given releases.
+func list(rs []Release) string {
+ var s string
+ for i, r := range rs {
+ if i > 0 {
+ s += ", "
+ }
+ s += r.Version
+ }
+ return s
+}
diff --git a/internal/dl/server.go b/internal/dl/server.go
new file mode 100644
index 0000000..43fa453
--- /dev/null
+++ b/internal/dl/server.go
@@ -0,0 +1,266 @@
+// Copyright 2015 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.
+
+// +build golangorg
+
+package dl
+
+import (
+ "context"
+ "crypto/hmac"
+ "crypto/md5"
+ "encoding/json"
+ "fmt"
+ "html"
+ "io"
+ "log"
+ "net/http"
+ "strings"
+ "sync"
+ "time"
+
+ "cloud.google.com/go/datastore"
+ "golang.org/x/tools/godoc/env"
+ "golang.org/x/tools/internal/memcache"
+)
+
+type server struct {
+ datastore *datastore.Client
+ memcache *memcache.CodecClient
+}
+
+func RegisterHandlers(mux *http.ServeMux, dc *datastore.Client, mc *memcache.Client) {
+ s := server{dc, mc.WithCodec(memcache.Gob)}
+ mux.HandleFunc("/dl", s.getHandler)
+ mux.HandleFunc("/dl/", s.getHandler) // also serves listHandler
+ mux.HandleFunc("/dl/upload", s.uploadHandler)
+
+ // NOTE(cbro): this only needs to be run once per project,
+ // and should be behind an admin login.
+ // TODO(cbro): move into a locally-run program? or remove?
+ // mux.HandleFunc("/dl/init", initHandler)
+}
+
+// rootKey is the ancestor of all File entities.
+var rootKey = datastore.NameKey("FileRoot", "root", nil)
+
+func (h server) listHandler(w http.ResponseWriter, r *http.Request) {
+ if r.Method != "GET" {
+ http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+ return
+ }
+ ctx := r.Context()
+ var d listTemplateData
+
+ if err := h.memcache.Get(ctx, cacheKey, &d); err != nil {
+ if err != memcache.ErrCacheMiss {
+ log.Printf("ERROR cache get error: %v", err)
+ // NOTE(cbro): continue to hit datastore if the memcache is down.
+ }
+
+ var fs []File
+ q := datastore.NewQuery("File").Ancestor(rootKey)
+ if _, err := h.datastore.GetAll(ctx, q, &fs); err != nil {
+ log.Printf("ERROR error listing: %v", err)
+ http.Error(w, "Could not get download page. Try again in a few minutes.", 500)
+ return
+ }
+ d.Stable, d.Unstable, d.Archive = filesToReleases(fs)
+ if len(d.Stable) > 0 {
+ d.Featured = filesToFeatured(d.Stable[0].Files)
+ }
+
+ item := &memcache.Item{Key: cacheKey, Object: &d, Expiration: cacheDuration}
+ if err := h.memcache.Set(ctx, item); err != nil {
+ log.Printf("ERROR cache set error: %v", err)
+ }
+ }
+
+ if r.URL.Query().Get("mode") == "json" {
+ w.Header().Set("Content-Type", "application/json")
+ enc := json.NewEncoder(w)
+ enc.SetIndent("", " ")
+ if err := enc.Encode(d.Stable); err != nil {
+ log.Printf("ERROR rendering JSON for releases: %v", err)
+ }
+ return
+ }
+
+ if err := listTemplate.ExecuteTemplate(w, "root", d); err != nil {
+ log.Printf("ERROR executing template: %v", err)
+ }
+}
+
+func (h server) uploadHandler(w http.ResponseWriter, r *http.Request) {
+ if r.Method != "POST" {
+ http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+ return
+ }
+ ctx := r.Context()
+
+ // Authenticate using a user token (same as gomote).
+ user := r.FormValue("user")
+ if !validUser(user) {
+ http.Error(w, "bad user", http.StatusForbidden)
+ return
+ }
+ if r.FormValue("key") != h.userKey(ctx, user) {
+ http.Error(w, "bad key", http.StatusForbidden)
+ return
+ }
+
+ var f File
+ defer r.Body.Close()
+ if err := json.NewDecoder(r.Body).Decode(&f); err != nil {
+ log.Printf("ERROR decoding upload JSON: %v", err)
+ http.Error(w, "Something broke", http.StatusInternalServerError)
+ return
+ }
+ if f.Filename == "" {
+ http.Error(w, "Must provide Filename", http.StatusBadRequest)
+ return
+ }
+ if f.Uploaded.IsZero() {
+ f.Uploaded = time.Now()
+ }
+ k := datastore.NameKey("File", f.Filename, rootKey)
+ if _, err := h.datastore.Put(ctx, k, &f); err != nil {
+ log.Printf("ERROR File entity: %v", err)
+ http.Error(w, "could not put File entity", http.StatusInternalServerError)
+ return
+ }
+ if err := h.memcache.Delete(ctx, cacheKey); err != nil {
+ log.Printf("ERROR delete error: %v", err)
+ }
+ io.WriteString(w, "OK")
+}
+
+func (h server) getHandler(w http.ResponseWriter, r *http.Request) {
+ isGoGet := (r.Method == "GET" || r.Method == "HEAD") && r.FormValue("go-get") == "1"
+ // For go get, we need to serve the same meta tags at /dl for cmd/go to
+ // validate against the import path.
+ if r.URL.Path == "/dl" && isGoGet {
+ w.Header().Set("Content-Type", "text/html; charset=utf-8")
+ fmt.Fprintf(w, `<!DOCTYPE html><html><head>
+<meta name="go-import" content="golang.org/dl git https://go.googlesource.com/dl">
+</head></html>`)
+ return
+ }
+ if r.URL.Path == "/dl" {
+ http.Redirect(w, r, "/dl/", http.StatusFound)
+ return
+ }
+
+ name := strings.TrimPrefix(r.URL.Path, "/dl/")
+ var redirectURL string
+ switch {
+ case name == "":
+ h.listHandler(w, r)
+ return
+ case fileRe.MatchString(name):
+ http.Redirect(w, r, downloadBaseURL+name, http.StatusFound)
+ return
+ case name == "gotip":
+ redirectURL = "https://godoc.org/golang.org/dl/gotip"
+ case goGetRe.MatchString(name):
+ redirectURL = "https://golang.org/dl/#" + name
+ default:
+ http.NotFound(w, r)
+ return
+ }
+ w.Header().Set("Content-Type", "text/html; charset=utf-8")
+ if !isGoGet {
+ w.Header().Set("Location", redirectURL)
+ }
+ fmt.Fprintf(w, `<!DOCTYPE html>
+<html>
+<head>
+<meta name="go-import" content="golang.org/dl git https://go.googlesource.com/dl">
+<meta http-equiv="refresh" content="0; url=%s">
+</head>
+<body>
+Nothing to see here; <a href="%s">move along</a>.
+</body>
+</html>
+`, html.EscapeString(redirectURL), html.EscapeString(redirectURL))
+}
+
+func (h server) initHandler(w http.ResponseWriter, r *http.Request) {
+ var fileRoot struct {
+ Root string
+ }
+ ctx := r.Context()
+ k := rootKey
+ _, err := h.datastore.RunInTransaction(ctx, func(tx *datastore.Transaction) error {
+ err := tx.Get(k, &fileRoot)
+ if err != nil && err != datastore.ErrNoSuchEntity {
+ return err
+ }
+ _, err = tx.Put(k, &fileRoot)
+ return err
+ }, nil)
+ if err != nil {
+ http.Error(w, err.Error(), 500)
+ return
+ }
+ io.WriteString(w, "OK")
+}
+
+func (h server) userKey(c context.Context, user string) string {
+ hash := hmac.New(md5.New, []byte(h.secret(c)))
+ hash.Write([]byte("user-" + user))
+ return fmt.Sprintf("%x", hash.Sum(nil))
+}
+
+// Code below copied from x/build/app/key
+
+var theKey struct {
+ sync.RWMutex
+ builderKey
+}
+
+type builderKey struct {
+ Secret string
+}
+
+func (k *builderKey) Key() *datastore.Key {
+ return datastore.NameKey("BuilderKey", "root", nil)
+}
+
+func (h server) secret(ctx context.Context) string {
+ // check with rlock
+ theKey.RLock()
+ k := theKey.Secret
+ theKey.RUnlock()
+ if k != "" {
+ return k
+ }
+
+ // prepare to fill; check with lock and keep lock
+ theKey.Lock()
+ defer theKey.Unlock()
+ if theKey.Secret != "" {
+ return theKey.Secret
+ }
+
+ // fill
+ if err := h.datastore.Get(ctx, theKey.Key(), &theKey.builderKey); err != nil {
+ if err == datastore.ErrNoSuchEntity {
+ // If the key is not stored in datastore, write it.
+ // This only happens at the beginning of a new deployment.
+ // The code is left here for SDK use and in case a fresh
+ // deployment is ever needed. "gophers rule" is not the
+ // real key.
+ if env.IsProd() {
+ panic("lost key from datastore")
+ }
+ theKey.Secret = "gophers rule"
+ h.datastore.Put(ctx, theKey.Key(), &theKey.builderKey)
+ return theKey.Secret
+ }
+ panic("cannot load builder key: " + err.Error())
+ }
+
+ return theKey.Secret
+}
diff --git a/internal/dl/tmpl.go b/internal/dl/tmpl.go
new file mode 100644
index 0000000..d086b69
--- /dev/null
+++ b/internal/dl/tmpl.go
@@ -0,0 +1,277 @@
+// Copyright 2015 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.
+
+package dl
+
+// TODO(adg): refactor this to use the tools/godoc/static template.
+
+const templateHTML = `
+{{define "root"}}
+<!DOCTYPE html>
+<html>
+<head>
+ <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+ <title>Downloads - The Go Programming Language</title>
+ <link type="text/css" rel="stylesheet" href="/lib/godoc/style.css">
+ <script type="text/javascript">window.initFuncs = [];</script>
+ <style>
+ table.codetable {
+ margin-left: 20px; margin-right: 20px;
+ border-collapse: collapse;
+ }
+ table.codetable tr {
+ background-color: #f0f0f0;
+ }
+ table.codetable tr:nth-child(2n), table.codetable tr.first {
+ background-color: white;
+ }
+ table.codetable td, table.codetable th {
+ white-space: nowrap;
+ padding: 6px 10px;
+ }
+ table.codetable tt {
+ font-size: xx-small;
+ }
+ table.codetable tr.highlight td {
+ font-weight: bold;
+ }
+ a.downloadBox {
+ display: block;
+ color: #222;
+ border: 1px solid #375EAB;
+ border-radius: 5px;
+ background: #E0EBF5;
+ width: 280px;
+ float: left;
+ margin-left: 10px;
+ margin-bottom: 10px;
+ padding: 10px;
+ }
+ a.downloadBox:hover {
+ text-decoration: none;
+ }
+ .downloadBox .platform {
+ font-size: large;
+ }
+ .downloadBox .filename {
+ color: #375EAB;
+ font-weight: bold;
+ line-height: 1.5em;
+ }
+ a.downloadBox:hover .filename {
+ text-decoration: underline;
+ }
+ .downloadBox .size {
+ font-size: small;
+ font-weight: normal;
+ }
+ .downloadBox .reqs {
+ font-size: small;
+ font-style: italic;
+ }
+ .downloadBox .checksum {
+ font-size: 5pt;
+ }
+ </style>
+</head>
+<body>
+
+<div id="topbar"><div class="container">
+
+<div class="top-heading"><a href="/">The Go Programming Language</a></div>
+<form method="GET" action="/search">
+<div id="menu">
+<a href="/doc/">Documents</a>
+<a href="/pkg/">Packages</a>
+<a href="/project/">The Project</a>
+<a href="/help/">Help</a>
+<a href="/blog/">Blog</a>
+<span class="search-box"><input type="search" id="search" name="q" placeholder="Search" aria-label="Search" required><button type="submit"><span><!-- magnifying glass: --><svg width="24" height="24" viewBox="0 0 24 24"><title>submit search</title><path d="M15.5 14h-.79l-.28-.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-.59 4.23-1.57l.27.28v.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"/><path d="M0 0h24v24H0z" fill="none"/></svg></span></button></span>
+</div>
+</form>
+
+</div></div>
+
+<div id="page">
+<div class="container">
+
+<h1>Downloads</h1>
+
+<p>
+After downloading a binary release suitable for your system,
+please follow the <a href="/doc/install">installation instructions</a>.
+</p>
+
+<p>
+If you are building from source,
+follow the <a href="/doc/install/source">source installation instructions</a>.
+</p>
+
+<p>
+See the <a href="/doc/devel/release.html">release history</a> for more
+information about Go releases.
+</p>
+
+{{with .Featured}}
+<h3 id="featured">Featured downloads</h3>
+{{range .}}
+{{template "download" .}}
+{{end}}
+{{end}}
+
+<div style="clear: both;"></div>
+
+{{with .Stable}}
+<h3 id="stable">Stable versions</h3>
+{{template "releases" .}}
+{{end}}
+
+{{with .Unstable}}
+<h3 id="unstable">Unstable version</h3>
+{{template "releases" .}}
+{{end}}
+
+{{with .Archive}}
+<div class="toggle" id="archive">
+ <div class="collapsed">
+ <h3 class="toggleButton" title="Click to show versions">Archived versionsā¹</h3>
+ </div>
+ <div class="expanded">
+ <h3 class="toggleButton" title="Click to hide versions">Archived versionsā¾</h3>
+ {{template "releases" .}}
+ </div>
+</div>
+{{end}}
+
+<div id="footer">
+ <p>
+ Except as
+ <a href="https://developers.google.com/site-policies#restrictions">noted</a>,
+ the content of this page is licensed under the Creative Commons
+ Attribution 3.0 License,<br>
+ and code is licensed under a <a href="http://golang.org/LICENSE">BSD license</a>.<br>
+ <a href="http://golang.org/doc/tos.html">Terms of Service</a> |
+ <a href="http://www.google.com/intl/en/policies/privacy/">Privacy Policy</a>
+ </p>
+</div><!-- #footer -->
+
+</div><!-- .container -->
+</div><!-- #page -->
+<script>
+ (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+ (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+ m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+ })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
+
+ ga('create', 'UA-11222381-2', 'auto');
+ ga('send', 'pageview');
+
+</script>
+</body>
+<script src="/lib/godoc/jquery.js"></script>
+<script src="/lib/godoc/godocs.js"></script>
+<script>
+$(document).ready(function() {
+ $('a.download').click(function(e) {
+ // Try using the link text as the file name,
+ // unless there's a child element of class 'filename'.
+ var filename = $(this).text();
+ var child = $(this).find('.filename');
+ if (child.length > 0) {
+ filename = child.text();
+ }
+
+ // This must be kept in sync with the filenameRE in godocs.js.
+ var filenameRE = /^go1\.\d+(\.\d+)?([a-z0-9]+)?\.([a-z0-9]+)(-[a-z0-9]+)?(-osx10\.[68])?\.([a-z.]+)$/;
+ var m = filenameRE.exec(filename);
+ if (!m) {
+ // Don't redirect to the download page if it won't recognize this file.
+ // (Should not happen.)
+ return;
+ }
+
+ var dest = "/doc/install";
+ if (filename.indexOf(".src.") != -1) {
+ dest += "/source";
+ }
+ dest += "?download=" + filename;
+
+ e.preventDefault();
+ e.stopPropagation();
+ window.location = dest;
+ });
+});
+</script>
+</html>
+{{end}}
+
+{{define "releases"}}
+{{range .}}
+<div class="toggle{{if .Visible}}Visible{{end}}" id="{{.Version}}">
+ <div class="collapsed">
+ <h2 class="toggleButton" title="Click to show downloads for this version">{{.Version}} ā¹</h2>
+ </div>
+ <div class="expanded">
+ <h2 class="toggleButton" title="Click to hide downloads for this version">{{.Version}} ā¾</h2>
+ {{if .Stable}}{{else}}
+ <p>This is an <b>unstable</b> version of Go. Use with caution.</p>
+ <p>If you already have Go installed, you can install this version by running:</p>
+<pre>
+go get golang.org/dl/{{.Version}}
+</pre>
+ <p>Then, use the <code>{{.Version}}</code> command instead of the <code>go</code> command to use {{.Version}}.</p>
+ {{end}}
+ {{template "files" .}}
+ </div>
+</div>
+{{end}}
+{{end}}
+
+{{define "files"}}
+<table class="codetable">
+<thead>
+<tr class="first">
+ <th>File name</th>
+ <th>Kind</th>
+ <th>OS</th>
+ <th>Arch</th>
+ <th>Size</th>
+ {{/* Use the checksum type of the first file for the column heading. */}}
+ <th>{{(index .Files 0).ChecksumType}} Checksum</th>
+</tr>
+</thead>
+{{if .SplitPortTable}}
+ {{range .Files}}{{if .PrimaryPort}}{{template "file" .}}{{end}}{{end}}
+
+ {{/* TODO(cbro): add a link to an explanatory doc page */}}
+ <tr class="first"><th colspan="6" class="first">Other Ports</th></tr>
+ {{range .Files}}{{if not .PrimaryPort}}{{template "file" .}}{{end}}{{end}}
+{{else}}
+ {{range .Files}}{{template "file" .}}{{end}}
+{{end}}
+</table>
+{{end}}
+
+{{define "file"}}
+<tr{{if .Highlight}} class="highlight"{{end}}>
+ <td class="filename"><a class="download" href="{{.URL}}">{{.Filename}}</a></td>
+ <td>{{pretty .Kind}}</td>
+ <td>{{.PrettyOS}}</td>
+ <td>{{pretty .Arch}}</td>
+ <td>{{.PrettySize}}</td>
+ <td><tt>{{.PrettyChecksum}}</tt></td>
+</tr>
+{{end}}
+
+{{define "download"}}
+<a class="download downloadBox" href="{{.URL}}">
+<div class="platform">{{.Platform}}</div>
+{{with .Requirements}}<div class="reqs">{{.}}</div>{{end}}
+<div>
+ <span class="filename">{{.Filename}}</span>
+ {{if .Size}}<span class="size">({{.PrettySize}})</span>{{end}}
+</div>
+</a>
+{{end}}
+`
diff --git a/internal/env/env.go b/internal/env/env.go
new file mode 100644
index 0000000..e1f55cd
--- /dev/null
+++ b/internal/env/env.go
@@ -0,0 +1,41 @@
+// Copyright 2018 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 env provides environment information for the godoc server running on
+// golang.org.
+package env
+
+import (
+ "log"
+ "os"
+ "strconv"
+)
+
+var (
+ isProd = boolEnv("GODOC_PROD")
+ enforceHosts = boolEnv("GODOC_ENFORCE_HOSTS")
+)
+
+// IsProd reports whether the server is running in its production configuration
+// on golang.org.
+func IsProd() bool {
+ return isProd
+}
+
+// EnforceHosts reports whether host filtering should be enforced.
+func EnforceHosts() bool {
+ return enforceHosts
+}
+
+func boolEnv(key string) bool {
+ v := os.Getenv(key)
+ if v == "" {
+ return false
+ }
+ b, err := strconv.ParseBool(v)
+ if err != nil {
+ log.Fatalf("environment variable %s (%q) must be a boolean", key, v)
+ }
+ return b
+}
diff --git a/internal/proxy/proxy.go b/internal/proxy/proxy.go
new file mode 100644
index 0000000..bb0e81c
--- /dev/null
+++ b/internal/proxy/proxy.go
@@ -0,0 +1,170 @@
+// Copyright 2015 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 proxy proxies requests to the playground's compile and share handlers.
+// It is designed to run only on the instance of godoc that serves golang.org.
+package proxy
+
+import (
+ "bytes"
+ "context"
+ "encoding/json"
+ "fmt"
+ "io"
+ "io/ioutil"
+ "log"
+ "net/http"
+ "strings"
+ "time"
+
+ "golang.org/x/tools/godoc/env"
+)
+
+const playgroundURL = "https://play.golang.org"
+
+type Request struct {
+ Body string
+}
+
+type Response struct {
+ Errors string
+ Events []Event
+}
+
+type Event struct {
+ Message string
+ Kind string // "stdout" or "stderr"
+ Delay time.Duration // time to wait before printing Message
+}
+
+const expires = 7 * 24 * time.Hour // 1 week
+var cacheControlHeader = fmt.Sprintf("public, max-age=%d", int(expires.Seconds()))
+
+func RegisterHandlers(mux *http.ServeMux) {
+ mux.HandleFunc("/compile", compile)
+ mux.HandleFunc("/share", share)
+}
+
+func compile(w http.ResponseWriter, r *http.Request) {
+ if r.Method != "POST" {
+ http.Error(w, "I only answer to POST requests.", http.StatusMethodNotAllowed)
+ return
+ }
+
+ ctx := r.Context()
+
+ body := r.FormValue("body")
+ res := &Response{}
+ req := &Request{Body: body}
+ if err := makeCompileRequest(ctx, req, res); err != nil {
+ log.Printf("ERROR compile error: %v", err)
+ http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+ return
+ }
+
+ var out interface{}
+ switch r.FormValue("version") {
+ case "2":
+ out = res
+ default: // "1"
+ out = struct {
+ CompileErrors string `json:"compile_errors"`
+ Output string `json:"output"`
+ }{res.Errors, flatten(res.Events)}
+ }
+ b, err := json.Marshal(out)
+ if err != nil {
+ log.Printf("ERROR encoding response: %v", err)
+ http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+ return
+ }
+
+ expiresTime := time.Now().Add(expires).UTC()
+ w.Header().Set("Expires", expiresTime.Format(time.RFC1123))
+ w.Header().Set("Cache-Control", cacheControlHeader)
+ w.Write(b)
+}
+
+// makePlaygroundRequest sends the given Request to the playground compile
+// endpoint and stores the response in the given Response.
+func makeCompileRequest(ctx context.Context, req *Request, res *Response) error {
+ reqJ, err := json.Marshal(req)
+ if err != nil {
+ return fmt.Errorf("marshalling request: %v", err)
+ }
+ hReq, _ := http.NewRequest("POST", playgroundURL+"/compile", bytes.NewReader(reqJ))
+ hReq.Header.Set("Content-Type", "application/json")
+ hReq = hReq.WithContext(ctx)
+
+ r, err := http.DefaultClient.Do(hReq)
+ if err != nil {
+ return fmt.Errorf("making request: %v", err)
+ }
+ defer r.Body.Close()
+
+ if r.StatusCode != http.StatusOK {
+ b, _ := ioutil.ReadAll(r.Body)
+ return fmt.Errorf("bad status: %v body:\n%s", r.Status, b)
+ }
+
+ if err := json.NewDecoder(r.Body).Decode(res); err != nil {
+ return fmt.Errorf("unmarshalling response: %v", err)
+ }
+ return nil
+}
+
+// flatten takes a sequence of Events and returns their contents, concatenated.
+func flatten(seq []Event) string {
+ var buf bytes.Buffer
+ for _, e := range seq {
+ buf.WriteString(e.Message)
+ }
+ return buf.String()
+}
+
+func share(w http.ResponseWriter, r *http.Request) {
+ if googleCN(r) {
+ http.Error(w, http.StatusText(http.StatusForbidden), http.StatusForbidden)
+ return
+ }
+
+ // HACK(cbro): use a simple proxy rather than httputil.ReverseProxy because of Issue #28168.
+ // TODO: investigate using ReverseProxy with a Director, unsetting whatever's necessary to make that work.
+ req, _ := http.NewRequest("POST", playgroundURL+"/share", r.Body)
+ req.Header.Set("Content-Type", r.Header.Get("Content-Type"))
+ req = req.WithContext(r.Context())
+ resp, err := http.DefaultClient.Do(req)
+ if err != nil {
+ log.Printf("ERROR share error: %v", err)
+ http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+ return
+ }
+ copyHeader := func(k string) {
+ if v := resp.Header.Get(k); v != "" {
+ w.Header().Set(k, v)
+ }
+ }
+ copyHeader("Content-Type")
+ copyHeader("Content-Length")
+ defer resp.Body.Close()
+ w.WriteHeader(resp.StatusCode)
+ io.Copy(w, resp.Body)
+}
+
+func googleCN(r *http.Request) bool {
+ if r.FormValue("googlecn") != "" {
+ return true
+ }
+ if !env.IsProd() {
+ return false
+ }
+ if strings.HasSuffix(r.Host, ".cn") {
+ return true
+ }
+ switch r.Header.Get("X-AppEngine-Country") {
+ case "", "ZZ", "CN":
+ return true
+ }
+ return false
+}
diff --git a/internal/redirect/hash.go b/internal/redirect/hash.go
new file mode 100644
index 0000000..d5a1e3e
--- /dev/null
+++ b/internal/redirect/hash.go
@@ -0,0 +1,138 @@
+// Copyright 2014 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.
+
+// This file provides a compact encoding of
+// a map of Mercurial hashes to Git hashes.
+
+package redirect
+
+import (
+ "encoding/binary"
+ "fmt"
+ "io"
+ "os"
+ "sort"
+ "strconv"
+ "strings"
+)
+
+// hashMap is a map of Mercurial hashes to Git hashes.
+type hashMap struct {
+ file *os.File
+ entries int
+}
+
+// newHashMap takes a file handle that contains a map of Mercurial to Git
+// hashes. The file should be a sequence of pairs of little-endian encoded
+// uint32s, representing a hgHash and a gitHash respectively.
+// The sequence must be sorted by hgHash.
+// The file must remain open for as long as the returned hashMap is used.
+func newHashMap(f *os.File) (*hashMap, error) {
+ fi, err := f.Stat()
+ if err != nil {
+ return nil, err
+ }
+ return &hashMap{file: f, entries: int(fi.Size() / 8)}, nil
+}
+
+// Lookup finds an hgHash in the map that matches the given prefix, and returns
+// its corresponding gitHash. The prefix must be at least 8 characters long.
+func (m *hashMap) Lookup(s string) gitHash {
+ if m == nil {
+ return 0
+ }
+ hg, err := hgHashFromString(s)
+ if err != nil {
+ return 0
+ }
+ var git gitHash
+ b := make([]byte, 8)
+ sort.Search(m.entries, func(i int) bool {
+ n, err := m.file.ReadAt(b, int64(i*8))
+ if err != nil {
+ panic(err)
+ }
+ if n != 8 {
+ panic(io.ErrUnexpectedEOF)
+ }
+ v := hgHash(binary.LittleEndian.Uint32(b[:4]))
+ if v == hg {
+ git = gitHash(binary.LittleEndian.Uint32(b[4:]))
+ }
+ return v >= hg
+ })
+ return git
+}
+
+// hgHash represents the lower (leftmost) 32 bits of a Mercurial hash.
+type hgHash uint32
+
+func (h hgHash) String() string {
+ return intToHash(int64(h))
+}
+
+func hgHashFromString(s string) (hgHash, error) {
+ if len(s) < 8 {
+ return 0, fmt.Errorf("string too small: len(s) = %d", len(s))
+ }
+ hash := s[:8]
+ i, err := strconv.ParseInt(hash, 16, 64)
+ if err != nil {
+ return 0, err
+ }
+ return hgHash(i), nil
+}
+
+// gitHash represents the leftmost 28 bits of a Git hash in its upper 28 bits,
+// and it encodes hash's repository in the lower 4 bits.
+type gitHash uint32
+
+func (h gitHash) Hash() string {
+ return intToHash(int64(h))[:7]
+}
+
+func (h gitHash) Repo() string {
+ return repo(h & 0xF).String()
+}
+
+func intToHash(i int64) string {
+ s := strconv.FormatInt(i, 16)
+ if len(s) < 8 {
+ s = strings.Repeat("0", 8-len(s)) + s
+ }
+ return s
+}
+
+// repo represents a Go Git repository.
+type repo byte
+
+const (
+ repoGo repo = iota
+ repoBlog
+ repoCrypto
+ repoExp
+ repoImage
+ repoMobile
+ repoNet
+ repoSys
+ repoTalks
+ repoText
+ repoTools
+)
+
+func (r repo) String() string {
+ return map[repo]string{
+ repoGo: "go",
+ repoBlog: "blog",
+ repoCrypto: "crypto",
+ repoExp: "exp",
+ repoImage: "image",
+ repoMobile: "mobile",
+ repoNet: "net",
+ repoSys: "sys",
+ repoTalks: "talks",
+ repoText: "text",
+ repoTools: "tools",
+ }[r]
+}
diff --git a/internal/redirect/redirect.go b/internal/redirect/redirect.go
new file mode 100644
index 0000000..b4599f6
--- /dev/null
+++ b/internal/redirect/redirect.go
@@ -0,0 +1,324 @@
+// Copyright 2013 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 redirect provides hooks to register HTTP handlers that redirect old
+// godoc paths to their new equivalents and assist in accessing the issue
+// tracker, wiki, code review system, etc.
+package redirect // import "golang.org/x/tools/godoc/redirect"
+
+import (
+ "context"
+ "fmt"
+ "html/template"
+ "net/http"
+ "os"
+ "regexp"
+ "strconv"
+ "strings"
+ "sync"
+ "time"
+
+ "golang.org/x/net/context/ctxhttp"
+)
+
+// Register registers HTTP handlers that redirect old godoc paths to their new
+// equivalents and assist in accessing the issue tracker, wiki, code review
+// system, etc. If mux is nil it uses http.DefaultServeMux.
+func Register(mux *http.ServeMux) {
+ if mux == nil {
+ mux = http.DefaultServeMux
+ }
+ handlePathRedirects(mux, pkgRedirects, "/pkg/")
+ handlePathRedirects(mux, cmdRedirects, "/cmd/")
+ for prefix, redirect := range prefixHelpers {
+ p := "/" + prefix + "/"
+ mux.Handle(p, PrefixHandler(p, redirect))
+ }
+ for path, redirect := range redirects {
+ mux.Handle(path, Handler(redirect))
+ }
+ // NB: /src/pkg (sans trailing slash) is the index of packages.
+ mux.HandleFunc("/src/pkg/", srcPkgHandler)
+ mux.HandleFunc("/cl/", clHandler)
+ mux.HandleFunc("/change/", changeHandler)
+ mux.HandleFunc("/design/", designHandler)
+}
+
+func handlePathRedirects(mux *http.ServeMux, redirects map[string]string, prefix string) {
+ for source, target := range redirects {
+ h := Handler(prefix + target + "/")
+ p := prefix + source
+ mux.Handle(p, h)
+ mux.Handle(p+"/", h)
+ }
+}
+
+// Packages that were renamed between r60 and go1.
+var pkgRedirects = map[string]string{
+ "asn1": "encoding/asn1",
+ "big": "math/big",
+ "cmath": "math/cmplx",
+ "csv": "encoding/csv",
+ "exec": "os/exec",
+ "exp/template/html": "html/template",
+ "gob": "encoding/gob",
+ "http": "net/http",
+ "http/cgi": "net/http/cgi",
+ "http/fcgi": "net/http/fcgi",
+ "http/httptest": "net/http/httptest",
+ "http/pprof": "net/http/pprof",
+ "json": "encoding/json",
+ "mail": "net/mail",
+ "rand": "math/rand",
+ "rpc": "net/rpc",
+ "rpc/jsonrpc": "net/rpc/jsonrpc",
+ "scanner": "text/scanner",
+ "smtp": "net/smtp",
+ "tabwriter": "text/tabwriter",
+ "template": "text/template",
+ "template/parse": "text/template/parse",
+ "url": "net/url",
+ "utf16": "unicode/utf16",
+ "utf8": "unicode/utf8",
+ "xml": "encoding/xml",
+}
+
+// Commands that were renamed between r60 and go1.
+var cmdRedirects = map[string]string{
+ "gofix": "fix",
+ "goinstall": "go",
+ "gopack": "pack",
+ "gotest": "go",
+ "govet": "vet",
+ "goyacc": "yacc",
+}
+
+var redirects = map[string]string{
+ "/blog": "/blog/",
+ "/build": "http://build.golang.org",
+ "/change": "https://go.googlesource.com/go",
+ "/cl": "https://go-review.googlesource.com",
+ "/cmd/godoc/": "http://godoc.org/golang.org/x/tools/cmd/godoc/",
+ "/issue": "https://github.com/golang/go/issues",
+ "/issue/new": "https://github.com/golang/go/issues/new",
+ "/issues": "https://github.com/golang/go/issues",
+ "/issues/new": "https://github.com/golang/go/issues/new",
+ "/play": "http://play.golang.org",
+ "/design": "https://go.googlesource.com/proposal/+/master/design",
+
+ // In Go 1.2 the references page is part of /doc/.
+ "/ref": "/doc/#references",
+ // This next rule clobbers /ref/spec and /ref/mem.
+ // TODO(adg): figure out what to do here, if anything.
+ // "/ref/": "/doc/#references",
+
+ // Be nice to people who are looking in the wrong place.
+ "/doc/mem": "/ref/mem",
+ "/doc/spec": "/ref/spec",
+
+ "/talks": "http://talks.golang.org",
+ "/tour": "http://tour.golang.org",
+ "/wiki": "https://github.com/golang/go/wiki",
+
+ "/doc/articles/c_go_cgo.html": "/blog/c-go-cgo",
+ "/doc/articles/concurrency_patterns.html": "/blog/go-concurrency-patterns-timing-out-and",
+ "/doc/articles/defer_panic_recover.html": "/blog/defer-panic-and-recover",
+ "/doc/articles/error_handling.html": "/blog/error-handling-and-go",
+ "/doc/articles/gobs_of_data.html": "/blog/gobs-of-data",
+ "/doc/articles/godoc_documenting_go_code.html": "/blog/godoc-documenting-go-code",
+ "/doc/articles/gos_declaration_syntax.html": "/blog/gos-declaration-syntax",
+ "/doc/articles/image_draw.html": "/blog/go-imagedraw-package",
+ "/doc/articles/image_package.html": "/blog/go-image-package",
+ "/doc/articles/json_and_go.html": "/blog/json-and-go",
+ "/doc/articles/json_rpc_tale_of_interfaces.html": "/blog/json-rpc-tale-of-interfaces",
+ "/doc/articles/laws_of_reflection.html": "/blog/laws-of-reflection",
+ "/doc/articles/slices_usage_and_internals.html": "/blog/go-slices-usage-and-internals",
+ "/doc/go_for_cpp_programmers.html": "/wiki/GoForCPPProgrammers",
+ "/doc/go_tutorial.html": "http://tour.golang.org/",
+}
+
+var prefixHelpers = map[string]string{
+ "issue": "https://github.com/golang/go/issues/",
+ "issues": "https://github.com/golang/go/issues/",
+ "play": "http://play.golang.org/",
+ "talks": "http://talks.golang.org/",
+ "wiki": "https://github.com/golang/go/wiki/",
+}
+
+func Handler(target string) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ url := target
+ if qs := r.URL.RawQuery; qs != "" {
+ url += "?" + qs
+ }
+ http.Redirect(w, r, url, http.StatusMovedPermanently)
+ })
+}
+
+var validId = regexp.MustCompile(`^[A-Za-z0-9-]*/?$`)
+
+func PrefixHandler(prefix, baseURL string) http.Handler {
+ return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ if p := r.URL.Path; p == prefix {
+ // redirect /prefix/ to /prefix
+ http.Redirect(w, r, p[:len(p)-1], http.StatusFound)
+ return
+ }
+ id := r.URL.Path[len(prefix):]
+ if !validId.MatchString(id) {
+ http.Error(w, "Not found", http.StatusNotFound)
+ return
+ }
+ target := baseURL + id
+ http.Redirect(w, r, target, http.StatusFound)
+ })
+}
+
+// Redirect requests from the old "/src/pkg/foo" to the new "/src/foo".
+// See http://golang.org/s/go14nopkg
+func srcPkgHandler(w http.ResponseWriter, r *http.Request) {
+ r.URL.Path = "/src/" + r.URL.Path[len("/src/pkg/"):]
+ http.Redirect(w, r, r.URL.String(), http.StatusMovedPermanently)
+}
+
+func clHandler(w http.ResponseWriter, r *http.Request) {
+ const prefix = "/cl/"
+ if p := r.URL.Path; p == prefix {
+ // redirect /prefix/ to /prefix
+ http.Redirect(w, r, p[:len(p)-1], http.StatusFound)
+ return
+ }
+ id := r.URL.Path[len(prefix):]
+ // support /cl/152700045/, which is used in commit 0edafefc36.
+ id = strings.TrimSuffix(id, "/")
+ if !validId.MatchString(id) {
+ http.Error(w, "Not found", http.StatusNotFound)
+ return
+ }
+ target := ""
+
+ if n, err := strconv.Atoi(id); err == nil && isRietveldCL(n) {
+ // Issue 28836: if this Rietveld CL happens to
+ // also be a Gerrit CL, render a disambiguation HTML
+ // page with two links instead. We need to make a
+ // Gerrit API call to figure that out, but we cache
+ // known Gerrit CLs so it's done at most once per CL.
+ if ok, err := isGerritCL(r.Context(), n); err == nil && ok {
+ w.Header().Set("Content-Type", "text/html; charset=utf-8")
+ clDisambiguationHTML.Execute(w, n)
+ return
+ }
+
+ target = "https://codereview.appspot.com/" + id
+ } else {
+ target = "https://go-review.googlesource.com/" + id
+ }
+ http.Redirect(w, r, target, http.StatusFound)
+}
+
+var clDisambiguationHTML = template.Must(template.New("").Parse(`<!DOCTYPE html>
+<html lang="en">
+ <head>
+ <title>Go CL {{.}} Disambiguation</title>
+ <meta name="viewport" content="width=device-width">
+ </head>
+ <body>
+ CL number {{.}} exists in both Gerrit (the current code review system)
+ and Rietveld (the previous code review system). Please make a choice:
+
+ <ul>
+ <li><a href="https://go-review.googlesource.com/{{.}}">Gerrit CL {{.}}</a></li>
+ <li><a href="https://codereview.appspot.com/{{.}}">Rietveld CL {{.}}</a></li>
+ </ul>
+ </body>
+</html>`))
+
+// isGerritCL reports whether a Gerrit CL with the specified numeric change ID (e.g., "4247")
+// is known to exist by querying the Gerrit API at https://go-review.googlesource.com.
+// isGerritCL uses gerritCLCache as a cache of Gerrit CL IDs that exist.
+func isGerritCL(ctx context.Context, id int) (bool, error) {
+ // Check cache first.
+ gerritCLCache.Lock()
+ ok := gerritCLCache.exist[id]
+ gerritCLCache.Unlock()
+ if ok {
+ return true, nil
+ }
+
+ // Query the Gerrit API Get Change endpoint, as documented at
+ // https://gerrit-review.googlesource.com/Documentation/rest-api-changes.html#get-change.
+ ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
+ defer cancel()
+ resp, err := ctxhttp.Get(ctx, nil, fmt.Sprintf("https://go-review.googlesource.com/changes/%d", id))
+ if err != nil {
+ return false, err
+ }
+ resp.Body.Close()
+ switch resp.StatusCode {
+ case http.StatusOK:
+ // A Gerrit CL with this ID exists. Add it to cache.
+ gerritCLCache.Lock()
+ gerritCLCache.exist[id] = true
+ gerritCLCache.Unlock()
+ return true, nil
+ case http.StatusNotFound:
+ // A Gerrit CL with this ID doesn't exist. It may get created in the future.
+ return false, nil
+ default:
+ return false, fmt.Errorf("unexpected status code: %v", resp.Status)
+ }
+}
+
+var gerritCLCache = struct {
+ sync.Mutex
+ exist map[int]bool // exist is a set of Gerrit CL IDs that are known to exist.
+}{exist: make(map[int]bool)}
+
+var changeMap *hashMap
+
+// LoadChangeMap loads the specified map of Mercurial to Git revisions,
+// which is used by the /change/ handler to intelligently map old hg
+// revisions to their new git equivalents.
+// It should be called before calling Register.
+// The file should remain open as long as the process is running.
+// See the implementation of this package for details.
+func LoadChangeMap(filename string) error {
+ f, err := os.Open(filename)
+ if err != nil {
+ return err
+ }
+ m, err := newHashMap(f)
+ if err != nil {
+ return err
+ }
+ changeMap = m
+ return nil
+}
+
+func changeHandler(w http.ResponseWriter, r *http.Request) {
+ const prefix = "/change/"
+ if p := r.URL.Path; p == prefix {
+ // redirect /prefix/ to /prefix
+ http.Redirect(w, r, p[:len(p)-1], http.StatusFound)
+ return
+ }
+ hash := r.URL.Path[len(prefix):]
+ target := "https://go.googlesource.com/go/+/" + hash
+ if git := changeMap.Lookup(hash); git > 0 {
+ target = fmt.Sprintf("https://go.googlesource.com/%v/+/%v", git.Repo(), git.Hash())
+ }
+ http.Redirect(w, r, target, http.StatusFound)
+}
+
+func designHandler(w http.ResponseWriter, r *http.Request) {
+ const prefix = "/design/"
+ if p := r.URL.Path; p == prefix {
+ // redirect /prefix/ to /prefix
+ http.Redirect(w, r, p[:len(p)-1], http.StatusFound)
+ return
+ }
+ name := r.URL.Path[len(prefix):]
+ target := "https://go.googlesource.com/proposal/+/master/design/" + name + ".md"
+ http.Redirect(w, r, target, http.StatusFound)
+}
diff --git a/internal/redirect/redirect_test.go b/internal/redirect/redirect_test.go
new file mode 100644
index 0000000..804bfb0
--- /dev/null
+++ b/internal/redirect/redirect_test.go
@@ -0,0 +1,113 @@
+// Copyright 2015 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 redirect
+
+import (
+ "net/http"
+ "net/http/httptest"
+ "testing"
+)
+
+type redirectResult struct {
+ status int
+ path string
+}
+
+func errorResult(status int) redirectResult {
+ return redirectResult{status, ""}
+}
+
+func TestRedirects(t *testing.T) {
+ var tests = map[string]redirectResult{
+ "/build": {301, "http://build.golang.org"},
+ "/ref": {301, "/doc/#references"},
+ "/doc/mem": {301, "/ref/mem"},
+ "/doc/spec": {301, "/ref/spec"},
+ "/tour": {301, "http://tour.golang.org"},
+ "/foo": errorResult(404),
+
+ "/pkg/asn1": {301, "/pkg/encoding/asn1/"},
+ "/pkg/template/parse": {301, "/pkg/text/template/parse/"},
+
+ "/src/pkg/foo": {301, "/src/foo"},
+
+ "/cmd/gofix": {301, "/cmd/fix/"},
+
+ // git commits (/change)
+ // TODO: mercurial tags and LoadChangeMap.
+ "/change": {301, "https://go.googlesource.com/go"},
+ "/change/a": {302, "https://go.googlesource.com/go/+/a"},
+
+ "/issue": {301, "https://github.com/golang/go/issues"},
+ "/issue?": {301, "https://github.com/golang/go/issues"},
+ "/issue/1": {302, "https://github.com/golang/go/issues/1"},
+ "/issue/new": {301, "https://github.com/golang/go/issues/new"},
+ "/issue/new?a=b&c=d%20&e=f": {301, "https://github.com/golang/go/issues/new?a=b&c=d%20&e=f"},
+ "/issues": {301, "https://github.com/golang/go/issues"},
+ "/issues/1": {302, "https://github.com/golang/go/issues/1"},
+ "/issues/new": {301, "https://github.com/golang/go/issues/new"},
+ "/issues/1/2/3": errorResult(404),
+
+ "/wiki/foo": {302, "https://github.com/golang/go/wiki/foo"},
+ "/wiki/foo/": {302, "https://github.com/golang/go/wiki/foo/"},
+
+ "/design": {301, "https://go.googlesource.com/proposal/+/master/design"},
+ "/design/": {302, "/design"},
+ "/design/123-foo": {302, "https://go.googlesource.com/proposal/+/master/design/123-foo.md"},
+ "/design/text/123-foo": {302, "https://go.googlesource.com/proposal/+/master/design/text/123-foo.md"},
+
+ "/cl/1": {302, "https://go-review.googlesource.com/1"},
+ "/cl/1/": {302, "https://go-review.googlesource.com/1"},
+ "/cl/267120043": {302, "https://codereview.appspot.com/267120043"},
+ "/cl/267120043/": {302, "https://codereview.appspot.com/267120043"},
+
+ // Verify that we're using the Rietveld CL table:
+ "/cl/152046": {302, "https://codereview.appspot.com/152046"},
+ "/cl/152047": {302, "https://go-review.googlesource.com/152047"},
+ "/cl/152048": {302, "https://codereview.appspot.com/152048"},
+
+ // And verify we're using the the "bigEnoughAssumeRietveld" value:
+ "/cl/299999": {302, "https://go-review.googlesource.com/299999"},
+ "/cl/300000": {302, "https://codereview.appspot.com/300000"},
+ }
+
+ mux := http.NewServeMux()
+ Register(mux)
+ ts := httptest.NewServer(mux)
+ defer ts.Close()
+
+ for path, want := range tests {
+ if want.path != "" && want.path[0] == '/' {
+ // All redirects are absolute.
+ want.path = ts.URL + want.path
+ }
+
+ req, err := http.NewRequest("GET", ts.URL+path, nil)
+ if err != nil {
+ t.Errorf("(path: %q) unexpected error: %v", path, err)
+ continue
+ }
+
+ resp, err := http.DefaultTransport.RoundTrip(req)
+ if err != nil {
+ t.Errorf("(path: %q) unexpected error: %v", path, err)
+ continue
+ }
+
+ if resp.StatusCode != want.status {
+ t.Errorf("(path: %q) got status %d, want %d", path, resp.StatusCode, want.status)
+ }
+
+ if want.status != 301 && want.status != 302 {
+ // Not a redirect. Just check status.
+ continue
+ }
+
+ out, _ := resp.Location()
+ if got := out.String(); got != want.path {
+ t.Errorf("(path: %q) got %s, want %s", path, got, want.path)
+ }
+ }
+}
diff --git a/internal/redirect/rietveld.go b/internal/redirect/rietveld.go
new file mode 100644
index 0000000..81b1094
--- /dev/null
+++ b/internal/redirect/rietveld.go
@@ -0,0 +1,1093 @@
+// Copyright 2018 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 redirect
+
+// bigEnoughAssumeRietveld is the value where CLs equal or great are
+// assumed to be on Rietveld. By including this threshold we shrink
+// the size of the table below. When Go amasses 150,000 more CLs, we'll
+// need to bump this number and regenerate the list below.
+const bigEnoughAssumeRietveld = 300000
+
+// isRietveldCL reports whether cl was a Rietveld CL number.
+func isRietveldCL(cl int) bool {
+ return cl >= bigEnoughAssumeRietveld || lowRietveldCL[cl]
+}
+
+// lowRietveldCLs are the old CL numbers assigned by Rietveld code
+// review system as used by Go prior to Gerrit which are less than
+// bigEnoughAssumeRietveld.
+//
+// This list of numbers is registered with the /cl/NNNN redirect
+// handler to disambiguate which code review system a particular
+// number corresponds to. In some rare cases there may be duplicates,
+// in which case we might render an HTML choice for the user.
+//
+// To re-generate this list, run:
+//
+// $ cd $GOROOT
+// $ git log 7d7c6a9..94151eb | grep "^ https://golang.org/cl/" | perl -ne 's,^\s+https://golang.org/cl/(\d+).*$,$1,; chomp; print "$_: true,\n" if $_ < 300000' | sort -n | uniq
+//
+// Note that we ignore the x/* repos because we didn't start using
+// "subrepos" until the Rietveld CLs numbers were already 4,000,000+,
+// well above bigEnoughAssumeRietveld.
+var lowRietveldCL = map[int]bool{
+ 152046: true,
+ 152048: true,
+ 152049: true,
+ 152050: true,
+ 152051: true,
+ 152052: true,
+ 152055: true,
+ 152056: true,
+ 152057: true,
+ 152072: true,
+ 152073: true,
+ 152075: true,
+ 152076: true,
+ 152077: true,
+ 152078: true,
+ 152079: true,
+ 152080: true,
+ 152082: true,
+ 152084: true,
+ 152085: true,
+ 152086: true,
+ 152088: true,
+ 152089: true,
+ 152091: true,
+ 152098: true,
+ 152101: true,
+ 152102: true,
+ 152105: true,
+ 152106: true,
+ 152107: true,
+ 152108: true,
+ 152109: true,
+ 152110: true,
+ 152114: true,
+ 152117: true,
+ 152118: true,
+ 152120: true,
+ 152123: true,
+ 152124: true,
+ 152128: true,
+ 152130: true,
+ 152131: true,
+ 152138: true,
+ 152141: true,
+ 152142: true,
+ 153048: true,
+ 153049: true,
+ 153050: true,
+ 153051: true,
+ 153055: true,
+ 153056: true,
+ 153057: true,
+ 154043: true,
+ 154044: true,
+ 154045: true,
+ 154049: true,
+ 154055: true,
+ 154057: true,
+ 154058: true,
+ 154059: true,
+ 154061: true,
+ 154064: true,
+ 154065: true,
+ 154067: true,
+ 154068: true,
+ 154069: true,
+ 154071: true,
+ 154072: true,
+ 154073: true,
+ 154076: true,
+ 154079: true,
+ 154096: true,
+ 154097: true,
+ 154099: true,
+ 154100: true,
+ 154101: true,
+ 154102: true,
+ 154108: true,
+ 154118: true,
+ 154121: true,
+ 154122: true,
+ 154123: true,
+ 154125: true,
+ 154126: true,
+ 154128: true,
+ 154136: true,
+ 154138: true,
+ 154139: true,
+ 154140: true,
+ 154141: true,
+ 154142: true,
+ 154143: true,
+ 154144: true,
+ 154145: true,
+ 154146: true,
+ 154152: true,
+ 154153: true,
+ 154156: true,
+ 154159: true,
+ 154161: true,
+ 154166: true,
+ 154167: true,
+ 154169: true,
+ 154171: true,
+ 154172: true,
+ 154173: true,
+ 154174: true,
+ 154175: true,
+ 154176: true,
+ 154177: true,
+ 154178: true,
+ 154179: true,
+ 154180: true,
+ 155041: true,
+ 155042: true,
+ 155045: true,
+ 155047: true,
+ 155048: true,
+ 155049: true,
+ 155050: true,
+ 155054: true,
+ 155055: true,
+ 155056: true,
+ 155057: true,
+ 155058: true,
+ 155059: true,
+ 155061: true,
+ 155062: true,
+ 155063: true,
+ 155065: true,
+ 155067: true,
+ 155069: true,
+ 155072: true,
+ 155074: true,
+ 155075: true,
+ 155077: true,
+ 155078: true,
+ 155079: true,
+ 156041: true,
+ 156044: true,
+ 156045: true,
+ 156046: true,
+ 156047: true,
+ 156051: true,
+ 156052: true,
+ 156054: true,
+ 156055: true,
+ 156056: true,
+ 156058: true,
+ 156059: true,
+ 156060: true,
+ 156061: true,
+ 156062: true,
+ 156063: true,
+ 156066: true,
+ 156067: true,
+ 156070: true,
+ 156071: true,
+ 156073: true,
+ 156075: true,
+ 156077: true,
+ 156079: true,
+ 156080: true,
+ 156081: true,
+ 156083: true,
+ 156084: true,
+ 156085: true,
+ 156086: true,
+ 156089: true,
+ 156091: true,
+ 156092: true,
+ 156093: true,
+ 156094: true,
+ 156097: true,
+ 156099: true,
+ 156100: true,
+ 156102: true,
+ 156103: true,
+ 156104: true,
+ 156106: true,
+ 156107: true,
+ 156108: true,
+ 156109: true,
+ 156110: true,
+ 156113: true,
+ 156115: true,
+ 156116: true,
+ 157041: true,
+ 157042: true,
+ 157043: true,
+ 157044: true,
+ 157046: true,
+ 157053: true,
+ 157055: true,
+ 157056: true,
+ 157058: true,
+ 157060: true,
+ 157061: true,
+ 157062: true,
+ 157065: true,
+ 157066: true,
+ 157067: true,
+ 157068: true,
+ 157069: true,
+ 157071: true,
+ 157072: true,
+ 157073: true,
+ 157074: true,
+ 157075: true,
+ 157076: true,
+ 157077: true,
+ 157082: true,
+ 157084: true,
+ 157085: true,
+ 157087: true,
+ 157088: true,
+ 157091: true,
+ 157095: true,
+ 157096: true,
+ 157099: true,
+ 157100: true,
+ 157101: true,
+ 157102: true,
+ 157103: true,
+ 157104: true,
+ 157106: true,
+ 157110: true,
+ 157111: true,
+ 157112: true,
+ 157114: true,
+ 157116: true,
+ 157119: true,
+ 157140: true,
+ 157142: true,
+ 157143: true,
+ 157144: true,
+ 157146: true,
+ 157147: true,
+ 157149: true,
+ 157151: true,
+ 157152: true,
+ 157153: true,
+ 157154: true,
+ 157156: true,
+ 157157: true,
+ 157158: true,
+ 157159: true,
+ 157160: true,
+ 157162: true,
+ 157166: true,
+ 157167: true,
+ 157168: true,
+ 157170: true,
+ 158041: true,
+ 159044: true,
+ 159049: true,
+ 159050: true,
+ 159051: true,
+ 160043: true,
+ 160044: true,
+ 160045: true,
+ 160046: true,
+ 160047: true,
+ 160054: true,
+ 160056: true,
+ 160057: true,
+ 160059: true,
+ 160060: true,
+ 160061: true,
+ 160064: true,
+ 160065: true,
+ 160069: true,
+ 160070: true,
+ 161049: true,
+ 161050: true,
+ 161056: true,
+ 161058: true,
+ 161060: true,
+ 161061: true,
+ 161069: true,
+ 161070: true,
+ 161073: true,
+ 161075: true,
+ 162041: true,
+ 162044: true,
+ 162046: true,
+ 162053: true,
+ 162054: true,
+ 162055: true,
+ 162056: true,
+ 162057: true,
+ 162058: true,
+ 162059: true,
+ 162061: true,
+ 162062: true,
+ 163042: true,
+ 163044: true,
+ 163049: true,
+ 163050: true,
+ 163051: true,
+ 163052: true,
+ 163053: true,
+ 163055: true,
+ 163058: true,
+ 163061: true,
+ 163062: true,
+ 163064: true,
+ 163067: true,
+ 163068: true,
+ 163069: true,
+ 163070: true,
+ 163071: true,
+ 163072: true,
+ 163082: true,
+ 163083: true,
+ 163085: true,
+ 163088: true,
+ 163091: true,
+ 163092: true,
+ 163097: true,
+ 163098: true,
+ 164043: true,
+ 164047: true,
+ 164049: true,
+ 164052: true,
+ 164053: true,
+ 164056: true,
+ 164059: true,
+ 164060: true,
+ 164062: true,
+ 164068: true,
+ 164069: true,
+ 164071: true,
+ 164073: true,
+ 164074: true,
+ 164075: true,
+ 164078: true,
+ 164079: true,
+ 164081: true,
+ 164082: true,
+ 164083: true,
+ 164085: true,
+ 164086: true,
+ 164088: true,
+ 164090: true,
+ 164091: true,
+ 164092: true,
+ 164093: true,
+ 164094: true,
+ 164095: true,
+ 165042: true,
+ 165044: true,
+ 165045: true,
+ 165048: true,
+ 165049: true,
+ 165050: true,
+ 165051: true,
+ 165055: true,
+ 165057: true,
+ 165058: true,
+ 165059: true,
+ 165061: true,
+ 165062: true,
+ 165063: true,
+ 165064: true,
+ 165065: true,
+ 165068: true,
+ 165070: true,
+ 165076: true,
+ 165078: true,
+ 165080: true,
+ 165083: true,
+ 165086: true,
+ 165097: true,
+ 165100: true,
+ 165101: true,
+ 166041: true,
+ 166043: true,
+ 166044: true,
+ 166047: true,
+ 166049: true,
+ 166052: true,
+ 166053: true,
+ 166055: true,
+ 166058: true,
+ 166059: true,
+ 166060: true,
+ 166064: true,
+ 166066: true,
+ 166067: true,
+ 166068: true,
+ 166070: true,
+ 166071: true,
+ 166072: true,
+ 166073: true,
+ 166074: true,
+ 166076: true,
+ 166077: true,
+ 166078: true,
+ 166080: true,
+ 167043: true,
+ 167044: true,
+ 167047: true,
+ 167050: true,
+ 167055: true,
+ 167057: true,
+ 167058: true,
+ 168041: true,
+ 168045: true,
+ 170042: true,
+ 170043: true,
+ 170044: true,
+ 170046: true,
+ 170047: true,
+ 170048: true,
+ 170049: true,
+ 171044: true,
+ 171046: true,
+ 171047: true,
+ 171048: true,
+ 171051: true,
+ 172041: true,
+ 172042: true,
+ 172043: true,
+ 172045: true,
+ 172049: true,
+ 173041: true,
+ 173044: true,
+ 173045: true,
+ 174042: true,
+ 174047: true,
+ 174048: true,
+ 174050: true,
+ 174051: true,
+ 174052: true,
+ 174053: true,
+ 174063: true,
+ 174064: true,
+ 174072: true,
+ 174076: true,
+ 174077: true,
+ 174078: true,
+ 174082: true,
+ 174083: true,
+ 174087: true,
+ 175045: true,
+ 175046: true,
+ 175047: true,
+ 175048: true,
+ 176056: true,
+ 176057: true,
+ 176058: true,
+ 176061: true,
+ 176062: true,
+ 176063: true,
+ 176064: true,
+ 176066: true,
+ 176067: true,
+ 176070: true,
+ 176071: true,
+ 176076: true,
+ 178043: true,
+ 178044: true,
+ 178046: true,
+ 178048: true,
+ 179047: true,
+ 179055: true,
+ 179061: true,
+ 179062: true,
+ 179063: true,
+ 179067: true,
+ 179069: true,
+ 179070: true,
+ 179072: true,
+ 179079: true,
+ 179088: true,
+ 179095: true,
+ 179096: true,
+ 179097: true,
+ 179099: true,
+ 179105: true,
+ 179106: true,
+ 179108: true,
+ 179118: true,
+ 179120: true,
+ 179125: true,
+ 179126: true,
+ 179128: true,
+ 179129: true,
+ 179130: true,
+ 180044: true,
+ 180045: true,
+ 180046: true,
+ 180047: true,
+ 180048: true,
+ 180049: true,
+ 180050: true,
+ 180052: true,
+ 180053: true,
+ 180054: true,
+ 180055: true,
+ 180056: true,
+ 180057: true,
+ 180059: true,
+ 180061: true,
+ 180064: true,
+ 180065: true,
+ 180068: true,
+ 180069: true,
+ 180070: true,
+ 180074: true,
+ 180075: true,
+ 180081: true,
+ 180082: true,
+ 180085: true,
+ 180092: true,
+ 180099: true,
+ 180105: true,
+ 180108: true,
+ 180112: true,
+ 180118: true,
+ 181041: true,
+ 181043: true,
+ 181044: true,
+ 181045: true,
+ 181049: true,
+ 181050: true,
+ 181055: true,
+ 181057: true,
+ 181058: true,
+ 181059: true,
+ 181063: true,
+ 181071: true,
+ 181073: true,
+ 181075: true,
+ 181077: true,
+ 181080: true,
+ 181083: true,
+ 181084: true,
+ 181085: true,
+ 181086: true,
+ 181087: true,
+ 181089: true,
+ 181097: true,
+ 181099: true,
+ 181102: true,
+ 181111: true,
+ 181130: true,
+ 181135: true,
+ 181137: true,
+ 181138: true,
+ 181139: true,
+ 181151: true,
+ 181152: true,
+ 181153: true,
+ 181155: true,
+ 181156: true,
+ 181157: true,
+ 181158: true,
+ 181160: true,
+ 181161: true,
+ 181163: true,
+ 181164: true,
+ 181171: true,
+ 181179: true,
+ 181183: true,
+ 181184: true,
+ 181186: true,
+ 182041: true,
+ 182043: true,
+ 182044: true,
+ 183042: true,
+ 183043: true,
+ 183044: true,
+ 183047: true,
+ 183049: true,
+ 183065: true,
+ 183066: true,
+ 183073: true,
+ 183074: true,
+ 183075: true,
+ 183083: true,
+ 183084: true,
+ 183087: true,
+ 183088: true,
+ 183090: true,
+ 183095: true,
+ 183104: true,
+ 183107: true,
+ 183109: true,
+ 183111: true,
+ 183112: true,
+ 183113: true,
+ 183116: true,
+ 183123: true,
+ 183124: true,
+ 183125: true,
+ 183126: true,
+ 183132: true,
+ 183133: true,
+ 183135: true,
+ 183136: true,
+ 183137: true,
+ 183138: true,
+ 183139: true,
+ 183140: true,
+ 183141: true,
+ 183142: true,
+ 183153: true,
+ 183155: true,
+ 183156: true,
+ 183157: true,
+ 183160: true,
+ 184043: true,
+ 184055: true,
+ 184058: true,
+ 184059: true,
+ 184068: true,
+ 184069: true,
+ 184079: true,
+ 184080: true,
+ 184081: true,
+ 185043: true,
+ 185045: true,
+ 186042: true,
+ 186043: true,
+ 186073: true,
+ 186076: true,
+ 186077: true,
+ 186078: true,
+ 186079: true,
+ 186081: true,
+ 186095: true,
+ 186108: true,
+ 186113: true,
+ 186115: true,
+ 186116: true,
+ 186118: true,
+ 186119: true,
+ 186132: true,
+ 186137: true,
+ 186138: true,
+ 186139: true,
+ 186143: true,
+ 186144: true,
+ 186145: true,
+ 186146: true,
+ 186147: true,
+ 186148: true,
+ 186159: true,
+ 186160: true,
+ 186161: true,
+ 186165: true,
+ 186169: true,
+ 186173: true,
+ 186180: true,
+ 186210: true,
+ 186211: true,
+ 186212: true,
+ 186213: true,
+ 186214: true,
+ 186215: true,
+ 186216: true,
+ 186228: true,
+ 186229: true,
+ 186230: true,
+ 186232: true,
+ 186234: true,
+ 186255: true,
+ 186263: true,
+ 186276: true,
+ 186279: true,
+ 186282: true,
+ 186283: true,
+ 188043: true,
+ 189042: true,
+ 189057: true,
+ 189059: true,
+ 189062: true,
+ 189078: true,
+ 189080: true,
+ 189083: true,
+ 189088: true,
+ 189093: true,
+ 189095: true,
+ 189096: true,
+ 189098: true,
+ 189100: true,
+ 190041: true,
+ 190042: true,
+ 190043: true,
+ 190044: true,
+ 190059: true,
+ 190062: true,
+ 190068: true,
+ 190074: true,
+ 190076: true,
+ 190077: true,
+ 190079: true,
+ 190085: true,
+ 190088: true,
+ 190103: true,
+ 190104: true,
+ 193055: true,
+ 193066: true,
+ 193067: true,
+ 193070: true,
+ 193075: true,
+ 193079: true,
+ 193080: true,
+ 193081: true,
+ 193091: true,
+ 193092: true,
+ 193095: true,
+ 193101: true,
+ 193104: true,
+ 194043: true,
+ 194045: true,
+ 194046: true,
+ 194050: true,
+ 194051: true,
+ 194052: true,
+ 194053: true,
+ 194064: true,
+ 194066: true,
+ 194069: true,
+ 194071: true,
+ 194072: true,
+ 194073: true,
+ 194074: true,
+ 194076: true,
+ 194077: true,
+ 194078: true,
+ 194082: true,
+ 194084: true,
+ 194085: true,
+ 194090: true,
+ 194091: true,
+ 194092: true,
+ 194094: true,
+ 194097: true,
+ 194098: true,
+ 194099: true,
+ 194100: true,
+ 194114: true,
+ 194116: true,
+ 194118: true,
+ 194119: true,
+ 194120: true,
+ 194121: true,
+ 194122: true,
+ 194126: true,
+ 194129: true,
+ 194131: true,
+ 194132: true,
+ 194133: true,
+ 194134: true,
+ 194146: true,
+ 194151: true,
+ 194156: true,
+ 194157: true,
+ 194159: true,
+ 194161: true,
+ 194165: true,
+ 195041: true,
+ 195044: true,
+ 195050: true,
+ 195051: true,
+ 195052: true,
+ 195068: true,
+ 195075: true,
+ 195076: true,
+ 195079: true,
+ 195080: true,
+ 195081: true,
+ 196042: true,
+ 196044: true,
+ 196050: true,
+ 196051: true,
+ 196055: true,
+ 196056: true,
+ 196061: true,
+ 196063: true,
+ 196065: true,
+ 196070: true,
+ 196071: true,
+ 196075: true,
+ 196077: true,
+ 196079: true,
+ 196087: true,
+ 196088: true,
+ 196090: true,
+ 196091: true,
+ 197041: true,
+ 197042: true,
+ 197043: true,
+ 197044: true,
+ 198044: true,
+ 198045: true,
+ 198046: true,
+ 198048: true,
+ 198049: true,
+ 198050: true,
+ 198053: true,
+ 198057: true,
+ 198058: true,
+ 198066: true,
+ 198071: true,
+ 198074: true,
+ 198081: true,
+ 198084: true,
+ 198085: true,
+ 198102: true,
+ 199042: true,
+ 199044: true,
+ 199045: true,
+ 199046: true,
+ 199047: true,
+ 199052: true,
+ 199054: true,
+ 199057: true,
+ 199066: true,
+ 199070: true,
+ 199082: true,
+ 199091: true,
+ 199094: true,
+ 199096: true,
+ 201041: true,
+ 201042: true,
+ 201043: true,
+ 201047: true,
+ 201048: true,
+ 201049: true,
+ 201058: true,
+ 201061: true,
+ 201064: true,
+ 201065: true,
+ 201068: true,
+ 202042: true,
+ 202043: true,
+ 202044: true,
+ 202051: true,
+ 202054: true,
+ 202055: true,
+ 203043: true,
+ 203050: true,
+ 203051: true,
+ 203053: true,
+ 203060: true,
+ 203062: true,
+ 204042: true,
+ 204044: true,
+ 204048: true,
+ 204052: true,
+ 204053: true,
+ 204061: true,
+ 204062: true,
+ 204064: true,
+ 204065: true,
+ 204067: true,
+ 204068: true,
+ 204069: true,
+ 205042: true,
+ 205044: true,
+ 206043: true,
+ 206044: true,
+ 206047: true,
+ 206050: true,
+ 206051: true,
+ 206052: true,
+ 206053: true,
+ 206054: true,
+ 206055: true,
+ 206058: true,
+ 206059: true,
+ 206060: true,
+ 206067: true,
+ 206069: true,
+ 206077: true,
+ 206078: true,
+ 206079: true,
+ 206084: true,
+ 206089: true,
+ 206101: true,
+ 206107: true,
+ 206109: true,
+ 207043: true,
+ 207044: true,
+ 207049: true,
+ 207050: true,
+ 207051: true,
+ 207052: true,
+ 207053: true,
+ 207054: true,
+ 207055: true,
+ 207061: true,
+ 207062: true,
+ 207069: true,
+ 207071: true,
+ 207085: true,
+ 207086: true,
+ 207087: true,
+ 207088: true,
+ 207095: true,
+ 207096: true,
+ 207102: true,
+ 207103: true,
+ 207106: true,
+ 207108: true,
+ 207110: true,
+ 207111: true,
+ 207112: true,
+ 209041: true,
+ 209042: true,
+ 209043: true,
+ 209044: true,
+ 210042: true,
+ 210043: true,
+ 210044: true,
+ 210047: true,
+ 211041: true,
+ 212041: true,
+ 212045: true,
+ 212046: true,
+ 212047: true,
+ 213041: true,
+ 213042: true,
+ 214042: true,
+ 214046: true,
+ 214049: true,
+ 214050: true,
+ 215042: true,
+ 215048: true,
+ 215050: true,
+ 216043: true,
+ 216046: true,
+ 216047: true,
+ 216052: true,
+ 216053: true,
+ 216054: true,
+ 216059: true,
+ 216068: true,
+ 217041: true,
+ 217044: true,
+ 217047: true,
+ 217048: true,
+ 217049: true,
+ 217056: true,
+ 217058: true,
+ 217059: true,
+ 217060: true,
+ 217061: true,
+ 217064: true,
+ 217066: true,
+ 217069: true,
+ 217071: true,
+ 217085: true,
+ 217086: true,
+ 217088: true,
+ 217093: true,
+ 217094: true,
+ 217108: true,
+ 217109: true,
+ 217111: true,
+ 217115: true,
+ 217116: true,
+ 218042: true,
+ 218044: true,
+ 218046: true,
+ 218050: true,
+ 218060: true,
+ 218061: true,
+ 218063: true,
+ 218064: true,
+ 218065: true,
+ 218070: true,
+ 218071: true,
+ 218072: true,
+ 218074: true,
+ 218076: true,
+ 222041: true,
+ 223041: true,
+ 223043: true,
+ 223044: true,
+ 223050: true,
+ 223052: true,
+ 223054: true,
+ 223058: true,
+ 223059: true,
+ 223061: true,
+ 223068: true,
+ 223069: true,
+ 223070: true,
+ 223071: true,
+ 223073: true,
+ 223075: true,
+ 223076: true,
+ 223083: true,
+ 223087: true,
+ 223094: true,
+ 223096: true,
+ 223101: true,
+ 223106: true,
+ 223108: true,
+ 224041: true,
+ 224042: true,
+ 224043: true,
+ 224045: true,
+ 224051: true,
+ 224053: true,
+ 224057: true,
+ 224060: true,
+ 224061: true,
+ 224062: true,
+ 224063: true,
+ 224068: true,
+ 224069: true,
+ 224081: true,
+ 224084: true,
+ 224087: true,
+ 224090: true,
+ 224096: true,
+ 224105: true,
+ 225042: true,
+ 227041: true,
+ 229045: true,
+ 229046: true,
+ 229048: true,
+ 229049: true,
+ 229050: true,
+ 231042: true,
+ 236041: true,
+ 237041: true,
+ 238041: true,
+ 238042: true,
+ 240041: true,
+ 240042: true,
+ 240043: true,
+ 241041: true,
+ 243041: true,
+ 244041: true,
+ 245041: true,
+ 247041: true,
+ 250041: true,
+ 252041: true,
+ 253041: true,
+ 253045: true,
+ 254043: true,
+ 255042: true,
+ 255043: true,
+ 257041: true,
+ 257042: true,
+ 258041: true,
+ 261041: true,
+ 264041: true,
+ 294042: true,
+ 296042: true,
+}
diff --git a/internal/short/short.go b/internal/short/short.go
new file mode 100644
index 0000000..3a399ab
--- /dev/null
+++ b/internal/short/short.go
@@ -0,0 +1,186 @@
+// Copyright 2015 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.
+
+// +build golangorg
+
+// Package short implements a simple URL shortener, serving an administrative
+// interface at /s and shortened urls from /s/key.
+// It is designed to run only on the instance of godoc that serves golang.org.
+package short
+
+// TODO(adg): collect statistics on URL visits
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "html/template"
+ "io"
+ "log"
+ "net/http"
+ "net/url"
+ "regexp"
+
+ "cloud.google.com/go/datastore"
+ "golang.org/x/tools/internal/memcache"
+ "google.golang.org/appengine/user"
+)
+
+const (
+ prefix = "/s"
+ kind = "Link"
+ baseURL = "https://golang.org" + prefix
+)
+
+// Link represents a short link.
+type Link struct {
+ Key, Target string
+}
+
+var validKey = regexp.MustCompile(`^[a-zA-Z0-9-_.]+$`)
+
+type server struct {
+ datastore *datastore.Client
+ memcache *memcache.CodecClient
+}
+
+func RegisterHandlers(mux *http.ServeMux, dc *datastore.Client, mc *memcache.Client) {
+ s := server{dc, mc.WithCodec(memcache.JSON)}
+ mux.HandleFunc(prefix+"/", s.linkHandler)
+
+ // TODO(cbro): move storage of the links to a text file in Gerrit.
+ // Disable the admin handler until that happens, since GAE Flex doesn't support
+ // the "google.golang.org/appengine/user" package.
+ // See golang.org/issue/27205#issuecomment-418673218
+ // mux.HandleFunc(prefix, adminHandler)
+ mux.HandleFunc(prefix, func(w http.ResponseWriter, r *http.Request) {
+ w.WriteHeader(http.StatusForbidden)
+ io.WriteString(w, "Link creation temporarily unavailable. See golang.org/issue/27205.")
+ })
+}
+
+// linkHandler services requests to short URLs.
+// http://golang.org/s/key
+// It consults memcache and datastore for the Link for key.
+// It then sends a redirects or an error message.
+func (h server) linkHandler(w http.ResponseWriter, r *http.Request) {
+ ctx := r.Context()
+
+ key := r.URL.Path[len(prefix)+1:]
+ if !validKey.MatchString(key) {
+ http.Error(w, "not found", http.StatusNotFound)
+ return
+ }
+
+ var link Link
+ if err := h.memcache.Get(ctx, cacheKey(key), &link); err != nil {
+ k := datastore.NameKey(kind, key, nil)
+ err = h.datastore.Get(ctx, k, &link)
+ switch err {
+ case datastore.ErrNoSuchEntity:
+ http.Error(w, "not found", http.StatusNotFound)
+ return
+ default: // != nil
+ log.Printf("ERROR %q: %v", key, err)
+ http.Error(w, "internal server error", http.StatusInternalServerError)
+ return
+ case nil:
+ item := &memcache.Item{
+ Key: cacheKey(key),
+ Object: &link,
+ }
+ if err := h.memcache.Set(ctx, item); err != nil {
+ log.Printf("WARNING %q: %v", key, err)
+ }
+ }
+ }
+
+ http.Redirect(w, r, link.Target, http.StatusFound)
+}
+
+var adminTemplate = template.Must(template.New("admin").Parse(templateHTML))
+
+// adminHandler serves an administrative interface.
+func (h server) adminHandler(w http.ResponseWriter, r *http.Request) {
+ ctx := r.Context()
+
+ if !user.IsAdmin(ctx) {
+ http.Error(w, "forbidden", http.StatusForbidden)
+ return
+ }
+
+ var newLink *Link
+ var doErr error
+ if r.Method == "POST" {
+ key := r.FormValue("key")
+ switch r.FormValue("do") {
+ case "Add":
+ newLink = &Link{key, r.FormValue("target")}
+ doErr = h.putLink(ctx, newLink)
+ case "Delete":
+ k := datastore.NameKey(kind, key, nil)
+ doErr = h.datastore.Delete(ctx, k)
+ default:
+ http.Error(w, "unknown action", http.StatusBadRequest)
+ }
+ err := h.memcache.Delete(ctx, cacheKey(key))
+ if err != nil && err != memcache.ErrCacheMiss {
+ log.Printf("WARNING %q: %v", key, err)
+ }
+ }
+
+ var links []*Link
+ q := datastore.NewQuery(kind).Order("Key")
+ if _, err := h.datastore.GetAll(ctx, q, &links); err != nil {
+ http.Error(w, err.Error(), http.StatusInternalServerError)
+ log.Printf("ERROR %v", err)
+ return
+ }
+
+ // Put the new link in the list if it's not there already.
+ // (Eventual consistency means that it might not show up
+ // immediately, which might be confusing for the user.)
+ if newLink != nil && doErr == nil {
+ found := false
+ for i := range links {
+ if links[i].Key == newLink.Key {
+ found = true
+ break
+ }
+ }
+ if !found {
+ links = append([]*Link{newLink}, links...)
+ }
+ newLink = nil
+ }
+
+ var data = struct {
+ BaseURL string
+ Prefix string
+ Links []*Link
+ New *Link
+ Error error
+ }{baseURL, prefix, links, newLink, doErr}
+ if err := adminTemplate.Execute(w, &data); err != nil {
+ log.Printf("ERROR adminTemplate: %v", err)
+ }
+}
+
+// putLink validates the provided link and puts it into the datastore.
+func (h server) putLink(ctx context.Context, link *Link) error {
+ if !validKey.MatchString(link.Key) {
+ return errors.New("invalid key; must match " + validKey.String())
+ }
+ if _, err := url.Parse(link.Target); err != nil {
+ return fmt.Errorf("bad target: %v", err)
+ }
+ k := datastore.NameKey(kind, link.Key, nil)
+ _, err := h.datastore.Put(ctx, k, link)
+ return err
+}
+
+// cacheKey returns a short URL key as a memcache key.
+func cacheKey(key string) string {
+ return "link-" + key
+}
diff --git a/internal/short/tmpl.go b/internal/short/tmpl.go
new file mode 100644
index 0000000..66f5401
--- /dev/null
+++ b/internal/short/tmpl.go
@@ -0,0 +1,119 @@
+// Copyright 2015 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.
+
+package short
+
+const templateHTML = `
+<!doctype HTML>
+<html>
+<head>
+<title>golang.org URL shortener</title>
+<style>
+body {
+ background: white;
+}
+input {
+ border: 1px solid #ccc;
+}
+input[type=text] {
+ width: 400px;
+}
+input, td, th {
+ color: #333;
+ font-family: Georgia, Times New Roman, serif;
+}
+input, td {
+ font-size: 14pt;
+}
+th {
+ font-size: 16pt;
+ text-align: left;
+ padding-top: 10px;
+}
+.autoselect {
+ border: none;
+}
+.error {
+ color: #900;
+}
+table {
+ margin-left: auto;
+ margin-right: auto;
+}
+</style>
+</head>
+<body>
+
+<table>
+
+{{with .Error}}
+<tr>
+ <th colspan="3">Error</th>
+</tr>
+<tr>
+ <td class="error" colspan="3">{{.}}</td>
+</tr>
+{{end}}
+
+<tr>
+ <th>Key</th>
+ <th>Target</th>
+ <th></th>
+</tr>
+
+<form method="POST" action="{{.Prefix}}">
+<tr>
+ <td><input type="text" name="key"{{with .New}} value="{{.Key}}"{{end}}></td>
+ <td><input type="text" name="target"{{with .New}} value="{{.Target}}"{{end}}></td>
+ <td><input type="submit" name="do" value="Add">
+</tr>
+</form>
+
+{{with .Links}}
+<tr>
+ <th>Short Link</th>
+ <th> </th>
+ <th> </th>
+</tr>
+{{range .}}
+<tr>
+ <td><input class="autoselect" type="text" orig="{{$.BaseURL}}/{{.Key}}" value="{{$.BaseURL}}/{{.Key}}"></td>
+ <td><input class="autoselect" type="text" orig="{{.Target}}" value="{{.Target}}"></td>
+ <td>
+ <form method="POST" action="{{$.Prefix}}">
+ <input type="hidden" name="key" value="{{.Key}}">
+ <input type="submit" name="do" value="Delete" class="delete">
+ </form>
+ </td>
+</tr>
+{{end}}
+{{end}}
+
+</table>
+
+</body>
+<script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/1.8.2/jquery.min.js"></script>
+<script type="text/javascript">window.jQuery || document.write(unescape("%3Cscript src='/doc/jquery.js' type='text/javascript'%3E%3C/script%3E"));</script>
+<script>
+$(document).ready(function() {
+ $('.autoselect').each(function() {
+ $(this).click(function() {
+ $(this).select();
+ });
+ $(this).change(function() {
+ $(this).val($(this).attr('orig'));
+ });
+ });
+ $('.delete').click(function(e) {
+ var link = $(this).closest('tr').find('input').first().val();
+ var ok = confirm('Delete this link?\n' + link);
+ if (!ok) {
+ e.preventDefault();
+ return false;
+ }
+ });
+});
+</script>
+</html>
+`
