capstan/proxy.go

package capstan

import (
	"bytes"
	"net/http"
	"strings"

	"github.com/go-chi/chi"
)

// The router proxy provides an intermediary between go-chi's handler and
// Capstan. This allows us to rebind or rename mount points by reinitializing
// the proxy's internal pointer to the new muxer.
type proxy struct {
	Hostname           string
	FullHost           string
	EnforceHost        bool
	EnforcePort        bool
	MaxRequestDuration int
	router             *Router
	mux                *chi.Mux
}

type proxyOptions struct {
	ListenAddr         string
	Hostname           string
	EnforceHost        bool
	EnforcePort        bool
	MaxRequestDuration int
}

// Returns a new proxy object with its router and mux unset.
//
// TODO: Replace or add feature for using a radix trie to determine the
// appropriate muxer for a given host name. Or, optionally, implement a
// different proxy type when multiple host names are configured/requested.
func newProxy(options *proxyOptions) *proxy {
	prx := &proxy{
		Hostname:           options.Hostname,
		EnforceHost:        options.EnforceHost,
		EnforcePort:        options.EnforcePort,
		MaxRequestDuration: options.MaxRequestDuration,
	}
	if options.EnforcePort && strings.IndexRune(options.Hostname, ':') == -1 {
		prx.FullHost = options.Hostname + options.ListenAddr[strings.IndexRune(options.ListenAddr, ':'):]
	}
	return prx
}

func (d *proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	// Host enforcement is not enabled.
	if !d.EnforceHost {
		d.mux.ServeHTTP(w, r)
		return
	}

	host := r.Host
	if !d.EnforcePort {
		if i := strings.IndexRune(host, ':'); i >= 0 {
			host = host[:i]
		}
	}

	if bytes.Compare([]byte(d.Hostname), []byte(host)) == 0 {
		d.mux.ServeHTTP(w, r)
		return
	}
	w.WriteHeader(404)
}

func (d *proxy) Switch(router chi.Router) {
	if mux, ok := router.(*chi.Mux); ok {
		d.mux = mux
	}
}

func (d *proxy) SwitchFunc() func(chi.Router) {
	return d.Switch
}

// Consider implementing a match function that uses radix tries similar to Chi
// (or port from Chi) such that subdomains could be matches using longest path
// matching or parameter matching ("{username}.example.com").
//
// vhostProxy will only be used and set automatically whenever a subserver is
// created, otherwise `proxy` is used instead.
type vhostProxy struct {
}

type proxyHandler interface {
	http.Handler
	Switch(chi.Router)
	SwitchFunc() func(chi.Router)
}