flex

README

flex

A collection of packages for building Go services.

Quick Start

Below is an example for how to get running quickly.
This code can be found in the examples folder.

package main

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

 "github.com/go-flexible/flex"
)

func main() {
        router := http.NewServeMux()
        router.HandleFunc("/", func(rw http.ResponseWriter, r *http.Request) {
                fmt.Fprint(rw, "hello, world\n")
        })

        srv := &http.Server{
                Addr:    ":8080",
                Handler: router,
        }

        flex.MustStart(
                context.Background(),
                NewHTTPServer(srv),
        )
}

// TODO: this functionality should be provided by a plugin.
// for now this is an example on how to implement our interfaces.
type Server struct{ *http.Server }

func NewHTTPServer(s *http.Server) *Server {
        return &Server{Server: s}
}

func (s *Server) Run(_ context.Context) error {
        log.Printf("serving on: http://localhost%s\n", s.Addr)
        return s.ListenAndServe()
}

func (s *Server) Halt(ctx context.Context) error {
        return s.Shutdown(ctx)
}

Contributors

Contributors listed in alphabetical order.

• Ben Cable: Author & Maintainer
• Zee Philip Vieira: Author & Maintainer

Documentation

Index

• Constants
• func MustStart(ctx context.Context, workers ...Worker)
• func Start(ctx context.Context, workers ...Worker) error
• type Halter
• type Runner
• type Worker

Constants

const DefaultHaltTimeout = 30 * time.Second

DefaultHaltTimeout is the default timeout for graceful shutdown of workers. This provides workers with a grace period to close connections, flush data, and clean up resources during the halt phase.

Functions

func MustStart

func MustStart(ctx context.Context, workers ...Worker)

MustStart is like Start, but panics if there is an error.

func Start

func Start(ctx context.Context, workers ...Worker) error

Start is a blocking operation that will start processing the workers.

Workers are started concurrently and run until one of the following occurs: 1. A worker returns an error from Run() 2. A signal (SIGINT, SIGKILL, SIGTERM) is received 3. The provided context is canceled

When shutdown is triggered, all workers' Halt() methods are called concurrently with a fresh context that has DefaultHaltTimeout as its deadline. This ensures workers have a grace period to perform graceful shutdown operations such as closing connections or flushing data.

Types

type Halter

type Halter interface {
	// Halt should tell the worker to stop doing work.
	Halt(context.Context) error
}

Halter represents the behaviour for stopping a service worker.

type Runner

type Runner interface {
	// Run should run start processing the worker and be a blocking operation.
	Run(context.Context) error
}

Runner represents the behaviour for running a service worker.

type Worker

type Worker interface {
	Runner
	Halter
}

Worker represents the behaviour for a service worker.