Documentation
¶
Index ¶
- Constants
- func CacheBustedPath(url string) string
- func GetAssetUrl(location string) string
- func MakeLocalPath(p string) string
- func ParseAuthorizationHeader(auth string) (scheme, params string)
- func ParseJsonBody(w http.ResponseWriter, r *http.Request, maxBytes int64, dest any) error
- func ParseValueAndParams(in string) (value string, params map[string]string)
- func RegisterAppHandler(pattern string, handler http.Handler)
- func RegisterAssetDirectory(prefix string, fsys fs.FS)
- func RegisterContentType(extension string, contentType string)
- func RegisterDrawFunc(pattern string, f DrawFunc)
- func RegisterFileProcessor(extension string, processorFunc FileProcessorFunc)
- func RegisterStaticHandler(pattern string, handler http.Handler)
- func SetLocalPathMaker(f LocalPathMaker)
- func StripCacheBusterPath(fPath string) string
- func UseMuxer(mux Muxer, next http.Handler) http.Handler
- func ValidateHeader(header http.Header) bool
- type DrawFunc
- type FileProcessorFunc
- type FileSystemServer
- type LocalPathMaker
- type Muxer
Constants ¶
const BrotliSuffix = ".br"
const GZipSuffix = ".gz"
Variables ¶
This section is empty.
Functions ¶
func CacheBustedPath ¶
CacheBustedPath returns a path to an asset that was previously registered with the CacheBuster. The new path will contain a hash of the file that will change whenever the file changes, and cause the browser to reload the file. Since we are in control of serving these files, we will later remove the hash before serving it.
func GetAssetUrl ¶
GetAssetUrl returns the url that corresponds to the asset at the given path.
This will add the cache-buster path, and the proxy path if there is one.
func MakeLocalPath ¶
MakeLocalPath turns a path that points to a resource on this computer into a path that will reach that resource from a browser. It takes into account a variety of settings that may affect the path and that will depend on how the app is deployed. You can inject your own local path maker using SetLocalPathMaker
func ParseAuthorizationHeader ¶
ParseAuthorizationHeader will parse an authorization header into its scheme and params.
func ParseJsonBody ¶
ParseJsonBody will look for json in the request, parse it into the given dest, and handle errors.
The dest should be a pointer to a structure or some other value you want filled with the data. Errors will result in an appropriate error response written to the response writer, and an error response. If maxBytes is reached, it will close the connection and error.
func ParseValueAndParams ¶
ParseValueAndParams returns the value and param map for Content-Type and Content-Disposition header values.
func RegisterAppHandler ¶
RegisterAppHandler registers a handler for the given pattern.
Use this when registering a handler to a specific path. Use RegisterAppPrefixHandler if registering a handler for a whole subdirectory of a path.
The given handler is served near the end of the application handler stack, so you will have access to session management and any other middleware handlers in the application stack.
You may call this from an init() function.
func RegisterAssetDirectory ¶
RegisterAssetDirectory maps a file system to a URL path in the application.
The files in the path are registered with the cache buster, so that when you edit the file a new URL will be generated forcing the browser to reload the asset. This is much better than using a cache control header.
If the browser attempts to access a file in the file system that does not exist, a 404 NotFound error will be sent back to the browser.
func RegisterContentType ¶
RegisterContentType registers a content type that associates a file extension with a specific content type. You do not need to do this for all content served, as Go's http handler will try to guess the content type by the name of the file or the content itself. This is for those situations where Go's default is not working.
The extension must begin with a dot and have only one dot in it.
func RegisterDrawFunc ¶
RegisterDrawFunc registers an output function for the given pattern.
This could be used to register template output with a path, for example. See the renderResource template macro and the configure.tpl.got file in the welcome application for an example.
The file name extension will be used first to determine the Content-Type. If that fails, then the content will be inspected to determine the Content-Type.
Registered handlers are served by the AppMuxer.
func RegisterFileProcessor ¶
func RegisterFileProcessor(extension string, processorFunc FileProcessorFunc)
RegisterFileProcessor registers a processor function for static files that have a particular extension. Do this at init time. The extension must begin with a dot and only have one dot in it.
func RegisterStaticHandler ¶
RegisterStaticHandler registers a handler for the given pattern.
The given handler is served immediately by the application without going through the application handler stack. If you need session management, HSTS protection, authentication, etc., use RegisterAppHandler.
If a ProxyPath is set, it will automatically be inserted in front of the path in the pattern. If the pattern has a path that ends in "/"
func SetLocalPathMaker ¶
func SetLocalPathMaker(f LocalPathMaker)
SetLocalPathMaker sets the local path maker to the given one.
The default local path maker will prepend config.ProxyPath to all local paths.
func StripCacheBusterPath ¶
StripCacheBusterPath removes the hash of the asset file from the path to the asset.
func UseMuxer ¶
UseMuxer serves a muxer such that if a handler cannot be found, or the found handler does not respond, control is past to the next handler.
Note that the default Go Muxer is NOT recommended, as it improperly handles redirects if this is behind a reverse proxy.
func ValidateHeader ¶
ValidateHeader confirms that the given header's values only contains ASCII characters.
Types ¶
type DrawFunc ¶
A DrawFunc sends output to the Writer. goradd uses this signature in its template functions.
type FileProcessorFunc ¶
FileProcessorFunc processes a static file and outputs it to the response writer.
type FileSystemServer ¶
type FileSystemServer struct {
// Fsys is the file system being served.
Fsys fs.FS
// SendModTime will send the modification time of the file when it is served. Generally, you want
// to do this for files that can be bookmarked, like html files, since there really is no other way
// to try to get the server to reload the file when it is changed. However, for asset files that are
// using the cache buster, you should not do this, since cache busting will take care of notifying
// the user the file is changed.
SendModTime bool
// UseCacheBuster will look for cache buster paths and fix them.
UseCacheBuster bool
// Hide is a slice of file endings that will be blocked from being served. These endings do not have to just
// be file extensions, but any string. So if you specify an ending of "_abc.txt", any file ending in the
// string will NOT be shown.
Hide []string
}
func (FileSystemServer) ServeHTTP ¶
func (f FileSystemServer) ServeHTTP(w http.ResponseWriter, r *http.Request)
ServeHTTP will serve the file system.
type LocalPathMaker ¶
LocalPathMaker converts an HTTP path rooted to the application, to a path accessible by the server.
type Muxer ¶
type Muxer interface {
// Handle associates a handler with the given pattern in the url path
Handle(pattern string, handler http.Handler)
// Handler returns the handler associate with the request, if one exists. It
// also returns the actual path registered to the handler
Handler(r *http.Request) (h http.Handler, pattern string)
// ServeHTTP sends a request to the MUX, to be forwarded on to the registered handler,
// or responded with an unknown resource error.
ServeHTTP(w http.ResponseWriter, r *http.Request)
}
Muxer represents the typical functions available in a mux and allows you to replace the default muxer here with a 3rd party mux, like the Gorilla mux.
However, beware. The default Go muxer will do redirects. If this goradd application is behind a reverse proxy that is rewriting the url, the Go muxer will not correctly do rewrites because it will not include the reverse proxy path in the rewrite rule, and things will break.
If you create your own mux and you want to do redirects, use MakeLocalPath to create the redirect url. See also maps.SafeMap for a map you can use if you are modifying paths while using the mux.
var AppMuxer Muxer = http.NewServeMux()
AppMuxer is the application muxer that lets you do http handling from behind the application facilities of session management, output buffering, etc.
var PatternMuxer Muxer = http.NewServeMux()
PatternMuxer is the muxer that immediately routes handlers based on the path without going through the application handlers. It responds directly to the ResponseWriter.
Source Files