1 #!python

     2 """Bootstrap distribute installation

     3 

     4 If you want to use setuptools in your package's setup.py, just include this

     5 file in the same directory with it, and add this to the top of your setup.py::

     6 

     7     from distribute_setup import use_setuptools

     8     use_setuptools()

     9 

    10 If you want to require a specific version of setuptools, set a download

    11 mirror, or use an alternate download directory, you can do so by supplying

    12 the appropriate options to ``use_setuptools()``.

    13 

    14 This file can also be run as a script to install or upgrade setuptools.

    15 """

    16 import os

    17 import sys

    18 import time

    19 import fnmatch

    20 import tempfile

    21 import tarfile

    22 from distutils import log

    23 

    24 try:

    25     from site import USER_SITE

    26 except ImportError:

    27     USER_SITE = None

    28 

    29 try:

    30     import subprocess

    31 

    32     def _python_cmd(*args):

    33         args = (sys.executable,) + args

    34         return subprocess.call(args) == 0

    35 

    36 except ImportError:

    37     # will be used for python 2.3

    38     def _python_cmd(*args):

    39         args = (sys.executable,) + args

    40         # quoting arguments if windows

    41         if sys.platform == 'win32':

    42             def quote(arg):

    43                 if ' ' in arg:

    44                     return '"%s"' % arg

    45                 return arg

    46             args = [quote(arg) for arg in args]

    47         return os.spawnl(os.P_WAIT, sys.executable, *args) == 0

    48 

    49 DEFAULT_VERSION = "0.6.21"

    50 DEFAULT_URL = "http://pypi.python.org/packages/source/d/distribute/"

    51 SETUPTOOLS_FAKED_VERSION = "0.6c11"

    52 

    53 SETUPTOOLS_PKG_INFO = """\

    54 Metadata-Version: 1.0

    55 Name: setuptools

    56 Version: %s

    57 Summary: xxxx

    58 Home-page: xxx

    59 Author: xxx

    60 Author-email: xxx

    61 License: xxx

    62 Description: xxx

    63 """ % SETUPTOOLS_FAKED_VERSION

    64 

    65 

    66 def _install(tarball):

    67     # extracting the tarball

    68     tmpdir = tempfile.mkdtemp()

    69     log.warn('Extracting in %s', tmpdir)

    70     old_wd = os.getcwd()

    71     try:

    72         os.chdir(tmpdir)

    73         tar = tarfile.open(tarball)

    74         _extractall(tar)

    75         tar.close()

    76 

    77         # going in the directory

    78         subdir = os.path.join(tmpdir, os.listdir(tmpdir)[0])

    79         os.chdir(subdir)

    80         log.warn('Now working in %s', subdir)

    81 

    82         # installing

    83         log.warn('Installing Distribute')

    84         if not _python_cmd('setup.py', 'install'):

    85             log.warn('Something went wrong during the installation.')

    86             log.warn('See the error message above.')

    87     finally:

    88         os.chdir(old_wd)

    89 

    90 

    91 def _build_egg(egg, tarball, to_dir):

    92     # extracting the tarball

    93     tmpdir = tempfile.mkdtemp()

    94     log.warn('Extracting in %s', tmpdir)

    95     old_wd = os.getcwd()

    96     try:

    97         os.chdir(tmpdir)

    98         tar = tarfile.open(tarball)

    99         _extractall(tar)

   100         tar.close()

   101 

   102         # going in the directory

   103         subdir = os.path.join(tmpdir, os.listdir(tmpdir)[0])

   104         os.chdir(subdir)

   105         log.warn('Now working in %s', subdir)

   106 

   107         # building an egg

   108         log.warn('Building a Distribute egg in %s', to_dir)

   109         _python_cmd('setup.py', '-q', 'bdist_egg', '--dist-dir', to_dir)

   110 

   111     finally:

   112         os.chdir(old_wd)

   113     # returning the result

   114     log.warn(egg)

   115     if not os.path.exists(egg):

   116         raise IOError('Could not build the egg.')

   117 

   118 

   119 def _do_download(version, download_base, to_dir, download_delay):

   120     egg = os.path.join(to_dir, 'distribute-%s-py%d.%d.egg'

   121                        % (version, sys.version_info[0], sys.version_info[1]))

   122     if not os.path.exists(egg):

   123         tarball = download_setuptools(version, download_base,

   124                                       to_dir, download_delay)

   125         _build_egg(egg, tarball, to_dir)

   126     sys.path.insert(0, egg)

   127     import setuptools

   128     setuptools.bootstrap_install_from = egg

   129 

   130 

   131 def use_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,

   132                    to_dir=os.curdir, download_delay=15, no_fake=True):

   133     # making sure we use the absolute path

   134     to_dir = os.path.abspath(to_dir)

   135     was_imported = 'pkg_resources' in sys.modules or \

   136         'setuptools' in sys.modules

   137     try:

   138         try:

   139             import pkg_resources

   140             if not hasattr(pkg_resources, '_distribute'):

   141                 if not no_fake:

   142                     _fake_setuptools()

   143                 raise ImportError

   144         except ImportError:

   145             return _do_download(version, download_base, to_dir, download_delay)

   146         try:

   147             pkg_resources.require("distribute>="+version)

   148             return

   149         except pkg_resources.VersionConflict:

   150             e = sys.exc_info()[1]

   151             if was_imported:

   152                 sys.stderr.write(

   153                 "The required version of distribute (>=%s) is not available,\n"

   154                 "and can't be installed while this script is running. Please\n"

   155                 "install a more recent version first, using\n"

   156                 "'easy_install -U distribute'."

   157                 "\n\n(Currently using %r)\n" % (version, e.args[0]))

   158                 sys.exit(2)

   159             else:

   160                 del pkg_resources, sys.modules['pkg_resources']    # reload ok

   161                 return _do_download(version, download_base, to_dir,

   162                                     download_delay)

   163         except pkg_resources.DistributionNotFound:

   164             return _do_download(version, download_base, to_dir,

   165                                 download_delay)

   166     finally:

   167         if not no_fake:

   168             _create_fake_setuptools_pkg_info(to_dir)

   169 

   170 def download_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,

   171                         to_dir=os.curdir, delay=15):

   172     """Download distribute from a specified location and return its filename

   173 

   174     `version` should be a valid distribute version number that is available

   175     as an egg for download under the `download_base` URL (which should end

   176     with a '/'). `to_dir` is the directory where the egg will be downloaded.

   177     `delay` is the number of seconds to pause before an actual download

   178     attempt.

   179     """

   180     # making sure we use the absolute path

   181     to_dir = os.path.abspath(to_dir)

   182     try:

   183         from urllib.request import urlopen

   184     except ImportError:

   185         from urllib2 import urlopen

   186     tgz_name = "distribute-%s.tar.gz" % version

   187     url = download_base + tgz_name

   188     saveto = os.path.join(to_dir, tgz_name)

   189     src = dst = None

   190     if not os.path.exists(saveto):  # Avoid repeated downloads

   191         try:

   192             log.warn("Downloading %s", url)

   193             src = urlopen(url)

   194             # Read/write all in one block, so we don't create a corrupt file

   195             # if the download is interrupted.

   196             data = src.read()

   197             dst = open(saveto, "wb")

   198             dst.write(data)

   199         finally:

   200             if src:

   201                 src.close()

   202             if dst:

   203                 dst.close()

   204     return os.path.realpath(saveto)

   205 

   206 def _no_sandbox(function):

   207     def __no_sandbox(*args, **kw):

   208         try:

   209             from setuptools.sandbox import DirectorySandbox

   210             if not hasattr(DirectorySandbox, '_old'):

   211                 def violation(*args):

   212                     pass

   213                 DirectorySandbox._old = DirectorySandbox._violation

   214                 DirectorySandbox._violation = violation

   215                 patched = True

   216             else:

   217                 patched = False

   218         except ImportError:

   219             patched = False

   220 

   221         try:

   222             return function(*args, **kw)

   223         finally:

   224             if patched:

   225                 DirectorySandbox._violation = DirectorySandbox._old

   226                 del DirectorySandbox._old

   227 

   228     return __no_sandbox

   229 

   230 def _patch_file(path, content):

   231     """Will backup the file then patch it"""

   232     existing_content = open(path).read()

   233     if existing_content == content:

   234         # already patched

   235         log.warn('Already patched.')

   236         return False

   237     log.warn('Patching...')

   238     _rename_path(path)

   239     f = open(path, 'w')

   240     try:

   241         f.write(content)

   242     finally:

   243         f.close()

   244     return True

   245 

   246 _patch_file = _no_sandbox(_patch_file)

   247 

   248 def _same_content(path, content):

   249     return open(path).read() == content

   250 

   251 def _rename_path(path):

   252     new_name = path + '.OLD.%s' % time.time()

   253     log.warn('Renaming %s into %s', path, new_name)

   254     os.rename(path, new_name)

   255     return new_name

   256 

   257 def _remove_flat_installation(placeholder):

   258     if not os.path.isdir(placeholder):

   259         log.warn('Unkown installation at %s', placeholder)

   260         return False

   261     found = False

   262     for file in os.listdir(placeholder):

   263         if fnmatch.fnmatch(file, 'setuptools*.egg-info'):

   264             found = True

   265             break

   266     if not found:

   267         log.warn('Could not locate setuptools*.egg-info')

   268         return

   269 

   270     log.warn('Removing elements out of the way...')

   271     pkg_info = os.path.join(placeholder, file)

   272     if os.path.isdir(pkg_info):

   273         patched = _patch_egg_dir(pkg_info)

   274     else:

   275         patched = _patch_file(pkg_info, SETUPTOOLS_PKG_INFO)

   276 

   277     if not patched:

   278         log.warn('%s already patched.', pkg_info)

   279         return False

   280     # now let's move the files out of the way

   281     for element in ('setuptools', 'pkg_resources.py', 'site.py'):

   282         element = os.path.join(placeholder, element)

   283         if os.path.exists(element):

   284             _rename_path(element)

   285         else:

   286             log.warn('Could not find the %s element of the '

   287                      'Setuptools distribution', element)

   288     return True

   289 

   290 _remove_flat_installation = _no_sandbox(_remove_flat_installation)

   291 

   292 def _after_install(dist):

   293     log.warn('After install bootstrap.')

   294     placeholder = dist.get_command_obj('install').install_purelib

   295     _create_fake_setuptools_pkg_info(placeholder)

   296 

   297 def _create_fake_setuptools_pkg_info(placeholder):

   298     if not placeholder or not os.path.exists(placeholder):

   299         log.warn('Could not find the install location')

   300         return

   301     pyver = '%s.%s' % (sys.version_info[0], sys.version_info[1])

   302     setuptools_file = 'setuptools-%s-py%s.egg-info' % \

   303             (SETUPTOOLS_FAKED_VERSION, pyver)

   304     pkg_info = os.path.join(placeholder, setuptools_file)

   305     if os.path.exists(pkg_info):

   306         log.warn('%s already exists', pkg_info)

   307         return

   308 

   309     log.warn('Creating %s', pkg_info)

   310     f = open(pkg_info, 'w')

   311     try:

   312         f.write(SETUPTOOLS_PKG_INFO)

   313     finally:

   314         f.close()

   315 

   316     pth_file = os.path.join(placeholder, 'setuptools.pth')

   317     log.warn('Creating %s', pth_file)

   318     f = open(pth_file, 'w')

   319     try:

   320         f.write(os.path.join(os.curdir, setuptools_file))

   321     finally:

   322         f.close()

   323 

   324 _create_fake_setuptools_pkg_info = _no_sandbox(_create_fake_setuptools_pkg_info)

   325 

   326 def _patch_egg_dir(path):

   327     # let's check if it's already patched

   328     pkg_info = os.path.join(path, 'EGG-INFO', 'PKG-INFO')

   329     if os.path.exists(pkg_info):

   330         if _same_content(pkg_info, SETUPTOOLS_PKG_INFO):

   331             log.warn('%s already patched.', pkg_info)

   332             return False

   333     _rename_path(path)

   334     os.mkdir(path)

   335     os.mkdir(os.path.join(path, 'EGG-INFO'))

   336     pkg_info = os.path.join(path, 'EGG-INFO', 'PKG-INFO')

   337     f = open(pkg_info, 'w')

   338     try:

   339         f.write(SETUPTOOLS_PKG_INFO)

   340     finally:

   341         f.close()

   342     return True

   343 

   344 _patch_egg_dir = _no_sandbox(_patch_egg_dir)

   345 

   346 def _before_install():

   347     log.warn('Before install bootstrap.')

   348     _fake_setuptools()

   349 

   350 

   351 def _under_prefix(location):

   352     if 'install' not in sys.argv:

   353         return True

   354     args = sys.argv[sys.argv.index('install')+1:]

   355     for index, arg in enumerate(args):

   356         for option in ('--root', '--prefix'):

   357             if arg.startswith('%s=' % option):

   358                 top_dir = arg.split('root=')[-1]

   359                 return location.startswith(top_dir)

   360             elif arg == option:

   361                 if len(args) > index:

   362                     top_dir = args[index+1]

   363                     return location.startswith(top_dir)

   364         if arg == '--user' and USER_SITE is not None:

   365             return location.startswith(USER_SITE)

   366     return True

   367 

   368 

   369 def _fake_setuptools():

   370     log.warn('Scanning installed packages')

   371     try:

   372         import pkg_resources

   373     except ImportError:

   374         # we're cool

   375         log.warn('Setuptools or Distribute does not seem to be installed.')

   376         return

   377     ws = pkg_resources.working_set

   378     try:

   379         setuptools_dist = ws.find(pkg_resources.Requirement.parse('setuptools',

   380                                   replacement=False))

   381     except TypeError:

   382         # old distribute API

   383         setuptools_dist = ws.find(pkg_resources.Requirement.parse('setuptools'))

   384 

   385     if setuptools_dist is None:

   386         log.warn('No setuptools distribution found')

   387         return

   388     # detecting if it was already faked

   389     setuptools_location = setuptools_dist.location

   390     log.warn('Setuptools installation detected at %s', setuptools_location)

   391 

   392     # if --root or --preix was provided, and if

   393     # setuptools is not located in them, we don't patch it

   394     if not _under_prefix(setuptools_location):

   395         log.warn('Not patching, --root or --prefix is installing Distribute'

   396                  ' in another location')

   397         return

   398 

   399     # let's see if its an egg

   400     if not setuptools_location.endswith('.egg'):

   401         log.warn('Non-egg installation')

   402         res = _remove_flat_installation(setuptools_location)

   403         if not res:

   404             return

   405     else:

   406         log.warn('Egg installation')

   407         pkg_info = os.path.join(setuptools_location, 'EGG-INFO', 'PKG-INFO')

   408         if (os.path.exists(pkg_info) and

   409             _same_content(pkg_info, SETUPTOOLS_PKG_INFO)):

   410             log.warn('Already patched.')

   411             return

   412         log.warn('Patching...')

   413         # let's create a fake egg replacing setuptools one

   414         res = _patch_egg_dir(setuptools_location)

   415         if not res:

   416             return

   417     log.warn('Patched done.')

   418     _relaunch()

   419 

   420 

   421 def _relaunch():

   422     log.warn('Relaunching...')

   423     # we have to relaunch the process

   424     # pip marker to avoid a relaunch bug

   425     if sys.argv[:3] == ['-c', 'install', '--single-version-externally-managed']:

   426         sys.argv[0] = 'setup.py'

   427     args = [sys.executable] + sys.argv

   428     sys.exit(subprocess.call(args))

   429 

   430 

   431 def _extractall(self, path=".", members=None):

   432     """Extract all members from the archive to the current working

   433        directory and set owner, modification time and permissions on

   434        directories afterwards. `path' specifies a different directory

   435        to extract to. `members' is optional and must be a subset of the

   436        list returned by getmembers().

   437     """

   438     import copy

   439     import operator

   440     from tarfile import ExtractError

   441     directories = []

   442 

   443     if members is None:

   444         members = self

   445 

   446     for tarinfo in members:

   447         if tarinfo.isdir():

   448             # Extract directories with a safe mode.

   449             directories.append(tarinfo)

   450             tarinfo = copy.copy(tarinfo)

   451             tarinfo.mode = 448 # decimal for oct 0700

   452         self.extract(tarinfo, path)

   453 

   454     # Reverse sort directories.

   455     if sys.version_info < (2, 4):

   456         def sorter(dir1, dir2):

   457             return cmp(dir1.name, dir2.name)

   458         directories.sort(sorter)

   459         directories.reverse()

   460     else:

   461         directories.sort(key=operator.attrgetter('name'), reverse=True)

   462 

   463     # Set correct owner, mtime and filemode on directories.

   464     for tarinfo in directories:

   465         dirpath = os.path.join(path, tarinfo.name)

   466         try:

   467             self.chown(tarinfo, dirpath)

   468             self.utime(tarinfo, dirpath)

   469             self.chmod(tarinfo, dirpath)

   470         except ExtractError:

   471             e = sys.exc_info()[1]

   472             if self.errorlevel > 1:

   473                 raise

   474             else:

   475                 self._dbg(1, "tarfile: %s" % e)

   476 

   477 

   478 def main(argv, version=DEFAULT_VERSION):

   479     """Install or upgrade setuptools and EasyInstall"""

   480     tarball = download_setuptools()

   481     _install(tarball)

   482 

   483 

   484 if __name__ == '__main__':

   485     main(sys.argv[1:])