setup.py

   1 #! /usr/bin/env python
   2
   3 # Allmydata Tahoe -- secure, distributed storage grid
   4 #
   5 # Copyright (C) 2008 Allmydata, Inc.
   6 #
   7 # This file is part of tahoe.
   8 #
   9 # See the docs/about.html file for licensing information.
  10
  11 import os, re, shutil, stat, subprocess, sys, zipfile
  12
  13 ##### sys.path management
  14
  15 def pylibdir(prefixdir):
  16     pyver = "python%d.%d" % (sys.version_info[:2])
  17     if sys.platform == "win32":
  18         return os.path.join(prefixdir, "Lib", "site-packages")
  19     else:
  20         return os.path.join(prefixdir, "lib", pyver, "site-packages")
  21
  22 basedir = os.path.dirname(os.path.abspath(__file__))
  23 supportlib = pylibdir(os.path.join(basedir, "support"))
  24
  25
  26 for i in range(len(sys.argv)):
  27     arg = sys.argv[i]
  28     prefixdir = None
  29     if arg.startswith("--prefix="):
  30         prefixdir = arg[len("--prefix="):]
  31     if arg == "--prefix":
  32         if len(sys.argv) > i+1:
  33             prefixdir = sys.argv[i+1]
  34
  35     if prefixdir:
  36         libdir = pylibdir(prefixdir)
  37         try:
  38             os.makedirs(libdir)
  39         except EnvironmentError, le:
  40             # Okay, maybe the dir was already there.
  41             pass
  42         sys.path.append(libdir)
  43         pp = os.environ.get('PYTHONPATH','').split(os.pathsep)
  44         pp.append(libdir)
  45         os.environ['PYTHONPATH'] = os.pathsep.join(pp)
  46
  47     if arg.startswith("install") or arg.startswith("develop"):
  48         if sys.platform == "linux2":
  49             # workaround for tahoe #229 / setuptools #17, on debian
  50             sys.argv.extend(["--site-dirs", "/var/lib/python-support/python%d.%d" % (sys.version_info[:2])])
  51         elif sys.platform == "darwin":
  52             # this probably only applies to leopard 10.5, possibly only 10.5.5
  53             sd = "/System/Library/Frameworks/Python.framework/Versions/%d.%d/Extras/lib/python" % (sys.version_info[:2])
  54             sys.argv.extend(["--site-dirs", sd])
  55
  56 try:
  57     from ez_setup import use_setuptools
  58 except ImportError:
  59     pass
  60 else:
  61     # This invokes our own customized version of ez_setup.py to make sure that
  62     # setuptools >= v0.6c8 (a.k.a. v0.6-final) is installed.
  63
  64     # setuptools < v0.6c8 doesn't handle eggs which get installed into the CWD
  65     # as a result of being transitively depended on in a setup_requires, but
  66     # then are needed for the installed code to run, i.e. in an
  67     # install_requires.
  68     use_setuptools(download_delay=0, min_version="0.6c10dev")
  69
  70 from setuptools import find_packages, setup
  71 from setuptools.command import sdist
  72 from distutils.core import Command
  73 from pkg_resources import require
  74
  75 # Make the dependency-version-requirement, which is used by the Makefile at
  76 # build-time, also available to the app at runtime:
  77 import shutil
  78 shutil.copyfile("_auto_deps.py", os.path.join("src", "allmydata", "_auto_deps.py"))
  79
  80 trove_classifiers=[
  81     "Development Status :: 5 - Production/Stable",
  82     "Environment :: Console",
  83     "Environment :: Web Environment",
  84     "License :: OSI Approved :: GNU General Public License (GPL)",
  85     "License :: DFSG approved",
  86     "License :: Other/Proprietary License",
  87     "Intended Audience :: Developers",
  88     "Intended Audience :: End Users/Desktop",
  89     "Intended Audience :: System Administrators",
  90     "Operating System :: Microsoft",
  91     "Operating System :: Microsoft :: Windows",
  92     "Operating System :: Microsoft :: Windows :: Windows NT/2000",
  93     "Operating System :: Unix",
  94     "Operating System :: POSIX :: Linux",
  95     "Operating System :: POSIX",
  96     "Operating System :: MacOS :: MacOS X",
  97     "Operating System :: OS Independent",
  98     "Natural Language :: English",
  99     "Programming Language :: C",
 100     "Programming Language :: Python",
 101     "Programming Language :: Python :: 2",
 102     "Programming Language :: Python :: 2.4",
 103     "Programming Language :: Python :: 2.5",
 104     "Topic :: Utilities",
 105     "Topic :: System :: Systems Administration",
 106     "Topic :: System :: Filesystems",
 107     "Topic :: System :: Distributed Computing",
 108     "Topic :: Software Development :: Libraries",
 109     "Topic :: Communications :: Usenet News",
 110     "Topic :: System :: Archiving :: Backup",
 111     "Topic :: System :: Archiving :: Mirroring",
 112     "Topic :: System :: Archiving",
 113     ]
 114
 115
 116 VERSIONFILE = "src/allmydata/_version.py"
 117 verstr = "unknown"
 118 try:
 119     verstrline = open(VERSIONFILE, "rt").read()
 120 except EnvironmentError:
 121     pass # Okay, there is no version file.
 122 else:
 123     VSRE = r"^verstr = ['\"]([^'\"]*)['\"]"
 124     mo = re.search(VSRE, verstrline, re.M)
 125     if mo:
 126         verstr = mo.group(1)
 127     else:
 128         print "unable to find version in %s" % (VERSIONFILE,)
 129         raise RuntimeError("if %s.py exists, it is required to be well-formed" % (VERSIONFILE,))
 130
 131 LONG_DESCRIPTION=\
 132 """Welcome to the Tahoe project, a secure, decentralized, fault-tolerant
 133 filesystem.  All of the source code is available under a Free Software, Open
 134 Source licence.
 135
 136 This filesystem is encrypted and spread over multiple peers in such a way that
 137 it remains available even when some of the peers are unavailable,
 138 malfunctioning, or malicious."""
 139
 140
 141 setup_requires = []
 142
 143 # Nevow requires Twisted to setup, but doesn't declare that requirement in a way that enables
 144 # setuptools to satisfy that requirement before Nevow's setup.py tried to "import twisted".
 145 setup_requires.extend(['Twisted >= 2.4.0', 'setuptools_trial'])
 146
 147 # darcsver is needed only if you want "./setup.py darcsver" to write a new
 148 # version stamp in src/allmydata/_version.py, with a version number derived from
 149 # darcs history.
 150 # http://pypi.python.org/pypi/darcsver
 151 if 'darcsver' in sys.argv[1:]:
 152     setup_requires.append('darcsver >= 1.1.5')
 153
 154 # setuptools_trial is needed only if you want "./setup.py trial" to execute the tests.
 155 # http://pypi.python.org/pypi/setuptools_trial
 156 if 'trial' in sys.argv[1:]:
 157     # Cygwin requires the poll reactor to work at all.  Linux requires the poll reactor to avoid
 158     # bug #402 (twisted bug #3218).  In general, the poll reactor is better than the select
 159     # reactor, but it is not available on all platforms.  According to exarkun on IRC, it is
 160     # available but buggy on some versions of Mac OS X, so just because you can install it
 161     # doesn't mean we want to use it on every platform.
 162     if sys.platform in ("linux2", "cygwin"):
 163         if not [a for a in sys.argv if a.startswith("--reactor")]:
 164             sys.argv.append("--reactor=poll")
 165     setup_requires.append('setuptools_trial >= 0.2')
 166
 167 # setuptools_darcs is required to produce complete distributions (such as with
 168 # "sdist" or "bdist_egg"), unless there is a PKG-INFO file present which shows
 169 # that this is itself a source distribution.
 170 # http://pypi.python.org/pypi/setuptools_darcs
 171 if not os.path.exists('PKG-INFO'):
 172     setup_requires.append('setuptools_darcs >= 1.1.0')
 173
 174 class ShowSupportLib(Command):
 175     user_options = []
 176     def initialize_options(self):
 177         pass
 178     def finalize_options(self):
 179         pass
 180     def run(self):
 181         # TODO: --quiet suppresses the 'running show_supportlib' message.
 182         # Find a way to do this all the time.
 183         print supportlib # TODO windowsy
 184
 185 class ShowPythonPath(Command):
 186     user_options = []
 187     def initialize_options(self):
 188         pass
 189     def finalize_options(self):
 190         pass
 191     def run(self):
 192         # TODO: --quiet suppresses the 'running show_supportlib' message.
 193         # Find a way to do this all the time.
 194         print "PYTHONPATH=%s" % os.environ.get("PYTHONPATH", '')
 195
 196 class RunWithPythonPath(Command):
 197     description = "Run a subcommand with PYTHONPATH set appropriately"
 198
 199     user_options = [ ("python", "p",
 200                       "Treat command string as arguments to a python executable"),
 201                      ("command=", "c", "Command to be run"),
 202                      ("directory=", "d", "Directory to run the command in"),
 203                      ]
 204     boolean_options = ["python"]
 205
 206     def initialize_options(self):
 207         self.command = None
 208         self.python = False
 209         self.directory = None
 210     def finalize_options(self):
 211         pass
 212     def run(self):
 213         oldpp = os.environ.get("PYTHONPATH", "").split(os.pathsep)
 214         if oldpp == [""]:
 215             # grr silly split() behavior
 216             oldpp = []
 217         os.environ['PYTHONPATH'] = os.pathsep.join(oldpp + [supportlib,])
 218
 219         # We must require the command to be safe to split on
 220         # whitespace, and have --python and --directory to make it
 221         # easier to achieve this.
 222
 223         command = []
 224         if self.python:
 225             command.append(sys.executable)
 226         if self.command:
 227             command.extend(self.command.split())
 228         if not command:
 229             raise RuntimeError("The --command argument is mandatory")
 230         if self.directory:
 231             os.chdir(self.directory)
 232         if self.verbose:
 233             print "command =", " ".join(command)
 234         rc = subprocess.call(command)
 235         sys.exit(rc)
 236
 237 class CheckAutoDeps(Command):
 238     user_options = []
 239     def initialize_options(self):
 240         pass
 241     def finalize_options(self):
 242         pass
 243     def run(self):
 244         import _auto_deps
 245         _auto_deps.require_auto_deps()
 246
 247
 248 class BuildTahoe(Command):
 249     user_options = []
 250     def initialize_options(self):
 251         pass
 252     def finalize_options(self):
 253         pass
 254     def run(self):
 255         # chmod +x bin/tahoe
 256         bin_tahoe = os.path.join("bin", "tahoe")
 257         old_mode = stat.S_IMODE(os.stat(bin_tahoe)[stat.ST_MODE])
 258         new_mode = old_mode | (stat.S_IXUSR | stat.S_IRUSR |
 259                                stat.S_IXGRP | stat.S_IRGRP |
 260                                stat.S_IXOTH | stat.S_IROTH )
 261         os.chmod(bin_tahoe, new_mode)
 262
 263         # On Windows, create the 'tahoe-script.py' file based on the 'tahoe'
 264         # executable script under the 'bin' directory so that the tahoe.exe
 265         # will work correctly.  The 'tahoe-script.py' file is exactly the same
 266         # as the 'tahoe' script except that we need to update the she-bang
 267         # line.  The tahoe.exe will be copied from the setuptools egg's cli.exe
 268         # and this will work from a zip-safe and non-zip-safe setuptools egg.
 269         if sys.platform == "win32":
 270             setuptools_egg = require("setuptools")[0].location
 271             if os.path.isfile(setuptools_egg):
 272                 z = zipfile.ZipFile(setuptools_egg, 'r')
 273                 for filename in z.namelist():
 274                     if 'cli.exe' in filename:
 275                         cli_exe = z.read(filename)
 276             else:
 277                 cli_exe = os.path.join(setuptools_egg, 'setuptools', 'cli.exe')
 278             tahoe_exe = os.path.join("bin", "tahoe.exe")
 279             if os.path.isfile(setuptools_egg):
 280                 f = open(tahoe_exe, 'wb')
 281                 f.write(cli_exe)
 282                 f.close()
 283             else:
 284                 shutil.copy(cli_exe, tahoe_exe)
 285             f = open(bin_tahoe, "r")
 286             script_lines = f.readlines()
 287             f.close()
 288             script_lines[0] = "#!%s\n" % sys.executable
 289             tahoe_script = os.path.join("bin", "tahoe-script.py")
 290             f = open(tahoe_script, "w")
 291             for line in script_lines:
 292                 f.write(line)
 293             f.close()
 294
 295         command = [sys.executable, "setup.py", "develop", "--prefix=support"]
 296         print "Command:", " ".join(command)
 297         rc = subprocess.call(command)
 298         if rc < 0:
 299             print >>sys.stderr, "'setup.py develop' terminated by signal", -rc
 300             sys.exit(1)
 301         elif rc > 0:
 302             print >>sys.stderr, "'setup.py develop' exited with rc", rc
 303             sys.exit(rc)
 304
 305 class MySdist(sdist.sdist):
 306     """ A hook in the sdist command so that we can determine whether this the
 307     tarball should be 'SUMO' or not, i.e. whether or not to include the
 308     external dependency tarballs. Note that we always include
 309     misc/dependencies/* in the tarball; --sumo controls whether tahoe-deps/*
 310     is included as well.
 311     """
 312
 313     user_options = sdist.sdist.user_options + \
 314         [('sumo', 's',
 315           "create a 'sumo' sdist which includes the contents of tahoe-deps/*"),
 316          ]
 317     boolean_options = ['sumo']
 318
 319     def initialize_options(self):
 320         sdist.sdist.initialize_options(self)
 321         self.sumo = False
 322
 323     def make_distribution(self):
 324         # add our extra files to the list just before building the
 325         # tarball/zipfile. We override make_distribution() instead of run()
 326         # because setuptools.command.sdist.run() does not lend itself to
 327         # easy/robust subclassing (the code we need to add goes right smack
 328         # in the middle of a 12-line method). If this were the distutils
 329         # version, we'd override get_file_list().
 330
 331         if self.sumo:
 332             # If '--sumo' was specified, include tahoe-deps/* in the sdist.
 333             # We assume that the user has fetched the tahoe-deps.tar.gz
 334             # tarball and unpacked it already.
 335             self.filelist.extend([os.path.join("tahoe-deps", fn)
 336                                   for fn in os.listdir("tahoe-deps")])
 337             # In addition, we want the tarball/zipfile to have -SUMO in the
 338             # name, and the unpacked directory to have -SUMO too. The easiest
 339             # way to do this is to patch self.distribution and override the
 340             # get_fullname() method. (an alternative is to modify
 341             # self.distribution.metadata.version, but that also affects the
 342             # contents of PKG-INFO).
 343             fullname = self.distribution.get_fullname()
 344             def get_fullname():
 345                 return fullname + "-SUMO"
 346             self.distribution.get_fullname = get_fullname
 347
 348         return sdist.sdist.make_distribution(self)
 349
 350 # Tahoe's dependencies are managed by the find_links= entry in setup.cfg and
 351 # the _auto_deps.install_requires list, which is used in the call to setup()
 352 # at the end of this file
 353 from _auto_deps import install_requires
 354
 355 setup(name='allmydata-tahoe',
 356       version=verstr,
 357       description='secure, decentralized, fault-tolerant filesystem',
 358       long_description=LONG_DESCRIPTION,
 359       author='the allmydata.org Tahoe project',
 360       author_email='tahoe-dev@allmydata.org',
 361       url='http://allmydata.org/',
 362       license='GNU GPL',
 363       cmdclass={"show_supportlib": ShowSupportLib,
 364                 "show_pythonpath": ShowPythonPath,
 365                 "run_with_pythonpath": RunWithPythonPath,
 366                 "check_auto_deps": CheckAutoDeps,
 367                 "build_tahoe": BuildTahoe,
 368                 "sdist": MySdist,
 369                 },
 370       package_dir = {'':'src'},
 371       packages=find_packages("src"),
 372       classifiers=trove_classifiers,
 373       test_suite="allmydata.test",
 374       install_requires=install_requires,
 375       include_package_data=True,
 376       setup_requires=setup_requires,
 377       entry_points = { 'console_scripts': [ 'tahoe = allmydata.scripts.runner:run' ] },
 378       zip_safe=False, # We prefer unzipped for easier access.
 379       )