Emit restart events when job restarted automatically

TBD

Using the `restart_openqa_job` from the Restart module should not duplicate
the event which is emitted by the API, which also invoke `auto_duplicate`. And
it should also trigger the event when the job is processed and not while is
queued.

That should make sure that the event is send to AMQP for jobs with
`RETRY` once it is actually triggered.

Load AMQP plugin into the Gru tasks

Makes possible to the minion tasks to emit events, as it makes the AMQP plugin
available in its context. The `one_tick` is called to trigger the `next_tick`
in the `register` function of the AMPQ module immediately, otherwise it seems
like it is registered late and the event is not emitted.

issue: https://progress.opensuse.org/issues/190557
Signed-off-by: Ioannis Bonatakis <[email protected]>

Author: d3flex

lib/OpenQA/Shared/Plugin/Gru.pm

@@ -98,6 +98,19 @@ sub register ($self, $app, $config) {
         });
 
     $self->register_tasks;
+    my $plugins = $app->config->{global}->{plugins};
+    if (defined $plugins && $plugins =~ /\bAMQP\b/) {
+        push @{$app->plugins->namespaces}, 'OpenQA::WebAPI::Plugin'    # uncoverable statement
+          unless grep { $_ eq 'OpenQA::WebAPI::Plugin' } @{$app->plugins->namespaces};
+
+        try {
+            $app->plugin('AMQP');
+            Mojo::IOLoop->singleton->one_tick;    # handle async plugin registration
+        }
+        catch ($e) {
+            log_error("Failed to load AMQP plugin for Gru: $e");
+        }
+    }
 
     # Enable the Minion Admin interface under /minion
     my $auth = $app->routes->under('/minion')->to('session#ensure_admin');

lib/OpenQA/Task/Job/Restart.pm

@@ -5,6 +5,7 @@ package OpenQA::Task::Job::Restart;
 use Mojo::Base 'Mojolicious::Plugin', -signatures;
 
 use Time::Seconds;
+use OpenQA::Events;
 
 sub register ($self, $app, @args) {
     $app->minion->add_task(restart_job => \&_restart_job);
@@ -17,6 +18,12 @@ sub restart_delay { $ENV{OPENQA_JOB_RESTART_DELAY} // 5 }
 sub restart_openqa_job ($minion_job, $openqa_job) {
     my $cloned_job_or_error = $openqa_job->auto_duplicate;
     my $is_ok = ref $cloned_job_or_error || $cloned_job_or_error =~ qr/(already.*clone|direct parent)/i;
+    if ($is_ok) {
+        my $openqa_job_id = $openqa_job->id;
+        my %event_data = (id => $openqa_job_id, result => $cloned_job_or_error, auto => 1);
+        OpenQA::Events->singleton->emit_event('openqa_job_restart', data => \%event_data);
+    }
+
     $minion_job->note(
         ref $cloned_job_or_error
         ? (cluster_cloned => $cloned_job_or_error->{cluster_cloned})

t/10-jobs.t

@@ -19,6 +19,7 @@ use OpenQA::Jobs::Constants;
 use OpenQA::Test::Case;
 use Test::MockModule 'strict';
 use Test::Mojo;
+use Test::Output;
 use Test::Warnings qw(:report_warnings warning);
 use Mojo::File 'path';
 use Mojo::JSON qw(decode_json encode_json);
@@ -899,7 +900,8 @@ subtest 'job setting based retriggering' => sub {
     my $finalize_job_count_before = @{$get_jobs->('finalize_job_results')};
     $job->update({state => SCHEDULED, result => NONE});
     $job->done(result => FAILED);
-    perform_minion_jobs($minion);
+    stdout_like { perform_minion_jobs($minion) } qr/Job \d+ duplicated as \d+/,
+      'check debug message from auto_duplicate';
     is $jobs->count, $jobs_nr + 2, 'job retriggered as it FAILED (with retry)';
     $job->update;
     $job->discard_changes;
@@ -931,6 +933,32 @@ subtest 'job setting based retriggering' => sub {
     is $lastest_job->latest_job->id, $lastest_job->id, 'found the latest job from latest job itself';
 };
 
+subtest 'AMQP event emission for minion restarts' => sub {
+    my $events_module = Test::MockModule->new('OpenQA::Events');
+    my @emitted_events;
+    $events_module->redefine(
+        emit_event => sub ($self, $event_type, %args) {
+            push @emitted_events, {type => $event_type, data => $args{data}};
+            $events_module->original('emit_event')->($self, $event_type, %args);
+        });
+
+    my $minion = $t->app->minion;
+    my %_settings = %settings;
+    $_settings{TEST} = 'test_restart';
+    $_settings{RETRY} = '1';
+    my $job = _job_create(\%_settings);
+    my $job_id = $job->id;
+
+    @emitted_events = ();
+    $job->done(result => FAILED);
+    stdout_like { perform_minion_jobs($minion) } qr/Job \d+ duplicated as \d+/;
+    my @restart_events = grep { $_->{type} eq 'openqa_job_restart' } @emitted_events;
+    is scalar(@restart_events), 1, 'exactly one job restart event emitted';
+    my $event_data = $restart_events[0]->{data};
+    is $event_data->{id}, $job_id, 'event contains original job ID';
+    ok exists($event_data->{result}), 'event contains result';
+};
+
 subtest '"race" between status updates and stale job detection' => sub {
     my $job = $jobs->create({TEST => 'test-job'});
     is_deeply $job->update_status({}), {result => 0}, 'status update rejected for scheduled job';