blob: ef811e20346f9928941917593e3faf413e536efa [file] [log] [blame]
// Package devserver provides code shared between Bazel and Blaze.
package devserver
import (
"bytes"
"fmt"
"net"
"net/http"
"net/url"
"os"
"path/filepath"
"strings"
"time"
)
func shouldAllowCors(request *http.Request) bool {
hostname, err := os.Hostname()
if err != nil {
return false
}
referer, err := url.Parse(request.Header.Get("Origin"))
if err != nil {
return false
}
host, _, err := net.SplitHostPort(referer.Host)
// SplitHostPort fails when the parameter doesn't have a port.
if err != nil {
host = referer.Host
}
return host == hostname || host == "localhost"
}
func customNotFoundMiddleware(notFound http.HandlerFunc, passThrough http.HandlerFunc) http.HandlerFunc {
return func(writer http.ResponseWriter, request *http.Request) {
passThrough(
&customNotFoundResponseWriter{ResponseWriter: writer, request: request, notFound: notFound},
request,
)
}
}
type customNotFoundResponseWriter struct {
http.ResponseWriter
request *http.Request
notFound http.HandlerFunc
has404 bool
hasWrite bool
}
// Write implements http.ResponseWriter.Write.
func (w *customNotFoundResponseWriter) Write(b []byte) (int, error) {
w.hasWrite = true
if w.has404 {
// We have already written the not found response, so drop this one.
return len(b), nil
}
return w.ResponseWriter.Write(b)
}
// WriteHeader implements http.ResponseWriter.WriteHeader.
func (w *customNotFoundResponseWriter) WriteHeader(code int) {
if code != http.StatusNotFound || w.hasWrite {
// We only intercept not found statuses. We also don't intercept statuses written after the
// first write as these are an error and should be handled by the default ResponseWriter.
w.ResponseWriter.WriteHeader(code)
return
}
// WriteHeader writes out the entire header (including content type) and only the first call
// will succeed. Therefore, if we want the correct content type set, we must set it here.
w.Header().Del("Content-Type")
w.Header().Add("Content-Type", "text/html; charset=utf-8")
w.ResponseWriter.WriteHeader(code)
w.has404 = true
// We have already written the header, so drop any calls to WriteHeader made by the not found
// handler. These additional calls are expected, and if passed through, would cause the base
// ResponseWriter to unnecessarily spam the error log.
w.notFound(&headerSuppressorResponseWriter{w.ResponseWriter}, w.request)
w.hasWrite = true
}
type headerSuppressorResponseWriter struct {
http.ResponseWriter
}
// WriteHeader implements http.ResponseWriter.WriteHeader.
func (w *headerSuppressorResponseWriter) WriteHeader(code int) {}
// CreateFileHandler returns an http handler to locate files on disk
func CreateFileHandler(servingPath, manifest string, pkgs []string, base string) http.HandlerFunc {
pkgPaths := chainedDir{}
for _, pkg := range pkgs {
path := filepath.Join(base, pkg)
if _, err := os.Stat(path); err != nil {
fmt.Fprintf(os.Stderr, "Cannot read server root package at %s: %v\n", path, err)
os.Exit(1)
}
pkgPaths = append(pkgPaths, http.Dir(path))
}
pkgPaths = append(pkgPaths, http.Dir(base))
fileHandler := http.FileServer(pkgPaths).ServeHTTP
// defaultIndex is not cached, so that a user's edits will be reflected.
defaultIndex := filepath.Join(base, pkgs[0], "index.html")
defaultPage := []byte(fmt.Sprintf(`<!doctype html>
<html>
<head>
<title>ts_devserver (%s)</title>
</head>
<body>
<script src="%s"></script>
</body>
</html>
`, manifest, servingPath))
// indexHandler serves an index.html if present, or otherwise serves a minimal
// generated index.html with a script tag to include the bundled js source.
indexHandler := func(w http.ResponseWriter, r *http.Request) {
if _, err := os.Stat(defaultIndex); err == nil {
http.ServeFile(w, r, defaultIndex)
return
}
content := bytes.NewReader(defaultPage)
http.ServeContent(w, r, "index.html", time.Now(), content)
}
// Serve a custom index.html so as to override the default directory listing
// from http.FileServer when no index.html file present.
indexOnNotFoundHandler := func(writer http.ResponseWriter, request *http.Request) {
// The browser can't tell the difference between different source checkouts or different devserver
// instances, so it may mistakenly cache static files (including templates) using versions from
// old instances if they haven't been modified more recently. To prevent this, we force no-cache
// on all static files.
writer.Header().Add("Cache-Control", "no-cache, no-store, must-revalidate")
if shouldAllowCors(request) {
writer.Header().Add("Access-Control-Allow-Origin", request.Header.Get("Origin"))
writer.Header().Add("Access-Control-Allow-Credentials", "true")
}
writer.Header().Add("Pragma", "no-cache")
writer.Header().Add("Expires", "0")
// Add gzip headers if serving .gz files.
if strings.HasSuffix(request.URL.EscapedPath(), ".gz") {
writer.Header().Add("Content-Encoding", "gzip")
}
if request.URL.Path == "/" {
indexHandler(writer, request)
return
}
// When a file is not found, serve a 404 code but serve the index.html from above as its body.
// This allows applications to use html5 routing and reload the page at /some/sub/path, but still
// get their web app served.
writer = &customNotFoundResponseWriter{ResponseWriter: writer, request: request, notFound: indexHandler}
fileHandler(writer, request)
}
return indexOnNotFoundHandler
}
// chainedDir implements http.FileSystem by looking in the list of dirs one after each other.
type chainedDir []http.Dir
func (chain chainedDir) Open(name string) (http.File, error) {
for _, dir := range chain {
f, err := dir.Open(name)
if os.IsNotExist(err) {
continue
}
if err != nil {
return nil, err
}
// Do not return a directory, since FileServer will either:
// 1) serve the index.html file -or-
// 2) fall back to directory listings
// In place of (2), we prefer to fall back to our index.html. We accomplish
// this by lying to the FileServer that the directory doesn't exist.
stat, err := f.Stat()
if err != nil {
return nil, err
}
if stat.IsDir() {
// Make sure to close the previous file handle before moving to a different file.
f.Close()
indexName := filepath.Join(name, "index.html")
f, err := dir.Open(indexName)
if os.IsNotExist(err) {
continue
}
return f, err
}
return f, nil
}
return nil, os.ErrNotExist
}