Package ctxio provides io.Reader and io.Writer wrappers that respect context.Contexts. Use these at the interface between your context code and your io. WARNING: read the code. see how writes and reads will continue until you cancel the io. Maybe this package should provide versions of io.ReadCloser and io.WriteCloser that automatically call .Close when the context expires. But for now -- since in my use cases I have long-lived connections with ephemeral io wrappers -- this has yet to be a need.
package ctxio

import (
	

	context 
)

type ioret struct {
	n   int
	err error
}

type Writer interface {
	io.Writer
}

type ctxWriter struct {
	w   io.Writer
	ctx context.Context
}
NewWriter wraps a writer to make it respect given Context. If there is a blocking write, the returned Writer will return whenever the context is cancelled (the return values are n=0 and err=ctx.Err().) Note well: this wrapper DOES NOT ACTUALLY cancel the underlying write-- there is no way to do that with the standard go io interface. So the read and write _will_ happen or hang. So, use this sparingly, make sure to cancel the read or write as necesary (e.g. closing a connection whose context is up, etc.) Furthermore, in order to protect your memory from being read _after_ you've cancelled the context, this io.Writer will first make a **copy** of the buffer.
func ( context.Context,  io.Writer) *ctxWriter {
	if  == nil {
		 = context.Background()
	}
	return &ctxWriter{ctx: , w: }
}

func ( *ctxWriter) ( []byte) (int, error) {
	 := make([]byte, len())
	copy(, )

	 := make(chan ioret, 1)

	go func() {
		,  := .w.Write()
		 <- ioret{, }
		close()
	}()

	select {
	case  := <-:
		return .n, .err
	case <-.ctx.Done():
		return 0, .ctx.Err()
	}
}

type Reader interface {
	io.Reader
}

type ctxReader struct {
	r   io.Reader
	ctx context.Context
}
NewReader wraps a reader to make it respect given Context. If there is a blocking read, the returned Reader will return whenever the context is cancelled (the return values are n=0 and err=ctx.Err().) Note well: this wrapper DOES NOT ACTUALLY cancel the underlying write-- there is no way to do that with the standard go io interface. So the read and write _will_ happen or hang. So, use this sparingly, make sure to cancel the read or write as necesary (e.g. closing a connection whose context is up, etc.) Furthermore, in order to protect your memory from being read _before_ you've cancelled the context, this io.Reader will allocate a buffer of the same size, and **copy** into the client's if the read succeeds in time.
func ( context.Context,  io.Reader) *ctxReader {
	return &ctxReader{ctx: , r: }
}

func ( *ctxReader) ( []byte) (int, error) {
	 := make([]byte, len())

	 := make(chan ioret, 1)

	go func() {
		,  := .r.Read()
		 <- ioret{, }
		close()
	}()

	select {
	case  := <-:
		copy(, )
		return .n, .err
	case <-.ctx.Done():
		return 0, .ctx.Err()
	}