Initial support for filtering TAR files through an external program.

At the moment this is hard-coded to pipe data through "bzip2 -c", but
this should be made flexible later.

Track which objects are used in which snapshots in the local database.

Debugging message cleanup.

Initial cut at re-using objects from old segments when contents match.

Keep an index of old stored blocks, using sqlite3.

Link sqlite3 in with the snapshot program, and start to write a wrapper
around a "local database" which tracks previously-backed-up data to make
incremental backups possible.

At the moment, blocks are indexed as they are stored, but we never read
from the index, so blocks are not yet reused.

Start writing up some design notes for LBS.

Try to explain the rationale for the chosen design, and explain some of the
other designs that were considered and rejected.

Ensure filesize written to metadata log matches number of bytes dumped.

Various minor tweaks to the metadata format.

Use a timestamp in generating the descriptor filename.

Also include the timestamp (in a more readable format) in the descriptor
file itself.

Disable debugging output for the reference restore program.

Most of the debugging can be turned on by setting $VERBOSE = 1;

Actually recreate files in the snapshot.

With this change, the prototype restore tool is essentially functional.
Special files are still not properly handled, and there are a few other
limitations, but for the most part it all works.

Add in decoding (URI-style, %xx) of filenames to reference decoder.

Continue work on reference decoder.

  - Add code to parse metadata sections (including following indirect
    pointers).
  - Add code to parse data block listings (including indirect pointers).
  - Verify checksums on all files.

Primarily left: actually write restored file contents out to the
filesystem.

Begin work on a reference decoder for backups.

The intent is that the reference decoder will eventually be a tool for
recovery, if need, before a better tool is written.  It should also help to
verify the format specification and backup tool.

The reference decoder can currently parse a single object reference and
extract the data for it.

Write backup descriptor to a file, not stdout.

The backup descriptor names the object at the root of the snapshot, and
lists all the segments needed.  The filename used is currently fixed,
though, and should later be based on the current time.

Clean up error reporting.

Use larger metadata blocks, and don't output type field twice.

Debugging output cleanup.

Allow metadata to be written incrementally.

Remove checksums and reference tracking; I think they are not needed.

A few minor adjustments to the ObjectReference interface.

Add a new object-oriented wrapper for building object references.

Miscellaneous changes.

  - Disable profiling output for now.  It can be turned on again later.
  - Allow destination directory for backup files to be specified on the
    command-line (but we should add proper command-line parsing later).
  - More work to track inter-object references, but not yet finished.

Start work on a more object-oriented interface for creating objects.

Rename tarstore -> store, since it is the only implementation now.

Remove old store implementation.

Partial support for tracker inter-object references.

Add indrect objects for listing contents of large files.

Remove code using old segment writer.

All writes should now happen to TAR-format segments, and data should be
serialized as text.

Automatically split segments to meet size targets.

Add URI-style escaping of filename characters.

Remove early test code for the tarfile storage backend.

Reduce debugging output.

Add checksums to tarstore, and partially migrate to using it for storage.

Each tarfile segment gets a file called "checksums" now which contains
SHA-1 hashes of all objects contained in it.  There is currently no
checksum computed for the checksum file itself.

Begin migrating scandir to using the tar-based storage for backups.
Backups in the old format are still written, and there is still some
other cleanup to be done, but most of the raw data is currently handled.

Begin work on an alternate object store mechanism using the TAR format.

Each segment is placed in a separate file, and each object is a file stored
within that TAR archive.  libtar is used to write (and perhaps later read)
tar files.

Tag objects with a 4-byte type code.

Return the names for allocated objects, and link file metaata to data.

Extend the interface for the new_object methods so that they can return the
segment UUID and object index for created objects.  Then, use this to write
out links from the file metadata to the data blocks making up the file, via
an indirect block.

Support for spreading objects across segments.

New segments are created automatically whenever an old segment becomes too
large (current limit is set at something over 1 MB, but this could be
adjusted).

Append checksums to segments to allow some verification.

Add new interface for creating new segments.

Initial support for objects encapsulated into segments.

Some Makefile improvements:
  - (Mostly) automatic header dependency tracking.
  - Use pkg-config to pull in dependencies for libuuid.

Improve comments, and track number of bytes written to a stream.

Compute SHA-1 checksums of regular files to be stored with index data.

Clean up output while scanning directories.

Extend basic support for serializing simple data types.

Add support for serializing integers, strings, and dictionaries.  Then,
extend the directory scanner to output a summary of stat information for
each file/directory.

Fill in a couple more details about a proposed file format.

Begin work to document a proposed file format for backups.

Add support for reading symlinks.

Read contents of all regular files processed.

More work on descending directory structure.

Improvements:
  - Directory listings are processed in sorted order.
  - Open regular files, but be very paranoid in doing so (try to avoid
    danger from race conditions).

Build with support for large files enabled.

Initial commit