Package 'syncr'

Source files to copy. See details

A single destination path, possibly remote.

increase verbosity

suppress non-error messages

suppress daemon-mode MOTD (see caveat)

skip based on checksum, not mod-time & size

archive mode; same as recursive, links, perms, times, group, owner, devices specials but no hard_links

recurse into directories

use relative path names

don't send implied dirs with relative

make backups (see suffix & backup_dir)

make backups into hierarchy based in DIR

backup suffix (default ~ w/o backup_dir)

skip files that are newer on the receiver

update destination files in-place

append data onto shorter files

transfer directories without recursing

copy symlinks as symlinks

transform symlink into referent file/dir

only "unsafe" symlinks are transformed

ignore symlinks that point outside the tree

transform symlink to dir into referent dir

treat symlinked dir on receiver as dir

preserve hard links

preserve permissions

preserve executability

affect file and/or directory permissions

preserve owner (super-user only)

preserve group

preserve device files (super-user only)

preserve special files

preserve times

omit directories when preserving times

receiver attempts super-user activities

handle sparse files efficiently

show what would have been transferred

copy files whole (without rsync algorithm)

don't cross filesystem boundaries

force a fixed checksum block-size

specify the remote shell to use

specify the rsync to run on remote machine

skip creating new files on receiver

skip updating files that exist on receiver

sender removes synchronized files (non-dir)

delete extraneous files from dest dirs

receiver deletes before transfer (default)

receiver deletes during xfer, not before

receiver deletes after transfer, not before

also delete excluded files from dest dirs

delete even if there are I/O errors

force deletion of dirs even if not empty

don't delete more than NUM files

don't transfer any file larger than SIZE

don't transfer any file smaller than SIZE

keep partially transferred files

put a partially transferred file into DIR

put all updated files into place at end

prune empty directory chains from file_list

don't map uid/gid values by user/group name

set I/O timeout in seconds

don't skip files that match size and time

skip files that match in size

compare mod_times with reduced accuracy

create temporary files in directory DIR

find similar file for basis if no dest file

also compare received files relative to DIR

... and include copies of unchanged files

hardlink to files in DIR when unchanged

compress file data during the transfer

explicitly set compression level

auto_ignore files in the same way CVS does

add a file_filtering RULE

exclude files matching PATTERN

read exclude patterns from FILE

don't exclude files matching PATTERN

read include patterns from FILE

read list of source-file names from FILE

all *from/filter files are delimited by 0s

bind address for outgoing socket to daemon

specify double_colon alternate port number

specify custom TCP options

use blocking I/O for the remote shell

give some file-transfer stats

leave high-bit chars unescaped in output

output numbers in a human-readable format

show progress during transfer

output a change-summary for all updates

output updates using the specified FORMAT

log what we're doing to the specified FILE

log updates using the specified FMT

read password from FILE

list the files instead of copying them

limit I/O bandwidth; KBytes per second

write a batched update to FILE

like write_batch but w/o updating dest

read a batched update from FILE

force an older protocol version to be used

set block/file checksum seed (advanced)

prefer IPv4

prefer IPv6

copy extended attributes, resource forks

disable fcntl(F_NOCACHE)

In the case where src is a single directory, don't copy the directory, but copy the contents.

Don't run anything and instead return the arguments that would have been passed to rsync.

Source files to copy. See details

A single destination path, possibly remote.

Copy in archive mode, being recursive, preserving attributes etc? Generally this is wanted.

Compress files on transfer?

Be verbose? (Always TRUE when using dry_run).

Copy relative paths only, rather than the last part of the file name. So if you have a directory src and you want to syncronise all the .c files in it, you could use src="src/*.c", relative=TRUE. You can include a dot at any point in a path name to indicate where the relative directory should start from; e.g. /absolute/path/to/./src/*.c which will create a directory src with .c files in it.

Delete files on the remote machine. When mirroring this is generally what you want to do but it is not enabled by default because it's potentially dangerous.

Don't actually do anything, but print what would be done instead.

In the case where src is a single directory, don't copy the directory, but copy the contents.

Copy files in place. This helps when copying to windows network shares where the unix emulation layer and windows don't get on very well. The downside is that if the copy fails it leaves files in an inconsistent state. By default, it will be used on windows and when the destination is an absolute path.

Don't run anything and instead return the arguments that would have been passed to rsync.