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 requires Twisted to setup, but prior to Nevow v0.9.33, didn't
 139 # declare that requirement in a way that enables setuptools to satisfy
 140 # the requirement before Nevow's setup.py tries to "import twisted".
 141 # This only matters when Twisted is not already installed.
 142 # See http://divmod.org/trac/ticket/2629
 143 # Retire this hack if/when we require Nevow >= 0.9.33.
 144 setup_requires.append('Twisted >= 2.4.0')
 145
 146 # setuptools_darcs is required to produce complete distributions (such
 147 # as with "sdist" or "bdist_egg"), unless there is a
 148 # src/allmydata_tahoe.egg-info/SOURCE.txt file present which contains
 149 # a complete list of files that should be included.
 150
 151 # http://pypi.python.org/pypi/setuptools_darcs
 152
 153 # However, requiring it runs afoul of a bug in Distribute, which was
 154 # shipped in Ubuntu Lucid, so for now you have to manually install it
 155 # before building sdists or eggs:
 156 # 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
 157
 158 # Note that we explicitly inject setuptools_darcs at the beginning of
 159 # this setup.py file, so it is still in effect when building dists
 160 # using this setup.py file even when the following requirement is
 161 # disabled.
 162 if False:
 163     setup_requires.append('setuptools_darcs >= 1.1.0')
 164
 165 # trialcoverage is required if you want the "trial" unit test runner to have a
 166 # "--reporter=bwverbose-coverage" option which produces code-coverage results.
 167 # The required version is 0.3.3, because that is the latest version that only
 168 # depends on a version of pycoverage for which binary packages are available.
 169 if "--reporter=bwverbose-coverage" in sys.argv:
 170     setup_requires.append('trialcoverage >= 0.3.3')
 171
 172 # stdeb is required to produce Debian files with the "sdist_dsc" command.
 173 if "sdist_dsc" in sys.argv:
 174     setup_requires.append('stdeb >= 0.3')
 175
 176 # We no longer have any requirements specific to tests.
 177 tests_require=[]
 178
 179
 180 class ShowSupportLib(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 supportlib # TODO windowsy
 190
 191 class ShowPythonPath(Command):
 192     user_options = []
 193     def initialize_options(self):
 194         pass
 195     def finalize_options(self):
 196         pass
 197     def run(self):
 198         # TODO: --quiet suppresses the 'running show_supportlib' message.
 199         # Find a way to do this all the time.
 200         print "PYTHONPATH=%s" % os.environ.get("PYTHONPATH", '')
 201
 202 class RunWithPythonPath(Command):
 203     description = "Run a subcommand with PYTHONPATH set appropriately"
 204
 205     user_options = [ ("python", "p",
 206                       "Treat command string as arguments to a python executable"),
 207                      ("command=", "c", "Command to be run"),
 208                      ("directory=", "d", "Directory to run the command in"),
 209                      ]
 210     boolean_options = ["python"]
 211
 212     def initialize_options(self):
 213         self.command = None
 214         self.python = False
 215         self.directory = None
 216     def finalize_options(self):
 217         pass
 218     def run(self):
 219         oldpp = os.environ.get("PYTHONPATH", "").split(os.pathsep)
 220         if oldpp == [""]:
 221             # grr silly split() behavior
 222             oldpp = []
 223         os.environ['PYTHONPATH'] = os.pathsep.join(oldpp + [supportlib,])
 224
 225         # We must require the command to be safe to split on
 226         # whitespace, and have --python and --directory to make it
 227         # easier to achieve this.
 228
 229         command = []
 230         if self.python:
 231             command.append(sys.executable)
 232         if self.command:
 233             command.extend(self.command.split())
 234         if not command:
 235             raise RuntimeError("The --command argument is mandatory")
 236         if self.directory:
 237             os.chdir(self.directory)
 238         if self.verbose:
 239             print "command =", " ".join(command)
 240         rc = subprocess.call(command)
 241         sys.exit(rc)
 242
 243 class TestMacDiskImage(Command):
 244     description = "test the Mac disk image in dmg format (unmaintained)"
 245     user_options = []
 246
 247     def initialize_options(self):
 248         pass
 249     def finalize_options(self):
 250         pass
 251     def run(self):
 252         import sys
 253         sys.path.append(os.path.join('misc', 'build_helpers'))
 254         import test_mac_diskimage
 255         return test_mac_diskimage.test_mac_diskimage('Allmydata', version=self.distribution.metadata.version)
 256
 257
 258 class Trial(Command):
 259     description = "run trial (use 'bin%stahoe debug trial' for the full set of trial options)" % (os.sep,)
 260     # This is just a subset of the most useful options, for compatibility.
 261     user_options = [ ("rterrors", "e", "Print out tracebacks as soon as they occur."),
 262                      ("reporter=", None, "The reporter to use for this test run."),
 263                      ("suite=", "s", "Specify the test suite."),
 264                      ("quiet", None, "Don't display version numbers and paths of Tahoe dependencies."),
 265                    ]
 266
 267     def initialize_options(self):
 268         self.rterrors = False
 269         self.reporter = None
 270         self.suite = "allmydata"
 271         self.quiet = False
 272
 273     def finalize_options(self):
 274         pass
 275
 276     def run(self):
 277         args = [sys.executable, os.path.join('bin', 'tahoe')]
 278         if not self.quiet:
 279             args.append('--version-and-path')
 280         args += ['debug', 'trial']
 281         if self.rterrors:
 282             args.append('--rterrors')
 283         if self.reporter:
 284             args.append('--reporter=' + self.reporter)
 285         if self.suite:
 286             args.append(self.suite)
 287         rc = subprocess.call(args)
 288         sys.exit(rc)
 289
 290
 291 class MakeExecutable(Command):
 292     description = "make the 'bin%stahoe' scripts" % (os.sep,)
 293     user_options = []
 294
 295     def initialize_options(self):
 296         pass
 297     def finalize_options(self):
 298         pass
 299     def run(self):
 300         bin_tahoe_template = os.path.join("bin", "tahoe-script.template")
 301
 302         # tahoe.pyscript is really only necessary for Windows, but we also
 303         # create it on Unix for consistency.
 304         script_names = ["tahoe.pyscript", "tahoe"]
 305
 306         # Create the tahoe script file under the 'bin' directory. This
 307         # file is exactly the same as the 'tahoe-script.template' script
 308         # except that the shebang line is rewritten to use our sys.executable
 309         # for the interpreter.
 310         f = open(bin_tahoe_template, "rU")
 311         script_lines = f.readlines()
 312         f.close()
 313         script_lines[0] = '#!%s\n' % (sys.executable,)
 314         for script_name in script_names:
 315             tahoe_script = os.path.join("bin", script_name)
 316             try:
 317                 os.remove(tahoe_script)
 318             except Exception:
 319                 if os.path.exists(tahoe_script):
 320                    raise
 321             f = open(tahoe_script, "wb")
 322             for line in script_lines:
 323                 f.write(line)
 324             f.close()
 325
 326             # chmod +x
 327             old_mode = stat.S_IMODE(os.stat(tahoe_script)[stat.ST_MODE])
 328             new_mode = old_mode | (stat.S_IXUSR | stat.S_IRUSR |
 329                                    stat.S_IXGRP | stat.S_IRGRP |
 330                                    stat.S_IXOTH | stat.S_IROTH )
 331             os.chmod(tahoe_script, new_mode)
 332
 333         old_tahoe_exe = os.path.join("bin", "tahoe.exe")
 334         try:
 335             os.remove(old_tahoe_exe)
 336         except Exception:
 337             if os.path.exists(old_tahoe_exe):
 338                 raise
 339
 340
 341 class MySdist(sdist.sdist):
 342     """ A hook in the sdist command so that we can determine whether this the
 343     tarball should be 'SUMO' or not, i.e. whether or not to include the
 344     external dependency tarballs. Note that we always include
 345     misc/dependencies/* in the tarball; --sumo controls whether tahoe-deps/*
 346     is included as well.
 347     """
 348
 349     user_options = sdist.sdist.user_options + \
 350         [('sumo', 's',
 351           "create a 'sumo' sdist which includes the contents of tahoe-deps/*"),
 352          ]
 353     boolean_options = ['sumo']
 354
 355     def initialize_options(self):
 356         sdist.sdist.initialize_options(self)
 357         self.sumo = False
 358
 359     def make_distribution(self):
 360         # add our extra files to the list just before building the
 361         # tarball/zipfile. We override make_distribution() instead of run()
 362         # because setuptools.command.sdist.run() does not lend itself to
 363         # easy/robust subclassing (the code we need to add goes right smack
 364         # in the middle of a 12-line method). If this were the distutils
 365         # version, we'd override get_file_list().
 366
 367         if self.sumo:
 368             # If '--sumo' was specified, include tahoe-deps/* in the sdist.
 369             # We assume that the user has fetched the tahoe-deps.tar.gz
 370             # tarball and unpacked it already.
 371             self.filelist.extend([os.path.join("tahoe-deps", fn)
 372                                   for fn in os.listdir("tahoe-deps")])
 373             # In addition, we want the tarball/zipfile to have -SUMO in the
 374             # name, and the unpacked directory to have -SUMO too. The easiest
 375             # way to do this is to patch self.distribution and override the
 376             # get_fullname() method. (an alternative is to modify
 377             # self.distribution.metadata.version, but that also affects the
 378             # contents of PKG-INFO).
 379             fullname = self.distribution.get_fullname()
 380             def get_fullname():
 381                 return fullname + "-SUMO"
 382             self.distribution.get_fullname = get_fullname
 383
 384         return sdist.sdist.make_distribution(self)
 385
 386
 387 setup_args = {}
 388 if version:
 389     setup_args["version"] = version
 390
 391 setup(name=APPNAME,
 392       description='secure, decentralized, fault-tolerant filesystem',
 393       long_description=open('README.txt', 'rU').read(),
 394       author='the Tahoe-LAFS project',
 395       author_email='tahoe-dev@tahoe-lafs.org',
 396       url='http://tahoe-lafs.org/',
 397       license='GNU GPL', # see README.txt -- there is an alternative licence
 398       cmdclass={"show_supportlib": ShowSupportLib,
 399                 "show_pythonpath": ShowPythonPath,
 400                 "run_with_pythonpath": RunWithPythonPath,
 401                 "test_mac_diskimage": TestMacDiskImage,
 402                 "trial": Trial,
 403                 "make_executable": MakeExecutable,
 404                 "sdist": MySdist,
 405                 },
 406       package_dir = {'':'src'},
 407       packages=find_packages("src"),
 408       classifiers=trove_classifiers,
 409       test_suite="allmydata.test",
 410       install_requires=install_requires,
 411       tests_require=tests_require,
 412       include_package_data=True,
 413       setup_requires=setup_requires,
 414       entry_points = { 'console_scripts': [ 'tahoe = allmydata.scripts.runner:run' ] },
 415       zip_safe=False, # We prefer unzipped for easier access.
 416       versionfiles=['src/allmydata/_version.py',],
 417       **setup_args
 418       )