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) 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_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)

Constructors
Constructor and Description
`PeerState(Peer peer, PeerListener listener, BandwidthListener bwl, MetaInfo metainfo, PeerConnectionIn in, PeerConnectionOut out)`

Method Summary

All 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)` BEP 6 Ignored for now
`(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`	`extensionMessage(int id, byte[] bs)` Handle an extension message from the 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
`(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) 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
`(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()` Get partial pieces, give them back to PeerCoordinator.
`(package private) void`	`setChoking(boolean choke)` Sets whether or not we are choking the peer.
`(package private) void`	`setInteresting(boolean interest)` Sets whether or not we are interested in pieces from this peer.
`void`	`setMetaInfo(MetaInfo meta)` Switch from magnet mode to normal mode.
`(package private) void`	`suggestMessage(int piece)` BEP 6 Treated as "have" for now
`(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
  - 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_PIPELINE
```
public static final int MAX_PIPELINE
```
    Maximum request pipeline depth for outbound requests.
    See Also:
    Constant Field Values
  - MIN_PIPELINE
```
public static final int MIN_PIPELINE
```
    Minimum request pipeline depth for outbound requests.
    See Also:
    Constant Field Values
  - out
```
final PeerConnectionOut out
```
    Outbound connection
  - PARTSIZE
```
public static final int PARTSIZE
```
    Chunk size for outbound piece requests.
    See Also:
    Constant Field Values
- Constructor Detail
  - PeerState
```
PeerState(Peer peer,
          PeerListener listener,
          BandwidthListener bwl,
          MetaInfo metainfo,
          PeerConnectionIn in,
          PeerConnectionOut out)
```
    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)
```
    BEP 6 Ignored for now
  - 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
  - extensionMessage
```
void extensionMessage(int id,
                      byte[] bs)
```
    Handle an extension message from the peer.
    Parameters:
    id - the extension message ID
    bs - the message payload
  - 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
    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
  - 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
  - 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()
```
    Get partial pieces, give them back to PeerCoordinator. Clears the request queue.
    Returns:
    List of PartialPieces, even those with an offset == 0, or empty list
  - setChoking
```
void setChoking(boolean choke)
```
    Sets whether or not we are choking the peer.
    Parameters:
    choke - true to choke, false to unchoke
  - setInteresting
```
void setInteresting(boolean interest)
```
    Sets whether or not 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
  - suggestMessage
```
void suggestMessage(int piece)
```
    BEP 6 Treated as "have" for now
  - 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

bitfield

choked

choking

in

interested

interesting

listener

MAX_PIPELINE

MIN_PIPELINE

out

PARTSIZE

Constructor Detail

PeerState

Method Detail

addRequest

allowedFastMessage

bitfieldMessage

cancelMessage

cancelPiece

chokeMessage

extensionMessage

getBandwidthListener

getOutstandingRequest

getRequests

haveMessage

haveMessage

havePiece

interestedMessage

keepAlive

keepAliveMessage

loadData

pieceMessage

portMessage

rejectMessage

requestMessage

retransmitRequests

returnPartialPieces

setChoking

setInteresting

setMetaInfo

suggestMessage

unknownMessage

uploaded