Apply megacheck to torrent package

diff --git a/client.go b/client.go
index 5020e07b41ec0451007529c934ec147c7bad2ed8..47d3b54bdfe957ef0096461766227d03ab37e0cc 100644 (file)
--- a/client.go
+++ b/client.go
@@ -836,25 +836,13 @@ type deadlineReader struct {
        r  io.Reader
 }
 
-func (r deadlineReader) Read(b []byte) (n int, err error) {
+func (r deadlineReader) Read(b []byte) (int, error) {
        // Keep-alives should be received every 2 mins. Give a bit of gracetime.
-       err = r.nc.SetReadDeadline(time.Now().Add(150 * time.Second))
+       err := r.nc.SetReadDeadline(time.Now().Add(150 * time.Second))
        if err != nil {
-               err = fmt.Errorf("error setting read deadline: %s", err)
-       }
-       n, err = r.r.Read(b)
-       // Convert common errors into io.EOF.
-       // if err != nil {
-       //      if opError, ok := err.(*net.OpError); ok && opError.Op == "read" && opError.Err == syscall.ECONNRESET {
-       //              err = io.EOF
-       //      } else if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
-       //              if n != 0 {
-       //                      panic(n)
-       //              }
-       //              err = io.EOF
-       //      }
-       // }
-       return
+               return 0, fmt.Errorf("error setting read deadline: %s", err)
+       }
+       return r.r.Read(b)
 }
 
 func handleEncryption(

diff --git a/client_test.go b/client_test.go
index c8994b6c08a1e87ca46327f12302b89d8128ca47..f589186c89dacc8e8ffc9b1426986067b598ae13 100644 (file)
--- a/client_test.go
+++ b/client_test.go
@@ -423,7 +423,7 @@ func testClientTransfer(t *testing.T, ps testClientTransferParams) {
 }
 
 func assertReadAllGreeting(t *testing.T, r io.ReadSeeker) {
-       pos, err := r.Seek(0, os.SEEK_SET)
+       pos, err := r.Seek(0, io.SeekStart)
        assert.NoError(t, err)
        assert.EqualValues(t, 0, pos)
        _greeting, err := ioutil.ReadAll(r)
@@ -573,6 +573,7 @@ func TestCompletedPieceWrongSize(t *testing.T) {
                },
        }
        b, err := bencode.Marshal(info)
+       require.NoError(t, err)
        tt, new, err := cl.AddTorrentSpec(&TorrentSpec{
                InfoBytes: b,
                InfoHash:  metainfo.HashBytes(b),
@@ -634,12 +635,12 @@ func TestResponsive(t *testing.T) {
        reader.SetReadahead(0)
        reader.SetResponsive()
        b := make([]byte, 2)
-       _, err = reader.Seek(3, os.SEEK_SET)
+       _, err = reader.Seek(3, io.SeekStart)
        require.NoError(t, err)
        _, err = io.ReadFull(reader, b)
        assert.Nil(t, err)
        assert.EqualValues(t, "lo", string(b))
-       _, err = reader.Seek(11, os.SEEK_SET)
+       _, err = reader.Seek(11, io.SeekStart)
        require.NoError(t, err)
        n, err := io.ReadFull(reader, b)
        assert.Nil(t, err)
@@ -677,13 +678,13 @@ func TestTorrentDroppedDuringResponsiveRead(t *testing.T) {
        reader.SetReadahead(0)
        reader.SetResponsive()
        b := make([]byte, 2)
-       _, err = reader.Seek(3, os.SEEK_SET)
+       _, err = reader.Seek(3, io.SeekStart)
        require.NoError(t, err)
        _, err = io.ReadFull(reader, b)
        assert.Nil(t, err)
        assert.EqualValues(t, "lo", string(b))
        go leecherTorrent.Drop()
-       _, err = reader.Seek(11, os.SEEK_SET)
+       _, err = reader.Seek(11, io.SeekStart)
        require.NoError(t, err)
        n, err := reader.Read(b)
        assert.EqualError(t, err, "torrent closed")

diff --git a/connection.go b/connection.go
index 54ebf59b565e6bd1929fe1f2504f84e6b1a20e36..6b83868ee4b92bfd24c97778c0962eca6fae8636 100644 (file)
--- a/connection.go
+++ b/connection.go
@@ -145,7 +145,7 @@ func eventAgeString(t time.Time) string {
        if t.IsZero() {
                return "never"
        }
-       return fmt.Sprintf("%.2fs ago", time.Now().Sub(t).Seconds())
+       return fmt.Sprintf("%.2fs ago", time.Since(t).Seconds())
 }
 
 func (cn *connection) connectionFlags() (ret string) {
@@ -871,7 +871,7 @@ func (c *connection) mainReadLoop() error {
                case pp.Piece:
                        c.receiveChunk(&msg)
                        if len(msg.Piece) == int(t.chunkSize) {
-                               t.chunkPool.Put(msg.Piece)
+                               t.chunkPool.Put(&msg.Piece)
                        }
                case pp.Extended:
                        switch msg.ExtendedID {
@@ -1043,9 +1043,9 @@ func (c *connection) receiveChunk(msg *pp.Message) {
 
        c.UsefulChunksReceived++
        c.lastUsefulChunkReceived = time.Now()
-       if t.fastestConn != c {
-               // log.Printf("setting fastest connection %p", c)
-       }
+       // if t.fastestConn != c {
+       // log.Printf("setting fastest connection %p", c)
+       // }
        t.fastestConn = c
 
        // Need to record that it hasn't been written yet, before we attempt to do
@@ -1087,7 +1087,6 @@ func (c *connection) receiveChunk(msg *pp.Message) {
 
        cl.event.Broadcast()
        t.publishPieceChange(int(req.Index))
-       return
 }
 
 // Also handles choking and unchoking of the remote peer.

diff --git a/peer_protocol/decoder_test.go b/peer_protocol/decoder_test.go
index 7e538adda5685742857b2b8fd35ed34f0195e8b5..0662e18122b4fd107f44ca95dca4efb71c884318 100644 (file)
--- a/peer_protocol/decoder_test.go
+++ b/peer_protocol/decoder_test.go
@@ -48,6 +48,6 @@ func BenchmarkDecodePieces(t *testing.B) {
                var msg Message
                require.NoError(t, d.Decode(&msg))
                // WWJD
-               d.Pool.Put(msg.Piece)
+               d.Pool.Put(&msg.Piece)
        }
 }

diff --git a/peer_protocol/protocol.go b/peer_protocol/protocol.go
index 8c309bcbfcc525327026d41e16350aa77ad35af9..0dc5784c93e2eaee23db58ac5e7ce38323f30cdc 100644 (file)
--- a/peer_protocol/protocol.go
+++ b/peer_protocol/protocol.go
@@ -211,7 +211,7 @@ func (d *Decoder) Decode(msg *Message) (err error) {
                        break
                }
                //msg.Piece, err = ioutil.ReadAll(r)
-               b := d.Pool.Get().([]byte)
+               b := *d.Pool.Get().(*[]byte)
                n, err := io.ReadFull(r, b)
                if err != nil {
                        if err != io.ErrUnexpectedEOF || n != int(length-9) {

diff --git a/reader.go b/reader.go
index 5afab9aa95c116a1edb0924fd819737387a9c31f..5c3bccada2fb743dbfac9eab4ec2d6d3a1af9613 100644 (file)
--- a/reader.go
+++ b/reader.go
@@ -4,7 +4,6 @@ import (
        "errors"
        "io"
        "log"
-       "os"
        "sync"
 
        "github.com/anacrolix/missinggo"
@@ -236,11 +235,11 @@ func (r *Reader) Seek(off int64, whence int) (ret int64, err error) {
        r.mu.Lock()
        defer r.mu.Unlock()
        switch whence {
-       case os.SEEK_SET:
+       case io.SeekStart:
                r.pos = off
-       case os.SEEK_CUR:
+       case io.SeekCurrent:
                r.pos += off
-       case os.SEEK_END:
+       case io.SeekEnd:
                r.pos = r.t.info.TotalLength() + off
        default:
                err = errors.New("bad whence")

diff --git a/torrent.go b/torrent.go
index d1fe406d3799b7dde8d40972224a59d6bec262a8..5eaa3d42112dde643236f48e13d31f1f32a4d06a 100644 (file)
--- a/torrent.go
+++ b/torrent.go
@@ -176,7 +176,8 @@ func (t *Torrent) setChunkSize(size pp.Integer) {
        t.chunkSize = size
        t.chunkPool = &sync.Pool{
                New: func() interface{} {
-                       return make([]byte, size)
+                       b := make([]byte, size)
+                       return &b
                },
        }
 }
@@ -1000,7 +1001,7 @@ func (t *Torrent) getConnPieceInclination() []int {
 }
 
 func (t *Torrent) putPieceInclination(pi []int) {
-       t.connPieceInclinationPool.Put(pi)
+       t.connPieceInclinationPool.Put(&pi)
        pieceInclinationsPut.Add(1)
 }
 

diff --git a/tracker_scraper.go b/tracker_scraper.go
index 1ddbf9ae9bdd25551559fd35247d1baa9bda3668..3463133c931ea6d4982bf1aeb15f5629eeb8119d 100644 (file)
--- a/tracker_scraper.go
+++ b/tracker_scraper.go
@@ -111,7 +111,7 @@ func (me *trackerScraper) Run() {
                me.lastAnnounce = ar
                me.t.cl.mu.Unlock()
 
-               intervalChan := time.After(ar.Completed.Add(ar.Interval).Sub(time.Now()))
+               intervalChan := time.After(time.Until(ar.Completed.Add(ar.Interval)))
 
                select {
                case <-me.t.closed.LockedChan(&me.t.cl.mu):