WebSVN – zfs_utils – Diff – /trunk/replication/replicate

 #! /usr/bin/env perl
+# very simple script to replicate a ZFS snapshot to another server.
+# no fancy bells and whistles, does not create snapshots, and does
+# not prune them. No major error checking either
 use strict;
 use warnings;
 use Data::Dumper;
+use Getopt::Long;
+Getopt::Long::Configure ("bundling");
-my $source = shift;
-my $target = shift;
-die "Usage: replicate source target\n" unless $source && $target;
+# create our configuration, with some defaults
-my $dryRun = 0; # if set, will only display the command to be executed
+# these are overridden by command line stuff
 my $config = {
+   # the source, where we're coming from
+   'source' => '',
+   # the target, where we want to replicate to
+   'target' => '',
    # compile the regex
-   'pattern' => qr/(\d{4}.\d{2}.\d{2}.\d{2}.\d{2})/
+   'filter' => qr/(\d{4}.\d{2}.\d{2}.\d{2}.\d{2})/,
+   # if non-zero, just display the commands we'd use, don't run them
+   'dryrun' => 0,
+   # whether to do all child datasets also (default)
+   'recurse' => 1,
+   # show more information
+   'verbose' => 0
    };
 sub parseDataSet {
    my $data = shift;
    my %return;
       $return{$dataset}{'snaps'}{$snap}{'used'} = $used;
+   }
    return \%return;
+}
-sub diffSnaps {
+#sub diffSnaps {
-   my ( $source, $target ) = @_;
+#   my ( $config->{'source'}, $config->{'target'} ) = @_;
-   my @source = sort keys %$source;
+#   my @source = sort keys %$config->{'source'};
-   my @target = sort keys %$target;
+#   my @target = sort keys %$config->{'target'};
 #   print "===Source\n" . join( "\n", @source ) . "\n===Target\n" . join( "\n", @target ) . "\n";
-   my $s = 0;
+#   my $s = 0;
-   my $t = 0;
+#   my $t = 0;
-   my %return;
+#   my %return;
-   $return{'deleteTarget'} = [];
+#   $return{'deleteTarget'} = [];
-   $return{'addTarget'} = [];
+#   $return{'addTarget'} = [];
-   $return{'lastMatch'} = 0;
+#   $return{'lastMatch'} = 0;
-   $return{'finalSync'} = 0;
+#   $return{'finalSync'} = 0;
-   while ( $s < @source && $t < @target ) {
+#   while ( $s < @source && $t < @target ) {
-      if ( $source[$s] eq $target[$t] ) { # matchies, just keep going
+#      if ( $config->{'source'}[$s] eq $config->{'target'}[$t] ) { # matchies, just keep going
-#         print "Source $s [$source[$s]] matches target $t [$target[$t]]\n";
+#         print "Source $s [$config->{'source'}[$s]] matches target $t [$config->{'target'}[$t]]\n";
-         $return{'lastMatch'} = $source[$s]; # keep track of the largest match
+#         $return{'lastMatch'} = $config->{'source'}[$s]; # keep track of the largest match
-         $s++; $t++;
+#         $s++; $t++;
-      } elsif ( $target[$t] ne $source[$s] ) { # we are processing stuff that needs to be deleted on target
+#      } elsif ( $config->{'target'}[$t] ne $config->{'source'}[$s] ) { # we are processing stuff that needs to be deleted on target
-         push @{$return{'deleteTarget'}}, $target[$t];
+#         push @{$return{'deleteTarget'}}, $config->{'target'}[$t];
-#         print "Adding delete target $t [$target[$t]]\n";
+#         print "Adding delete target $t [$config->{'target'}[$t]]\n";
-         $t++;
+#         $t++;
-      }
+#      }
-   }
+#   }
-   die "Could not reconcile snapshots, ran out of source too soon\n" if $s > @source;
+#   die "Could not reconcile snapshots, ran out of source too soon\n" if $s > @source;
-   # put a value into finalSync to make sure there is one. If we do not have any sync
+#   # put a value into finalSync to make sure there is one. If we do not have any sync
-   # to do, final and lastMatch will be the same
+#   # to do, final and lastMatch will be the same
-   $return{'finalSync'} = $return{'lastMatch'};
+#   $return{'finalSync'} = $return{'lastMatch'};
-   while ( $s < @source ) {
+#   while ( $s < @source ) {
-      push @{$return{'addTarget'}}, $source[$s];
+#      push @{$return{'addTarget'}}, $config->{'source'}[$s];
-      $return{'finalSync'} = $source[$s];
+#      $return{'finalSync'} = $config->{'source'}[$s];
-      $s++;
+#      $s++;
-   }
+#   }
 #   die Dumper( \%return );
-   return \%return;
+#   return \%return;
-}
+#}
-sub arrayEquals {
+#sub arrayEquals {
-   my ($a, $b ) = @_;
+#   my ($a, $b ) = @_;
-   return 0 unless @{$a} == @{$b}; # they are different sizes
+#   return 0 unless @{$a} == @{$b}; # they are different sizes
-   for ( my $i = 0; $i < @$a; $i++ ) {
+#   for ( my $i = 0; $i < @$a; $i++ ) {
-      if ( $$a[$i] ne $$b[$i] ) {
+#      if ( $$a[$i] ne $$b[$i] ) {
-         print STDERR "No Match!\n" . join( "\t", @$a ) . "\n" . join( "\t", @$b ) . "\n";
+#         print STDERR "No Match!\n" . join( "\t", @$a ) . "\n" . join( "\t", @$b ) . "\n";
-         return 0;
+#         return 0;
-      }
+#      }
-   }
+#   }
-   return 1;
+#   return 1;
-}
+#}
 sub createCommands {
-   my ( $source, $target, $config ) = @_;
+   my ( $config->{'source'}, $config->{'target'}, $config ) = @_;
    my @return;
    # check for new snapshots to sync
-   if ( $source ne $target ) {
+   if ( $config->{'source'} ne $config->{'target'} ) {
       # first create the replicate command. The send command request recursion (-R)
       # and the range of snapshots including all intermediate ones (-I)
-      my $sourceCommand = 'zfs send -RI ';
+      my $config->{'source'}Command = 'zfs send -RI ';
-      $sourceCommand .= $config->{'source'}->{'dataset'} . '@' . $target . ' ';
+      $config->{'source'}Command .= $config->{'source'}->{'dataset'} . '@' . $config->{'target'} . ' ';
-      $sourceCommand .= $config->{'source'}->{'dataset'} . '@' . $source;
+      $config->{'source'}Command .= $config->{'source'}->{'dataset'} . '@' . $config->{'source'};
-      $sourceCommand = "ssh $config->{source}->{server} '$sourceCommand'" if $config->{'source'}->{'server'};
+      $config->{'source'}Command = "ssh $config->{source}->{server} '$config->{'source'}Command'" if $config->{'source'}->{'server'};
-      my $targetCommand = 'zfs receive -v ';
+      my $config->{'target'}Command = 'zfs receive -v ';
-      $targetCommand .= $config->{'target'}->{'dataset'};
+      $config->{'target'}Command .= $config->{'target'}->{'dataset'};
-      $targetCommand = "ssh $config->{target}->{server} '$sourceCommand'" if $config->{'target'}->{'server'};
+      $config->{'target'}Command = "ssh $config->{target}->{server} '$config->{'source'}Command'" if $config->{'target'}->{'server'};
-      push @return, $sourceCommand . ' | ' . $targetCommand;
+      push @return, $config->{'source'}Command . ' | ' . $config->{'target'}Command;
    } else {
       push @return, '# Nothing new to sync';
+   }
    # now, check for snapshots to remove
    #if ( $config->{'actions'}->{'deleteTarget'} ) {
    if ( $config->{'source'}->{'allOk'} and $config->{'target'}->{'allOk'} ) { # whew, they match
       return( $config->{'source'}->{'last'}, $config->{'target'}->{'last'}, \@warnings );
    } else {
       return( '','',\@warnings);
+   }
-}
+} # sub calculate
+GetOptions( $config,
+   'source|s=s',
+   'target|t=s',
+   'filter|f=s',
+   'dryrun|n',
+   'recurse|r',
+   'verbose|v',
+   'help|h'
+);
+# allow them to use positional, without flags, such as
+# replicate source target --filter='regex' -n
+$config->{'source'} = shift unless $config->{'source'};
+$config->{'target'} = shift unless $config->{'target'};
+die "You must enter a source and a target, at a minimum\n" unless $config->{'source'} && $config->{'target'};
+# WARNING: this converts source and targets from a string to a hash
+# '10.0.0.1:data/set' becomes ( 'server' => '10.0.0.1', 'dataset' => 'data/set')
+# and 'data/set' becomes ( 'server' => '', 'dataset' => 'data/set')
-$config->{'source'} = &parseDataSet( $source );
+$config->{'source'} = &parseDataSet( $config->{'source'} );
-$config->{'target'} = &parseDataSet( $target );
+$config->{'target'} = &parseDataSet( $config->{'target'} );
 # both source and target can not have a server portion; one must be local
 die "Source and Target can not both be remote\n" if $config->{'source'}->{'server'} && $config->{'target'}->{'server'};
-$config->{'source'}->{'snapshots'} = &getSnaps( $config->{'source'}, $config->{'pattern'} );
+$config->{'source'}->{'snapshots'} = &getSnaps( $config->{'source'}, $config->{'filter'} );
-$config->{'target'}->{'snapshots'} = &getSnaps( $config->{'target'}, $config->{'pattern'} );
+$config->{'target'}->{'snapshots'} = &getSnaps( $config->{'target'}, $config->{'filter'} );
-# $config->{'actions'} = &calculate( $config );
+# we sync from last snap on target machine to last snap on source machine
 my ( $lastSource, $lastTarget ) = &calculate( $config );
 #print Dumper( $config ) . "\nSource = $lastSource\nTarget = $lastTarget\n"; die;
+# actually creates the commands to do the replicate
 my $commands = &createCommands( $lastSource, $lastTarget, $config );
 for ( my $i = 0; $i < @{$commands}; $i++ ) {
-   print "$$commands[$i]\n";
+   print "$$commands[$i]\n" if $config->{'verbose'} or $config->{'dryrun'};
-   if ( $dryRun ) {
+   if ( $config->{'dryrun'} ) {
       print "Dry Run\n";
    } else {
       print qx/$$commands[$i]/ if $$commands[$i] =~ m/^[a-zA-Z]/;
+   }
+}

Subversion Repositories zfs_utils

(root)/trunk/replication/replicate – Rev 2 → 4