Use the rust-chrono library.

On Windows non-UTF8 paths are not supported. However, in the manifest they could appear. If this happens, the backup becomes unreadable on Windows, so it's better to support them under the hood, and to change Entry interface, providing:

• an Option<Path> for the Entry path,
• and an &[u8] for the path bytes.

Build a command line tool similar to duplicity. The parameters don't have to be the same of duplicity. The focus should be for clarity.

• add command line handler from kbknapp/clap-rs;
• support list collections;
• support list files.

Library users will be able to get warnings at least.

Currently BackupSet::volume_path takes an i32. Should be changed to usize. Moreover, the underlying storage should be a Vec and not an HashMap<i32, Path>.

Documentation:

• Publishing artifacts to GitHub Releases;
• Example with GitHub deploy;
• Example with artifact.

The utils suffix is very ugly and means nothing. Will "unuseful" modules ever exist? They are all supposed to be useful or to contain utilities somehow...

• Local time zone is not settable from the test, so simply remove the test
• Size hint does not work for the unprintable path in the backup
• Non-UTF8 paths are not supported on windows, so fix tests accordingly

When a backup with multiple chains is provided, examining an incremental snapshot of a chain different than the first will rise "The signature chain is incomplete" error.

For example with this backup:

Backup chain
Start time:            Aug 11  2015
End time:              Sep 25  2015
Number of backup sets:            3
Number of volumes:             1971
Backup sets (index, type, time, num volumes):
     0 Full         Aug 11  2015  1929
     1 Incremental  Sep 20  2015    28
     2 Incremental  Sep 25  2015    14

Backup chain
Start time:            Dec 06  2015
End time:              Jan 08 22:53
Number of backup sets:            5
Number of volumes:             1990
Backup sets (index, type, time, num volumes):
     3 Full         Dec 06  2015  1985
     4 Incremental  Dec 12  2015     1
     5 Incremental  Dec 25  2015     2
     6 Incremental  Jan 05 22:10     1
     7 Incremental  Jan 08 22:53     1

Listing files in snapshot number 4, will rise that error.

Instead of pushing docs with travis, use https://docs.rs/ for crate documentation.

Builds are failing for target x86_64-pc-windows-msvc. The build fails because advapi32-sys can't find ws2_32.lib.

See this PR for a temporary fix, and this rust-lang issue for the complete fix.

The current pretty format for timestamps is RFC-822Z, that is not the best for readability. I suggest to use the same format as the unix ls command does. If the date is from the same as the current year, print month, day, time; otherwise print month, day, year.

Example:

drwxr-xr-x 2 dev dev 4096 Jul 27  2002 old_dir
-rw-rw-r-- 1 dev dev 3016 Nov 14 16:18 new_file

In a large backup (104190 files), some performance issues were found when getting the file list. See the attached flame graph.

The 87.89% of execution time is inside the compute_size_hint function, caused by getting the file size by using the Read::count method.

Consider the execution time with compute_size_hint enabled:

real    0m36.682s
user    0m36.534s
sys 0m0.176s

And with that computation disabled:

real    0m10.099s
user    0m9.929s
sys 0m0.176s

• in file_naming module, merge FileType and FileName in a single enum. This change saves memory and provides better readability;
• consider the same issue in collections module, for BackupSet

Instead of implementing Iterator directly, implement IntoIterator. This is less misleading, since one can call as_snapshots while iterating, which is not unsafe, but at least, strange. In this way we have a clear separation between the as_xxx and iterators.

Current Display for backup files does not consider setuid, setgid and sticky bit.

On unix they are displayed as:

$ touch file
$ chmod 7700 file
$ ls -la file
-rws--S--T 1 dev dev    0 Nov 27 09:52 file

See Unix permissions calculator to do some experiments.

Add tests on signature module by comparing with duplicity output.

Bleeding edge version uses:

• Entries intead of Files;
• EntriesMut instead of FilesMut;
• Entry instead of File.

Handle also support for entry types like is_directory, is_file, is_soft_link, etc.

See tar-rs docs.

• Port to new API;
• Check if entry type is correctly exposed;
• Use a published version and not the git repo.

Need to cleanup the public interface:

• make collections/file_naming mod private;
• make collections mod private or cleanup its interface.

See rust-clippy and travis-cargo docs on how to enable it only on nightly for travis builds.

Add tests on collections module by comparing with duplicity output.

Currently the Backend trait has too much associated types. It's too difficult to use it as a trait object. Consider removing them.

Currently we do not provide the type of entry for a BackupFile. It could be a directory, a file, a link, etc.

Need also to rename "File" in "Entry" for this reason.

To display colored informations in terminal, use ogham/rust-ansi-term, or Stebalien/term.

See an example usage in kbknapp/clap-rs.

Support for encrypted backups. Needed a GPG crate to work with.

When displaying file list, if a path is too long it is truncated.

Example:

rw-rw-r--  michele  michele  Aug 14  2013  home/michele/Documenti/Development/Progetti/Meta cloud/Reference/duplicati/BuildTools/WixI

But the original path is:

home/michele/Documenti/Development/Progetti/Meta cloud/Reference/duplicati/BuildTools/WixIncludeMake/Program.cs

Investigate the possibility to improve Backend interface, and make it more generic, by changing signature of get_file_names. It should return an iterator instead of a slice.

There are currently no differences between formatting a timestamp in UTC and local time zones.
There is probably a bug in time_utils module.

Use std::path::PathBuf instead of plain String in:

• Backend;
• collections mod.

This occurs when merging a new signature into a chain, in signature module. Consider using a custom unsafe function or (if possible) itertools::merge_by.

There are a bunch of if a > b { a - b } else { 0 } occurrences. This could be easily solved by using a.saturating_sub(b) if the variables are unsigned.

Instead of implementing Iterator for SnapshotEntries, it's better to implement IntoIterator for SnapshotEntries, &SnapshotEntries, &mut SnapshotEntries. This allows to add to SnapshotEntries these methods independently:

• entry(&self, id: EntryId) -> Entry;
• into_display(self) -> SnapshotEntriesDisplay.

Working with byte arrays is a big pain, especially in the manifest parsing. It's maybe better to drop support for non UTF-8 paths. We are not going to see many of them in real world backups.

Understand signature file format to get the original file size.

See mksum.c in librsync project.

Duplicity uses md4 type signatures, because the header starts with: 0x72730136.

Suggested interface: fn size_hint(&self) -> (usize, usize).

• Struct definitions first, impl after;
• Public first, private after;
• Use free functions instead of static one if self is not used;
• Move static functions into free functions;
• Run rustfmt on the sources.

When an error happens in signature files, report them to the user, when she will iterate over that point.

Leave this crate free of unused lib dependencies. Suggested name for the other crate (it will depend on this one): ruplicity-console.

Avoid to store many different times the same user and group names. Set up a cache uid -> uname and uid -> gname that saves this infomation. Store only the gid and uid into PathInfo-

Extract the restore functionality from duplicity, to implement the read of a file snapshot in a backup.

• Parse manifest files
• Integrate librsync-rs crate
• Implement a cache trait to allow reusing extracted file chunks
• Use fnv hashing for the cache
• Documentation

Tests are now failing because files reported by incremental signatures are equal to the parent full signature.

The test in question exposes the problem, because in the first incremental signature there undetected modifications w.r.t the full snapshot:

• new files;
• deleted files;
• changed last modified times.

We can get rid of unmaintenable table formatting with fmt, by using BurntSushi/tabwriter.

Right now we have to pass a Ref<Option<Chain>> and an index to build a SnapshotFiles instance.
This can be simplified into a simple Ref<signature::SnapshotFiles>, whenever Ref::map will be marked as stable.

Waiting for rust-lang/rust#27746.

Add documentation to all public structs and methods.

• Use #![deny(missing_docs)] lint at crate level to help documenting everything
• Add examples for all common methods
• Add examples in README
• Add license notes in README
• Add motivations and related crates in README

Now we use pub type BlockId = (EntryId, usize) and pub type EntryId = (usize, u8) which are pretty unreadable. For example, to get the snapshot number out of a BlockId we have to do (id.0).1. Better to wrap them in new types and provide accessor methods.

Instead of using io::Error everywhere, create a new crate global error type, that contains all the possible errors. A nice possibility is to use the quick-error crate.