util: move PollMixin to a separate file (pollmixin.py), so testutil can be moved into test/

control.py: removed unused testutil.PollMixin

web/filenode: oops, fix test failures, not everything has a storage index

web/filenode: add Accept-Ranges and ETag (for immutable files) headers to GET responses

#527: respond to GETs with early ranges quickly, without waiting for the whole file to download. Fixes the alacrity problems with the earlier code. Still needs cache expiration.

#527: support HTTP 'Range:' requests, using a cachefile. Adds filenode.read(consumer, offset, size) method. Still needs: cache expiration, reduced alacrity.

iputil.py: avoid a DNS lookup at startup (which may timeout tests when run on a partially-offline host) by using 198.41.0.4 instead of A.ROOT-SERVERS.NET

interfaces.py: promote immutable.encode.NotEnoughSharesError.. it isn't just for immutable files any more

interfaces.IMutableFileNode.download_best_version(): fix return value

dirnode lookup: use distinct NoSuchChildError instead of the generic KeyError when a child can't be found

storage: don't use colons in the corruption-advisory filename, since windows can't tolerate them

mutable: call remove_advise_corrupt_share when we see share corruption in mapupdate/download/check, tolerate servers that do not implement it

storage: add remote_advise_corrupt_share, for clients to tell storage servers about share corruption that they've discovered. The server logs the report.

mutable/servermap.py: fix needs_merge(), it was incorrectly claiming that mixed shares with distinct seqnums needed a merge, causing repair(force=False) to fail

test_web.test_POST_DIRURL_deepcheck: confirm that /operations/HANDLE/ works with or without the slash

web/checker_results.py: remove dead code

test_web: more test coverage

webapi: fix t=rename from==to, it used to delete the file

test_system: update test to match web checker results

webapi deep-check: show the root as <root>, rather than an empty path string

mutable/checker: announce the mapupdate op on the 'recent uploads+downloads' page

scripts/create_node.py: remove empty-string defaults for --introducer= and --nickname=

deep-check: add webapi links to detailed per-file/dir results

interface.py: fix typo

webapi: make the /operations/ 't=status' qualifier optional, remove it from examples

setup: require the latest version of the setuptools bootstrap egg

setup: include _pkgutil.py in setuptools bootstrap egg so that it will work on Python 2.4

setup: pretend the tahoe requires twisted to set up, so that twisted will be there for nevow

setup: require the SVN snapshot of setuptools to build

setup: remove old bundled setuptools-0.6c9

setup: bundle an SVN snapshot of setuptools instead of the most recent stable release of setuptools
This SVN snapshot fixes a problem that prevents the setting up of nevow:
http://bugs.python.org/setuptools/issue20

setup: reorder dependencies to be sort of increasing order of how much they depend on other stuff
Not that the order makes any different to how it gets installed, as far as I can tell.

docs: add a note that when you make a new tahoe release, you should send the announcement to fuse-devel@lists.sourceforge.net

web/info.py: fix 'Check This Object' link, for files it was checking the parent directory by mistake

#514: add meta-refresh=60 tag to t=status page for incomplete operations

test_dirnode.py: oops, missed a Monitor(), unbreak tests

immutable/filenode.py: add TODO note about the #514 monitor to check(), rather than going through the checker/verifier code and adding it, since Zooko is currently working on that code

more #514: pass a Monitor to all checker operations, make mutable-checker honor the cancel flag

dirnode.py: check for cancel during deep-traverse operations, and don't initiate any new ones if we've been cancelled. Gets us closer to #514.

more #514 log-webop status/cancel: add handle-expiration, test coverage

webapi.txt: improve t=deep-size output docs

#514: improve test coverage

Change deep-size/stats/check/manifest to a start+poll model instead of a single long-running synchronous operation. No cancel or handle-expiration yet. #514.

setup: change ez_setup.py to install setuptools-0.6c9

setup: bundle setuptools-0.6c9

setup: remove bundled setuptools-0.6c8

setup: remove the developer note about doing without GNU make (the GNU make requirement is about to hurt Peter if he tries to follow this doc, by the way)
add classifiers showing with which versions of Python it is known to work.

* fuse/runtests: added --catch-up-pause option

On linux, write tests are failing because data written to fuse isn't showing
up in tahoe by the time it's checked.  it's not clear where this is originating,
since the fuse implementation [should be] waiting for completion of tahoe
operations before returning from its calls.  This adds an option to control the
duration of a pause between the fuse write and the check of tahoe, which is by
default set to 2s on linux, which - somewhat inexplicably - seems to 'fix' the
problem, in as far as it allows tests to complete.

fuse/runtests: include length in drepr() output

fuse/runtests: make exceptions in 'read_in_random_order' into TestFailures

fuse/blackmatch: added asynchronous (background) file download

previously, upon opening a file for reading, the open() call would block
while the entire file was retrieved from tahoe into the cache directory.
This change adds a DownloaderWithReadQueue class, and associated plumbing,
such that an open() will return promptly with the download initiated 'in
the background'.  Subsequent read() operations will block until enough
data has been downloaded to satisfy that request.  This provides a behaviour
similar to streaming, i.e. the client application will be able to read
data from the fuse interface while the remainder of the file is still being
downloaded.

fuse/runtests: added 'read_in_random_order' test

this test uploads a test file to tahoe, and then reads the file from fuse,
but reads the blocks of the file in a random order; this is designed to
exercise the asynchronous download feature of blackmatch - where the file
is downloaded from tahoe asynchronously, and rather than blocking open()
for the entirety of the download, instead individual read() calls are
blocked until enough of the file has been downloaded to satisfy them

fuse/runtests: added a --no-cleanup option

the code had a 'fullcleanup' flag internally which controlled whether
working directories were cleaned up.  this promotes that to a command
line option (negated) '--no-cleanup' defaulting to False, i.e. do cleanup

fuse/runtests: truncate expected file contents in reported error message

this avoids dumping the repr of 1Mb of random data to stdout in the event
of a test failure, but rather just dumps the start/end of the errant strings
if the amount of data is > 200 chars repr'd

fuse/blackmatch: fix platform specific problems in repr_flags

the repr_flags debug/logging function had a list of fields from the os
module that might be passed into an open() call, but it included at
least one which was available on the mac but not on linux. symmetrically
linux has numerous flags which are not present on the mac. the repr_flags
function is now tolerant of flags not being present, and has an expanded
list of flags

makefile: added 'fuse-test' target to makefile, to run 'runtests'

fuse/runtests: added a 'todo' flag, surpressing failure for implementations not expected to pass

since the current tests assume that the implementation responds to changes made
to tahoe after mount, and impl_b prefetches and cached directory data, impl_b
fails the current 'read' test suite.

rather than reflect that problem in the overall failure of the runtests exit
code, this adds a 'todo' flag to the implementations table, and sets the todo
flag for impl_b.  Thus errors will therein be reported in output, but not cause
a failing exit code.

fuse/runtests: made runtests exit code depend on success

return an exit code of 0 only if no tests failed, and 1 in the case of
linkage error, test setup failure, or individual test case failure

storage.py: assert that immutable share size will fit in the 4-byte v1 container (see #346). The struct module in py2.4 raises an error on overflow, but py2.5 merely emits a warning

NEWS: update to summarize all changes since the last update

fuse/runtest: make removal of webport file soft

previously the runtests suite removed the webport file created by
tahoe create-client in all but the first node.  now that the node config
is in tahoe.cfg by default this file might not exist.

fuse/blackmatch: update json handling to support simplejson v2

simplejson v2 returns strings as either unicode or str, depending upon its
mood.  thus the interpretation of the node's json repr of a directory, and
the serialisation of strings in the json based rpc both exploded when built
against simplejson v2.  this makes both of these places liberal in their
acceptance of either str or unicode.

fuse/blackmatch: log exception in server startup

humphf.  my build runs the fuse stuff fine, but the build from the buildslave
doesn't seem to start up properly.  hopefully this will elicit some useful info

fuse/blackmatch: add readability to some logging, fix a permissions problem

adds a couple of functions to unpack 'mode' and 'flags' for open() calls, to
facilitate debugging.

adds a fix to ensure that all tmp files created for writing are opened with
permissions 0600 - one problem I had with testing with the Finder was that
files were being opened write only (0200) and were then failing to upload
to tahoe due to internal permission denied errors.

there remain a variety of problems with finder access which I'm unable to
comprehend at this time.  sometimes copies to tahoe will work fine, sometimes
they yield "the finder cannot complete the operation because some data ...
could not be read or written. (Error code -36)" sometimes "You may need to
enter the name and password for an administrator on this computer to change
the item" sometimes "The operation cannot be completed because an item with
the name ... already exists." and sometimes "The operation cannot be completed
because the item ... is locked."  What seems to be absent is rhyme or reason.

unix operations (cp, mv) work fine, rsync works fine.

fuse/blackmatch: fix linkage problems with daemonize

the daemonize() function imported from twisted was causing problems when
run from a frozen (py2app) build.  I simply copied the daemonize function
into this file, and that fixes the problem.

also removed a couple of lines of debugging spam that slipped through.

gui/macapp: minor bugfixes

though it seemed to work before the 'fstype' passed to fuse of 'allmydata' was
today throwing errors that len(fstype) must be at most 7.

fixed a typo in changes to 'mount_filesystem()' args

bumped the delay between mounting a filesystem and 'open'ing it in Finder to
4s, as it seems to take a little longer to mount now the client and server
fuse processes need to coordinate.

fuse/blackmatch: split into client/server (twisted server)

This implements a client/server split for blackmatch, where the client
implements the fuse_main bindings and a simple blocking rpc client mechanism.
The server implements the other half of that rpc mechanism, and contains all
the actual logic for interpreting fuse requests in the context of the on disk
cache and requests to the tahoe node.  The server is based on a twisted reactor.

The rpc mechanism implements a simple method dispatch including marshalling,
using json, of basic inert data types, in a flat namespace (no objects).
The client side is written in a blocking idiom, to interface with the threading
model used by the fuse_main bindings, whereas the server side is written for a
twisted reactor-based environment, intended to facilitate implementing more
sophisticated logic in that paradigm.  The two communicate over a unix domain
socket, allocated within the nodedir.

Command line usage is unchanged; the server is launched automatically by the
client. The server daemonizes itself, to avoid preventing the original parent
process (e.g. 'runtests') from waiting upon the server exiting.

The client keeps open a 'keepalive' connection to the server; upon loss thereof
the server will exit. This addresses the fact that the python-fuse bindings
provide no notification of exit of the client process upon unmount.

The client thus provides a relatively thin 'shim' proxying requests from the
fuse_main bindings across the rpc to the server process, which handles the
logic behind each request.

For the time being, a '--no-split' option is provided to surpress the splitting
into client/server, yielding the prior behaviour.  Once the server logic gets
more complex and more entrenched in a twisted idiom, this might be removed.
The 'runtests' test harness currently tests both modes, as 'impl_c' and
'impl_c_no_split'

fuse/blackmatch: 'flatten' the fuse api implementation

the previous revision of blackmatch used a file_class to delegate all fuse
api operations on files to a specific per-file class, which is an option
given by the python-fuse bindings.

this is a pre-cursor to the 'split' client/server version, which uses a
simple, moreover flat, rpc mechanism to broker access to methods.

fuse/runtests: disable impl_a/impl_b on mac, as they don't actually work.

fuse/runtests: added write_partial_overwrite test

this tests opening a file for update, overwriting a small part of it, and
ensuring that the end result constitutes an overwrite of the original file.
This tests, e.g. the implementation doesn' open a 'fresh' file but does in
fact initialise the file to be uploaded with the contents of any extant
file before applying updates

fuse/runtests: added --tests, renamed --suites

changed the --tests option to be --suites, as it takes a prefix, e.g. 'read'
'write' (or 'all', the default) and runs those suites which are applicable to
each implementation being tested.

added a --tests option, which takes a list of tests, e.g. 'read_file_contents'
'write_overlapping_large_writes' and runs all tests specified without regard
to whether the implementation(s) under test are declared to support them.

this is basically to allow a specific test or two to be run, saving time
during development and debugging by not running the entire suite

fuse/runtests: added 'random scatter' write test

this writes the test file in a randomised order, with randomly sized writes.
also for each 'slice' of the file written, a randomly chosen overlapping
write is also made to the file.  this ensures that the file will be written
in its entirety in a thoroughly random order, with many overlapping writes.

fuse/runtests: add overlapping write tests

using both small and large blocksizes for writes, write a 1Mb file to fuse
where every write overlaps another.

This serves a useful purpose - in manual testing of blackmatch some time ago
most operations e.g. bulk copies, worked fine, but using rsync caused data
corruption on most files.  it turned out to be that rsync writes in 64K blocks,
but rather than making the last block short, the last block instead overlaps
the preceding (already written) block.  This revealed a problem where cache
files were being opened 'append' rather than 'write' and hence the overlapping
write to the fuse layer caused the overlapping portion of the file to be
duplicated in cache, leading to oversized and corrupt files being uploaded.

fuse/runtests: remove write small file test, as it's subsumed by the tiny_file test

fuse/runtests: added linear write tests for various block sizes

unit tests to test writing contiguous blocks linearly through the file,
for a variety of block sizes;  'tiny_file' is an entire file fitting within
a single io block / write operation.  'linear_{small,large}_writes' test
a 1Mb file written with each write operation containing significantly less
or more, respecitvely, data than fuse will pass into the implementation as
a single operation (which on the mac at least is 64Kib)

fuse/runtests: add a very simple 'write' test

this performs a very simple write through the fuse layer and confirms that
the file is stored correctly into the tahoe mesh.  ('simple' in the sense
that the entire file body fits trivially in a single write() operation,
disk block etc)

fuse/runtests: added a --web-open option

similar to the --debug-wait option which causes the test harness to
pause at various stages of the process to facilitate debugging, this
option simplifies that debugging by automatically opening a web browser
to the root dir of that implementation's tests when tests are commenced.

in addition, if --web-open is specfied but --debug-wait is not, the
harness will still pause after running tests but before tearing down
the tahoe grid - this allows all tests to run to completion, but
provide a debugging hook to investigate the end state of the grid's
contents thereafter.

fuse/impl_a: fix a suspected bug in caching

from my examination of the tahoe_fuse ('impl_a') code, it looks like
the intention is to cache the file contents in memory while it's open,
since it does in fact do that.  however it looks like it also ignored
that cache entirely, and made an individual tahoe webapi GET request
for each and every read() operation regardless of the relative size of
the read block and the file in question.

this changes that to make read() use the data in memory rather than
fetch the data over again.   if there's something more subtle going
on, please let me know.

gui/macapp: slew of code cleanup; unmount filesystems on quit

a handful of code cleanup, renaming and refactoring.  basically consolidating
'application logic' (mount/unmount fs) into the 'MacGuiApp' class (the wx.App)
and cleaning up various scoping things around that.  renamed all references to
'app' to refer more clearly to the 'AppContainer' or to the guiapp.

globally renamed basedir -> nodedir

also made the guiapp keep a note of each filesystem it mounts, and unmount
them upon 'quit' so as to cleanup the user's environment before the tahoe node
vanishes from out underneath the orphaned tahoe fuse processes

gui/macapp: make submenu of aliases for 'webopen'

this changes the 'open webroot' menu item to be a submenu listing all aliases
defined in ~/.tahoe.  Note that the dock menu does not support submenus, so it
only offers a single 'open webroot' option for the default tahoe: alias.

I had trouble with this at first and concluded that the submenus didn't work,
and made it a distinct 'WebUI' menu in it's own right.  on further inspection,
there are still problems but they seem to be something like once the dock menu
has been used, sometimes the app's main menubar menus will cease to function,
and this happens regardless of whether submenus or plain simple menus are used.
I have no idea what the peoblem is, but it's not submenu specific.

repairer: fix flaw in testutil.flip_one_bit() that Brian pointed out

misc/incident-gatherer: add classify_tahoe.py: a foolscap incident-gatherer classification plugin

repairer: test all different kinds of corruption that can happen to share files on disk

util/time_format.py: accept space separator, add unit tests

test_storage: use different filenames, poor stupid windows

scripts/debug.py: emit the immutable-share version number, tolerate v2

storage.py: improve some precondition() error messages

storage: introduce v2 immutable shares, with 8-byte offsets fields, to remove two of the three size limitations in #346. This code handles v2 shares but does not generate them. We'll make a release with this v2-tolerance, wait a while, then make a second release that actually generates v2 shares, to avoid compatibility problems.

debug.py: oops, add missing import for ReadBucketProxy

storage: split WriteBucketProxy and ReadBucketProxy out into immutable/layout.py . No behavioral changes.

interfaces: loosen a few max-size constraints which would limit us to a mere 1.09 TB maximum file size

These constraints were originally intended to protect against attacks on the
storage server protocol layer which exhaust memory in the peer.  However,
defending against that sort of DoS is hard -- probably it isn't completely
achieved -- and it costs development time to think about it, and it sometimes
imposes limits on legitimate users which we don't necessarily want to impose.
So, for now we forget about limiting the amount of RAM that a foolscap peer can
cause you to start using.

util/limiter: add a repr

dirnode.build_manifest: include node.list in the limiter, that's the most important thing to slow down

web/directory: t=manifest output=html: make the caps into clickable hrefs

web/directory: factor out the get_root function

web/directory.py: remove unused imports

test_web: deep-size is more variable than I thought, so assert less

web: change t=manifest to return a list of (path,read/writecap) tuples, instead of a list of verifycaps. Add output=html,text,json.

web: rewrite t=deep-size in terms of deep-stats, update test to match inclusion of directory sizes

ftpd: hush pyflakes