diff options
Diffstat (limited to 'configure.py')
| -rw-r--r-- | configure.py | 343 |
1 files changed, 343 insertions, 0 deletions
diff --git a/configure.py b/configure.py new file mode 100644 index 0000000000..e4a4ee25ca --- /dev/null +++ b/configure.py @@ -0,0 +1,343 @@ +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +import codecs +import errno +import io +import itertools +import logging +import os +import pprint +import sys +import textwrap +from collections.abc import Iterable + +base_dir = os.path.abspath(os.path.dirname(__file__)) +sys.path.insert(0, os.path.join(base_dir, "python", "mach")) +sys.path.insert(0, os.path.join(base_dir, "python", "mozboot")) +sys.path.insert(0, os.path.join(base_dir, "python", "mozbuild")) +sys.path.insert(0, os.path.join(base_dir, "third_party", "python", "packaging")) +sys.path.insert(0, os.path.join(base_dir, "third_party", "python", "pyparsing")) +sys.path.insert(0, os.path.join(base_dir, "third_party", "python", "six")) +sys.path.insert(0, os.path.join(base_dir, "third_party", "python", "looseversion")) +import mozpack.path as mozpath +import six +from mach.requirements import MachEnvRequirements +from mach.site import ( + CommandSiteManager, + ExternalPythonSite, + MachSiteManager, + MozSiteMetadata, + SitePackagesSource, +) +from mozbuild.backend.configenvironment import PartialConfigEnvironment +from mozbuild.configure import TRACE, ConfigureSandbox +from mozbuild.pythonutil import iter_modules_in_path + + +def main(argv): + # Check for CRLF line endings. + with open(__file__, "r") as fh: + data = fh.read() + if "\r" in data: + print( + "\n ***\n" + " * The source tree appears to have Windows-style line endings.\n" + " *\n" + " * If using Git, Git is likely configured to use Windows-style\n" + " * line endings.\n" + " *\n" + " * To convert the working copy to UNIX-style line endings, run\n" + " * the following:\n" + " *\n" + " * $ git config core.autocrlf false\n" + " * $ git config core.eof lf\n" + " * $ git rm --cached -r .\n" + " * $ git reset --hard\n" + " *\n" + " * If not using Git, the tool you used to obtain the source\n" + " * code likely converted files to Windows line endings. See\n" + " * usage information for that tool for more.\n" + " ***", + file=sys.stderr, + ) + return 1 + + config = {} + + if "OLD_CONFIGURE" not in os.environ: + os.environ["OLD_CONFIGURE"] = os.path.join(base_dir, "old-configure") + + sandbox = ConfigureSandbox(config, os.environ, argv) + + if not sandbox._help: + # This limitation has mostly to do with GNU make. Since make can't represent + # variables with spaces without correct quoting and many paths are used + # without proper quoting, using paths with spaces commonly results in + # targets or dependencies being treated as multiple paths. This, of course, + # undermines the ability for make to perform up-to-date checks and makes + # the build system not work very efficiently. In theory, a non-make build + # backend will make this limitation go away. But there is likely a long tail + # of things that will need fixing due to e.g. lack of proper path quoting. + topsrcdir = os.path.realpath(os.path.dirname(__file__)) + if len(topsrcdir.split()) > 1: + print( + "Source directory cannot be located in a path with spaces: %s" + % topsrcdir, + file=sys.stderr, + ) + return 1 + topobjdir = os.path.realpath(os.curdir) + if len(topobjdir.split()) > 1: + print( + "Object directory cannot be located in a path with spaces: %s" + % topobjdir, + file=sys.stderr, + ) + return 1 + + # Do not allow topobjdir == topsrcdir + if os.path.samefile(topsrcdir, topobjdir): + print( + " ***\n" + " * Building directly in the main source directory is not allowed.\n" + " *\n" + " * To build, you must run configure from a separate directory\n" + " * (referred to as an object directory).\n" + " *\n" + " * If you are building with a mozconfig, you will need to change your\n" + " * mozconfig to point to a different object directory.\n" + " ***", + file=sys.stderr, + ) + return 1 + _activate_build_virtualenv() + + clobber_file = "CLOBBER" + if not os.path.exists(clobber_file): + # Simply touch the file. + with open(clobber_file, "a"): + pass + + if os.environ.get("MOZ_CONFIGURE_TRACE"): + sandbox._logger.setLevel(TRACE) + + sandbox.run(os.path.join(os.path.dirname(__file__), "moz.configure")) + + if sandbox._help: + return 0 + + logging.getLogger("moz.configure").info("Creating config.status") + + old_js_configure_substs = config.pop("OLD_JS_CONFIGURE_SUBSTS", None) + old_js_configure_defines = config.pop("OLD_JS_CONFIGURE_DEFINES", None) + if old_js_configure_substs or old_js_configure_defines: + js_config = config.copy() + pwd = os.getcwd() + try: + try: + os.makedirs("js/src") + except OSError as e: + if e.errno != errno.EEXIST: + raise + + os.chdir("js/src") + js_config["OLD_CONFIGURE_SUBSTS"] = old_js_configure_substs + js_config["OLD_CONFIGURE_DEFINES"] = old_js_configure_defines + # The build system frontend expects $objdir/js/src/config.status + # to have $objdir/js/src as topobjdir. + # We want forward slashes on all platforms. + js_config["TOPOBJDIR"] += "/js/src" + config_status(js_config, execute=False) + finally: + os.chdir(pwd) + + return config_status(config) + + +def check_unicode(obj): + """Recursively check that all strings in the object are unicode strings.""" + if isinstance(obj, dict): + result = True + for k, v in six.iteritems(obj): + if not check_unicode(k): + print("%s key is not unicode." % k, file=sys.stderr) + result = False + elif not check_unicode(v): + print("%s value is not unicode." % k, file=sys.stderr) + result = False + return result + if isinstance(obj, bytes): + return False + if isinstance(obj, six.text_type): + return True + if isinstance(obj, Iterable): + return all(check_unicode(o) for o in obj) + return True + + +def config_status(config, execute=True): + # Sanitize config data to feed config.status + # Ideally, all the backend and frontend code would handle the booleans, but + # there are so many things involved, that it's easier to keep config.status + # untouched for now. + def sanitize_config(v): + if v is True: + return "1" + if v is False: + return "" + # Serialize types that look like lists and tuples as lists. + if not isinstance(v, (bytes, six.text_type, dict)) and isinstance(v, Iterable): + return list(v) + return v + + sanitized_config = {} + sanitized_config["substs"] = { + k: sanitize_config(v) + for k, v in six.iteritems(config) + if k + not in ( + "DEFINES", + "TOPSRCDIR", + "TOPOBJDIR", + "CONFIG_STATUS_DEPS", + "OLD_CONFIGURE_SUBSTS", + "OLD_CONFIGURE_DEFINES", + ) + } + for k, v in config["OLD_CONFIGURE_SUBSTS"]: + sanitized_config["substs"][k] = sanitize_config(v) + sanitized_config["defines"] = { + k: sanitize_config(v) for k, v in six.iteritems(config["DEFINES"]) + } + for k, v in config["OLD_CONFIGURE_DEFINES"]: + sanitized_config["defines"][k] = sanitize_config(v) + sanitized_config["topsrcdir"] = config["TOPSRCDIR"] + sanitized_config["topobjdir"] = config["TOPOBJDIR"] + sanitized_config["mozconfig"] = config.get("MOZCONFIG") + + if not check_unicode(sanitized_config): + print("Configuration should be all unicode.", file=sys.stderr) + print("Please file a bug for the above.", file=sys.stderr) + sys.exit(1) + + # Some values in sanitized_config also have more complex types, such as + # EnumString, which using when calling config_status would currently + # break the build, as well as making it inconsistent with re-running + # config.status, for which they are normalized to plain strings via + # indented_repr. Likewise for non-dict non-string iterables being + # converted to lists. + def normalize(obj): + if isinstance(obj, dict): + return {k: normalize(v) for k, v in six.iteritems(obj)} + if isinstance(obj, six.text_type): + return six.text_type(obj) + if isinstance(obj, Iterable): + return [normalize(o) for o in obj] + return obj + + sanitized_config = normalize(sanitized_config) + + # Create config.status. Eventually, we'll want to just do the work it does + # here, when we're able to skip configure tests/use cached results/not rely + # on autoconf. + with codecs.open("config.status", "w", "utf-8") as fh: + fh.write( + textwrap.dedent( + """\ + #!%(python)s + # coding=utf-8 + """ + ) + % {"python": config["PYTHON3"]} + ) + for k, v in sorted(six.iteritems(sanitized_config)): + fh.write("%s = " % k) + pprint.pprint(v, stream=fh, indent=4) + fh.write( + "__all__ = ['topobjdir', 'topsrcdir', 'defines', " "'substs', 'mozconfig']" + ) + + if execute: + fh.write( + textwrap.dedent( + """ + if __name__ == '__main__': + from mozbuild.config_status import config_status + args = dict([(name, globals()[name]) for name in __all__]) + config_status(**args) + """ + ) + ) + + partial_config = PartialConfigEnvironment(config["TOPOBJDIR"]) + partial_config.write_vars(sanitized_config) + + # Write out a file so the build backend knows to re-run configure when + # relevant Python changes. + with io.open("config_status_deps.in", "w", encoding="utf-8", newline="\n") as fh: + for f in sorted( + itertools.chain( + config["CONFIG_STATUS_DEPS"], + iter_modules_in_path(config["TOPOBJDIR"], config["TOPSRCDIR"]), + ) + ): + fh.write("%s\n" % mozpath.normpath(f)) + + # Other things than us are going to run this file, so we need to give it + # executable permissions. + os.chmod("config.status", 0o755) + if execute: + from mozbuild.config_status import config_status + + return config_status(args=[], **sanitized_config) + return 0 + + +def _activate_build_virtualenv(): + """Ensure that the build virtualenv is activated + + configure.py may be executed through Mach, or via "./configure, make". + In the first case, the build virtualenv should already be activated. + In the second case, we're likely being executed with the system Python, and must + prepare the virtualenv and activate it ourselves. + """ + + version = ".".join(str(i) for i in sys.version_info[0:3]) + print(f"Using Python {version} from {sys.executable}") + + active_site = MozSiteMetadata.from_runtime() + if active_site and active_site.site_name == "build": + # We're already running within the "build" virtualenv, no additional work is + # needed. + return + + # We're using the system python (or are nested within a non-build mach-managed + # virtualenv), so we should activate the build virtualenv as expected by the rest of + # configure. + + topobjdir = os.path.realpath(".") + topsrcdir = os.path.realpath(os.path.dirname(__file__)) + + mach_site = MachSiteManager( + topsrcdir, + None, + MachEnvRequirements(), + ExternalPythonSite(sys.executable), + SitePackagesSource.NONE, + ) + mach_site.activate() + build_site = CommandSiteManager.from_environment( + topsrcdir, + None, + "build", + os.path.join(topobjdir, "_virtualenvs"), + ) + if not build_site.ensure(): + print("Created Python 3 virtualenv") + build_site.activate() + + +if __name__ == "__main__": + sys.exit(main(sys.argv)) |