setup.py

   1 #! /usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3 u"Tahoe-LAFS does not run under Python 3. Please use a version of Python between 2.4.4 and 2.7.x inclusive."
   4
   5 # Tahoe-LAFS -- secure, distributed storage grid
   6 #
   7 # Copyright © 2006-2012 The Tahoe-LAFS Software Foundation
   8 #
   9 # This file is part of Tahoe-LAFS.
  10 #
  11 # See the docs/about.rst file for licensing information.
  12
  13 import glob, os, stat, subprocess, sys, re
  14
  15 ##### sys.path management
  16
  17 def pylibdir(prefixdir):
  18     pyver = "python%d.%d" % (sys.version_info[:2])
  19     if sys.platform == "win32":
  20         return os.path.join(prefixdir, "Lib", "site-packages")
  21     else:
  22         return os.path.join(prefixdir, "lib", pyver, "site-packages")
  23
  24 basedir = os.path.dirname(os.path.abspath(__file__))
  25 supportlib = pylibdir(os.path.join(basedir, "support"))
  26
  27 # locate our version number
  28
  29 def read_version_py(infname):
  30     try:
  31         verstrline = open(infname, "rt").read()
  32     except EnvironmentError:
  33         return None
  34     else:
  35         VSRE = r"^verstr = ['\"]([^'\"]*)['\"]"
  36         mo = re.search(VSRE, verstrline, re.M)
  37         if mo:
  38             return mo.group(1)
  39
  40 version = read_version_py("src/allmydata/_version.py")
  41
  42 APPNAME='allmydata-tahoe'
  43 APPNAMEFILE = os.path.join('src', 'allmydata', '_appname.py')
  44 APPNAMEFILESTR = "__appname__ = '%s'" % (APPNAME,)
  45 try:
  46     curappnamefilestr = open(APPNAMEFILE, 'rU').read()
  47 except EnvironmentError:
  48     # No file, or unreadable or something, okay then let's try to write one.
  49     open(APPNAMEFILE, "w").write(APPNAMEFILESTR)
  50 else:
  51     if curappnamefilestr.strip() != APPNAMEFILESTR:
  52         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)
  53         sys.exit(-1)
  54
  55 # setuptools/zetuptoolz looks in __main__.__requires__ for a list of
  56 # requirements. When running "python setup.py test", __main__ is
  57 # setup.py, so we put the list here so that the requirements will be
  58 # available for tests:
  59
  60 # Tahoe's dependencies are managed by the find_links= entry in setup.cfg and
  61 # the _auto_deps.install_requires list, which is used in the call to setup()
  62 # below.
  63 adglobals = {}
  64 execfile('src/allmydata/_auto_deps.py', adglobals)
  65 install_requires = adglobals['install_requires']
  66
  67 if len(sys.argv) > 1 and sys.argv[1] == '--fakedependency':
  68     del sys.argv[1]
  69     install_requires += ["fakedependency >= 1.0.0"]
  70
  71 __requires__ = install_requires[:]
  72
  73 egg = os.path.realpath(glob.glob('setuptools-*.egg')[0])
  74 sys.path.insert(0, egg)
  75 egg = os.path.realpath(glob.glob('darcsver-*.egg')[0])
  76 sys.path.insert(0, egg)
  77 import setuptools; setuptools.bootstrap_install_from = egg
  78
  79 from setuptools import setup
  80 from setuptools.command import sdist
  81 from setuptools import Command
  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     "Programming Language :: Python :: 2.7",
 109     "Topic :: Utilities",
 110     "Topic :: System :: Systems Administration",
 111     "Topic :: System :: Filesystems",
 112     "Topic :: System :: Distributed Computing",
 113     "Topic :: Software Development :: Libraries",
 114     "Topic :: Communications :: Usenet News",
 115     "Topic :: System :: Archiving :: Backup",
 116     "Topic :: System :: Archiving :: Mirroring",
 117     "Topic :: System :: Archiving",
 118     ]
 119
 120
 121 setup_requires = []
 122
 123 # The darcsver command from the darcsver plugin is needed to initialize the
 124 # distribution's .version attribute correctly. (It does this either by
 125 # examining darcs history, or if that fails by reading the
 126 # src/allmydata/_version.py file). darcsver will also write a new version
 127 # stamp in src/allmydata/_version.py, with a version number derived from
 128 # darcs history. Note that the setup.cfg file has an "[aliases]" section
 129 # which enumerates commands that you might run and specifies that it will run
 130 # darcsver before each one. If you add different commands (or if I forgot
 131 # some that are already in use), you may need to add it to setup.cfg and
 132 # configure it to run darcsver before your command, if you want the version
 133 # number to be correct when that command runs.
 134 # http://pypi.python.org/pypi/darcsver
 135 setup_requires.append('darcsver >= 1.7.2')
 136
 137 # Nevow imports itself when building, which causes Twisted and zope.interface
 138 # to be imported. We need to make sure that the versions of Twisted and
 139 # zope.interface used at build time satisfy Nevow's requirements. If not
 140 # then there are two problems:
 141 #  - prior to Nevow v0.9.33, Nevow didn't declare its dependency on Twisted
 142 #    in a way that enabled setuptools to satisfy that requirement at
 143 #    build time.
 144 #  - some versions of zope.interface, e.g. v3.6.4, are incompatible with
 145 #    Nevow, and we need to avoid those both at build and run-time.
 146 #
 147 # This only matters when compatible versions of Twisted and zope.interface
 148 # are not already installed. Retire this hack when
 149 # https://bugs.launchpad.net/nevow/+bug/812537 has been fixed.
 150 setup_requires += [req for req in install_requires if req.startswith('Twisted') or req.startswith('zope.interface')]
 151
 152 # trialcoverage is required if you want the "trial" unit test runner to have a
 153 # "--reporter=bwverbose-coverage" option which produces code-coverage results.
 154 # The required version is 0.3.3, because that is the latest version that only
 155 # depends on a version of pycoverage for which binary packages are available.
 156 if "--reporter=bwverbose-coverage" in sys.argv:
 157     setup_requires.append('trialcoverage >= 0.3.3')
 158
 159 # stdeb is required to produce Debian files with the "sdist_dsc" command.
 160 if "sdist_dsc" in sys.argv:
 161     setup_requires.append('stdeb >= 0.3')
 162
 163 # We no longer have any requirements specific to tests.
 164 tests_require=[]
 165
 166
 167 class Trial(Command):
 168     description = "run trial (use 'bin%stahoe debug trial' for the full set of trial options)" % (os.sep,)
 169     # This is just a subset of the most useful options, for compatibility.
 170     user_options = [ ("no-rterrors", None, "Don't print out tracebacks as they occur."),
 171                      ("until-failure", "u", "Repeat a test (specified by -s) until it fails."),
 172                      ("reporter=", None, "The reporter to use for this test run."),
 173                      ("suite=", "s", "Specify the test suite."),
 174                      ("quiet", None, "Don't display version numbers and paths of Tahoe dependencies."),
 175                    ]
 176
 177     def initialize_options(self):
 178         self.no_rterrors = False
 179         self.until_failure = False
 180         self.reporter = None
 181         self.suite = "allmydata"
 182         self.quiet = False
 183
 184     def finalize_options(self):
 185         pass
 186
 187     def run(self):
 188         args = [sys.executable, os.path.join('bin', 'tahoe')]
 189         if not self.quiet:
 190             args.append('--version-and-path')
 191         args += ['debug', 'trial']
 192         if not self.no_rterrors:
 193             args.append('--rterrors')
 194         if self.until_failure:
 195             args.append('--until-failure')
 196         if self.reporter:
 197             args.append('--reporter=' + self.reporter)
 198         if self.suite:
 199             args.append(self.suite)
 200         rc = subprocess.call(args)
 201         sys.exit(rc)
 202
 203
 204 class MakeExecutable(Command):
 205     description = "make the 'bin%stahoe' scripts" % (os.sep,)
 206     user_options = []
 207
 208     def initialize_options(self):
 209         pass
 210     def finalize_options(self):
 211         pass
 212     def run(self):
 213         bin_tahoe_template = os.path.join("bin", "tahoe-script.template")
 214
 215         # tahoe.pyscript is really only necessary for Windows, but we also
 216         # create it on Unix for consistency.
 217         script_names = ["tahoe.pyscript", "tahoe"]
 218
 219         # Create the tahoe script file under the 'bin' directory. This
 220         # file is exactly the same as the 'tahoe-script.template' script
 221         # except that the shebang line is rewritten to use our sys.executable
 222         # for the interpreter.
 223         f = open(bin_tahoe_template, "rU")
 224         script_lines = f.readlines()
 225         f.close()
 226         script_lines[0] = '#!%s\n' % (sys.executable,)
 227         for script_name in script_names:
 228             tahoe_script = os.path.join("bin", script_name)
 229             try:
 230                 os.remove(tahoe_script)
 231             except Exception:
 232                 if os.path.exists(tahoe_script):
 233                    raise
 234             f = open(tahoe_script, "wb")
 235             for line in script_lines:
 236                 f.write(line)
 237             f.close()
 238
 239         # chmod +x
 240         unix_script = os.path.join("bin", "tahoe")
 241         old_mode = stat.S_IMODE(os.stat(unix_script)[stat.ST_MODE])
 242         new_mode = old_mode | (stat.S_IXUSR | stat.S_IRUSR |
 243                                stat.S_IXGRP | stat.S_IRGRP |
 244                                stat.S_IXOTH | stat.S_IROTH )
 245         os.chmod(unix_script, new_mode)
 246
 247         old_tahoe_exe = os.path.join("bin", "tahoe.exe")
 248         try:
 249             os.remove(old_tahoe_exe)
 250         except Exception:
 251             if os.path.exists(old_tahoe_exe):
 252                 raise
 253
 254
 255 DARCS_VERSION_BODY = '''
 256 # This _version.py is generated from darcs metadata by the tahoe setup.py
 257 # and the "darcsver" package.
 258
 259 __pkgname__ = "%(pkgname)s"
 260 verstr = "%(pkgversion)s"
 261 __version__ = verstr
 262 '''
 263
 264 GIT_VERSION_BODY = '''
 265 # This _version.py is generated from git metadata by the tahoe setup.py.
 266
 267 __pkgname__ = "%(pkgname)s"
 268 real_version = "%(version)s"
 269 full_version = "%(full)s"
 270 verstr = "%(normalized)s"
 271 __version__ = verstr
 272 '''
 273
 274 def run_command(args, cwd=None, verbose=False):
 275     try:
 276         # remember shell=False, so use git.cmd on windows, not just git
 277         p = subprocess.Popen(args, stdout=subprocess.PIPE, cwd=cwd)
 278     except EnvironmentError, e:
 279         if verbose:
 280             print "unable to run %s" % args[0]
 281             print e
 282         return None
 283     stdout = p.communicate()[0].strip()
 284     if p.returncode != 0:
 285         if verbose:
 286             print "unable to run %s (error)" % args[0]
 287         return None
 288     return stdout
 289
 290
 291 def versions_from_git(tag_prefix, verbose=False):
 292     # this runs 'git' from the directory that contains this file. That either
 293     # means someone ran a setup.py command (and this code is in
 294     # versioneer.py, thus the containing directory is the root of the source
 295     # tree), or someone ran a project-specific entry point (and this code is
 296     # in _version.py, thus the containing directory is somewhere deeper in
 297     # the source tree). This only gets called if the git-archive 'subst'
 298     # variables were *not* expanded, and _version.py hasn't already been
 299     # rewritten with a short version string, meaning we're inside a checked
 300     # out source tree.
 301
 302     # versions_from_git (as copied from python-versioneer) returns strings
 303     # like "1.9.0-25-gb73aba9-dirty", which means we're in a tree with
 304     # uncommited changes (-dirty), the latest checkin is revision b73aba9,
 305     # the most recent tag was 1.9.0, and b73aba9 has 25 commits that weren't
 306     # in 1.9.0 . The narrow-minded NormalizedVersion parser that takes our
 307     # output (meant to enable sorting of version strings) refuses most of
 308     # that. Tahoe uses a function named suggest_normalized_version() that can
 309     # handle "1.9.0.post25", so dumb down our output to match.
 310
 311     try:
 312         source_dir = os.path.dirname(os.path.abspath(__file__))
 313     except NameError:
 314         # some py2exe/bbfreeze/non-CPython implementations don't do __file__
 315         return {} # not always correct
 316     GIT = "git"
 317     if sys.platform == "win32":
 318         GIT = "git.cmd"
 319     stdout = run_command([GIT, "describe", "--tags", "--dirty", "--always"],
 320                          cwd=source_dir)
 321     if stdout is None:
 322         return {}
 323     if not stdout.startswith(tag_prefix):
 324         if verbose:
 325             print "tag '%s' doesn't start with prefix '%s'" % (stdout, tag_prefix)
 326         return {}
 327     version = stdout[len(tag_prefix):]
 328     pieces = version.split("-")
 329     if len(pieces) == 1:
 330         normalized_version = pieces[0]
 331     else:
 332         normalized_version = "%s.post%s" % (pieces[0], pieces[1])
 333     stdout = run_command([GIT, "rev-parse", "HEAD"], cwd=source_dir)
 334     if stdout is None:
 335         return {}
 336     full = stdout.strip()
 337     if version.endswith("-dirty"):
 338         full += "-dirty"
 339         normalized_version += ".dev0"
 340     return {"version": version, "normalized": normalized_version, "full": full}
 341
 342
 343 class UpdateVersion(Command):
 344     description = "update _version.py from revision-control metadata"
 345     user_options = []
 346
 347     def initialize_options(self):
 348         pass
 349     def finalize_options(self):
 350         pass
 351     def run(self):
 352         target = self.distribution.versionfiles[0]
 353         if os.path.isdir(os.path.join(basedir, "_darcs")):
 354             verstr = self.try_from_darcs(target)
 355         elif os.path.isdir(os.path.join(basedir, ".git")):
 356             verstr = self.try_from_git(target)
 357         else:
 358             print "no version-control data found, leaving _version.py alone"
 359             return
 360         if verstr:
 361             self.distribution.metadata.version = verstr
 362
 363     def try_from_darcs(self, target):
 364         from darcsver.darcsvermodule import update
 365         (rc, verstr) = update(pkgname=self.distribution.get_name(),
 366                               verfilename=self.distribution.versionfiles,
 367                               revision_number=True,
 368                               version_body=DARCS_VERSION_BODY)
 369         if rc == 0:
 370             return verstr
 371
 372     def try_from_git(self, target):
 373         versions = versions_from_git("allmydata-tahoe-", verbose=True)
 374         if versions:
 375             for fn in self.distribution.versionfiles:
 376                 f = open(fn, "wb")
 377                 f.write(GIT_VERSION_BODY %
 378                         { "pkgname": self.distribution.get_name(),
 379                           "version": versions["version"],
 380                           "normalized": versions["normalized"],
 381                           "full": versions["full"] })
 382                 f.close()
 383                 print "git-version: wrote '%s' into '%s'" % (versions["version"], fn)
 384         return versions.get("normalized", None)
 385
 386
 387 class MySdist(sdist.sdist):
 388     """ A hook in the sdist command so that we can determine whether this the
 389     tarball should be 'SUMO' or not, i.e. whether or not to include the
 390     external dependency tarballs. Note that we always include
 391     misc/dependencies/* in the tarball; --sumo controls whether tahoe-deps/*
 392     is included as well.
 393     """
 394
 395     user_options = sdist.sdist.user_options + \
 396         [('sumo', 's',
 397           "create a 'sumo' sdist which includes the contents of tahoe-deps/*"),
 398          ]
 399     boolean_options = ['sumo']
 400
 401     def initialize_options(self):
 402         sdist.sdist.initialize_options(self)
 403         self.sumo = False
 404
 405     def make_distribution(self):
 406         # add our extra files to the list just before building the
 407         # tarball/zipfile. We override make_distribution() instead of run()
 408         # because setuptools.command.sdist.run() does not lend itself to
 409         # easy/robust subclassing (the code we need to add goes right smack
 410         # in the middle of a 12-line method). If this were the distutils
 411         # version, we'd override get_file_list().
 412
 413         if self.sumo:
 414             # If '--sumo' was specified, include tahoe-deps/* in the sdist.
 415             # We assume that the user has fetched the tahoe-deps.tar.gz
 416             # tarball and unpacked it already.
 417             self.filelist.extend([os.path.join("tahoe-deps", fn)
 418                                   for fn in os.listdir("tahoe-deps")])
 419             # In addition, we want the tarball/zipfile to have -SUMO in the
 420             # name, and the unpacked directory to have -SUMO too. The easiest
 421             # way to do this is to patch self.distribution and override the
 422             # get_fullname() method. (an alternative is to modify
 423             # self.distribution.metadata.version, but that also affects the
 424             # contents of PKG-INFO).
 425             fullname = self.distribution.get_fullname()
 426             def get_fullname():
 427                 return fullname + "-SUMO"
 428             self.distribution.get_fullname = get_fullname
 429
 430         try:
 431             old_mask = os.umask(int("022", 8))
 432             return sdist.sdist.make_distribution(self)
 433         finally:
 434             os.umask(old_mask)
 435
 436
 437 setup_args = {}
 438 if version:
 439     setup_args["version"] = version
 440
 441 setup(name=APPNAME,
 442       description='secure, decentralized, fault-tolerant filesystem',
 443       long_description=open('README.txt', 'rU').read(),
 444       author='the Tahoe-LAFS project',
 445       author_email='tahoe-dev@tahoe-lafs.org',
 446       url='https://tahoe-lafs.org/',
 447       license='GNU GPL', # see README.txt -- there is an alternative licence
 448       cmdclass={"trial": Trial,
 449                 "make_executable": MakeExecutable,
 450                 "update_version": UpdateVersion,
 451                 "sdist": MySdist,
 452                 },
 453       package_dir = {'':'src'},
 454       packages=['allmydata',
 455                 'allmydata.frontends',
 456                 'allmydata.immutable',
 457                 'allmydata.immutable.downloader',
 458                 'allmydata.introducer',
 459                 'allmydata.mutable',
 460                 'allmydata.scripts',
 461                 'allmydata.storage',
 462                 'allmydata.test',
 463                 'allmydata.util',
 464                 'allmydata.web',
 465                 'allmydata.web.static',
 466                 'allmydata.windows',
 467                 'buildtest'],
 468       classifiers=trove_classifiers,
 469       test_suite="allmydata.test",
 470       install_requires=install_requires,
 471       tests_require=tests_require,
 472       package_data={"allmydata.web": ["*.xhtml"],
 473                     "allmydata.web.static": ["*.js", "*.png", "*.css"],
 474                     },
 475       setup_requires=setup_requires,
 476       entry_points = { 'console_scripts': [ 'tahoe = allmydata.scripts.runner:run' ] },
 477       zip_safe=False, # We prefer unzipped for easier access.
 478       versionfiles=['src/allmydata/_version.py',],
 479       **setup_args
 480       )