Categorygithub.com/aaronland/go-http-server/v2
modulepackage
2.0.1
Repository: https://github.com/aaronland/go-http-server.git
Documentation: pkg.go.dev

# README

go-http-server

Go package to provide interfaces and implementation for HTTP servers.

It is mostly a syntactic wrapper around existing HTTP server implementation with a common interface configured using a URI-based syntax.

Documentation

Go Reference

Example

Error hanldling has been removed for the sake of brevity.

Using a server

package main

import (
	"context"
	"flag"
	"fmt"
	"net/http"

	"github.com/aaronland/go-http-server/v2"
)

func NewHandler() http.Handler {

	fn := func(rsp http.ResponseWriter, req *http.Request) {
		msg := fmt.Sprintf("Hello, %s", req.Host)
		rsp.Write([]byte(msg))
	}

	h := http.HandlerFunc(fn)
	return h
}

func main() {

	server_uri := flag.String("server-uri", "http://localhost:8080", "...")

	flag.Parse()

	ctx := context.Background()

	s, _ := server.NewServer(ctx, *server_uri)

	mux := http.NewServeMux()
	mux.Handle("/", NewHandler())

	log.Printf("Listening on %s", s.Address())
	s.ListenAndServe(ctx, mux)
}

Writing a server

package server

import (
	"context"
	"net/http"
	"net/url"
)

func init() {
	ctx := context.Background()
	RegisterServer(ctx, "http", NewHTTPServer)
}

type HTTPServer struct {
	Server
	url *url.URL
}

func NewHTTPServer(ctx context.Context, uri string) (Server, error) {

	u, _ := url.Parse(uri)

	u.Scheme = "http"

	server := HTTPServer{
		url: u,
	}

	return &server, nil
}

func (s *HTTPServer) Address() string {
	return s.url.String()
}

func (s *HTTPServer) ListenAndServe(ctx context.Context, mux *http.ServeMux) error {
	return http.ListenAndServe(s.url.Host, mux)
}

Server schemes

The following schemes/implementations are included by default with this package.

functionurl://

An AWS Lambda Function URL compatible HTTP server.

http://{HOST}

A standard, plain-vanilla, HTTP server.

https://{HOST}?cert={TLS_CERTIFICATE}&key={TLS_KEY}

This is an alias to the tls:// scheme.

lambda://

An AWS Lambda function + API Gateway compatible HTTP server.

mkcert://{HOST}

A thin wrapper to invoke the mkcert tool to generate locally signed TLS certificate and key files. Once created this implementation will invoke the tls:// scheme with the files create by mkcert. It is hoped this will be a short-lived scheme but it is necessary in the absence of an ACME compatibility with the mkcert tool.

tls://{HOST}?cert={TLS_CERTIFICATE}&key={TLS_KEY}

A standard, plain-vanilla, HTTPS/TLS server. You must provide TLS certificate and key files.

See also

# Packages

No description provided by the author
Package handler provides middleware `http.Handler` handlers for use with `server.Server` implementations.

# Functions

NewHTTPServer returns a new `HTTPServer` instance configured by 'uri' which is expected to be defined in the form of: {SCHEME}://{ADDRESS}:{PORT}?{PARAMETERS} Where {SCHEME} is either 'http' or 'https'; {ADDRESS} and {PORT} are the address and port to listen for requests on.
NewLambdaFunctionURLServer returns a new `LambdaFunctionURLServer` instance configured by 'uri' which is expected to be defined in the form of: functionurl://?{PARAMETERS} Valid parameters are: * `binary_type={MIMETYPE}` One or more mimetypes to be served by AWS FunctionURLs as binary content types.
NewLambdaServer returns a new `LambdaServer` instance configured by 'uri' which is expected to be defined in the form of: lambda://?{PARAMETERS} Valid parameters are: * `binary_type={MIMETYPE}` One or more mimetypes to be served by AWS API Gateway as binary content types.
NewMkCertServer returns a new `HTTPServer` instance configured using 'uri' in the form of: mkcert://?{PARAMETERS} Valid parameters are: - `root={PATH}` An optional path to specify where `mkcert` certificates and keys should be created.
NewServer() returns a new instance of `Server` for the scheme associated with 'uri'.
RegisterServer() associates 'scheme' with 'f' in an internal list of avilable `Server` implementations.
Schemes() returns the list of schemes that have been "registered".

# Constants

No description provided by the author

# Structs

HTTPServer implements the `Server` interface for a basic `net/http` server.
LambdaFunctionURLServer implements the `Server` interface for a use in a AWS LambdaFunctionURL + API Gateway context.
LambdaServer implements the `Server` interface for a use in a AWS Lambda + API Gateway context.

# Interfaces

type Server is an interface for creating server instances that serve requests using a `http.Handler` router.

# Type aliases

ServeritializeFunc is a function used to initialize an implementation of the `Server` interface.