The Tor Browser / file revision

 # 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/.

 from __future__ import print_function, unicode_literals

 import os

 import re

 import subprocess

 import sys

 from distutils.version import StrictVersion

 NO_MERCURIAL = '''

 Could not find Mercurial (hg) in the current shell's path. Try starting a new

 shell and running the bootstrapper again.

 '''

 MERCURIAL_UNABLE_UPGRADE = '''

 You are currently running Mercurial %s. Running %s or newer is

 recommended for performance and stability reasons.

 Unfortunately, this bootstrapper currently does not know how to automatically

 upgrade Mercurial on your machine.

 You can usually install Mercurial through your package manager or by

 downloading a package from http://mercurial.selenic.com/.

 '''

 MERCURIAL_UPGRADE_FAILED = '''

 We attempted to upgrade Mercurial to a modern version (%s or newer).

 However, you appear to have version %s still.

 It's possible your package manager doesn't support a modern version of

 Mercurial. It's also possible Mercurial is not being installed in the search

 path for this shell. Try creating a new shell and run this bootstrapper again.

 If it continues to fail, consider installing Mercurial by following the

 instructions at http://mercurial.selenic.com/.

 '''

 PYTHON_UNABLE_UPGRADE = '''

 You are currently running Python %s. Running %s or newer (but

 not 3.x) is required.

 Unfortunately, this bootstrapper does not currently know how to automatically

 upgrade Python on your machine.

 Please search the Internet for how to upgrade your Python and try running this

 bootstrapper again to ensure your machine is up to date.

 '''

 PYTHON_UPGRADE_FAILED = '''

 We attempted to upgrade Python to a modern version (%s or newer).

 However, you appear to still have version %s.

 It's possible your package manager doesn't yet expose a modern version of

 Python. It's also possible Python is not being installed in the search path for

 this shell. Try creating a new shell and run this bootstrapper again.

 If this continues to fail and you are sure you have a modern Python on your

 system, ensure it is on the $PATH and try again. If that fails, you'll need to

 install Python manually and ensure the path with the python binary is listed in

 the $PATH environment variable.

 We recommend the following tools for installing Python:

     pyenv   -- https://github.com/yyuu/pyenv)

     pythonz -- https://github.com/saghul/pythonz

     official installers -- http://www.python.org/

 '''

 # Upgrade Mercurial older than this.

 MODERN_MERCURIAL_VERSION = StrictVersion('2.5')

 # Upgrade Python older than this.

 MODERN_PYTHON_VERSION = StrictVersion('2.7.3')

 class BaseBootstrapper(object):

     """Base class for system bootstrappers."""

     def __init__(self):

         self.package_manager_updated = False

     def install_system_packages(self):

         raise NotImplemented('%s must implement install_system_packages()' %

             __name__)

     def which(self, name):

         """Python implementation of which.

         It returns the path of an executable or None if it couldn't be found.

         """

         for path in os.environ['PATH'].split(os.pathsep):

             test = os.path.join(path, name)

             if os.path.exists(test) and os.access(test, os.X_OK):

                 return test

         return None

     def run_as_root(self, command):

         if os.geteuid() != 0:

             if self.which('sudo'):

                 command.insert(0, 'sudo')

             else:

                 command = ['su', 'root', '-c', ' '.join(command)]

         print('Executing as root:', subprocess.list2cmdline(command))

         subprocess.check_call(command, stdin=sys.stdin)

     def yum_install(self, *packages):

         command = ['yum', 'install']

         command.extend(packages)

         self.run_as_root(command)

     def yum_groupinstall(self, *packages):

         command = ['yum', 'groupinstall']

         command.extend(packages)

         self.run_as_root(command)

     def yum_update(self, *packages):

         command = ['yum', 'update']

         command.extend(packages)

         self.run_as_root(command)

     def apt_install(self, *packages):

         command = ['apt-get', 'install']

         command.extend(packages)

         self.run_as_root(command)

     def apt_update(self):

         command = ['apt-get', 'update']

         self.run_as_root(command)

     def apt_add_architecture(self, arch):

         command = ['dpkg', '--add-architecture']

         command.extend(arch)

         self.run_as_root(command)

     def check_output(self, *args, **kwargs):

         """Run subprocess.check_output even if Python doesn't provide it."""

         fn = getattr(subprocess, 'check_output', BaseBootstrapper._check_output)

         return fn(*args, **kwargs)

     @staticmethod

     def _check_output(*args, **kwargs):

         """Python 2.6 compatible implementation of subprocess.check_output."""

         proc = subprocess.Popen(stdout=subprocess.PIPE, *args, **kwargs)

         output, unused_err = proc.communicate()

         retcode = proc.poll()

         if retcode:

             cmd = kwargs.get('args', args[0])

             e = subprocess.CalledProcessError(retcode, cmd)

             e.output = output

             raise e

         return output

     def prompt_int(self, prompt, low, high, limit=5):

         ''' Prompts the user with prompt and requires an integer between low and high. '''

         valid = False

         while not valid and limit > 0:

             try:

                 choice = int(raw_input(prompt))

                 if not low <= choice <= high:

                     print("ERROR! Please enter a valid option!")

                     limit -= 1

                 else:

                     valid = True

             except ValueError:

                 print("ERROR! Please enter a valid option!")

                 limit -= 1

         if limit > 0:

             return choice

         else:

             raise Exception("Error! Reached max attempts of entering option.")

     def _ensure_package_manager_updated(self):

         if self.package_manager_updated:

             return

         self._update_package_manager()

         self.package_manager_updated = True

     def _update_package_manager(self):

         """Updates the package manager's manifests/package list.

         This should be defined in child classes.

         """

     def _hgplain_env(self):

         """ Returns a copy of the current environment updated with the HGPLAIN

         environment variable.

         HGPLAIN prevents Mercurial from applying locale variations to the output

         making it suitable for use in scripts.

         """

         env = os.environ.copy()

         env['HGPLAIN'] = '1'

         return env

     def is_mercurial_modern(self):

         hg = self.which('hg')

         if not hg:

             print(NO_MERCURIAL)

             return False, False, None

         info = self.check_output([hg, '--version'], env=self._hgplain_env()).splitlines()[0]

         match = re.search('version ([^\+\)]+)', info)

         if not match:

             print('ERROR: Unable to identify Mercurial version.')

             return True, False, None

         our = StrictVersion(match.group(1))

         return True, our >= MODERN_MERCURIAL_VERSION, our

     def ensure_mercurial_modern(self):

         installed, modern, version = self.is_mercurial_modern()

         if not installed or modern:

             print('Your version of Mercurial (%s) is sufficiently modern.' %

                 version)

             return

         self._ensure_package_manager_updated()

         self.upgrade_mercurial(version)

         installed, modern, after = self.is_mercurial_modern()

         if installed and not modern:

             print(MERCURIAL_UPGRADE_FAILED % (MODERN_MERCURIAL_VERSION, after))

     def upgrade_mercurial(self, current):

         """Upgrade Mercurial.

         Child classes should reimplement this.

         """

         print(MERCURIAL_UNABLE_UPGRADE % (current, MODERN_MERCURIAL_VERSION))

     def is_python_modern(self):

         python = None

         for test in ['python2.7', 'python']:

             python = self.which(test)

             if python:

                 break

         assert python

         info = self.check_output([python, '--version'],

             stderr=subprocess.STDOUT)

         match = re.search('Python ([a-z0-9\.]+)', info)

         if not match:

             print('ERROR Unable to identify Python version.')

             return False, None

         our = StrictVersion(match.group(1))

         return our >= MODERN_PYTHON_VERSION, our

     def ensure_python_modern(self):

         modern, version = self.is_python_modern()

         if modern:

             print('Your version of Python (%s) is new enough.' % version)

             return

         print('Your version of Python (%s) is too old. Will try to upgrade.' %

             version)

         self._ensure_package_manager_updated()

         self.upgrade_python(version)

         modern, after = self.is_python_modern()

         if not modern:

             print(PYTHON_UPGRADE_FAILED % (MODERN_PYTHON_VERSION, after))

             sys.exit(1)

     def upgrade_python(self, current):

         """Upgrade Python.

         Child classes should reimplement this.

         """

         print(PYTHON_UNABLE_UPGRADE % (current, MODERN_PYTHON_VERSION))