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(
}
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)
},
}
b, err := bencode.Marshal(info)
+ require.NoError(t, err)
tt, new, err := cl.AddTorrentSpec(&TorrentSpec{
InfoBytes: b,
InfoHash: metainfo.HashBytes(b),
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)
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")
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) {
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 {
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
cl.event.Broadcast()
t.publishPieceChange(int(req.Index))
- return
}
// Also handles choking and unchoking of the remote peer.
var msg Message
require.NoError(t, d.Decode(&msg))
// WWJD
- d.Pool.Put(msg.Piece)
+ d.Pool.Put(&msg.Piece)
}
}
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) {
"errors"
"io"
"log"
- "os"
"sync"
"github.com/anacrolix/missinggo"
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")
t.chunkSize = size
t.chunkPool = &sync.Pool{
New: func() interface{} {
- return make([]byte, size)
+ b := make([]byte, size)
+ return &b
},
}
}
}
func (t *Torrent) putPieceInclination(pi []int) {
- t.connPieceInclinationPool.Put(pi)
+ t.connPieceInclinationPool.Put(&pi)
pieceInclinationsPut.Add(1)
}
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):