internal/devserver/devserver.go - rules_typescript - Git at Google

 // 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
 }
	// 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
	}