# Copyright (c) 2014 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
# This module helps launch pseudomodem as a subprocess. It helps with the
# initial setup of pseudomodem, as well as ensures proper cleanup.
# For details about the options accepted by pseudomodem, please check the
# |pseudomodem| module.
# This module also doubles as the python entry point to run pseudomodem from the
# command line. To avoid confusion, please use the shell script run_pseudomodem
# to run pseudomodem from command line.
import dbus
import json
import logging
import os
import pwd
import signal
import stat
import sys
import subprocess
import tempfile
import common
from autotest_lib.client.bin import utils
from autotest_lib.client.common_lib import error
from autotest_lib.client.cros import service_stopper
from autotest_lib.client.cros.cellular import mm1_constants
from autotest_lib.client.cros.cellular import net_interface
import pm_constants
import pseudomodem
# TODO(pprabhu) Move this to the right utils file.
# pprabhu: I haven't yet figured out which of the myriad utils files I should
# update. There is an implementation of |nuke_subprocess| that does not take
# timeout_hint_seconds in common_lib/base_utils.py, but |poll_for_condition|
# is not available there.
def nuke_subprocess(subproc, timeout_hint_seconds=0):
"""
Attempt to kill the given subprocess via an escalating series of signals.
Between each attempt, the process is given |timeout_hint_seconds| to clean
up. So, the function may take up to 3 * |timeout_hint_seconds| time to
finish.
@param subproc: The python subprocess to nuke.
@param timeout_hint_seconds: The time to wait between successive attempts.
@returns: The result from the subprocess, None if we failed to kill it.
"""
# check if the subprocess is still alive, first
if subproc.poll() is not None:
return subproc.poll()
signal_queue = [signal.SIGINT, signal.SIGTERM, signal.SIGKILL]
for sig in signal_queue:
logging.info('Nuking %s with %s', subproc.pid, sig)
utils.signal_pid(subproc.pid, sig)
try:
utils.poll_for_condition(
lambda: subproc.poll() is not None,
timeout=timeout_hint_seconds)
return subproc.poll()
except utils.TimeoutError:
pass
return None
class PseudoModemManagerContextException(Exception):
""" Exception class for exceptions raised by PseudoModemManagerContext. """
pass
class PseudoModemManagerContext(object):
"""
A context to launch pseudomodem in background.
Tests should use |PeudoModemManagerContext| to launch pseudomodem. It is
intended to be used with the |with| clause like so:
with PseudoModemManagerContext(...):
# Run test
pseudomodem will be launch in a subprocess safely when entering the |with|
block, and cleaned up when exiting.
"""
SHORT_TIMEOUT_SECONDS = 4
# Some actions are dependent on hardware cooperating. We need to wait longer
# for these. Try to minimize using this constant.
WAIT_FOR_HARDWARE_TIMEOUT_SECONDS = 12
TEMP_FILE_PREFIX = 'pseudomodem_'
REAL_MANAGER_SERVICES = ['modemmanager', 'cromo']
REAL_MANAGER_PROCESSES = ['ModemManager', 'cromo']
TEST_OBJECT_ARG_FLAGS = ['test-modem-arg',
'test-sim-arg',
'test-state-machine-factory-arg']
def __init__(self,
use_pseudomodem,
flags_map=None,
block_output=True,
bus=None):
"""
@param use_pseudomodem: This flag can be used to treat pseudomodem as a
no-op. When |True|, pseudomodem is launched as expected. When
|False|, this operation is a no-op, and pseudomodem will not be
launched.
@param flags_map: This is a map of pseudomodem arguments. See
|pseudomodem| module for the list of supported arguments. For
example, to launch pseudomodem with a modem of family 3GPP, use:
with PseudoModemManager(True, flags_map={'family' : '3GPP}):
# Do stuff
@param block_output: If True, output from the pseudomodem process is not
piped to stdout. This is the default.
@param bus: A handle to the dbus.SystemBus. If you use dbus in your
tests, you should obtain a handle to the bus and pass it in
here. Not doing so can cause incompatible mainloop settings in
the dbus module.
"""
self._use_pseudomodem = use_pseudomodem
self._block_output = block_output
self._temp_files = []
self.cmd_line_flags = self._ConvertMapToFlags(flags_map if flags_map
else {})
self._service_stopper = service_stopper.ServiceStopper(
self.REAL_MANAGER_SERVICES)
self._net_interface = None
self._null_pipe = None
self._exit_error_file_path = None
self._pseudomodem_process = None
self._bus = bus
if not self._bus:
# Currently, the glib mainloop, or a wrapper thereof are the only
# mainloops we ever use with dbus. So, it's a comparatively safe bet
# to set that up as the mainloop here.
# Ideally, if a test wants to use dbus, it should pass us its own
# bus.
dbus_loop = dbus.mainloop.glib.DBusGMainLoop()
self._bus = dbus.SystemBus(private=True, mainloop=dbus_loop)
@property
def cmd_line_flags(self):
""" The command line flags that will be passed to pseudomodem. """
return self._cmd_line_flags
@cmd_line_flags.setter
def cmd_line_flags(self, val):
"""
Set the command line flags to be passed to pseudomodem.
@param val: The flags.
"""
logging.info('Command line flags for pseudomodem set to: |%s|', val)
self._cmd_line_flags = val
def __enter__(self):
return self.Start()
def __exit__(self, *args):
return self.Stop(*args)
def Start(self):
""" Start the context. This launches pseudomodem. """
if not self._use_pseudomodem:
return self
self._CheckPseudoModemArguments()
self._service_stopper.stop_services()
self._WaitForRealModemManagersToDie()
self._net_interface = net_interface.PseudoNetInterface()
self._net_interface.Setup()
toplevel = os.path.dirname(os.path.realpath(__file__))
cmd = [os.path.join(toplevel, 'pseudomodem.py')]
cmd = cmd + self.cmd_line_flags
fd, self._exit_error_file_path = self._CreateTempFile()
os.close(fd) # We don't need the fd.
cmd = cmd + [pseudomodem.EXIT_ERROR_FILE_FLAG,
self._exit_error_file_path]
# Setup health checker for child process.
signal.signal(signal.SIGCHLD, self._SigchldHandler)
if self._block_output:
self._null_pipe = open(os.devnull, 'w')
self._pseudomodem_process = subprocess.Popen(
cmd,
preexec_fn=PseudoModemManagerContext._SetUserModem,
close_fds=True,
stdout=self._null_pipe,
stderr=self._null_pipe)
else:
self._pseudomodem_process = subprocess.Popen(
cmd,
preexec_fn=PseudoModemManagerContext._SetUserModem,
close_fds=True)
self._EnsurePseudoModemUp()
return self
def Stop(self, *args):
""" Exit the context. This terminates pseudomodem. """
if not self._use_pseudomodem:
return
# Remove health check on child process.
signal.signal(signal.SIGCHLD, signal.SIG_DFL)
if self._pseudomodem_process:
if self._pseudomodem_process.poll() is None:
if (nuke_subprocess(self._pseudomodem_process,
self.SHORT_TIMEOUT_SECONDS) is
None):
logging.warning('Failed to clean up the launched '
'pseudomodem process')
self._pseudomodem_process = None
if self._null_pipe:
self._null_pipe.close()
self._null_pipe = None
if self._net_interface:
self._net_interface.Teardown()
self._net_interface = None
self._DeleteTempFiles()
self._service_stopper.restore_services()
def _ConvertMapToFlags(self, flags_map):
"""
Convert the argument map given to the context to flags for pseudomodem.
@param flags_map: A map of flags. The keys are the names of the flags
accepted by pseudomodem. The value, if not None, is the value
for that flag. We do not support |None| as the value for a flag.
@returns: the list of flags to pass to pseudomodem.
"""
cmd_line_flags = []
for key, value in flags_map.iteritems():
cmd_line_flags.append('--' + key)
if key in self.TEST_OBJECT_ARG_FLAGS:
cmd_line_flags.append(self._DumpArgToFile(value))
elif value:
cmd_line_flags.append(value)
return cmd_line_flags
def _DumpArgToFile(self, arg):
"""
Dump a given python list to a temp file in json format.
This is used to pass arguments to custom objects from tests that
are to be instantiated by pseudomodem. The argument must be a list. When
running pseudomodem, this list will be unpacked to get the arguments.
@returns: Absolute path to the tempfile created.
"""
fd, arg_file_path = self._CreateTempFile()
arg_file = os.fdopen(fd, 'wb')
json.dump(arg, arg_file)
arg_file.close()
return arg_file_path
def _WaitForRealModemManagersToDie(self):
"""
Wait for real modem managers to quit. Die otherwise.
Sometimes service stopper does not kill ModemManager process, if it is
launched by something other than upstart. We want to ensure that the
process is dead before continuing.
This method can block for up to a minute. Sometimes, ModemManager can
take up to a 10 seconds to die after service stopper has stopped it. We
wait for it to clean up before concluding that the process is here to
stay.
@raises: PseudoModemManagerContextException if a modem manager process
does not quit in a reasonable amount of time.
"""
def _IsProcessRunning(process):
try:
utils.run('pgrep -x %s' % process)
return True
except error.CmdError:
return False
for manager in self.REAL_MANAGER_PROCESSES:
try:
utils.poll_for_condition(
lambda:not _IsProcessRunning(manager),
timeout=self.WAIT_FOR_HARDWARE_TIMEOUT_SECONDS)
except utils.TimeoutError:
err_msg = ('%s is still running. '
'It may interfere with pseudomodem.' %
manager)
logging.error(err_msg)
raise PseudoModemManagerContextException(err_msg)
def _CheckPseudoModemArguments(self):
"""
Parse the given pseudomodem arguments.
By parsing the arguments in the context, we can provide early feedback
about incorrect arguments.
"""
pseudomodem.ParseArguments(self.cmd_line_flags)
@staticmethod
def _SetUserModem():
"""
Set the unix user of the calling process to |modem|.
This functions is called by the launched subprocess so that pseudomodem
can be launched as the |modem| user.
On encountering an error, this method will terminate the process.
"""
try:
pwd_data = pwd.getpwnam(pm_constants.MM1_USER)
except KeyError as e:
logging.error('Could not find uid for user %s [%s]',
pm_constants.MM1_USER, str(e))
sys.exit(1)
logging.debug('Setting UID to %d', pwd_data.pw_uid)
try:
os.setuid(pwd_data.pw_uid)
except OSError as e:
logging.error('Could not set uid to %d [%s]',
pwd_data.pw_uid, str(e))
sys.exit(1)
def _EnsurePseudoModemUp(self):
""" Makes sure that pseudomodem in child process is ready. """
def _LivenessCheck():
try:
testing_object = self._bus.get_object(
mm1_constants.I_MODEM_MANAGER,
pm_constants.TESTING_PATH)
return testing_object.IsAlive(
dbus_interface=pm_constants.I_TESTING)
except dbus.DBusException as e:
logging.debug('LivenessCheck: No luck yet. (%s)', str(e))
return False
utils.poll_for_condition(
_LivenessCheck,
timeout=self.SHORT_TIMEOUT_SECONDS,
exception=PseudoModemManagerContextException(
'pseudomodem did not initialize properly.'))
def _CreateTempFile(self):
"""
Creates a tempfile such that the child process can read/write it.
The file path is stored in a list so that the file can be deleted later
using |_DeleteTempFiles|.
@returns: (fd, arg_file_path)
fd: A file descriptor for the created file.
arg_file_path: Full path of the created file.
"""
fd, arg_file_path = tempfile.mkstemp(prefix=self.TEMP_FILE_PREFIX)
self._temp_files.append(arg_file_path)
# Set file permissions so that pseudomodem process can read/write it.
cur_mod = os.stat(arg_file_path).st_mode
os.chmod(arg_file_path,
cur_mod | stat.S_IRGRP | stat.S_IROTH | stat.S_IWGRP |
stat.S_IWOTH)
return fd, arg_file_path
def _DeleteTempFiles(self):
""" Deletes all temp files created by this context. """
for file_path in self._temp_files:
try:
os.remove(file_path)
except OSError as e:
logging.warning('Failed to delete temp file: %s (error %s)',
file_path, str(e))
def _SigchldHandler(self, signum, frame):
"""
Signal handler for SIGCHLD.
This is setup while the pseudomodem subprocess is running. A call to
this signal handler may signify early termination of the subprocess.
@param signum: The signal number.
@param frame: Ignored.
"""
if not self._pseudomodem_process:
# We can receive a SIGCHLD even before the setup of the child
# process is complete.
return
if self._pseudomodem_process.poll() is not None:
# See if child process left detailed error report
error_reason, error_traceback = pseudomodem.ExtractExitError(
self._exit_error_file_path)
logging.error('pseudomodem child process quit early!')
logging.error('Reason: %s', error_reason)
for line in error_traceback:
logging.error('Traceback: %s', line.strip())
raise PseudoModemManagerContextException(
'pseudomodem quit early! (%s)' %
error_reason)