setup.py

   1 #! /usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3
   4 # Tahoe-LAFS -- secure, distributed storage grid
   5 #
   6 # Copyright © 2008-2011 Allmydata, Inc.
   7 #
   8 # This file is part of Tahoe-LAFS.
   9 #
  10 # See the docs/about.rst file for licensing information.
  11
  12 import glob, os, stat, subprocess, sys, re
  13
  14 ##### sys.path management
  15
  16 def pylibdir(prefixdir):
  17     pyver = "python%d.%d" % (sys.version_info[:2])
  18     if sys.platform == "win32":
  19         return os.path.join(prefixdir, "Lib", "site-packages")
  20     else:
  21         return os.path.join(prefixdir, "lib", pyver, "site-packages")
  22
  23 basedir = os.path.dirname(os.path.abspath(__file__))
  24 supportlib = pylibdir(os.path.join(basedir, "support"))
  25
  26 # locate our version number
  27
  28 def read_version_py(infname):
  29     try:
  30         verstrline = open(infname, "rt").read()
  31     except EnvironmentError:
  32         return None
  33     else:
  34         VSRE = r"^verstr = ['\"]([^'\"]*)['\"]"
  35         mo = re.search(VSRE, verstrline, re.M)
  36         if mo:
  37             return mo.group(1)
  38
  39 version = read_version_py("src/allmydata/_version.py")
  40
  41 APPNAME='allmydata-tahoe'
  42 APPNAMEFILE = os.path.join('src', 'allmydata', '_appname.py')
  43 APPNAMEFILESTR = "__appname__ = '%s'" % (APPNAME,)
  44 try:
  45     curappnamefilestr = open(APPNAMEFILE, 'rU').read()
  46 except EnvironmentError:
  47     # No file, or unreadable or something, okay then let's try to write one.
  48     open(APPNAMEFILE, "w").write(APPNAMEFILESTR)
  49 else:
  50     if curappnamefilestr.strip() != APPNAMEFILESTR:
  51         print "Error -- this setup.py file is configured with the 'application name' to be '%s', but there is already a file in place in '%s' which contains the contents '%s'.  If the file is wrong, please remove it and setup.py will regenerate it and write '%s' into it." % (APPNAME, APPNAMEFILE, curappnamefilestr, APPNAMEFILESTR)
  52         sys.exit(-1)
  53
  54 # setuptools/zetuptoolz looks in __main__.__requires__ for a list of
  55 # requirements. When running "python setup.py test", __main__ is
  56 # setup.py, so we put the list here so that the requirements will be
  57 # available for tests:
  58
  59 # Tahoe's dependencies are managed by the find_links= entry in setup.cfg and
  60 # the _auto_deps.install_requires list, which is used in the call to setup()
  61 # below.
  62 adglobals = {}
  63 execfile('src/allmydata/_auto_deps.py', adglobals)
  64 install_requires = adglobals['install_requires']
  65
  66 if len(sys.argv) > 1 and sys.argv[1] == '--fakedependency':
  67     del sys.argv[1]
  68     install_requires += ["fakedependency >= 1.0.0"]
  69
  70 __requires__ = install_requires[:]
  71
  72 egg = os.path.realpath(glob.glob('setuptools-*.egg')[0])
  73 sys.path.insert(0, egg)
  74 egg = os.path.realpath(glob.glob('darcsver-*.egg')[0])
  75 sys.path.insert(0, egg)
  76 egg = os.path.realpath(glob.glob('setuptools_darcs-*.egg')[0])
  77 sys.path.insert(0, egg)
  78 import setuptools; setuptools.bootstrap_install_from = egg
  79
  80 from setuptools import find_packages, setup
  81 from setuptools.command import sdist
  82 from setuptools import Command
  83
  84 trove_classifiers=[
  85     "Development Status :: 5 - Production/Stable",
  86     "Environment :: Console",
  87     "Environment :: Web Environment",
  88     "License :: OSI Approved :: GNU General Public License (GPL)",
  89     "License :: DFSG approved",
  90     "License :: Other/Proprietary License",
  91     "Intended Audience :: Developers",
  92     "Intended Audience :: End Users/Desktop",
  93     "Intended Audience :: System Administrators",
  94     "Operating System :: Microsoft",
  95     "Operating System :: Microsoft :: Windows",
  96     "Operating System :: Microsoft :: Windows :: Windows NT/2000",
  97     "Operating System :: Unix",
  98     "Operating System :: POSIX :: Linux",
  99     "Operating System :: POSIX",
 100     "Operating System :: MacOS :: MacOS X",
 101     "Operating System :: OS Independent",
 102     "Natural Language :: English",
 103     "Programming Language :: C",
 104     "Programming Language :: Python",
 105     "Programming Language :: Python :: 2",
 106     "Programming Language :: Python :: 2.4",
 107     "Programming Language :: Python :: 2.5",
 108     "Programming Language :: Python :: 2.6",
 109     "Programming Language :: Python :: 2.7",
 110     "Topic :: Utilities",
 111     "Topic :: System :: Systems Administration",
 112     "Topic :: System :: Filesystems",
 113     "Topic :: System :: Distributed Computing",
 114     "Topic :: Software Development :: Libraries",
 115     "Topic :: Communications :: Usenet News",
 116     "Topic :: System :: Archiving :: Backup",
 117     "Topic :: System :: Archiving :: Mirroring",
 118     "Topic :: System :: Archiving",
 119     ]
 120
 121
 122 setup_requires = []
 123
 124 # The darcsver command from the darcsver plugin is needed to initialize the
 125 # distribution's .version attribute correctly. (It does this either by
 126 # examining darcs history, or if that fails by reading the
 127 # src/allmydata/_version.py file). darcsver will also write a new version
 128 # stamp in src/allmydata/_version.py, with a version number derived from
 129 # darcs history. Note that the setup.cfg file has an "[aliases]" section
 130 # which enumerates commands that you might run and specifies that it will run
 131 # darcsver before each one. If you add different commands (or if I forgot
 132 # some that are already in use), you may need to add it to setup.cfg and
 133 # configure it to run darcsver before your command, if you want the version
 134 # number to be correct when that command runs.
 135 # http://pypi.python.org/pypi/darcsver
 136 setup_requires.append('darcsver >= 1.7.2')
 137
 138 # Nevow imports itself when building, which causes Twisted and zope.interface
 139 # to be imported. We need to make sure that the versions of Twisted and
 140 # zope.interface used at build time satisfy Nevow's requirements. If not
 141 # then there are two problems:
 142 #  - prior to Nevow v0.9.33, Nevow didn't declare its dependency on Twisted
 143 #    in a way that enabled setuptools to satisfy that requirement at
 144 #    build time.
 145 #  - some versions of zope.interface, e.g. v3.6.4, are incompatible with
 146 #    Nevow, and we need to avoid those both at build and run-time.
 147 #
 148 # This only matters when compatible versions of Twisted and zope.interface
 149 # are not already installed. Retire this hack when
 150 # https://bugs.launchpad.net/nevow/+bug/812537 has been fixed.
 151 setup_requires += [req for req in install_requires if req.startswith('Twisted') or req.startswith('zope.interface')]
 152
 153 # setuptools_darcs is required to produce complete distributions (such
 154 # as with "sdist" or "bdist_egg"), unless there is a
 155 # src/allmydata_tahoe.egg-info/SOURCE.txt file present which contains
 156 # a complete list of files that should be included.
 157
 158 # http://pypi.python.org/pypi/setuptools_darcs
 159
 160 # However, requiring it runs afoul of a bug in Distribute, which was
 161 # shipped in Ubuntu Lucid, so for now you have to manually install it
 162 # before building sdists or eggs:
 163 # http://bitbucket.org/tarek/distribute/issue/55/revision-control-plugin-automatically-installed-as-a-build-dependency-is-not-present-when-another-build-dependency-is-being
 164
 165 # Note that we explicitly inject setuptools_darcs at the beginning of
 166 # this setup.py file, so it is still in effect when building dists
 167 # using this setup.py file even when the following requirement is
 168 # disabled.
 169 if False:
 170     setup_requires.append('setuptools_darcs >= 1.1.0')
 171
 172 # trialcoverage is required if you want the "trial" unit test runner to have a
 173 # "--reporter=bwverbose-coverage" option which produces code-coverage results.
 174 # The required version is 0.3.3, because that is the latest version that only
 175 # depends on a version of pycoverage for which binary packages are available.
 176 if "--reporter=bwverbose-coverage" in sys.argv:
 177     setup_requires.append('trialcoverage >= 0.3.3')
 178
 179 # stdeb is required to produce Debian files with the "sdist_dsc" command.
 180 if "sdist_dsc" in sys.argv:
 181     setup_requires.append('stdeb >= 0.3')
 182
 183 # We no longer have any requirements specific to tests.
 184 tests_require=[]
 185
 186
 187 class ShowSupportLib(Command):
 188     user_options = []
 189     def initialize_options(self):
 190         pass
 191     def finalize_options(self):
 192         pass
 193     def run(self):
 194         # TODO: --quiet suppresses the 'running show_supportlib' message.
 195         # Find a way to do this all the time.
 196         print supportlib # TODO windowsy
 197
 198 class ShowPythonPath(Command):
 199     user_options = []
 200     def initialize_options(self):
 201         pass
 202     def finalize_options(self):
 203         pass
 204     def run(self):
 205         # TODO: --quiet suppresses the 'running show_supportlib' message.
 206         # Find a way to do this all the time.
 207         print "PYTHONPATH=%s" % os.environ.get("PYTHONPATH", '')
 208
 209 class RunWithPythonPath(Command):
 210     description = "Run a subcommand with PYTHONPATH set appropriately"
 211
 212     user_options = [ ("python", "p",
 213                       "Treat command string as arguments to a python executable"),
 214                      ("command=", "c", "Command to be run"),
 215                      ("directory=", "d", "Directory to run the command in"),
 216                      ]
 217     boolean_options = ["python"]
 218
 219     def initialize_options(self):
 220         self.command = None
 221         self.python = False
 222         self.directory = None
 223     def finalize_options(self):
 224         pass
 225     def run(self):
 226         oldpp = os.environ.get("PYTHONPATH", "").split(os.pathsep)
 227         if oldpp == [""]:
 228             # grr silly split() behavior
 229             oldpp = []
 230         os.environ['PYTHONPATH'] = os.pathsep.join(oldpp + [supportlib,])
 231
 232         # We must require the command to be safe to split on
 233         # whitespace, and have --python and --directory to make it
 234         # easier to achieve this.
 235
 236         command = []
 237         if self.python:
 238             command.append(sys.executable)
 239         if self.command:
 240             command.extend(self.command.split())
 241         if not command:
 242             raise RuntimeError("The --command argument is mandatory")
 243         if self.directory:
 244             os.chdir(self.directory)
 245         if self.verbose:
 246             print "command =", " ".join(command)
 247         rc = subprocess.call(command)
 248         sys.exit(rc)
 249
 250 class TestMacDiskImage(Command):
 251     description = "test the Mac disk image in dmg format (unmaintained)"
 252     user_options = []
 253
 254     def initialize_options(self):
 255         pass
 256     def finalize_options(self):
 257         pass
 258     def run(self):
 259         import sys
 260         sys.path.append(os.path.join('misc', 'build_helpers'))
 261         import test_mac_diskimage
 262         return test_mac_diskimage.test_mac_diskimage('Allmydata', version=self.distribution.metadata.version)
 263
 264
 265 class Trial(Command):
 266     description = "run trial (use 'bin%stahoe debug trial' for the full set of trial options)" % (os.sep,)
 267     # This is just a subset of the most useful options, for compatibility.
 268     user_options = [ ("rterrors", "e", "Print out tracebacks as soon as they occur."),
 269                      ("reporter=", None, "The reporter to use for this test run."),
 270                      ("suite=", "s", "Specify the test suite."),
 271                      ("quiet", None, "Don't display version numbers and paths of Tahoe dependencies."),
 272                    ]
 273
 274     def initialize_options(self):
 275         self.rterrors = False
 276         self.reporter = None
 277         self.suite = "allmydata"
 278         self.quiet = False
 279
 280     def finalize_options(self):
 281         pass
 282
 283     def run(self):
 284         args = [sys.executable, os.path.join('bin', 'tahoe')]
 285         if not self.quiet:
 286             args.append('--version-and-path')
 287         args += ['debug', 'trial']
 288         if self.rterrors:
 289             args.append('--rterrors')
 290         if self.reporter:
 291             args.append('--reporter=' + self.reporter)
 292         if self.suite:
 293             args.append(self.suite)
 294         rc = subprocess.call(args)
 295         sys.exit(rc)
 296
 297
 298 class MakeExecutable(Command):
 299     description = "make the 'bin%stahoe' scripts" % (os.sep,)
 300     user_options = []
 301
 302     def initialize_options(self):
 303         pass
 304     def finalize_options(self):
 305         pass
 306     def run(self):
 307         bin_tahoe_template = os.path.join("bin", "tahoe-script.template")
 308
 309         # tahoe.pyscript is really only necessary for Windows, but we also
 310         # create it on Unix for consistency.
 311         script_names = ["tahoe.pyscript", "tahoe"]
 312
 313         # Create the tahoe script file under the 'bin' directory. This
 314         # file is exactly the same as the 'tahoe-script.template' script
 315         # except that the shebang line is rewritten to use our sys.executable
 316         # for the interpreter.
 317         f = open(bin_tahoe_template, "rU")
 318         script_lines = f.readlines()
 319         f.close()
 320         script_lines[0] = '#!%s\n' % (sys.executable,)
 321         for script_name in script_names:
 322             tahoe_script = os.path.join("bin", script_name)
 323             try:
 324                 os.remove(tahoe_script)
 325             except Exception:
 326                 if os.path.exists(tahoe_script):
 327                    raise
 328             f = open(tahoe_script, "wb")
 329             for line in script_lines:
 330                 f.write(line)
 331             f.close()
 332
 333         # chmod +x
 334         unix_script = os.path.join("bin", "tahoe")
 335         old_mode = stat.S_IMODE(os.stat(unix_script)[stat.ST_MODE])
 336         new_mode = old_mode | (stat.S_IXUSR | stat.S_IRUSR |
 337                                stat.S_IXGRP | stat.S_IRGRP |
 338                                stat.S_IXOTH | stat.S_IROTH )
 339         os.chmod(unix_script, new_mode)
 340
 341         old_tahoe_exe = os.path.join("bin", "tahoe.exe")
 342         try:
 343             os.remove(old_tahoe_exe)
 344         except Exception:
 345             if os.path.exists(old_tahoe_exe):
 346                 raise
 347
 348
 349 class MySdist(sdist.sdist):
 350     """ A hook in the sdist command so that we can determine whether this the
 351     tarball should be 'SUMO' or not, i.e. whether or not to include the
 352     external dependency tarballs. Note that we always include
 353     misc/dependencies/* in the tarball; --sumo controls whether tahoe-deps/*
 354     is included as well.
 355     """
 356
 357     user_options = sdist.sdist.user_options + \
 358         [('sumo', 's',
 359           "create a 'sumo' sdist which includes the contents of tahoe-deps/*"),
 360          ]
 361     boolean_options = ['sumo']
 362
 363     def initialize_options(self):
 364         sdist.sdist.initialize_options(self)
 365         self.sumo = False
 366
 367     def make_distribution(self):
 368         # add our extra files to the list just before building the
 369         # tarball/zipfile. We override make_distribution() instead of run()
 370         # because setuptools.command.sdist.run() does not lend itself to
 371         # easy/robust subclassing (the code we need to add goes right smack
 372         # in the middle of a 12-line method). If this were the distutils
 373         # version, we'd override get_file_list().
 374
 375         if self.sumo:
 376             # If '--sumo' was specified, include tahoe-deps/* in the sdist.
 377             # We assume that the user has fetched the tahoe-deps.tar.gz
 378             # tarball and unpacked it already.
 379             self.filelist.extend([os.path.join("tahoe-deps", fn)
 380                                   for fn in os.listdir("tahoe-deps")])
 381             # In addition, we want the tarball/zipfile to have -SUMO in the
 382             # name, and the unpacked directory to have -SUMO too. The easiest
 383             # way to do this is to patch self.distribution and override the
 384             # get_fullname() method. (an alternative is to modify
 385             # self.distribution.metadata.version, but that also affects the
 386             # contents of PKG-INFO).
 387             fullname = self.distribution.get_fullname()
 388             def get_fullname():
 389                 return fullname + "-SUMO"
 390             self.distribution.get_fullname = get_fullname
 391
 392         return sdist.sdist.make_distribution(self)
 393
 394
 395 setup_args = {}
 396 if version:
 397     setup_args["version"] = version
 398
 399 setup(name=APPNAME,
 400       description='secure, decentralized, fault-tolerant filesystem',
 401       long_description=open('README.txt', 'rU').read(),
 402       author='the Tahoe-LAFS project',
 403       author_email='tahoe-dev@tahoe-lafs.org',
 404       url='http://tahoe-lafs.org/',
 405       license='GNU GPL', # see README.txt -- there is an alternative licence
 406       cmdclass={"show_supportlib": ShowSupportLib,
 407                 "show_pythonpath": ShowPythonPath,
 408                 "run_with_pythonpath": RunWithPythonPath,
 409                 "test_mac_diskimage": TestMacDiskImage,
 410                 "trial": Trial,
 411                 "make_executable": MakeExecutable,
 412                 "sdist": MySdist,
 413                 },
 414       package_dir = {'':'src'},
 415       packages=find_packages("src"),
 416       classifiers=trove_classifiers,
 417       test_suite="allmydata.test",
 418       install_requires=install_requires,
 419       tests_require=tests_require,
 420       include_package_data=True,
 421       setup_requires=setup_requires,
 422       entry_points = { 'console_scripts': [ 'tahoe = allmydata.scripts.runner:run' ] },
 423       zip_safe=False, # We prefer unzipped for easier access.
 424       versionfiles=['src/allmydata/_version.py',],
 425       **setup_args
 426       )