Simplify relay

mtglib/internal/faketls/conn.go

 		}
 
 		switch rec.Type { // nolint: exhaustive
-		case record.TypeChangeCipherSpec:
 		case record.TypeApplicationData:
 			rec.Payload.WriteTo(&c.readBuffer) // nolint: errcheck
 
 			return c.readBuffer.Read(p)
+		case record.TypeChangeCipherSpec:
 		default:
 			return 0, fmt.Errorf("unsupported record type %v", rec.Type)
 		}

mtglib/internal/relay/conn.go

 package relay
 
-import "io"
+import (
+	"context"
+	"io"
+)
 
 type conn struct {
 	io.ReadWriteCloser
 
-	relay *Relay
+	ctx         context.Context
+	tickChannel chan struct{}
 }
 
 func (c conn) Read(p []byte) (int, error) {
 	n, err := c.ReadWriteCloser.Read(p)
 
 	select {
-	case <-c.relay.ctx.Done():
-	case c.relay.tickChannel <- struct{}{}:
+	case <-c.ctx.Done():
+	case c.tickChannel <- struct{}{}:
 	}
 
 	return n, err // nolint: wrapcheck
 	n, err := c.ReadWriteCloser.Write(p)
 
 	select {
-	case <-c.relay.ctx.Done():
-	case c.relay.tickChannel <- struct{}{}:
+	case <-c.ctx.Done():
+	case c.tickChannel <- struct{}{}:
 	}
 
 	return n, err // nolint: wrapcheck

mtglib/internal/relay/relay.go

 func (r *Relay) Process(eastConn, westConn io.ReadWriteCloser) error {
 	eastConn = conn{
 		ReadWriteCloser: eastConn,
-		relay:           r,
+		ctx:             r.ctx,
+		tickChannel:     r.tickChannel,
 	}
 	westConn = conn{
 		ReadWriteCloser: westConn,
-		relay:           r,
+		ctx:             r.ctx,
+		tickChannel:     r.tickChannel,
 	}
 
 	defer func() {
 	wg := &sync.WaitGroup{}
 	wg.Add(3) // nolint: gomnd
 
-	go r.runObserver(r.ctx, wg)
+	go r.runObserver(wg)
 
 	go r.transmit(eastConn, westConn, r.westBuffer, "west", wg)
 
 
 		select {
 		case <-r.ctx.Done():
+			err = r.ctx.Err()
+		default:
+		}
+
+		select {
 		case r.errorChannel <- err:
 		default:
 		}
 	}
 }
 
-func (r *Relay) runObserver(ctx context.Context, wg *sync.WaitGroup) {
+func (r *Relay) runObserver(wg *sync.WaitGroup) {
 	ticker := time.NewTicker(time.Second)
 
 	defer func() {
 
 	for {
 		select {
-		case <-ctx.Done():
+		case <-r.ctx.Done():
 			return
 		case <-r.tickChannel:
 			lastTickAt = time.Now()