src/PVE/LXC/Create.pm

   1 package PVE::LXC::Create;
   2
   3 use strict;
   4 use warnings;
   5 use File::Basename;
   6 use File::Path;
   7 use Data::Dumper;
   8
   9 use PVE::Storage;
  10 use PVE::LXC;
  11 use PVE::LXC::Setup;
  12 use PVE::VZDump::ConvertOVZ;
  13 use PVE::Tools;
  14
  15 sub next_free_nbd_dev {
  16
  17     for(my $i = 0;;$i++) {
  18         my $dev = "/dev/nbd$i";
  19         last if ! -b $dev;
  20         next if -f "/sys/block/nbd$i/pid"; # busy
  21         return $dev;
  22     }
  23     die "unable to find free nbd device\n";
  24 }
  25
  26 sub restore_archive {
  27     my ($archive, $rootdir, $conf, $no_unpack_error) = @_;
  28
  29     my ($id_map, $rootuid, $rootgid) = PVE::LXC::parse_id_maps($conf);
  30     my $userns_cmd = PVE::LXC::userns_command($id_map);
  31
  32     my $cmd = [@$userns_cmd, 'tar', 'xpf', $archive, '--totals',
  33                @$PVE::LXC::COMMON_TAR_FLAGS,
  34                '-C', $rootdir];
  35
  36     # skip-old-files doesn't have anything to do with time (old/new), but is
  37     # simply -k (annoyingly also called --keep-old-files) without the 'treat
  38     # existing files as errors' part... iow. it's bsdtar's interpretation of -k
  39     # *sigh*, gnu...
  40     push @$cmd, '--skip-old-files';
  41     push @$cmd, '--anchored';
  42     push @$cmd, '--exclude' , './dev/*';
  43
  44     if ($archive eq '-') {
  45         print "extracting archive from STDIN\n";
  46         eval { PVE::Tools::run_command($cmd, input => "<&STDIN"); };
  47     } else {
  48         print "extracting archive '$archive'\n";
  49         eval { PVE::Tools::run_command($cmd); };
  50     }
  51     die $@ if $@ && !$no_unpack_error;
  52
  53     # determine file type of /usr/bin/file itself to get guests' architecture
  54     $cmd = [@$userns_cmd, '/usr/bin/file', '-b', '-L', "$rootdir/bin/sh"];
  55     PVE::Tools::run_command($cmd, outfunc => sub {
  56         shift =~ /^ELF (\d{2}-bit)/; # safely assumes x86 linux
  57         my $arch_str = $1;
  58         $conf->{'arch'} = 'amd64'; # defaults to 64bit
  59         if(defined($arch_str)) {
  60             $conf->{'arch'} = 'i386' if $arch_str =~ /32/;
  61             print "Detected container architecture: $conf->{'arch'}\n";
  62         } else {
  63             print "CT architecture detection failed, falling back to amd64.\n" .
  64                   "Edit the config in /etc/pve/nodes/{node}/lxc/{vmid}/config " .
  65                   "to set another architecture.\n";
  66         }
  67     });
  68 }
  69
  70 sub tar_archive_search_conf {
  71     my ($archive) = @_;
  72
  73     die "ERROR: file '$archive' does not exist\n" if ! -f $archive;
  74
  75     my $pid = open(my $fh, '-|', 'tar', 'tf', $archive) ||
  76        die "unable to open file '$archive'\n";
  77
  78     my $file;
  79     while (defined($file = <$fh>)) {
  80         if ($file =~ m!^(\./etc/vzdump/(pct|vps)\.conf)$!) {
  81             $file = $1; # untaint
  82             last;
  83         }
  84     }
  85
  86     kill 15, $pid;
  87     waitpid $pid, 0;
  88     close $fh;
  89
  90     die "ERROR: archive contains no configuration file\n" if !$file;
  91     chomp $file;
  92
  93     return $file;
  94 }
  95
  96 sub recover_config {
  97     my ($archive) = @_;
  98
  99     my $conf_file = tar_archive_search_conf($archive);
 100
 101     my $raw = '';
 102     my $out = sub {
 103         my $output = shift;
 104         $raw .= "$output\n";
 105     };
 106
 107     PVE::Tools::run_command(['tar', '-xpOf', $archive, $conf_file, '--occurrence'], outfunc => $out);
 108
 109     my $conf;
 110     my $disksize;
 111
 112     if ($conf_file =~ m/pct\.conf/) {
 113
 114         $conf = PVE::LXC::parse_pct_config("/lxc/0.conf" , $raw);
 115
 116         delete $conf->{snapshots};
 117         delete $conf->{template}; # restored CT is never a template
 118
 119         if (defined($conf->{rootfs})) {
 120             my $rootinfo = PVE::LXC::parse_ct_rootfs($conf->{rootfs});
 121             $disksize = $rootinfo->{size} if defined($rootinfo->{size});
 122         }
 123
 124     } elsif ($conf_file =~ m/vps\.conf/) {
 125
 126         ($conf, $disksize) = PVE::VZDump::ConvertOVZ::convert_ovz($raw);
 127
 128     } else {
 129
 130        die "internal error";
 131     }
 132
 133     return wantarray ? ($conf, $disksize) : $conf;
 134 }
 135
 136 sub restore_and_configure {
 137     my ($vmid, $archive, $rootdir, $conf, $password, $restore, $no_unpack_error) = @_;
 138
 139     restore_archive($archive, $rootdir, $conf, $no_unpack_error);
 140
 141     if (!$restore) {
 142         my $lxc_setup = PVE::LXC::Setup->new($conf, $rootdir); # detect OS
 143
 144         PVE::LXC::Config->write_config($vmid, $conf); # safe config (after OS detection)
 145         $lxc_setup->post_create_hook($password);
 146     } else {
 147         # restore: try to extract configuration from archive
 148
 149         my $pct_cfg_fn = "$rootdir/etc/vzdump/pct.conf";
 150         my $pct_fwcfg_fn = "$rootdir/etc/vzdump/pct.fw";
 151         my $ovz_cfg_fn = "$rootdir/etc/vzdump/vps.conf";
 152         if (-f $pct_cfg_fn) {
 153             my $raw = PVE::Tools::file_get_contents($pct_cfg_fn);
 154             my $oldconf = PVE::LXC::parse_pct_config("/lxc/$vmid.conf", $raw);
 155
 156             foreach my $key (keys %$oldconf) {
 157                 next if $key eq 'digest' || $key eq 'rootfs' || $key eq 'snapshots' || $key eq 'unprivileged';
 158                 next if $key =~ /^mp\d+$/; # don't recover mountpoints
 159                 $conf->{$key} = $oldconf->{$key} if !defined($conf->{$key});
 160             }
 161             unlink($pct_cfg_fn);
 162
 163             if (-f $pct_fwcfg_fn) {
 164                 my $pve_firewall_dir = '/etc/pve/firewall';
 165                 mkdir $pve_firewall_dir; # make sure the directory exists
 166                 PVE::Tools::file_copy($pct_fwcfg_fn, "${pve_firewall_dir}/$vmid.fw");
 167                 unlink $pct_fwcfg_fn;
 168             }
 169
 170         } elsif (-f $ovz_cfg_fn) {
 171             print "###########################################################\n";
 172             print "Converting OpenVZ configuration to LXC.\n";
 173             print "Please check the configuration and reconfigure the network.\n";
 174             print "###########################################################\n";
 175
 176             my $lxc_setup = PVE::LXC::Setup->new($conf, $rootdir); # detect OS
 177             $conf->{ostype} = $lxc_setup->{conf}->{ostype};
 178             my $raw = PVE::Tools::file_get_contents($ovz_cfg_fn);
 179             my $oldconf = PVE::VZDump::ConvertOVZ::convert_ovz($raw);
 180             foreach my $key (keys %$oldconf) {
 181                 $conf->{$key} = $oldconf->{$key} if !defined($conf->{$key});
 182             }
 183             unlink($ovz_cfg_fn);
 184
 185         } else {
 186             print "###########################################################\n";
 187             print "Backup archive does not contain any configuration\n";
 188             print "###########################################################\n";
 189         }
 190     }
 191 }
 192
 193 sub create_rootfs {
 194     my ($storage_cfg, $vmid, $conf, $archive, $password, $restore, $no_unpack_error) = @_;
 195
 196     my $config_fn = PVE::LXC::Config->config_file($vmid);
 197     if (-f $config_fn) {
 198         die "container exists" if !$restore; # just to be sure
 199
 200         my $old_conf = PVE::LXC::Config->load_config($vmid);
 201
 202         # destroy old container volume
 203         PVE::LXC::destroy_lxc_container($storage_cfg, $vmid, $old_conf);
 204
 205         # do not copy all settings to restored container
 206         foreach my $opt (qw(rootfs digest snapshots arch ostype unprivileged parent)) {
 207             delete $old_conf->{$opt};
 208         }
 209         foreach my $opt (keys %$old_conf) {
 210             delete $old_conf->{$opt} if $opt =~ m/^mp\d+$/;
 211         }
 212
 213         PVE::LXC::update_pct_config($vmid, $conf, 0, $old_conf);
 214
 215         PVE::LXC::Config->write_config($vmid, $conf);
 216
 217     } else {
 218
 219         PVE::LXC::Config->write_config($vmid, $conf);
 220     }
 221
 222     eval {
 223         my $rootdir = PVE::LXC::mount_all($vmid, $storage_cfg, $conf);
 224         restore_and_configure($vmid, $archive, $rootdir, $conf, $password, $restore, $no_unpack_error);
 225     };
 226     my $err = $@;
 227     PVE::LXC::umount_all($vmid, $storage_cfg, $conf, $err ? 1 : 0);
 228     PVE::Storage::deactivate_volumes($storage_cfg, PVE::LXC::get_vm_volumes($conf));
 229     die $err if $err;
 230 }
 231
 232 1;