## net.i2p.client.streaming
Class Connection

    java.lang.Object
      net.i2p.client.streaming.Connection

     class Connection

extends Object

Maintain the state controlling a streaming connection between two destinations.

Nested Class Summary
`(package private) class` `Connection.ConEvent` fired to reschedule event notification
`(package private) class` `Connection.ResendPacketEvent` Coordinate the resends of a given packet

Field Summary
`static int` `DISCONNECT_TIMEOUT` wait up to 5 minutes after disconnection so we can ack/close packets
`(package private) static int` `FAST_RETRANSMIT_THRESHOLD` If we have been explicitly NACKed three times, retransmit the packet even if there are other packets in flight.
`static long` `MAX_RESEND_DELAY`
`static int` `MAX_WINDOW_SIZE`
`static long` `MIN_RESEND_DELAY`

Constructor Summary
`Connection(I2PAppContext ctx, ConnectionManager manager, SchedulerChooser chooser, PacketQueue queue, ConnectionPacketHandler handler)`
`Connection(I2PAppContext ctx, ConnectionManager manager, SchedulerChooser chooser, PacketQueue queue, ConnectionPacketHandler handler, ConnectionOptions opts)`

Method Summary
`(package private) void` `ackImmediately()`
`(package private) List<PacketLocal>` `ackPackets(long ackThrough, long[] nacks)` Process the acks and nacks received in a packet
`(package private) void` `closeReceived()`
`(package private) void` `congestionOccurred()`
`(package private) void` `disconnect(boolean cleanDisconnect)`
`(package private) void` `disconnect(boolean cleanDisconnect, boolean removeFromConMgr)`
`(package private) void` `disconnectComplete()`
`(package private) void` `eventOccurred()`
`long` `getAckedPackets()` how many packets have we sent and the other side has ACKed?
`long` `getCloseReceivedOn()`
`long` `getCloseSentOn()`
`long` `getCongestionWindowEnd()`
`String` `getConnectionError()`
`SimpleTimer.TimedEvent` `getConnectionEvent()`
`long` `getCreatedOn()`
`long` `getDisconnectScheduledOn()`
`boolean` `getHardDisconnected()`
`long` `getHighestAckedThrough()`
`MessageInputStream` `getInputStream()` stream that the local peer receives data on
`boolean` `getIsConnected()`
`long` `getLastActivityOn()`
`int` `getLastCongestionSeenAt()`
`long` `getLastSendId()` What was the last packet Id sent to the peer?
`long` `getLastSendTime()` When did we last send anything to the peer?
`long` `getLifetime()`
`long` `getLifetimeBytesReceived()`
`long` `getLifetimeBytesSent()`
`long` `getLifetimeDupMessagesReceived()`
`long` `getLifetimeDupMessagesSent()`
`long` `getNextOutboundPacketNum()`
`long` `getNextSendTime()` Time when the scheduler next want to send a packet, or -1 if never.
`ConnectionOptions` `getOptions()` Retrieve the current ConnectionOptions.
`MessageOutputStream` `getOutputStream()` stream that the local peer sends data to the remote peer on
`ConnectionPacketHandler` `getPacketHandler()`
`long` `getReceiveStreamId()` The stream ID of a peer connection that sends data to us.
`Destination` `getRemotePeer()` who are we talking with
`boolean` `getResetReceived()`
`boolean` `getResetSent()`
`long` `getResetSentOn()`
`long` `getSendStreamId()` what stream do we send data to the peer on?
`I2PSession` `getSession()`
`I2PSocketFull` `getSocket()`
`int` `getUnackedPacketsReceived()`
`int` `getUnackedPacketsSent()` how many packets have we sent but not yet received an ACK for?
`void` `incrementBytesReceived(int bytes)`
`void` `incrementBytesSent(int bytes)`
`void` `incrementDupMessagesReceived(int msgs)`
`void` `incrementDupMessagesSent(int msgs)`
`void` `incrementUnackedPacketsReceived()`
`boolean` `isInbound()`
`(package private) void` `packetReceived()`
`(package private) boolean` `packetSendChoke(long timeoutMs)` This doesn't "send a choke".
`(package private) void` `resetReceived()`
`(package private) void` `sendAvailable()` Flush any data that we can
`(package private) void` `sendPacket(PacketLocal packet)`
`(package private) void` `sendReset()` got a packet we shouldn't have, send 'em a reset
`void` `setCloseReceivedOn(long when)`
`void` `setCloseSentOn(long when)`
`void` `setCongestionWindowEnd(long endMsg)`
`void` `setConnectionError(String err)`
`void` `setHighestAckedThrough(long msgNum)` Deprecated. unused
`void` `setInbound()`
`void` `setLastSendId(long id)` Set the packet Id that was sent to a peer.
`void` `setLastSendTime(long when)` Set the time we sent data.
`void` `setNextSendTime(long when)` If the next send time is currently >= 0 (i.e.
`void` `setOptions(ConnectionOptions opts)` Set the ConnectionOptions.
`void` `setReceiveStreamId(long id)`
`void` `setRemotePeer(Destination peer)`
`void` `setSendStreamId(long id)`
`void` `setSocket(I2PSocketFull socket)`
`String` `toString()`
`void` `updateShareOpts()`
`(package private) void` `waitForConnect()` wait until a connection is made or the connection fails within the timeout period, setting the error accordingly.
`(package private) void` `windowAdjusted()`

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

Field Detail

### MAX_RESEND_DELAY

    public static final long MAX_RESEND_DELAY

See Also:
  Constant Field Values

### MIN_RESEND_DELAY

    public static final long MIN_RESEND_DELAY

See Also:
  Constant Field Values

### DISCONNECT_TIMEOUT

    public static final int DISCONNECT_TIMEOUT

  wait up to 5 minutes after disconnection so we can ack/close packets

  See Also:
    Constant Field Values

### MAX_WINDOW_SIZE

    public static final int MAX_WINDOW_SIZE

See Also:
  Constant Field Values

### FAST_RETRANSMIT_THRESHOLD

    static final int FAST_RETRANSMIT_THRESHOLD

  If we have been explicitly NACKed three times, retransmit the packet even if there are other packets in flight. 3 takes forever, let's try 2.

  See Also:
    Constant Field Values

Constructor Detail

### Connection

    public Connection(I2PAppContext ctx,
                      ConnectionManager manager,
                      SchedulerChooser chooser,
                      PacketQueue queue,
                      ConnectionPacketHandler handler)

### Connection

    public Connection(I2PAppContext ctx,
                      ConnectionManager manager,
                      SchedulerChooser chooser,
                      PacketQueue queue,
                      ConnectionPacketHandler handler,
                      ConnectionOptions opts)

Method Detail

### getNextOutboundPacketNum

    public long getNextOutboundPacketNum()

### closeReceived

    void closeReceived()

### packetSendChoke

    boolean packetSendChoke(long timeoutMs)

  This doesn't "send a choke". Rather, it blocks if the outbound window is full, thus choking the sender that calls this. Block until there is an open outbound packet slot or the write timeout expires. PacketLocal is the only caller, generally with -1.

  Parameters:
    `timeoutMs` - 0 or negative means wait forever, 5 minutes max
  Returns:
    true if the packet should be sent, false for a fatal error will return false after 5 minutes even if timeoutMs is <= 0.

### windowAdjusted

    void windowAdjusted()

### ackImmediately

    void ackImmediately()

### sendReset

    void sendReset()

  got a packet we shouldn't have, send 'em a reset

### sendAvailable

    void sendAvailable()

  Flush any data that we can

### sendPacket

    void sendPacket(PacketLocal packet)

### ackPackets

    List<PacketLocal> ackPackets(long ackThrough,
                                 long[] nacks)

  Process the acks and nacks received in a packet

  Returns:
    List of packets acked or null

### eventOccurred

    void eventOccurred()

### resetReceived

    void resetReceived()

### getResetReceived

    public boolean getResetReceived()

### setInbound

    public void setInbound()

### isInbound

    public boolean isInbound()

### getIsConnected

    public boolean getIsConnected()

### getHardDisconnected

    public boolean getHardDisconnected()

### getResetSent

    public boolean getResetSent()

### getResetSentOn

    public long getResetSentOn()

### getDisconnectScheduledOn

    public long getDisconnectScheduledOn()

### disconnect

    void disconnect(boolean cleanDisconnect)

### disconnect

    void disconnect(boolean cleanDisconnect,
                    boolean removeFromConMgr)

### disconnectComplete

    void disconnectComplete()

### getRemotePeer

    public Destination getRemotePeer()

  who are we talking with

  Returns:
    peer Destination

### setRemotePeer

    public void setRemotePeer(Destination peer)

### getSendStreamId

    public long getSendStreamId()

  what stream do we send data to the peer on?

  Returns:
    non-global stream sending ID

### setSendStreamId

    public void setSendStreamId(long id)

### getReceiveStreamId

    public long getReceiveStreamId()

  The stream ID of a peer connection that sends data to us. (may be null)

  Returns:
    receive stream ID, or null if there isn't one

### setReceiveStreamId

    public void setReceiveStreamId(long id)

### getLastSendTime

    public long getLastSendTime()

  When did we last send anything to the peer?

  Returns:
    Last time we sent data

### setLastSendTime

    public void setLastSendTime(long when)

  Set the time we sent data.

  Parameters:
    `when` - The time we sent data

### getLastSendId

    public long getLastSendId()

  What was the last packet Id sent to the peer?

  Returns:
    The last sent packet ID

### setLastSendId

    public void setLastSendId(long id)

  Set the packet Id that was sent to a peer.

  Parameters:
    `id` - The packet ID

### getOptions

    public ConnectionOptions getOptions()

  Retrieve the current ConnectionOptions.

  Returns:
    the current ConnectionOptions

### setOptions

    public void setOptions(ConnectionOptions opts)

  Set the ConnectionOptions.

  Parameters:
    `opts` - ConnectionOptions

### getSession

    public I2PSession getSession()

### getSocket

    public I2PSocketFull getSocket()

### setSocket

    public void setSocket(I2PSocketFull socket)

### getConnectionError

    public String getConnectionError()

### setConnectionError

    public void setConnectionError(String err)

### getLifetime

    public long getLifetime()

### getPacketHandler

    public ConnectionPacketHandler getPacketHandler()

### getLifetimeBytesSent

    public long getLifetimeBytesSent()

### getLifetimeBytesReceived

    public long getLifetimeBytesReceived()

### getLifetimeDupMessagesSent

    public long getLifetimeDupMessagesSent()

### getLifetimeDupMessagesReceived

    public long getLifetimeDupMessagesReceived()

### incrementBytesSent

    public void incrementBytesSent(int bytes)

### incrementDupMessagesSent

    public void incrementDupMessagesSent(int msgs)

### incrementBytesReceived

    public void incrementBytesReceived(int bytes)

### incrementDupMessagesReceived

    public void incrementDupMessagesReceived(int msgs)

### getNextSendTime

    public long getNextSendTime()

  Time when the scheduler next want to send a packet, or -1 if never. This should be set when we want to send on timeout, for instance, or want to delay an ACK.

  Returns:
    the next time the scheduler will want to send a packet, or -1 if never.

### setNextSendTime

    public void setNextSendTime(long when)

  If the next send time is currently >= 0 (i.e. not "never"), this may make the next time sooner but will not make it later. If the next send time is currently < 0 (i.e. "never"), this will set it to the time specified, but not later than options.getSendAckDelay() from now (2000 ms)

### getAckedPackets

    public long getAckedPackets()

  how many packets have we sent and the other side has ACKed?

  Returns:
    Count of how many packets ACKed.

### getCreatedOn

    public long getCreatedOn()

### getCloseSentOn

    public long getCloseSentOn()

### setCloseSentOn

    public void setCloseSentOn(long when)

### getCloseReceivedOn

    public long getCloseReceivedOn()

### setCloseReceivedOn

    public void setCloseReceivedOn(long when)

### updateShareOpts

    public void updateShareOpts()

### incrementUnackedPacketsReceived

    public void incrementUnackedPacketsReceived()

### getUnackedPacketsReceived

    public int getUnackedPacketsReceived()

### getUnackedPacketsSent

    public int getUnackedPacketsSent()

  how many packets have we sent but not yet received an ACK for?

  Returns:
    Count of packets in-flight.

### getCongestionWindowEnd

    public long getCongestionWindowEnd()

### setCongestionWindowEnd

    public void setCongestionWindowEnd(long endMsg)

### getHighestAckedThrough

    public long getHighestAckedThrough()

  Returns:
    the highest outbound packet we have recieved an ack for

### setHighestAckedThrough

    public void setHighestAckedThrough(long msgNum)

  Deprecated. unused

### getLastActivityOn

    public long getLastActivityOn()

### getLastCongestionSeenAt

    public int getLastCongestionSeenAt()

### congestionOccurred

    void congestionOccurred()

### packetReceived

    void packetReceived()

### waitForConnect

    void waitForConnect()

  wait until a connection is made or the connection fails within the timeout period, setting the error accordingly.

### getInputStream

    public MessageInputStream getInputStream()

  stream that the local peer receives data on

  Returns:
    the inbound message stream

### getOutputStream

    public MessageOutputStream getOutputStream()

  stream that the local peer sends data to the remote peer on

  Returns:
    the outbound message stream

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`

### getConnectionEvent

    public SimpleTimer.TimedEvent getConnectionEvent()