frontend

type Endpoint ¶

type Endpoint struct {
	// Basic backend configuration
	Name string // name of this backend (shown in __backends)
	Root string

	// Additional limits
	AllowHeader   map[string]bool
	StripHeader   map[string]bool
	BodySizeLimit int64

	// Transport for making requests.  HandleEndpoint will set
	// this to http.DefaultTransport if it is nil.
	http.RoundTripper
	// contains filtered or unexported fields
}

An Endpoint handles routing requests to a backend. The zero values of all unexported fields and of all map fields are safe to use. No unexported fields may be modified after the Endpoint begins to serve traffic.

The following are used to construct the backend request:

Method              - Unmodified
URL.Path            - Unmodified
URL.RawQuery        - Unmodified
Header              - Subject to whitelisting
Body                - Subject to size limits
ContentLength       - Subject to size limits

The request contains the following standard headers:

Host                - Set to the Host from the client
X-Forwarded-For     - Set to the source IP of the client
X-Forwarded-Proto   - Set to "http" or "https"

The request also contains the following nonstandard headers:

X-Gofr-Backend      - Set to the name of the bakend
X-Gofr-Backend-Root - Set to the backend's root path

The response will have the following additional headers:

X-Frame-Options     - Set to "sameorigin"
X-XSS-Protection    - Set to "1; mode=block"

The following headers are passed through by default:

Accept, Accept-Language, Content-Type
Authorization, Referer, User-Agent, Cookie
ETag, Etag, Cache-Control, If-Modified-Since
If-Unmodified-Since, If-Match, If-None-Match

A number of standard headers are stripped by default:

Accept-Charset, Accept-Encoding, Accept-Datetime
Content-MD5, Via, Connection

Any other headers will log a warning before being discarded.

func (b *Endpoint) ServeHTTP(w http.ResponseWriter, original *http.Request)

type Frontend ¶

type Frontend struct {
	// Frontend configuration
	DebugIPs []*net.IPNet // IP networks allowed to access the debug handlers

	// Requests are handled by this ServeMux
	ServeMux
	// contains filtered or unexported fields
}

A Frontend manages backends and other handlers for this frontend. The zero value of all unexported fields are already for use.

func New() *Frontend

func (f *Frontend) Debug(h http.Handler) http.HandlerFunc

func (f *Frontend) HandleDebug()

/__backends   - backend information (ListBackends)

func (f *Frontend) HandleEndpoint(b *Endpoint)

func (f *Frontend) ListBackends(w http.ResponseWriter, r *http.Request)

func (f *Frontend) ServeBackend(conn net.Conn, pingDelay time.Duration) error

func (f *Frontend) ServeBackends(l net.Listener, pingDelay time.Duration) error

type RegisterBackend ¶

type RegisterBackend struct {
	Name string // name of endpoint to join
	Host string // source IP assumed if empty
	Port int    // port number (required)
}

RegisterBackend is sent by backend upon connection. The backend is assumed to be served from the source port of the incoming connection.

type ServeMux ¶

type ServeMux interface {
	http.Handler
	Handle(pattern string, handler http.Handler)
	HandleFunc(pattern string, fn func(http.ResponseWriter, *http.Request))
}

A ServeMux allows handlers to be registered and can distribute requests to them.

This package has been designed in particular to work with the ServeMux provided by "net/http" and "kylelemons.net/go/gofr/trie".

type Status ¶

type Status struct {
	Nonce int64 // must match response
}

Status is sent from the frontend to the backend with a Nonce, after which the Status is sent back to the frontend with the same Nonce and an up-to-date Status.