Links

• samba.org: rsync manpage
  • Search for sections
    • FILTER RULES
    • INCLUDE/EXCLUDE PATTERN RULES
      • See also: http://ss64.com/bash/rsync.html#exclude
    • MERGE-FILE FILTER RULES
    • ANCHORING INCLUDE/EXCLUDE PATTERNS
    • PER-DIRECTORY RULES AND DELETE
    • BATCH MODE
    • SYMBOLIC LINKS
    • ENVIRONMENT VARIABLES
• samba.org: rsyncd.conf
  • linux.die.net: rsyncd.conf

Examples

# rsync and preserve more and also delete
rsync -aAHX --delete --progress --exclude '.Trashes' --exclude '*.pyc' src/ dst/

# rsync like behavior
rsync -avz --delete --progress --exclude '.Trashes' --exclude '*.pyc' src/ dst/

# don't preserve permissions and times
rsync -rlDvz --delete --progress --exclude '.Trashes' --exclude '*.pyc' src/ dst/

# Simpler (if you won't encounter special files when traversing.)
rsync -rl --delete src1/ src2/ dst/

# copy a directory resolving the symlinks that point outside the tree along the way.
rsync --progress -rlv --copy-unsafe-links --delete ~/play/webdev/dart/node_bind_ex01/ ant.c-k.me:~/ck/web_roots/play/webdev/dart/node_bind_ex01/

Command line options

See also: Full List of Options

-a → -rlptgoD

-a is equivalent to -rlptgoD.  For handy reference, here's what they mean.

-R, --relative: Use relative paths

Use relative paths. This means that the full path names specified on the command line are sent to the server rather than just the last parts of the filenames. This is particularly useful when you want to send several different directories at the same time. For example, if you used the command

rsync foo/bar/foo.c remote:/tmp/

then this would create a file called foo.c in /tmp/ on the remote machine. If instead you used

rsync -R foo/bar/foo.c remote:/tmp/

then a file called /tmp/foo/bar/foo.c would be created on the remote machine. The full path name is preserved.

Filter (and Include / Exclude patterns)

Note

• The --include/--exclude command-line options do not allow the full range of rule parsing that you can perform using --filter. They only allow the specification of include/exclude patterns plus a "!" token to clear the list If a pattern does not begin with "- " (dash, space) or "+ " (plus, space), then the rule will be interpreted as if "+ " (for an include option) or "- " (for an exclude option) were prefixed to the string.
• A --filter option, on the other hand, must always contain either a short or long rule name at the start of the rule.
• The --filter, --include, and --exclude options take one rule/pattern each. To add multiple ones
  • you can repeat the options on the command-line,
  • use the merge-file syntax of the --filter option, or the --include-from/--exclude-from options.

rsync checks each name to be transferred against the list of include/exclude patterns in turn, and the first matching pattern is acted on:

• if it is an exclude pattern, then that file is skipped;
• if it is an include pattern then that filename is not skipped;
• if no matching pattern is found, then the filename is not skipped.

Rsync builds an ordered list of filter rules as specified on the command-line. Filter rules have the following syntax:

RULE [PATTERN_OR_FILENAME]
RULE,MODIFIERS [PATTERN_OR_FILENAME]

You have your choice of using either short or long RULE names, as described below. If you use a short-named rule, the ',' separating the RULE from the MODIFIERS is optional. The PATTERN or FILENAME that follows (when present) must come after either a single space or an underscore (_). Here are the available rule prefixes:

When rules are being read from a file, empty lines are ignored, as are comment lines that start with a "#".

Modifiers

The following modifiers are accepted after a "+" or "-":

• A / specifies that the include/exclude rule should be matched against the absolute pathname of the current item. For example, "-/ /etc/passwd" would exclude the passwd file any time the transfer was sending files from the "/etc" directory, and "-/ subdir/foo" would always exclude "foo" when it is in a dir named "subdir", even if "foo" is at the root of the current transfer.
• A ! specifies that the include/exclude should take effect if the pattern fails to match. For instance, -! */ would exclude all non-directories.
• A C is used to indicate that all the global CVS-exclude rules should be inserted as excludes in place of the "-C". No arg should follow.
• An s is used to indicate that the rule applies to the sending side. When a rule affects the sending side, it prevents files from being transferred. The default is for a rule to affect both sides unless --delete-excluded was specified, in which case default rules become sender-side only. See also the hide (H) and show (S) rules, which are an alternate way to specify sending-side includes/excludes.
• An r is used to indicate that the rule applies to the receiving side. When a rule affects the receiving side, it prevents files from being deleted. See the s modifier for more info. See also the protect (P) and risk (R) rules, which are an alternate way to specify receiver-side includes/excludes.
• A p indicates that a rule is perishable, meaning that it is ignored in directories that are being deleted. For instance, the -C option's default rules that exclude things like "CVS" and "*.o" are marked as perishable, and will not prevent a directory that was removed on the source from being deleted on the destination.

Patterns

• if the pattern starts with a / then it is anchored to a particular spot in the hierarchy of files, otherwise it is matched against the end of the pathname. This is similar to a leading ^ in regular expressions. Thus "/foo" would match a name of "foo" at either the "root of the transfer" (for a global rule) or in the merge-file's directory (for a per-directory rule). An unqualified "foo" would match a name of "foo" anywhere in the tree because the algorithm is applied recursively from the top down; it behaves as if each path component gets a turn at being the end of the filename. Even the unanchored "sub/foo" would match at any point in the hierarchy where a "foo" was found within a directory named "sub". See the section on ANCHORING INCLUDE/EXCLUDE PATTERNS for a full discussion of how to specify a pattern that matches at the root of the transfer.
• if the pattern ends with a / then it will only match a directory, not a regular file, symlink, or device.
• rsync chooses between doing a simple string match and wildcard matching by checking if the pattern contains one of these three wildcard characters: '*', '?', and [.
• a '*' matches any path component, but it stops at slashes.
• use '**' to match anything, including slashes.
• a '?' matches any character except a slash (/).
• a '[' introduces a character class, such as [a-z] or [[:alpha:]].
• in a wildcard pattern, a backslash can be used to escape a wildcard character, but it is matched literally when no wildcards are present.
• if the pattern contains a / (not counting a trailing /) or a "**", then it is matched against the full pathname, including any leading directories. If the pattern doesn't contain a / or a "**", then it is matched only against the final component of the filename. (Remember that the algorithm is applied recursively so "full filename" can actually be any portion of a path from the starting directory on down.)
• a trailing "dir_name/***" will match both the directory (as if "dir_name/" had been specified) and everything in the directory (as if "dir_name/**" had been specified). This behavior was added in version 2.6.7.

Note that, when using the --recursive (-r) option (which is implied by -a), every subcomponent of every path is visited from the top down, so include/exclude patterns get applied recursively to each subcomponent's full name (e.g. to include "/foo/bar/baz" the subcomponents "/foo" and "/foo/bar" must not be excluded). The exclude patterns actually short-circuit the directory traversal stage when rsync finds the files to send. If a pattern excludes a particular parent directory, it can render a deeper include pattern ineffectual because rsync did not descend through that excluded section of the hierarchy. This is particularly important when using a trailing '*' rule. For instance, this won't work:

+ /some/path/this-file-will-not-be-found
+ /file-is-included
- *

This fails because the parent directory "some" is excluded by the '*' rule, so rsync never visits any of the files in the "some" or "some/path" directories. One solution is to ask for all directories in the hierarchy to be included by using a single rule: "+ */" (put it somewhere before the "- *" rule), and perhaps use the --prune-empty-dirs option. Another solution is to add specific include rules for all the parent dirs that need to be visited. For instance, this set of rules works fine:

+ /some/
+ /some/path/
+ /some/path/this-file-is-found
+ /file-also-included
- *

Examples

• - *.o would exclude all names matching *.o
• "- /foo" would exclude a file (or directory) named foo in the transfer-root directory
• "- foo/" would exclude any directory named foo
• "- /foo/*/bar" would exclude any file named bar which is at two levels below a directory named foo in the transfer-root directory
• "- /foo/**/bar" would exclude any file named bar two or more levels below a directory named foo in the transfer-root directory
• The combination of "+ */, "+ *.c, and "- *" would include all directories and C source files but nothing else (see also the --prune-empty-dirs option)
• The combination of "+ foo/, "+ foo/bar.c, and "- * would include only the foo directory and foo/bar.c (the foo directory must be explicitly included or it would be excluded by the "*")