add function to easily get the extension used for indexes

Ignore files created by setup.sh

adding some missing debug lines

adding setup files to create an rpm for python-delta-tar

removing unused vars

derefering backed up files for now

missing change from string to bytes join

adding support for adding extra data to deltatar indexes

Test compatible with tar 1.22 (intranator version)

Using python3 instead of python in tests system calls

adding header and move to python 3

adding python3 headers

fixing another file not closed warning on new vol handler and special case where the last file in a multivolume tar was being repeated in the tar index iterator

fixing some warnings in python3 from dereferenced but unclosed files

fixing open mode for updating the file to r+b

closing also volume files on cleanup

initial port to python 3, not finished

ignore the PowmInsecureWarning warning given by libgmp4 because it doesn't affect our code

adding support for filtering via whitelist with -inc

some unit tests were only failing when run with superuser, because only then chown can be called and had not been properly tested

fixing aes only mode: it turns out we were not closing correctly the aes stream

removing some unnecesary over-optimizations like running the gc manually or deleting stat dict

optimization memory usage during restore by saving dir perms in a specific class with only the needed data

start working on AES-only delta tar mode, with no encryption. some tests still fail

removing references to dowser, comment pytracemalloc usage, very useful though painful to setup tool to trace memory usage

fixing unit test where only even lines where being processed

fixing memory leaks, now memory usage remains nearly constant when creating a full backup

reducing leaks in tarfile by allowing not to store files in self.members

fixing last two unit tests bugs, realted to multivol and tar iterator

* when a file was split in two volumes, the tarinfo from the second volume was read twice
* tar iterator failed when reading an empty volume because instead of returning None, it tried to read position 0 and when reading from _Stream thats not allowed

fixing bug in a deltatar that excepts two vols for a backup of .git, which might not be needed

migrating tar restore to use the same code as index restore

previous commit was a mess because it mixed two commits, my fault.
it mixed both the mtime directories fix and the generalization of
tar restore with index restore.

this commit continues the work towards this generalization, fixing
the TarPathIterator (which was just not tested), doing the removed
os.chdir in restore_backup (which resulted in cwd data loss when
running the tests), fixing also the indentation at the end of the
restore_backup function, and setting correctly the
new_volume_handler in RestoreHelper when restoring from a tarball.

However, there are still some unit tests related to multivolume
handling that still fail.

fixing bug when restoring files, mtime of parent dir was not preserved/restored correctly

Fixing corner case where pad was not taken into account when decrypting the end of a file in a stream

__dec_read function reads directly from the file and returns the data
decrypted. This means that if the file is not encrypted, this function
is trivial.

If the data in the file is encrypted, then the process is different:
first we have to read the raw encrypted data, then decrypt it and
return. But the decryption process is not straightforward because the
self.fileobj stream contains multiple encrypted files one after the
other. We need to detect each separate file, which is detected because
they are separated by the "Salted__" keyword.

It gets more complicated, because we decrypt chunk by chunk, and to
correctly decrypt one chunk we need to set a "last" variable that
specifies if it's the last chunk of a file, because the end of a file is
handled differently, as it gets padded.

Knowing if the current chunk is the last part of a file is usually done
just by detecting if it's followed by a "Salted__" keyword or if we
cannot read more bytes from the stream. BUT there's a pretty particular
case, in which the current chunk ends exactly with one file, so that
the next chunk starts with "Salted__".

To fix that rare case, we just read N bytes from the stream, and check
if the last bytes correspond with the string "Salted__". Then we save
those last characters for next call to __dec_read. If the last bytes
were "Salted__", then we set "last" to True.

Well, actually we not only substract the length of "Salted__", but 16/32
chars because the file is decrypted in multiples of the key size.

when a comparison of two json paths in test_deltatar fails, show the two of them in console, this is quite handy

adding again all the test clases to runtests, as we were only testing default tar mode

improving the filesplitter, allowing to split at specified offsets. this is useful for debugging or to use as a last resort technique to recover a backup, knowing the offsets from the index for example

adding more options to backup script, like listing backup files

fixing some restore problems

* files that are not in the index being restored are now removed

* directories' mtime was not being restored sometimes because it
  wasn't finding the tarobj

fixing sorting and improving dramatically restore diff backup:

* sorting was not correct because the directory separator was being taken
  into account as part of the sorting, and thus if a directory contained
  a character like '-' it would affect sorting when compared with '/'.
  Now we sort directory by directory in a path, so the dir separator is
  not sorted itself.

* diffs backups where very slow because we were using a very simple
  algorithm that was also very slow, were for each file we would reopen
  and go across the index until found. Now we go across the index only
  once in the whole restore operation, so the speed of restoring a
  backup has increased dramatically.

small documentation fix, improving jsonpath comparator for directories, as their size dont matter, and improving it also to not compare uid or gid if not superuser

add handy backup command, used for benchmarks

fixing bug related to deltatar multivol restore

Extracting a multivol diff backup sometimes failed because we did
not set the volume number, which is needed to be done when we are
extracting files one by one.

fixing multiple errors in deltatar at once:

* naming of the generated backups was incorrect because they were
always named as if they were full backups, even if it was a diff
one. This has been changed both at backup creation and at backup
finding.

Related to that is the backup volume "finder": it was trying to
find volumes with current date which is not what we want, so now
it guesses the date of the volume based on a prefix and a suffix
inside the backup directory.

* changing the ordering of the files in _recursive_walk_dir to
follow an ascending naming sorted Breadth First Search algorithm.
This has been fixed without having to retrieve the full list and
then apply a sort to be efficient, which was something Daniel
applied as a fix and got reverted for memory efficiency.

* fixing index iterator also removing the need to have the full
index in memory and allowing it to be used with the "with"
python statement.

* fixing collate_iterators sorting because when the second index
element was less than the first one, we were not taking into
account that in a BFS algorithm files nearer to the root in depth
go first regardless of the sorting.

* some optimizations and fixes related to the deletion of files
in restore_backup for diff backups have been done

Fixed multivolume with encryption creation

Adding the test test_restore_from_index_diff_backup3_multivol I've found a
bug in the multivolume creation with encryption. The problem was that the
first volume of data was created correctly, but the second and so were
created in plain text.

The problem was in the TarFile.open_volume method, just in the creation of
the new volume file, the encryption data was not passed to the new _Stream
object.

Fixed aes deltatar restoring

Test DeltaTarGzipAes256ConcatTest.test_restore_from_index_diff_backup3 was
failing and this patch fixed it.

The encryption was initialized on every call to _init_read_gz and every
time we found a new encryption chunk (something that starts with
"Salted__"). The correct way to do it is to initialize at the beginning and
every time we find a new encryption chunk, it's not needed to initialize
the encryption on every call to _init_read_gz.

There was an exception trying to decompress a chunk of data in the line:

buf = self.cmp.decompress(buf)

This happened because at the end of the file the call to _init_read_gz
fails and the exception is controlled by a try-except, but sometimes just
after this fail there is a call to read the trailing data with the gzip and
a try to decompress and it fails because the self.cmp is not initialized,
this data is garbage, so I catch this exception and everything works okay.

Fixed DeltaTar create_diff_backup and restore_backup

Start all tests in the same directory

Fixed test_create_diff_backup1

fixing again tarfile.readline..

adding unit test that uses .git to create and restore backups

fixing readlin in tarfile, it was not working right after passing the bufsize

removing typo error

adding support for compressed index files

deltatar: setting and checking mtime and ctime in dirs and files

fixing bug in diff engine making it fail when a directory is removed

adding some unit tests for restoring diff backups and fixing some bugs in there

deltatar: initial implementation of the diff restore engine

improving diff engine unit test so that it test deletion of files

deltatar: fixing some problems with diff engine and adding more unit tests

improving the empty diff backup unit test

deltatar: standarizing using a prefix for all kind of file paths in all types of backups

initial implementation of diff backup and a simple unit test

writing iterators for directory diffs and unit testing them

deltatar: adding parent path checking, and unit tests for it

testing deltatar filtering regular expressions

allow also filtering on the extraction of backup tar files

deltatar: limit restore from index tests to uncompressed or concat compressed modes

deltatar: adding support for filtering in restore index and adding unit tests

Fixing AESCrypt stupid bug

adding unit tests for filter function

first implementation of filtered restore_backup and unit test

implementing filter_func in deltatar

Removing OFB pad to avoid to hide errors

fixing bug extracting tarfiles from index offsets when using multivol

restore from index without multiple vols now works

adding initial support to restore from index. still failing in directories

tarfile: adding a way to know the starting position of last tar member added

updated the estimation

fixing and unit testing multivolume support

deltatar: removing not bz2 concat stream test, adding crc checking and unit test for it

adding a test class for each supported mode and fixing some related bugs

deltatar: now index file is created on create_full_backup calls

initial super simple implementation and unit test of restore_backup

initial basic implementation of the create_full_backup and very basic unit test

adding steps to the design

specifing max vol size in mb and only for backup creation

fixing minor typos in DeltaTar spec

Fix small typo

improving design of the tool after thomas input

fixing some minor details

improving the design of DeltaTar public API, making it more flexible

uploading proposed public API

Add note about file index compression/encryption

specifying key_length in bits instead of bytes

Supporing aes128 and aes256 encryption type

Changed the gpl header to lgpl

Fixed encryption pad treatment using random pad

Fixed filesplit corner case infinite loop

Added encrypt/decrypt multivolume test

Adding intra2net copyright header to every python file

Using aes128 for encryption