From 0ad4dda9fc0c9623912b9b6200ca2468854317a2 Mon Sep 17 00:00:00 2001 From: Matt Joiner Date: Sun, 24 Jan 2016 15:21:17 +1100 Subject: [PATCH] Move fillRequests and replenishConnRequests into connection.go --- client.go | 29 ++++++++--------------------- connection.go | 44 ++++++++++++++++++++++++++++++++++++++++++++ torrent.go | 37 +++++-------------------------------- 3 files changed, 57 insertions(+), 53 deletions(-) diff --git a/client.go b/client.go index fe1c6ae4..d1dcd4a8 100644 --- a/client.go +++ b/client.go @@ -1185,13 +1185,13 @@ func (me *Client) peerGotPiece(t *torrent, c *connection, piece int) error { c.PeerPieces[piece] = true } if t.wantPiece(piece) { - me.replenishConnRequests(t, c) + c.updateRequests() } return nil } func (me *Client) peerUnchoked(torrent *torrent, conn *connection) { - me.replenishConnRequests(torrent, conn) + conn.updateRequests() } func (cl *Client) connCancel(t *torrent, cn *connection, r request) (ok bool) { @@ -1416,10 +1416,10 @@ func (me *Client) connectionLoop(t *torrent, c *connection) error { me.connDeleteRequest(t, c, r) } // We can then reset our interest. - me.replenishConnRequests(t, c) + c.updateRequests() case pp.Reject: me.connDeleteRequest(t, c, newRequest(msg.Index, msg.Begin, msg.Length)) - me.replenishConnRequests(t, c) + c.updateRequests() case pp.Unchoke: c.PeerChoked = false me.peerUnchoked(t, c) @@ -1671,6 +1671,7 @@ func (me *Client) addConnection(t *torrent, c *connection) bool { panic(len(t.Conns)) } t.Conns = append(t.Conns, c) + c.t = t return true } @@ -2362,20 +2363,6 @@ func (me *Client) WaitAll() bool { return true } -func (me *Client) replenishConnRequests(t *torrent, c *connection) { - if !t.haveInfo() { - return - } - t.fillRequests(c) - if len(c.Requests) == 0 && !c.PeerChoked { - // So we're not choked, but we don't want anything right now. We may - // have completed readahead, and the readahead window has not rolled - // over to the next piece. Better to stay interested in case we're - // going to want data in the near future. - c.SetInterested(!t.haveAllPieces()) - } -} - // Handle a received chunk from a peer. func (me *Client) downloadedChunk(t *torrent, c *connection, msg *pp.Message) error { chunksReceived.Add(1) @@ -2384,7 +2371,7 @@ func (me *Client) downloadedChunk(t *torrent, c *connection, msg *pp.Message) er // Request has been satisfied. if me.connDeleteRequest(t, c, req) { - defer me.replenishConnRequests(t, c) + defer c.updateRequests() } else { unexpectedChunksReceived.Add(1) } @@ -2447,7 +2434,7 @@ func (me *Client) downloadedChunk(t *torrent, c *connection, msg *pp.Message) er // Cancel pending requests for this chunk. for _, c := range t.Conns { if me.connCancel(t, c, req) { - me.replenishConnRequests(t, c) + c.updateRequests() } } @@ -2520,7 +2507,7 @@ func (me *Client) onFailedPiece(t *torrent, piece int) { me.openNewConns(t) for _, conn := range t.Conns { if conn.PeerHasPiece(piece) { - me.replenishConnRequests(t, conn) + conn.updateRequests() } } } diff --git a/connection.go b/connection.go index 9a881918..75c26d46 100644 --- a/connection.go +++ b/connection.go @@ -30,6 +30,7 @@ const ( // Maintains the state of a connection with a peer. type connection struct { + t *torrent conn net.Conn rw io.ReadWriter // The real slim shady encrypted bool @@ -534,3 +535,46 @@ func (cn *connection) Bitfield(haves []bool) { }) cn.sentHaves = haves } + +func (c *connection) updateRequests() { + if !c.t.haveInfo() { + return + } + if c.Interested { + if c.PeerChoked { + return + } + if len(c.Requests) > c.requestsLowWater { + return + } + } + c.fillRequests() + if len(c.Requests) == 0 && !c.PeerChoked { + // So we're not choked, but we don't want anything right now. We may + // have completed readahead, and the readahead window has not rolled + // over to the next piece. Better to stay interested in case we're + // going to want data in the near future. + c.SetInterested(!c.t.haveAllPieces()) + } +} + +func (c *connection) fillRequests() { + if !c.t.forUrgentPieces(func(piece int) (again bool) { + return c.t.connRequestPiecePendingChunks(c, piece) + }) { + return + } + c.t.forReaderWantedRegionPieces(func(begin, end int) (again bool) { + for i := begin + 1; i < end; i++ { + if !c.t.connRequestPiecePendingChunks(c, i) { + return false + } + } + return true + }) + for i := range c.t.pendingPieces { + if !c.t.connRequestPiecePendingChunks(c, i) { + return + } + } +} diff --git a/torrent.go b/torrent.go index cb1c3fa8..eaa33aa0 100644 --- a/torrent.go +++ b/torrent.go @@ -458,7 +458,7 @@ func (t *torrent) String() string { } func (t *torrent) haveInfo() bool { - return t != nil && t.Info != nil + return t.Info != nil } // TODO: Include URIs that weren't converted to tracker clients. @@ -814,7 +814,7 @@ func (t *torrent) forUrgentPieces(f func(piece int) (again bool)) (all bool) { func (t *torrent) readersChanged(cl *Client) { for _, c := range t.Conns { - cl.replenishConnRequests(t, c) + c.updateRequests() } cl.openNewConns(t) } @@ -897,8 +897,10 @@ func (t *torrent) pendPiece(piece int, cl *Client) { if !c.PeerHasPiece(piece) { continue } - + c.updateRequests() } + cl.openNewConns(t) + cl.pieceChanged(t, piece) } func (t *torrent) connRequestPiecePendingChunks(c *connection, piece int) (more bool) { @@ -913,32 +915,3 @@ func (t *torrent) connRequestPiecePendingChunks(c *connection, piece int) (more } return true } - -func (t *torrent) fillRequests(c *connection) { - if c.Interested { - if c.PeerChoked { - return - } - if len(c.Requests) > c.requestsLowWater { - return - } - } - if !t.forUrgentPieces(func(piece int) (again bool) { - return t.connRequestPiecePendingChunks(c, piece) - }) { - return - } - t.forReaderWantedRegionPieces(func(begin, end int) (again bool) { - for i := begin + 1; i < end; i++ { - if !t.connRequestPiecePendingChunks(c, i) { - return false - } - } - return true - }) - for i := range t.pendingPieces { - if !t.connRequestPiecePendingChunks(c, i) { - return - } - } -}