octopus

Octopus

Overview

This repository provides a simple set of tools to run a framework consisting of multiple concurrent tasks.

An Octopus object exposes a method Run(ctx context.Context) that executes a list of tasks and stops when:

• the input ctx is canceled (Canceled termination)
• a supported os.Signal is intercepted (the Termination depends on the behavior)

The user can define the Behavior of the Octopus by providing the relation between every supported signal and the corresponding desired Termination. The user may also defined a custom logger for message logging.

The user can specify the tasks to run concurrently by means of two Options:

• WithTasks defines the tasks to be executed as soon as Run is called;
• WithBlockedTasks defines the tasks that will be kept on hold until a Termination occurs.

How to clone

go get -u github.com/antonioiubatti93/octopus

How to use

A realistic example consists in setting up a framework to control the graceful shutdown of a HTTP server:

package main

import (
    "context"
    "errors"
    "net/http"
    "os"

    "github.com/antonioiubatti93/octopus"
)

func main(){
    // Define a trivial handler that replies with 200.
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, _ *http.Request) {
        w.WriteHeader(http.StatusOK)
    })
    server = &http.Server{
        Addr: ":8080",
        Handler: mux,
    }

    ctx, cancel := context.WithCancel(context.Background())
    defer cancel()
    
    const stop octopus.Termination = "stop"

    o := octopus.New(
        WithTasks(func() error {
            // This function starts the HTTP listener and check for errors when it returns.
            if err := server.ListenAndServe(); err != nil && !errors.As(err, &http.ErrServerClosed) {
                return err
            }
            return nil
        }),
        WithBlockedTasks(func() error {
            // This function invokes the HTTP Shutdown as soon as a termination is intercepted.
            if err := server.Shutdown(ctx); err != nil && !errors.Is(err, ctx.Err()) {
                return err
            }
            return nil
        }),
        WithBehavior(map[os.Signal]octopus.Termination{
            syscall.SIGTERM: stop,
            syscall.SIGINT: stop,
        }),
    )

    switch termination := o.Run(ctx); termination {
    case stop:
        os.Exit(0)
    default:
        os.Exit(1)
    }
}