scripts: west: fix some intel_s1000 runner issues

There are a few issues with the intel_s1000 runner:

- it doesn't attach to the client when running debug (this is
  a part of the command's contract specified in core.py)

- it uses hard-coded sleeps when running subprocesses instead of
  waiting for them to terminate

- it re-implements pre-existing popen_ignore_int() functionality (in a
  way that is not portable to Windows) rather than using it directly

Fix these issues.

Signed-off-by: Marti Bolivar <[email protected]>

Author: Marti Bolivar

scripts/meta/west/runner/intel_s1000.py

@@ -1,12 +1,13 @@
 # Copyright (c) 2018 Intel Corporation.
+# Copyright 2018 Open Source Foundries Limited.
 #
 # SPDX-License-Identifier: Apache-2.0
 
 '''Runner for debugging and flashing intel_s1000 devices'''
 from os import path
 from .core import ZephyrBinaryRunner
 import time
-import signal
+import subprocess
 
 DEFAULT_XT_GDB_PORT = 20000
 
@@ -75,6 +76,7 @@ def do_run(self, command, **kwargs):
         elif command == 'debugserver':
             self.debugserver(**kwargs)
         else:
+            self.debugserver(**kwargs)
             self.do_debug()
 
     def flash(self, **kwargs):
@@ -90,23 +92,19 @@ def flash(self, **kwargs):
         # Start the server
         # Note that XTOCD always fails the first time. It has to be
         # relaunched the second time to work.
-        self.popen_ignore_int(server_cmd)
-        time.sleep(3)
+        self.call(server_cmd)
         server_proc = self.popen_ignore_int(server_cmd)
         time.sleep(3)
 
-        # Start the client
+        # Start the client, and wait for it to finish flashing the file.
         gdb_cmd = [self.gdb_cmd, '-x', gdb_flash_file]
         client_proc = self.popen_ignore_int(gdb_cmd)
-
-        # Wait for 3 seconds (waiting for XTGDB to finish)
-        time.sleep(3)
+        client_proc.wait()
 
         # At this point, the ELF image is loaded and the program is in
-        # execution. Now we can quit the client (xt-gdb) and the server
-        # (xt-ocd) as they are not needed anymore. The loaded program
-        # (ELF) will continue to run though.
-        client_proc.terminate()
+        # execution. Now we can quit the server (xt-ocd); it is not
+        # needed anymore. The loaded program (ELF) will continue to
+        # run.
         server_proc.terminate()
 
     def do_debug(self):
@@ -118,15 +116,10 @@ def do_debug(self):
         gdb_cmd = [self.gdb_cmd,
                    '-ex', 'target remote :{}'.format(self.gdb_port),
                    self.elf_name]
-
-        # The below statement will consume the "^C" keypress ensuring
-        # the python main application doesn't exit. This is important
-        # since ^C in gdb means a "halt" operation.
-        previous = signal.signal(signal.SIGINT, signal.SIG_IGN)
-        try:
-            self.check_call(gdb_cmd)
-        finally:
-            signal.signal(signal.SIGINT, previous)
+        gdb_proc = self.popen_ignore_int(gdb_cmd)
+        retcode = gdb_proc.wait()
+        if retcode:
+            raise subprocess.CalledProcessError((retcode, gdb_cmd))
 
     def print_gdbserver_message(self, gdb_port):
         print('Intel S1000 GDB server running on port {}'.format(gdb_port))
@@ -142,6 +135,5 @@ def debugserver(self, **kwargs):
 
         # Note that XTOCD always fails the first time. It has to be
         # relaunched the second time to work.
-        self.popen_ignore_int(server_cmd)
-        time.sleep(3)
+        self.call(server_cmd)
         self.check_call(server_cmd)