Merge ~sylvain-pineau/checkbox-ng:remote-interact-fixes-rebased into checkbox-ng:master

[Sylvain Pineau]

Multiple fixes to support all interactions type for manual jobs (skip, rerun).

Fix user interact types jobs where command output was not streamed resulting in a re-connection after 30s.

[Sylvain Pineau (sylvain-pineau)]

Rebased since several initial commits have been merged already.

review: Needs Resubmitting

[Sylvain Pineau (sylvain-pineau)]

self-approved

review: Approve

diff --git a/checkbox_ng/launcher/master.py b/checkbox_ng/launcher/master.py
index 818e78d..82dc20d 100644
--- a/checkbox_ng/launcher/master.py
+++ b/checkbox_ng/launcher/master.py
@@ -19,7 +19,9 @@
 This module contains implementation of the master end of the remote execution
 functionality.
 """
+import getpass
 import gettext
+import ipaddress
 import logging
 import os
 import select
@@ -43,7 +45,7 @@ from checkbox_ng.urwid_ui import CategoryBrowser
 from checkbox_ng.urwid_ui import ReRunBrowser
 from checkbox_ng.urwid_ui import interrupt_dialog
 from checkbox_ng.urwid_ui import resume_dialog
-from checkbox_ng.launcher.run import NormalUI
+from checkbox_ng.launcher.run import NormalUI, ReRunJob
 from checkbox_ng.launcher.stages import MainLoopStage
 from checkbox_ng.launcher.stages import ReportsStage
 _ = gettext.gettext
@@ -122,6 +124,7 @@ class RemoteMaster(Command, ReportsStage, MainLoopStage):
         self._is_bootstrapping = False
         self._target_host = ctx.args.host
         self._sudo_provider = None
+        self._normal_user = ''
         self.launcher = DefaultLauncherDefinition()
         if ctx.args.launcher:
             expanded_path = os.path.expanduser(ctx.args.launcher)
@@ -131,11 +134,18 @@ class RemoteMaster(Command, ReportsStage, MainLoopStage):
             with open(expanded_path, 'rt') as f:
                 self._launcher_text = f.read()
             self.launcher.read_string(self._launcher_text)
+        if 'local' in ctx.args.host:
+            ctx.args.host = '127.0.0.1'
+            if ipaddress.ip_address(ctx.args.host).is_loopback:
+                self._normal_user = getpass.getuser()
+        if ctx.args.user:
+            self._normal_user = ctx.args.user
         timeout = 600
         deadline = time.time() + timeout
         port = ctx.args.port
-        print(_("Connecting to {}:{}. Timeout: {}s").format(
-            ctx.args.host, port, timeout))
+        if not ipaddress.ip_address(ctx.args.host).is_loopback:
+            print(_("Connecting to {}:{}. Timeout: {}s").format(
+                ctx.args.host, port, timeout))
         while time.time() < deadline:
             try:
                 self.connect_and_run(ctx.args.host, port)
@@ -218,6 +228,7 @@ class RemoteMaster(Command, ReportsStage, MainLoopStage):
         _logger.info("master: Starting new session.")
         configuration = dict()
         configuration['launcher'] = self._launcher_text
+        configuration['normal_user'] = self._normal_user
 
         tps = self.sa.start_session(configuration)
         _logger.debug("master: Session started. Available TPs:\n%s",
@@ -295,6 +306,8 @@ class RemoteMaster(Command, ReportsStage, MainLoopStage):
             "launcher definition file to use"))
         parser.add_argument('--port', type=int, default=18871, help=_(
             "port to connect to"))
+        parser.add_argument('-u', '--user', help=_(
+            "normal user to run non-root jobs"))
 
     def _handle_interrupt(self):
         """
@@ -477,37 +490,68 @@ class RemoteMaster(Command, ReportsStage, MainLoopStage):
             print(_("Category: {0}").format(job['category_name']))
             SimpleUI.horiz_line()
             next_job = False
-            for interaction in self.sa.run_job(job['id']):
-                if interaction.kind == 'sudo_input':
-                    self.sa.save_password(
-                        self._sudo_provider.encrypted_password)
-                if interaction.kind == 'purpose':
-                    SimpleUI.description(_('Purpose:'), interaction.message)
-                elif interaction.kind in ['description', 'steps']:
-                    SimpleUI.description(_('Steps:'), interaction.message)
-                    if job['command'] is None:
-                        cmd = 'run'
-                    else:
-                        cmd = SimpleUI(None).wait_for_interaction_prompt(None)
-                    if cmd == 'skip':
+            while next_job is False:
+                for interaction in self.sa.run_job(job['id']):
+                    if interaction.kind == 'sudo_input':
+                        self.sa.save_password(
+                            self._sudo_provider.encrypted_password)
+                    if interaction.kind == 'purpose':
+                        SimpleUI.description(_('Purpose:'),
+                                             interaction.message)
+                    elif interaction.kind == 'description':
+                        SimpleUI.description(_('Description:'),
+                                             interaction.message)
+                        if job['command'] is None:
+                            cmd = 'run'
+                        else:
+                            cmd = SimpleUI(
+                                None).wait_for_interaction_prompt(None)
+                        if cmd == 'skip':
+                            next_job = True
+                        self.sa.remember_users_response(cmd)
+                        self.wait_for_job(dont_finish=True)
+                    elif interaction.kind in 'steps':
+                        SimpleUI.description(_('Steps:'), interaction.message)
+                        if job['command'] is None:
+                            cmd = 'run'
+                        else:
+                            cmd = SimpleUI(
+                                None).wait_for_interaction_prompt(None)
+                        if cmd == 'skip':
+                            next_job = True
+                        self.sa.remember_users_response(cmd)
+                    elif interaction.kind == 'verification':
+                        self.wait_for_job(dont_finish=True)
+                        if interaction.message:
+                            SimpleUI.description(
+                                _('Verification:'), interaction.message)
+                        JobAdapter = namedtuple('job_adapter', ['command'])
+                        job_lite = JobAdapter(job['command'])
+                        try:
+                            cmd = SimpleUI(None)._interaction_callback(
+                                job_lite, interaction.extra._builder)
+                            self.sa.remember_users_response(cmd)
+                            self.finish_job(
+                                interaction.extra._builder.get_result())
+                            next_job = True
+                            break
+                        except ReRunJob:
+                            next_job = False
+                            self.sa.rerun_job(
+                                job['id'],
+                                interaction.extra._builder.get_result())
+                            break
+                    elif interaction.kind == 'comment':
+                        new_comment = input(SimpleUI.C.BLUE(
+                            _('Please enter your comments:') + '\n'))
+                        self.sa.remember_users_response(new_comment + '\n')
+                    elif interaction.kind == 'skip':
+                        self.finish_job(
+                            interaction.extra._builder.get_result())
                         next_job = True
-                    self.sa.remember_users_response(cmd)
-                elif interaction.kind == 'verification':
-                    self.wait_for_job(dont_finish=True)
-                    if interaction.message:
-                        SimpleUI.description(
-                            _('Verification:'), interaction.message)
-                    JobAdapter = namedtuple('job_adapter', ['command'])
-                    job = JobAdapter(job['command'])
-                    cmd = SimpleUI(None)._interaction_callback(
-                        job, interaction.extra)
-                    self.sa.remember_users_response(cmd)
-                    self.finish_job(interaction.extra.get_result())
-                    next_job = True
-                elif interaction.kind == 'comment':
-                    new_comment = input(SimpleUI.C.BLUE(
-                        _('Please enter your comments:') + '\n'))
-                    self.sa.remember_users_response(new_comment + '\n')
+                        break
+                else:
+                    self.wait_for_job()
+                    break
             if next_job:
                 continue
-            self.wait_for_job()
diff --git a/plainbox/impl/session/remote_assistant.py b/plainbox/impl/session/remote_assistant.py
index 907bce2..bef07f3 100644
--- a/plainbox/impl/session/remote_assistant.py
+++ b/plainbox/impl/session/remote_assistant.py
@@ -25,12 +25,11 @@ import time
 import sys
 from collections import namedtuple
 from threading import Thread, Lock
-from subprocess import DEVNULL, CalledProcessError, check_call, check_output
+from subprocess import CalledProcessError, check_output
 
 from plainbox.impl.execution import UnifiedRunner
 from plainbox.impl.session.assistant import SessionAssistant
 from plainbox.impl.session.assistant import SA_RESTARTABLE
-from plainbox.impl.session.jobs import InhibitionCause
 from plainbox.impl.secure.sudo_broker import SudoBroker, EphemeralKey
 from plainbox.impl.secure.sudo_broker import is_passwordless_sudo
 from plainbox.impl.secure.sudo_broker import validate_pass
@@ -210,7 +209,6 @@ class RemoteSessionAssistant():
                 return self._prepare_display_without_psutil()
             if ("DISPLAY" in p_environ and p_user != 'gdm'):  # gdm uses :1024
                 return {'DISPLAY': p_environ['DISPLAY']}
-                break
 
     @allowed_when(Idle)
     def start_session(self, configuration):
@@ -229,6 +227,8 @@ class RemoteSessionAssistant():
         self._sa.load_providers()
 
         self._normal_user = self._launcher.normal_user
+        if configuration['normal_user']:
+            self._normal_user = configuration['normal_user']
         pass_provider = (None if self._passwordless_sudo else
                          self.get_decrypted_password)
         runner_kwargs = {
@@ -292,6 +292,13 @@ class RemoteSessionAssistant():
         self._jobs_count = len(self._sa.get_dynamic_todo_list())
         self._state = TestsSelected
 
+    @allowed_when(Interacting)
+    def rerun_job(self, job_id, result):
+        self._sa.use_job_result(job_id, result)
+        self.session_change_lock.acquire(blocking=False)
+        self.session_change_lock.release()
+        self._state = TestsSelected
+
     @allowed_when(TestsSelected)
     def run_job(self, job_id):
         """
@@ -316,7 +323,8 @@ class RemoteSessionAssistant():
                     yield from self.interact(
                         Interaction('purpose', job.tr_purpose()))
                 if job.tr_steps():
-                    yield from self.interact(Interaction('steps', job.tr_steps()))
+                    yield from self.interact(
+                        Interaction('steps', job.tr_steps()))
                 if self._last_response == 'comment':
                     yield from self.interact(Interaction('comment'))
                     if self._last_response:
@@ -324,13 +332,16 @@ class RemoteSessionAssistant():
                     may_comment = True
                     continue
             if self._last_response == 'skip':
-                result_builder = JobResultBuilder(
-                    outcome=IJobResult.OUTCOME_SKIP,
-                    comments=_("Explicitly skipped before execution"))
-                if self._current_comments != "":
-                    result_builder.comments = self._current_comments
-                self.finish_job(result_builder.get_result())
-                return
+                def skipped_builder(*args, **kwargs):
+                    result_builder = JobResultBuilder(
+                        outcome=IJobResult.OUTCOME_SKIP,
+                        comments=_("Explicitly skipped before execution"))
+                    if self._current_comments != "":
+                        result_builder.comments = self._current_comments
+                    return result_builder
+                self._be = BackgroundExecutor(self, job_id, skipped_builder)
+                yield from self.interact(
+                    Interaction('skip', job.verification, self._be))
         if job.command:
             if (job.user and not self._passwordless_sudo
                     and not self._sudo_password):
@@ -355,14 +366,8 @@ class RemoteSessionAssistant():
             self._be = BackgroundExecutor(self, job_id, undecided_builder)
         if self._sa.get_job(self._currently_running_job).plugin in [
                 'manual', 'user-interact-verify']:
-            rb = self._be.wait()
-            # by this point the ui will handle adding comments via
-            # ResultBuilder.add_comment method that adds \n in front
-            # of the addition, let's rstrip it
-            rb.comments = self._current_comments.rstrip()
             yield from self.interact(
-                Interaction('verification', job.verification, rb))
-            self.finish_job(rb.get_result())
+                Interaction('verification', job.verification, self._be))
 
     @allowed_when(Started, Bootstrapping)
     def run_bootstrapping_job(self, job_id):