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