Update the README to reflect recent changes.

Merge branch 'cygwin'

* cygwin:
  Assorted cleanups to Luke's cygwin fixes.
  Makefile: work with cygwin on different windows versions.
  .gitignore sanity.
  Makefile:  On Windows, executable files must end with .exe.
  client.py:  Windows files don't support ':', so rename cachedir.
  index.py:  os.rename() fails on Windows if dstfile already exists.
  Don't try to rename tmpfiles into existing open files.
  helpers.py:  Cygwin doesn't support `hostname -f`, use `hostname`.
  cmd-index.py:  Retry os.open without O_LARGEFILE if not supported.
  Makefile:  Build on Windows under Cygwin.

Assorted cleanups to Luke's cygwin fixes.

There were a few things that weren't quite done how I would have done them,
so I changed the implementation.  Should still work in cygwin, though.

The only actual functional changes are:
 - index.Reader.close() now actually sets m=None rather than just closing it
 - removed the "if rename fails, then unlink first" logic, which is
   seemingly not needed after all.
 - rather than special-casing cygwin to use "hostname" instead of "hostname
   -f", it turns out python has a socket.getfqdn() that does what we want.

Makefile: work with cygwin on different windows versions.

Just check the CYGWIN part; don't depend on the fact that it's NT 5.1.  (Of
course, uname isn't supposed to report such things by default anyway... but
that's cygwin for you.)

Merge branch 'master' of git://github.com/apenwarr/bup

.gitignore sanity.

Makefile:  On Windows, executable files must end with .exe.

client.py:  Windows files don't support ':', so rename cachedir.

Cachedir was previously $host:$dir, and is now $host-$dir.

index.py:  os.rename() fails on Windows if dstfile already exists.

Hence, we perform an os.unlink on the dstfile if os.rename() receives
an OSError exception, and try again.

Don't try to rename tmpfiles into existing open files.

Linux and friends have no problem with this, but Windows doesn't allow
this without some effort, which we can avoid by... not needing to write
to an already-open file.

Give index.Reader a 'close' method which identifies and closes any open
mmaped files, and make cmd-index.py use this before trying to close a
index.Writer instance (which renames a tmpfile into the same file the
Reader has mmaped).

helpers.py:  Cygwin doesn't support `hostname -f`, use `hostname`.

cmd-index.py:  Retry os.open without O_LARGEFILE if not supported.

Python under Cygwin doesn't have os.O_LARGEFILE, so if we receive an
'AttributeError' exception trying to open something, just remove
O_LARGEFILE and try again.

Makefile:  Build on Windows under Cygwin.

- Python modules have to end with .dll instead .so to load into Python
  via 'import'.
- GCC under Windows builds all programs with -fPIC, and doesn't accept
  this command-line option.
- libpython2.5.dll is found in /usr/bin under Cygwin (wtf?), so we need
  to add this to the LDFLAGS path.
- 'make clean' should remove .dll files too.

Oops, 'bup save /' produced an invalid tree.

Add a bunch of assertions to make sure that never happens.

This adds the long-awaited indexfile feature, so you no longer have to feed
your backups through tar.

Okay, 'bup save' is still a bit weak... but it could be much worse.

Merge branch 'indexfile'

* indexfile:
  Minor fix for python 2.4.4 compatibility.
  cmd-save: completely reimplement using the indexfile.
  Moved some reusable index-handling code from cmd-index.py to index.py.
  A bunch of wvtests for the 'bup index' command.
  Start using wvtest.sh for shell-based tests in test-sh.
  cmd-index: default indexfile path is ~/.bup/bupindex, not $PWD/index
  cmd-index: skip merging the index if nothing was written to the new one.
  cmd-index: only update if -u is given; print only given file/dirnames.
  cmd-index: correct reporting of deleted vs. added vs. modified status.
  Generalize the multi-index-walking code.
  cmd-index: indexfiles should start with a well-known header.
  cmd-index: eliminate redundant paths from index update command.
  cmd-index: some handy options.
  index: add --xdev (--one-file-system) option.
  Fix some bugs with indexing '/'
  cmd-index: basic index reader/writer/merger.

Minor fix for python 2.4.4 compatibility.

cmd-save: completely reimplement using the indexfile.

'bup save' no longer walks the filesystem: instead it walks the indexfile
(which is much faster) and doesn't bother opening any files that haven't had
an attribute change, since it can just reuse their sha1 from before.  That
makes it *much* faster in the common case.

Moved some reusable index-handling code from cmd-index.py to index.py.

A bunch of wvtests for the 'bup index' command.

Start using wvtest.sh for shell-based tests in test-sh.

This makes the output a little prettier... at least in the common case where
it passes :)

cmd-index: default indexfile path is ~/.bup/bupindex, not $PWD/index

cmd-index: skip merging the index if nothing was written to the new one.

cmd-index: only update if -u is given; print only given file/dirnames.

cmd-index now does two things:
 - it updates the index with the given names if -u is given
 - it prints the index if -p, -s, or -m are given.

In both cases, if filenames are given, it operates (recursively) on the
given filenames or directories.  If no filenames are given, -u fails (we
don't want to default to /; it's too slow) but -p/s/m just prints the whole
index.

cmd-index: correct reporting of deleted vs. added vs. modified status.

A file with an all-zero sha1 is considered Added instead of Modified, since
it has obviously *never* had a valid sha1.  (A modified file has an old
sha1, but IX_HASHVALID isn't set.)

We also now don't remove old files from the index - for now - so that we can
report old files with a D status.  This might perhaps be useful eventually.

Furthermore, we had a but where reindexing a particular filename would
"sometimes" cause siblings of that file to be marked as deleted.  The
sibling entries should never be updated, because we didn't check them and
thus have no idea of their new status.  This bug was mostly caused by the
silly way we current pass dirnames and filenames around...

Generalize the multi-index-walking code.

Now you can walk through multiple indexes correctly from anywhere, avoiding
the need for merging a huge index just to update a few files.

cmd-index: indexfiles should start with a well-known header.

cmd-index: eliminate redundant paths from index update command.

If someone asks to update "/etc" and "/etc/passwd", the latter is redundant
because it's included in the first.  Don't bother updating the file twice
(and thus causing two index merges, etc).

Ideally we would only do one merge for *any* number of updates (etc /etc and
/var).  This should be possible as long as we sort the entries correctly
(/var/ and then /etc/), since a single sequential indexfile could just have
one appended to the other.  But we don't do that yet.

cmd-index: some handy options.

New options:
--modified: print only files that aren't up to date
--status: prefix printouts with status chars
--fake-valid: mark all entries as up to date
--indexfile: override the default index filename

index: add --xdev (--one-file-system) option.

For not traversing across filesystem boundaries.

Fix some bugs with indexing '/'

cmd-index: basic index reader/writer/merger.

On MacOS X, "wc -l" returns extra whitespace.

ie. "    0" instead of "0".

The easiest workaround is to compare as a number instead of as a string.
This seems to work correctly on both MacOS and Linux.

More compile options for MacOS X.

Based on a patch from Dave Coombs.  I changed it to auto-detect the OS
platform, so I might have broken it, however.

splitting to a remote server would cause "already busy" errors.

Specifically:
client.ClientError: already busy with command 'receive-objects'

That's because recent changes removed the call to onclose() from
PackWriter_Remote.  Now it's back, plus I added an extra unit test to reveal
the problem.

client: enhance the PATH when searching for the 'bup' binary.

Automatically adds the *local* $PWD to the *remote* $PATH before trying to
run 'bup server'.  That way, if you build the source in exactly the same
folder on two machines - or if those two machines are actually the same
machine and you're just doing a test against localhost - it'll work.

I hereby curse both "sh -c <command>" and "ssh hostname -- <command>" for
not allowing a sensible way to just set argv[] without doing any stupid
quoting.  Nasty.

wvtest: coerce non-string arguments when printing.

Much more user-friendly error messages when bup can't exec the server.

...which happens unfortunately often, including in 'make test' when PATH
doesn't include bup.  I'll fix that next.  But it makes sense to fix the
error messages first :)

Add a 'make stupid' target that does 'make test' with a minimal PATH.

Because I'm stupid and I keep forgetting to test what happens if you don't
have 'bup' in your PATH.

Thanks to Dave Coombs and Andy Chong for reporting the problem.  And in
v0.01 too.

Merge remote branch 'remotes/apenwarr-master/master'

split: Prevent memory drain from excessively long shalists.

This avoids huge RAM usage when you're splitting a really huge object, plus
git probably doesn't work too well with single trees that contain millions
of objects anyway.

Split packs around 100M objects or 1G bytes.

This will make pruning much easier later, plus avoids any problems with
packs >= 2GB (not that we've had any of those yet, but...), plus avoids
wasting RAM with an overly full MultiPackIndex.also{} dictionary.

OOPS!  Was writing one byte at a time to the server.

_raw_write() expects a list, not a string, so it was iterating over it
character by character.  Magically it worked anyway.  Which is sort of cool,
and yet not.

Fix compatibility with git 1.5.4.3 (Ubuntu Hardy).

Thanks to Andy Chong for reporting the problem.

Basically it comes down to two things that are missing in that version but
exist in git 1.5.6:

  - git init --bare doesn't work, but git --bare init does.
  - git cat-file --batch doesn't exist in that version.

Unfortunately, the latter problem is pretty serious; bup join is really slow
without it.  I guess it might be time to implement an internal version of
cat-file.

Figure out where Python dynamic libraries live.  Use them, too.

Older git needs 'git --bare init' instead of 'git init --bare'

Needed in at least 1.5.4 (Ubuntu Hardy), but not 1.5.6 (Debian Lenny).

test-sh: don't truncate stderr.

Normally you wouldn't notice this problem, unless you tried to run:

make test >&test.out

and found that it was full of NUL characters.  Oops.

Makefile: avoid using backquotes.

Make now calls python2.5-config.

Fix two bugs reported by dcoombs.

test-sh was assuming 'bup' was on the PATH.  (It wasn't *supposed* to be
assuming that, but the "alias bup=whatever" line wasn't working,
apparently.)

randomgen.c triggered a warning in some versions of gcc about the return
value of write() being ignored.  It really doesn't bother me if some of my
random bytes don't get written, but whatever; I'll assert instead, which
should shut it up.

Add a README for v0.01.

Force generated pack indexes to be version 2.

We don't support parsing earlier versions, and the earlier versions are
inferior anyway.

Rewrite bup-join in python and add remote server support.

We can now update refs when we do a backup.

Supported by both cmd-save and cmd-split, albeit with a disturbing amount of
code duplication.

Also updated bup-join to use a default BUP_DIR if none is specified.

Refactored client stuff into client.py; now cmd-save and cmd-init use it too.

Still not updating refs, however, so it remains a bit stupid.

Fix some problems running on older Debian.

python 2.5 (pre-2.5.2) can't struct.unpack from a buffer(); coerce it to a
string first.

The default python is 2.4, so run /usr/bin/python2.5 explicitly.

Support incremental backups to a remote server.

We now cache the server's packfile indexes locally, so we know which objects
he does and doesn't have.  That way we can send him a packfile with only the
ones he's missing.

cmd-split supports this now, but cmd-save still doesn't support remote
servers.

The -n option (set a ref correctly) doesn't work yet either.

Extremely basic 'bup server' support.

It's enough to send a pack to the remote end with 'bup split', though 'bup
save' doesn't support it yet, and we're not smart enough to do incremental
backups, which means we generate the gigantic pack every single time.

bup save: handle symlinks correctly.

ie. save symlinks as symlinks, don't blindly recurse into them.

Also, directory names in trees need to be sorted as if they were "name/",
not "name".  Otherwise git fsck complains.

Improved 'make test' to check 'git fsck' output and to actually run bup
save.

cmd-join didn't honour $BUP_DIR.

Add 'bup init' command.

Basically an alias for git init, but uses BUP_DIR instead of GIT_DIR
environment variable.

Moved some git.* globals into PackWriter; use BUP_DIR as repo path.

If BUP_DIR isn't set, it defaults to ./.git, which is probably not so smart,
but works for now (and was what we were using *until* now anyway).

Name temp files from 'make test' as *.tmp to make them easier to clean.

Better behaviour with --verbose.

Also added --verbose to cmd-save.

Use binary sha1 instead of hex sha1 whenever possible.

'make test' now tests the -t and -c options of bup split.

git.PackIndex: a class for quickly searching a git packfile index.

This will allow us to generate incremental backups more efficiently, since
we can avoid rewriting already-known objects into a new pack.

Write git pack files instead of loose object files.

This causes much, much less disk grinding than creating zillions of files,
plus it's even more disk space efficient.

We could theoretically make it go even faster by generating the .idx file
ourselves, but for now, we just call "git index-pack" to do it.  That
helpfully also confirms that the data was written in a git-compatible way.

bup split: print extra output to stderr if -v or -vv is given.

'bup split': speed optimization for never-ending blocks.

For blocks which never got split (eg. huge endless streams of zeroes) we
would constantly scan and re-scan the same sub-blocks, making things go
really slowly.  In such a bad situation, there's no point in being so careful;
just dump the *entire* input buffer to a chunk and move on.  This vastly
speeds up splitting of files with lots of blank space in them, eg.
VirtualBox images.

Also add a cache for git.hash_raw() so it doesn't have to stat() the same
blob files over and over if the same blocks (especially zeroes) occur more
than once.

Fix 'bup split --bench'.

This was broken earlier and apparently didn't have a test; now it does.

Fix generated commit messages.

The first (summary) line should be shorter so that git log looks prettier.

'bup save' now generates a hierarchical set of git trees as it should.

Initial version of 'bup save'.

Saves a complete tree by recursively iterating into subdirs, and splits
large files into chunks using the same algorithm as 'bup split'.

Currently no support for special files (symlinks etc), and it generates the
resulting git tree incorrectly (by just turning / into _ in filenames).

'bup join' now takes objects on the command line and handles commitids.

It converts commitids directly into trees and cats the entire tree
recursively.

If no ids are provided on the command line, it reverts back to reading the
list of objects from stdin.

Refactor splitting functions from cmd-split.py into hashsplit.py.

Now we can split other stuff from other programs (which don't exist yet).

Oops, multi-file split forced a split between each file.

Now if you have multiple files on input, it's possible for a single
resulting blob to contain parts of more than one file.

split: name chunkfiles more carefully to prevent name changes.

This isn't perfect, but a bit of byte jitter here and there now won't cause
unnecessary filename changes.

'bup split' takes a list of filenames on the command line.

'bup split' now outputs any combination of blobs, tree, and commit.

maximum flexibility.

'bup split' can now update a git ref if you give it the -n option.

Automatically handle "--no-" prefix on long options.

Similar to how git does it.

'bup split' now has a -c option to generate a git commit object.

There's no way to set its parent yet, but at least this is all you need if
you want to repack.

Completely revamped option parsing based on git-shell-style.

This is in options.py.  Also added some wvtests for option parsing stuff.

Import wvtestrun and wvtest.py from the wvtest.git project.

Corresponding wvtest commit is db65ff5907571a5004bb3c500efd19421cb06d1a.

Rename datagen.c to randomgen.c, to better reflect its purpose.

Add a '-t' option to 'bup split' and make 'bup join' support it.

This lets you generate a git "tree" object with the list of hashes in a
particular file, so you can treat the file as a directory as far as git is
concerned.  And 'bup join' knows how to take a tree and concatenate it
together to reverse the operation.

Also refactored a bunch of stuff in cmd-split.py.

Get rid of extra CFLAGS/LDFLAGS that I don't understand anyway.

I just copied them from some other python module.  But it's better to keep
things simple, I think.

Add a 'bup' wrapper program.

We're going to use that with some subcommands, git-style.

Remove old hashsplit.c, since hashsplit.py replaces it.

Do less work for objects that occur more than once.

Clean up buffering to reduce number of buffer copies.

Slight performance improvement, but not inspirational.

Use t# instead of et# for hashsplit parameter type.

This lets us work with any kind of buffer object, which means there's no
unnecessary data copying when coming into our module.  Causes a bit of
speedup.

Also refactored the checksum code for easier experimentation.

Hey wow, turning on -O2 gives about a 50% speedup.

Add a C module to do the rolling checksum.

This is about 80x faster than the old speed (27megs/sec instead of 330k/sec)
but still quite a lot slower than the 60+megs/sec I get *without* the
checksum stuff.  There are a few inefficiencies remaining, but not such easy
ones as before...

hashsplit.py: print performance timings to stderr on exit.

datagen.c: a quick program to generate a repeatable series of bytes.

Useful for testing.  Note that we *don't* see the random number generator,
so every time you generate the bytes, you get the same sequence.

This is also vastly faster than /dev/urandom, since it doesn't try to be
cryptographically secure.  It generates about 200 megs/sec on my computer,
which is much faster than a disk and thus useful for testing the speed of
hashsplit.

hashsplit.py: less excessive logging, more suitable for speed tests.

Result of speed tests: it's slow.  Almost entirely because of how slow
splitbuf() is in python (which is no surprise at all).

hashsplit.py: create blob objects by hand, not with 'git hash-object'

Much quicker this way, since we never need to fork anything.

hashsplit.py is now much, much faster than before.

4.8 secs vs. 0.8 secs for testfile1.

Still vastly slower than the C version (0.17 secs including time to fork
git for each blob) but still a significant improvement.

The remaining slowness seems to be entirely from:

- running git hash-object (which we can avoid by hashing the object
  ourselves)

- running the rolling checksum algorithm (which we can speed up using a C
  module)

So it's looking good.

hashsplit.py: a python version of hashsplit.c

It's slow.  Very slow.  But hopefully it won't be too hard to optimize.