Using context to share a common timeout across consecutive function calls

I want to make some consecutive function calls in a Go program, e.g.

(error checking apparently ommitted)

result1, err := fxn1()

result2, err := fxn2()

I want the entire call sequence to be completed within a certain duration, otherwise the process should be aborted (and the program exited with error)

Assuming I have the timeout (as duration) somehow passed into my program, I guess one approach is to

a) create a context with Deadline adding timeout to current time

myDeadline := time.Now().Add(timeout * time.Second)
ctx, cancel := context.WithDeadline(context.Background(), myDeadline)
defer cancel()

b) have the final function communicate its result via a channel (I think this is called the channel generator pattern?)

func fxn2() (chan string) {

 resChan := make(chan string)

   go func() {
   // get the job done
   resChan <- result
   }()
 return resChan
}

and

c) then block the main goroutine on a select statement as follows

select {
  case err := <-ctx.Done():
    log.Println("Process has timed out...exiting")
    os.Exit(err)
  case result := <- resChan
    log.Println("Process completed in time")
}

This is the best I can think of for now, but I was wandering whether there is a better or more go-idiomatic way (say with spanwing new copies of contexts for each function - that should of course accept context.Context as input arguments) that somehow track the remaining time?)

This is more complicated than it needs to be. There are two ways to do this:

1. If the functions take a context.Context argument, you don't need to wait for <-ctx.Done() at the top level. Instead, when the context finishes, the functions will (after some unknown unknown delay, possibly never, depending on the function) return ctx.Err() (which should be context.DeadlineExceeded).

2. If the functions do not take a context.Context argument, then you can just exit the process. You don't need a context.Context to do this. All I mean by that is that the context.Context is just a more complicated way to call <-time.After(timeout).

type myResultType struct{}

func longFunctionCall() (*myResultType, error) {
    ...
}

func invokeFunctionWithDeadline() {
	const timeout = 10 * time.Second

    // Run the function on a goroutine, and return the result with a channel.
	type resultStruct struct {
		value *myResultType
		err error
	}
	ch := make(chan resultStruct)
	go func() {
		v, err := longFunctionCall()
		ch <- resultStruct{v, err}
	}()

    // Wait for either the timeout, or the result.
	select {
	case <-time.After(timeout):
		log.Println("Timed out")
		os.Exit(1)
	case result := <-ch:
		log.Println("Success:", result)
	}
}

Note that this strategy only works because you are calling os.Exit(), which forcibly terminates all outstanding goroutines.