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

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `(package private) class` | `Connection.ConEvent` fired to reschedule event notification
    `(package private) class` | `Connection.ResendPacketEvent` Coordinate the resends of a given packet

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `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

    Constructors
    Constructor and Description
    `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

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `(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()