How to emulate rsync into cp to copy all files from source that don't exist in destination disk and update existing ones?

You cannot strictly emulate rsync using only the cp command because cp lacks built-in logic to compare file timestamps, sizes, or checksums before overwriting. To achieve incremental updates where only new or modified files are transferred, you must use a combination of find with -newer flags, shell loops for conditional copying, or rely on the native rsync tool which is specifically designed for this idempotent behavior as discussed in our guide on Is rsync idempotent?.

Understanding the Limitations of cp

The cp command is a basic utility intended for straightforward duplication. When you run cp -r source/ dest/, it blindly copies every file and directory structure from the source to the destination. It does not check if a file already exists in the target location, nor does it verify if the source file has been modified since the last copy. This behavior makes it inefficient for large datasets or network transfers where bandwidth and time are critical resources. In contrast, rsync uses a sophisticated algorithm that compares metadata (timestamps and file sizes) between the source and destination. If a file is identical in both locations, rsync skips it entirely. This capability is often referred to as idempotency, meaning running the command multiple times yields the same result without redundant work. For users facing issues where rsync ignores existing data due to mount points, see our analysis on Rsync Always Copy from Scratch with Mounted NAS: Fixing the Issue.

Method 1: Using find with -newer

The most efficient way to mimic rsync's update logic using standard Unix tools is to combine find with cp. The find command can locate files based on their modification time relative to a reference file. By creating a "marker" file at the destination, you can identify all source files that are newer than any file currently in the destination. First, create a marker file in your destination directory. This file acts as the timestamp baseline. You can create an empty file with the current timestamp using touch:

touch /path/to/destination/marker.txt

Next, use find to locate all regular files in the source directory that are newer than this marker. Pipe the results into cp using the -t option to specify the target directory. Because find outputs paths relative to the starting point, you may need to adjust the path structure depending on your needs.

find /path/to/source -type f -newer /path/to/destination/marker.txt -exec cp {} /path/to/destination/ \;

This approach ensures that only files that have been added or modified since the last operation are copied. However, note that this method copies files directly into the destination root unless you preserve the directory structure, which requires more complex scripting to recreate the folder hierarchy before copying.

Method 2: Shell Scripting with Conditional Checks

For scenarios requiring strict preservation of directory structures and explicit control over overwrite logic, a shell script provides greater flexibility. This method iterates through the source tree, checks if the corresponding file exists in the destination, and verifies if the source file is newer. Start by defining your source and destination variables. Use a recursive function or a for loop to traverse directories. For each file found, construct the expected destination path. Before copying, use the -nt (newer than) test operator within a bash conditional statement.

src="/path/to/source"
dst="/path/to/destination"

# Ensure destination exists
mkdir -p "$dst"

find "$src" -type f | while read -r file; do
    # Calculate relative path
    rel_path="${file#$src/}"
    dest_file="$dst/$rel_path"
    
    # Create destination directory if it doesn't exist
    mkdir -p "$(dirname "$dest_file")"
    
    # Check if file doesn't exist OR source is newer
    if [ ! -e "$dest_file" ] || [ "$file" -nt "$dest_file" ]; then
        cp -p "$file" "$dest_file"
        echo "Copied: $rel_path"
    fi
done

The -p flag in cp preserves file attributes such as permissions and timestamps, which is crucial for maintaining system integrity during backups. This script effectively emulates the core update logic of rsync but runs significantly slower on large file sets due to the overhead of spawning processes for each file.

Why rsync Remains the Superior Choice

While the methods above demonstrate how to approximate rsync functionality, they lack several critical features that make rsync indispensable for robust file transfer. rsync supports partial transfers, allowing interrupted downloads to resume rather than restarting. It also offers delta transfer algorithms for remote connections, sending only the differences between files rather than entire copies, which saves massive amounts of bandwidth. Furthermore, rsync handles special files like symlinks, devices, and hard links correctly out of the box. Custom scripts often struggle with these edge cases, leading to broken links or incorrect ownership settings. If you are dealing with sparse files, ensure you understand how compression affects them, as detailed in our article on How to Shrink Sparse Files in Linux After Copying Them Without the -S Operator. For simple local copies where speed is paramount and the dataset is small, cp is faster because it avoids the network latency of establishing an SSH connection or checking remote states. However, for any production environment, backup strategy, or large-scale synchronization task, the reliability and efficiency of rsync outweigh the complexity of setting it up.

Frequently Asked Questions

Can I use cp to delete files that no longer exist in the source?

No, cp only adds or overwrites files; it never deletes anything. To remove obsolete files from the destination, you would need to use rsync --delete or manually manage the destination directory with rm commands after comparing lists.

Does the find method preserve directory permissions?

The find combined with cp approach described above does not automatically recreate directory structures or preserve their specific permissions unless you add additional logic to create directories with mkdir -m before copying the files.

Is rsync safe to use on mounted network drives?

Generally yes, but as noted in our related content, some NAS configurations may cause rsync to ignore existing files due to timestamp resolution issues. Always test with the --dry-run flag first to verify behavior before executing actual transfers.

What is the fastest way to copy large files locally?

For purely local operations where no updates are needed, cp -a is typically the fastest option. It uses direct system calls and avoids the overhead of network sockets or complex comparison algorithms used by rsync.

How do I handle symbolic links with cp?

By default, cp dereferences symbolic links and copies the target file's content. To copy the link itself, you must use the -d or --no-dereference flag, though this still differs from rsync's more nuanced handling of symlink types across different operating systems.