2769

pending completion

Build # 2769

Build Type

push

travis-ci

Committed by

coolo

Commit Message

<a href="https://github.com/os-autoinst/os-autoinst/commit/<a class=hub.com/os-autoinst/os-autoinst/commit/<a class="double-link" href="https://git"><a class=hub.com/os-autoinst/os-autoinst/commit/e56063ad06b57b39cc111466009b60e582e9809f">e56063ad0<a href="https://github.com/os-autoinst/os-autoinst/commit/e56063ad06b57b39cc111466009b60e582e9809f">&lt;a href=&quot;https://github.com/os-autoinst/os-autoinst/commit/e56063ad06b57b39cc111466009b60e582e9809f&quot;&gt;&amp;quot;&amp;gt;Also compute and store needles git hash (#805)

This allows easier investigation when the needles repository is its own and
one want so review what changes have been introduced between two test runs.

Example output:

```
17:21:32.5690 5175 git hash in /var/lib/openqa/share/tests/opensuse: &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/os-autoinst/os-autoinst/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/os-autoinst/os-autoinst/commit/9302c275cdd6e8a55cbf0a34a9bf8bc5f8c176a3&quot;&gt;9302c275c&lt;/a&gt;&quot;&gt;9302c275c&lt;/a&gt;&lt;a href=&quot;https://github.com/os-autoinst/os-autoinst/commit/e56063ad06b57b39cc111466009b60e582e9809f">
[…]
17:21:33.4503 5175 git hash in /var/lib/openqa/share/tests/opensuse/products/opensuse/needles: </a><a class="double-link" href="https://github.com/os-autoinst/os-autoinst/commit/<a class="double-link" href="https://github.com/os-autoinst/os-autoinst/commit/517190eb2793b3903b7eccd34650dae1c0e42e17">517190eb2</a>">517190eb2</a><a href="https://github.com/os-autoinst/os-autoinst/commit/e56063ad06b57b39cc111466009b60e582e9809f">
```

Obviously, if the needles directory is part of the same git repository it will
output the same git hash for both directories.

Run Details

3393 of 6379 relevant lines covered (53.19%)

180.85 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

68.0

/isotovideo

#!/usr/bin/perl -w
# Copyright © 2009-2013 Bernhard M. Wiedemann
# Copyright © 2012-2016 SUSE LLC
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, see <http://www.gnu.org/licenses/>.
#

=head1 SYNOPSIS

isotovideo [OPTIONS]

Parses vars.json and tests the given assets/ISOs.

=head1 OPTIONS

=over 4

=item B<-d, --debug>

Enable direct output to STDERR instead of autoinst-log.txt

=item B<-h, -?, --help>

Show this help.

=cut

use strict;

my $installprefix;    # $bmwqemu::scriptdir

BEGIN {
    # the following line is modified during make install
    $installprefix = undef;

    my ($wd) = $0 =~ m-(.*)/-;
    $wd ||= '.';
    $installprefix ||= $wd;
    unshift @INC, "$installprefix";
}

# this shall be an integer increased by every change of the API
# either to the worker or the tests
our $INTERFACE = 7;

use bmwqemu;
use needle;
use autotest;
use commands;
use distribution;
use testapi 'diag';
use Getopt::Long;
require IPC::System::Simple;
use autodie ':all';
no autodie 'kill';
use Cwd;
use POSIX qw(:sys_wait_h _exit);
use Carp 'cluck';
use Time::HiRes qw(gettimeofday tv_interval sleep time);
use File::Spec;
use File::Path;
Getopt::Long::Configure("no_ignore_case");

my %options;
# global exit status
my $r = 1;

sub usage {
    my ($return_code) = @_;
    $r = $return_code;
    eval { use Pod::Usage; pod2usage($return_code); };
    if ($@) {
        die "cannot display help, install perl(Pod::Usage)\n";
    }
}

sub version {
    my $thisversion = qx{git rev-parse HEAD};
    print "Current version is $thisversion";
    exit 0;
}

GetOptions(\%options, 'debug|d', 'help|h|?', 'version|v') or usage(1);
usage(0)  if $options{help};
version() if $options{version};


# enable debug default when started from a tty
$bmwqemu::istty         = -t 1;              ## no critic
$bmwqemu::direct_output = $options{debug};

# whether tests completed (or we bailed due to a failed 'fatal' test)
my $completed = 0;

select(STDERR);
$| = 1;
select(STDOUT);                              # default
$| = 1;

$bmwqemu::scriptdir = $installprefix;
bmwqemu::init();

# Sanity checks
die "CASEDIR environment variable not set, unknown test case directory" if !defined $bmwqemu::vars{CASEDIR};
die "No scripts in $bmwqemu::vars{CASEDIR}" if !-e "$bmwqemu::vars{CASEDIR}";

my $cpid;
my $testpid;
my $cfd;

my $loop = 1;

sub kill_commands {
    return unless $cpid;
    # create a copy as cpid is overwritten by SIGCHLD
    my $pid = $cpid;
    if (kill('TERM', $pid)) {
        diag "awaiting death of commands process";
        my $ret = waitpid($pid, 0);
        diag "commands process exited: $ret";
    }
    $cpid = 0;
}

sub kill_autotest {
    return unless $testpid;
    # create a copy as cpid is overwritten by SIGCHLD
    my $pid = $testpid;
    if (kill('TERM', $pid)) {
        diag "awaiting death of testpid $pid";
        my $ret = waitpid($pid, 0);
        diag "test process exited: $ret";
    }
    $testpid = 0;
}

sub kill_backend {
    if (defined $bmwqemu::backend && $bmwqemu::backend->{backend_pid}) {
        # save the pid in a scalar - signal handlers will reset it
        my $bpid = $bmwqemu::backend->{backend_pid};
        diag "killing backend process $bpid";
        kill('-TERM', $bpid);
        waitpid($bpid, 0);
        diag("done with backend process");
        $bmwqemu::backend->{backend_pid} = 0;
    }
}

sub signalhandler {

    my ($sig) = @_;
    diag("signalhandler got $sig - loop $loop");
    if ($loop) {
        $loop = 0;
        return;
    }
    kill_backend;
    kill_commands;
    kill_autotest;
    _exit(1);
}

sub signalhandler_chld {

    while ((my $child = waitpid(-1, WNOHANG)) > 0) {
        if ($child == $cpid) {
            diag("commands webserver died");
            $loop = 0;
            $cpid = 0;
            next;
        }
        if ($bmwqemu::backend->{backend_pid} && $child == $bmwqemu::backend->{backend_pid}) {
            diag("backend $child died");
            $bmwqemu::backend->{backend_pid} = 0;
            $loop = 0;
            next;
        }
        if ($child == $testpid) {
            diag("tests died");
            $testpid = 0;
            $loop    = 0;
            next;
        }
        diag("unknown child $child died");
    }
}

our $test_git_hash;
our $needles_git_hash;

sub init_backend {
    my ($name) = @_;
    $bmwqemu::vars{BACKEND} ||= "qemu";

    # make sure the needles are initialized
    my $needles_dir = $bmwqemu::vars{PRODUCTDIR} . '/needles';
    needle::init($needles_dir);
    $needles_git_hash = calculate_git_hash($needles_dir);
    $bmwqemu::vars{NEEDLES_GIT_HASH} = $needles_git_hash;

    $bmwqemu::backend = backend::driver->new($bmwqemu::vars{BACKEND});
    return $bmwqemu::backend;
}

sub calculate_git_hash {
    my ($git_repo_dir) = @_;
    my $dir = getcwd;
    chdir($git_repo_dir);
    chomp(my $git_hash = qx{git rev-parse HEAD});
    $git_hash ||= "UNKNOWN";
    chdir($dir);
    diag "git hash in $git_repo_dir: $git_hash";
    return $git_hash;
}

$SIG{TERM} = \&signalhandler;
$SIG{INT}  = \&signalhandler;
$SIG{HUP}  = \&signalhandler;
$SIG{CHLD} = \&signalhandler_chld;

# make sure all commands coming from the backend will not be in the
# developers's locale - but a defined english one. This is SUSE's
# default locale
$ENV{LC_ALL} = 'en_US.UTF-8';
$ENV{LANG}   = 'en_US.UTF-8';

# Try to load the main.pm from one of the following in this order:
#  - product dir
#  - casedir
#
# This allows further structuring the test distribution collections with
# multiple distributions or flavors in one repository.
$bmwqemu::vars{PRODUCTDIR} ||= $bmwqemu::vars{CASEDIR};

# as we are about to load the test modules store the git hash that has been
# used. If it is not a git repo fail silently, i.e. store an empty variable

$test_git_hash = calculate_git_hash($bmwqemu::vars{CASEDIR});
# TODO find a better place to store hash in than vars.json, see
# https://github.com/os-autoinst/os-autoinst/pull/393#discussion_r50143013
$bmwqemu::vars{TEST_GIT_HASH} = $test_git_hash;

# start the command fork before we get into the backend, the command child
# is not supposed to talk to the backend directly
($cpid, $cfd) = commands::start_server($bmwqemu::vars{QEMUPORT} + 1);

# add lib of the test distributions - but only for main.pm not to pollute
# further dependencies (the tests get it through autotest)
my @oldINC = @INC;
unshift @INC, $bmwqemu::vars{CASEDIR} . '/lib';
require $bmwqemu::vars{PRODUCTDIR} . "/main.pm";
@INC = @oldINC;

# set a default distribution if the tests don't have one
$testapi::distri ||= distribution->new;

testapi::init();

# init part
bmwqemu::save_vars();

my $testfd;
($testpid, $testfd) = autotest::start_process();

init_backend();

open(my $fd, ">", "os-autoinst.pid");
print $fd "$$\n";
close $fd;

if (!$bmwqemu::backend->_send_json({cmd => 'alive'})) {
    # might throw an exception
    $bmwqemu::backend->start_vm();
}

if ($ENV{RUN_VNCVIEWER}) {
    system("vncviewer -shared localhost:" . $bmwqemu::vars{VNC} . " -viewonly &");
}
if ($ENV{RUN_DEBUGVIEWER}) {
    system("$bmwqemu::scriptdir/debugviewer/debugviewer qemuscreenshot/last.png &");
}

use IO::Select;

my $s = IO::Select->new();
$s->add($testfd);
$s->add($cfd);
$s->add($bmwqemu::backend->{from_child});

# now we have everything, give the tests a go
$testfd->write("GO\n");

my $interactive = 0;
my $needinput   = 0;

my $current_test_name;

# timeout for the select (only set for check_screens)
my $timeout = undef;

# do not wait for timeout if set
my $no_wait = undef;

# marks a running check_screen
our $tags = undef;

# set to the socket we have to send replies to when the backend is done
my $backend_requester = undef;

my ($last_check_seconds, $last_check_microseconds) = gettimeofday;
sub _calc_check_delta {
    # an estimate of eternity
    my $delta = 100;
    if ($last_check_seconds) {
        $delta = tv_interval([$last_check_seconds, $last_check_microseconds], [gettimeofday]);
    }
    if ($delta > 0) {
        # sleep the remains of one second
        $timeout = 1 - $delta;
        $timeout = 0 if $timeout < 0;
    }
    else {
        $timeout = 0;
    }
    return $delta;
}

sub check_asserted_screen {
    my ($force_timeout, $no_wait) = @_;

    if ($no_wait) {
        # prevent CPU overload by waiting at least a little bit
        $timeout = 0.1;
    }
    else {
        _calc_check_delta;
        # come back later, avoid too often called function
        return if $timeout > 0.05;
    }
    ($last_check_seconds, $last_check_microseconds) = gettimeofday;
    my $rsp = $bmwqemu::backend->_send_json({cmd => 'check_asserted_screen'}) || {};
    # the test needs that information
    $rsp->{tags} = $tags;
    if ($rsp->{found}) {
        myjsonrpc::send_json($testfd, {ret => $rsp});
        $tags = $timeout = undef;
    }
    elsif ($rsp->{timeout}) {
        if ($interactive && !$force_timeout) {
            # now get fancy
            $bmwqemu::backend->_send_json({cmd => 'freeze_vm'});
            $rsp->{saveresult} = 1;
            myjsonrpc::send_json($testfd, {ret => $rsp});
            $needinput = 1;
        }
        else {
            myjsonrpc::send_json($testfd, {ret => $rsp});
            $tags = undef;
        }
        $timeout = undef;
    }
    else {
        _calc_check_delta unless $no_wait;
    }
}

$r = 0;

while ($loop) {
    my ($reads, $writes, $exceps) = IO::Select::select($s, undef, $s, $timeout);
    for my $r (@$reads) {
        my $rsp = myjsonrpc::read_json($r);
        if (!defined $rsp) {
            diag sprintf("THERE IS NOTHING TO READ %d %d %d", fileno($r), fileno($testfd), fileno($cfd));
            $r    = 1;
            $loop = 0;
            last;
        }
        if ($r == $bmwqemu::backend->{from_child}) {
            myjsonrpc::send_json($backend_requester, {ret => $rsp->{rsp}});
            $backend_requester = undef;
            next;
        }
        if ($rsp->{cmd} =~ m/^backend_(.*)/) {
            die "we need to implement a backend queue" if $backend_requester;
            $backend_requester = $r;
            my $cmd = $1;
            delete $rsp->{cmd};
            myjsonrpc::send_json($bmwqemu::backend->{to_child}, {cmd => $cmd, arguments => $rsp});
            next;
        }
        if ($rsp->{cmd} eq 'set_current_test') {
            $bmwqemu::backend->_send_json({cmd => 'set_serial_offset'});
            $current_test_name = $rsp->{name};
            myjsonrpc::send_json($r, {ret => 1});
            next;
        }
        if ($rsp->{cmd} eq 'tests_done') {
            $r         = $rsp->{died};
            $completed = $rsp->{completed};
            CORE::close($testfd);
            $testfd = undef;
            kill_autotest;
            $loop = 0;
            next;
        }
        if ($rsp->{cmd} eq 'check_screen') {
            $no_wait = $rsp->{no_wait} // 0;

            $tags = $bmwqemu::backend->_send_json(
                {
                    cmd       => 'set_tags_to_assert',
                    arguments => {
                        mustmatch => $rsp->{mustmatch},
                        timeout   => $rsp->{timeout},
                        check     => $rsp->{check}}})->{tags};
            next;
        }

        ##### HTTP commands
        if ($rsp->{cmd} eq 'status') {
            my $result = {tags => $tags, running => $current_test_name};
            $result->{interactive} = $interactive;
            $result->{needinput}   = $needinput;
            myjsonrpc::send_json($r, $result);
            next;
        }

        if ($rsp->{cmd} eq 'version') {
            my $result = {test_git_hash => $test_git_hash, needles_git_hash => $needles_git_hash, version => $INTERFACE};
            myjsonrpc::send_json($r, $result);
            next;
        }

        if ($rsp->{cmd} eq 'interactive') {
            # interactive is boolean
            $interactive = $rsp->{params}->{state} ? 1 : 0;
            if (!$interactive && $needinput) {
                # need to continue the VM
                $bmwqemu::backend->_send_json({cmd => 'retry_assert_screen'});
                $needinput = 0;
                $timeout   = .1;
                check_asserted_screen(1, $no_wait);
            }
            myjsonrpc::send_json($r, {interactive => $interactive});
            next;
        }

        if ($rsp->{cmd} eq 'stop_waitforneedle') {
            $bmwqemu::backend->_send_json({cmd => 'reduce_deadline'});
            myjsonrpc::send_json($r, {ret => 0});
            next;
        }
        if ($rsp->{cmd} eq 'continue_waitforneedle' || $rsp->{cmd} eq 'reload_needles') {
            $needinput = 0;
            $timeout   = .1;
            my $reload = $rsp->{cmd} eq 'reload_needles';
            # tell backend to retry
            $bmwqemu::backend->_send_json({cmd => 'retry_assert_screen', arguments => {reload_needles => $reload}});
            # that's enough for the webui to know
            myjsonrpc::send_json($r, {ret => 0});
            check_asserted_screen(1, $no_wait);
            next;
        }
        die "Unknown command $rsp->{cmd}";
    }

    if (defined $tags && !$needinput) {
        check_asserted_screen(0, $no_wait);
    }
}

# don't leave the commands server open - it will no longer react anyway
# as most of it ends up in the loop above
kill_commands;

if ($testfd) {
    $r = 1;    # unusual shutdown
    CORE::close $testfd;
    kill_autotest;
}

diag "isotovideo " . ($r ? 'failed' : 'done');

my $clean_shutdown;
if (!$r) {
    eval {
        $clean_shutdown = $bmwqemu::backend->_send_json({cmd => 'is_shutdown'});
        diag "BACKEND SHUTDOWN $clean_shutdown";
    };
    # don't rely on the backend in a sane state if we failed - just kill it later
    eval { bmwqemu::stop_vm(); };
    if ($@) {
        diag "Error during stop_vm: $@";
        $r = 1;
    }
}

# read calculated variables from backend and tests
bmwqemu::load_vars();

# mark hard disks for upload if test finished
if (!$r && $completed && (my $nd = $bmwqemu::vars{NUMDISKS}) && ($bmwqemu::vars{BACKEND} eq 'qemu')) {
    my @toextract;
    for my $i (1 .. $nd) {
        my $dir = 'assets_private';
        my $name = $bmwqemu::vars{"STORE_HDD_$i"} || undef;
        unless ($name) {
            $name = $bmwqemu::vars{"PUBLISH_HDD_$i"} || undef;
            $dir = 'assets_public';
        }
        next unless $name;
        $name =~ /\.([[:alnum:]]+)$/;
        my $format = $1;
        push @toextract, {hdd_num => $i, name => $name, dir => $dir, format => $format};
    }
    if (@toextract && !$clean_shutdown) {
        diag "ERROR: Machine not shut down when uploading disks!\n";
        $r = 1;
    }
    else {
        for my $asset (@toextract) {
            $bmwqemu::backend->extract_assets($asset);
        }
    }
}

END {
    kill_backend;
    kill_commands;
    kill_autotest;
    # in case of early exit, e.g. help display
    $r //= 0;
    print "$$: EXIT $r\n";
    $? = $r;
}

# vim: set sw=4 et:

1	#!/usr/bin/perl -w
2	# Copyright © 2009-2013 Bernhard M. Wiedemann
3	# Copyright © 2012-2016 SUSE LLC
4	#
5	# This program is free software; you can redistribute it and/or modify
6	# it under the terms of the GNU General Public License as published by
7	# the Free Software Foundation; either version 2 of the License, or
8	# (at your option) any later version.
9	#
10	# This program is distributed in the hope that it will be useful,
11	# but WITHOUT ANY WARRANTY; without even the implied warranty of
12	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13	# GNU General Public License for more details.
14	#
15	# You should have received a copy of the GNU General Public License along
16	# with this program; if not, see <http://www.gnu.org/licenses/>.
17	#
18
19	=head1 SYNOPSIS
20
21	isotovideo [OPTIONS]
22
23	Parses vars.json and tests the given assets/ISOs.
24
25	=head1 OPTIONS
26
27	=over 4
28
29	=item B<-d, --debug>
30
31	Enable direct output to STDERR instead of autoinst-log.txt
32
33	=item B<-h, -?, --help>
34
35	Show this help.
36
37	=cut
38
39	use strict;	3✔
40
41	my $installprefix; # $bmwqemu::scriptdir	3✔
42
43	BEGIN {
44	# the following line is modified during make install
45	$installprefix = undef;	3✔
46
47	my ($wd) = $0 =~ m-(.*)/-;	3✔
48	$wd \|\|= '.';	3✔
49	$installprefix \|\|= $wd;	3✔
50	unshift @INC, "$installprefix";	3✔
51	}
52
53	# this shall be an integer increased by every change of the API
54	# either to the worker or the tests
55	our $INTERFACE = 7;	3✔
56
57	use bmwqemu;	3✔
58	use needle;	3✔
59	use autotest;	3✔
60	use commands;	3✔
61	use distribution;	3✔
62	use testapi 'diag';	3✔
63	use Getopt::Long;	3✔
64	require IPC::System::Simple;	3✔
65	use autodie ':all';	3✔
66	no autodie 'kill';	3✔
67	use Cwd;	3✔
68	use POSIX qw(:sys_wait_h _exit);	3✔
69	use Carp 'cluck';	3✔
70	use Time::HiRes qw(gettimeofday tv_interval sleep time);	3✔
71	use File::Spec;	3✔
72	use File::Path;	3✔
73	Getopt::Long::Configure("no_ignore_case");	3✔
74
75	my %options;	3✔
76	# global exit status
77	my $r = 1;	3✔
78
79	sub usage {
80	my ($return_code) = @_;	×
81	$r = $return_code;	×
82	eval { use Pod::Usage; pod2usage($return_code); };	3✔
83	if ($@) {	×
84	die "cannot display help, install perl(Pod::Usage)\n";	×
85	}
86	}
87
88	sub version {
89	my $thisversion = qx{git rev-parse HEAD};	×
90	print "Current version is $thisversion";	×
91	exit 0;	×
92	}
93
94	GetOptions(\%options, 'debug\|d', 'help\|h\|?', 'version\|v') or usage(1);	3✔
95	usage(0) if $options{help};	3✔
96	version() if $options{version};	3✔
97
98
99	# enable debug default when started from a tty
100	$bmwqemu::istty = -t 1; ## no critic	3✔
101	$bmwqemu::direct_output = $options{debug};	3✔
102
103	# whether tests completed (or we bailed due to a failed 'fatal' test)
104	my $completed = 0;	3✔
105
106	select(STDERR);	3✔
107	$\| = 1;	3✔
108	select(STDOUT); # default	3✔
109	$\| = 1;	3✔
110
111	$bmwqemu::scriptdir = $installprefix;	3✔
112	bmwqemu::init();	3✔
113
114	# Sanity checks
115	die "CASEDIR environment variable not set, unknown test case directory" if !defined $bmwqemu::vars{CASEDIR};	3✔
116	die "No scripts in $bmwqemu::vars{CASEDIR}" if !-e "$bmwqemu::vars{CASEDIR}";	3✔
117
118	my $cpid;	3✔
119	my $testpid;	3✔
120	my $cfd;	3✔
121
122	my $loop = 1;	3✔
123
124	sub kill_commands {
125	return unless $cpid;	2✔
126	# create a copy as cpid is overwritten by SIGCHLD
127	my $pid = $cpid;	1✔
128	if (kill('TERM', $pid)) {	1✔
129	diag "awaiting death of commands process";	1✔
130	my $ret = waitpid($pid, 0);	1✔
131	diag "commands process exited: $ret";	1✔
132	}
133	$cpid = 0;	1✔
134	}
135
136	sub kill_autotest {
137	return unless $testpid;	2✔
138	# create a copy as cpid is overwritten by SIGCHLD
139	my $pid = $testpid;	1✔
140	if (kill('TERM', $pid)) {	1✔
141	diag "awaiting death of testpid $pid";	1✔
142	my $ret = waitpid($pid, 0);	1✔
143	diag "test process exited: $ret";	1✔
144	}
145	$testpid = 0;	1✔
146	}
147
148	sub kill_backend {
149	if (defined $bmwqemu::backend && $bmwqemu::backend->{backend_pid}) {	1✔
150	# save the pid in a scalar - signal handlers will reset it
151	my $bpid = $bmwqemu::backend->{backend_pid};	×
152	diag "killing backend process $bpid";	×
153	kill('-TERM', $bpid);	×
154	waitpid($bpid, 0);	×
155	diag("done with backend process");	×
156	$bmwqemu::backend->{backend_pid} = 0;	×
157	}
158	}
159
160	sub signalhandler {
161
162	my ($sig) = @_;	×
163	diag("signalhandler got $sig - loop $loop");	×
164	if ($loop) {	×
165	$loop = 0;	×
166	return;	×
167	}
168	kill_backend;	×
169	kill_commands;	×
170	kill_autotest;	×
171	_exit(1);	×
172	}
173
174	sub signalhandler_chld {
175
176	while ((my $child = waitpid(-1, WNOHANG)) > 0) {	8✔
177	if ($child == $cpid) {	×
178	diag("commands webserver died");	×
179	$loop = 0;	×
180	$cpid = 0;	×
181	next;	×
182	}
183	if ($bmwqemu::backend->{backend_pid} && $child == $bmwqemu::backend->{backend_pid}) {	×
184	diag("backend $child died");	×
185	$bmwqemu::backend->{backend_pid} = 0;	×
186	$loop = 0;	×
187	next;	×
188	}
189	if ($child == $testpid) {	×
190	diag("tests died");	×
191	$testpid = 0;	×
192	$loop = 0;	×
193	next;	×
194	}
195	diag("unknown child $child died");	×
196	}
197	}
198
199	our $test_git_hash;	3✔
200	our $needles_git_hash;	3✔
201
202	sub init_backend {
203	my ($name) = @_;	2✔
204	$bmwqemu::vars{BACKEND} \|\|= "qemu";	2✔
205
206	# make sure the needles are initialized
207	my $needles_dir = $bmwqemu::vars{PRODUCTDIR} . '/needles';	2✔
208	needle::init($needles_dir);	2✔
209	$needles_git_hash = calculate_git_hash($needles_dir);	2✔
210	$bmwqemu::vars{NEEDLES_GIT_HASH} = $needles_git_hash;	2✔
211
212	$bmwqemu::backend = backend::driver->new($bmwqemu::vars{BACKEND});	2✔
213	return $bmwqemu::backend;	1✔
214	}
215
216	sub calculate_git_hash {
217	my ($git_repo_dir) = @_;	5✔
218	my $dir = getcwd;	5✔
219	chdir($git_repo_dir);	5✔
220	chomp(my $git_hash = qx{git rev-parse HEAD});	5✔
221	$git_hash \|\|= "UNKNOWN";	5✔
222	chdir($dir);	5✔
223	diag "git hash in $git_repo_dir: $git_hash";	5✔
224	return $git_hash;	5✔
225	}
226
227	$SIG{TERM} = \&signalhandler;	3✔
228	$SIG{INT} = \&signalhandler;	3✔
229	$SIG{HUP} = \&signalhandler;	3✔
230	$SIG{CHLD} = \&signalhandler_chld;	3✔
231
232	# make sure all commands coming from the backend will not be in the
233	# developers's locale - but a defined english one. This is SUSE's
234	# default locale
235	$ENV{LC_ALL} = 'en_US.UTF-8';	3✔
236	$ENV{LANG} = 'en_US.UTF-8';	3✔
237
238	# Try to load the main.pm from one of the following in this order:
239	# - product dir
240	# - casedir
241	#
242	# This allows further structuring the test distribution collections with
243	# multiple distributions or flavors in one repository.
244	$bmwqemu::vars{PRODUCTDIR} \|\|= $bmwqemu::vars{CASEDIR};	3✔
245
246	# as we are about to load the test modules store the git hash that has been
247	# used. If it is not a git repo fail silently, i.e. store an empty variable
248
249	$test_git_hash = calculate_git_hash($bmwqemu::vars{CASEDIR});	3✔
250	# TODO find a better place to store hash in than vars.json, see
251	# https://github.com/os-autoinst/os-autoinst/pull/393#discussion_r50143013
252	$bmwqemu::vars{TEST_GIT_HASH} = $test_git_hash;	3✔
253
254	# start the command fork before we get into the backend, the command child
255	# is not supposed to talk to the backend directly
256	($cpid, $cfd) = commands::start_server($bmwqemu::vars{QEMUPORT} + 1);	3✔
257
258	# add lib of the test distributions - but only for main.pm not to pollute
259	# further dependencies (the tests get it through autotest)
260	my @oldINC = @INC;	2✔
261	unshift @INC, $bmwqemu::vars{CASEDIR} . '/lib';	2✔
262	require $bmwqemu::vars{PRODUCTDIR} . "/main.pm";	2✔
263	@INC = @oldINC;	2✔
264
265	# set a default distribution if the tests don't have one
266	$testapi::distri \|\|= distribution->new;	2✔
267
268	testapi::init();	2✔
269
270	# init part
271	bmwqemu::save_vars();	2✔
272
273	my $testfd;	2✔
274	($testpid, $testfd) = autotest::start_process();	2✔
275
276	init_backend();	2✔
277
278	open(my $fd, ">", "os-autoinst.pid");	1✔
279	print $fd "$$\n";	1✔
280	close $fd;	1✔
281
282	if (!$bmwqemu::backend->_send_json({cmd => 'alive'})) {	1✔
283	# might throw an exception
284	$bmwqemu::backend->start_vm();	1✔
285	}
286
287	if ($ENV{RUN_VNCVIEWER}) {	1✔
288	system("vncviewer -shared localhost:" . $bmwqemu::vars{VNC} . " -viewonly &");	×
289	}
290	if ($ENV{RUN_DEBUGVIEWER}) {	1✔
291	system("$bmwqemu::scriptdir/debugviewer/debugviewer qemuscreenshot/last.png &");	×
292	}
293
294	use IO::Select;	3✔
295
296	my $s = IO::Select->new();	1✔
297	$s->add($testfd);	1✔
298	$s->add($cfd);	1✔
299	$s->add($bmwqemu::backend->{from_child});	1✔
300
301	# now we have everything, give the tests a go
302	$testfd->write("GO\n");	1✔
303
304	my $interactive = 0;	1✔
305	my $needinput = 0;	1✔
306
307	my $current_test_name;	1✔
308
309	# timeout for the select (only set for check_screens)
310	my $timeout = undef;	1✔
311
312	# do not wait for timeout if set
313	my $no_wait = undef;	1✔
314
315	# marks a running check_screen
316	our $tags = undef;	1✔
317
318	# set to the socket we have to send replies to when the backend is done
319	my $backend_requester = undef;	1✔
320
321	my ($last_check_seconds, $last_check_microseconds) = gettimeofday;	1✔
322	sub _calc_check_delta {
323	# an estimate of eternity
324	my $delta = 100;	38✔
325	if ($last_check_seconds) {	38✔
326	$delta = tv_interval([$last_check_seconds, $last_check_microseconds], [gettimeofday]);	38✔
327	}
328	if ($delta > 0) {	38✔
329	# sleep the remains of one second
330	$timeout = 1 - $delta;	38✔
331	$timeout = 0 if $timeout < 0;	38✔
332	}
333	else {
334	$timeout = 0;	×
335	}
336	return $delta;	38✔
337	}
338
339	sub check_asserted_screen {
340	my ($force_timeout, $no_wait) = @_;	75✔
341
342	if ($no_wait) {	75✔
343	# prevent CPU overload by waiting at least a little bit
344	$timeout = 0.1;	54✔
345	}
346	else {
347	_calc_check_delta;	21✔
348	# come back later, avoid too often called function
349	return if $timeout > 0.05;	21✔
350	}
351	($last_check_seconds, $last_check_microseconds) = gettimeofday;	73✔
352	my $rsp = $bmwqemu::backend->_send_json({cmd => 'check_asserted_screen'}) \|\| {};	73✔
353	# the test needs that information
354	$rsp->{tags} = $tags;	73✔
355	if ($rsp->{found}) {	73✔
356	myjsonrpc::send_json($testfd, {ret => $rsp});	4✔
357	$tags = $timeout = undef;	4✔
358	}
359	elsif ($rsp->{timeout}) {
360	if ($interactive && !$force_timeout) {	×
361	# now get fancy
362	$bmwqemu::backend->_send_json({cmd => 'freeze_vm'});	×
363	$rsp->{saveresult} = 1;	×
364	myjsonrpc::send_json($testfd, {ret => $rsp});	×
365	$needinput = 1;	×
366	}
367	else {
368	myjsonrpc::send_json($testfd, {ret => $rsp});	×
369	$tags = undef;	×
370	}
371	$timeout = undef;	×
372	}
373	else {
374	_calc_check_delta unless $no_wait;	69✔
375	}
376	}
377
378	$r = 0;	1✔
379
380	while ($loop) {	1✔
381	my ($reads, $writes, $exceps) = IO::Select::select($s, undef, $s, $timeout);	132✔
382	for my $r (@$reads) {	132✔
383	my $rsp = myjsonrpc::read_json($r);	61✔
384	if (!defined $rsp) {	61✔
385	diag sprintf("THERE IS NOTHING TO READ %d %d %d", fileno($r), fileno($testfd), fileno($cfd));	×
386	$r = 1;	×
387	$loop = 0;	×
388	last;	×
389	}
390	if ($r == $bmwqemu::backend->{from_child}) {	61✔
391	myjsonrpc::send_json($backend_requester, {ret => $rsp->{rsp}});	26✔
392	$backend_requester = undef;	26✔
393	next;	26✔
394	}
395	if ($rsp->{cmd} =~ m/^backend_(.*)/) {	35✔
396	die "we need to implement a backend queue" if $backend_requester;	26✔
397	$backend_requester = $r;	26✔
398	my $cmd = $1;	26✔
399	delete $rsp->{cmd};	26✔
400	myjsonrpc::send_json($bmwqemu::backend->{to_child}, {cmd => $cmd, arguments => $rsp});	26✔
401	next;	26✔
402	}
403	if ($rsp->{cmd} eq 'set_current_test') {	9✔
404	$bmwqemu::backend->_send_json({cmd => 'set_serial_offset'});	4✔
405	$current_test_name = $rsp->{name};	4✔
406	myjsonrpc::send_json($r, {ret => 1});	4✔
407	next;	4✔
408	}
409	if ($rsp->{cmd} eq 'tests_done') {	5✔
410	$r = $rsp->{died};	1✔
411	$completed = $rsp->{completed};	1✔
412	CORE::close($testfd);	1✔
413	$testfd = undef;	1✔
414	kill_autotest;	1✔
415	$loop = 0;	1✔
416	next;	1✔
417	}
418	if ($rsp->{cmd} eq 'check_screen') {	4✔
419	$no_wait = $rsp->{no_wait} // 0;	4✔
420
421	$tags = $bmwqemu::backend->_send_json(	4✔
422	{
423	cmd => 'set_tags_to_assert',
424	arguments => {
425	mustmatch => $rsp->{mustmatch},
426	timeout => $rsp->{timeout},
427	check => $rsp->{check}}})->{tags};
428	next;	4✔
429	}
430
431	##### HTTP commands
432	if ($rsp->{cmd} eq 'status') {	×
433	my $result = {tags => $tags, running => $current_test_name};	×
434	$result->{interactive} = $interactive;	×
435	$result->{needinput} = $needinput;	×
436	myjsonrpc::send_json($r, $result);	×
437	next;	×
438	}
439
440	if ($rsp->{cmd} eq 'version') {	×
441	my $result = {test_git_hash => $test_git_hash, needles_git_hash => $needles_git_hash, version => $INTERFACE};	×
442	myjsonrpc::send_json($r, $result);	×
443	next;	×
444	}
445
446	if ($rsp->{cmd} eq 'interactive') {	×
447	# interactive is boolean
448	$interactive = $rsp->{params}->{state} ? 1 : 0;	×
449	if (!$interactive && $needinput) {	×
450	# need to continue the VM
451	$bmwqemu::backend->_send_json({cmd => 'retry_assert_screen'});	×
452	$needinput = 0;	×
453	$timeout = .1;	×
454	check_asserted_screen(1, $no_wait);	×
455	}
456	myjsonrpc::send_json($r, {interactive => $interactive});	×
457	next;	×
458	}
459
460	if ($rsp->{cmd} eq 'stop_waitforneedle') {	×
461	$bmwqemu::backend->_send_json({cmd => 'reduce_deadline'});	×
462	myjsonrpc::send_json($r, {ret => 0});	×
463	next;	×
464	}
465	if ($rsp->{cmd} eq 'continue_waitforneedle' \|\| $rsp->{cmd} eq 'reload_needles') {	×
466	$needinput = 0;	×
467	$timeout = .1;	×
468	my $reload = $rsp->{cmd} eq 'reload_needles';	×
469	# tell backend to retry
470	$bmwqemu::backend->_send_json({cmd => 'retry_assert_screen', arguments => {reload_needles => $reload}});	×
471	# that's enough for the webui to know
472	myjsonrpc::send_json($r, {ret => 0});	×
473	check_asserted_screen(1, $no_wait);	×
474	next;	×
475	}
476	die "Unknown command $rsp->{cmd}";	×
477	}
478
479	if (defined $tags && !$needinput) {	132✔
480	check_asserted_screen(0, $no_wait);	75✔
481	}
482	}
483
484	# don't leave the commands server open - it will no longer react anyway
485	# as most of it ends up in the loop above
486	kill_commands;	1✔
487
488	if ($testfd) {	1✔
489	$r = 1; # unusual shutdown	×
490	CORE::close $testfd;	×
491	kill_autotest;	×
492	}
493
494	diag "isotovideo " . ($r ? 'failed' : 'done');	1✔
495
496	my $clean_shutdown;	1✔
497	if (!$r) {	1✔
498	eval {	1✔
499	$clean_shutdown = $bmwqemu::backend->_send_json({cmd => 'is_shutdown'});	1✔
500	diag "BACKEND SHUTDOWN $clean_shutdown";	1✔
501	};
502	# don't rely on the backend in a sane state if we failed - just kill it later
503	eval { bmwqemu::stop_vm(); };	1✔
504	if ($@) {	1✔
505	diag "Error during stop_vm: $@";	×
506	$r = 1;	×
507	}
508	}
509
510	# read calculated variables from backend and tests
511	bmwqemu::load_vars();	1✔
512
513	# mark hard disks for upload if test finished
514	if (!$r && $completed && (my $nd = $bmwqemu::vars{NUMDISKS}) && ($bmwqemu::vars{BACKEND} eq 'qemu')) {	1✔
515	my @toextract;	1✔
516	for my $i (1 .. $nd) {	1✔
517	my $dir = 'assets_private';	1✔
518	my $name = $bmwqemu::vars{"STORE_HDD_$i"} \|\| undef;	1✔
519	unless ($name) {	1✔
520	$name = $bmwqemu::vars{"PUBLISH_HDD_$i"} \|\| undef;	1✔
521	$dir = 'assets_public';	1✔
522	}
523	next unless $name;	1✔
524	$name =~ /\.([[:alnum:]]+)$/;	×
525	my $format = $1;	×
526	push @toextract, {hdd_num => $i, name => $name, dir => $dir, format => $format};	×
527	}
528	if (@toextract && !$clean_shutdown) {	1✔
529	diag "ERROR: Machine not shut down when uploading disks!\n";	×
530	$r = 1;	×
531	}
532	else {
533	for my $asset (@toextract) {	1✔
534	$bmwqemu::backend->extract_assets($asset);	×
535	}
536	}
537	}
538
539	END {
540	kill_backend;	1✔
541	kill_commands;	1✔
542	kill_autotest;	1✔
543	# in case of early exit, e.g. help display
544	$r //= 0;	1✔
545	print "$$: EXIT $r\n";	1✔
546	$? = $r;	1✔
547	}
548
549	# vim: set sw=4 et:

os-autoinst / os-autoinst / 2769

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous