Revision db398015
Added by Benoît PECCATTE over 7 years ago
rudder-server-relay/SOURCES/Makefile | ||
---|---|---|
.DEFAULT_GOAL := localdepends
|
||
|
||
RUDDER_VERSION_TO_PACKAGE = <put Rudder version or version-snapshot here>
|
||
VIRTUALENV_RELEASE = 12.0.7
|
||
WGET := $(if $(PROXY), http_proxy=$(PROXY) ftp_proxy=$(PROXY)) /usr/bin/wget -q
|
||
|
||
localdepends: ./rudder-sources
|
||
localdepends: ./rudder-sources ./virtualenv/virtualenv.py
|
||
|
||
./rudder-sources.tar.bz2:
|
||
$(WGET) -O rudder-sources.tar.bz2 http://www.rudder-project.org/archives/rudder-sources-${RUDDER_VERSION_TO_PACKAGE}.tar.bz2
|
||
... | ... | |
tar -xjf rudder-sources.tar.bz2
|
||
mv rudder-sources-*/ rudder-sources/
|
||
|
||
./relay-api/virtualenv.tgz: /usr/bin/wget
|
||
# Original URL: https://pypi.python.org/packages/source/v/virtualenv/virtualenv-12.0.7.tar.gz
|
||
$(WGET) -O relay-api/virtualenv.tgz http://www.normation.com/tarball/virtualenv/virtualenv-$(VIRTUALENV_RELEASE).tar.gz
|
||
|
||
./virtualenv/virtualenv.py: ./relay-api/virtualenv.tgz
|
||
cd relay-api && tar -xzf ./virtualenv.tgz
|
||
cd relay-api && mv ./virtualenv-$(VIRTUALENV_RELEASE)/ virtualenv/
|
||
|
||
localclean:
|
||
rm -rf ./rudder-sources
|
||
|
rudder-server-relay/SOURCES/relay-api/virtualenv.py | ||
---|---|---|
#!/usr/bin/env python
|
||
"""Create a "virtual" Python installation
|
||
"""
|
||
|
||
# If you change the version here, change it in setup.py
|
||
# and docs/conf.py as well.
|
||
__version__ = "1.9.1" # following best practices
|
||
virtualenv_version = __version__ # legacy, again
|
||
|
||
import base64
|
||
import sys
|
||
import os
|
||
import codecs
|
||
import optparse
|
||
import re
|
||
import shutil
|
||
import logging
|
||
import tempfile
|
||
import zlib
|
||
import errno
|
||
import glob
|
||
import distutils.sysconfig
|
||
from distutils.util import strtobool
|
||
import struct
|
||
import subprocess
|
||
|
||
if sys.version_info < (2, 5):
|
||
print('ERROR: %s' % sys.exc_info()[1])
|
||
print('ERROR: this script requires Python 2.5 or greater.')
|
||
sys.exit(101)
|
||
|
||
try:
|
||
set
|
||
except NameError:
|
||
from sets import Set as set
|
||
try:
|
||
basestring
|
||
except NameError:
|
||
basestring = str
|
||
|
||
try:
|
||
import ConfigParser
|
||
except ImportError:
|
||
import configparser as ConfigParser
|
||
|
||
join = os.path.join
|
||
py_version = 'python%s.%s' % (sys.version_info[0], sys.version_info[1])
|
||
|
||
is_jython = sys.platform.startswith('java')
|
||
is_pypy = hasattr(sys, 'pypy_version_info')
|
||
is_win = (sys.platform == 'win32')
|
||
is_cygwin = (sys.platform == 'cygwin')
|
||
is_darwin = (sys.platform == 'darwin')
|
||
abiflags = getattr(sys, 'abiflags', '')
|
||
|
||
user_dir = os.path.expanduser('~')
|
||
if is_win:
|
||
default_storage_dir = os.path.join(user_dir, 'virtualenv')
|
||
else:
|
||
default_storage_dir = os.path.join(user_dir, '.virtualenv')
|
||
default_config_file = os.path.join(default_storage_dir, 'virtualenv.ini')
|
||
|
||
if is_pypy:
|
||
expected_exe = 'pypy'
|
||
elif is_jython:
|
||
expected_exe = 'jython'
|
||
else:
|
||
expected_exe = 'python'
|
||
|
||
|
||
REQUIRED_MODULES = ['os', 'posix', 'posixpath', 'nt', 'ntpath', 'genericpath',
|
||
'fnmatch', 'locale', 'encodings', 'codecs',
|
||
'stat', 'UserDict', 'readline', 'copy_reg', 'types',
|
||
're', 'sre', 'sre_parse', 'sre_constants', 'sre_compile',
|
||
'zlib']
|
||
|
||
REQUIRED_FILES = ['lib-dynload', 'config']
|
||
|
||
majver, minver = sys.version_info[:2]
|
||
if majver == 2:
|
||
if minver >= 6:
|
||
REQUIRED_MODULES.extend(['warnings', 'linecache', '_abcoll', 'abc'])
|
||
if minver >= 7:
|
||
REQUIRED_MODULES.extend(['_weakrefset'])
|
||
if minver <= 3:
|
||
REQUIRED_MODULES.extend(['sets', '__future__'])
|
||
elif majver == 3:
|
||
# Some extra modules are needed for Python 3, but different ones
|
||
# for different versions.
|
||
REQUIRED_MODULES.extend(['_abcoll', 'warnings', 'linecache', 'abc', 'io',
|
||
'_weakrefset', 'copyreg', 'tempfile', 'random',
|
||
'__future__', 'collections', 'keyword', 'tarfile',
|
||
'shutil', 'struct', 'copy', 'tokenize', 'token',
|
||
'functools', 'heapq', 'bisect', 'weakref',
|
||
'reprlib'])
|
||
if minver >= 2:
|
||
REQUIRED_FILES[-1] = 'config-%s' % majver
|
||
if minver == 3:
|
||
import sysconfig
|
||
platdir = sysconfig.get_config_var('PLATDIR')
|
||
REQUIRED_FILES.append(platdir)
|
||
# The whole list of 3.3 modules is reproduced below - the current
|
||
# uncommented ones are required for 3.3 as of now, but more may be
|
||
# added as 3.3 development continues.
|
||
REQUIRED_MODULES.extend([
|
||
#"aifc",
|
||
#"antigravity",
|
||
#"argparse",
|
||
#"ast",
|
||
#"asynchat",
|
||
#"asyncore",
|
||
"base64",
|
||
#"bdb",
|
||
#"binhex",
|
||
#"bisect",
|
||
#"calendar",
|
||
#"cgi",
|
||
#"cgitb",
|
||
#"chunk",
|
||
#"cmd",
|
||
#"codeop",
|
||
#"code",
|
||
#"colorsys",
|
||
#"_compat_pickle",
|
||
#"compileall",
|
||
#"concurrent",
|
||
#"configparser",
|
||
#"contextlib",
|
||
#"cProfile",
|
||
#"crypt",
|
||
#"csv",
|
||
#"ctypes",
|
||
#"curses",
|
||
#"datetime",
|
||
#"dbm",
|
||
#"decimal",
|
||
#"difflib",
|
||
#"dis",
|
||
#"doctest",
|
||
#"dummy_threading",
|
||
"_dummy_thread",
|
||
#"email",
|
||
#"filecmp",
|
||
#"fileinput",
|
||
#"formatter",
|
||
#"fractions",
|
||
#"ftplib",
|
||
#"functools",
|
||
#"getopt",
|
||
#"getpass",
|
||
#"gettext",
|
||
#"glob",
|
||
#"gzip",
|
||
"hashlib",
|
||
#"heapq",
|
||
"hmac",
|
||
#"html",
|
||
#"http",
|
||
#"idlelib",
|
||
#"imaplib",
|
||
#"imghdr",
|
||
"imp",
|
||
"importlib",
|
||
#"inspect",
|
||
#"json",
|
||
#"lib2to3",
|
||
#"logging",
|
||
#"macpath",
|
||
#"macurl2path",
|
||
#"mailbox",
|
||
#"mailcap",
|
||
#"_markupbase",
|
||
#"mimetypes",
|
||
#"modulefinder",
|
||
#"multiprocessing",
|
||
#"netrc",
|
||
#"nntplib",
|
||
#"nturl2path",
|
||
#"numbers",
|
||
#"opcode",
|
||
#"optparse",
|
||
#"os2emxpath",
|
||
#"pdb",
|
||
#"pickle",
|
||
#"pickletools",
|
||
#"pipes",
|
||
#"pkgutil",
|
||
#"platform",
|
||
#"plat-linux2",
|
||
#"plistlib",
|
||
#"poplib",
|
||
#"pprint",
|
||
#"profile",
|
||
#"pstats",
|
||
#"pty",
|
||
#"pyclbr",
|
||
#"py_compile",
|
||
#"pydoc_data",
|
||
#"pydoc",
|
||
#"_pyio",
|
||
#"queue",
|
||
#"quopri",
|
||
#"reprlib",
|
||
"rlcompleter",
|
||
#"runpy",
|
||
#"sched",
|
||
#"shelve",
|
||
#"shlex",
|
||
#"smtpd",
|
||
#"smtplib",
|
||
#"sndhdr",
|
||
#"socket",
|
||
#"socketserver",
|
||
#"sqlite3",
|
||
#"ssl",
|
||
#"stringprep",
|
||
#"string",
|
||
#"_strptime",
|
||
#"subprocess",
|
||
#"sunau",
|
||
#"symbol",
|
||
#"symtable",
|
||
#"sysconfig",
|
||
#"tabnanny",
|
||
#"telnetlib",
|
||
#"test",
|
||
#"textwrap",
|
||
#"this",
|
||
#"_threading_local",
|
||
#"threading",
|
||
#"timeit",
|
||
#"tkinter",
|
||
#"tokenize",
|
||
#"token",
|
||
#"traceback",
|
||
#"trace",
|
||
#"tty",
|
||
#"turtledemo",
|
||
#"turtle",
|
||
#"unittest",
|
||
#"urllib",
|
||
#"uuid",
|
||
#"uu",
|
||
#"wave",
|
||
#"weakref",
|
||
#"webbrowser",
|
||
#"wsgiref",
|
||
#"xdrlib",
|
||
#"xml",
|
||
#"xmlrpc",
|
||
#"zipfile",
|
||
])
|
||
|
||
if is_pypy:
|
||
# these are needed to correctly display the exceptions that may happen
|
||
# during the bootstrap
|
||
REQUIRED_MODULES.extend(['traceback', 'linecache'])
|
||
|
||
class Logger(object):
|
||
|
||
"""
|
||
Logging object for use in command-line script. Allows ranges of
|
||
levels, to avoid some redundancy of displayed information.
|
||
"""
|
||
|
||
DEBUG = logging.DEBUG
|
||
INFO = logging.INFO
|
||
NOTIFY = (logging.INFO+logging.WARN)/2
|
||
WARN = WARNING = logging.WARN
|
||
ERROR = logging.ERROR
|
||
FATAL = logging.FATAL
|
||
|
||
LEVELS = [DEBUG, INFO, NOTIFY, WARN, ERROR, FATAL]
|
||
|
||
def __init__(self, consumers):
|
||
self.consumers = consumers
|
||
self.indent = 0
|
||
self.in_progress = None
|
||
self.in_progress_hanging = False
|
||
|
||
def debug(self, msg, *args, **kw):
|
||
self.log(self.DEBUG, msg, *args, **kw)
|
||
def info(self, msg, *args, **kw):
|
||
self.log(self.INFO, msg, *args, **kw)
|
||
def notify(self, msg, *args, **kw):
|
||
self.log(self.NOTIFY, msg, *args, **kw)
|
||
def warn(self, msg, *args, **kw):
|
||
self.log(self.WARN, msg, *args, **kw)
|
||
def error(self, msg, *args, **kw):
|
||
self.log(self.ERROR, msg, *args, **kw)
|
||
def fatal(self, msg, *args, **kw):
|
||
self.log(self.FATAL, msg, *args, **kw)
|
||
def log(self, level, msg, *args, **kw):
|
||
if args:
|
||
if kw:
|
||
raise TypeError(
|
||
"You may give positional or keyword arguments, not both")
|
||
args = args or kw
|
||
rendered = None
|
||
for consumer_level, consumer in self.consumers:
|
||
if self.level_matches(level, consumer_level):
|
||
if (self.in_progress_hanging
|
||
and consumer in (sys.stdout, sys.stderr)):
|
||
self.in_progress_hanging = False
|
||
sys.stdout.write('\n')
|
||
sys.stdout.flush()
|
||
if rendered is None:
|
||
if args:
|
||
rendered = msg % args
|
||
else:
|
||
rendered = msg
|
||
rendered = ' '*self.indent + rendered
|
||
if hasattr(consumer, 'write'):
|
||
consumer.write(rendered+'\n')
|
||
else:
|
||
consumer(rendered)
|
||
|
||
def start_progress(self, msg):
|
||
assert not self.in_progress, (
|
||
"Tried to start_progress(%r) while in_progress %r"
|
||
% (msg, self.in_progress))
|
||
if self.level_matches(self.NOTIFY, self._stdout_level()):
|
||
sys.stdout.write(msg)
|
||
sys.stdout.flush()
|
||
self.in_progress_hanging = True
|
||
else:
|
||
self.in_progress_hanging = False
|
||
self.in_progress = msg
|
||
|
||
def end_progress(self, msg='done.'):
|
||
assert self.in_progress, (
|
||
"Tried to end_progress without start_progress")
|
||
if self.stdout_level_matches(self.NOTIFY):
|
||
if not self.in_progress_hanging:
|
||
# Some message has been printed out since start_progress
|
||
sys.stdout.write('...' + self.in_progress + msg + '\n')
|
||
sys.stdout.flush()
|
||
else:
|
||
sys.stdout.write(msg + '\n')
|
||
sys.stdout.flush()
|
||
self.in_progress = None
|
||
self.in_progress_hanging = False
|
||
|
||
def show_progress(self):
|
||
"""If we are in a progress scope, and no log messages have been
|
||
shown, write out another '.'"""
|
||
if self.in_progress_hanging:
|
||
sys.stdout.write('.')
|
||
sys.stdout.flush()
|
||
|
||
def stdout_level_matches(self, level):
|
||
"""Returns true if a message at this level will go to stdout"""
|
||
return self.level_matches(level, self._stdout_level())
|
||
|
||
def _stdout_level(self):
|
||
"""Returns the level that stdout runs at"""
|
||
for level, consumer in self.consumers:
|
||
if consumer is sys.stdout:
|
||
return level
|
||
return self.FATAL
|
||
|
||
def level_matches(self, level, consumer_level):
|
||
"""
|
||
>>> l = Logger([])
|
||
>>> l.level_matches(3, 4)
|
||
False
|
||
>>> l.level_matches(3, 2)
|
||
True
|
||
>>> l.level_matches(slice(None, 3), 3)
|
||
False
|
||
>>> l.level_matches(slice(None, 3), 2)
|
||
True
|
||
>>> l.level_matches(slice(1, 3), 1)
|
||
True
|
||
>>> l.level_matches(slice(2, 3), 1)
|
||
False
|
||
"""
|
||
if isinstance(level, slice):
|
||
start, stop = level.start, level.stop
|
||
if start is not None and start > consumer_level:
|
||
return False
|
||
if stop is not None and stop <= consumer_level:
|
||
return False
|
||
return True
|
||
else:
|
||
return level >= consumer_level
|
||
|
||
#@classmethod
|
||
def level_for_integer(cls, level):
|
||
levels = cls.LEVELS
|
||
if level < 0:
|
||
return levels[0]
|
||
if level >= len(levels):
|
||
return levels[-1]
|
||
return levels[level]
|
||
|
||
level_for_integer = classmethod(level_for_integer)
|
||
|
||
# create a silent logger just to prevent this from being undefined
|
||
# will be overridden with requested verbosity main() is called.
|
||
logger = Logger([(Logger.LEVELS[-1], sys.stdout)])
|
||
|
||
def mkdir(path):
|
||
if not os.path.exists(path):
|
||
logger.info('Creating %s', path)
|
||
os.makedirs(path)
|
||
else:
|
||
logger.info('Directory %s already exists', path)
|
||
|
||
def copyfileordir(src, dest):
|
||
if os.path.isdir(src):
|
||
shutil.copytree(src, dest, True)
|
||
else:
|
||
shutil.copy2(src, dest)
|
||
|
||
def copyfile(src, dest, symlink=True):
|
||
if not os.path.exists(src):
|
||
# Some bad symlink in the src
|
||
logger.warn('Cannot find file %s (bad symlink)', src)
|
||
return
|
||
if os.path.exists(dest):
|
||
logger.debug('File %s already exists', dest)
|
||
return
|
||
if not os.path.exists(os.path.dirname(dest)):
|
||
logger.info('Creating parent directories for %s' % os.path.dirname(dest))
|
||
os.makedirs(os.path.dirname(dest))
|
||
if not os.path.islink(src):
|
||
srcpath = os.path.abspath(src)
|
||
else:
|
||
srcpath = os.readlink(src)
|
||
if symlink and hasattr(os, 'symlink') and not is_win:
|
||
logger.info('Symlinking %s', dest)
|
||
try:
|
||
os.symlink(srcpath, dest)
|
||
except (OSError, NotImplementedError):
|
||
logger.info('Symlinking failed, copying to %s', dest)
|
||
copyfileordir(src, dest)
|
||
else:
|
||
logger.info('Copying to %s', dest)
|
||
copyfileordir(src, dest)
|
||
|
||
def writefile(dest, content, overwrite=True):
|
||
if not os.path.exists(dest):
|
||
logger.info('Writing %s', dest)
|
||
f = open(dest, 'wb')
|
||
f.write(content.encode('utf-8'))
|
||
f.close()
|
||
return
|
||
else:
|
||
f = open(dest, 'rb')
|
||
c = f.read()
|
||
f.close()
|
||
if c != content.encode("utf-8"):
|
||
if not overwrite:
|
||
logger.notify('File %s exists with different content; not overwriting', dest)
|
||
return
|
||
logger.notify('Overwriting %s with new content', dest)
|
||
f = open(dest, 'wb')
|
||
f.write(content.encode('utf-8'))
|
||
f.close()
|
||
else:
|
||
logger.info('Content %s already in place', dest)
|
||
|
||
def rmtree(dir):
|
||
if os.path.exists(dir):
|
||
logger.notify('Deleting tree %s', dir)
|
||
shutil.rmtree(dir)
|
||
else:
|
||
logger.info('Do not need to delete %s; already gone', dir)
|
||
|
||
def make_exe(fn):
|
||
if hasattr(os, 'chmod'):
|
||
oldmode = os.stat(fn).st_mode & 0xFFF # 0o7777
|
||
newmode = (oldmode | 0x16D) & 0xFFF # 0o555, 0o7777
|
||
os.chmod(fn, newmode)
|
||
logger.info('Changed mode of %s to %s', fn, oct(newmode))
|
||
|
||
def _find_file(filename, dirs):
|
||
for dir in reversed(dirs):
|
||
files = glob.glob(os.path.join(dir, filename))
|
||
if files and os.path.isfile(files[0]):
|
||
return True, files[0]
|
||
return False, filename
|
||
|
||
def _install_req(py_executable, unzip=False, distribute=False,
|
||
search_dirs=None, never_download=False):
|
||
|
||
if search_dirs is None:
|
||
search_dirs = file_search_dirs()
|
||
|
||
if not distribute:
|
||
egg_path = 'setuptools-*-py%s.egg' % sys.version[:3]
|
||
found, egg_path = _find_file(egg_path, search_dirs)
|
||
project_name = 'setuptools'
|
||
bootstrap_script = EZ_SETUP_PY
|
||
tgz_path = None
|
||
else:
|
||
# Look for a distribute egg (these are not distributed by default,
|
||
# but can be made available by the user)
|
||
egg_path = 'distribute-*-py%s.egg' % sys.version[:3]
|
||
found, egg_path = _find_file(egg_path, search_dirs)
|
||
project_name = 'distribute'
|
||
if found:
|
||
tgz_path = None
|
||
bootstrap_script = DISTRIBUTE_FROM_EGG_PY
|
||
else:
|
||
# Fall back to sdist
|
||
# NB: egg_path is not None iff tgz_path is None
|
||
# iff bootstrap_script is a generic setup script accepting
|
||
# the standard arguments.
|
||
egg_path = None
|
||
tgz_path = 'distribute-*.tar.gz'
|
||
found, tgz_path = _find_file(tgz_path, search_dirs)
|
||
bootstrap_script = DISTRIBUTE_SETUP_PY
|
||
|
||
if is_jython and os._name == 'nt':
|
||
# Jython's .bat sys.executable can't handle a command line
|
||
# argument with newlines
|
||
fd, ez_setup = tempfile.mkstemp('.py')
|
||
os.write(fd, bootstrap_script)
|
||
os.close(fd)
|
||
cmd = [py_executable, ez_setup]
|
||
else:
|
||
cmd = [py_executable, '-c', bootstrap_script]
|
||
if unzip and egg_path:
|
||
cmd.append('--always-unzip')
|
||
env = {}
|
||
remove_from_env = ['__PYVENV_LAUNCHER__']
|
||
if logger.stdout_level_matches(logger.DEBUG) and egg_path:
|
||
cmd.append('-v')
|
||
|
||
old_chdir = os.getcwd()
|
||
if egg_path is not None and os.path.exists(egg_path):
|
||
logger.info('Using existing %s egg: %s' % (project_name, egg_path))
|
||
cmd.append(egg_path)
|
||
if os.environ.get('PYTHONPATH'):
|
||
env['PYTHONPATH'] = egg_path + os.path.pathsep + os.environ['PYTHONPATH']
|
||
else:
|
||
env['PYTHONPATH'] = egg_path
|
||
elif tgz_path is not None and os.path.exists(tgz_path):
|
||
# Found a tgz source dist, let's chdir
|
||
logger.info('Using existing %s egg: %s' % (project_name, tgz_path))
|
||
os.chdir(os.path.dirname(tgz_path))
|
||
# in this case, we want to be sure that PYTHONPATH is unset (not
|
||
# just empty, really unset), else CPython tries to import the
|
||
# site.py that it's in virtualenv_support
|
||
remove_from_env.append('PYTHONPATH')
|
||
elif never_download:
|
||
logger.fatal("Can't find any local distributions of %s to install "
|
||
"and --never-download is set. Either re-run virtualenv "
|
||
"without the --never-download option, or place a %s "
|
||
"distribution (%s) in one of these "
|
||
"locations: %r" % (project_name, project_name,
|
||
egg_path or tgz_path,
|
||
search_dirs))
|
||
sys.exit(1)
|
||
elif egg_path:
|
||
logger.info('No %s egg found; downloading' % project_name)
|
||
cmd.extend(['--always-copy', '-U', project_name])
|
||
else:
|
||
logger.info('No %s tgz found; downloading' % project_name)
|
||
logger.start_progress('Installing %s...' % project_name)
|
||
logger.indent += 2
|
||
cwd = None
|
||
if project_name == 'distribute':
|
||
env['DONT_PATCH_SETUPTOOLS'] = 'true'
|
||
|
||
def _filter_ez_setup(line):
|
||
return filter_ez_setup(line, project_name)
|
||
|
||
if not os.access(os.getcwd(), os.W_OK):
|
||
cwd = tempfile.mkdtemp()
|
||
if tgz_path is not None and os.path.exists(tgz_path):
|
||
# the current working dir is hostile, let's copy the
|
||
# tarball to a temp dir
|
||
target = os.path.join(cwd, os.path.split(tgz_path)[-1])
|
||
shutil.copy(tgz_path, target)
|
||
try:
|
||
call_subprocess(cmd, show_stdout=False,
|
||
filter_stdout=_filter_ez_setup,
|
||
extra_env=env,
|
||
remove_from_env=remove_from_env,
|
||
cwd=cwd)
|
||
finally:
|
||
logger.indent -= 2
|
||
logger.end_progress()
|
||
if cwd is not None:
|
||
shutil.rmtree(cwd)
|
||
if os.getcwd() != old_chdir:
|
||
os.chdir(old_chdir)
|
||
if is_jython and os._name == 'nt':
|
||
os.remove(ez_setup)
|
||
|
||
def file_search_dirs():
|
||
here = os.path.dirname(os.path.abspath(__file__))
|
||
dirs = ['.', here,
|
||
join(here, 'virtualenv_support')]
|
||
if os.path.splitext(os.path.dirname(__file__))[0] != 'virtualenv':
|
||
# Probably some boot script; just in case virtualenv is installed...
|
||
try:
|
||
import virtualenv
|
||
except ImportError:
|
||
pass
|
||
else:
|
||
dirs.append(os.path.join(os.path.dirname(virtualenv.__file__), 'virtualenv_support'))
|
||
return [d for d in dirs if os.path.isdir(d)]
|
||
|
||
def install_setuptools(py_executable, unzip=False,
|
||
search_dirs=None, never_download=False):
|
||
_install_req(py_executable, unzip,
|
||
search_dirs=search_dirs, never_download=never_download)
|
||
|
||
def install_distribute(py_executable, unzip=False,
|
||
search_dirs=None, never_download=False):
|
||
_install_req(py_executable, unzip, distribute=True,
|
||
search_dirs=search_dirs, never_download=never_download)
|
||
|
||
_pip_re = re.compile(r'^pip-.*(zip|tar.gz|tar.bz2|tgz|tbz)$', re.I)
|
||
def install_pip(py_executable, search_dirs=None, never_download=False):
|
||
if search_dirs is None:
|
||
search_dirs = file_search_dirs()
|
||
|
||
filenames = []
|
||
for dir in search_dirs:
|
||
filenames.extend([join(dir, fn) for fn in os.listdir(dir)
|
||
if _pip_re.search(fn)])
|
||
filenames = [(os.path.basename(filename).lower(), i, filename) for i, filename in enumerate(filenames)]
|
||
filenames.sort()
|
||
filenames = [filename for basename, i, filename in filenames]
|
||
if not filenames:
|
||
filename = 'pip'
|
||
else:
|
||
filename = filenames[-1]
|
||
easy_install_script = 'easy_install'
|
||
if is_win:
|
||
easy_install_script = 'easy_install-script.py'
|
||
# There's two subtle issues here when invoking easy_install.
|
||
# 1. On unix-like systems the easy_install script can *only* be executed
|
||
# directly if its full filesystem path is no longer than 78 characters.
|
||
# 2. A work around to [1] is to use the `python path/to/easy_install foo`
|
||
# pattern, but that breaks if the path contains non-ASCII characters, as
|
||
# you can't put the file encoding declaration before the shebang line.
|
||
# The solution is to use Python's -x flag to skip the first line of the
|
||
# script (and any ASCII decoding errors that may have occurred in that line)
|
||
cmd = [py_executable, '-x', join(os.path.dirname(py_executable), easy_install_script), filename]
|
||
# jython and pypy don't yet support -x
|
||
if is_jython or is_pypy:
|
||
cmd.remove('-x')
|
||
if filename == 'pip':
|
||
if never_download:
|
||
logger.fatal("Can't find any local distributions of pip to install "
|
||
"and --never-download is set. Either re-run virtualenv "
|
||
"without the --never-download option, or place a pip "
|
||
"source distribution (zip/tar.gz/tar.bz2) in one of these "
|
||
"locations: %r" % search_dirs)
|
||
sys.exit(1)
|
||
logger.info('Installing pip from network...')
|
||
else:
|
||
logger.info('Installing existing %s distribution: %s' % (
|
||
os.path.basename(filename), filename))
|
||
logger.start_progress('Installing pip...')
|
||
logger.indent += 2
|
||
def _filter_setup(line):
|
||
return filter_ez_setup(line, 'pip')
|
||
try:
|
||
call_subprocess(cmd, show_stdout=False,
|
||
filter_stdout=_filter_setup)
|
||
finally:
|
||
logger.indent -= 2
|
||
logger.end_progress()
|
||
|
||
def filter_ez_setup(line, project_name='setuptools'):
|
||
if not line.strip():
|
||
return Logger.DEBUG
|
||
if project_name == 'distribute':
|
||
for prefix in ('Extracting', 'Now working', 'Installing', 'Before',
|
||
'Scanning', 'Setuptools', 'Egg', 'Already',
|
||
'running', 'writing', 'reading', 'installing',
|
||
'creating', 'copying', 'byte-compiling', 'removing',
|
||
'Processing'):
|
||
if line.startswith(prefix):
|
||
return Logger.DEBUG
|
||
return Logger.DEBUG
|
||
for prefix in ['Reading ', 'Best match', 'Processing setuptools',
|
||
'Copying setuptools', 'Adding setuptools',
|
||
'Installing ', 'Installed ']:
|
||
if line.startswith(prefix):
|
||
return Logger.DEBUG
|
||
return Logger.INFO
|
||
|
||
|
||
class UpdatingDefaultsHelpFormatter(optparse.IndentedHelpFormatter):
|
||
"""
|
||
Custom help formatter for use in ConfigOptionParser that updates
|
||
the defaults before expanding them, allowing them to show up correctly
|
||
in the help listing
|
||
"""
|
||
def expand_default(self, option):
|
||
if self.parser is not None:
|
||
self.parser.update_defaults(self.parser.defaults)
|
||
return optparse.IndentedHelpFormatter.expand_default(self, option)
|
||
|
||
|
||
class ConfigOptionParser(optparse.OptionParser):
|
||
"""
|
||
Custom option parser which updates its defaults by by checking the
|
||
configuration files and environmental variables
|
||
"""
|
||
def __init__(self, *args, **kwargs):
|
||
self.config = ConfigParser.RawConfigParser()
|
||
self.files = self.get_config_files()
|
||
self.config.read(self.files)
|
||
optparse.OptionParser.__init__(self, *args, **kwargs)
|
||
|
||
def get_config_files(self):
|
||
config_file = os.environ.get('VIRTUALENV_CONFIG_FILE', False)
|
||
if config_file and os.path.exists(config_file):
|
||
return [config_file]
|
||
return [default_config_file]
|
||
|
||
def update_defaults(self, defaults):
|
||
"""
|
||
Updates the given defaults with values from the config files and
|
||
the environ. Does a little special handling for certain types of
|
||
options (lists).
|
||
"""
|
||
# Then go and look for the other sources of configuration:
|
||
config = {}
|
||
# 1. config files
|
||
config.update(dict(self.get_config_section('virtualenv')))
|
||
# 2. environmental variables
|
||
config.update(dict(self.get_environ_vars()))
|
||
# Then set the options with those values
|
||
for key, val in config.items():
|
||
key = key.replace('_', '-')
|
||
if not key.startswith('--'):
|
||
key = '--%s' % key # only prefer long opts
|
||
option = self.get_option(key)
|
||
if option is not None:
|
||
# ignore empty values
|
||
if not val:
|
||
continue
|
||
# handle multiline configs
|
||
if option.action == 'append':
|
||
val = val.split()
|
||
else:
|
||
option.nargs = 1
|
||
if option.action == 'store_false':
|
||
val = not strtobool(val)
|
||
elif option.action in ('store_true', 'count'):
|
||
val = strtobool(val)
|
||
try:
|
||
val = option.convert_value(key, val)
|
||
except optparse.OptionValueError:
|
||
e = sys.exc_info()[1]
|
||
print("An error occured during configuration: %s" % e)
|
||
sys.exit(3)
|
||
defaults[option.dest] = val
|
||
return defaults
|
||
|
||
def get_config_section(self, name):
|
||
"""
|
||
Get a section of a configuration
|
||
"""
|
||
if self.config.has_section(name):
|
||
return self.config.items(name)
|
||
return []
|
||
|
||
def get_environ_vars(self, prefix='VIRTUALENV_'):
|
||
"""
|
||
Returns a generator with all environmental vars with prefix VIRTUALENV
|
||
"""
|
||
for key, val in os.environ.items():
|
||
if key.startswith(prefix):
|
||
yield (key.replace(prefix, '').lower(), val)
|
||
|
||
def get_default_values(self):
|
||
"""
|
||
Overridding to make updating the defaults after instantiation of
|
||
the option parser possible, update_defaults() does the dirty work.
|
||
"""
|
||
if not self.process_default_values:
|
||
# Old, pre-Optik 1.5 behaviour.
|
||
return optparse.Values(self.defaults)
|
||
|
||
defaults = self.update_defaults(self.defaults.copy()) # ours
|
||
for option in self._get_all_options():
|
||
default = defaults.get(option.dest)
|
||
if isinstance(default, basestring):
|
||
opt_str = option.get_opt_string()
|
||
defaults[option.dest] = option.check_value(opt_str, default)
|
||
return optparse.Values(defaults)
|
||
|
||
|
||
def main():
|
||
parser = ConfigOptionParser(
|
||
version=virtualenv_version,
|
||
usage="%prog [OPTIONS] DEST_DIR",
|
||
formatter=UpdatingDefaultsHelpFormatter())
|
||
|
||
parser.add_option(
|
||
'-v', '--verbose',
|
||
action='count',
|
||
dest='verbose',
|
||
default=0,
|
||
help="Increase verbosity")
|
||
|
||
parser.add_option(
|
||
'-q', '--quiet',
|
||
action='count',
|
||
dest='quiet',
|
||
default=0,
|
||
help='Decrease verbosity')
|
||
|
||
parser.add_option(
|
||
'-p', '--python',
|
||
dest='python',
|
||
metavar='PYTHON_EXE',
|
||
help='The Python interpreter to use, e.g., --python=python2.5 will use the python2.5 '
|
||
'interpreter to create the new environment. The default is the interpreter that '
|
||
'virtualenv was installed with (%s)' % sys.executable)
|
||
|
||
parser.add_option(
|
||
'--clear',
|
||
dest='clear',
|
||
action='store_true',
|
||
help="Clear out the non-root install and start from scratch")
|
||
|
||
parser.set_defaults(system_site_packages=False)
|
||
parser.add_option(
|
||
'--no-site-packages',
|
||
dest='system_site_packages',
|
||
action='store_false',
|
||
help="Don't give access to the global site-packages dir to the "
|
||
"virtual environment (default)")
|
||
|
||
parser.add_option(
|
||
'--system-site-packages',
|
||
dest='system_site_packages',
|
||
action='store_true',
|
||
help="Give access to the global site-packages dir to the "
|
||
"virtual environment")
|
||
|
||
parser.add_option(
|
||
'--unzip-setuptools',
|
||
dest='unzip_setuptools',
|
||
action='store_true',
|
||
help="Unzip Setuptools or Distribute when installing it")
|
||
|
||
parser.add_option(
|
||
'--relocatable',
|
||
dest='relocatable',
|
||
action='store_true',
|
||
help='Make an EXISTING virtualenv environment relocatable. '
|
||
'This fixes up scripts and makes all .pth files relative')
|
||
|
||
parser.add_option(
|
||
'--distribute', '--use-distribute', # the second option is for legacy reasons here. Hi Kenneth!
|
||
dest='use_distribute',
|
||
action='store_true',
|
||
help='Use Distribute instead of Setuptools. Set environ variable '
|
||
'VIRTUALENV_DISTRIBUTE to make it the default ')
|
||
|
||
parser.add_option(
|
||
'--no-setuptools',
|
||
dest='no_setuptools',
|
||
action='store_true',
|
||
help='Do not install distribute/setuptools (or pip) '
|
||
'in the new virtualenv.')
|
||
|
||
parser.add_option(
|
||
'--no-pip',
|
||
dest='no_pip',
|
||
action='store_true',
|
||
help='Do not install pip in the new virtualenv.')
|
||
|
||
parser.add_option(
|
||
'--setuptools',
|
||
dest='use_distribute',
|
||
action='store_false',
|
||
help='Use Setuptools instead of Distribute. Set environ variable '
|
||
'VIRTUALENV_SETUPTOOLS to make it the default ')
|
||
|
||
# Set this to True to use distribute by default, even in Python 2.
|
||
parser.set_defaults(use_distribute=False)
|
||
|
||
default_search_dirs = file_search_dirs()
|
||
parser.add_option(
|
||
'--extra-search-dir',
|
||
dest="search_dirs",
|
||
action="append",
|
||
default=default_search_dirs,
|
||
help="Directory to look for setuptools/distribute/pip distributions in. "
|
||
"You can add any number of additional --extra-search-dir paths.")
|
||
|
||
parser.add_option(
|
||
'--never-download',
|
||
dest="never_download",
|
||
action="store_true",
|
||
help="Never download anything from the network. Instead, virtualenv will fail "
|
||
"if local distributions of setuptools/distribute/pip are not present.")
|
||
|
||
parser.add_option(
|
||
'--prompt',
|
||
dest='prompt',
|
||
help='Provides an alternative prompt prefix for this environment')
|
||
|
||
if 'extend_parser' in globals():
|
||
extend_parser(parser)
|
||
|
||
options, args = parser.parse_args()
|
||
|
||
global logger
|
||
|
||
if 'adjust_options' in globals():
|
||
adjust_options(options, args)
|
||
|
||
verbosity = options.verbose - options.quiet
|
||
logger = Logger([(Logger.level_for_integer(2 - verbosity), sys.stdout)])
|
||
|
||
if options.python and not os.environ.get('VIRTUALENV_INTERPRETER_RUNNING'):
|
||
env = os.environ.copy()
|
||
interpreter = resolve_interpreter(options.python)
|
||
if interpreter == sys.executable:
|
||
logger.warn('Already using interpreter %s' % interpreter)
|
||
else:
|
||
logger.notify('Running virtualenv with interpreter %s' % interpreter)
|
||
env['VIRTUALENV_INTERPRETER_RUNNING'] = 'true'
|
||
file = __file__
|
||
if file.endswith('.pyc'):
|
||
file = file[:-1]
|
||
popen = subprocess.Popen([interpreter, file] + sys.argv[1:], env=env)
|
||
raise SystemExit(popen.wait())
|
||
|
||
# Force --distribute on Python 3, since setuptools is not available.
|
||
if majver > 2:
|
||
options.use_distribute = True
|
||
|
||
if os.environ.get('PYTHONDONTWRITEBYTECODE') and not options.use_distribute:
|
||
print(
|
||
"The PYTHONDONTWRITEBYTECODE environment variable is "
|
||
"not compatible with setuptools. Either use --distribute "
|
||
"or unset PYTHONDONTWRITEBYTECODE.")
|
||
sys.exit(2)
|
||
if not args:
|
||
print('You must provide a DEST_DIR')
|
||
parser.print_help()
|
||
sys.exit(2)
|
||
if len(args) > 1:
|
||
print('There must be only one argument: DEST_DIR (you gave %s)' % (
|
||
' '.join(args)))
|
||
parser.print_help()
|
||
sys.exit(2)
|
||
|
||
home_dir = args[0]
|
||
|
||
if os.environ.get('WORKING_ENV'):
|
||
logger.fatal('ERROR: you cannot run virtualenv while in a workingenv')
|
||
logger.fatal('Please deactivate your workingenv, then re-run this script')
|
||
sys.exit(3)
|
||
|
||
if 'PYTHONHOME' in os.environ:
|
||
logger.warn('PYTHONHOME is set. You *must* activate the virtualenv before using it')
|
||
del os.environ['PYTHONHOME']
|
||
|
||
if options.relocatable:
|
||
make_environment_relocatable(home_dir)
|
||
return
|
||
|
||
create_environment(home_dir,
|
||
site_packages=options.system_site_packages,
|
||
clear=options.clear,
|
||
unzip_setuptools=options.unzip_setuptools,
|
||
use_distribute=options.use_distribute,
|
||
prompt=options.prompt,
|
||
search_dirs=options.search_dirs,
|
||
never_download=options.never_download,
|
||
no_setuptools=options.no_setuptools,
|
||
no_pip=options.no_pip)
|
||
if 'after_install' in globals():
|
||
after_install(options, home_dir)
|
||
|
||
def call_subprocess(cmd, show_stdout=True,
|
||
filter_stdout=None, cwd=None,
|
||
raise_on_returncode=True, extra_env=None,
|
||
remove_from_env=None):
|
||
cmd_parts = []
|
||
for part in cmd:
|
||
if len(part) > 45:
|
||
part = part[:20]+"..."+part[-20:]
|
||
if ' ' in part or '\n' in part or '"' in part or "'" in part:
|
||
part = '"%s"' % part.replace('"', '\\"')
|
||
if hasattr(part, 'decode'):
|
||
try:
|
||
part = part.decode(sys.getdefaultencoding())
|
||
except UnicodeDecodeError:
|
||
part = part.decode(sys.getfilesystemencoding())
|
||
cmd_parts.append(part)
|
||
cmd_desc = ' '.join(cmd_parts)
|
||
if show_stdout:
|
||
stdout = None
|
||
else:
|
||
stdout = subprocess.PIPE
|
||
logger.debug("Running command %s" % cmd_desc)
|
||
if extra_env or remove_from_env:
|
||
env = os.environ.copy()
|
||
if extra_env:
|
||
env.update(extra_env)
|
||
if remove_from_env:
|
||
for varname in remove_from_env:
|
||
env.pop(varname, None)
|
||
else:
|
||
env = None
|
||
try:
|
||
proc = subprocess.Popen(
|
||
cmd, stderr=subprocess.STDOUT, stdin=None, stdout=stdout,
|
||
cwd=cwd, env=env)
|
||
except Exception:
|
||
e = sys.exc_info()[1]
|
||
logger.fatal(
|
||
"Error %s while executing command %s" % (e, cmd_desc))
|
||
raise
|
||
all_output = []
|
||
if stdout is not None:
|
||
stdout = proc.stdout
|
||
encoding = sys.getdefaultencoding()
|
||
fs_encoding = sys.getfilesystemencoding()
|
||
while 1:
|
||
line = stdout.readline()
|
||
try:
|
||
line = line.decode(encoding)
|
||
except UnicodeDecodeError:
|
||
line = line.decode(fs_encoding)
|
||
if not line:
|
||
break
|
||
line = line.rstrip()
|
||
all_output.append(line)
|
||
if filter_stdout:
|
||
level = filter_stdout(line)
|
||
if isinstance(level, tuple):
|
||
level, line = level
|
||
logger.log(level, line)
|
||
if not logger.stdout_level_matches(level):
|
||
logger.show_progress()
|
||
else:
|
||
logger.info(line)
|
||
else:
|
||
proc.communicate()
|
||
proc.wait()
|
||
if proc.returncode:
|
||
if raise_on_returncode:
|
||
if all_output:
|
||
logger.notify('Complete output from command %s:' % cmd_desc)
|
||
logger.notify('\n'.join(all_output) + '\n----------------------------------------')
|
||
raise OSError(
|
||
"Command %s failed with error code %s"
|
||
% (cmd_desc, proc.returncode))
|
||
else:
|
||
logger.warn(
|
||
"Command %s had error code %s"
|
||
% (cmd_desc, proc.returncode))
|
||
|
||
|
||
def create_environment(home_dir, site_packages=False, clear=False,
|
||
unzip_setuptools=False, use_distribute=False,
|
||
prompt=None, search_dirs=None, never_download=False,
|
||
no_setuptools=False, no_pip=False):
|
||
"""
|
||
Creates a new environment in ``home_dir``.
|
||
|
||
If ``site_packages`` is true, then the global ``site-packages/``
|
||
directory will be on the path.
|
||
|
||
If ``clear`` is true (default False) then the environment will
|
||
first be cleared.
|
||
"""
|
||
home_dir, lib_dir, inc_dir, bin_dir = path_locations(home_dir)
|
||
|
||
py_executable = os.path.abspath(install_python(
|
||
home_dir, lib_dir, inc_dir, bin_dir,
|
||
site_packages=site_packages, clear=clear))
|
||
|
||
install_distutils(home_dir)
|
||
|
||
if not no_setuptools:
|
||
if use_distribute:
|
||
install_distribute(py_executable, unzip=unzip_setuptools,
|
||
search_dirs=search_dirs, never_download=never_download)
|
||
else:
|
||
install_setuptools(py_executable, unzip=unzip_setuptools,
|
||
search_dirs=search_dirs, never_download=never_download)
|
||
|
||
if not no_pip:
|
||
install_pip(py_executable, search_dirs=search_dirs, never_download=never_download)
|
||
|
||
install_activate(home_dir, bin_dir, prompt)
|
||
|
||
def is_executable_file(fpath):
|
||
return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
|
||
|
||
def path_locations(home_dir):
|
||
"""Return the path locations for the environment (where libraries are,
|
||
where scripts go, etc)"""
|
||
# XXX: We'd use distutils.sysconfig.get_python_inc/lib but its
|
||
# prefix arg is broken: http://bugs.python.org/issue3386
|
||
if is_win:
|
||
# Windows has lots of problems with executables with spaces in
|
||
# the name; this function will remove them (using the ~1
|
||
# format):
|
||
mkdir(home_dir)
|
||
if ' ' in home_dir:
|
||
import ctypes
|
||
GetShortPathName = ctypes.windll.kernel32.GetShortPathNameW
|
||
size = max(len(home_dir)+1, 256)
|
||
buf = ctypes.create_unicode_buffer(size)
|
||
try:
|
||
u = unicode
|
||
except NameError:
|
||
u = str
|
||
ret = GetShortPathName(u(home_dir), buf, size)
|
||
if not ret:
|
||
print('Error: the path "%s" has a space in it' % home_dir)
|
||
print('We could not determine the short pathname for it.')
|
||
print('Exiting.')
|
||
sys.exit(3)
|
||
home_dir = str(buf.value)
|
||
lib_dir = join(home_dir, 'Lib')
|
||
inc_dir = join(home_dir, 'Include')
|
||
bin_dir = join(home_dir, 'Scripts')
|
||
if is_jython:
|
||
lib_dir = join(home_dir, 'Lib')
|
||
inc_dir = join(home_dir, 'Include')
|
||
bin_dir = join(home_dir, 'bin')
|
||
elif is_pypy:
|
||
lib_dir = home_dir
|
||
inc_dir = join(home_dir, 'include')
|
||
bin_dir = join(home_dir, 'bin')
|
||
elif not is_win:
|
||
lib_dir = join(home_dir, 'lib', py_version)
|
||
multiarch_exec = '/usr/bin/multiarch-platform'
|
||
if is_executable_file(multiarch_exec):
|
||
# In Mageia (2) and Mandriva distros the include dir must be like:
|
||
# virtualenv/include/multiarch-x86_64-linux/python2.7
|
||
# instead of being virtualenv/include/python2.7
|
||
p = subprocess.Popen(multiarch_exec, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
|
||
stdout, stderr = p.communicate()
|
||
# stdout.strip is needed to remove newline character
|
||
inc_dir = join(home_dir, 'include', stdout.strip(), py_version + abiflags)
|
||
else:
|
||
inc_dir = join(home_dir, 'include', py_version + abiflags)
|
||
bin_dir = join(home_dir, 'bin')
|
||
return home_dir, lib_dir, inc_dir, bin_dir
|
||
|
||
|
||
def change_prefix(filename, dst_prefix):
|
||
prefixes = [sys.prefix]
|
||
|
||
if is_darwin:
|
||
prefixes.extend((
|
||
os.path.join("/Library/Python", sys.version[:3], "site-packages"),
|
||
os.path.join(sys.prefix, "Extras", "lib", "python"),
|
||
os.path.join("~", "Library", "Python", sys.version[:3], "site-packages"),
|
||
# Python 2.6 no-frameworks
|
||
os.path.join("~", ".local", "lib","python", sys.version[:3], "site-packages"),
|
||
# System Python 2.7 on OSX Mountain Lion
|
||
os.path.join("~", "Library", "Python", sys.version[:3], "lib", "python", "site-packages")))
|
||
|
||
if hasattr(sys, 'real_prefix'):
|
||
prefixes.append(sys.real_prefix)
|
||
if hasattr(sys, 'base_prefix'):
|
||
prefixes.append(sys.base_prefix)
|
||
prefixes = list(map(os.path.expanduser, prefixes))
|
||
prefixes = list(map(os.path.abspath, prefixes))
|
||
# Check longer prefixes first so we don't split in the middle of a filename
|
||
prefixes = sorted(prefixes, key=len, reverse=True)
|
||
filename = os.path.abspath(filename)
|
||
for src_prefix in prefixes:
|
||
if filename.startswith(src_prefix):
|
||
_, relpath = filename.split(src_prefix, 1)
|
||
if src_prefix != os.sep: # sys.prefix == "/"
|
||
assert relpath[0] == os.sep
|
||
relpath = relpath[1:]
|
||
return join(dst_prefix, relpath)
|
||
assert False, "Filename %s does not start with any of these prefixes: %s" % \
|
||
(filename, prefixes)
|
||
|
||
def copy_required_modules(dst_prefix):
|
||
import imp
|
||
# If we are running under -p, we need to remove the current
|
||
# directory from sys.path temporarily here, so that we
|
||
# definitely get the modules from the site directory of
|
||
# the interpreter we are running under, not the one
|
||
# virtualenv.py is installed under (which might lead to py2/py3
|
||
# incompatibility issues)
|
||
_prev_sys_path = sys.path
|
||
if os.environ.get('VIRTUALENV_INTERPRETER_RUNNING'):
|
||
sys.path = sys.path[1:]
|
||
try:
|
||
for modname in REQUIRED_MODULES:
|
||
if modname in sys.builtin_module_names:
|
||
logger.info("Ignoring built-in bootstrap module: %s" % modname)
|
||
continue
|
||
try:
|
||
f, filename, _ = imp.find_module(modname)
|
||
except ImportError:
|
||
logger.info("Cannot import bootstrap module: %s" % modname)
|
||
else:
|
||
if f is not None:
|
||
f.close()
|
||
# special-case custom readline.so on OS X, but not for pypy:
|
||
if modname == 'readline' and sys.platform == 'darwin' and not (
|
||
is_pypy or filename.endswith(join('lib-dynload', 'readline.so'))):
|
||
dst_filename = join(dst_prefix, 'lib', 'python%s' % sys.version[:3], 'readline.so')
|
||
else:
|
||
dst_filename = change_prefix(filename, dst_prefix)
|
||
copyfile(filename, dst_filename)
|
||
if filename.endswith('.pyc'):
|
||
pyfile = filename[:-1]
|
||
if os.path.exists(pyfile):
|
||
copyfile(pyfile, dst_filename[:-1])
|
||
finally:
|
||
sys.path = _prev_sys_path
|
||
|
||
|
||
def subst_path(prefix_path, prefix, home_dir):
|
||
prefix_path = os.path.normpath(prefix_path)
|
||
prefix = os.path.normpath(prefix)
|
||
home_dir = os.path.normpath(home_dir)
|
||
if not prefix_path.startswith(prefix):
|
||
logger.warn('Path not in prefix %r %r', prefix_path, prefix)
|
||
return
|
||
return prefix_path.replace(prefix, home_dir, 1)
|
||
|
||
|
||
def install_python(home_dir, lib_dir, inc_dir, bin_dir, site_packages, clear):
|
||
"""Install just the base environment, no distutils patches etc"""
|
||
if sys.executable.startswith(bin_dir):
|
||
print('Please use the *system* python to run this script')
|
||
return
|
||
|
||
if clear:
|
||
rmtree(lib_dir)
|
||
## FIXME: why not delete it?
|
||
## Maybe it should delete everything with #!/path/to/venv/python in it
|
||
logger.notify('Not deleting %s', bin_dir)
|
||
|
||
if hasattr(sys, 'real_prefix'):
|
||
logger.notify('Using real prefix %r' % sys.real_prefix)
|
||
prefix = sys.real_prefix
|
||
elif hasattr(sys, 'base_prefix'):
|
||
logger.notify('Using base prefix %r' % sys.base_prefix)
|
||
prefix = sys.base_prefix
|
||
else:
|
||
prefix = sys.prefix
|
||
mkdir(lib_dir)
|
||
fix_lib64(lib_dir)
|
||
stdlib_dirs = [os.path.dirname(os.__file__)]
|
||
if is_win:
|
||
stdlib_dirs.append(join(os.path.dirname(stdlib_dirs[0]), 'DLLs'))
|
||
elif is_darwin:
|
||
stdlib_dirs.append(join(stdlib_dirs[0], 'site-packages'))
|
||
if hasattr(os, 'symlink'):
|
||
logger.info('Symlinking Python bootstrap modules')
|
||
else:
|
||
logger.info('Copying Python bootstrap modules')
|
||
logger.indent += 2
|
||
try:
|
||
# copy required files...
|
||
for stdlib_dir in stdlib_dirs:
|
||
if not os.path.isdir(stdlib_dir):
|
||
continue
|
||
for fn in os.listdir(stdlib_dir):
|
||
bn = os.path.splitext(fn)[0]
|
||
if fn != 'site-packages' and bn in REQUIRED_FILES:
|
||
copyfile(join(stdlib_dir, fn), join(lib_dir, fn))
|
||
# ...and modules
|
||
copy_required_modules(home_dir)
|
||
finally:
|
||
logger.indent -= 2
|
||
mkdir(join(lib_dir, 'site-packages'))
|
||
import site
|
||
site_filename = site.__file__
|
||
if site_filename.endswith('.pyc'):
|
||
site_filename = site_filename[:-1]
|
||
elif site_filename.endswith('$py.class'):
|
||
site_filename = site_filename.replace('$py.class', '.py')
|
||
site_filename_dst = change_prefix(site_filename, home_dir)
|
||
site_dir = os.path.dirname(site_filename_dst)
|
||
writefile(site_filename_dst, SITE_PY)
|
||
writefile(join(site_dir, 'orig-prefix.txt'), prefix)
|
||
site_packages_filename = join(site_dir, 'no-global-site-packages.txt')
|
||
if not site_packages:
|
||
writefile(site_packages_filename, '')
|
||
|
||
if is_pypy or is_win:
|
||
stdinc_dir = join(prefix, 'include')
|
||
else:
|
||
stdinc_dir = join(prefix, 'include', py_version + abiflags)
|
||
if os.path.exists(stdinc_dir):
|
||
copyfile(stdinc_dir, inc_dir)
|
||
else:
|
||
logger.debug('No include dir %s' % stdinc_dir)
|
||
|
||
platinc_dir = distutils.sysconfig.get_python_inc(plat_specific=1)
|
||
if platinc_dir != stdinc_dir:
|
||
platinc_dest = distutils.sysconfig.get_python_inc(
|
||
plat_specific=1, prefix=home_dir)
|
||
if platinc_dir == platinc_dest:
|
||
# Do platinc_dest manually due to a CPython bug;
|
||
# not http://bugs.python.org/issue3386 but a close cousin
|
||
platinc_dest = subst_path(platinc_dir, prefix, home_dir)
|
||
if platinc_dest:
|
||
# PyPy's stdinc_dir and prefix are relative to the original binary
|
||
# (traversing virtualenvs), whereas the platinc_dir is relative to
|
||
# the inner virtualenv and ignores the prefix argument.
|
||
# This seems more evolved than designed.
|
||
copyfile(platinc_dir, platinc_dest)
|
||
|
||
# pypy never uses exec_prefix, just ignore it
|
||
if sys.exec_prefix != prefix and not is_pypy:
|
||
if is_win:
|
||
exec_dir = join(sys.exec_prefix, 'lib')
|
||
elif is_jython:
|
||
exec_dir = join(sys.exec_prefix, 'Lib')
|
||
else:
|
||
exec_dir = join(sys.exec_prefix, 'lib', py_version)
|
||
for fn in os.listdir(exec_dir):
|
||
copyfile(join(exec_dir, fn), join(lib_dir, fn))
|
||
|
||
if is_jython:
|
||
# Jython has either jython-dev.jar and javalib/ dir, or just
|
||
# jython.jar
|
||
for name in 'jython-dev.jar', 'javalib', 'jython.jar':
|
||
src = join(prefix, name)
|
||
if os.path.exists(src):
|
||
copyfile(src, join(home_dir, name))
|
||
# XXX: registry should always exist after Jython 2.5rc1
|
||
src = join(prefix, 'registry')
|
||
if os.path.exists(src):
|
||
copyfile(src, join(home_dir, 'registry'), symlink=False)
|
||
copyfile(join(prefix, 'cachedir'), join(home_dir, 'cachedir'),
|
||
symlink=False)
|
||
|
||
mkdir(bin_dir)
|
||
py_executable = join(bin_dir, os.path.basename(sys.executable))
|
||
if 'Python.framework' in prefix:
|
||
# OS X framework builds cause validation to break
|
||
# https://github.com/pypa/virtualenv/issues/322
|
||
if os.environ.get('__PYVENV_LAUNCHER__'):
|
||
os.unsetenv('__PYVENV_LAUNCHER__')
|
||
if re.search(r'/Python(?:-32|-64)*$', py_executable):
|
||
# The name of the python executable is not quite what
|
||
# we want, rename it.
|
||
py_executable = os.path.join(
|
||
os.path.dirname(py_executable), 'python')
|
||
|
||
logger.notify('New %s executable in %s', expected_exe, py_executable)
|
||
pcbuild_dir = os.path.dirname(sys.executable)
|
||
pyd_pth = os.path.join(lib_dir, 'site-packages', 'virtualenv_builddir_pyd.pth')
|
||
if is_win and os.path.exists(os.path.join(pcbuild_dir, 'build.bat')):
|
||
logger.notify('Detected python running from build directory %s', pcbuild_dir)
|
||
logger.notify('Writing .pth file linking to build directory for *.pyd files')
|
||
writefile(pyd_pth, pcbuild_dir)
|
||
else:
|
||
pcbuild_dir = None
|
||
if os.path.exists(pyd_pth):
|
||
logger.info('Deleting %s (not Windows env or not build directory python)' % pyd_pth)
|
||
os.unlink(pyd_pth)
|
||
|
||
if sys.executable != py_executable:
|
||
## FIXME: could I just hard link?
|
||
executable = sys.executable
|
||
shutil.copyfile(executable, py_executable)
|
||
make_exe(py_executable)
|
||
if is_win or is_cygwin:
|
||
pythonw = os.path.join(os.path.dirname(sys.executable), 'pythonw.exe')
|
||
if os.path.exists(pythonw):
|
||
logger.info('Also created pythonw.exe')
|
||
shutil.copyfile(pythonw, os.path.join(os.path.dirname(py_executable), 'pythonw.exe'))
|
||
python_d = os.path.join(os.path.dirname(sys.executable), 'python_d.exe')
|
||
python_d_dest = os.path.join(os.path.dirname(py_executable), 'python_d.exe')
|
||
if os.path.exists(python_d):
|
||
logger.info('Also created python_d.exe')
|
||
shutil.copyfile(python_d, python_d_dest)
|
||
elif os.path.exists(python_d_dest):
|
||
logger.info('Removed python_d.exe as it is no longer at the source')
|
||
os.unlink(python_d_dest)
|
||
# we need to copy the DLL to enforce that windows will load the correct one.
|
||
# may not exist if we are cygwin.
|
||
py_executable_dll = 'python%s%s.dll' % (
|
||
sys.version_info[0], sys.version_info[1])
|
||
py_executable_dll_d = 'python%s%s_d.dll' % (
|
||
sys.version_info[0], sys.version_info[1])
|
||
pythondll = os.path.join(os.path.dirname(sys.executable), py_executable_dll)
|
||
pythondll_d = os.path.join(os.path.dirname(sys.executable), py_executable_dll_d)
|
||
pythondll_d_dest = os.path.join(os.path.dirname(py_executable), py_executable_dll_d)
|
||
if os.path.exists(pythondll):
|
||
logger.info('Also created %s' % py_executable_dll)
|
||
shutil.copyfile(pythondll, os.path.join(os.path.dirname(py_executable), py_executable_dll))
|
||
if os.path.exists(pythondll_d):
|
||
logger.info('Also created %s' % py_executable_dll_d)
|
||
shutil.copyfile(pythondll_d, pythondll_d_dest)
|
||
elif os.path.exists(pythondll_d_dest):
|
||
logger.info('Removed %s as the source does not exist' % pythondll_d_dest)
|
||
os.unlink(pythondll_d_dest)
|
||
if is_pypy:
|
||
# make a symlink python --> pypy-c
|
||
python_executable = os.path.join(os.path.dirname(py_executable), 'python')
|
||
if sys.platform in ('win32', 'cygwin'):
|
||
python_executable += '.exe'
|
||
logger.info('Also created executable %s' % python_executable)
|
||
copyfile(py_executable, python_executable)
|
||
|
||
if is_win:
|
||
for name in 'libexpat.dll', 'libpypy.dll', 'libpypy-c.dll', 'libeay32.dll', 'ssleay32.dll', 'sqlite.dll':
|
||
src = join(prefix, name)
|
||
if os.path.exists(src):
|
||
copyfile(src, join(bin_dir, name))
|
||
|
||
if os.path.splitext(os.path.basename(py_executable))[0] != expected_exe:
|
||
secondary_exe = os.path.join(os.path.dirname(py_executable),
|
||
expected_exe)
|
||
py_executable_ext = os.path.splitext(py_executable)[1]
|
||
if py_executable_ext == '.exe':
|
||
# python2.4 gives an extension of '.4' :P
|
||
secondary_exe += py_executable_ext
|
||
if os.path.exists(secondary_exe):
|
||
logger.warn('Not overwriting existing %s script %s (you must use %s)'
|
||
% (expected_exe, secondary_exe, py_executable))
|
||
else:
|
||
logger.notify('Also creating executable in %s' % secondary_exe)
|
||
shutil.copyfile(sys.executable, secondary_exe)
|
||
make_exe(secondary_exe)
|
||
|
||
if '.framework' in prefix:
|
||
if 'Python.framework' in prefix:
|
||
logger.debug('MacOSX Python framework detected')
|
||
# Make sure we use the the embedded interpreter inside
|
||
# the framework, even if sys.executable points to
|
||
# the stub executable in ${sys.prefix}/bin
|
||
# See http://groups.google.com/group/python-virtualenv/
|
||
# browse_thread/thread/17cab2f85da75951
|
||
original_python = os.path.join(
|
||
prefix, 'Resources/Python.app/Contents/MacOS/Python')
|
||
if 'EPD' in prefix:
|
||
logger.debug('EPD framework detected')
|
||
original_python = os.path.join(prefix, 'bin/python')
|
||
shutil.copy(original_python, py_executable)
|
||
|
||
# Copy the framework's dylib into the virtual
|
||
# environment
|
||
virtual_lib = os.path.join(home_dir, '.Python')
|
||
|
||
if os.path.exists(virtual_lib):
|
||
os.unlink(virtual_lib)
|
||
copyfile(
|
||
os.path.join(prefix, 'Python'),
|
||
virtual_lib)
|
Also available in: Unified diff
Fixes #9824: virtualenv doesn't work in the build environment