Python util.get_state_dir函数代码示例

    def populate_context(context, key=None):
        if key is None:
            return
        if key == 'state_dir':
            state_dir, is_environ = get_state_dir()
            if is_environ:
                if not os.path.exists(state_dir):
                    print('Creating global state directory from environment variable: %s'
                          % state_dir)
                    os.makedirs(state_dir, mode=0o770)
            else:
                if not os.path.exists(state_dir):
                    if not os.environ.get('MOZ_AUTOMATION'):
                        print(STATE_DIR_FIRST_RUN.format(userdir=state_dir))
                        try:
                            sys.stdin.readline()
                        except KeyboardInterrupt:
                            sys.exit(1)

                    print('\nCreating default state directory: %s' % state_dir)
                    os.makedirs(state_dir, mode=0o770)

            return state_dir

        if key == 'topdir':
            return topsrcdir

        if key == 'telemetry_handler':
            return telemetry_handler

        if key == 'post_dispatch_handler':
            return post_dispatch_handler

        raise AttributeError(key)

    def post_dispatch_handler(context, handler, args):
        """Perform global operations after command dispatch.


        For now,  we will use this to handle build system telemetry.
        """
        # Don't do anything when...
        if should_skip_dispatch(context, handler):
            return

        # We call mach environment in client.mk which would cause the
        # data submission below to block the forward progress of make.
        if handler.name in ('environment'):
            return

        # We have not opted-in to telemetry
        if 'BUILD_SYSTEM_TELEMETRY' not in os.environ:
            return

        # Every n-th operation
        if random.randint(1, TELEMETRY_SUBMISSION_FREQUENCY) != 1:
            return

        with open(os.devnull, 'wb') as devnull:
            subprocess.Popen([sys.executable,
                              os.path.join(topsrcdir, 'build',
                                           'submit_telemetry_data.py'),
                              get_state_dir()[0]],
                              stdout=devnull, stderr=devnull)

def fzf_bootstrap(update=False):
    """Bootstrap fzf if necessary and return path to the executable.

    The bootstrap works by cloning the fzf repository and running the included
    `install` script. If update is True, we will pull the repository and re-run
    the install script.
    """
    fzf_bin = find_executable('fzf')
    if fzf_bin and not update:
        return fzf_bin

    fzf_path = os.path.join(get_state_dir()[0], 'fzf')
    if update and not os.path.isdir(fzf_path):
        print("fzf installed somewhere other than {}, please update manually".format(fzf_path))
        sys.exit(1)

    def get_fzf():
        return find_executable('fzf', os.path.join(fzf_path, 'bin'))

    if update:
        ret = run(['git', 'pull'], cwd=fzf_path)
        if ret:
            print("Update fzf failed.")
            sys.exit(1)

        run_fzf_install_script(fzf_path)
        return get_fzf()

    if os.path.isdir(fzf_path):
        fzf_bin = get_fzf()
        if fzf_bin:
            return fzf_bin
        # Fzf is cloned, but binary doesn't exist. Try running the install script
        return fzf_bootstrap(update=True)

    install = raw_input("Could not detect fzf, install it now? [y/n]: ")
    if install.lower() != 'y':
        return

    if not find_executable('git'):
        print("Git not found.")
        print(FZF_INSTALL_FAILED)
        sys.exit(1)

    cmd = ['git', 'clone', '--depth', '1', 'https://github.com/junegunn/fzf.git']
    if subprocess.call(cmd, cwd=os.path.dirname(fzf_path)):
        print(FZF_INSTALL_FAILED)
        sys.exit(1)

    run_fzf_install_script(fzf_path)

    print("Installed fzf to {}".format(fzf_path))
    return get_fzf()

    def telemetry_handler(context, data):
        # We have not opted-in to telemetry
        if "BUILD_SYSTEM_TELEMETRY" not in os.environ:
            return

        telemetry_dir = os.path.join(get_state_dir()[0], "telemetry")
        try:
            os.mkdir(telemetry_dir)
        except OSError as e:
            if e.errno != errno.EEXIST:
                raise
        outgoing_dir = os.path.join(telemetry_dir, "outgoing")
        try:
            os.mkdir(outgoing_dir)
        except OSError as e:
            if e.errno != errno.EEXIST:
                raise

        # Add common metadata to help submit sorted data later on.
        data["argv"] = sys.argv
        data.setdefault("system", {}).update(
            dict(
                architecture=list(platform.architecture()),
                machine=platform.machine(),
                python_version=platform.python_version(),
                release=platform.release(),
                system=platform.system(),
                version=platform.version(),
            )
        )

        if platform.system() == "Linux":
            dist = list(platform.linux_distribution())
            data["system"]["linux_distribution"] = dist
        elif platform.system() == "Windows":
            win32_ver = (list((platform.win32_ver())),)
            data["system"]["win32_ver"] = win32_ver
        elif platform.system() == "Darwin":
            # mac version is a special Cupertino snowflake
            r, v, m = platform.mac_ver()
            data["system"]["mac_ver"] = [r, list(v), m]

        with open(os.path.join(outgoing_dir, str(uuid.uuid4()) + ".json"), "w") as f:
            json.dump(data, f, sort_keys=True)

    def telemetry_handler(context, data):
        # We have not opted-in to telemetry
        if 'BUILD_SYSTEM_TELEMETRY' not in os.environ:
            return

        telemetry_dir = os.path.join(get_state_dir()[0], 'telemetry')
        try:
            os.mkdir(telemetry_dir)
        except OSError as e:
            if e.errno != errno.EEXIST:
                raise
        outgoing_dir = os.path.join(telemetry_dir, 'outgoing')
        try:
            os.mkdir(outgoing_dir)
        except OSError as e:
            if e.errno != errno.EEXIST:
                raise

        # Add common metadata to help submit sorted data later on.
        data['argv'] = sys.argv
        data.setdefault('system', {}).update(dict(
            architecture=list(platform.architecture()),
            machine=platform.machine(),
            python_version=platform.python_version(),
            release=platform.release(),
            system=platform.system(),
            version=platform.version(),
        ))

        if platform.system() == 'Linux':
            dist = list(platform.linux_distribution())
            data['system']['linux_distribution'] = dist
        elif platform.system() == 'Windows':
            win32_ver=list((platform.win32_ver())),
            data['system']['win32_ver'] = win32_ver
        elif platform.system() == 'Darwin':
            # mac version is a special Cupertino snowflake
            r, v, m = platform.mac_ver()
            data['system']['mac_ver'] = [r, list(v), m]

        with open(os.path.join(outgoing_dir, str(uuid.uuid4()) + '.json'),
                  'w') as f:
            json.dump(data, f, sort_keys=True)

    def post_dispatch_handler(context, handler, instance, result,
                              start_time, end_time, args):
        """Perform global operations after command dispatch.


        For now,  we will use this to handle build system telemetry.
        """
        # Don't do anything when...
        if should_skip_dispatch(context, handler):
            return

        # We have not opted-in to telemetry
        if not context.settings.build.telemetry:
            return

        from mozbuild.telemetry import gather_telemetry
        from mozbuild.base import MozbuildObject

        if not isinstance(instance, MozbuildObject):
            instance = MozbuildObject.from_environment()

        try:
            substs = instance.substs
        except Exception:
            substs = {}

        # We gather telemetry for every operation...
        gather_telemetry(command=handler.name, success=(result == 0),
                         start_time=start_time, end_time=end_time,
                         mach_context=context, substs=substs,
                         paths=[instance.topsrcdir, instance.topobjdir])

        # But only submit about every n-th operation
        if random.randint(1, TELEMETRY_SUBMISSION_FREQUENCY) != 1:
            return

        with open(os.devnull, 'wb') as devnull:
            subprocess.Popen([sys.executable,
                              os.path.join(topsrcdir, 'build',
                                           'submit_telemetry_data.py'),
                              get_state_dir()[0]],
                             stdout=devnull, stderr=devnull)

    def telemetry_handler(context, data):
        # We have not opted-in to telemetry
        if not context.settings.build.telemetry:
            return

        telemetry_dir = os.path.join(get_state_dir()[0], 'telemetry')
        try:
            os.mkdir(telemetry_dir)
        except OSError as e:
            if e.errno != errno.EEXIST:
                raise
        outgoing_dir = os.path.join(telemetry_dir, 'outgoing')
        try:
            os.mkdir(outgoing_dir)
        except OSError as e:
            if e.errno != errno.EEXIST:
                raise

        with open(os.path.join(outgoing_dir, str(uuid.uuid4()) + '.json'),
                  'w') as f:
            json.dump(data, f, sort_keys=True)

    def post_dispatch_handler(context, handler, args):
        """Perform global operations after command dispatch.


        For now,  we will use this to handle build system telemetry.
        """
        # Don't do anything when...
        if should_skip_dispatch(context, handler):
            return

        # We have not opted-in to telemetry
        if not context.settings.build.telemetry:
            return

        # Every n-th operation
        if random.randint(1, TELEMETRY_SUBMISSION_FREQUENCY) != 1:
            return

        with open(os.devnull, 'wb') as devnull:
            subprocess.Popen([sys.executable,
                              os.path.join(topsrcdir, 'build',
                                           'submit_telemetry_data.py'),
                              get_state_dir()[0]],
                             stdout=devnull, stderr=devnull)

def generate_tasks(params, full, root):
    params = params or "project=mozilla-central"

    cache_dir = os.path.join(get_state_dir()[0], 'cache', 'taskgraph')
    attr = 'full_task_set' if full else 'target_task_set'
    cache = os.path.join(cache_dir, attr)

    invalidate(cache, root)
    if os.path.isfile(cache):
        with open(cache, 'r') as fh:
            return fh.read().splitlines()

    if not os.path.isdir(cache_dir):
        os.makedirs(cache_dir)

    print("Task configuration changed, generating {}".format(attr.replace('_', ' ')))
    try:
        params = load_parameters_file(params, strict=False)
        params.check()
    except ParameterMismatch as e:
        print(PARAMETER_MISMATCH.format(e.args[0]))
        sys.exit(1)

    taskgraph.fast = True
    cwd = os.getcwd()
    os.chdir(build.topsrcdir)

    root = os.path.join(root, 'taskcluster', 'ci')
    tg = getattr(TaskGraphGenerator(root_dir=root, parameters=params), attr)
    labels = [label for label in tg.graph.visit_postorder()]

    os.chdir(cwd)

    with open(cache, 'w') as fh:
        fh.write('\n'.join(labels))
    return labels

def bootstrap(topsrcdir, mozilla_dir=None):
    if mozilla_dir is None:
        mozilla_dir = topsrcdir

    # Ensure we are running Python 2.7+. We put this check here so we generate a
    # user-friendly error message rather than a cryptic stack trace on module
    # import.
    if sys.version_info[0] != 2 or sys.version_info[1] < 7:
        print('Python 2.7 or above (but not Python 3) is required to run mach.')
        print('You are running Python', platform.python_version())
        sys.exit(1)

    # Global build system and mach state is stored in a central directory. By
    # default, this is ~/.mozbuild. However, it can be defined via an
    # environment variable. We detect first run (by lack of this directory
    # existing) and notify the user that it will be created. The logic for
    # creation is much simpler for the "advanced" environment variable use
    # case. For default behavior, we educate users and give them an opportunity
    # to react. We always exit after creating the directory because users don't
    # like surprises.
    sys.path[0:0] = [os.path.join(mozilla_dir, path)
                     for path in search_path(mozilla_dir,
                                             'build/virtualenv_packages.txt')]
    import mach.base
    import mach.main
    from mozboot.util import get_state_dir

    from mozbuild.util import patch_main
    patch_main()

    def resolve_repository():
        import mozversioncontrol

        try:
            # This API doesn't respect the vcs binary choices from configure.
            # If we ever need to use the VCS binary here, consider something
            # more robust.
            return mozversioncontrol.get_repository_object(path=mozilla_dir)
        except (mozversioncontrol.InvalidRepoPath,
                mozversioncontrol.MissingVCSTool):
            return None

    def telemetry_handler(context, data):
        # We have not opted-in to telemetry
        if not context.settings.build.telemetry:
            return

        telemetry_dir = os.path.join(get_state_dir()[0], 'telemetry')
        try:
            os.mkdir(telemetry_dir)
        except OSError as e:
            if e.errno != errno.EEXIST:
                raise
        outgoing_dir = os.path.join(telemetry_dir, 'outgoing')
        try:
            os.mkdir(outgoing_dir)
        except OSError as e:
            if e.errno != errno.EEXIST:
                raise

        with open(os.path.join(outgoing_dir, str(uuid.uuid4()) + '.json'),
                  'w') as f:
            json.dump(data, f, sort_keys=True)

    def should_skip_dispatch(context, handler):
        # The user is performing a maintenance command.
        if handler.name in ('bootstrap', 'doctor', 'mach-commands', 'vcs-setup',
                            # We call mach environment in client.mk which would cause the
                            # data submission to block the forward progress of make.
                            'environment'):
            return True

        # We are running in automation.
        if 'MOZ_AUTOMATION' in os.environ or 'TASK_ID' in os.environ:
            return True

        # The environment is likely a machine invocation.
        if sys.stdin.closed or not sys.stdin.isatty():
            return True

        return False

    def post_dispatch_handler(context, handler, instance, result,
                              start_time, end_time, args):
        """Perform global operations after command dispatch.


        For now,  we will use this to handle build system telemetry.
        """
        # Don't do anything when...
        if should_skip_dispatch(context, handler):
            return

        # We have not opted-in to telemetry
        if not context.settings.build.telemetry:
            return

        from mozbuild.telemetry import gather_telemetry
        from mozbuild.base import MozbuildObject

#.........这里部分代码省略.........

    def bootstrap(self):
        if self.choice is None:
            # Like ['1. Firefox for Desktop', '2. Firefox for Android Artifact Mode', ...].
            labels = ["%s. %s" % (i + 1, name) for (i, (name, _)) in enumerate(APPLICATIONS_LIST)]
            prompt = APPLICATION_CHOICE % "\n".join(labels)
            prompt_choice = self.instance.prompt_int(prompt=prompt, low=1, high=len(APPLICATIONS))
            name, application = APPLICATIONS_LIST[prompt_choice - 1]
        elif self.choice not in APPLICATIONS.keys():
            raise Exception("Please pick a valid application choice: (%s)" % "/".join(APPLICATIONS.keys()))
        else:
            name, application = APPLICATIONS[self.choice]

        self.instance.install_system_packages()

        # Like 'install_browser_packages' or 'install_mobile_android_packages'.
        getattr(self.instance, "install_%s_packages" % application)()

        hg_installed, hg_modern = self.instance.ensure_mercurial_modern()
        self.instance.ensure_python_modern()

        # The state directory code is largely duplicated from mach_bootstrap.py.
        # We can't easily import mach_bootstrap.py because the bootstrapper may
        # run in self-contained mode and only the files in this directory will
        # be available. We /could/ refactor parts of mach_bootstrap.py to be
        # part of this directory to avoid the code duplication.
        state_dir, _ = get_state_dir()

        if not os.path.exists(state_dir):
            if not self.instance.no_interactive:
                choice = self.instance.prompt_int(prompt=STATE_DIR_INFO.format(statedir=state_dir), low=1, high=2)

                if choice == 1:
                    print("Creating global state directory: %s" % state_dir)
                    os.makedirs(state_dir, mode=0o770)

        state_dir_available = os.path.exists(state_dir)

        # Possibly configure Mercurial if the user wants to.
        # TODO offer to configure Git.
        if hg_installed and state_dir_available:
            configure_hg = False
            if not self.instance.no_interactive:
                choice = self.instance.prompt_int(prompt=CONFIGURE_MERCURIAL, low=1, high=2)
                if choice == 1:
                    configure_hg = True
            else:
                configure_hg = self.hg_configure

            if configure_hg:
                configure_mercurial(self.instance.which("hg"), state_dir)

        # Offer to clone if we're not inside a clone.
        checkout_type = current_firefox_checkout(check_output=self.instance.check_output, hg=self.instance.which("hg"))
        have_clone = False

        if checkout_type:
            have_clone = True
        elif hg_installed and not self.instance.no_interactive:
            dest = raw_input(CLONE_MERCURIAL)
            dest = dest.strip()
            if dest:
                dest = os.path.expanduser(dest)
                have_clone = clone_firefox(self.instance.which("hg"), dest)

        if not have_clone:
            print(SOURCE_ADVERTISE)

        print(self.finished % name)

        # Like 'suggest_browser_mozconfig' or 'suggest_mobile_android_mozconfig'.
        getattr(self.instance, "suggest_%s_mozconfig" % application)()

def bootstrap(topsrcdir, mozilla_dir=None):
    if mozilla_dir is None:
        mozilla_dir = topsrcdir

    # Ensure we are running Python 2.7+. We put this check here so we generate a
    # user-friendly error message rather than a cryptic stack trace on module
    # import.
    if sys.version_info[0] != 2 or sys.version_info[1] < 7:
        print('Python 2.7 or above (but not Python 3) is required to run mach.')
        print('You are running Python', platform.python_version())
        sys.exit(1)

    # Global build system and mach state is stored in a central directory. By
    # default, this is ~/.mozbuild. However, it can be defined via an
    # environment variable. We detect first run (by lack of this directory
    # existing) and notify the user that it will be created. The logic for
    # creation is much simpler for the "advanced" environment variable use
    # case. For default behavior, we educate users and give them an opportunity
    # to react. We always exit after creating the directory because users don't
    # like surprises.
    sys.path[0:0] = [os.path.join(mozilla_dir, path)
                     for path in search_path(mozilla_dir,
                                             'build/virtualenv_packages.txt')]
    import mach.main
    from mozboot.util import get_state_dir

    from mozbuild.util import patch_main
    patch_main()

    def telemetry_handler(context, data):
        # We have not opted-in to telemetry
        if 'BUILD_SYSTEM_TELEMETRY' not in os.environ:
            return

        telemetry_dir = os.path.join(get_state_dir()[0], 'telemetry')
        try:
            os.mkdir(telemetry_dir)
        except OSError as e:
            if e.errno != errno.EEXIST:
                raise
        outgoing_dir = os.path.join(telemetry_dir, 'outgoing')
        try:
            os.mkdir(outgoing_dir)
        except OSError as e:
            if e.errno != errno.EEXIST:
                raise

        # Add common metadata to help submit sorted data later on.
        data['argv'] = sys.argv
        data.setdefault('system', {}).update(dict(
            architecture=list(platform.architecture()),
            machine=platform.machine(),
            python_version=platform.python_version(),
            release=platform.release(),
            system=platform.system(),
            version=platform.version(),
        ))

        if platform.system() == 'Linux':
            dist = list(platform.linux_distribution())
            data['system']['linux_distribution'] = dist
        elif platform.system() == 'Windows':
            win32_ver=list((platform.win32_ver())),
            data['system']['win32_ver'] = win32_ver
        elif platform.system() == 'Darwin':
            # mac version is a special Cupertino snowflake
            r, v, m = platform.mac_ver()
            data['system']['mac_ver'] = [r, list(v), m]

        with open(os.path.join(outgoing_dir, str(uuid.uuid4()) + '.json'),
                  'w') as f:
            json.dump(data, f, sort_keys=True)

    def should_skip_dispatch(context, handler):
        # The user is performing a maintenance command.
        if handler.name in ('bootstrap', 'doctor', 'mach-commands', 'mercurial-setup'):
            return True

        # We are running in automation.
        if 'MOZ_AUTOMATION' in os.environ or 'TASK_ID' in os.environ:
            return True

        # The environment is likely a machine invocation.
        if sys.stdin.closed or not sys.stdin.isatty():
            return True

        return False

    def post_dispatch_handler(context, handler, args):
        """Perform global operations after command dispatch.


        For now,  we will use this to handle build system telemetry.
        """
        # Don't do anything when...
        if should_skip_dispatch(context, handler):
            return

        # We call mach environment in client.mk which would cause the
        # data submission below to block the forward progress of make.
#.........这里部分代码省略.........

    def post_dispatch_handler(context, handler, instance, result,
                              start_time, end_time, depth, args):
        """Perform global operations after command dispatch.


        For now,  we will use this to handle build system telemetry.
        """
        # Don't write telemetry data if this mach command was invoked as part of another
        # mach command.
        if depth != 1 or os.environ.get('MACH_MAIN_PID') != str(os.getpid()):
            return

        # Don't write telemetry data for 'mach' when 'DISABLE_TELEMETRY' is set.
        if os.environ.get('DISABLE_TELEMETRY') == '1':
            return

        # We have not opted-in to telemetry
        if not context.settings.build.telemetry:
            return

        from mozbuild.telemetry import gather_telemetry
        from mozbuild.base import MozbuildObject
        import mozpack.path as mozpath

        if not isinstance(instance, MozbuildObject):
            instance = MozbuildObject.from_environment()

        try:
            substs = instance.substs
        except Exception:
            substs = {}

        # We gather telemetry for every operation.
        paths = {
            instance.topsrcdir: '$topsrcdir/',
            instance.topobjdir: '$topobjdir/',
            mozpath.normpath(os.path.expanduser('~')): '$HOME/',
        }
        # This might override one of the existing entries, that's OK.
        # We don't use a sigil here because we treat all arguments as potentially relative
        # paths, so we'd like to get them back as they were specified.
        paths[mozpath.normpath(os.getcwd())] = ''
        data = gather_telemetry(command=handler.name, success=(result == 0),
                                start_time=start_time, end_time=end_time,
                                mach_context=context, substs=substs,
                                paths=paths)
        if data:
            telemetry_dir = os.path.join(get_state_dir(), 'telemetry')
            try:
                os.mkdir(telemetry_dir)
            except OSError as e:
                if e.errno != errno.EEXIST:
                    raise
            outgoing_dir = os.path.join(telemetry_dir, 'outgoing')
            try:
                os.mkdir(outgoing_dir)
            except OSError as e:
                if e.errno != errno.EEXIST:
                    raise

            with open(os.path.join(outgoing_dir, str(uuid.uuid4()) + '.json'),
                      'w') as f:
                json.dump(data, f, sort_keys=True)

        if should_skip_telemetry_submission(handler):
            return True

        state_dir = get_state_dir()

        machpath = os.path.join(instance.topsrcdir, 'mach')
        with open(os.devnull, 'wb') as devnull:
            subprocess.Popen([sys.executable, machpath, 'python',
                              '--no-virtualenv',
                              os.path.join(topsrcdir, 'build',
                                           'submit_telemetry_data.py'),
                              state_dir],
                             stdout=devnull, stderr=devnull)

def bootstrap(topsrcdir, mozilla_dir=None):
    if mozilla_dir is None:
        mozilla_dir = topsrcdir

    # Ensure we are running Python 2.7+. We put this check here so we generate a
    # user-friendly error message rather than a cryptic stack trace on module
    # import.
    if sys.version_info[0] != 2 or sys.version_info[1] < 7:
        print('Python 2.7 or above (but not Python 3) is required to run mach.')
        print('You are running Python', platform.python_version())
        sys.exit(1)

    # Global build system and mach state is stored in a central directory. By
    # default, this is ~/.mozbuild. However, it can be defined via an
    # environment variable. We detect first run (by lack of this directory
    # existing) and notify the user that it will be created. The logic for
    # creation is much simpler for the "advanced" environment variable use
    # case. For default behavior, we educate users and give them an opportunity
    # to react. We always exit after creating the directory because users don't
    # like surprises.
    sys.path[0:0] = [os.path.join(mozilla_dir, path)
                     for path in search_path(mozilla_dir,
                                             'build/virtualenv_packages.txt')]
    import mach.base
    import mach.main
    from mozboot.util import get_state_dir

    from mozbuild.util import patch_main
    patch_main()

    def resolve_repository():
        import mozversioncontrol

        try:
            # This API doesn't respect the vcs binary choices from configure.
            # If we ever need to use the VCS binary here, consider something
            # more robust.
            return mozversioncontrol.get_repository_object(path=mozilla_dir)
        except (mozversioncontrol.InvalidRepoPath,
                mozversioncontrol.MissingVCSTool):
            return None

    def should_skip_telemetry_submission(handler):
        # The user is performing a maintenance command.
        if handler.name in ('bootstrap', 'doctor', 'mach-commands', 'vcs-setup',
                            # We call mach environment in client.mk which would cause the
                            # data submission to block the forward progress of make.
                            'environment'):
            return True

        # Never submit data when running in automation or when running tests.
        if any(e in os.environ for e in ('MOZ_AUTOMATION', 'TASK_ID', 'MACH_TELEMETRY_NO_SUBMIT')):
            return True

        return False

    def post_dispatch_handler(context, handler, instance, result,
                              start_time, end_time, depth, args):
        """Perform global operations after command dispatch.


        For now,  we will use this to handle build system telemetry.
        """
        # Don't write telemetry data if this mach command was invoked as part of another
        # mach command.
        if depth != 1 or os.environ.get('MACH_MAIN_PID') != str(os.getpid()):
            return

        # Don't write telemetry data for 'mach' when 'DISABLE_TELEMETRY' is set.
        if os.environ.get('DISABLE_TELEMETRY') == '1':
            return

        # We have not opted-in to telemetry
        if not context.settings.build.telemetry:
            return

        from mozbuild.telemetry import gather_telemetry
        from mozbuild.base import MozbuildObject
        import mozpack.path as mozpath

        if not isinstance(instance, MozbuildObject):
            instance = MozbuildObject.from_environment()

        try:
            substs = instance.substs
        except Exception:
            substs = {}

        # We gather telemetry for every operation.
        paths = {
            instance.topsrcdir: '$topsrcdir/',
            instance.topobjdir: '$topobjdir/',
            mozpath.normpath(os.path.expanduser('~')): '$HOME/',
        }
        # This might override one of the existing entries, that's OK.
        # We don't use a sigil here because we treat all arguments as potentially relative
        # paths, so we'd like to get them back as they were specified.
        paths[mozpath.normpath(os.getcwd())] = ''
        data = gather_telemetry(command=handler.name, success=(result == 0),
                                start_time=start_time, end_time=end_time,
#.........这里部分代码省略.........

    def bootstrap(self):
        if self.choice is None:
            # Like ['1. Firefox for Desktop', '2. Firefox for Android Artifact Mode', ...].
            labels = ['%s. %s' % (i + 1, name) for (i, (name, _)) in enumerate(APPLICATIONS_LIST)]
            prompt = APPLICATION_CHOICE % '\n'.join(labels)
            prompt_choice = self.instance.prompt_int(prompt=prompt, low=1, high=len(APPLICATIONS))
            name, application = APPLICATIONS_LIST[prompt_choice-1]
        elif self.choice not in APPLICATIONS.keys():
            raise Exception('Please pick a valid application choice: (%s)' % '/'.join(APPLICATIONS.keys()))
        else:
            name, application = APPLICATIONS[self.choice]

        self.instance.install_system_packages()

        # Like 'install_browser_packages' or 'install_mobile_android_packages'.
        getattr(self.instance, 'install_%s_packages' % application)()

        hg_installed, hg_modern = self.instance.ensure_mercurial_modern()
        self.instance.ensure_python_modern()
        self.instance.ensure_rust_modern()

        # The state directory code is largely duplicated from mach_bootstrap.py.
        # We can't easily import mach_bootstrap.py because the bootstrapper may
        # run in self-contained mode and only the files in this directory will
        # be available. We /could/ refactor parts of mach_bootstrap.py to be
        # part of this directory to avoid the code duplication.
        state_dir, _ = get_state_dir()

        if not os.path.exists(state_dir):
            if not self.instance.no_interactive:
                choice = self.instance.prompt_int(
                    prompt=STATE_DIR_INFO.format(statedir=state_dir),
                    low=1,
                    high=2)

                if choice == 1:
                    print('Creating global state directory: %s' % state_dir)
                    os.makedirs(state_dir, mode=0o770)

        state_dir_available = os.path.exists(state_dir)

        # Install the clang packages needed for developing stylo.
        if not self.instance.no_interactive:
            choice = self.instance.prompt_int(
                prompt=STYLO_DEVELOPMENT_INFO,
                low=1,
                high=2)

            # The best place to install our packages is in the state directory
            # we have.  If the user doesn't have one, we need them to re-run
            # bootstrap and create the directory.
            #
            # XXX Android bootstrap just assumes the existence of the state
            # directory and writes the NDK into it.  Should we do the same?
            if choice == 1:
                if not state_dir_available:
                    print(STYLO_DIRECTORY_MESSAGE.format(statedir=state_dir))
                    sys.exit(1)

                self.instance.stylo = True
                self.instance.state_dir = state_dir
                self.instance.ensure_stylo_packages(state_dir)

        checkout_type = current_firefox_checkout(check_output=self.instance.check_output,
                                                 hg=self.instance.which('hg'))

        # Possibly configure Mercurial, but not if the current checkout is Git.
        # TODO offer to configure Git.
        if hg_installed and state_dir_available and checkout_type != 'git':
            configure_hg = False
            if not self.instance.no_interactive:
                choice = self.instance.prompt_int(prompt=CONFIGURE_MERCURIAL,
                                                  low=1, high=2)
                if choice == 1:
                    configure_hg = True
            else:
                configure_hg = self.hg_configure

            if configure_hg:
                configure_mercurial(self.instance.which('hg'), state_dir)

        # Offer to clone if we're not inside a clone.
        have_clone = False

        if checkout_type:
            have_clone = True
        elif hg_installed and not self.instance.no_interactive:
            dest = raw_input(CLONE_MERCURIAL)
            dest = dest.strip()
            if dest:
                dest = os.path.expanduser(dest)
                have_clone = clone_firefox(self.instance.which('hg'), dest)

        if not have_clone:
            print(SOURCE_ADVERTISE)

        print(self.finished % name)
        if not (self.instance.which('rustc') and self.instance._parse_version('rustc') >= MODERN_RUST_VERSION):
            print("To build %s, please restart the shell (Start a new terminal window)" % name)

#.........这里部分代码省略.........