Correctly reset relay state

mtglib/internal/relay/pools.go

 }
 
 func ReleaseRelay(r *Relay) {
-	r.ctxCancel()
-
-	r.ctx = nil
-	r.ctxCancel = nil
-	r.logger = nil
-
+	r.Reset()
 	relayPool.Put(r)
 }

mtglib/internal/relay/relay.go

 	ctx          context.Context
 	ctxCancel    context.CancelFunc
 	logger       Logger
+	processMutex sync.Mutex
 	eastBuffer   []byte
 	westBuffer   []byte
 	tickChannel  chan struct{}
 	tickTimeout  time.Duration
 }
 
+func (r *Relay) Reset() {
+	r.processMutex.Lock()
+	defer r.processMutex.Unlock()
+
+	if r.ctxCancel != nil {
+		r.ctxCancel()
+	}
+
+	r.ctx = nil
+	r.ctxCancel = nil
+	r.logger = nil
+}
+
 func (r *Relay) Process(eastConn, westConn io.ReadWriteCloser) error {
+	r.processMutex.Lock()
+	defer r.processMutex.Unlock()
+
 	eastConn = conn{
 		ReadWriteCloser: eastConn,
 		ctx:             r.ctx,
 		tickChannel:     r.tickChannel,
 	}
 
-	defer func() {
-		r.ctxCancel()
-		eastConn.Close()
-		westConn.Close()
-	}()
-
 	wg := &sync.WaitGroup{}
 	wg.Add(3) // nolint: gomnd
 
-	go r.runObserver(wg)
+	go r.runObserver(eastConn, westConn, wg)
 
 	go r.transmit(eastConn, westConn, r.westBuffer, "west", wg)
 
 func (r *Relay) transmit(src io.ReadCloser, dst io.WriteCloser,
 	buffer []byte, direction string, wg *sync.WaitGroup) {
 	defer func() {
-		wg.Done()
 		src.Close()
 		dst.Close()
+		wg.Done()
+		r.ctxCancel()
 	}()
 
 	if _, err := io.CopyBuffer(dst, src, buffer); err != nil {
 	}
 }
 
-func (r *Relay) runObserver(wg *sync.WaitGroup) {
+func (r *Relay) runObserver(one, another io.Closer, wg *sync.WaitGroup) {
 	ticker := time.NewTicker(time.Second)
 
 	defer func() {
+		one.Close()
+		another.Close()
+
 		ticker.Stop()
 
 		select {