PeerState (Javadocs [I2P+ 2.13.0+] - API Version 0.9.70+)

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

All Implemented Interfaces:
DataLoader
```
class PeerState
extends Object
implements DataLoader
```
Manages the state and protocol logic for a BitTorrent peer connection.
This class tracks peer interest/choking status, piece availability, request queues, and handles all BitTorrent protocol message processing.

Field Summary

Fields
Modifier and Type	Field and Description
`(package private) Set<Integer>`	`_expectedAllowedFast` BEP 6: pieces a conforming sender may advertise, derived from our own destination hash; null until computed, or when our destination cannot be determined.
`(package private) Set<Integer>`	`_peerAllowedFast` BEP 6: pieces the peer advertised to us, requestable while it chokes us
`(package private) BitField`	`bitfield` The pieces the peer has.
`(package private) boolean`	`choked` Whether the peer has choked us
`(package private) boolean`	`choking` Whether we are choking the peer
`(package private) PeerConnectionIn`	`in` Inbound connection
`(package private) boolean`	`interested` Whether the peer is interested in us
`(package private) boolean`	`interesting` Whether we are interested in the peer
`(package private) PeerListener`	`listener` Fixme, used by Peer.disconnect() to get to the coordinator
`static int`	`MAX_PARTSIZE` Cap on a single piece request from a peer.
`static int`	`MAX_PIPELINE` Maximum request pipeline depth for outbound requests.
`static int`	`MIN_PIPELINE` Minimum request pipeline depth for outbound requests.
`(package private) PeerConnectionOut`	`out` Outbound connection
`static int`	`PARTSIZE` Chunk size for outbound piece requests.

Constructor Summary

Constructors
Constructor and Description
`PeerState(Peer peer, PeerListener listener, BandwidthListener bwl, MetaInfo metainfo, PeerConnectionIn in, PeerConnectionOut out)` Create the peer state for the torrent.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`(package private) void`	`addRequest()` Adds a new request to the outstanding requests list.
`(package private) void`	`allowedFastMessage(int piece)` Handle an allowed fast message (BEP 6): the peer will serve this piece even while it chokes us.
`(package private) void`	`bitfieldMessage(byte[] bitmap)` Handle a bitfield message from the peer
`(package private) void`	`cancelMessage(int piece, int begin, int length)` Handle a cancel message from the peer
`(package private) void`	`cancelPiece(int piece)` Tell the other side that we are no longer interested in any of the outstanding requests (if any) for this piece.
`(package private) void`	`chokeMessage(boolean choke)` Handle a choke or unchoke message from the peer
`(package private) void`	`dontHaveMessage(int piece)` Handle a BEP 54 lt_donthave message: the peer no longer has a piece it advertised.
`(package private) Set<Integer>`	`expectedAllowedFast()` The set of pieces a conforming sender may advertise, derived from our own destination hash, or null when our destination cannot be determined.
`(package private) void`	`extensionMessage(int id, byte[] bs)` Handle an extension message from the peer.
`(package private) static Set<Integer>`	`generateAllowedFastSet(byte[] peerHash, byte[] infohash, int pieces)` Generate the BEP 6 allowed fast set for a peer.
`(package private) BandwidthListener`	`getBandwidthListener()` Returns the bandwidth listener for this peer state.
`(package private) Request`	`getOutstandingRequest(int piece, int begin, int length)` Called when a piece message is being processed by the incoming connection.
`(package private) String`	`getRequests()` Debug string for the peer, or null.
`(package private) void`	`haveMessage(boolean isAll)` BEP 6
`(package private) void`	`haveMessage(int piece)` Handle a have message from the peer
`(package private) void`	`havePiece(int piece)` We now have this piece.
`(package private) void`	`interestedMessage(boolean interest)` Handle an interested or uninterested message from the peer
`(package private) boolean`	`isAllowedFast(int piece)` Whether the piece is in our BEP 6 allowed fast set for this peer.
`(package private) boolean`	`isSnubbing()` True if the peer is snubbing us: it is unchoked by us and interested but has sent no request for SNUB_TIMEOUT, and nothing is queued to send it.
`(package private) void`	`keepAlive()` Send a keepalive message to the peer.
`(package private) void`	`keepAliveMessage()` Handle a keepalive message from the peer
`ByteArray`	`loadData(int piece, int begin, int length)` This is the callback that PeerConnectionOut calls
`static int`	`maxPipelineBytes()` Maximum bytes of pipelined inbound requests to a single peer.
`(package private) void`	`pieceMessage(Request req)` Called when a full chunk (i.e.
`(package private) void`	`portMessage(int port)` Handle a port message from the peer.
`(package private) void`	`rejectMessage(int piece, int begin, int length)` BEP 6
`(package private) void`	`requestMessage(int piece, int begin, int length)` Handle a request message from the peer
`(package private) void`	`retransmitRequests()` Retransmit outstanding requests if necessary.
`(package private) List<Request>`	`returnPartialPieces()` Return partial pieces to the PeerCoordinator and clear the request queue.
`(package private) List<Request>`	`returnPartialPieces(int piece)` Return the partial piece for a piece to the PeerCoordinator.
`(package private) void`	`sendAllowedFast(BitField ourBitfield)` Generate and queue the BEP 6 allowed fast set for this peer.
`(package private) void`	`setChoking(boolean choke)` Whether we are choking the peer.
`(package private) void`	`setInteresting(boolean interest)` Whether we are interested in pieces from this peer.
`void`	`setMetaInfo(MetaInfo meta)` Switch from magnet mode to normal mode.
`static void`	`setPipelineParams(int min, int max, int chunk, int maxPart)` Apply configurable pipeline bounds, chunk size, and per-request cap, clamped to safe limits.
`(package private) void`	`suggestMessage(int piece)` BEP 6 Suggest.
`(package private) void`	`unknownMessage(int type, byte[] bs)` Handle an unknown message type from the peer.
`(package private) void`	`uploaded(int size)` Called when some bytes have left the outgoing connection.

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

- Field Detail
  - _expectedAllowedFast
```
Set<Integer> _expectedAllowedFast
```
    BEP 6: pieces a conforming sender may advertise, derived from our own destination hash; null until computed, or when our destination cannot be determined.
  - _peerAllowedFast
```
final Set<Integer> _peerAllowedFast
```
    BEP 6: pieces the peer advertised to us, requestable while it chokes us
  - bitfield
```
BitField bitfield
```
    The pieces the peer has. Locking: this.
  - choked
```
volatile boolean choked
```
    Whether the peer has choked us
  - choking
```
volatile boolean choking
```
    Whether we are choking the peer
  - in
```
final PeerConnectionIn in
```
    Inbound connection
  - interested
```
volatile boolean interested
```
    Whether the peer is interested in us
  - interesting
```
volatile boolean interesting
```
    Whether we are interested in the peer
  - listener
```
final PeerListener listener
```
    Fixme, used by Peer.disconnect() to get to the coordinator
  - MAX_PARTSIZE
```
public static volatile int MAX_PARTSIZE
```
    Cap on a single piece request from a peer.
  - MAX_PIPELINE
```
public static volatile int MAX_PIPELINE
```
    Maximum request pipeline depth for outbound requests. Bumped from 16 to 32 so a single peer can keep enough chunks in flight to saturate a fast connection at tunnel latency; the per-connection AIMD still dials this down under bandwidth pressure.
  - MIN_PIPELINE
```
public static volatile int MIN_PIPELINE
```
    Minimum request pipeline depth for outbound requests.
  - out
```
final PeerConnectionOut out
```
    Outbound connection
  - PARTSIZE
```
public static volatile int PARTSIZE
```
    Chunk size for outbound piece requests.
- Constructor Detail
  - PeerState
```
PeerState(Peer peer,
          PeerListener listener,
          BandwidthListener bwl,
          MetaInfo metainfo,
          PeerConnectionIn in,
          PeerConnectionOut out)
```
    Create the peer state for the torrent.
    Parameters:
    metainfo - null if in magnet mode
- Method Detail
  - addRequest
```
void addRequest()
```
    Adds a new request to the outstanding requests list. Then send interested if we weren't. Then send new requests if not choked. If nothing to request, send not interested if we were.
    This is called from several places:
```
   By getOutstandingRequest() when the first part of a chunk comes in
   By havePiece() when somebody got a new piece completed
   By chokeMessage() when we receive an unchoke
   By setInteresting() when we are now interested
   By PeerCoordinator.updatePiecePriorities()
 
```
  - allowedFastMessage
```
void allowedFastMessage(int piece)
```
    Handle an allowed fast message (BEP 6): the peer will serve this piece even while it chokes us. Store it and pull a request now, while we are still choked.
    Indices outside the deterministic set derived from our own destination hash are dropped, defending against buggy or malicious senders that invent pieces.
    Parameters:
    piece - the piece index
  - bitfieldMessage
```
void bitfieldMessage(byte[] bitmap)
```
    Handle a bitfield message from the peer
  - cancelMessage
```
void cancelMessage(int piece,
                   int begin,
                   int length)
```
    Handle a cancel message from the peer
  - cancelPiece
```
void cancelPiece(int piece)
```
    Tell the other side that we are no longer interested in any of the outstanding requests (if any) for this piece.
  - chokeMessage
```
void chokeMessage(boolean choke)
```
    Handle a choke or unchoke message from the peer
  - dontHaveMessage
```
void dontHaveMessage(int piece)
```
    Handle a BEP 54 lt_donthave message: the peer no longer has a piece it advertised. Without the Fast extension, silently cancel outstanding requests for the piece.
    Parameters:
    piece - the piece index
  - expectedAllowedFast
```
Set<Integer> expectedAllowedFast()
```
    The set of pieces a conforming sender may advertise, derived from our own destination hash, or null when our destination cannot be determined.
    Computed once per connection; called only from the reader thread.
    Returns:
    the expected set, or null for no verification
  - extensionMessage
```
void extensionMessage(int id,
                      byte[] bs)
```
    Handle an extension message from the peer.
    Parameters:
    id - the extension message ID
    bs - the message payload
  - generateAllowedFastSet
```
static Set<Integer> generateAllowedFastSet(byte[] peerHash,
                                           byte[] infohash,
                                           int pieces)
```
    Generate the BEP 6 allowed fast set for a peer.
    The first four bytes of the peer's destination hash stand in for the masked IP address, so both ends of an I2P connection can compute the same up to ten piece indices from the torrent infohash.
    Parameters:
    peerHash - the 32-byte destination hash of the peer
    infohash - the infohash of the torrent
    pieces - the number of pieces in the torrent
    Returns:
    the allowed fast set, never null
  - getBandwidthListener
```
BandwidthListener getBandwidthListener()
```
    Returns the bandwidth listener for this peer state.
    Returns:
    the bandwidth listener
  - getOutstandingRequest
```
Request getOutstandingRequest(int piece,
                              int begin,
                              int length)
```
    Called when a piece message is being processed by the incoming connection. That is, when the header of the piece message was received. Returns null when there was no such request. It also requeues/sends requests when it thinks that they must have been lost.
  - getRequests
```
String getRequests()
```
    Debug string for the peer, or null.
    Returns:
    string or null
  - haveMessage
```
void haveMessage(boolean isAll)
```
    BEP 6
    Parameters:
    isAll - true for have_all, false for have_none
  - haveMessage
```
void haveMessage(int piece)
```
    Handle a have message from the peer
  - havePiece
```
void havePiece(int piece)
```
    We now have this piece. Tell the peer and cancel any requests for the piece.
  - interestedMessage
```
void interestedMessage(boolean interest)
```
    Handle an interested or uninterested message from the peer
  - isAllowedFast
```
boolean isAllowedFast(int piece)
```
    Whether the piece is in our BEP 6 allowed fast set for this peer.
    Parameters:
    piece - the piece index
    Returns:
    true if servable even while we choke the peer
  - isSnubbing
```
boolean isSnubbing()
```
    True if the peer is snubbing us: it is unchoked by us and interested but has sent no request for SNUB_TIMEOUT, and nothing is queued to send it. The clock restarts when we unchoke the peer, so a freshly unchoked peer always gets the full window to respond.
    Returns:
    true if the peer is snubbing
  - keepAlive
```
void keepAlive()
```
    Send a keepalive message to the peer.
  - keepAliveMessage
```
void keepAliveMessage()
```
    Handle a keepalive message from the peer
  - loadData
```
public ByteArray loadData(int piece,
                          int begin,
                          int length)
```
    This is the callback that PeerConnectionOut calls
    Specified by:
    loadData in interface DataLoader
    Returns:
    bytes or null for errors such as not having the piece yet
    Throws:
    RuntimeException - on IOE getting the data
  - maxPipelineBytes
```
public static int maxPipelineBytes()
```
    Maximum bytes of pipelined inbound requests to a single peer. Derived from MAX_PIPELINE and PARTSIZE, so it follows the configurable values.
    Returns:
    the inbound pipeline byte ceiling
  - pieceMessage
```
void pieceMessage(Request req)
```
    Called when a full chunk (i.e. a piece message) has been received by PeerConnectionIn.
    This may block quite a while if it is the last chunk for a piece, as it calls the listener, who stores the piece and then calls havePiece for every peer on the torrent (including us).
  - portMessage
```
void portMessage(int port)
```
    Handle a port message from the peer.
    Parameters:
    port - the port number
  - rejectMessage
```
void rejectMessage(int piece,
                   int begin,
                   int length)
```
    BEP 6
  - requestMessage
```
void requestMessage(int piece,
                    int begin,
                    int length)
```
    Handle a request message from the peer
  - retransmitRequests
```
void retransmitRequests()
```
    Retransmit outstanding requests if necessary.
  - returnPartialPieces
```
List<Request> returnPartialPieces()
```
    Return partial pieces to the PeerCoordinator and clear the request queue.
    Returns:
    List of PartialPieces, even those with an offset == 0, or empty list
  - returnPartialPieces
```
List<Request> returnPartialPieces(int piece)
```
    Return the partial piece for a piece to the PeerCoordinator. Clears the requests for that piece.
    Parameters:
    piece - the piece index
    Returns:
    List of one PartialPiece, or empty list
  - sendAllowedFast
```
void sendAllowedFast(BitField ourBitfield)
```
    Generate and queue the BEP 6 allowed fast set for this peer.
    The set is derived from the peer's destination hash, so both ends compute the same pieces. Only pieces we actually have are advertised, and requests for them are served even while we choke the peer.
    Parameters:
    ourBitfield - the pieces we have, may be null
  - setChoking
```
void setChoking(boolean choke)
```
    Whether we are choking the peer.
    Parameters:
    choke - true to choke, false to unchoke
  - setInteresting
```
void setInteresting(boolean interest)
```
    Whether we are interested in pieces from this peer.
    Parameters:
    interest - true if interested
  - setMetaInfo
```
public void setMetaInfo(MetaInfo meta)
```
    Switch from magnet mode to normal mode. If we already have the metainfo, this does nothing.
    Parameters:
    meta - non-null
  - setPipelineParams
```
public static void setPipelineParams(int min,
                                     int max,
                                     int chunk,
                                     int maxPart)
```
    Apply configurable pipeline bounds, chunk size, and per-request cap, clamped to safe limits. Call once at startup; standalone snark reads these from its own config file.
    Parameters:
    min - minimum pipeline depth, clamped to [1, max]
    max - maximum pipeline depth, clamped to [min, MAX_PIPELINE_CAP]
    chunk - request chunk size in bytes, clamped to [1KiB, maxPart]
    maxPart - cap on a single request in bytes, clamped to [chunk, 1MiB]
  - suggestMessage
```
void suggestMessage(int piece)
```
    BEP 6 Suggest. Treated as a one-shot request hint: the peer is hinting that this piece is a good one to request from it. Request it immediately if we want it and are unchoked. Never recorded as a permanent have, as that would distort availability for the swarm.
  - unknownMessage
```
void unknownMessage(int type,
                    byte[] bs)
```
    Handle an unknown message type from the peer.
    Parameters:
    type - the message type byte
    bs - the message payload
  - uploaded
```
void uploaded(int size)
```
    Called when some bytes have left the outgoing connection. XXX - Should indicate whether it was a real piece or overhead.

Class PeerState

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

_expectedAllowedFast

_peerAllowedFast

bitfield

choked

choking

in

interested

interesting

listener

MAX_PARTSIZE

MAX_PIPELINE

MIN_PIPELINE

out

PARTSIZE

Constructor Detail

PeerState

Method Detail

addRequest

allowedFastMessage

bitfieldMessage

cancelMessage

cancelPiece

chokeMessage

dontHaveMessage

expectedAllowedFast

extensionMessage

generateAllowedFastSet

getBandwidthListener

getOutstandingRequest

getRequests

haveMessage

haveMessage

havePiece

interestedMessage

isAllowedFast

isSnubbing

keepAlive

keepAliveMessage

loadData

maxPipelineBytes

pieceMessage

portMessage

rejectMessage

requestMessage

retransmitRequests

returnPartialPieces

returnPartialPieces

sendAllowedFast

setChoking

setInteresting

setMetaInfo

setPipelineParams

suggestMessage

unknownMessage

uploaded