syncrclone

syncrclone is not atomic. If the process is interrupted, it can be left in an incomplete state. While generally safe from data loss, you should be aware of the following consequences:

Recommendation: Always maintain backups and consider running a backup before and after a sync if data integrity is critical.

Unlike bisync, which compares the current state to a past state to generate changes, syncrclone uses a different approach to change detection and conflict resolution:

1. Current State Comparison: syncrclone first compares the current state of each machine/remote.
2. Conflict Resolution: It then uses the previous (past) state to resolve conflicts and deduce the necessary changes.

Key benefits of this approach:

• Implicit First Sync: Because the algorithm handles the absence of previous state gracefully, there is no need for an explicit --first-sync flag. If no previous state exists, syncrclone performs a union of the two sides (no deletes), making it safer for initial setups.
• Robustness: It is more robust to issues where the previous state might be missing or corrupted.
• Filter Flexibility: You can safely change filters (except for --include-if-present) without needing to rerun a special 'first-sync' mode.

Move tracking allows syncrclone to detect when a file has been renamed rather than deleted and recreated. This is only active if the renames{A/B} attribute is set in your configuration.

Supported Attributes

You can choose which attributes to use for tracking. The actual comparison performed depends on your selection:

How it works

A rename is detected on side A if:

1. A file is marked as new on side A.
2. The renamesA attribute matches a file in the prev list that was marked as old (deleted) on side A.
3. The file named old on side B is marked for deletion and matches the --compare attribute.

If these conditions are met, the file is moved on the target side instead of being transferred as a new file.

| Attribute | Actually compared |
|-----------|-------------------|
| size      | size              |
| mtime     | size,mtime        |
| hash      | size,hash         |

syncrclone uses a bi-directional synchronization algorithm that compares two remotes (A and B) against their previous states to determine which files are new, modified, deleted, or moved.

Comparison Logic

The algorithm first identifies identical files (where A == B) and removes them from both current and previous lists to simplify the remaining comparison. For the remaining files, it evaluates:

• Missing Files: If a file exists on one side but not the other, it checks the previous list to distinguish between a new file and a deleted file.
• Modified Files/Conflicts: If files differ, the algorithm checks their previous states. If only one side shows a modification relative to the previous state, it performs a backup and sync. If both sides show modifications, a conflict is identified.

Conflict Resolution

Resolution behavior is determined by your configuration. Available strategies include:

• A or B: Force one side to win.
• tag: Renaming both files.
• older / newer: Based on mtime (modification time).
• older_tag / newer_tag: Based on mtime.

Note: If the comparison attribute is hash or size, older means smaller and newer means larger.

If you use the same configuration file across multiple machines, you can use Python to define dynamic paths and unique names. This prevents different machines from overwriting each other's data.

Using Hostname for unique names

You can use the subprocess module to fetch the hostname:

import subprocess
hostname = subprocess.check_output(['hostname']).decode().strip()
name = hostname

if hostname == 'machine1':
    remoteA = '/path/to/machine1/documents'
elif hostname == 'machine2':
    remoteA = '/different/path/to/documents'
else:
    raise ValueError(f"Unrecognized host {hostname}")

remoteB = 'remoteB:path/to/remote'

Using Environment Variables

You can define a name in your shell profile (e.g., .bashrc) and read it in the config:

In .bashrc:

export SYNCRCLONE_NAME="my_computer_name"

In config.py:

import os
name = os.environ['SYNCRCLONE_NAME']

Attribute settings (like compare, conflict_mode, and renames) depend on the capabilities of your remotes.

Recommended: High Robustness (using hashes)

If both remotes support hashes, use this for the most reliable sync and clear conflict resolution:

compare = 'hash'
conflict_mode = 'tag'
renamesA = 'hash'
renamesB = 'hash'

Recommended: General Purpose (using mtime)

If hashes are not easily available, use modification time:

compare = 'mtime'
conflict_mode = 'newer_tag'

Handling Remotes without Hash support (e.g., SFTP)

If one side (e.g., B) doesn't support hashes, use reuse_hashes to save resources:

compare = 'mtime'
conflict_mode = 'newer_tag'
renamesA = 'hash'
renamesB = 'mtime'

Worst-case: No ModTime or Hash support

If neither remote supports ModTime or hashes, use size-based comparison. Note that rename tracking will not work reliably here:

compare = 'size'
conflict_mode = 'tag'
renamesA = None
renamesB = None

compare = 'hash'
conflict_mode = 'tag'
renamesA = 'hash'
renamesB = 'hash"