Merge lp:~nataliabidart/ubuntu-sso-client/run-stuff-from-mainloop into lp:ubuntu-sso-client

[Natalia Bidart]

- Provide a helper to spawn programs from the main loop that is being used by the SSO Service (LP: #920949).

The spawnner for twisted is provided so we can have a valid test suite running inside trial, it shouldn't be used IRL.

[Roberto Alsina (ralsina)]

+1 I like it!

review: Approve

[lp:~nataliabidart/ubuntu-sso-client/run-stuff-from-mainloop]

861. By Natalia Bidart on 2012-02-08

Merged trunk in.

862. By Natalia Bidart on 2012-02-08

Handle programs that already have the EXE_EXT.

[Manuel de la Peña (mandel)]

Nice work, I have tried to be evil in the review and I could't!

review: Approve

=== modified file 'setup.py'
--- setup.py	2012-02-08 02:34:29 +0000
+++ setup.py	2012-02-08 18:36:30 +0000
@@ -391,6 +391,8 @@
         'ubuntu_sso.qt.ui',
         'ubuntu_sso.utils',
         'ubuntu_sso.utils.tests',
+        'ubuntu_sso.utils.runner',
+        'ubuntu_sso.utils.runner.tests',
         'ubuntu_sso.utils.webclient',
         'ubuntu_sso.utils.webclient.tests',
         'ubuntu_sso.xdg_base_directory',

=== modified file 'ubuntu_sso/logger.py'
--- ubuntu_sso/logger.py	2012-02-06 19:57:46 +0000
+++ ubuntu_sso/logger.py	2012-02-08 18:36:30 +0000
@@ -35,7 +35,7 @@
 if not os.path.exists(unicode_path(LOGFOLDER)):
     os.makedirs(unicode_path(LOGFOLDER))
 
-if os.environ.get('DEBUG'):
+if os.environ.get('U1_DEBUG'):
     LOG_LEVEL = logging.DEBUG
 else:
     # Only log this level and above

=== modified file 'ubuntu_sso/utils/__init__.py'
--- ubuntu_sso/utils/__init__.py	2012-02-07 14:45:29 +0000
+++ ubuntu_sso/utils/__init__.py	2012-02-08 18:36:30 +0000
@@ -1,8 +1,6 @@
 # -*- coding: utf-8 -*-
-
-# Author: Alejandro J. Cura <[e-mail]>
 #
-# Copyright 2010, 2011 Canonical Ltd.
+# Copyright 2010-2012 Canonical Ltd.
 #
 # This program is free software: you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 3, as published
@@ -26,6 +24,8 @@
 from urlparse import urlparse
 
 from ubuntu_sso.logger import setup_logging
+
+
 logger = setup_logging("ubuntu_sso.utils")
 
 

=== added directory 'ubuntu_sso/utils/runner'
=== added file 'ubuntu_sso/utils/runner/__init__.py'
--- ubuntu_sso/utils/runner/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/runner/__init__.py	2012-02-08 18:36:30 +0000
@@ -0,0 +1,99 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+
+"""Utility to spawn another program from a mainloop."""
+
+import sys
+
+from twisted.internet import defer
+
+from ubuntu_sso.logger import setup_logging
+
+
+logger = setup_logging("ubuntu_sso.utils.runner")
+
+
+class SpawnError(Exception):
+    """Generic error when spawning processes."""
+
+
+class FailedToStartError(SpawnError):
+    """The process could not be spawned."""
+
+
+def is_qt4_main_loop_installed():
+    """Check if the Qt4 main loop is installed."""
+    result = False
+    try:
+        from PyQt4.QtCore import QCoreApplication
+        result = QCoreApplication.instance() is not None
+    except ImportError:
+        pass
+
+    return result
+
+
+def is_twisted_reactor_installed():
+    """Check if the Twisted reactor is installed."""
+    result = 'twisted.internet.reactor' in sys.modules
+    return result
+
+
+def spawn_program(args):
+    """Spawn the program specified by 'args'.
+
+    - 'args' should be a sequence of program arguments, the program to execute
+    is normally the first item in 'args'.
+
+    Return a deferred that will be fired when the execution of 'args' finishes,
+    passing as the deferred result code the program return code.
+
+    On error, the returned deferred will be errback'd.
+
+    """
+    logger.debug('spawn_program: requested to spawn %r.', repr(args))
+    d = defer.Deferred()
+
+    if is_twisted_reactor_installed():
+        from ubuntu_sso.utils.runner import tx
+        source = tx
+    elif 'PyQt4' in sys.modules and is_qt4_main_loop_installed():
+        from ubuntu_sso.utils.runner import qt
+        source = qt
+    else:
+        from ubuntu_sso.utils.runner import glib
+        source = glib
+
+    logger.debug('Spawn source is %r.', source)
+
+    def reply_handler(status):
+        """Callback the returned deferred."""
+        logger.debug('The program %r finished with status %r.', args, status)
+        d.callback(status)
+
+    def error_handler(msg, failed_to_start=False):
+        """Errback the returned deferred."""
+        if failed_to_start:
+            msg = 'Process %r could not be started (%r).' % (args, msg)
+            exc = FailedToStartError(msg)
+        else:
+            exc = SpawnError('Unspecified error (%r).' % msg)
+
+        logger.error('The program %r could not be run: %r', args, exc)
+        d.errback(exc)
+
+    source.spawn_program(args, reply_handler, error_handler)
+    return d

=== added file 'ubuntu_sso/utils/runner/glib.py'
--- ubuntu_sso/utils/runner/glib.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/runner/glib.py	2012-02-08 18:36:30 +0000
@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+
+"""Utility to spawn another program from a GLib mainloop."""
+
+# pylint: disable=E0611,F0401
+try:
+    from shlex import quote
+except ImportError:
+    from pipes import quote
+
+from gi.repository import GLib
+# pylint: enable=E0611,F0401
+
+from ubuntu_sso.logger import setup_logging
+
+logger = setup_logging("ubuntu_sso.utils.runner.glib")
+
+
+NO_SUCH_FILE_OR_DIR = '(No such file or directory)'
+
+
+def spawn_program(args, reply_handler, error_handler):
+    """Spawn the program specified by 'args' using the GLib mainloop.
+
+    When the program finishes, 'reply_handler' will be called with a single
+    argument that will be the porgram status code.
+
+    If there is an error, error_handler will be called with an instance of
+    SpawnError.
+
+    """
+
+    def child_watch(pid, status):
+        """Handle child termination."""
+        # pylint: disable=E1103
+        GLib.spawn_close_pid(pid)
+        # pylint: enable=E1103
+        reply_handler(status)
+
+    def handle_error(gerror):
+        """Handle error when spawning the process."""
+        failed_to_start = NO_SUCH_FILE_OR_DIR in gerror.message
+        msg = 'GError is: code %r, message %r' % (gerror.code, gerror.message)
+        error_handler(msg=msg, failed_to_start=failed_to_start)
+
+    # escape arguments
+    args = [quote(a) for a in args]
+
+    flags = GLib.SpawnFlags.DO_NOT_REAP_CHILD | \
+            GLib.SpawnFlags.SEARCH_PATH | \
+            GLib.SpawnFlags.STDOUT_TO_DEV_NULL | \
+            GLib.SpawnFlags.STDERR_TO_DEV_NULL
+    pid = None
+    try:
+        pid, _, _, _ = GLib.spawn_async(argv=args, flags=flags)
+    except GLib.GError, e:
+        handle_error(e)
+    else:
+        logger.debug('Spawning the program %r with the glib mainloop '
+                     '(returned pid is %r).', args, pid)
+        GLib.child_watch_add(pid, child_watch)

=== added file 'ubuntu_sso/utils/runner/qt.py'
--- ubuntu_sso/utils/runner/qt.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/runner/qt.py	2012-02-08 18:36:30 +0000
@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+
+"""Utility to spawn another program from a plain Qt mainloop."""
+
+from PyQt4 import QtCore
+
+from ubuntu_sso.logger import setup_logging
+
+
+logger = setup_logging("ubuntu_sso.utils.runner.qt")
+
+
+def spawn_program(args, reply_handler, error_handler):
+    """Spawn the program specified by 'args' using the Qt mainloop.
+
+    When the program finishes, 'reply_handler' will be called with a single
+    argument that will be the porgram status code.
+
+    If there is an error, error_handler will be called with an instance of
+    SpawnError.
+
+    """
+
+    process = QtCore.QProcess()
+
+    def print_pid():
+        """Add a debug log message."""
+        pid = process.pid()
+        logger.debug('Spawning the program %r with the qt mainloop '
+                     '(returned pid is %r).', args, pid)
+
+    def handle_error(process_error):
+        """Handle error when spawning the process."""
+        failed_to_start = process_error == QtCore.QProcess.FailedToStart
+        msg = 'ProcessError is %r' % process_error
+        error_handler(msg=msg, failed_to_start=failed_to_start)
+
+    process.started.connect(print_pid)
+    process.finished.connect(reply_handler)
+    process.error.connect(handle_error)
+
+    args = list(args)
+    program = args[0]
+    argv = args[1:]
+    process.start(program, argv)

=== added directory 'ubuntu_sso/utils/runner/tests'
=== added file 'ubuntu_sso/utils/runner/tests/__init__.py'
--- ubuntu_sso/utils/runner/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/runner/tests/__init__.py	2012-02-08 18:36:30 +0000
@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+
+"""Tests for the program runner."""

=== added file 'ubuntu_sso/utils/runner/tests/test_qt.py'
--- ubuntu_sso/utils/runner/tests/test_qt.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/runner/tests/test_qt.py	2012-02-08 18:36:30 +0000
@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+
+"""Tests for the qt runner helper module."""
+
+import subprocess
+
+from PyQt4 import QtCore
+from twisted.internet import defer
+
+from ubuntu_sso.utils import runner
+from ubuntu_sso.utils.runner.tests.test_runner import SpawnProgramTestCase
+
+
+class FakedSignal(object):
+    """Fake a Qt signal."""
+
+    def __init__(self, name):
+        self.name = name
+        self._handlers = []
+
+    def connect(self, handler):
+        """Connect 'handler' with this signal."""
+        self._handlers.append(handler)
+
+    def emit(self, *args, **kwargs):
+        """Emit this signal."""
+        for handler in self._handlers:
+            handler(*args, **kwargs)
+
+
+class FakedProcess(object):
+    """Fake a Qt Process."""
+
+    _pid = 123456
+    _error = None
+    _status_code = 0
+
+    FailedToStart = 0
+
+    def __init__(self):
+        self.pid = lambda: self._pid
+        self.started = FakedSignal('started')
+        self.finished = FakedSignal('finished')
+        self.error = FakedSignal('error')
+
+    def start(self, program, arguments):
+        """Start this process."""
+        if self._error is None:
+            self.started.emit()
+
+            args = (program,) + tuple(arguments)
+            try:
+                subprocess.call(args)
+            except OSError, e:
+                if e.errno == 2:
+                    self.error.emit(self.FailedToStart)
+                else:
+                    self.error.emit(e)
+            except Exception, e:
+                self.error.emit(e)
+            else:
+                self.finished.emit(self._status_code)
+        else:
+            self.error.emit(self._error)
+
+
+class QtSpawnProgramTestCase(SpawnProgramTestCase):
+    """The test suite for the spawn_program method (using Qt)."""
+
+    use_reactor = False
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(QtSpawnProgramTestCase, self).setUp()
+        # Since we can't mix plan qt runner and the qt4reactor, we patch
+        # QProcess and fake the conditions so the qt runner is chosen
+        self.patch(QtCore, 'QProcess', FakedProcess)
+        self.patch(runner, 'is_twisted_reactor_installed', lambda: False)
+        self.patch(runner, 'is_qt4_main_loop_installed', lambda: True)

=== added file 'ubuntu_sso/utils/runner/tests/test_runner.py'
--- ubuntu_sso/utils/runner/tests/test_runner.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/runner/tests/test_runner.py	2012-02-08 18:36:30 +0000
@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+
+"""Tests for the runner helper module."""
+
+import os
+
+from twisted.internet import defer
+
+from ubuntu_sso.tests import TestCase
+from ubuntu_sso.utils import runner
+
+
+TEST_ME_DIR = 'test-me'
+
+
+class SpawnProgramTestCase(TestCase):
+    """The test suite for the spawn_program method."""
+
+    timeout = 3
+    args = ('python', '-c', 'import os; os.system("mkdir %s")' % TEST_ME_DIR)
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(SpawnProgramTestCase, self).setUp()
+        assert not os.path.exists(TEST_ME_DIR)
+        self.addCleanup(lambda: os.path.exists(TEST_ME_DIR) and
+                                os.rmdir(TEST_ME_DIR))
+
+    def spawn_fn(self, args):
+        """The target function to test."""
+        return runner.spawn_program(args)
+
+    def assert_command_was_run(self):
+        """The spawnned commnad was correctly run."""
+        self.assertTrue(os.path.exists(TEST_ME_DIR))
+        self.assertTrue(os.path.isdir(TEST_ME_DIR))
+
+    @defer.inlineCallbacks
+    def test_program_is_spawned(self):
+        """The program is actually spawned."""
+        yield self.spawn_fn(self.args)
+        self.assert_command_was_run()
+
+    @defer.inlineCallbacks
+    def test_program_is_spawned_returned_code_non_zero(self):
+        """The program is actually spawned."""
+        status = yield self.spawn_fn(self.args)
+        self.assertEqual(status, 0)
+
+    @defer.inlineCallbacks
+    def test_failed_to_start(self):
+        """FailedToStartError is raised if the program does not start."""
+        no_such_program = './myexecutablethatdoesnotexist'
+        assert not os.path.exists(no_such_program)
+
+        d = self.spawn_fn((no_such_program,))
+        exc = yield self.assertFailure(d, runner.FailedToStartError)
+
+        self.assertIn(no_such_program, exc.message)
+
+    @defer.inlineCallbacks
+    def test_other_error(self):
+        """SpawnError is raised if the program does not start."""
+        d = self.spawn_fn((None,))
+        exc = yield self.assertFailure(d, runner.SpawnError)
+
+        self.assertIn('Unspecified error', exc.message)

=== added file 'ubuntu_sso/utils/runner/tx.py'
--- ubuntu_sso/utils/runner/tx.py	1970-01-01 00:00:00 +0000
+++ ubuntu_sso/utils/runner/tx.py	2012-02-08 18:36:30 +0000
@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, 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/>.
+
+"""Utility to spawn another program from a mainloop."""
+
+import os
+import sys
+
+from twisted.internet import utils
+
+from ubuntu_sso.logger import setup_logging
+
+
+logger = setup_logging("ubuntu_sso.utils.runner.tx")
+
+NO_SUCH_FILE_OR_DIR = 'OSError: [Errno 2] No such file or directory'
+
+
+EXE_EXT = ''
+if sys.platform == 'win32':
+    EXE_EXT = '.exe'
+
+
+def spawn_program(args, reply_handler, error_handler):
+    """Spawn the program specified by 'args' using the twisted reactor.
+
+    When the program finishes, 'reply_handler' will be called with a single
+    argument that will be the porgram status code.
+
+    If there is an error, error_handler will be called with an instance of
+    SpawnError.
+
+    """
+
+    def child_watch((stdout, stderr, exit_code)):
+        """Handle child termination."""
+        if stdout:
+            logger.debug('Returned stdout is (exit code was %r): %r',
+                         exit_code, stdout)
+        if stderr:
+            logger.warning('Returned stderr is (exit code was %r): %r',
+                           exit_code, stderr)
+
+        if OSError.__name__ in stderr:
+            failed_to_start = NO_SUCH_FILE_OR_DIR in stderr
+            error_handler(msg=stderr, failed_to_start=failed_to_start)
+        else:
+            reply_handler(exit_code)
+
+    def handle_error(failure):
+        """Handle error when spawning the process."""
+        error_handler(msg=failure.getErrorMessage())
+
+    args = list(args)
+    program = args[0]
+    argv = args[1:]
+
+    if program and not os.access(program, os.X_OK):
+        # handle searching the executable in the PATH, since
+        # twisted will not solve that for us :-/
+        paths = os.environ['PATH'].split(os.pathsep)
+        for path in paths:
+            target = os.path.join(path, program)
+            if not target.endswith(EXE_EXT):
+                target += EXE_EXT
+            if os.access(target, os.X_OK):
+                program = target
+                break
+
+    try:
+        d = utils.getProcessOutputAndValue(program, argv, env=os.environ)
+    except OSError, e:
+        error_handler(msg=e, failed_to_start=True)
+    except Exception, e:
+        error_handler(msg=e, failed_to_start=False)
+    else:
+        logger.debug('Spawning the program %r with the twisted reactor '
+                     '(returned deferred is %r).', repr(args), d)
+        d.addCallback(child_watch)
+        d.addErrback(handle_error)