vz-tools/trunk/vz-clone.pl

#!/usr/bin/perl -w

use strict;
use Shell qw/rsync lvcreate mount umount lvremove which lvdisplay mke2fs/;

use lib 'lib';
use VZ;

my $snap_size = '10G';

my ( $action, $VEID ) = @ARGV;

my $use_snapshot = 1;

my $valid_actions = 'create|mount|umount|destroy';

die "Usage: $0 ($valid_actions) VEID\n\n",`vzlist` unless $VEID && $action && $action =~ m{($valid_actions)};

my $CVEID = "10$VEID";

sub vzctl_stop {
        my $veid = shift;
        my $vzlist = vzlist();
        if ( $vzlist =~ m/$veid/ ) {
                print "stop $veid\n";
                vzctl('stop', $veid);
        }
}

if ( $action eq 'create' ) {
        vzctl_stop( $CVEID );
} elsif ( $action eq 'destroy' ) {
        vzctl_stop( $VEID );
}


if ( $action =~ m{(create|umount|destroy)} ) {
        my $clone;
        my $snap;
        open(my $m, '-|', 'mount') || die "can't open mount: $!";
        while(<$m>) {
                my @v = split(/\s+/,$_);
                if ( $v[2] =~ m{/(private|root)/($VEID|$CVEID)$} && $v[5] =~ m{bind} ) {
                        umount( $v[2] );
                } elsif ( $v[2] =~ m{vz-clone-$CVEID$} ) {
                        $clone = $v[2];
                } elsif ( $v[2] =~ m{-snap} ) {
                        $snap = $v[0];
                        umount( $snap );
                }
        }
        umount( $clone ) if $clone;
        if ( $action eq 'destroy' && -e $snap ) {
                lvremove( '-f', $snap );
        }

        vzctl('destroy', $VEID) if $action eq 'destroy';

        exit if $action =~ m{(umount|destroy)};
}


my $orig_conf = "/etc/vz/conf/$VEID.conf";

die "$VEID config $orig_conf doesn't exist\n" unless -e $orig_conf;

print "Clone VE $VEID -> $CVEID\n";

my $vz_lv;

open(my $m, '-|', "df $vz_root") || die "can't open df $vz_root: $!";
while(<$m>) {
        next if ! m{^/};
        my @v = split(/\s+/,$_);
        $vz_lv = $v[0];
        warn "found LV $vz_lv for $vz_root\n";
        last;
}

sub fs_quota {
        my $id = shift;
        open(my $q, '-|', "vzquota -b show $id") || die "can't exec vzquota show $id: $!";
        my $l = <$q>;
        $l =~ s/^\s+//;
        my ( $usage, $soft, $hard ) = split(/\s+/,$l);
        warn "quota for $id | $soft < $hard | usage: $usage\n";
        return ( $usage, $soft, $hard ) if wantarray;
        return $soft;
}

sub copy_files {
        my ( $from, $to ) = @_;
        return if $action ne 'create';
        warn "rsync $from -> $to\n";
        rsync('-raSHAD', '--delete', "$from/", "$to/" );
}

if ( $vz_lv ) {

        my ( $vz_lv_path, $vz_lv_name ) = ( $1, $2 ) if ( $vz_lv =~ m{^(.+)/([^/]+)$} );

        my $snap = $vz_lv_name . '-snap';
        my $clone = "vz-clone-$CVEID";

        sub do_mount {
                my ( $from, $to ) = @_;
                mkdir $to || die "can't create $to: $!";
                print "Mounting $from to $to\n";
                mount( $from, $to, '-o', 'noatime' );
        }

        sub test_mkdir {
                my $dir = shift;
                if ( ! -d $dir ) {
                        mkdir $dir || die "can't mkdir $dir: $!";
                }
        }

        sub mount_bind {
                my ( $from, $to ) = @_;
                die "$from doesn't exist!" unless -d $from;
                test_mkdir( $to );
                mount( '--bind', $from, $to );
        }

        if ( $use_snapshot ) {

                print "Creating $snap_size snapshot $snap from $vz_lv\n";
                lvcreate( '--size', $snap_size, '--snapshot', '--name', $snap, $vz_lv );

                do_mount( "$vz_lv_path/$snap", "/tmp/$snap" );
        
                mount_bind( "/tmp/$snap/private/$VEID", "$vz_root/private/$CVEID" );
                mount_bind( "/tmp/$snap/root/$VEID", "$vz_root/root/$CVEID" );

        } else {

                if ( lvdisplay( "$vz_lv_path/$clone" ) ) {
                        warn "using existing $vz_lv_path/$clone\n";
                } else {
                        my $vg_name = $1 if ( $vz_lv_path =~ m{/([^/]+)/*$} );
                        my $clone_size = fs_quota( $VEID ) . 'k';
                        print "Creating LV $clone ($clone_size bytes) in VG $vg_name for $VEID clone filesystem\n";
                        lvcreate( '--size', $clone_size, '--name', $clone, $vg_name );
                        mke2fs( '-m', 0, '-j', "$vz_lv_path/$clone" );
                }

                do_mount( "$vz_lv_path/$clone", "/tmp/$clone" );

                test_mkdir( "/tmp/$clone/private" );
                test_mkdir( "/tmp/$clone/root" );

                copy_files( "$vz_root/private/$VEID", "/tmp/$clone/private" );

                mount_bind( "/tmp/$clone/private", "$vz_root/private/$CVEID" );
                mount_bind( "/tmp/$clone/root", "$vz_root/root/$CVEID" );

        }

} else {

        copy_files( "$vz_root/private/$VEID", "$vz_root/private/$CVEID" );
}

exit if $action eq 'mount';

my $note = "# modified by $0\n";

my $ve_clone_ip;

sub fix_ip {
        my $ip = shift;
        $ip =~ s/['"]//g;
#       $ip =~ s/^\d+\./10./;
        $ip =~ s/^\d+\.\d+\./192.168./;
        warn "$CVEID new IP number: $ip\n";
        $ve_clone_ip = $ip;
        return $note . qq{IP_ADDRESS="$ip"};
}

sub fix_hostname {
        my $hostname = shift;
        $hostname =~ s/['"]//g;
        $hostname = "clone-$hostname";
        warn "$CVEID new hostname: $hostname\n";
        return $note . qq{HOSTNAME="$hostname"};
}

open(my $o, '<', "$vz_conf/$VEID.conf")  || die "can't open $vz_conf/$VEID.conf: $!";
open(my $n, '>', "$vz_conf/$CVEID.conf") || die "can't open $vz_conf/$CVEID.conf: $!";
while(<$o>) {
        s{^HOSTNAME=(.*)$}{fix_hostname($1)}ie;
        s{^IP_ADDRESS=(.*)$}{fix_ip($1)}ie;
        s{^(ONBOOT=).*$}{# modified by $0\n$1"no"}i;
        print $n $_;
}

print $n qq{DISK_QUOTA="no"\n} if $use_snapshot; # don't wait for quota rebuild on startup

my $iptables="iptables -t nat -A POSTROUTING -s $ve_clone_ip -o eth0 -j MASQUERADE";
system( $iptables );
print "\nConfig file: $vz_conf/$CVEID.conf\nAdded NAT for new VE with: $iptables\nStart clone of $VEID with: vzctl start $CVEID\n"

1	dpavlin	20	#!/usr/bin/perl -w
2
3			use strict;
4	dpavlin	73	use Shell qw/rsync lvcreate mount umount lvremove which lvdisplay mke2fs/;
5	dpavlin	20
6	dpavlin	73	use lib 'lib';
7			use VZ;
8	dpavlin	20
9	dpavlin	67	my $snap_size = '10G';
10	dpavlin	21
11	dpavlin	25	my ( $action, $VEID ) = @ARGV;
12	dpavlin	20
13	dpavlin	65	my $use_snapshot = 1;
14	dpavlin	27
15	dpavlin	29	my $valid_actions = 'create\|mount\|umount\|destroy';
16	dpavlin	25
17	dpavlin	73	die "Usage: $0 ($valid_actions) VEID\n\n",`vzlist` unless $VEID && $action && $action =~ m{($valid_actions)};
18	dpavlin	25
19	dpavlin	27	my $CVEID = "10$VEID";
20
21			sub vzctl_stop {
22			my $veid = shift;
23	dpavlin	25	my $vzlist = vzlist();
24	dpavlin	27	if ( $vzlist =~ m/$veid/ ) {
25			print "stop $veid\n";
26			vzctl('stop', $veid);
27	dpavlin	25	}
28			}
29
30	dpavlin	27	if ( $action eq 'create' ) {
31			vzctl_stop( $CVEID );
32			} elsif ( $action eq 'destroy' ) {
33			vzctl_stop( $VEID );
34			}
35
36
37	dpavlin	66	if ( $action =~ m{(create\|umount\|destroy)} ) {
38	dpavlin	25	my $clone;
39	dpavlin	66	my $snap;
40	dpavlin	25	open(my $m, '-\|', 'mount') \|\| die "can't open mount: $!";
41			while(<$m>) {
42			my @v = split(/\s+/,$_);
43	dpavlin	66	if ( $v[2] =~ m{/(private\|root)/($VEID\|$CVEID)$} && $v[5] =~ m{bind} ) {
44	dpavlin	25	umount( $v[2] );
45	dpavlin	64	} elsif ( $v[2] =~ m{vz-clone-$CVEID$} ) {
46	dpavlin	25	$clone = $v[2];
47	dpavlin	66	} elsif ( $v[2] =~ m{-snap} ) {
48			$snap = $v[0];
49			umount( $snap );
50	dpavlin	25	}
51			}
52			umount( $clone ) if $clone;
53	dpavlin	66	if ( $action eq 'destroy' && -e $snap ) {
54			lvremove( '-f', $snap );
55			}
56	dpavlin	30
57	dpavlin	69	vzctl('destroy', $VEID) if $action eq 'destroy';
58
59			exit if $action =~ m{(umount\|destroy)};
60	dpavlin	25	}
61
62
63	dpavlin	20	my $orig_conf = "/etc/vz/conf/$VEID.conf";
64
65			die "$VEID config $orig_conf doesn't exist\n" unless -e $orig_conf;
66
67			print "Clone VE $VEID -> $CVEID\n";
68
69	dpavlin	21	my $vz_lv;
70	dpavlin	20
71	dpavlin	73	open(my $m, '-\|', "df $vz_root") \|\| die "can't open df $vz_root: $!";
72	dpavlin	21	while(<$m>) {
73	dpavlin	73	next if ! m{^/};
74	dpavlin	21	my @v = split(/\s+/,$_);
75	dpavlin	73	$vz_lv = $v[0];
76			warn "found LV $vz_lv for $vz_root\n";
77			last;
78	dpavlin	21	}
79
80	dpavlin	23	sub fs_quota {
81			my $id = shift;
82			open(my $q, '-\|', "vzquota -b show $id") \|\| die "can't exec vzquota show $id: $!";
83			my $l = <$q>;
84			$l =~ s/^\s+//;
85			my ( $usage, $soft, $hard ) = split(/\s+/,$l);
86			warn "quota for $id \| $soft < $hard \| usage: $usage\n";
87			return ( $usage, $soft, $hard ) if wantarray;
88			return $soft;
89			}
90
91	dpavlin	21	sub copy_files {
92			my ( $from, $to ) = @_;
93	dpavlin	29	return if $action ne 'create';
94	dpavlin	24	warn "rsync $from -> $to\n";
95	dpavlin	31	rsync('-raSHAD', '--delete', "$from/", "$to/" );
96	dpavlin	21	}
97
98			if ( $vz_lv ) {
99
100	dpavlin	64	my ( $vz_lv_path, $vz_lv_name ) = ( $1, $2 ) if ( $vz_lv =~ m{^(.+)/([^/]+)$} );
101	dpavlin	21
102			my $snap = $vz_lv_name . '-snap';
103	dpavlin	26	my $clone = "vz-clone-$CVEID";
104	dpavlin	23
105			sub do_mount {
106			my ( $from, $to ) = @_;
107			mkdir $to \|\| die "can't create $to: $!";
108			print "Mounting $from to $to\n";
109			mount( $from, $to, '-o', 'noatime' );
110			}
111
112			sub test_mkdir {
113			my $dir = shift;
114			if ( ! -d $dir ) {
115			mkdir $dir \|\| die "can't mkdir $dir: $!";
116			}
117			}
118
119			sub mount_bind {
120			my ( $from, $to ) = @_;
121			die "$from doesn't exist!" unless -d $from;
122			test_mkdir( $to );
123			mount( '--bind', $from, $to );
124			}
125
126	dpavlin	27	if ( $use_snapshot ) {
127	dpavlin	21
128	dpavlin	27	print "Creating $snap_size snapshot $snap from $vz_lv\n";
129			lvcreate( '--size', $snap_size, '--snapshot', '--name', $snap, $vz_lv );
130	dpavlin	21
131	dpavlin	27	do_mount( "$vz_lv_path/$snap", "/tmp/$snap" );
132
133	dpavlin	73	mount_bind( "/tmp/$snap/private/$VEID", "$vz_root/private/$CVEID" );
134			mount_bind( "/tmp/$snap/root/$VEID", "$vz_root/root/$CVEID" );
135	dpavlin	27
136	dpavlin	23	} else {
137	dpavlin	21
138	dpavlin	65	if ( lvdisplay( "$vz_lv_path/$clone" ) ) {
139			warn "using existing $vz_lv_path/$clone\n";
140			} else {
141			my $vg_name = $1 if ( $vz_lv_path =~ m{/([^/]+)/*$} );
142			my $clone_size = fs_quota( $VEID ) . 'k';
143			print "Creating LV $clone ($clone_size bytes) in VG $vg_name for $VEID clone filesystem\n";
144			lvcreate( '--size', $clone_size, '--name', $clone, $vg_name );
145			mke2fs( '-m', 0, '-j', "$vz_lv_path/$clone" );
146			}
147	dpavlin	21
148	dpavlin	65	do_mount( "$vz_lv_path/$clone", "/tmp/$clone" );
149	dpavlin	21
150	dpavlin	65	test_mkdir( "/tmp/$clone/private" );
151			test_mkdir( "/tmp/$clone/root" );
152	dpavlin	21
153	dpavlin	73	copy_files( "$vz_root/private/$VEID", "/tmp/$clone/private" );
154	dpavlin	23
155	dpavlin	73	mount_bind( "/tmp/$clone/private", "$vz_root/private/$CVEID" );
156			mount_bind( "/tmp/$clone/root", "$vz_root/root/$CVEID" );
157	dpavlin	23
158	dpavlin	27	}
159
160	dpavlin	21	} else {
161
162	dpavlin	73	copy_files( "$vz_root/private/$VEID", "$vz_root/private/$CVEID" );
163	dpavlin	21	}
164
165	dpavlin	29	exit if $action eq 'mount';
166
167	dpavlin	21	my $note = "# modified by $0\n";
168
169	dpavlin	50	my $ve_clone_ip;
170
171	dpavlin	20	sub fix_ip {
172			my $ip = shift;
173	dpavlin	21	$ip =~ s/['"]//g;
174	dpavlin	33	# $ip =~ s/^\d+\./10./;
175			$ip =~ s/^\d+\.\d+\./192.168./;
176	dpavlin	20	warn "$CVEID new IP number: $ip\n";
177	dpavlin	50	$ve_clone_ip = $ip;
178	dpavlin	21	return $note . qq{IP_ADDRESS="$ip"};
179	dpavlin	20	}
180
181	dpavlin	21	sub fix_hostname {
182			my $hostname = shift;
183			$hostname =~ s/['"]//g;
184			$hostname = "clone-$hostname";
185			warn "$CVEID new hostname: $hostname\n";
186			return $note . qq{HOSTNAME="$hostname"};
187			}
188
189	dpavlin	73	open(my $o, '<', "$vz_conf/$VEID.conf") \|\| die "can't open $vz_conf/$VEID.conf: $!";
190			open(my $n, '>', "$vz_conf/$CVEID.conf") \|\| die "can't open $vz_conf/$CVEID.conf: $!";
191	dpavlin	20	while(<$o>) {
192	dpavlin	62	s{^HOSTNAME=(.*)$}{fix_hostname($1)}ie;
193			s{^IP_ADDRESS=(.*)$}{fix_ip($1)}ie;
194			s{^(ONBOOT=).*$}{# modified by $0\n$1"no"}i;
195	dpavlin	20	print $n $_;
196			}
197
198	dpavlin	65	print $n qq{DISK_QUOTA="no"\n} if $use_snapshot; # don't wait for quota rebuild on startup
199
200	dpavlin	67	my $iptables="iptables -t nat -A POSTROUTING -s $ve_clone_ip -o eth0 -j MASQUERADE";
201			system( $iptables );
202	dpavlin	73	print "\nConfig file: $vz_conf/$CVEID.conf\nAdded NAT for new VE with: $iptables\nStart clone of $VEID with: vzctl start $CVEID\n"
203	dpavlin	66