Remove all cleverness that broke uploads

essentials/conns.go

 // CloseableReader is a reader interface that can close its reading end.
 type CloseableReader interface {
 	io.Reader
-
 	CloseRead() error
 }
 
 // CloseableWriter is a writer that can close its writing end.
 type CloseableWriter interface {
 	io.Writer
-
 	CloseWrite() error
 }
 

mtglib/internal/relay/init.go

 package relay
 
-import "time"
-
 const (
-	copyBufferSize   = 64 * 1024
-	writerBufferSize = 128 * 1024
-	readTimeout      = 10 * time.Millisecond
+	copyBufferSize = 64 * 1024
 )
 
 type Logger interface {

mtglib/internal/relay/pools.go

 package relay
 
-import (
-	"bufio"
-	"io"
-	"net"
-	"sync"
-)
+import "sync"
 
-var syncPairPool = sync.Pool{
+var copyBufferPool = sync.Pool{
 	New: func() interface{} {
-		return &syncPair{
-			writer:  bufio.NewWriterSize(nil, writerBufferSize),
-			copyBuf: make([]byte, copyBufferSize),
-		}
+		rv := make([]byte, copyBufferSize)
+
+		return &rv
 	},
 }
 
-func acquireSyncPair(reader net.Conn, writer io.Writer) *syncPair {
-	sp := syncPairPool.Get().(*syncPair) // nolint: forcetypeassert
-	sp.writer.Reset(writer)
-	sp.reader = reader
-
-	return sp
+func acquireCopyBuffer() *[]byte {
+	return copyBufferPool.Get().(*[]byte)
 }
 
-func releaseSyncPair(sp *syncPair) {
-	sp.writer.Reset(nil)
-	sp.reader = nil
-	syncPairPool.Put(sp)
+func releaseCopyBuffer(buf *[]byte) {
+	copyBufferPool.Put(buf)
 }

mtglib/internal/relay/relay.go

 	"context"
 	"errors"
 	"io"
-	"sync"
 
 	"github.com/9seconds/mtg/v2/essentials"
 )
 		clientConn.Close()
 	}()
 
-	wg := &sync.WaitGroup{}
-	wg.Add(2) // nolint: gomnd
+	closeChan := make(chan struct{})
 
-	go pump(log, telegramConn, clientConn, wg, "client -> telegram")
+	go func() {
+		defer close(closeChan)
+
+		pump(log, telegramConn, clientConn, "client -> telegram")
+	}()
 
-	pump(log, clientConn, telegramConn, wg, "telegram -> client")
+	pump(log, clientConn, telegramConn, "telegram -> client")
 
-	wg.Wait()
+	<-closeChan
 }
 
-func pump(log Logger, src, dst essentials.Conn, wg *sync.WaitGroup, direction string) {
-	syncer := acquireSyncPair(src, dst)
+func pump(log Logger, src, dst essentials.Conn, direction string) {
+	defer src.CloseRead()  // nolint: errcheck
+	defer dst.CloseWrite() // nolint: errcheck
 
-	defer func() {
-		syncer.Flush()
-		releaseSyncPair(syncer)
-		src.CloseRead()  // nolint: errcheck
-		dst.CloseWrite() // nolint: errcheck
-		wg.Done()
-	}()
+	copyBuffer := acquireCopyBuffer()
+	defer releaseCopyBuffer(copyBuffer)
 
-	n, err := syncer.Sync()
+	n, err := io.CopyBuffer(src, dst, *copyBuffer)
 
 	switch {
 	case err == nil:

mtglib/internal/relay/relay_test.go

 	suite.telegramConnMock.On("CloseWrite").Return(nil).Once()
 	suite.telegramConnMock.On("Read", mock.Anything).Return(10, io.EOF).Once()
 	suite.telegramConnMock.On("Write", mock.Anything).Return(10, io.EOF).Maybe()
-	suite.telegramConnMock.On("SetReadDeadline", mock.Anything).Return(nil).Maybe()
 
 	suite.clientConnMock.On("Read", mock.Anything).Return(0, io.EOF).Once()
 	suite.clientConnMock.On("Write", mock.Anything).Return(10, io.EOF).Maybe()
 	suite.clientConnMock.On("Close").Return(nil)
 	suite.clientConnMock.On("CloseRead").Return(nil).Once()
 	suite.clientConnMock.On("CloseWrite").Return(nil).Once()
-	suite.clientConnMock.On("SetReadDeadline", mock.Anything).Return(nil).Maybe()
 
 	relay.Relay(suite.ctx, suite.loggerMock, suite.telegramConnMock, suite.clientConnMock)
 }

mtglib/internal/relay/sync_pair.go

-package relay
-
-import (
-	"bufio"
-	"errors"
-	"fmt"
-	"io"
-	"net"
-	"os"
-	"sync"
-	"time"
-)
-
-type syncPair struct {
-	writer  *bufio.Writer
-	copyBuf []byte
-
-	mutex  sync.Mutex
-	reader net.Conn
-}
-
-func (s *syncPair) Sync() (int64, error) {
-	return io.CopyBuffer(s, s, s.copyBuf) // nolint: wrapcheck
-}
-
-func (s *syncPair) Read(p []byte) (int, error) {
-	n, err := s.readBlocking(p, false)
-
-	// nothing has been delivered for readTimeout time. Let's flush.
-	if errors.Is(err, os.ErrDeadlineExceeded) {
-		if err := s.Flush(); err != nil {
-			return 0, fmt.Errorf("cannot flush writer hand-side: %w", err)
-		}
-
-		return s.readBlocking(p, true)
-	}
-
-	return n, err
-}
-
-func (s *syncPair) Write(p []byte) (int, error) {
-	s.mutex.Lock()
-	defer s.mutex.Unlock()
-
-	n, err := s.writer.Write(p)
-
-	// optimization for a case when we have a small package and want to avoid a
-	// delay in readTimeout. In that case, we assume that peer has finished to
-	// sent a data it wants to send so we can flush without waiting for anything
-	// else.
-	if err == nil && n < copyBufferSize {
-		err = s.writer.Flush()
-	}
-
-	return n, err // nolint: wrapcheck
-}
-
-func (s *syncPair) Flush() error {
-	s.mutex.Lock()
-	defer s.mutex.Unlock()
-
-	return s.writer.Flush() // nolint: wrapcheck
-}
-
-func (s *syncPair) readBlocking(p []byte, blocking bool) (int, error) {
-	var deadline time.Time
-
-	if !blocking {
-		deadline = time.Now().Add(readTimeout)
-	}
-
-	if err := s.reader.SetReadDeadline(deadline); err != nil {
-		return 0, fmt.Errorf("cannot set read deadline: %w", err)
-	}
-
-	return s.reader.Read(p) // nolint: wrapcheck
-}