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	#!/usr/bin/perl -w
2
3	use strict;
4	use Shell qw/rsync lvcreate mount umount lvremove which lvdisplay mke2fs/;
5
6	use lib 'lib';
7	use VZ;
8
9	my $snap_size = '10G';
10
11	my ( $action, $VEID ) = @ARGV;
12
13	my $use_snapshot = 1;
14
15	my $valid_actions = 'create\|mount\|umount\|destroy';
16
17	die "Usage: $0 ($valid_actions) VEID\n\n",`vzlist` unless $VEID && $action && $action =~ m{($valid_actions)};
18
19	my $CVEID = "10$VEID";
20
21	sub vzctl_stop {
22	my $veid = shift;
23	my $vzlist = vzlist();
24	if ( $vzlist =~ m/$veid/ ) {
25	print "stop $veid\n";
26	vzctl('stop', $veid);
27	}
28	}
29
30	if ( $action eq 'create' ) {
31	vzctl_stop( $CVEID );
32	} elsif ( $action eq 'destroy' ) {
33	vzctl_stop( $VEID );
34	}
35
36
37	if ( $action =~ m{(create\|umount\|destroy)} ) {
38	my $clone;
39	my $snap;
40	open(my $m, '-\|', 'mount') \|\| die "can't open mount: $!";
41	while(<$m>) {
42	my @v = split(/\s+/,$_);
43	if ( $v[2] =~ m{/(private\|root)/($VEID\|$CVEID)$} && $v[5] =~ m{bind} ) {
44	umount( $v[2] );
45	} elsif ( $v[2] =~ m{vz-clone-$CVEID$} ) {
46	$clone = $v[2];
47	} elsif ( $v[2] =~ m{-snap} ) {
48	$snap = $v[0];
49	umount( $snap );
50	}
51	}
52	umount( $clone ) if $clone;
53	if ( $action eq 'destroy' && -e $snap ) {
54	lvremove( '-f', $snap );
55	}
56
57	vzctl('destroy', $VEID) if $action eq 'destroy';
58
59	exit if $action =~ m{(umount\|destroy)};
60	}
61
62
63	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	my $vz_lv;
70
71	open(my $m, '-\|', "df $vz_root") \|\| die "can't open df $vz_root: $!";
72	while(<$m>) {
73	next if ! m{^/};
74	my @v = split(/\s+/,$_);
75	$vz_lv = $v[0];
76	warn "found LV $vz_lv for $vz_root\n";
77	last;
78	}
79
80	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	sub copy_files {
92	my ( $from, $to ) = @_;
93	return if $action ne 'create';
94	warn "rsync $from -> $to\n";
95	rsync('-raSHAD', '--delete', "$from/", "$to/" );
96	}
97
98	if ( $vz_lv ) {
99
100	my ( $vz_lv_path, $vz_lv_name ) = ( $1, $2 ) if ( $vz_lv =~ m{^(.+)/([^/]+)$} );
101
102	my $snap = $vz_lv_name . '-snap';
103	my $clone = "vz-clone-$CVEID";
104
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	if ( $use_snapshot ) {
127
128	print "Creating $snap_size snapshot $snap from $vz_lv\n";
129	lvcreate( '--size', $snap_size, '--snapshot', '--name', $snap, $vz_lv );
130
131	do_mount( "$vz_lv_path/$snap", "/tmp/$snap" );
132
133	mount_bind( "/tmp/$snap/private/$VEID", "$vz_root/private/$CVEID" );
134	mount_bind( "/tmp/$snap/root/$VEID", "$vz_root/root/$CVEID" );
135
136	} else {
137
138	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
148	do_mount( "$vz_lv_path/$clone", "/tmp/$clone" );
149
150	test_mkdir( "/tmp/$clone/private" );
151	test_mkdir( "/tmp/$clone/root" );
152
153	copy_files( "$vz_root/private/$VEID", "/tmp/$clone/private" );
154
155	mount_bind( "/tmp/$clone/private", "$vz_root/private/$CVEID" );
156	mount_bind( "/tmp/$clone/root", "$vz_root/root/$CVEID" );
157
158	}
159
160	} else {
161
162	copy_files( "$vz_root/private/$VEID", "$vz_root/private/$CVEID" );
163	}
164
165	exit if $action eq 'mount';
166
167	my $note = "# modified by $0\n";
168
169	my $ve_clone_ip;
170
171	sub fix_ip {
172	my $ip = shift;
173	$ip =~ s/['"]//g;
174	# $ip =~ s/^\d+\./10./;
175	$ip =~ s/^\d+\.\d+\./192.168./;
176	warn "$CVEID new IP number: $ip\n";
177	$ve_clone_ip = $ip;
178	return $note . qq{IP_ADDRESS="$ip"};
179	}
180
181	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	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	while(<$o>) {
192	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	print $n $_;
196	}
197
198	print $n qq{DISK_QUOTA="no"\n} if $use_snapshot; # don't wait for quota rebuild on startup
199
200	my $iptables="iptables -t nat -A POSTROUTING -s $ve_clone_ip -o eth0 -j MASQUERADE";
201	system( $iptables );
202	print "\nConfig file: $vz_conf/$CVEID.conf\nAdded NAT for new VE with: $iptables\nStart clone of $VEID with: vzctl start $CVEID\n"
203