* Expire queued messages even when the writer is blocked.
* Reimplement most of the I2NP writing with less temporary memory
allocations (I2NP reading still gobbles memory).
* Implement an active queue management scheme on the TCP transports,
dropping messages probabalistically as the queue fills up. The
estimated queue capacity is determined by the rate at which messages
have been sent to the peer (averaged at 1, 5, and 60m periods). As
we exceed 1/2 of the estimated capacity, we drop messages throughout
the queue probabalistically with regards to their size. This is based
on RFC 2309's RED, with the minimum threshold set to 1/2 the
estimated connection capacity. We may want to consider using a send
rate and queue size measured across all connections, to deal with our
own local bandwidth saturation, but we'll try the per-con metrics first.
* Enable explicit disabling of the systray entirely for windows machines
with strange configurations: add -Dsystray.disable=true to the java
command line. (thanks mihi!)
* Don't go into a fast busy if an I2PTunnel 'server' is explicitly killed
(thanks mule!)
* Handle some more error conditions regarding abruptly closing sockets
(thanks Jonva!)
* Update the shitlist to reject a peer for an exponentially increasing
period of time (with an upper bounds of an hour).
* Various minor stat and debugging fixes
* Add a new stat logging component to optionally dump the raw stats to
disk as they are generated, rather than rely upon the summarized data.
By default, this is off, but the router property "stat.logFilters" can
be set to a comma delimited list of stats (e.g. "client.sendAckTime")
which will be written to the file "stats.log" (or whatever the property
"stat.logFile" is set to). This can also log profile related stats,
such as "dbResponseTime" or "tunnelTestResponseTime".
* Assure that we quickly fail messages bound for shitlisted peers.
* Address a race on startup where the first peer contacted could hang the
router (thanks Romster!)
* Only whine about an intermittent inability to query the time server once
* Command line utility to verify a peer's reachability - simply run
net.i2p.router.transport.tcp.ConnectionHandler hostname port# and it
will print out whether that peer is reachable or not (using a simple
verification handshake).
2004-09-30 jrandom
* Bundle the configuration necessary to run an eepsite out of the box
with Jetty - simply edit ./eepsite/docroot/index.html and give people
the key listed on the I2PTunnel configuration page, and its up.
* Router console cleanup, and some (off by default) tunnels -
smtp.postman.i2p (port 7659), pop.postman.i2p (port 7660), and
irc.baffled.i2p (port 7661)
* deal with some degenerate situations with identities changing and auto IP detection
* some catch-alls for cleaning up the registry on degenerate tunnels
* lots of logging
* Bundle the configuration necessary to run an eepsite out of the box
with Jetty - simply edit ./eepsite/docroot/index.html and give people
the key listed on the I2PTunnel configuration page, and its up.
plus minor bugfixes / refactoring / logging
- sendsPerFailure: how many partial sends we make when they all fail
- timeoutCongestionInbound: describes how much faster than our average speed we were receiving data when each partial send timed out (in Bps)
- timeoutCongestionMessage: our send processing time when each partial send timed out (in ms)
- timeoutCongestionTunnel: our tunnel test time when each partial send timed out (in ms)
- participatingMessagesProcessedActive: # of messages more than the (most recent) average that a tunnel we were participating in transmitted (for tunnels with more than the average)
* updated to use Writer for rendering the console, so we can do partial writes (and hopefully help debug some kooky threading bugs on kaffe)
- sendsPerFailure: how many partial sends we make when they all fail
- timeoutCongestionInbound: describes how much faster than our average speed we were receiving data when each partial send timed out (in Bps)
- timeoutCongestionMessage: our send processing time when each partial send timed out (in ms)
- timeoutCongestionTunnel: our tunnel test time when each partial send timed out (in ms)
- participatingMessagesProcessedActive: # of messages more than the (most recent) average that a tunnel we were participating in transmitted (for tunnels with more than the average)
* updated to use Writer for rendering the console, so we can do partial writes (and hopefully help debug some kooky threading bugs on kaffe)
* Always wipe the Jetty work directory on startup, so that web updates
are reflected immediately (Jetty does not honor the cache across
multiple executions)
in addition, refactor various file ops out of the DataHelper into FileUtil
got some pretty heavy GC churn when under load. rough estimate is we allocate 5-8x as
much data as we need, copying it all over the place before forwarding it (or processing it).
this should cut down a few of those copies, but not enough yet. it'd be great to get that
down to 2x.
* lots of logging
* Limit the number of connection tags saved to 10,000. This is a huge
limit, but consumes no more than 1MB of RAM. For now, we drop them
randomly after reaching that size, forcing those dropped peers to use
a full DH negotiation.
* HTML cleanup in the console.
