mirror of
https://github.com/umputun/reproxy.git
synced 2025-11-29 22:08:14 +02:00
111 lines
2.9 KiB
Go
111 lines
2.9 KiB
Go
package rest
|
|
|
|
import (
|
|
"fmt"
|
|
"io"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
)
|
|
|
|
// FileServer returns http.FileServer handler to serve static files from a http.FileSystem,
|
|
// prevents directory listing.
|
|
// - public defines base path of the url, i.e. for http://example.com/static/* it should be /static
|
|
// - local for the local path to the root of the served directory
|
|
// - notFound is the reader for the custom 404 html, can be nil for default
|
|
func FileServer(public, local string, notFound io.Reader) (http.Handler, error) {
|
|
|
|
root, err := filepath.Abs(local)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("can't get absolute path for %s: %w", local, err)
|
|
}
|
|
if _, err = os.Stat(root); os.IsNotExist(err) {
|
|
return nil, fmt.Errorf("local path %s doesn't exist: %w", root, err)
|
|
}
|
|
|
|
fs := http.StripPrefix(public, http.FileServer(noDirListingFS{http.Dir(root), false}))
|
|
return custom404Handler(fs, notFound)
|
|
}
|
|
|
|
// FileServerSPA returns FileServer as above, but instead of no-found returns /local/index.html
|
|
func FileServerSPA(public, local string, notFound io.Reader) (http.Handler, error) {
|
|
|
|
root, err := filepath.Abs(local)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("can't get absolute path for %s: %w", local, err)
|
|
}
|
|
if _, err = os.Stat(root); os.IsNotExist(err) {
|
|
return nil, fmt.Errorf("local path %s doesn't exist: %w", root, err)
|
|
}
|
|
|
|
fs := http.StripPrefix(public, http.FileServer(noDirListingFS{http.Dir(root), true}))
|
|
return custom404Handler(fs, notFound)
|
|
}
|
|
|
|
type noDirListingFS struct {
|
|
fs http.FileSystem
|
|
spa bool
|
|
}
|
|
|
|
// Open file on FS, for directory enforce index.html and fail on a missing index
|
|
func (fs noDirListingFS) Open(name string) (http.File, error) {
|
|
|
|
f, err := fs.fs.Open(name)
|
|
if err != nil {
|
|
if fs.spa {
|
|
return fs.fs.Open("/index.html")
|
|
}
|
|
return nil, err
|
|
}
|
|
|
|
s, err := f.Stat()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if s.IsDir() {
|
|
index := strings.TrimSuffix(name, "/") + "/index.html"
|
|
if _, err := fs.fs.Open(index); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
return f, nil
|
|
}
|
|
|
|
// respWriter404 intercept Write to provide custom 404 response
|
|
type respWriter404 struct {
|
|
http.ResponseWriter
|
|
status int
|
|
msg []byte
|
|
}
|
|
|
|
func (w *respWriter404) WriteHeader(status int) {
|
|
w.status = status
|
|
w.ResponseWriter.WriteHeader(status)
|
|
}
|
|
|
|
func (w *respWriter404) Write(p []byte) (n int, err error) {
|
|
if w.status != http.StatusNotFound || w.msg == nil {
|
|
return w.ResponseWriter.Write(p)
|
|
}
|
|
_, err = w.ResponseWriter.Write(w.msg)
|
|
return len(p), err
|
|
}
|
|
|
|
func custom404Handler(next http.Handler, notFound io.Reader) (http.Handler, error) {
|
|
if notFound == nil {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { next.ServeHTTP(w, r) }), nil
|
|
}
|
|
|
|
body, err := ioutil.ReadAll(notFound)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
next.ServeHTTP(&respWriter404{ResponseWriter: w, msg: body}, r)
|
|
}), nil
|
|
}
|