* Refactor the TCP transport to deal with changing identities gracefully,
and to prevent some wasted effort by keeping track of what host+port
combinations we are connected to (rather than just the identities). Also
catch a few configuration errors earlier.
* Removed no longer relevent methods from the Transport API that were
exposing ideas that probably shouldn't be exposed.
* Removed the 0.4.0.1 specific files from i2pupdate.zip (relating to script
updates)
* Update for the SDK reconnection to deal with overflow.
* Web improvements (@ not # on the /logs.jsp [thanks ugha!] and fixed the
rounding on lifetime bandwidth used [thanks gott!]).
2004-09-08 jrandom
* Updated the "Active:" peer count to display the # of connections as well
as the number of recently active router identities.
* Implement some basic updating code - on startup, if there is a file named
"i2pupdate.zip" in the I2P installation directory, extract it, delete it,
then restart.
* Added an ugly little script to allow launching the router on win9x
machines without a dos box (using javaw to run a .bat file).
* Logging updates.
* Updated VERSION constants to 0.4.0.1
hopefully any other affected *nix systems) now properly discards non-
essential directories after installation.
* Support for Win9x in the installer and postinstall.bat.
* Changed the name of the default installation directory on all platforms
from "I2P" to "i2p" in the installer.
* Changed "wrapper.conf" to "wrapper.config" for naming consistency with the
other configuration files.
* Make sure that peers placed in the 'fast' group are ones we both know
how to reach and have been able to reach recently. These peers may
still be placed in the 'high capacity' group however (though that group
is only queried if the 'fast' group is too small)
* Include some updates to the ProgileOrganizer's CLI.
* Disable the timestamper by default for all applications except the router
(enable via -Dtime.disabled=false)
* Simplify the retrieval of the full destination with text based browsers.
* Bundle the updated wrapper.config and hosts.txt in the i2pupdate.tar.bz2
* Write the native libraries to the current directory when they are loaded
from a resource, and load them from that file on subsequent runs (in
turn, we no longer *cough* delete the running libraries...)
* Added support for a graceful restart.
* Added new pseudo-shutdown hook specific to the router, allowing
applications to request tasks to be run when the router shuts down. We
use this for integration with the service manager, since otherwise a
graceful shutdown would cause a timeout, followed by a forced hard
shutdown.
* Handle a bug in the SimpleTimer with requeued tasks.
* Made the capacity calculator a bit more dynamic by not outright ignoring
the otherwise valid capacity data for a period with a single rejected
tunnel (except for the 10 minute period). In addition, peers with an
equal capacity are ordered by speed rather than by their hashes.
* Cleaned up the SimpleTimer, addressing some threading and synchronization
issues.
* When an I2PTunnel client or httpclient is explicitly closed, destroy the
associated session (unless there are other clients using it), and deal
with a closed session when starting a new I2PTunnel instance.
* Refactoring and logging.
* Address a race condition in the key management code that would manifest
itself as a corrupt router identity.
* Properly clear old transport addresses from being displayed on the old
console after soft restarts.
* Properly refuse to load the client applications more than once in the
same JVM.
* Added support for a graceful restart (a graceful shutdown followed by a
full JVM restart - useful for restarting client apps).
* More defensive programming, HTML cleanup, logging
* wrapper.config cleanup of duplicate lines
* Added some basic guards to prevent multiple instances from running.
Specifically, a file "router.ping" in the install directory which is
written to once a minute - if that file exists and has been modified
within the last minute, refuse to start up. In turn, adjust the
service wrapper to wait a minute before restarting a crashed JVM.
* Create a "work" directory in the I2P install dir which Jetty will
use for all of its temporary files.
* Tell the browser not to cache most of the router console's pages.
* Updated default wrapper.config to deal with the hard restart option
* Include the history.txt in the /help.jsp page
* HTML updates (wrapper.log, and no more unix scripts)
* Updated VERSION constants to 0.4
* Added some filters to the HTTP request, replacing the User-Agent,
Referrer, Via, and From headers, which helps until we have a more
comprehensive filtering system.
2004-09-03 jrandom
* Disabled the old listener on port 7655.
* Cleaned up the base build.xml, adding a new target ("updater") which
builds the file i2pupdate.tar.bz2 which can be safely extracted over
existing installs.
this may have unintended consequences, as we need to deal with messages received from skewed clocks, but I believe the two pathways
used here are safe (we leave the larger timeout thresholds intact for dealing with remotely generated message times)
* revert some of the overly zealous peer distribution code - select randomly from the fast peers, not according to a strict LRU
(which was causing lots of queued up tunnel requests, as well as tunnel failures when they all failed)
need to think some more thunks about how to address this right now. a few different algorithms available
to deal with different scenarios and #s of users, but nothing that by itself strikes me as 'ideal', yet. perhaps its
time for another trip to the pub to see what inspiration can be found there ;)
* removed all of the "temporary" threads used for adding timeouts to blocking socket operations:
- use the ConnectionEstablisher's thread + a SimpleTimer.TimedEvent callback to timeout socket create
- added a pool of socket handler threads (size=3 atm) for receiving any inbound sockets, which are
pulled off a queue, after which a handshake occurs to verify the other side is I2NP (along side
another SimpleTimer.TimedEvent callback in case that blocks)
this should get the last of the temporary threads (Jetty has its own thread pool for dealing with
HTTP requests, so we can ignore that thread created in the AdminRunner). The only significant
reduction in threads left is to go with either NIO or UDP, but neither are happening in the immediate
future.
* use that to render the last few lines of the wrapper log on /logs.jsp (for the on demand stack trace)
* thread creation / finalization logging
* support a hard restart (stop immediately and restart the JVM) - useful for rerunning clients.config (etc)
* systray when not supported
* new safer way of shutting down the router per discussions with oOo (dealing with a graceful
shutdown where the user updates their config before the shutdown is complete, etc)
* graceful shutdown implemented in the router - shutdownGracefully(), cancelGracefulShutdown(), shutdownInProgress()
into account various skew situations and the capacity growth constant with
the intent of producing a higher quality threshold whenever possible
* increased the minimum # of fast peers from 4 to 8 (yay), which means we'll
try to have at least some peers to choose from
* added a new router config option - "router.maxParticipatingTunnels". This is
useful for gracefully shutting down the router (aka set it to 0 and wait until
the router is no longer participating in tunnels, then shutdown). You can
probably also come up with other situations where this is useful, but I don't
want to spoil all the fun ;)
reading the router's props only if that file doesn't exist.
* by default, only log CRIT messages to the screen (the rest are sent to
the log file). this will be useful with the upcoming service controller
* refactor a common Properties helper to DataHelper.loadProps
much of our tunnel failure detection code itself uses tunnels - send out tunnel 1
and get the reply through tunnel 2. If it fails, which one "broke"?
* we now add a failure mark to both in all situations, including during tunnel
creation
* properly check the tunnel expiration 2-2.5 minutes prior to completion, rather
than the old 0.5-1.5 minutes.
requests which are notified on completion
* query peers who are sending us bad references, just don't follow their suggestions.
this is necessary since the peer may actually have the data (and other people may not be
getting shitty references from them)
