## org.klomp.snark
Class PeerCoordinator

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

All Implemented Interfaces:
  PeerListener

    public class PeerCoordinator

extends Object
implements PeerListener

Coordinates what peer does what.

Field Summary
`I2PSnarkUtil` `_util`
`(package private) static long` `CHECK_PERIOD`
`(package private) int` `interestedAndChoking`
`(package private) static int` `MAX_UPLOADERS`
`(package private) MetaInfo` `metainfo`
`(package private) int` `peerCount` estimate of the peers, without requiring any synchronization
`(package private) List<Peer>` `peers`
`(package private) static int` `RATE_DEPTH`
`(package private) Snark` `snark`
`(package private) Storage` `storage`
`String` `trackerProblems`
`int` `trackerSeenPeers`
`(package private) int` `uploaders`

Constructor Summary
`PeerCoordinator(I2PSnarkUtil util, byte[] id, MetaInfo metainfo, Storage storage, CoordinatorListener listener, Snark torrent)`

Method Summary
`boolean` `addPeer(Peer peer)`
`int` `allowedUploaders()` Return number of allowed uploaders for this torrent.
`boolean` `completed()`
`void` `connected(Peer peer)` Called when the connection to the peer has started and the handshake was successfull.
`void` `disconnected(Peer peer)` Called when the connection to the peer was terminated or the connection handshake failed.
`void` `downloaded(Peer peer, int size)` Called when a peer has downloaded some bytes of a piece.
`byte[]` `getBitMap()`
`long` `getCurrentUploadRate()`
`long` `getDownloaded()` Returns the total number of downloaded bytes of all peers.
`long` `getDownloadRate()` Returns the 4-minute-average rate in Bps
`byte[]` `getID()`
`long` `getLeft()` Returns how many bytes are still needed to get the complete file.
`CoordinatorListener` `getListener()`
`MetaInfo` `getMetaInfo()`
`int` `getPeerCount()` might be wrong
`Request` `getPeerPartial(BitField havePieces)` Return partial piece if it's still wanted and peer has it.
`int` `getPeers()` should be right
`(package private) static long` `getRate(long[] array)`
`Storage` `getStorage()`
`long` `getUploaded()` Returns the total number of uploaded bytes of all peers.
`long` `getUploadRate()`
`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.
`boolean` `gotHave(Peer peer, int piece)` Called when a have piece message is received.
`void` `gotInterest(Peer peer, boolean interest)` Called when an interested message is received.
`boolean` `gotPiece(Peer peer, int piece, byte[] bs)` Returns false if the piece is no good (according to the hash).
`byte[]` `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()`
`boolean` `halted()`
`void` `markUnrequested(Peer peer)` Mark a peer's requested pieces unrequested when it is disconnected Once for each piece This is enough trouble, maybe would be easier just to regenerate the requested list from scratch instead.
`boolean` `needPeers()`
`boolean` `overUpBWLimit()`
`boolean` `overUpBWLimit(long total)`
`List<Peer>` `peerList()`
`void` `removePeerFromPieces(Peer peer)` Called when a peer is removed, to prevent it from being used in rarest-first calculations.
`void` `savePeerPartial(PeerState state)` Called when the peer has disconnected and the peer task may have a partially downloaded piece that the PeerCoordinator can save
`(package private) static void` `setRate(long val, long[] array)`
`void` `setRateHistory(long up, long down)` Push the total uploaded/downloaded onto a RATE_DEPTH deep stack
`void` `setWantedPieces()`
`(package private) void` `unchokePeer()`
`void` `updatePiecePriorities()` Maps file priorities to piece priorities.
`void` `uploaded(Peer peer, int size)` Called when a peer has uploaded some bytes of a piece.
`int` `wantPiece(Peer peer, BitField havePieces)` Returns one of pieces in the given BitField that is still wanted or -1 if none of the given pieces are wanted.

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

Field Detail

### metainfo

    final MetaInfo metainfo

### storage

    final Storage storage

### snark

    final Snark snark

### CHECK_PERIOD

    static final long CHECK_PERIOD

See Also:
  Constant Field Values

### MAX_UPLOADERS

    static final int MAX_UPLOADERS

See Also:
  Constant Field Values

### uploaders

    int uploaders

### interestedAndChoking

    int interestedAndChoking

### RATE_DEPTH

    static final int RATE_DEPTH

See Also:
  Constant Field Values

### peers

    final List<Peer> peers

### peerCount

    volatile int peerCount

  estimate of the peers, without requiring any synchronization

### _util

    public I2PSnarkUtil _util

### trackerProblems

    public String trackerProblems

### trackerSeenPeers

    public int trackerSeenPeers

Constructor Detail

### PeerCoordinator

    public PeerCoordinator(I2PSnarkUtil util,
                           byte[] id,
                           MetaInfo metainfo,
                           Storage storage,
                           CoordinatorListener listener,
                           Snark torrent)

Method Detail

### setWantedPieces

    public void setWantedPieces()

### getStorage

    public Storage getStorage()

### getListener

    public CoordinatorListener getListener()

### peerList

    public List<Peer> peerList()

### getID

    public byte[] getID()

### completed

    public boolean completed()

### getPeerCount

    public int getPeerCount()

  might be wrong

### getPeers

    public int getPeers()

  should be right

### getLeft

    public long getLeft()

  Returns how many bytes are still needed to get the complete file.

### getUploaded

    public long getUploaded()

  Returns the total number of uploaded bytes of all peers.

### getDownloaded

    public long getDownloaded()

  Returns the total number of downloaded bytes of all peers.

### setRateHistory

    public void setRateHistory(long up,
                               long down)

  Push the total uploaded/downloaded onto a RATE_DEPTH deep stack

### setRate

    static void setRate(long val,
                        long[] array)

### getDownloadRate

    public long getDownloadRate()

  Returns the 4-minute-average rate in Bps

### getUploadRate

    public long getUploadRate()

### getCurrentUploadRate

    public long getCurrentUploadRate()

### getRate

    static long getRate(long[] array)

### getMetaInfo

    public MetaInfo getMetaInfo()

### needPeers

    public boolean needPeers()

### halted

    public boolean halted()

### halt

    public void halt()

### connected

    public void connected(Peer peer)

  Description copied from interface: `PeerListener`
  Called when the connection to the peer has started and the handshake was successfull.

  Specified by:
    `connected` in interface `PeerListener`
  Parameters:
    `peer` - the Peer that just got connected.

### addPeer

    public boolean addPeer(Peer peer)

### unchokePeer

    void unchokePeer()

### getBitMap

    public byte[] getBitMap()

### gotHave

    public boolean gotHave(Peer peer,
                           int piece)

  Description copied from interface: `PeerListener`
  Called when a have piece message is received. If the method returns true and the peer has not yet received a interested message or we indicated earlier to be not interested then an interested message will be send.

  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

### 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.

### wantPiece

    public int wantPiece(Peer peer,
                         BitField havePieces)

  Returns one of pieces in the given BitField that is still wanted or -1 if none of the given pieces are wanted.

  Specified by:
    `wantPiece` 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:
    one of the pieces from the bitfield that we want or -1 if we are no longer interested in the peer.

### updatePiecePriorities

    public void updatePiecePriorities()

  Maps file priorities to piece priorities. Call after updating file priorities Storage.setPriority()

  Since:
    0.8.1

### gotRequest

    public byte[] 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:
    a byte array containing the piece or null when the piece is not available (which is a protocol error).

### uploaded

    public void uploaded(Peer peer,
                         int size)

  Called when a peer has uploaded some bytes of a piece.

  Specified by:
    `uploaded` in interface `PeerListener`
  Parameters:
    `peer` - the Peer to which size bytes where uploaded.
    `size` - the number of bytes that where uploaded.

### downloaded

    public void downloaded(Peer peer,
                           int size)

  Called when a peer has downloaded some bytes of a piece.

  Specified by:
    `downloaded` in interface `PeerListener`
  Parameters:
    `peer` - the Peer from which size bytes where downloaded.
    `size` - the number of bytes that where downloaded.

### gotPiece

    public boolean gotPiece(Peer peer,
                            int piece,
                            byte[] bs)

  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.
    `piece` - the piece number received.
    `bs` - the byte array containing the piece.
  Returns:
    true when the bytes represent the piece, false otherwise.

### gotChoke

    public void gotChoke(Peer peer,
                         boolean choke)

  Description copied from interface: `PeerListener`
  Called when a choke message is received.

  Specified by:
    `gotChoke` in interface `PeerListener`
  Parameters:
    `peer` - the Peer that got the message.
    `choke` - true when the peer got a choke message, false when the peer got an unchoke message.

### gotInterest

    public void gotInterest(Peer peer,
                            boolean interest)

  Description copied from interface: `PeerListener`
  Called when an interested message is received.

  Specified by:
    `gotInterest` in interface `PeerListener`
  Parameters:
    `peer` - the Peer that got the message.
    `interest` - true when the peer got a interested message, false when the peer got an uninterested message.

### disconnected

    public void disconnected(Peer peer)

  Description copied from interface: `PeerListener`
  Called when the connection to the peer was terminated or the connection handshake failed.

  Specified by:
    `disconnected` in interface `PeerListener`
  Parameters:
    `peer` - the Peer that just got disconnected.

### removePeerFromPieces

    public void removePeerFromPieces(Peer peer)

  Called when a peer is removed, to prevent it from being used in rarest-first calculations.

### savePeerPartial

    public void savePeerPartial(PeerState state)

  Description copied from interface: `PeerListener`
  Called when the peer has disconnected and the peer task may have a partially downloaded piece that the PeerCoordinator can save

  Specified by:
    `savePeerPartial` in interface `PeerListener`
  Parameters:
    `state` - the PeerState for the peer

### getPeerPartial

    public Request getPeerPartial(BitField havePieces)

  Return partial piece if it's still wanted and peer has it.

  Specified by:
    `getPeerPartial` in interface `PeerListener`
  Parameters:
    `havePieces` - the have-pieces bitmask for the peer
  Returns:
    request (contains the partial data and valid length)

### markUnrequested

    public void markUnrequested(Peer peer)

  Mark a peer's requested pieces unrequested when it is disconnected Once for each piece This is enough trouble, maybe would be easier just to regenerate the requested list from scratch instead.

  Specified by:
    `markUnrequested` in interface `PeerListener`
  Parameters:
    `peer` - the peer that is disconnecting

### 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.

### overUpBWLimit

    public boolean overUpBWLimit()

### overUpBWLimit

    public boolean overUpBWLimit(long total)