Not today...

import (
	"context"
)
type (

	// This interface is simple enough, it gets a context which will be used
	// to propagate some event down the pipe. We also want to handle potential
	// errors.
	Runner interface {
		Run(ctx context.Context) error
	}
	// This is more boilerplate, it will help us write runners without needing
	// structs. This is related to Tomas Senart video.
	RunnerFunc    func(context.Context) error
)

func (rf RunnerFunc) Run(ctx context.Context) error { return rf(ctx) }

import (
	"context"
	"fmt"
	"time"
)
// Miscellaneous runner because why not.
func Misc() Runner {

	// Here we use a bit of functionnal programming, to return a function implementing
	// our interface.
	return RunnerFunc(func(ctx context.Context) error {
		fmt.Println("Starting doing something...")

		// We will now block on two different events, either our work finish
		// normally, or we receive a done event from the context.
		select {

		// The normal workflow need to use a channel, to allow event base handling
		// here is a good example: https://gobyexample.com/select.
		// We just use the time package to wait a fixed duration.
		case <-time.After(20 * time.Second):
			fmt.Println("Done doing something...")
			return nil // nothing went wrong so no need to return an error

		// Here is the event received from the context, it asks to stop the current
		// work. We perform a teardown operation which takes a given time (just sleeping here).
		case <-ctx.Done():
			fmt.Println("Tearing down...")
			time.Sleep(5 * time.Second)
			fmt.Println("Tearing down, finished...")
			// Everything went ok, so no need to return any error, if teardown fails
			// we can propagate error
			return nil
		}
	})
}

import (
	"context"
	"os"
	"os/signal"
)
func Interrupt() Runner {
	// Plug the interrupt call to a channel, so we can easily get the event.
	interrupt := make(chan os.Signal)
	signal.Notify(interrupt, os.Interrupt)

	// Build our runner.
	return RunnerFunc(func(ctx context.Context) error {

		// Here we block and return on either event is the first one to fire.
		select {
		case <-interrupt:
			return nil
		case <-ctx.Done():
			return nil
		}
	})
}

import (
	"context"
	"sync"
)

type (
	// Our manager is just a slice of tasks which we want to run.
	RunnerManager []Runner
)

// Only one function required, we block the program until all execution has been done.
// We use a context as argument, so user can provide more constraints, like
// timeouts or external cancellation
// (see: https://golang.org/pkg/context/#WithCancel or https://golang.org/pkg/context/#WithTimeout for ideas).
// We also return an error, for the moment it will be the first caught one if any,
// we will improve this later.
func (rm RunnerManager) Wait(ctx context.Context) error {

	// Required variables:
	wg := sync.WaitGroup{}                  // WaitGroup keep tracks of running goroutines.
	ctx, cancel := context.WithCancel(ctx)  // Enhance the base context with a cancel function.
	errors := []error{}                     // We need to store errors, as multiple can come.

	// We loop over all the tasks we want to run
	for _, runner := range rm {
		// Add it to our group, this has to be done before going parallel as
		// go routines may not have started before the end of the function
		// and main function, causing program to exit before the work starts
		wg.Add(1)

		// Start a goroutine, collect errors, decrement group when task is done
		go func(runner Runner) {
			if err := runner.Run(ctx); err != nil {
				errors = append(errors, err)
			}

			// Task ended, decrement WaitGroup counter
			wg.Done()

			// Once task is done, we want to cancel all the remaining ones.
			// This is a design choice, nothing stops you from continuing execution
			// and only cancel when an error is caught.
			cancel()
		}(runner)
	}

	// Use the WaitGroup counter to block execution until all tasks finished.
	wg.Wait()

	// Return first caught error.
	if len(errors) != 0 {
		return errors[0]
	} else {
		return nil
	}
}

import (
	"fmt"
)

func main() {
	// We queue our two tasks, and use a default context
	RunnerManager{Interrupt(), Misc()}.Wait(context.Background())
}

type (
	// Simple type, just a list of errors
	Errors []error
)

// We only print the first one, yet another choice, feel free to customize according to your needs.
// We let it panic, cause we should have at least one error here.
func (e Errors) Error() string { return e[0].Error() }

// Adapt the function accordingly
func (rm RunnerManager) Wait(ctx context.Context) error {
	wg := sync.WaitGroup{}
	ctx, cancel := context.WithCancel(ctx)
	errors := []error{}

	for _, runner := range rm {
		wg.Add(1)
		go func(runner Runner) {
			if err := runner.Run(ctx); err != nil {
				errors = append(errors, err)
			}
			wg.Done()
			cancel()
		}(runner)
	}

	wg.Wait()
	// Here is our change, we check if we gathered an error
	if len(errors) != 0 {
		// We cast our array to the new type
		return Errors(errors)
	} else {
		// Otherwise we just return nil, as no error occured.
		return nil
	}
}

import (
	"context"
)

// Make a synchronous function asynchronous using a channel and a goroutine.
// We will use this in our next function.
func Async(cb func() error) <-chan error {
	out := make(chan error)
	go func() { out <- cb() }()
	return out
}

// We use here two function to create a runner. Those functions do not rely on
// any context logic, and are both blocking.
func TeardownRunnerFunc(run func() error, teardown func() error) Runner {

	return RunnerFunc(func(ctx context.Context) error {
		// We make the run function asynchronous and we wait both on return and context
		select {
		case err := <-Async(run):
			return err
		case <-ctx.Done():
			return teardown()
		}
	})
}

// Define an interface with the two function needed.
type TeardownRunner interface {
	Run() error
	Teardown() error
}

// Define a function to use our new interface as a runner.
func RunnerWithTeardown(tr TeardownRunner) Runner {
	return TeardownRunnerFunc(tr.Run, tr.Teardown)
}