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/BenefexLtd/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

• func MustStart(ctx context.Context, workers ...Worker)
• func Start(ctx context.Context, workers ...Worker) error
• type Halter
• type MultiError
  • func (e MultiError) Error() string
  • func (e MultiError) Unwrap() error
  • func (e MultiError) Valid() bool
• type Runner
• type Worker

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.

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 MultiError

type MultiError struct{ Errors []error }

MultiError holds a slice of errors and implements the error interface.

func (MultiError) Error

func (e MultiError) Error() string

Error returns a string representation of the MultiError.

func (MultiError) Unwrap

func (e MultiError) Unwrap() error

Unwrap returns an error from Error (or nil if there are no errors). This error returned will further support Unwrap to get the next error, etc. The order will match the order of Errors in the multierror.Error at the time of calling.

func (MultiError) Valid

func (e MultiError) Valid() bool

Valid returns true if the MultiError Errors slice is not empty.

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.