PeerCoordinator (Javadocs [I2P+ 2.13.0+]

java.lang.Object
- org.klomp.snark.PeerCoordinator

All Implemented Interfaces:
BandwidthListener, PeerListener
```
class PeerCoordinator
extends Object
implements PeerListener, BandwidthListener
```
Coordinates peer activities for a single torrent including upload/download management, peer selection, piece distribution, and bandwidth allocation.
This class manages the core BitTorrent coordination logic:
- Managing connected peers and their states
- Choking/unchoking logic for upload slots
- Piece selection and rarest-first distribution
- Request queue management and pipeline control
- Bandwidth distribution among peers
- Peer Exchange (PEX) for peer discovery
- DHT integration for trackerless operation
- Tracker announcements and response processing
Thread safety: This class uses extensive synchronization for thread-safe peer management. External access to some fields is documented where permitted.
See Also:
Peer, PeerState, Storage

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) static long`	`CHECK_PERIOD` How often to recompute upload slots and UI download speeds.
`static long`	`MAX_INACTIVE` Inactivity timeout before disconnecting idle peers.
`static long`	`MAX_SEED_INACTIVE` Inactivity timeout before disconnecting idle seeds.
`(package private) static int`	`MAX_UPLOADERS` Maximum peers we upload to at once.
`(package private) MetaInfo`	`metainfo` Will be null when in magnet mode.
`(package private) Deque<Peer>`	`peers` Synchronize on this when changing peers or downloaders.
`(package private) static long`	`PIECE_STALL_TIMEOUT` Inactivity timeout before re-queuing a requested piece that is receiving no data.
`(package private) static int`	`RATE_DEPTH` Number of samples in the upload/download rate windows.
`(package private) Storage`	`storage` Will be null when in magnet mode.

Constructor Summary

Constructors
Constructor and Description
`PeerCoordinator(I2PSnarkUtil util, byte[] id, byte[] infohash, MetaInfo metainfo, Storage storage, CoordinatorListener listener, Snark torrent, BandwidthListener bwl)` Create a peer coordinator for the torrent.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addInterestedAndChoking(int toAdd)`
`boolean`	`addPeer(Peer peer)` Add peer (inbound or outbound)
`int`	`allowedUploaders()` Return number of allowed uploaders for this torrent.
`void`	`ban(Hash h)` Ban the given hash.
`void`	`banWebPeer(String host, boolean isPermanent)` Ban a web peer for this torrent, for while or permanently.
`(package private) void`	`checkStalledPieces(long now)` Re-queues any requested pieces that have received no data for PIECE_STALL_TIMEOUT, so they can be requested from other peers.
`boolean`	`completed()` Returns whether the torrent is complete.
`void`	`connected(Peer peer)` Called when a peer connection is established.
`void`	`decrementUploaders(boolean isInterested)` Decrement the uploaders and (if set) the interestedUploaders counts
`void`	`disconnected(Peer peer)` Called when a peer disconnects.
`void`	`downloaded(int size)` Called when a peer has downloaded some bytes of a piece.
`long`	`getCurrentUploadRate()` Returns the rate in Bps over last complete CHECK_PERIOD seconds
`long`	`getDownBWLimit()` Current limit in Bps
`long`	`getDownloaded()` Returns the total number of downloaded bytes of all peers.
`long`	`getDownloadRate()` Returns the average rate in Bps over last RATE_DEPTH * CHECK_PERIOD seconds
`byte[]`	`getID()` Returns our peer ID.
`byte[]`	`getInfoHash()` The info hash for this torrent.
`int`	`getInterestedAndChoking()` The current value.
`int`	`getInterestedUploaders()` Uploaders, interested only.
`long`	`getLeft()` Bytes not yet in storage.
`MetaInfo`	`getMetaInfo()` Returns the metainfo for this torrent.
`String`	`getName()` Returns the torrent name.
`long`	`getNeededLength()` Bytes still wanted.
`PartialPiece`	`getPartialPiece(Peer peer, BitField havePieces)` Return partial piece to the PeerState if it's still wanted and peer has it.
`PartialPiece`	`getPartialPiece(Peer peer, BitField havePieces, Set<Integer> allowed)` Return partial piece to the PeerState if it's still wanted and peer has it.
`PartialPiece`	`getPartialPiece(Peer peer, int piece)` Allocates a PartialPiece for a specific suggested piece, or returns null if the piece is not wanted, is already being fetched, or the peer is already fetching it.
`int`	`getPeerCount()` Returns the estimated peer count (may be stale).
`int`	`getPeers()` Returns the current number of connected peers.
`(package private) Set<PeerID>`	`getPEXPeers()` Called by TrackerClient
`(package private) static long`	`getRate(long[] array)` The download or upload rate, per the param.
`Storage`	`getStorage()` Returns the storage for this torrent.
`int`	`getSwarmPeerCount()` Distinct swarm peers seen recently (within `SWARM_PEER_TTL`) or currently connected, for the torrent view peer count.
`long`	`getUpBWLimit()` Current limit in Bps
`long`	`getUploaded()` Returns the total number of uploaded bytes of all peers.
`int`	`getUploaders()` Uploaders whether interested or not Use this for per-torrent limits.
`long`	`getUploadRate()` Returns the average rate in Bps over last RATE_DEPTH * CHECK_PERIOD seconds
`I2PSnarkUtil`	`getUtil()` Convenience
`boolean`	`gotBitField(Peer peer, BitField bitfield)` Returns true if the given bitfield contains at least one piece we are interested in.
`void`	`gotChoke(Peer peer, boolean choke)` Called when a choke message is received.
`void`	`gotCommentReq(Peer peer, int num)` Called when comments are requested via ut_comment
`void`	`gotComments(Peer peer, List<Comment> comments)` Called when comments are received via ut_comment
`void`	`gotExtension(Peer peer, int id, byte[] bs)` PeerListener callback
`boolean`	`gotHave(Peer peer, int piece)` Whether we still want the given piece.
`void`	`gotInterest(Peer peer, boolean interest)` Called when an interested message is received.
`void`	`gotPeers(Peer peer, List<PeerID> peers)` Handle peers from PEX; a PeerListener callback.
`boolean`	`gotPiece(Peer peer, PartialPiece pp)` Returns false if the piece is no good (according to the hash).
`void`	`gotPort(Peer peer, int port, int rport)` PeerListener callback Tell the DHT to ping it, this will get back the node info
`ByteArray`	`gotRequest(Peer peer, int piece, int off, int len)` Returns a byte array containing the requested piece or null of the piece is unknown.
`void`	`halt()` Halt this coordinator, disconnecting all peers.
`boolean`	`halted()` Returns whether this coordinator has been halted.
`boolean`	`isBanned(Hash h)` Is the given hash banned?
`(package private) static boolean`	`isStalled(Piece p, long now, long timeout)` Checks if the piece has been requested but has received no data for longer than the timeout.
`boolean`	`isWebPeerBanned(String host)` Is a web peer banned?
`boolean`	`needOutboundPeers()` Outbound.
`boolean`	`needPeers()` Inbound.
`boolean`	`needPiece(Peer peer, BitField havePieces)` Called when we are downloading from the peer and may need to ask for a new piece.
`boolean`	`overDownBWLimit()` Are we currently over the limit?
`boolean`	`overUpBWLimit()` Is snark as a whole over its upload limit?
`boolean`	`overUpBWLimit(long total)` Is a particular peer who has downloaded this many bytes from us in the last CHECK_PERIOD over its limit?
`List<Peer>`	`peerList()` Returns a snapshot of the connected peers list for web page detailed stats.
`(package private) void`	`recordSwarmPeer(Peer peer)` Record a peer surfaced by any source (announce, PEX, DHT, inbound) as a distinct swarm member, keyed by destination hash.
`void`	`restart()` Restart after halt.
`void`	`savePartialPieces(Peer peer, List<Request> partials)` Save partial pieces on peer disconnection and hopefully restart it later.
`(package private) void`	`sendCommentReq(Peer peer)` Send a commment request message to the peer, if he supports it.
`(package private) void`	`sendDHT(Peer peer)` Send a DHT message to the peer, if we both support DHT.
`(package private) void`	`sendPeers(Peer peer)` Send a PEX message to the peer, if he supports PEX.
`(package private) static void`	`setRate(long val, long[] array)` Push a value onto a RATE_DEPTH deep stack.
`void`	`setRateHistory(long up, long down)` Push the total uploaded/downloaded onto a RATE_DEPTH deep stack.
`void`	`setStorage(Storage stg)` Store the storage after transition out of magnet mode.
`void`	`setUploaded(long up)` The initial total of uploaded bytes of all peers, from a saved status.
`void`	`setUploaders(int upl, int inter)` Record the uploader and interested-uploader counts.
`void`	`setWantedPieces()` Rebuild the wanted pieces list from storage.
`boolean`	`shouldRequest(Peer peer, int size)` Should we request this many bytes?
`boolean`	`shouldSend(int size)` Should we send this many bytes? Do NOT call uploaded() if this returns true.
`(package private) void`	`unchokePeer()` (Optimistically) unchoke.
`void`	`updatePiecePriorities()` Maps file priorities to piece priorities.
`void`	`uploaded(int size)` Called when a peer has uploaded some bytes of a piece.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - CHECK_PERIOD
```
static final long CHECK_PERIOD
```
    How often to recompute upload slots and UI download speeds.
    See Also:
    Constant Field Values
  - MAX_INACTIVE
```
public static final long MAX_INACTIVE
```
    Inactivity timeout before disconnecting idle peers.
    See Also:
    Constant Field Values
  - MAX_SEED_INACTIVE
```
public static final long MAX_SEED_INACTIVE
```
    Inactivity timeout before disconnecting idle seeds.
    See Also:
    Constant Field Values
  - MAX_UPLOADERS
```
static final int MAX_UPLOADERS
```
    Maximum peers we upload to at once.
    See Also:
    Constant Field Values
  - metainfo
```
MetaInfo metainfo
```
    Will be null when in magnet mode.
  - peers
```
final Deque<Peer> peers
```
    Synchronize on this when changing peers or downloaders. This is a Queue, not a Set, because PeerCheckerTask keeps things in order for choking/unchoking.
  - PIECE_STALL_TIMEOUT
```
static final long PIECE_STALL_TIMEOUT
```
    Inactivity timeout before re-queuing a requested piece that is receiving no data.
    See Also:
    Constant Field Values
  - RATE_DEPTH
```
static final int RATE_DEPTH
```
    Number of samples in the upload/download rate windows.
    See Also:
    Constant Field Values
  - storage
```
Storage storage
```
    Will be null when in magnet mode.
- Constructor Detail
  - PeerCoordinator
```
public PeerCoordinator(I2PSnarkUtil util,
                       byte[] id,
                       byte[] infohash,
                       MetaInfo metainfo,
                       Storage storage,
                       CoordinatorListener listener,
                       Snark torrent,
                       BandwidthListener bwl)
```
    Create a peer coordinator for the torrent.
    Parameters:
    metainfo - null if in magnet mode
    storage - null if in magnet mode
- Method Detail
  - addInterestedAndChoking
```
public void addInterestedAndChoking(int toAdd)
```
  - addPeer
```
public boolean addPeer(Peer peer)
```
    Add peer (inbound or outbound)
    Returns:
    true if actual attempt to add peer occurs
  - allowedUploaders
```
public int allowedUploaders()
```
    Return number of allowed uploaders for this torrent. * Check with Snark to see if we are over the total upload limit.
  - ban
```
public void ban(Hash h)
```
    Ban the given hash.
    Specified by:
    ban in interface PeerListener
    Parameters:
    h - the hash
  - banWebPeer
```
public void banWebPeer(String host,
                       boolean isPermanent)
```
    Ban a web peer for this torrent, for while or permanently.
    Parameters:
    host - the hostname
  - checkStalledPieces
```
void checkStalledPieces(long now)
```
    Re-queues any requested pieces that have received no data for PIECE_STALL_TIMEOUT, so they can be requested from other peers. Called periodically by PeerCheckerTask.
    Parameters:
    now - the current time in milliseconds
  - completed
```
public boolean completed()
```
    Returns whether the torrent is complete.
    Returns:
    true if all pieces are downloaded
  - connected
```
public void connected(Peer peer)
```
    Called when a peer connection is established.
    Specified by:
    connected in interface PeerListener
    Parameters:
    peer - the newly connected peer
  - decrementUploaders
```
public void decrementUploaders(boolean isInterested)
```
    Decrement the uploaders and (if set) the interestedUploaders counts
  - disconnected
```
public void disconnected(Peer peer)
```
    Called when a peer disconnects.
    Specified by:
    disconnected in interface PeerListener
    Parameters:
    peer - the disconnected peer
  - downloaded
```
public void downloaded(int size)
```
    Called when a peer has downloaded some bytes of a piece.
    Specified by:
    downloaded in interface BandwidthListener
    Parameters:
    size - the number of bytes received
  - getCurrentUploadRate
```
public long getCurrentUploadRate()
```
    Returns the rate in Bps over last complete CHECK_PERIOD seconds
  - getDownBWLimit
```
public long getDownBWLimit()
```
    Current limit in Bps
    Specified by:
    getDownBWLimit in interface BandwidthListener
    Returns:
    the down b w limit
  - getDownloaded
```
public long getDownloaded()
```
    Returns the total number of downloaded bytes of all peers.
    Returns:
    total downloaded bytes
  - getDownloadRate
```
public long getDownloadRate()
```
    Returns the average rate in Bps over last RATE_DEPTH * CHECK_PERIOD seconds
    Specified by:
    getDownloadRate in interface BandwidthListener
    Returns:
    the average download rate in Bps
  - getID
```
public byte[] getID()
```
    Returns our peer ID.
    Returns:
    the peer ID bytes
  - getInfoHash
```
public byte[] getInfoHash()
```
    The info hash for this torrent.
    Returns:
    info hash
  - getInterestedAndChoking
```
public int getInterestedAndChoking()
```
    The current value.
    Returns:
    current
  - getInterestedUploaders
```
public int getInterestedUploaders()
```
    Uploaders, interested only. Use this to calculate the global total, so that unchoked but uninterested peers don't count against the global limit.
    Returns:
    current
  - getLeft
```
public long getLeft()
```
    Bytes not yet in storage. Does NOT account for skipped files. Returns how many bytes are still needed to get the complete torrent.
    Returns:
    -1 if in magnet mode
  - getMetaInfo
```
public MetaInfo getMetaInfo()
```
    Returns the metainfo for this torrent.
    Returns:
    the metainfo, or null if in magnet mode
  - getName
```
public String getName()
```
    Returns the torrent name.
    Returns:
    the name
  - getNeededLength
```
public long getNeededLength()
```
    Bytes still wanted. DOES account for skipped files.
    Returns:
    exact value. or -1 if no storage yet.
  - getPartialPiece
```
public PartialPiece getPartialPiece(Peer peer,
                                    BitField havePieces)
```
    Return partial piece to the PeerState if it's still wanted and peer has it.
    Specified by:
    getPartialPiece in interface PeerListener
    Parameters:
    havePieces - pieces the peer has, the rv will be one of these
    Returns:
    PartialPiece or null
  - getPartialPiece
```
public PartialPiece getPartialPiece(Peer peer,
                                    BitField havePieces,
                                    Set<Integer> allowed)
```
    Return partial piece to the PeerState if it's still wanted and peer has it.
    When the allowed set is not null, only pieces in it are eligible, for requesting BEP 6 allowed fast pieces from a peer that chokes us.
    Specified by:
    getPartialPiece in interface PeerListener
    Parameters:
    havePieces - pieces the peer has, the rv will be one of these
    allowed - the pieces servable while choked, or null for no restriction
    Returns:
    PartialPiece or null
  - getPartialPiece
```
public PartialPiece getPartialPiece(Peer peer,
                                    int piece)
```
    Allocates a PartialPiece for a specific suggested piece, or returns null if the piece is not wanted, is already being fetched, or the peer is already fetching it. Used for BEP 6 suggest handling.
    Specified by:
    getPartialPiece in interface PeerListener
    Parameters:
    peer - the peer that suggested the piece
    piece - the suggested piece number
    Returns:
    a new PartialPiece to request, or null
  - getPeerCount
```
public int getPeerCount()
```
    Returns the estimated peer count (may be stale).
    Returns:
    estimated peer count
  - getPeers
```
public int getPeers()
```
    Returns the current number of connected peers.
    Returns:
    peer count
  - getPEXPeers
```
Set<PeerID> getPEXPeers()
```
    Called by TrackerClient
    Returns:
    the Set itself, modifiable, not a copy, caller should clear()
  - getRate
```
static long getRate(long[] array)
```
    The download or upload rate, per the param.
  - getStorage
```
public Storage getStorage()
```
    Returns the storage for this torrent.
    Returns:
    the storage, or null if in magnet mode
  - getSwarmPeerCount
```
public int getSwarmPeerCount()
```
    Distinct swarm peers seen recently (within SWARM_PEER_TTL) or currently connected, for the torrent view peer count. Prunes stale entries lazily.
    Returns:
    the count, 0 if none
  - getUpBWLimit
```
public long getUpBWLimit()
```
    Current limit in Bps
    Specified by:
    getUpBWLimit in interface BandwidthListener
    Returns:
    the up b w limit
  - getUploaded
```
public long getUploaded()
```
    Returns the total number of uploaded bytes of all peers.
    Returns:
    total uploaded bytes
  - getUploaders
```
public int getUploaders()
```
    Uploaders whether interested or not Use this for per-torrent limits.
    Returns:
    current
  - getUploadRate
```
public long getUploadRate()
```
    Returns the average rate in Bps over last RATE_DEPTH * CHECK_PERIOD seconds
    Specified by:
    getUploadRate in interface BandwidthListener
    Returns:
    the average upload rate in Bps
  - getUtil
```
public I2PSnarkUtil getUtil()
```
    Convenience
    Specified by:
    getUtil in interface PeerListener
    Returns:
    the util
  - gotBitField
```
public boolean gotBitField(Peer peer,
                           BitField bitfield)
```
    Returns true if the given bitfield contains at least one piece we are interested in.
    Specified by:
    gotBitField in interface PeerListener
    Parameters:
    peer - the Peer that got the message.
    bitfield - a BitField containing the pieces that the other side has.
    Returns:
    true when the BitField contains pieces we want, false if the piece is already known.
  - gotChoke
```
public void gotChoke(Peer peer,
                     boolean choke)
```
    Called when a choke message is received. This does nothing but logging.
    Specified by:
    gotChoke in interface PeerListener
    Parameters:
    peer - the peer
    choke - true for choke, false for unchoke
  - gotCommentReq
```
public void gotCommentReq(Peer peer,
                          int num)
```
    Called when comments are requested via ut_comment
    Specified by:
    gotCommentReq in interface PeerListener
  - gotComments
```
public void gotComments(Peer peer,
                        List<Comment> comments)
```
    Called when comments are received via ut_comment
    Specified by:
    gotComments in interface PeerListener
    Parameters:
    comments - non-null
  - gotExtension
```
public void gotExtension(Peer peer,
                         int id,
                         byte[] bs)
```
    PeerListener callback
    Specified by:
    gotExtension in interface PeerListener
    Parameters:
    peer - the Peer that got the message.
    id - the message ID
    bs - the message payload
  - gotHave
```
public boolean gotHave(Peer peer,
                       int piece)
```
    Whether we still want the given piece.
    Specified by:
    gotHave in interface PeerListener
    Parameters:
    peer - the Peer that got the message.
    piece - the piece number that the per just got.
    Returns:
    true if we still want the given piece
  - gotInterest
```
public void gotInterest(Peer peer,
                        boolean interest)
```
    Called when an interested message is received.
    Specified by:
    gotInterest in interface PeerListener
    Parameters:
    peer - the peer
    interest - true for interested, false for uninterested
  - gotPeers
```
public void gotPeers(Peer peer,
                     List<PeerID> peers)
```
    Handle peers from PEX; a PeerListener callback.
    Specified by:
    gotPeers in interface PeerListener
    Parameters:
    peer - the Peer that got the message.
    peers - the peer IDs (dest hashes)
  - gotPiece
```
public boolean gotPiece(Peer peer,
                        PartialPiece pp)
```
    Returns false if the piece is no good (according to the hash). In that case the peer that supplied the piece should probably be blacklisted.
    Specified by:
    gotPiece in interface PeerListener
    Parameters:
    peer - the Peer that got the piece.
    pp - the piece received.
    Returns:
    true when the bytes represent the piece, false otherwise.
    Throws:
    RuntimeException - on a genuine storage error saving the piece
  - gotPort
```
public void gotPort(Peer peer,
                    int port,
                    int rport)
```
    PeerListener callback Tell the DHT to ping it, this will get back the node info
    Specified by:
    gotPort in interface PeerListener
    Parameters:
    rport - must be port + 1
    peer - the Peer that got the message.
    port - the query port
  - gotRequest
```
public ByteArray gotRequest(Peer peer,
                            int piece,
                            int off,
                            int len)
```
    Returns a byte array containing the requested piece or null of the piece is unknown.
    Specified by:
    gotRequest in interface PeerListener
    Parameters:
    peer - the Peer that wants the piece.
    piece - the piece number requested.
    off - byte offset into the piece.
    len - length of the chunk requested.
    Returns:
    bytes or null for errors such as not having the piece yet
    Throws:
    RuntimeException - on IOE getting the data
  - halt
```
public void halt()
```
    Halt this coordinator, disconnecting all peers.
  - halted
```
public boolean halted()
```
    Returns whether this coordinator has been halted.
    Returns:
    true if halted
  - isBanned
```
public boolean isBanned(Hash h)
```
    Is the given hash banned?
    Specified by:
    isBanned in interface PeerListener
    Parameters:
    h - the hash
    Returns:
    true if banned
  - isStalled
```
static boolean isStalled(Piece p,
                         long now,
                         long timeout)
```
    Checks if the piece has been requested but has received no data for longer than the timeout.
    Parameters:
    p - the piece to check
    now - the current time in milliseconds
    timeout - the stall timeout in milliseconds
    Returns:
    true if the piece is requested and stale
  - isWebPeerBanned
```
public boolean isWebPeerBanned(String host)
```
    Is a web peer banned?
    Parameters:
    host - the hostname
    Returns:
    whether web peer banned
  - needOutboundPeers
```
public boolean needOutboundPeers()
```
    Outbound. Not halted, peers < max, and need pieces.
  - needPeers
```
public boolean needPeers()
```
    Inbound. Not halted, peers < max.
  - needPiece
```
public boolean needPiece(Peer peer,
                         BitField havePieces)
```
    Called when we are downloading from the peer and may need to ask for a new piece. Returns true if wantPiece() or getPartialPiece() would return a piece.
    Specified by:
    needPiece in interface PeerListener
    Parameters:
    peer - the Peer that will be asked to provide the piece.
    havePieces - a BitField containing the pieces that the other side has.
    Returns:
    if we want any of what the peer has
  - overDownBWLimit
```
public boolean overDownBWLimit()
```
    Are we currently over the limit?
    Specified by:
    overDownBWLimit in interface BandwidthListener
    Returns:
    true if over the download limit, false otherwise
  - overUpBWLimit
```
public boolean overUpBWLimit()
```
    Is snark as a whole over its upload limit?
    Specified by:
    overUpBWLimit in interface BandwidthListener
    Returns:
    true if over limit
  - overUpBWLimit
```
public boolean overUpBWLimit(long total)
```
    Is a particular peer who has downloaded this many bytes from us in the last CHECK_PERIOD over its limit?
    Parameters:
    total - bytes uploaded to the peer in the last CHECK_PERIOD
    Returns:
    true if over limit
  - peerList
```
public List<Peer> peerList()
```
    Returns a snapshot of the connected peers list for web page detailed stats.
    Returns:
    list of connected peers
  - recordSwarmPeer
```
void recordSwarmPeer(Peer peer)
```
    Record a peer surfaced by any source (announce, PEX, DHT, inbound) as a distinct swarm member, keyed by destination hash. Web seeds are not swarm members. Bounded; refreshes the last-seen time.
    Parameters:
    peer - the peer, non-null
  - restart
```
public void restart()
```
    Restart after halt.
  - savePartialPieces
```
public void savePartialPieces(Peer peer,
                              List<Request> partials)
```
    Save partial pieces on peer disconnection and hopefully restart it later. Replace a partial piece in the List if the new one is bigger. Storage method is private so we can expand to save multiple partials if we wish.
    Also mark the piece unrequested if this peer was the only one.
    Specified by:
    savePartialPieces in interface PeerListener
    Parameters:
    peer - partials, must include the zero-offset (empty) ones too. No dup pieces. len field in Requests is ignored.
  - sendCommentReq
```
void sendCommentReq(Peer peer)
```
    Send a commment request message to the peer, if he supports it.
  - sendDHT
```
void sendDHT(Peer peer)
```
    Send a DHT message to the peer, if we both support DHT.
  - sendPeers
```
void sendPeers(Peer peer)
```
    Send a PEX message to the peer, if he supports PEX. This sends everybody we have connected to since the last time we sent PEX to him.
  - setRate
```
static void setRate(long val,
                    long[] array)
```
    Push a value onto a RATE_DEPTH deep stack.
    Parameters:
    val - the value to push
    array - the rate array to update
  - setRateHistory
```
public void setRateHistory(long up,
                           long down)
```
    Push the total uploaded/downloaded onto a RATE_DEPTH deep stack.
    Parameters:
    up - uploaded bytes this period
    down - downloaded bytes this period
  - setStorage
```
public void setStorage(Storage stg)
```
    Store the storage after transition out of magnet mode. Snark calls this after we call gotMetaInfo().
  - setUploaded
```
public void setUploaded(long up)
```
    The initial total of uploaded bytes of all peers, from a saved status.
  - setUploaders
```
public void setUploaders(int upl,
                         int inter)
```
    Record the uploader and interested-uploader counts.
    Parameters:
    upl - whether interested or not
    inter - interested only
  - setWantedPieces
```
public void setWantedPieces()
```
    Rebuild the wanted pieces list from storage. Sets wantedBytes too. Only called externally from Storage after the double-check fails.
  - shouldRequest
```
public boolean shouldRequest(Peer peer,
                             int size)
```
    Should we request this many bytes?
    Specified by:
    shouldRequest in interface BandwidthListener
    Parameters:
    peer - the peer
    size - the number of bytes to request
    Returns:
    whether request
  - shouldSend
```
public boolean shouldSend(int size)
```
    Should we send this many bytes? Do NOT call uploaded() if this returns true.
    Specified by:
    shouldSend in interface BandwidthListener
    Parameters:
    size - the number of bytes to send
    Returns:
    whether send
  - unchokePeer
```
void unchokePeer()
```
    (Optimistically) unchoke. Must be called with peers synchronized
  - updatePiecePriorities
```
public void updatePiecePriorities()
```
    Maps file priorities to piece priorities. Call after updating file priorities Storage.setPriority()
  - uploaded
```
public void uploaded(int size)
```
    Called when a peer has uploaded some bytes of a piece.
    Specified by:
    uploaded in interface BandwidthListener
    Parameters:
    size - the number of bytes sent

Class PeerCoordinator

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

CHECK_PERIOD

MAX_INACTIVE

MAX_SEED_INACTIVE

MAX_UPLOADERS

metainfo

peers

PIECE_STALL_TIMEOUT

RATE_DEPTH

storage

Constructor Detail

PeerCoordinator

Method Detail

addInterestedAndChoking

addPeer

allowedUploaders

ban

banWebPeer

checkStalledPieces

completed

connected

decrementUploaders

disconnected

downloaded

getCurrentUploadRate

getDownBWLimit

getDownloaded

getDownloadRate

getID

getInfoHash

getInterestedAndChoking

getInterestedUploaders

getLeft

getMetaInfo

getName

getNeededLength

getPartialPiece

getPartialPiece

getPartialPiece

getPeerCount

getPeers

getPEXPeers

getRate

getStorage

getSwarmPeerCount

getUpBWLimit

getUploaded

getUploaders

getUploadRate

getUtil

gotBitField

gotChoke

gotCommentReq

gotComments

gotExtension

gotHave

gotInterest

gotPeers

gotPiece

gotPort

gotRequest

halt

halted

isBanned

isStalled

isWebPeerBanned

needOutboundPeers

needPeers

needPiece

overDownBWLimit

overUpBWLimit

overUpBWLimit

peerList

recordSwarmPeer

restart