3 # Usage: replicate <hostname> <zfs filesystem>
7 remote_lockdir="/tmp/zfs-admin-lock"
9 # Set the name of the local pool used to store the backup of the remote
12 # Set the email address to send notification to
13 mailto=root@pippins.net
15 # When this variable is set, local filesystems will be destroyed
16 # before receiving a full streams into them from the remote source.
17 destroy_local_filesystem_on_full_replicate=0
19 # The ssh connection doesn't find zfs without this.
22 # Setup our cleanup and exit trap
24 ssh $remote rm -rf "$remote_lockdir"
30 # Make sure we have valid arguments
31 if [[ -z "$remote" ]] || [[ -z "$remote_fs" ]]; then
32 echo "Usage: $0 <hostname> <zfs filesystem>"
36 # Make sure the local pool and local receiving filesystem exist, or print some errors
37 zpool list -H "$local_pool" >/dev/null 2>&1
39 echo >&2 "-E- The local pool, '$local_pool' doesn't seem to exist."
42 zfs list "$local_pool/$remote_pool" >/dev/null 2>&1
44 echo >&2 "-I- The local filesystem for the remote pool, '$local_pool/$remote_pool' doesn't seem to exist."
45 echo >&2 " Creating the local filesystem to receive the remote pool into: $local_pool/$remote_pool"
46 $zfs create $local_pool/$remote_pool
48 echo "-E- remote $zfs create command failed"
53 # Obtain the zpool guid for the local pool
54 local_pool_guid=`zpool get guid $local_pool 2>&1 | grep $local_pool | awk '{ print $3 }'`
55 zpool get guid $local_pool > /dev/null 2>&1
57 echo >&2 "-E- Unable to extract the guid for the local pool: $local_pool"
61 # Turn on shell verbosity
64 # Create the remote lockdir before continuing with the replicate
65 # Spinlock on creating the lock
70 ssh $remote mkdir "$remote_lockdir" >/dev/null 2>&1
72 # Another zfs admin tool is running.
73 # Wait a random amount of time and try again
74 ransleep=$(($RANDOM % $maxsleeptime))
76 ((attempts=attempts+1))
78 # No other zfs admin tool is running, we can now.
81 if [[ $attempts -gt $maxattempts ]]; then
82 # We've exceeded our maximum while loop count
83 echo "-W- The zfs filesystem has been locked down. Skipping replicate operation."
84 ssh $remote ls -ld $remote_lockdir | /usr/bin/mailx -s "zfs-replicate-all unable to obtain zfs admin lock" $mailto
89 # Setup our backup marker names
90 current_backup_marker=${remote_fs}@current-backup-${local_pool_guid}
91 previous_backup_marker=${remote_fs}@previous-backup-${local_pool_guid}
93 # List the snapshots on the remote machine.
94 remote_list=$(mktemp /tmp/replicate.XXXXXX)
96 $zfs list -H -t snapshot |
98 awk '{print$1}' > $remote_list
100 echo "-E- remote $zfs list command failed"
104 # List the snapshots on the local machine.
105 # Don't list the current backup marker if it exists on the local side.
106 # If you do, it can mess up the common finding algorithm below.
107 local_list=$(mktemp /tmp/replicate.XXXXXX)
108 $zfs list -H -t snapshot |
109 grep ^${local_pool}/${remote_fs}@ |
110 grep -v ^${local_pool}/${current_backup_marker} |
111 awk "{gsub(/^$local_pool./,\"\",\$1); print\$1}" > $local_list
113 echo "-E- local $zfs list command failed"
117 # Destroy the current backup marker snapshot on the remote system if it exists
118 grep -q ${current_backup_marker} $remote_list
120 ssh $remote $zfs destroy ${current_backup_marker}
122 echo "-E- remote $zfs destroy command failed"
127 # Create the current backup marker snapshot on the remote system
128 ssh $remote $zfs snapshot ${current_backup_marker}
130 echo "-E- remote $zfs snapshot command failed"
134 # Check to see if the previous backup marker exists in the remote snapshot list.
135 # Check to see if the previous backup marker exists in the local snapshot list.
136 # If the previous backup markers exists, perform an incremental replicate. Else:
137 # 1) check to see if a common snapshot exists, and perform an incremental replicate.
138 # 2) if no common snapshot exists, destroy the local filesystem, and perform a full replicate.
139 grep -q ${previous_backup_marker} $remote_list
141 grep -q ${previous_backup_marker} $local_list
142 no_markers=$(($no_markers || $?))
144 if [ $no_markers == 0 ]; then
145 # We found backup markers, incrementally send the new snaps
147 # First, rollback the local pool to the previous backup marker in case the previous
148 # backup was interrupted for some reason. If we don't do this, the zfs send -R command
149 # below may complain about snaps already existing as it tries to resend from the
150 # previous backup marker again from a previously interrupted replicate.
151 $zfs rollback -r ${local_pool}/${previous_backup_marker}
153 echo "-E- remote incremental $zfs rollback command failed"
156 # Now it should be safe to send the snaps
157 ssh $remote $zfs send -R -I${previous_backup_marker} ${current_backup_marker} |
158 $zfs receive -vF -d ${local_pool}/${remote_pool}
160 echo "-E- remote incremental $zfs send command failed"
164 # We didn't find any backup markers, next check to see if we have a common snapshot.
166 # See what the most recent snapshot on the remote end is.
167 latest=$(tail -n 1 $remote_list)
169 # I did this to make sure that diff would always display the most recent common
170 # Since we're keying off the context of the diff, we need to ensure we will get context
171 # by injecting a known difference in case no others exist in the lists.
172 echo bogus.remote >> $remote_list
173 echo bogus.local >> $local_list
174 common=$(diff -u $remote_list $local_list | grep '^ ' | tail -n 1)
176 if [[ -n "$common" ]]; then
177 # We found a common snapshot, incrementally send the new snaps
178 ssh $remote $zfs send -R -I${common/*@/@} ${current_backup_marker} |
179 $zfs receive -vF -d ${local_pool}/${remote_pool}
181 echo "-E- remote incremental $zfs send command failed"
185 # We did not find any markers or a common snapshot
186 # At this point, we'll have to send the entire filesystem
187 # Destroy the local filesystem if it exists before receving the full replicate
188 zfs list ${local_pool}/${remote_fs} > /dev/null 2>&1
190 if [[ $destroy_local_filesystem_on_full_replicate == 1 ]]; then
191 $zfs destroy -r ${local_pool}/${remote_fs}
193 echo "-E- remote full $zfs destroy command failed"
197 echo "-W- We need to destroy a local filesystem before receiving a full stream."
198 echo " However, since the option is set to prevent this, skipping replicate operation."
199 echo "$zfs destroy -r ${local_pool}/${remote_fs} not able to run" | /usr/bin/mailx -s "zfs-replicate-all unable to destroy local filesystem" $mailto
203 # Send the full filesystem
204 ssh $remote $zfs send -R ${current_backup_marker} |
205 $zfs receive -vF -d ${local_pool}/${remote_pool}
207 echo "-E- remote full $zfs send command failed"
213 # destroy the previous backup markers now that we've replicated past them
214 # don't check the return codes here because these may not exist, and that is ok
215 $zfs destroy ${local_pool}/${previous_backup_marker} > /dev/null 2>&1
216 ssh $remote $zfs destroy ${previous_backup_marker} > /dev/null 2>&1
218 # Rename the current backup marker to be the previous backup marker
219 $zfs rename ${local_pool}/${current_backup_marker} ${local_pool}/${previous_backup_marker}
221 echo "-E- local $zfs rename command failed"
224 ssh $remote $zfs rename ${current_backup_marker} ${previous_backup_marker}
226 echo "-E- remote $zfs rename command failed"
231 rm -f $local_list $remote_list