High performance, file copying tool, used locally or to/from another host, for backup and mirroring. Can perform most ftp tasks.
Local side is refered to as the "client" and the remote as the "server".
rsyncd, the (optional) daemon is always a server. A remote server can be either a daemon or a remote-shell spawned process.
| Local: | rsync [option …] src… [dest]
|
Use remote shell: (when rsyncd is not running on host) notice single ':' | |
| Pull: | rsync [option …] [user@]host:src… [dest] |
| Push: | rsync [option …] src[/]… [user@]host:destTo copy a directory to a different name, use a trailing slash on the source directory
|
Use rsync daemon at remote host. (notice ::)
| |
| Pull: | rsync [option …] [user@]host::src… [dest] |
rsync [option …] rsync://[user@]host[:port]/src… [dest] | |
| Push: | rsync [option …] src… [user@]host::dest |
rsync [option …] src… rsync://[user@]host[:port]/dest | |
Single file example to host not using remote rsyncd. Useful when transfering a large file (SD card image) when
Display updates from a repository:
Copies locally (perhaps network shares) if neither the source or destination path are a host.
Examples
If a single source is specified without a destination, the files are listed in an output format similar to
Example:
The order of the options is important. The result of
Filenames are displayed in
Each file, dir, etc. that gets updated in a significant way (a transferred file,
a recreated symlink/device, or a touched directory) will be output.
The out-formated string is output prior to a file's transfer.
Statistics can be misleading with the delta-transfer algorithm.
For example, if the file is a log previously sent the reported rate will drop dramatically when the receiver gets to the
new data, and the transfer will take much longer to finish than predicted.
When a file transfer finishes, the progress line is replaced with a summary line like :
Does not affect the copying of symlinks or other special files.
Important for transfers which need to be restarted.
Useful when
WARNING: Do not use this to update files being accessed by others.
Implies
If
Do not use an absolute path unless
If
Add an exclude/hide/protect rule for the
Avoid using
The
Set the
For the purposes of "refuse options" setting,
If
Conflicts with
Requires enough free disk space to hold an additional copy of all the updated files.
See the "atomic-rsync" perl script in the "support" subdir
for an update algorithm that is more atomic (it uses --link-dest and a parallel hierarchy of files).
These extra path elements are called "implied directories" ("foo" and the "foo/bar" directories in the above example).
To limit the amount of path information sent as implied directories for each path, insert a dot and a slash into the source path.
For instance, if a command-line arg or a files-from entry told rsync to transfer the file "path/foo/file", the directories
"path" and "path/foo" are implied when
without
Without this , if the sending side has replaced a directory with a symlink to a directory, the receiving side will
delete anything that is in the way of the new symlink, including a directory hierarchy (as long as See
For example, transfer a directory "foo" that contains a file "file", but "foo" is a symlink to directory "bar" on the receiver.
See also --copy-dirlinks for an analogous option for the sending side.
When updating a non-empty destination, ensures that files that are hard-linked together on the source
are hard-linked together on the destination.
Rsync can only detect hard links between files that are in the transfer set. If rsync updates a file that has
extra hard-link connections to files outside the transfer, that linkage will be broken.
If incremental recursion is active rsync may
transfer a missing hard-linked file before it finds that another link for that contents exists elsewhere in the hierarchy.
With
rsync alias --compress --no--perms --no--group --chmod=ugo=rwX
then use : rsync -avZ src/ dest/
An item that should only apply to a directory is prefixed with
See
only if the receiver is super-user (see
The preservation of group information will associate matching
names by default, but may fall back to using the ID number
overridden by both
See
If repeated, rsync omits all mount-point directories.
If collapse symlinks (via
This is a transfer rule, not an exclude, it doesn't affect the data that goes into the file-lists, and thus it
doesn't affect deletions. It just limits the files that the receiver requests to be transferred.
Deletions will also occur when
Including
If the sending side detects I/O errors, deletion of any files will be disabled,
May be combined with one of the
Helpful when the destination filesystem is low on space.
See the FILTER RULES section for a way to make individual exclusions behave this way on the receiver, and for a way to protect
files from
Does not preserve hardlinks,
If
The side-effects of the
Examples:
When combining rsync --verbose --verbose --compress --progress \
--log-file=rsync$yymmdd.log \
SD-16GB.200421.gz/ user@host:
Retrieve entire directory: (First with dry-run to see what is going to happen)
ruser=DaRemote$UNAME
rhost=DaRemoteSHot
rsync --verbose --verbose --compress --progress --archive --xattrs --acls --log-file=/tmp/rsync.$yymmdd.log \
--update --dry-run \
$ruser@$rhost:/home/$ruser/Documents/ . # dot is destination
rsync --recursive user@fromHost:directory/sub . --list-only
Most basic transfer options:
--compress Compress in flight data ( no effect on destination) .
--archive Recursion, presering basic attributes (permissions, owner, type symbolic links ).
--atimes Preserve access times
--crtimes Preserve creation times.
--xattrs Preserve eXtended attributes.
--acls Preserve Access Control Lists.
--update If existing file is current or newer, skip transfer.
--log-file=rsync$yymmdd.log log ( .profile includes export yymmdd=`date +"%y%m%d"`
--hard-links preserve hard links, see symbolic links
--exclude-from=rsync-excludes exclude patterns (one per line).
Is your shell clean? abort message.
There is a lot to know about rsync ( and I only know a little), here's what you HAVE TO know.
ls -l.
The "=" is optional; whitespace can be used.
--no-option Turn off implied options
For example --archive is a synonym for -recursive --links etc. follow it with --no-links to not recreate links.--no-devices, --no-perms have different defaults in various circumstances
Example: --no-whole-file, --no-blocking-io, --no-dirs.
--no--recursive --archive is that --recursive would end up being turned on, the opposite of
--archive --no--recursive.
--list-only
Use to specify more than one source (explicititly or with wild-card expanded by the shell into multiple args)
for listing, otherwise second source would be intrepreted as the destination.
rsync --list-only uname@Real-World-Systems.com:*.txt # list all txt files on that host's root directory
-rw-r----- 160 2017/05/18 20:31:30 apacheNotes.txt
-rw-r--r-- 1490 2018/10/22 16:57:32 pepper-181022.txt
-rw-r----- 3679 2017/12/29 19:04:47 smacproPart4.txt
rsync --list-only /Volumes/big/*.MOV # list all the MOV files on that volume/dirctory
--recursive is not effective
-rw-r--r-- 308842544 2018/05/16 07:56:53 CamperGrandTour_2064.MOV
-rw-r--r-- 12014106 2018/06/23 15:40:36 DoorClosingWithGap188.MOV
-rw-r--r-- 185538306 2017/02/18 13:29:27 Hummers_0655.MOV
-rw-r--r-- 19434966 2019/01/19 09:28:38 IMG_0332.MOV
-n
--dry-run No transfers, produces a similar report to a real run.
-v
--verbose
By default, rsync works silently.
Gives information about files being transferred and a brief summary at the end.
No mention is made if a file had its attributes changed.--verbose --verbose Includes files are being skipped,
files over max-size,
hiding file xxx because of patterni x .--out-format of %n%L by default,
( name and if it is a link, where it points).
-q
--quiet decreases information reported.
Useful when invoking from cron.
Use with --verbose and/or --itemize-changes to see what a command is going to do.
options affecting report
-i
--itemize-changes
Increases verbosity. Default --out-format='%i %n%L'.
Repeating the option causes unchanged files to be output,.
.d var/
.f var/logPrune.sh
%i string YXcstpoguax, where
When deleting files, Y
. item is not being updated (attributes may be modified).
< file is being sent.
> file is being received
c change/creation is occurring for
the item
(such as the creation of a directory or the changing of a symlink, etc.).
h hard link to another item (requires --hard-links).
* itemized-output area contains a message (example: "deleting").
X file-type
f file d directory L symlink D device S special file (examples: named sockets and fifos). The other letters in the the associated attribute being updated
. no change.
+ new item ++++++++++
space identical item
?unknown attribute
Reasons for transfer
c regular file has a different checksum (requires --checksum) or
symlink, device, or special file has a changed value.
s size of a regular file
t time of last modification (requires --times).
Ttime of last modification will be set to the transfer time
if a file/symlink/device is updated without --times or
a symlink is changed and the receiver can't set its time.
p permissions are different (requires --perms).
o owner is different (requires --owner and super-user privileges).
g group is different (requires --group and the authority to set the group).
u future use.
a ACL (Access Control List) information changed.
x extended attribute information changed.
%i will output the string *deleting.
--out-format=format string of field specifiers.
Default with --verbose is %n%L (name and, if the item is a link, where it points).
See "log format" in rsyncd.conf .
(e.g. With --itemize-changes the logging of names includes any item changed.
If a transfer-statistic option is requested, logging is done at the end of the file's transfer.
When this late logging is in effect and --progress is
specified, the name of the file being transferred is output prior to its progress information followed by the out-format output.
--log-file=file
For a non-daemon transfer logging with a default %i %n%L.
Example: Remote side logs what is happening:
rsync --archive --verbose --rsync-path="rsync --log-file=/tmp/rlog" src/ dest/
Useful to diagnose connection closing.
--log-file-format=format
"transfer logging" unless the string is empty, then logging is turned off.
See log format in rsyncd.conf .
Default with --log-file %i %n%L i.e. name link.
-h
--human-readable K, M, or G. units are K (1000), M (1000*1000), and G (1000*1000*1000);
-h -h , units are powers of 1024 .
--stats output statistics
Number of files: 88417
Number of files transferred: 0
Total file size: 5008416760 bytes
Total transferred file size: 0 bytes
Literal data: 0 bytes
Matched data: 0 bytes
File list size: 2710302
File list generation time: 1.156 seconds
File list transfer time: 0.000 seconds
Total bytes sent: 20
Total bytes received: 2710322
sent 20 bytes received 2710322 bytes 285299.16 bytes/sec
total size is 5008416760 speedup is 1847.89
--progress Implies
--verbose
While transferring a regular file, updates a progress line like :
782448 63% 110.64kB/s 0:00:04
The transfer might finish in :04 seconds
1238099 100% 146.38kB/s 0:00:08 (xfer#5, to-check=169/396)
This was the 5th regular file transfered, 169 more files for the receiver to check out of the 396 files
Handling file match
Default: skip files with the same size and modification timestamp.
-I
--ignore-times
--size-only Useful when a system which does not preserve timestamps well.
timestamps considered equal if they differ by no more than the seconds.
Default 0 (exact match).
FAT filesystem represents times with a 2-second resolution --modify-window=1 allows times to differ by up to 1 second.
-u
--update Preserve a destination with a newer modification time.
-c
--checksum compare checksums for files with matching sizes.
Performance degradation affecting both sides, requires reading all the data in the files.
transfer handling
--append ONLY for files known to "growing", for example logs. Probably inapproiate for transfering entire directories.
No check is made to ensure that the begining of source and destination are the same.
The update occurs inplace.
No transfer occurs if the source file is not larger. The file's attributes ( permissions, ownership, etc.) are not updated.
Does not affect the updating of non-regular files. --append-verify --append, only if checksums of the beginning of the files match.
--inplace Writes directly to the destination file.
Without this a tempfile is created and moved when its transfer is complete preserving the previous version in the event of an aborted transfer.
Effects:
source files being updated will not be transfered.
destination files being read cannot be updated.
Combine with --backup, since rsync will use the backup file as the basis file for the transfer to prevent this.
--partial (an interrupted transfer does not delete the file),
Conflicts with --partial-dir and --delay-updates.
--partial Keep partially transfered file.
Default: delete partially transferred file
--partial-dir=partdir directory holding partial data, Implies --partial.
partdir is an absolute path it is consideered an existing working directory.
(1) there are no files in the transfer having the same name (since all the updated files will be put into a single directory )
and
(2) there are no mount points in the hierarchy (the delayed updates will fail if they can't be renamed into place).partdir is a relative path, it will be made and excluded preventing sending partdir files on the sending side,
and prevent untimely deletion of partdir files on the receiving side.
An example: the above --partial-dir option would add the equivalent of -f '-p .rsync-partial/'
at the end of any other filter rules.
partdir to
partdirs,
specify --delete-after and add a "risk" filter rule, eg. -f 'R .rsync-partial/'.--delete-before or --delete-du ring unless the left-over partdir data is not needed during the current run.)
partial-dir should not be writable by other users and avoid using /tmp. partdir to $RSYNC_PARTIAL_DIR. Setting this in $RSYNC_PARTIAL_DIR does not
enable --partial only where partial files go when --partial is specified. For instance,
instead of using --partial-dir=.rsync-tmp along with --progress,
Set $RSYNC_PARTIAL_DIR=.rsync-tmp and then use -P to use that for partial transfers.
--partial does not use this with:
.--inplace
--delay-updates--partial-dir does NOT imply --partial.
a refusal of --partial can be used to disallow the
overwriting of destination files with a partial transfer, while still allowing the safer idiom provided by --partial-dir. --whole-file is specified (or implied), partial-dir files are removed. -P equivalent to --partial --progress. Useful for a long transfer that may be interrupted.
--delay-updates puts the temporary file in
a holding directory until the end of the transfer, then all the files are moved into place
in an attempt to make the updating of the files more atomic.
By default the files are placed into .~tmp~/ in each file's destination directory.
Change the directory with --partial-dir.
--inplace and --append.
-W
--whole-file delta-transfer is not used.
The transfer may be faster if this option is used when the bandwidth between the
source and destination machines is higher than the bandwidth to
disk (example: when the "disk" is actually a networked filesystem).
Default when source and destination are local paths, if no batch writing option is in effect.
-S
--sparse Handle sparse files efficiently so they take up less space on the destination.
Conflicts with --inplace.
-R
--relative Use relative paths.
The full path names specified on the command line are sent to the server rather than just the last parts of the filenames.
Useful when sending several different directories at the same time.
For example:> rsync -av /foo/bar/baz.c remote:/tmp/
Creates /tmp/baz.c.> rsync -avR /foo/bar/baz.c remote:/tmp/
creates /tmp/foo/bar/baz.c preserving its full path.
rsync sends these implied directories as real directories in the file list, even if a path
element is really a symlink on the sending side. This prevents
unexpected behaviors when copying the full path of a file that you didn't realize had a symlink in its path.
To duplicate a server-side symlink, include both the symlink via its path, and referent directory via its real path.
>rsync -avR /foo/./bar/baz.c remote:/tmp/
Creates /tmp/bar/baz.c on the remote machine. (Note that the dot must be followed by a slash, so "/foo/." would not
--no-implied-dirs affects the default behavior of --relative .
The attributes of the implied directories from the source names are not included in the transfer.
This means that the corresponding path elements on the destination system are left unchanged if they exist, and any
missing implied directories are created with default attributes.
This allows these implied path elements to have big differences, such as being a symlink to a directory on the receiving side.
--relative is used. If "path/foo" is a symlink to "bar" on the destination system, the
receiving rsync would ordinarily delete "path/foo", recreate it as a directory, and receive the file into the new directory.
With --no-implied-dirs, the receiving rsync updates "path/foo/file" using the existing path elements, which means
that the file ends up being created in "path/bar".
Another way to accomplish this link preservation is to use the
--keep-dirlinks option (which will also affect symlinks to directories in the rest of the transfer).
-b
--backup Existing destination files are renamed before
files are transferred or deleted.
(watch free space on destination).
--backup-dir =DIR With --backup store all backups in DIR on
the receiving side. This can be used for incremental backups.
--suffix=suffix if no --backup-dir was specified Default suffix is ~
with --backup-dir no suffix is appended by default.
--backup-dir,
Prevents previously backed-up files from being deleted. --omit-dir-times is implied, and
--delete is in effect (without --delete-excluded), rsync will add a
"protect" filter-rule for the backup suffix to the end of all existing excludes (e.g. -f "P *~").
With filter rules, insert own exclude/protect rule higher up in the
list so that it has a high enough priority to be effective (e.g., if your rules specify a trailing inclusion/exclusion of
'*', the auto-added rule would never be reached).
-d
--dirs
Tell the sending side to include any directories that are encountered. Unlike --recursive, a directory's contents are not
copied unless the directory name specified is "." or ends with a trailing slash (e.g. ".", "dir/.", "dir/", etc.). Without this
option or --recursive , rsync will skip all directories it encounters (and output a message to that effect for each
one).
Specifing both --dirs and --recursive, --recursive takes precedence.
--dirs is implied by --files-from or --list-only (including an implied --list-only usage) if
Specify --no-dirs to turn this off.
Link handling
skip to attribute handling
-l
--links recreate symlinks on the destination.
-L
--copy-links for symlinks, the item that they point to (the referent) is copied.
--copy-unsafe-links copy the referent of symlinks that point outside the copied tree.
Absolute symlinks are treated like ordinary files, and as are symlinks in the source path itself when --relative is used.
Has no additional effect if --copy-links was also specified.
--safe-links ignore any symbolic links which point outside the copied tree and absolute symlinks
With --relative may give unexpected results.
-k
--copy-dirlinks sending side treats a symlink to a
directory as though it were a real directory.
Useful if you don't want symlinks to non-directories to be affected, as they would be using --copy-links.
--force or --delete is in effect).
--keep-dirlinks for an analogous option for the receiving side.
-K
--keep-dirlinks receiving side treats a symlink to a
directory as though it were a real directory, only if it matches a real directory from the sender.
Without this the receiver's symlink would be deleted and replaced with a real directory.
Without --keep-dirlinks, the receiver deletes symlink "foo", recreates it as a directory, and receives the file into the new directory.
With --keep-dirlinks, the receiver keeps the symlink and "file" ends up in "bar".
caution: when using --keep-dirlinks, you must trust all the symlinks in the copy!
If it is possible for an untrusted user to create their own symlink to any directory, the user could then (on a subsequent copy)
replace the symlink with a real directory and affect the content of whatever directory the symlink references.
For backup copies, use a bind mount instead of a symlink to modify your receiving hierarchy. -H
--hard-links hard-linked files in the transfer are linked to the corresponding files on the receiving side.
Without this option, hard-linked files in the transfer are treated as though they were separate files.
Does NOT break existing hard links on the destination that do not exist between the source files.
If one or more extra-linked files have content changes, they will become unlinked when updated (if not using --inplace ).
Using --inplace to avoid this breakage, there may be
unintended changes due to lingering hard links (see --inplace ).
This does not affect the accuracy of the transfer, just its efficiency,
To avoid this disable incremental recursion with --no-inc-recursive
Attributes, Meta-data, i.e. file permissions, Access Control Lists, owner, group …
-p
--perms set the destination permissions to be the same as the source permissions.
See --chmod to modify what are considered to be the source permissions.--no--perms:
--executability might change the execute permission.)
umask, or
the permissions specified via the destination directory's default AccessControlList.
Special mod bits are disabled except where a new directory inherits setgid from its parent.
To give new files the destination-default permissions (while leaving existing files
unchanged), use --no--perm--chmod=ugo=rwX
--chmod apply comma-separated chmod strings to the permission of the files in the transfer.
as if they were the permissions supplied by the sender.
Can seem to have no effect on existing files if --perms is not enabled.D', or to a file if prefixed with 'F'.
For example:
Multiple --chmod=Dg+s,ug+w,Fo-w,+X--chmods are permitted.--perms and --executability for how the resulting permission value can be applied to the files in the transfer.
-E
--executability preserve the executability (or nonexecutability) of regular files when --perms is not enabled.
A regular file is considered to be executable if at least one 'x' is turned on in its permissions. When an existing destination
file's executability differs from that of the corresponding source file, rsync modifies the destination file's permissions as follows:
-A
--acls update the ACLs, implies --perms.
See --fake-super to backup and restore ACLs that are not compatible.
-X
--xattrs update the remote extended attributes.
When done by super-user, copies all namespaces except system.*.
A normal user only copies the user.* namespace.
To to backup and restore non-user namespaces as a normal user, see --fake-super .
-o
--owner Preserve owner (other than receiving user)
Default: the owner is set to the user on the receiving side.--super and --fake-super ).
Caution: The preservation of ownership will associate matching names but if it falls back to using the ID number (see --numeric-ids it will surely be incorrect!!.
-g
--groupPreserve group
If the receiving program is not running as the super-user (or if --no-super was specified),
only groups that the invoking user on the receiving side is a member of will be preserved.
Without this option, the group is set to the default group of the invoking user on the receiving side. -t
--times preserve modification times (implied with --archive).
If times are not preserved (in addition to corrupting the modification time on the destination) the next time a transfer is performed,
the evaluation which excludes files that have not been modified will be incorrect. The deltatransfer algorithm will minimize the update.
-O
--omit-dir-times omit directories when preserving modification times (see --times).
Suggested if NFS is sharing the directories on the receiving side.
Implied with --backup without --backup-dir.
--super receiving side attempts to execute super-user activities even if it wasn't run by the super-user.
Include: preserving users via the --owner option,
preserving all groups (not just the current user's groups) via --groups , and
copying devices via --devices .
Useful for systems that allow such activities without being the super-user and
ensuring errors if the receiving side isn't being run as the super-user.
To turn off super-user activities, the super-user can use --no-super.
--fake-super simulate super-user activities by saving/restoring the privileged attributes via special extended attributes.
Includes the file's owner and group (if it is not the default), the file's device info (device & special files are
created as empty text files), and any permission bits that won't be allowed to be set on the real file (e.g. the real file gets
u-s,g-s,o-t for safety) or that would limit the owner's access
(since the real super-user can always access/change a file, the
files we create can always be accessed/changed by the creating user).
Handles ACLs (if --acls was specified) and non-user extended attributes (if --xattrs was specified).
backup data without using a super-user, and to store ACLs from incompatible systems.
Only affects the side where the option is used. To affect the remote side of a remote-shell connection, specify an rsync path:
There is only one "side" in a local copy, this affects both the sending and receiving of files.
Specify a copy using "localhost" to avoid this, possibly using the rsync -av --rsync-path="rsync --fake-super" /src/ host:/dest/
lsh shell script (from the support directory)
as a substitute for an actual remote shell (see --rsh).--super and --no-super.fake super in rsyncd.conf.
-x
--one-file-system avoid crossing a filesystem boundary when recursing.
This does not limit the ability to specify items to copy from multiple filesystems, just rsync's recursion
through the hierarchy of each directory that the user specified,
and also the analogous recursion on the receiving side during deletion.
A "bind" mount to the same device is considered being on the same filesystem.
Otherwise, it includes an empty directory at each mount-point it encounters (using the attributes of the
mounted directory because those of the underlying mount-point directory are inaccessible).--copy-links or --copy-unsafe-links), a symlink to a directory on another device
is treated like a mount-point. Symlinks to non-directories are unaffected by this option.
--existing,
--ignore-non-existing skip creating files and directories
that do not exist on the destination.
If combined with the --ignore-existing , no files will be updated (useful to delete extraneous files).
--ignore-existing skip updating files that already exist on
the destination (this does NOT ignore existing directories, or nothing would get done). See also --existing.
This is a transfer rule, not an exclude, so it doesn't affect the data that goes into the file-lists, and doesn't affect deletions.
It limits the files that the receiver requests to be transferred.
Useful for doing backups using --link-dest when continung a n interrupted backup.
Since a --link-dest run is copied into a new directory hierarchy (when it is used properly),
using --ignore existing will ensure that the already-handled files don't get
tweaked (which avoids a change in permissions on the hard-linked files).
This does mean that this option is only looking at the existing files in the destination hierarchy itself.
Deleting Files on the receiving side
This occurs when files on the sending side are deleted or moved to a different directory.
If this run is expected to be a backup, this results with files deleted locally will not be recoverable.
--delete For directories being synchronized
(i.e. updating those previously sent using dir or dir/ )
files no longer on the sending side are deleted from the receiving side.
(Not effective for files using a wildcard for the directory's contents which was expanded to a list of files.)
excluded files are not deleted unless --delete-excluded
or mark the rules as only matching on the sending side
See include/exclude modifiers .--dirs is enabled for directories whose contents are being copied. --dry-run shows files that would be deleted without deleting them.--delete-during(default) May be a better choice than after)
--delete-before
--delete-after
--delete-delay
--prune-empty-dirs--delay-updates.
(use --del --delete-during to request this deletion mode explicitly).
Incremental recursion can be disabled using --no-inc-recursive.
useful with NFS errors on the sending side)
--delete-when as well as --delete-excluded.
See --delete-delay and --delete-after.
--delete-before Deletions are done before any transfer .
See --delete.
Introduces a delay before the start of the transfer which might cause the transfer to timeout
Forces non-incremental recursion that requires a scan of the files for the transfer into memory at once
(see --recursive).
--delete-during
--del deletions are done as the transfer occurs.
The per-directory delete scan is done before each directory is checked for updates
--delete-delay File deletions are done after the transfer.
Useful when combined with --delay-updates and/or --fuzzy, and is more efficient
than using --delete-after
(can behave differently, since --delete-after computes the deletions in a separate pass after all updates are done).
If the number of removed files is very large
--delete-after (unless --recursive is doing an incremental scan).
See --delete.
--delete-after file deletions are done after the transfer has completed.
Useful when sending new per-directory merge files as a part of the transfer and
you want their exclusions to take effect for the delete phase of the current transfer.
Forces non-incremental recursion that requires scanning all the file names in the transfer into memory at once.
--delete-excluded
Include deleting files on the receiving side that are excluded. --delete-excluded
--force Delete a directory when it is to be replaced by a file,
even if the directory contains files. Only relevant if deletions are not active (see --delete for details).
--ignore-errors --delete deletes files even when there are I/O errors.Danger
--max-delete=N MAXimun number of files or directories deleted, once exceeded
exit with an error code 25 . --max-delete=0 warning without removing
Remove from the sending side files successfully MOVED .
options controling files to be transfered
-a
--archive synonym for -recursive --links --perms --times --group --owner --devices --specials
ACL and eXtended attributes are not be preserved ed
When --files-from is specified --recursive is not implied.---hard-links.-archive follows --compress it will reenable the "--no-" options
--files-from option are NOT positional, as it affects the default state of
several options and slightly changes the meaning of --archive.
-r
--recursive copy directories recursively. See --dirs .
-f
--filter=rule add rules to selectively include/exclude files. Useful in combination with a recursive transfer.
Multiple --filter options are permitted.
If rule contains whitespace, quote it.
An underscore can be used to replace the space that separates a rule from its arg. See FILTER RULES
--max-size=bytes Supress transferring files larger than bytes.
may be a fractional (e.g. --max-size=1.5m).
A transfer rule limits the files that the receiver requests to be transferred
not an exclude, doesn't affect the file-lists or deletions.
Suffixes (case insensitive)
+1 or -1 to offset by one byte.
--max-size=1.5mb-1 is 1,499,999 bytes
--max-size=2g+1 is 2,147,483,649 bytes.
--min-size=mb Skip small files,i.e. those less than mb.
small, junk files.
-F
-F-F Use .rsync-filter sprinkled through the hierarchy rules to filter the files and
and exclude them.
--exclude=pattern
--exclude-from=file file contains exclude patterns (one per line).
Blank lines and lines starting with ; or # are ignored.
If FILE is -, the list will be read from standard input.
-C
--cvs-exclude
Exclude files that shouldn't be transfered, similar to CVS
These are marked perishable see filter rules
RCS SCCS CVS CVS.adm RCSLOG cvslog.* tags TAGS
.make.state .nse_depinfo *~ #* .#* ,* _$* *$ *.old *.bak
*.BAK *.orig *.rej .del-* *.a *.olb *.o *.obj *.so *.exe
*.Z *.elc *.ln core .svn/ .git/ .bzr/
$CVSIGNORE (delimited by whitespace). See CVS
$HOME/.cvsignore
.cvsignore
.cvsignore (delimited by whitespace).
--filter rules with -C
CVS excludes are appended regardless of where the -C was placed on the commandline.
This makes them a lower priority than any rules specified explicitly.
To control where these get inserted into filter rules,
omit -C as a command-line option and use a combination of
--filter=:C and --filter=-C (either on the command-line or by
putting the ":C" and "-C" rules into a filter file with other rules).
:C turns on the per-directory scanning for the .cvsignore file.
-C does a one-time import of the CVS excludes.
--include=pattern
--include-from= file as with --exclude-from
--files-from=