__author__ = "jadmanski@google.com (John Admanski)"
|
|
import os, sys
|
|
# This must run on Python versions less than 2.4.
|
dirname = os.path.dirname(sys.modules[__name__].__file__)
|
common_dir = os.path.abspath(os.path.join(dirname, "common_lib"))
|
sys.path.insert(0, common_dir)
|
import check_version
|
sys.path.pop(0)
|
check_version.check_python_version()
|
|
import glob, traceback, types
|
|
|
def _create_module(name):
|
"""Create a single top-level module"""
|
module = types.ModuleType(name)
|
sys.modules[name] = module
|
return module
|
|
|
def _create_module_and_parents(name):
|
"""Create a module, and all the necessary parents"""
|
parts = name.split(".")
|
# first create the top-level module
|
parent = _create_module(parts[0])
|
created_parts = [parts[0]]
|
parts.pop(0)
|
# now, create any remaining child modules
|
while parts:
|
child_name = parts.pop(0)
|
module = types.ModuleType(child_name)
|
setattr(parent, child_name, module)
|
created_parts.append(child_name)
|
sys.modules[".".join(created_parts)] = module
|
parent = module
|
|
|
def _import_children_into_module(parent_module_name, path):
|
"""Import all the packages on a path into a parent module"""
|
# find all the packages at 'path'
|
names = []
|
for filename in os.listdir(path):
|
full_name = os.path.join(path, filename)
|
if not os.path.isdir(full_name):
|
continue # skip files
|
if "." in filename:
|
continue # if "." is in the name it's not a valid package name
|
if not os.access(full_name, os.R_OK | os.X_OK):
|
continue # need read + exec access to make a dir importable
|
if "__init__.py" in os.listdir(full_name):
|
names.append(filename)
|
# import all the packages and insert them into 'parent_module'
|
sys.path.insert(0, path)
|
for name in names:
|
module = __import__(name)
|
# add the package to the parent
|
parent_module = sys.modules[parent_module_name]
|
setattr(parent_module, name, module)
|
full_name = parent_module_name + "." + name
|
sys.modules[full_name] = module
|
# restore the system path
|
sys.path.pop(0)
|
|
|
def import_module(module, from_where):
|
"""Equivalent to 'from from_where import module'
|
Returns the corresponding module"""
|
from_module = __import__(from_where, globals(), locals(), [module])
|
return getattr(from_module, module)
|
|
|
def _autotest_logging_handle_error(self, record):
|
"""Method to monkey patch into logging.Handler to replace handleError."""
|
# The same as the default logging.Handler.handleError but also prints
|
# out the original record causing the error so there is -some- idea
|
# about which call caused the logging error.
|
import logging
|
if logging.raiseExceptions:
|
# Avoid recursion as the below output can end up back in here when
|
# something has *seriously* gone wrong in autotest.
|
logging.raiseExceptions = 0
|
sys.stderr.write('Exception occurred formatting message: '
|
'%r using args %r\n' % (record.msg, record.args))
|
traceback.print_stack()
|
sys.stderr.write('-' * 50 + '\n')
|
traceback.print_exc()
|
sys.stderr.write('Future logging formatting exceptions disabled.\n')
|
|
|
def _monkeypatch_logging_handle_error():
|
# Hack out logging.py*
|
logging_py = os.path.join(os.path.dirname(__file__), "common_lib",
|
"logging.py*")
|
if glob.glob(logging_py):
|
os.system("rm -f %s" % logging_py)
|
|
# Monkey patch our own handleError into the logging module's StreamHandler.
|
# A nicer way of doing this -might- be to have our own logging module define
|
# an autotest Logger instance that added our own Handler subclass with this
|
# handleError method in it. But that would mean modifying tons of code.
|
import logging
|
assert callable(logging.Handler.handleError)
|
logging.Handler.handleError = _autotest_logging_handle_error
|
|
|
def setup(base_path, root_module_name=""):
|
"""
|
Perform all the necessary setup so that all the packages at
|
'base_path' can be imported via "import root_module_name.package".
|
If root_module_name is empty, then all the packages at base_path
|
are inserted as top-level packages.
|
|
Also, setup all the common.* aliases for modules in the common
|
library.
|
|
The setup must be different if you are running on an Autotest server
|
or on a test machine that just has the client directories installed.
|
"""
|
# Hack... Any better ideas?
|
if (root_module_name == 'autotest_lib.client' and
|
os.path.exists(os.path.join(os.path.dirname(__file__),
|
'..', 'server'))):
|
root_module_name = 'autotest_lib'
|
base_path = os.path.abspath(os.path.join(base_path, '..'))
|
|
_create_module_and_parents(root_module_name)
|
_import_children_into_module(root_module_name, base_path)
|
|
if root_module_name == 'autotest_lib':
|
# Allow locally installed third party packages to be found
|
# before any that are installed on the system itself when not.
|
# running as a client.
|
# This is primarily for the benefit of frontend and tko so that they
|
# may use libraries other than those available as system packages.
|
sys.path.insert(0, os.path.join(base_path, "site-packages"))
|
|
_monkeypatch_logging_handle_error()
|
