net.i2p.router

## Interface ProfileManager

- All Known Implementing Classes:
    ProfileManagerImpl

      public interface ProfileManager

  Manages peer profiles and performance metrics for router peers. Tracks communication statistics, tunnel participation, and database interactions to maintain performance profiles for network peers.

- - ### Method Summary

    All Methods Instance Methods Abstract Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `commErrorOccurred(Hash peer)` Note that there was some sort of communication error talking with the peer
    `void` | `dbLookupFailed(Hash peer)` Note that the peer was unable to reply to a db lookup - either with data or with a lookupReply redirecting the user elsewhere
    `void` | `dbLookupReceived(Hash peer)` Note that the local router received a db lookup from the given peer
    `void` | `dbLookupReply(Hash peer, int newPeers, int oldPeers, int invalid, int duplicate, long responseTimeMs)` Note that the peer replied to a db lookup with a redirect to other routers, where the list of redirected users included newPeers routers that the local router didn't know about, oldPeers routers that the local router already knew about, the given invalid routers that were invalid in some way, and the duplicate number of routers that we explicitly asked them not to send us, but they did anyway
    `void` | `dbLookupSuccessful(Hash peer, long responseTimeMs)` Note that the peer was able to return the valid data for a db lookup
    `void` | `dbStoreFailed(Hash peer)` Note that we were unable to confirm a successful send of db data to the peer, at least not within our timeout period
    `void` | `dbStoreReceived(Hash peer, boolean wasNewKey)` Note that the local router received an unprompted db store from the given peer
    `void` | `dbStoreSent(Hash peer, long responseTimeMs)` Note that we've confirmed a successful send of db data to the peer (though we haven't necessarily requested it again from them, so they /might/ be lying)
    `void` | `dbStoreSuccessful(Hash peer)` Note that we confirmed a successful send of db data to the peer.
    `void` | `heardAbout(Hash peer)` Note that the local router received a reference to the given peer, either through an explicit dbStore or in a dbLookupReply.
    `void` | `heardAbout(Hash peer, long when)` Note that the local router received a reference to the given peer at a specific time.
    `void` | `messageFailed(Hash peer)` Note that the router failed to send a message to the peer over any transport
    `void` | `messageFailed(Hash peer, String transport)` Note that the router failed to send a message to the peer over the transport specified
    `void` | `messageReceived(Hash peer, String style, long msToReceive, int bytesRead)` Note that the router received a message from the given peer on the specified transport.
    `void` | `messageSent(Hash peer, String transport, long msToSend, long bytesSent)` Note that it took msToSend to send a message of size bytesSent to the peer over the transport.
    `void` | `tunnelDataPushed(Hash peer, long rtt, int size)` Note that we were able to push some data through a tunnel that the peer is participating in (detected after rtt).
    `void` | `tunnelDataPushed1m(Hash peer, int size)` Note that the peer is participating in a tunnel that pushed the given amount of data over the last minute.
    `void` | `tunnelFailed(Hash peer, int pct)` Note that the peer participated in a tunnel that failed.
    `void` | `tunnelJoined(Hash peer, long responseTimeMs)` Note that the router agreed to participate in a tunnel
    `void` | `tunnelLifetimePushed(Hash peer, long lifetime, long size)` Note that we were able to push the given amount of data through a tunnel that the peer is participating in
    `void` | `tunnelRejected(Hash peer, long responseTimeMs, int severity)` Note that a router explicitly rejected joining a tunnel
    `void` | `tunnelTestSucceeded(Hash peer, long responseTimeMs)` Note that a tunnel that the router is participating in was successfully tested with the given round trip latency
    `void` | `tunnelTimedOut(Hash peer)` Note that a router timed out joining a tunnel

- - ### Method Detail

    - #### commErrorOccurred

          void commErrorOccurred(Hash peer)

      Note that there was some sort of communication error talking with the peer

    - #### dbLookupFailed

          void dbLookupFailed(Hash peer)

      Note that the peer was unable to reply to a db lookup - either with data or with a lookupReply redirecting the user elsewhere

    - #### dbLookupReceived

          void dbLookupReceived(Hash peer)

      Note that the local router received a db lookup from the given peer

    - #### dbLookupReply

          void dbLookupReply(Hash peer,
                             int newPeers,
                             int oldPeers,
                             int invalid,
                             int duplicate,
                             long responseTimeMs)

      Note that the peer replied to a db lookup with a redirect to other routers, where the list of redirected users included newPeers routers that the local router didn't know about, oldPeers routers that the local router already knew about, the given invalid routers that were invalid in some way, and the duplicate number of routers that we explicitly asked them not to send us, but they did anyway

    - #### dbLookupSuccessful

          void dbLookupSuccessful(Hash peer,
                                  long responseTimeMs)

      Note that the peer was able to return the valid data for a db lookup

    - #### dbStoreFailed

          void dbStoreFailed(Hash peer)

      Note that we were unable to confirm a successful send of db data to the peer, at least not within our timeout period

    - #### dbStoreReceived

          void dbStoreReceived(Hash peer,
                               boolean wasNewKey)

      Note that the local router received an unprompted db store from the given peer

    - #### dbStoreSent

          void dbStoreSent(Hash peer,
                           long responseTimeMs)

      Note that we've confirmed a successful send of db data to the peer (though we haven't necessarily requested it again from them, so they /might/ be lying)

    - #### dbStoreSuccessful

          void dbStoreSuccessful(Hash peer)

      Note that we confirmed a successful send of db data to the peer.

    - #### heardAbout

          void heardAbout(Hash peer)

      Note that the local router received a reference to the given peer, either through an explicit dbStore or in a dbLookupReply.
      Parameters:
        `peer` - the hash of the peer we learned about

    - #### heardAbout

          void heardAbout(Hash peer,
                          long when)

      Note that the local router received a reference to the given peer at a specific time.
      Parameters:
        `peer` - the hash of the peer we learned about
        `when` - the timestamp when we learned about the peer

    - #### messageFailed

          void messageFailed(Hash peer)

      Note that the router failed to send a message to the peer over any transport

    - #### messageFailed

          void messageFailed(Hash peer,
                             String transport)

      Note that the router failed to send a message to the peer over the transport specified

    - #### messageReceived

          void messageReceived(Hash peer,
                               String style,
                               long msToReceive,
                               int bytesRead)

      Note that the router received a message from the given peer on the specified transport. Messages received without any "from" information aren't recorded through this metric. If msToReceive is negative, there was no timing information available

    - #### messageSent

          void messageSent(Hash peer,
                           String transport,
                           long msToSend,
                           long bytesSent)

      Note that it took msToSend to send a message of size bytesSent to the peer over the transport. This should only be called if the transport considered the send successful.

    - #### tunnelDataPushed

          void tunnelDataPushed(Hash peer,
                                long rtt,
                                int size)

      Note that we were able to push some data through a tunnel that the peer is participating in (detected after rtt).

    - #### tunnelDataPushed1m

          void tunnelDataPushed1m(Hash peer,
                                  int size)

      Note that the peer is participating in a tunnel that pushed the given amount of data over the last minute.

    - #### tunnelFailed

          void tunnelFailed(Hash peer,
                            int pct)

      Note that the peer participated in a tunnel that failed. Its failure may not have been the peer's fault however.

    - #### tunnelJoined

          void tunnelJoined(Hash peer,
                            long responseTimeMs)

      Note that the router agreed to participate in a tunnel

    - #### tunnelLifetimePushed

          void tunnelLifetimePushed(Hash peer,
                                    long lifetime,
                                    long size)

      Note that we were able to push the given amount of data through a tunnel that the peer is participating in

    - #### tunnelRejected

          void tunnelRejected(Hash peer,
                              long responseTimeMs,
                              int severity)

      Note that a router explicitly rejected joining a tunnel
      Parameters:
        `peer` - who rejected us
        `responseTimeMs` - how long it took to get the rejection
        `severity` - how much the peer doesnt want to participate in the tunnel (large == more severe)

    - #### tunnelTestSucceeded

          void tunnelTestSucceeded(Hash peer,
                                   long responseTimeMs)

      Note that a tunnel that the router is participating in was successfully tested with the given round trip latency

    - #### tunnelTimedOut

          void tunnelTimedOut(Hash peer)

      Note that a router timed out joining a tunnel
      Parameters:
        `peer` - who rejected us