gocloud.dev: gocloud.dev/server Index | Examples | Files | Directories

package server

import "gocloud.dev/server"

Package server provides a preconfigured HTTP server with diagnostic hooks.

Index

Examples

Package Files

server.go

Variables

var Set = wire.NewSet(
    New,
    wire.Struct(new(Options), "RequestLogger", "HealthChecks", "TraceExporter", "DefaultSamplingPolicy", "Driver"),
    wire.Value(&DefaultDriver{}),
    wire.Bind(new(driver.Server), new(*DefaultDriver)),
)

Set is a Wire provider set that produces a *Server given the fields of Options.

type DefaultDriver Uses

type DefaultDriver struct {
    Server http.Server
}

DefaultDriver implements the driver.Server interface. The zero value is a valid http.Server.

func NewDefaultDriver Uses

func NewDefaultDriver() *DefaultDriver

NewDefaultDriver creates a driver with an http.Server with default timeouts.

func (*DefaultDriver) ListenAndServe Uses

func (dd *DefaultDriver) ListenAndServe(addr string, h http.Handler) error

ListenAndServe sets the address and handler on DefaultDriver's http.Server, then calls ListenAndServe on it.

func (*DefaultDriver) Shutdown Uses

func (dd *DefaultDriver) Shutdown(ctx context.Context) error

Shutdown gracefully shuts down the server without interrupting any active connections, by calling Shutdown on DefaultDriver's http.Server

type Options Uses

type Options struct {
    // RequestLogger specifies the logger that will be used to log requests.
    RequestLogger requestlog.Logger

    // HealthChecks specifies the health checks to be run when the
    // /healthz/readiness endpoint is requested.
    HealthChecks []health.Checker

    // TraceExporter exports sampled trace spans.
    TraceExporter trace.Exporter

    // DefaultSamplingPolicy is a function that takes a
    // trace.SamplingParameters struct and returns a true or false decision about
    // whether it should be sampled and exported.
    DefaultSamplingPolicy trace.Sampler

    // Driver serves HTTP requests.
    Driver driver.Server
}

Options is the set of optional parameters.

type Server Uses

type Server struct {
    // contains filtered or unexported fields
}

Server is a preconfigured HTTP server with diagnostic hooks. The zero value is a server with the default options.

func New Uses

func New(h http.Handler, opts *Options) *Server

New creates a new server. New(nil, nil) is the same as new(Server).

func (*Server) ListenAndServe Uses

func (srv *Server) ListenAndServe(addr string) error

ListenAndServe is a wrapper to use wherever http.ListenAndServe is used. It wraps the passed-in http.Handler with a handler that handles tracing and request logging. If the handler is nil, then http.DefaultServeMux will be used. A configured Requestlogger will log all requests except HealthChecks.

func (*Server) Shutdown Uses

func (srv *Server) Shutdown(ctx context.Context) error

Shutdown gracefully shuts down the server without interrupting any active connections.

Code:

// OPTIONAL: Specify a driver in the options for the constructor.
// NewDefaultDriver will be used by default if it is not explicitly set, and
// uses http.Server with read, write, and idle timeouts set. When Shutdown
// is called on the server, it is called on the driver.
srvOptions := &server.Options{
    Driver: server.NewDefaultDriver(),
}

// Pass the options to the Server constructor.
srv := server.New(http.DefaultServeMux, srvOptions)

// If your application will be behind a load balancer that handles graceful
// shutdown of requests, you may not need to call Shutdown on the server
// directly. If you need to ensure graceful shutdown directly, it is important
// to have a separate goroutine, because ListenAndServe blocks indefinitely.
go func() {
    interrupt := make(chan os.Signal, 1)
    signal.Notify(interrupt, os.Interrupt)
    // Receive off the chanel in a loop, because the interrupt could be sent
    // before ListenAndServe starts.
    for {
        <-interrupt
        srv.Shutdown(context.Background())
    }
}()

// Register a route.
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello, World!")
})

// Start the server. You will see requests logged to STDOUT.
// In the absence of an error, ListenAndServe blocks forever.
if err := srv.ListenAndServe(":8080"); err != nil {
    log.Fatalf("%v", err)
}

Directories

PathSynopsis
driverPackage driver defines an interface for custom HTTP listeners.
healthPackage health provides health check handlers.
health/sqlhealthPackage sqlhealth provides a health check for a SQL database connection.
requestlogPackage requestlog provides an http.Handler that logs information about requests.
sdserverPackage sdserver provides the diagnostic hooks for a server using Stackdriver.
xrayserverPackage xrayserver provides the diagnostic hooks for a server using AWS X-Ray.

Package server imports 10 packages (graph) and is imported by 10 packages. Updated 2019-07-17. Refresh now. Tools for package owners.