test/run_config2command_tests.pl

   1 #!/usr/bin/perl
   2
   3 use strict;
   4 use warnings;
   5
   6 use lib qw(..);
   7
   8 use Test::More;
   9 use Test::MockModule;
  10 use Socket qw(AF_INET AF_INET6);
  11
  12 use PVE::Tools qw(file_get_contents file_set_contents run_command);
  13 use PVE::INotify;
  14 use PVE::SysFSTools;
  15
  16 use PVE::QemuConfig;
  17 use PVE::QemuServer;
  18 use PVE::QemuServer::Monitor;
  19 use PVE::QemuServer::Machine;
  20 use PVE::QemuServer::CPUConfig;
  21
  22 my $base_env = {
  23     storage_config => {
  24         ids => {
  25             local => {
  26                 content => {
  27                     images => 1,
  28                 },
  29                 path => '/var/lib/vz',
  30                 type => 'dir',
  31                 shared => 0,
  32             },
  33             'cifs-store' => {
  34                 shared => 1,
  35                 path => '/mnt/pve/cifs-store',
  36                 username => 'guest',
  37                 server => '127.0.0.42',
  38                 type => 'cifs',
  39                 share => 'CIFShare',
  40                 content => {
  41                     images => 1
  42                 },
  43             },
  44             'rbd-store' => {
  45                 monhost => '127.0.0.42,127.0.0.21,::1',
  46                 content => {
  47                     images => 1
  48                 },
  49                 type => 'rbd',
  50                 pool => 'cpool',
  51                 username => 'admin',
  52                 shared => 1
  53             },
  54             'local-lvm' => {
  55                 vgname => 'pve',
  56                 bwlimit => 'restore=1024',
  57                 type => 'lvmthin',
  58                 thinpool => 'data',
  59                 content => {
  60                     images => 1,
  61                 }
  62             }
  63         }
  64     },
  65     vmid => 8006,
  66     real_qemu_version => PVE::QemuServer::kvm_user_version(), # not yet mocked
  67 };
  68
  69 my $pci_devs = [
  70     "0000:00:43.1",
  71     "0000:00:f4.0",
  72     "0000:00:ff.1",
  73     "0000:0f:f2.0",
  74     "0000:d0:13.0",
  75     "0000:d0:15.1",
  76     "0000:d0:17.0",
  77     "0000:f0:42.0",
  78     "0000:f0:43.0",
  79     "0000:f0:43.1",
  80     "1234:f0:43.1",
  81 ];
  82
  83 my $current_test; # = {
  84 #   description => 'Test description', # if available
  85 #   qemu_version => '2.12',
  86 #   host_arch => 'HOST_ARCH',
  87 #   expected_error => 'error message',
  88 #   expected_warning => 'warning message',
  89 #   config => { config hash },
  90 #   expected => [ expected outcome cmd line array ],
  91 # };
  92
  93 # use the config description to allow changing environment, fields are:
  94 #   TEST: A single line describing the test, gets outputted
  95 #   QEMU_VERSION: \d+\.\d+(\.\d+)? (defaults to current version)
  96 #   HOST_ARCH: x86_64 | aarch64 (default to x86_64, to make tests stable)
  97 #   EXPECT_ERROR: <error message> For negative tests
  98 # all fields are optional
  99 sub parse_test($) {
 100     my ($config_fn) = @_;
 101
 102     $current_test = {}; # reset
 103
 104     my $fake_config_fn ="$config_fn/qemu-server/8006.conf";
 105     my $config_raw = file_get_contents($config_fn);
 106     my $config = PVE::QemuServer::parse_vm_config($fake_config_fn, $config_raw);
 107
 108     $current_test->{config} = $config;
 109
 110     my $description = $config->{description} // '';
 111
 112     while ($description =~ /^\h*(.*?)\h*$/gm) {
 113         my $line = $1;
 114         next if !$line || $line =~ /^#/;
 115         $line =~ s/^\s+//;
 116         $line =~ s/\s+$//;
 117
 118         if ($line =~ /^TEST:\s*(.*)\s*$/) {
 119             $current_test->{description} = "$1";
 120         } elsif ($line =~ /^QEMU_VERSION:\s*(.*)\s*$/) {
 121             $current_test->{qemu_version} = "$1";
 122         } elsif ($line =~ /^HOST_ARCH:\s*(.*)\s*$/) {
 123             $current_test->{host_arch} = "$1";
 124         } elsif ($line =~ /^EXPECT_ERROR:\s*(.*)\s*$/) {
 125             $current_test->{expect_error} = "$1";
 126         } elsif ($line =~ /^EXPECT_WARN(?:ING)?:\s*(.*)\s*$/) {
 127             $current_test->{expect_warning} = "$1";
 128         }
 129     }
 130
 131     $config_fn =~ /([^\/]+)$/;
 132     my $testname = "$1";
 133     if (my $desc = $current_test->{description}) {
 134         $testname = "'$testname' - $desc";
 135     }
 136     $current_test->{testname} = $testname;
 137 }
 138
 139 sub get_test_qemu_version {
 140     $current_test->{qemu_version} // $base_env->{real_qemu_version} // '2.12';
 141 }
 142
 143 my $qemu_server_module;
 144 $qemu_server_module = Test::MockModule->new('PVE::QemuServer');
 145 $qemu_server_module->mock(
 146     kvm_user_version => sub {
 147         return get_test_qemu_version();
 148     },
 149     kvm_version => sub {
 150         return get_test_qemu_version();
 151     },
 152     kernel_has_vhost_net => sub {
 153         return 1; # TODO: make this per-test configurable?
 154     },
 155     get_host_arch => sub() {
 156         return $current_test->{host_arch} // 'x86_64';
 157     },
 158     get_initiator_name => sub {
 159         return 'iqn.1993-08.org.debian:01:aabbccddeeff';
 160     }
 161 );
 162
 163 my $qemu_server_config;
 164 $qemu_server_config = Test::MockModule->new('PVE::QemuConfig');
 165 $qemu_server_config->mock(
 166     load_config => sub {
 167         my ($class, $vmid, $node) = @_;
 168
 169         return $current_test->{config};
 170     },
 171 );
 172
 173 my $pve_common_tools;
 174 $pve_common_tools = Test::MockModule->new('PVE::Tools');
 175 $pve_common_tools->mock(
 176     next_vnc_port => sub {
 177         my ($family, $address) = @_;
 178
 179         return '5900';
 180     },
 181     next_spice_port => sub {
 182         my ($family, $address) = @_;
 183
 184         return '61000';
 185     },
 186     getaddrinfo_all => sub {
 187         my ($hostname, @opts) = @_;
 188         die "need stable hostname" if $hostname ne 'localhost';
 189         return (
 190             {
 191                 addr => Socket::pack_sockaddr_in(0, Socket::INADDR_LOOPBACK),
 192                 family => AF_INET, # IPv4
 193                 protocol => 6,
 194                 socktype => 1,
 195             },
 196         );
 197     },
 198 );
 199
 200 my $pve_cpuconfig;
 201 $pve_cpuconfig = Test::MockModule->new('PVE::QemuServer::CPUConfig');
 202 $pve_cpuconfig->mock(
 203     load_custom_model_conf => sub {
 204         # mock custom CPU model config
 205         return PVE::QemuServer::CPUConfig->parse_config("cpu-models.conf",
 206 <<EOF
 207
 208 # "qemu64" is also a default CPU, used here to test that this doesn't matter
 209 cpu-model: qemu64
 210     reported-model athlon
 211     flags +aes;+avx;-kvm_pv_unhalt
 212     hv-vendor-id testvend
 213     phys-bits 40
 214
 215 cpu-model: alldefault
 216
 217 EOF
 218         )
 219     },
 220 );
 221
 222 my $pve_common_network;
 223 $pve_common_network = Test::MockModule->new('PVE::Network');
 224 $pve_common_network->mock(
 225     read_bridge_mtu => sub {
 226         return 1500;
 227     },
 228 );
 229
 230
 231 my $pve_common_inotify;
 232 $pve_common_inotify = Test::MockModule->new('PVE::INotify');
 233 $pve_common_inotify->mock(
 234     nodename => sub {
 235         return 'localhost';
 236     },
 237 );
 238
 239 my $pve_common_sysfstools;
 240 $pve_common_sysfstools = Test::MockModule->new('PVE::SysFSTools');
 241 $pve_common_sysfstools->mock(
 242     lspci => sub {
 243         my ($filter, $verbose) = @_;
 244
 245         return [
 246             map { { id => $_ } }
 247             grep {
 248                 !defined($filter)
 249                 || (!ref($filter) && $_ =~ m/^(0000:)?\Q$filter\E/)
 250                 || (ref($filter) eq 'CODE' && $filter->({ id => $_ }))
 251             } sort @$pci_devs
 252         ];
 253     },
 254 );
 255
 256 my $qemu_monitor_module;
 257 $qemu_monitor_module = Test::MockModule->new('PVE::QemuServer::Monitor');
 258 $qemu_monitor_module->mock(
 259     mon_cmd => sub {
 260         my ($vmid, $cmd) = @_;
 261
 262         die "invalid vmid: $vmid (expected: $base_env->{vmid})"
 263             if $vmid != $base_env->{vmid};
 264
 265         if ($cmd eq 'query-version') {
 266             my $ver = get_test_qemu_version();
 267             $ver =~ m/(\d+)\.(\d+)(?:\.(\d+))?/;
 268             return {
 269                 qemu => {
 270                     major => $1,
 271                     minor => $2,
 272                     micro => $3
 273                 }
 274             }
 275         }
 276
 277         die "unexpected QMP command: '$cmd'";
 278     },
 279 );
 280 $qemu_monitor_module->mock('qmp_cmd', \&qmp_cmd);
 281
 282 sub diff($$) {
 283     my ($a, $b) = @_;
 284     return if $a eq $b;
 285
 286     my ($ra, $wa) = POSIX::pipe();
 287     my ($rb, $wb) = POSIX::pipe();
 288     my $ha = IO::Handle->new_from_fd($wa, 'w');
 289     my $hb = IO::Handle->new_from_fd($wb, 'w');
 290
 291     open my $diffproc, '-|', 'diff', '-up', "/proc/self/fd/$ra", "/proc/self/fd/$rb" ## no critic
 292         or die "failed to run program 'diff': $!";
 293     POSIX::close($ra);
 294     POSIX::close($rb);
 295
 296     open my $f1, '<', \$a;
 297     open my $f2, '<', \$b;
 298     my ($line1, $line2);
 299     do {
 300         $ha->print($line1) if defined($line1 = <$f1>);
 301         $hb->print($line2) if defined($line2 = <$f2>);
 302     } while (defined($line1 // $line2));
 303     close $f1;
 304     close $f2;
 305     close $ha;
 306     close $hb;
 307
 308     local $/ = undef;
 309     my $diff = <$diffproc>;
 310     close $diffproc;
 311     die "files differ:\n$diff";
 312 }
 313
 314 $SIG{__WARN__} = sub {
 315     my $warning = shift;
 316     chomp $warning;
 317     if (my $warn_expect = $current_test->{expect_warning}) {
 318         if ($warn_expect ne $warning) {
 319             fail($current_test->{testname});
 320             note("warning does not match expected error: '$warning' != '$warn_expect'");
 321         } else {
 322             note("got expected warning '$warning'");
 323             return;
 324         }
 325     }
 326
 327     fail($current_test->{testname});
 328     note("got unexpected warning '$warning'");
 329 };
 330
 331 sub do_test($) {
 332     my ($config_fn) = @_;
 333
 334     die "no such input test config: $config_fn\n" if ! -f $config_fn;
 335
 336     parse_test $config_fn;
 337
 338     my $testname = $current_test->{testname};
 339
 340     my ($vmid, $storecfg) = $base_env->@{qw(vmid storage_config)};
 341
 342     my $cmdline = eval { PVE::QemuServer::vm_commandline($storecfg, $vmid) };
 343     my $err = $@;
 344
 345     if (my $err_expect = $current_test->{expect_error}) {
 346         if (!$err) {
 347             fail("$testname");
 348             note("did NOT get any error, but expected error: $err_expect");
 349             return;
 350         }
 351         chomp $err;
 352         if ($err ne $err_expect) {
 353             fail("$testname");
 354             note("error does not match expected error: '$err' !~ '$err_expect'");
 355         } else {
 356             pass("$testname");
 357         }
 358         return;
 359     } elsif ($err) {
 360         fail("$testname");
 361         note("got unexpected error: $err");
 362         return;
 363     }
 364
 365     # check if QEMU version set correctly and test version_cmp
 366     (my $qemu_major = get_test_qemu_version()) =~ s/\..*$//;
 367     die "runs_at_least_qemu_version returned false, maybe error in version_cmp?"
 368         if !PVE::QemuServer::Machine::runs_at_least_qemu_version($vmid, $qemu_major);
 369
 370     $cmdline =~ s/ -/ \\\n  -/g; # same as qm showcmd --pretty
 371     $cmdline .= "\n";
 372
 373     my $cmd_fn = "$config_fn.cmd";
 374
 375     if (-f $cmd_fn) {
 376         my $cmdline_expected = file_get_contents($cmd_fn);
 377
 378         my $cmd_expected = [ split /\s*\\?\n\s*/, $cmdline_expected ];
 379         my $cmd = [ split /\s*\\?\n\s*/, $cmdline ];
 380
 381         # uncomment for easier debugging
 382         #file_set_contents("$cmd_fn.tmp", $cmdline);
 383
 384         my $exp = join("\n", @$cmd_expected);
 385         my $got = join("\n", @$cmd);
 386         eval { diff($exp, $got) };
 387         if (my $err = $@) {
 388             fail("$testname");
 389             note($err);
 390         } else {
 391             pass("$testname");
 392         }
 393     } else {
 394         file_set_contents($cmd_fn, $cmdline);
 395     }
 396 }
 397
 398 print "testing config to command stabillity\n";
 399
 400 # exec tests
 401 if (my $file = shift) {
 402     do_test $file;
 403 } else {
 404     foreach my $file (<cfg2cmd/*.conf>) {
 405         do_test $file;
 406     }
 407 }
 408
 409 done_testing();