improved unittest's create file: do not gather GB in memory before writing

clean up in unittest: remove size_test_* files

clean up in unittest: remove unused imports

make file size test faster by removing 16GB test file

create unittest for warning

warn if trying to compress/encrypt multivolume with mode w:...

adjust file-size-estimation unittest; add an actual test to unittest

started a unittest for multi-volume with compression

created unittest for get_file_size

added function get_file_size and var _file_size to _Stream

changed some comments, corrected one indent

delete(): Don't crash on removing symlinks to directories

shutil.rmtree() will refuse to follow symlinks.
-> just call os.unlink() for symlinks.

Revert "added arguments for permissions of created dirs and files to deltatar.create_full/diff_backup"

This reverts commit 8db5dd46357def656b84019cded8aed8f0626a03.

(simpler and more important to have UI deal with unclean input)

added arguments for permissions of created dirs and files to deltatar.create_full/diff_backup

Increase version to 1.1

Reflect the filename changes and
a few other bells and whistles.

Switch produced filenames from YY-mm-dd to YYYY-mm-dd

Ability to the run the unit tests without a .git directory

Useful for executing the tests during every rpm build.

Include unit test files in source tarball

Don't install them though. Just needed for
running the unit tests during the rpm binary build.

Unit test: Skip multivolume split test for modes that don't support it.

Actual code borrowed from test_restore_from_index().
Same code in test_restore_multivol_from_index() and a few others.

All unit tests running again.

Unit test: Fix _equal_stat_dicts() invocation

The jsonize_path_iterator() generator returns a tuple
with the wanted dictionary as the first element.

Pass on 'compresslevel' for gzip / bzip2 compressed archives only

Otherwise we crash when opening plain tar files for writing:

    TypeError: taropen() takes from 2 to 4 positional arguments but 5 were given

First part of the unit test fix. Verified with debug statements
in gzopen() that passing on the parameter still works.

Add comments about the callback param to the docs

Also, some others cosmetic changes.

Add a callback function to the restore process

By having a function called for every file
that's about to be restore, we can keep track
of the progress of the extraction.

adding an integration test that uses create_pseudo_random_files to create a deterministic files and directories tree and then uses delta-tar with the run_benchmark script.

adding zlib and zlib-blocks tests

improving benchmark tests and their documentation

adding support to set the gzip compression level in tarfile

Move README.txt to the docs folder. Better name

Added profiler test for tarfile and zlib.

Added test to test multivolume corruption at restore

Fixed "random" file corruption in multivol restore

Files splitted between two volumes were not valid in the restored backup.
The first part was okay but the second part was garbage. The problem was
that we don't set correctly the volume number so the second part always was
from the first tar file.

We were checking member variable, but this variable changes before, so I've
added a new bool variable "ismember" that don't change with member.

fix delete current file when doesnt match when restoring, logging was not being done correctly (crash)

allow to set a new_volume_handler in iterate_tar_path, but make it optional

small formating change

Fix typo in comment

fix typo error, variable should be named beginning_size

making testbackup.py work

adding more easy to understand diff backup debug output

fix debug logging in diff mode

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