setup.py

   1 #! /usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3 import sys; assert sys.version_info < (3,), ur"Tahoe-LAFS does not run under Python 3. Please use a version of Python between 2.6 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, 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 import setuptools; setuptools.bootstrap_install_from = egg
  76
  77 from setuptools import setup
  78 from setuptools.command import sdist
  79 from setuptools import Command
  80
  81 trove_classifiers=[
  82     "Development Status :: 5 - Production/Stable",
  83     "Environment :: Console",
  84     "Environment :: Web Environment",
  85     "License :: OSI Approved :: GNU General Public License (GPL)",
  86     "License :: DFSG approved",
  87     "License :: Other/Proprietary License",
  88     "Intended Audience :: Developers",
  89     "Intended Audience :: End Users/Desktop",
  90     "Intended Audience :: System Administrators",
  91     "Operating System :: Microsoft",
  92     "Operating System :: Microsoft :: Windows",
  93     "Operating System :: Microsoft :: Windows :: Windows NT/2000",
  94     "Operating System :: Unix",
  95     "Operating System :: POSIX :: Linux",
  96     "Operating System :: POSIX",
  97     "Operating System :: MacOS :: MacOS X",
  98     "Operating System :: OS Independent",
  99     "Natural Language :: English",
 100     "Programming Language :: C",
 101     "Programming Language :: Python",
 102     "Programming Language :: Python :: 2",
 103     "Programming Language :: Python :: 2.4",
 104     "Programming Language :: Python :: 2.5",
 105     "Programming Language :: Python :: 2.6",
 106     "Programming Language :: Python :: 2.7",
 107     "Topic :: Utilities",
 108     "Topic :: System :: Systems Administration",
 109     "Topic :: System :: Filesystems",
 110     "Topic :: System :: Distributed Computing",
 111     "Topic :: Software Development :: Libraries",
 112     "Topic :: Communications :: Usenet News",
 113     "Topic :: System :: Archiving :: Backup",
 114     "Topic :: System :: Archiving :: Mirroring",
 115     "Topic :: System :: Archiving",
 116     ]
 117
 118
 119 setup_requires = []
 120
 121 # Nevow imports itself when building, which causes Twisted and zope.interface
 122 # to be imported. We need to make sure that the versions of Twisted and
 123 # zope.interface used at build time satisfy Nevow's requirements. If not
 124 # then there are two problems:
 125 #  - prior to Nevow v0.9.33, Nevow didn't declare its dependency on Twisted
 126 #    in a way that enabled setuptools to satisfy that requirement at
 127 #    build time.
 128 #  - some versions of zope.interface, e.g. v3.6.4, are incompatible with
 129 #    Nevow, and we need to avoid those both at build and run-time.
 130 #
 131 # This only matters when compatible versions of Twisted and zope.interface
 132 # are not already installed. Retire this hack when
 133 # https://bugs.launchpad.net/nevow/+bug/812537 has been fixed.
 134 setup_requires += [req for req in install_requires if req.startswith('Twisted') or req.startswith('zope.interface')]
 135
 136 # We no longer have any requirements specific to tests.
 137 tests_require=[]
 138
 139
 140 class Trial(Command):
 141     description = "run trial (use 'bin%stahoe debug trial' for the full set of trial options)" % (os.sep,)
 142     # This is just a subset of the most useful options, for compatibility.
 143     user_options = [ ("no-rterrors", None, "Don't print out tracebacks as they occur."),
 144                      ("rterrors", "e", "Print out tracebacks as they occur (default, so ignored)."),
 145                      ("until-failure", "u", "Repeat a test (specified by -s) until it fails."),
 146                      ("reporter=", None, "The reporter to use for this test run."),
 147                      ("suite=", "s", "Specify the test suite."),
 148                      ("quiet", None, "Don't display version numbers and paths of Tahoe dependencies."),
 149                      ("coverage", "c", "Collect branch coverage information."),
 150                    ]
 151
 152     def initialize_options(self):
 153         self.rterrors = False
 154         self.no_rterrors = False
 155         self.until_failure = False
 156         self.reporter = None
 157         self.suite = "allmydata"
 158         self.quiet = False
 159         self.coverage = False
 160
 161     def finalize_options(self):
 162         pass
 163
 164     def run(self):
 165         args = [sys.executable, os.path.join('bin', 'tahoe')]
 166
 167         if self.coverage:
 168             from errno import ENOENT
 169             coverage_cmd = 'coverage'
 170             try:
 171                 subprocess.call([coverage_cmd, 'help'])
 172             except OSError as e:
 173                 if e.errno != ENOENT:
 174                     raise
 175                 coverage_cmd = 'python-coverage'
 176                 try:
 177                     rc = subprocess.call([coverage_cmd, 'help'])
 178                 except OSError as e:
 179                     if e.errno != ENOENT:
 180                         raise
 181                     print >>sys.stderr
 182                     print >>sys.stderr, "Couldn't find the command 'coverage' nor 'python-coverage'."
 183                     print >>sys.stderr, "coverage can be installed using 'pip install coverage', or on Debian-based systems, 'apt-get install python-coverage'."
 184                     sys.exit(1)
 185
 186             args += ['@' + coverage_cmd, 'run', '--branch', '--source=src/allmydata', '@tahoe']
 187
 188         if not self.quiet:
 189             args.append('--version-and-path')
 190         args += ['debug', 'trial']
 191         if self.rterrors and self.no_rterrors:
 192             raise AssertionError("--rterrors and --no-rterrors conflict.")
 193         if not self.no_rterrors:
 194             args.append('--rterrors')
 195         if self.until_failure:
 196             args.append('--until-failure')
 197         if self.reporter:
 198             args.append('--reporter=' + self.reporter)
 199         if self.suite:
 200             args.append(self.suite)
 201         rc = subprocess.call(args)
 202         sys.exit(rc)
 203
 204
 205 class MakeExecutable(Command):
 206     description = "make the 'bin%stahoe' scripts" % (os.sep,)
 207     user_options = []
 208
 209     def initialize_options(self):
 210         pass
 211     def finalize_options(self):
 212         pass
 213     def run(self):
 214         bin_tahoe_template = os.path.join("bin", "tahoe-script.template")
 215
 216         # tahoe.pyscript is really only necessary for Windows, but we also
 217         # create it on Unix for consistency.
 218         script_names = ["tahoe.pyscript", "tahoe"]
 219
 220         # Create the tahoe script file under the 'bin' directory. This
 221         # file is exactly the same as the 'tahoe-script.template' script
 222         # except that the shebang line is rewritten to use our sys.executable
 223         # for the interpreter.
 224         f = open(bin_tahoe_template, "rU")
 225         script_lines = f.readlines()
 226         f.close()
 227         script_lines[0] = '#!%s\n' % (sys.executable,)
 228         for script_name in script_names:
 229             tahoe_script = os.path.join("bin", script_name)
 230             try:
 231                 os.remove(tahoe_script)
 232             except Exception:
 233                 if os.path.exists(tahoe_script):
 234                    raise
 235             f = open(tahoe_script, "wb")
 236             for line in script_lines:
 237                 f.write(line)
 238             f.close()
 239
 240         # chmod +x
 241         unix_script = os.path.join("bin", "tahoe")
 242         old_mode = stat.S_IMODE(os.stat(unix_script)[stat.ST_MODE])
 243         new_mode = old_mode | (stat.S_IXUSR | stat.S_IRUSR |
 244                                stat.S_IXGRP | stat.S_IRGRP |
 245                                stat.S_IXOTH | stat.S_IROTH )
 246         os.chmod(unix_script, new_mode)
 247
 248         old_tahoe_exe = os.path.join("bin", "tahoe.exe")
 249         try:
 250             os.remove(old_tahoe_exe)
 251         except Exception:
 252             if os.path.exists(old_tahoe_exe):
 253                 raise
 254
 255
 256 GIT_VERSION_BODY = '''
 257 # This _version.py is generated from git metadata by the tahoe setup.py.
 258
 259 __pkgname__ = %(pkgname)r
 260 real_version = %(version)r
 261 full_version = %(full)r
 262 branch = %(branch)r
 263 verstr = %(normalized)r
 264 __version__ = verstr
 265 '''
 266
 267 def run_command(args, cwd=None, verbose=False):
 268     try:
 269         # remember shell=False, so use git.cmd on windows, not just git
 270         p = subprocess.Popen(args, stdout=subprocess.PIPE, cwd=cwd)
 271     except EnvironmentError as e:  # if this gives a SyntaxError, note that Tahoe-LAFS requires Python 2.6+
 272         if verbose:
 273             print("unable to run %s" % args[0])
 274             print(e)
 275         return None
 276     stdout = p.communicate()[0].strip()
 277     if p.returncode != 0:
 278         if verbose:
 279             print("unable to run %s (error)" % args[0])
 280         return None
 281     return stdout
 282
 283
 284 def versions_from_git(tag_prefix, verbose=False):
 285     # this runs 'git' from the directory that contains this file. That either
 286     # means someone ran a setup.py command (and this code is in
 287     # versioneer.py, thus the containing directory is the root of the source
 288     # tree), or someone ran a project-specific entry point (and this code is
 289     # in _version.py, thus the containing directory is somewhere deeper in
 290     # the source tree). This only gets called if the git-archive 'subst'
 291     # variables were *not* expanded, and _version.py hasn't already been
 292     # rewritten with a short version string, meaning we're inside a checked
 293     # out source tree.
 294
 295     # versions_from_git (as copied from python-versioneer) returns strings
 296     # like "1.9.0-25-gb73aba9-dirty", which means we're in a tree with
 297     # uncommited changes (-dirty), the latest checkin is revision b73aba9,
 298     # the most recent tag was 1.9.0, and b73aba9 has 25 commits that weren't
 299     # in 1.9.0 . The narrow-minded NormalizedVersion parser that takes our
 300     # output (meant to enable sorting of version strings) refuses most of
 301     # that. Tahoe uses a function named suggest_normalized_version() that can
 302     # handle "1.9.0.post25", so dumb down our output to match.
 303
 304     try:
 305         source_dir = os.path.dirname(os.path.abspath(__file__))
 306     except NameError:
 307         # some py2exe/bbfreeze/non-CPython implementations don't do __file__
 308         return {} # not always correct
 309     GIT = "git"
 310     if sys.platform == "win32":
 311         GIT = "git.cmd"
 312     stdout = run_command([GIT, "describe", "--tags", "--dirty", "--always"],
 313                          cwd=source_dir)
 314     if stdout is None:
 315         return {}
 316     if not stdout.startswith(tag_prefix):
 317         if verbose:
 318             print("tag '%s' doesn't start with prefix '%s'" % (stdout, tag_prefix))
 319         return {}
 320     version = stdout[len(tag_prefix):]
 321     pieces = version.split("-")
 322     if len(pieces) == 1:
 323         normalized_version = pieces[0]
 324     else:
 325         normalized_version = "%s.post%s" % (pieces[0], pieces[1])
 326
 327     stdout = run_command([GIT, "rev-parse", "HEAD"], cwd=source_dir)
 328     if stdout is None:
 329         return {}
 330     full = stdout.strip()
 331     if version.endswith("-dirty"):
 332         full += "-dirty"
 333         normalized_version += ".dev0"
 334
 335     # Thanks to Jistanidiot at <http://stackoverflow.com/questions/6245570/get-current-branch-name>.
 336     stdout = run_command([GIT, "rev-parse", "--abbrev-ref", "HEAD"], cwd=source_dir)
 337     branch = (stdout or "unknown").strip()
 338
 339     return {"version": version, "normalized": normalized_version, "full": full, "branch": branch}
 340
 341 # setup.cfg has an [aliases] section which runs "update_version" before many
 342 # commands (like "build" and "sdist") that need to know our package version
 343 # ahead of time. If you add different commands (or if we forgot some), you
 344 # may need to add it to setup.cfg and configure it to run update_version
 345 # before your command.
 346
 347 class UpdateVersion(Command):
 348     description = "update _version.py from revision-control metadata"
 349     user_options = []
 350
 351     def initialize_options(self):
 352         pass
 353     def finalize_options(self):
 354         pass
 355     def run(self):
 356         if os.path.isdir(os.path.join(basedir, ".git")):
 357             verstr = self.try_from_git()
 358         else:
 359             print("no version-control data found, leaving _version.py alone")
 360             return
 361         if verstr:
 362             self.distribution.metadata.version = verstr
 363
 364     def try_from_git(self):
 365         versions = versions_from_git("allmydata-tahoe-", verbose=True)
 366         if versions:
 367             fn = 'src/allmydata/_version.py'
 368             f = open(fn, "wb")
 369             f.write(GIT_VERSION_BODY %
 370                     { "pkgname": self.distribution.get_name(),
 371                       "version": versions["version"],
 372                       "normalized": versions["normalized"],
 373                       "full": versions["full"],
 374                       "branch": versions["branch"],
 375                     })
 376             f.close()
 377             print("git-version: wrote '%s' into '%s'" % (versions["version"], fn))
 378         return versions.get("normalized", None)
 379
 380
 381 class MySdist(sdist.sdist):
 382     """ A hook in the sdist command so that we can determine whether this the
 383     tarball should be 'SUMO' or not, i.e. whether or not to include the
 384     external dependency tarballs. Note that we always include
 385     misc/dependencies/* in the tarball; --sumo controls whether tahoe-deps/*
 386     is included as well.
 387     """
 388
 389     user_options = sdist.sdist.user_options + \
 390         [('sumo', 's',
 391           "create a 'sumo' sdist which includes the contents of tahoe-deps/*"),
 392          ]
 393     boolean_options = ['sumo']
 394
 395     def initialize_options(self):
 396         sdist.sdist.initialize_options(self)
 397         self.sumo = False
 398
 399     def make_distribution(self):
 400         # add our extra files to the list just before building the
 401         # tarball/zipfile. We override make_distribution() instead of run()
 402         # because setuptools.command.sdist.run() does not lend itself to
 403         # easy/robust subclassing (the code we need to add goes right smack
 404         # in the middle of a 12-line method). If this were the distutils
 405         # version, we'd override get_file_list().
 406
 407         if self.sumo:
 408             # If '--sumo' was specified, include tahoe-deps/* in the sdist.
 409             # We assume that the user has fetched the tahoe-deps.tar.gz
 410             # tarball and unpacked it already.
 411             self.filelist.extend([os.path.join("tahoe-deps", fn)
 412                                   for fn in os.listdir("tahoe-deps")])
 413             # In addition, we want the tarball/zipfile to have -SUMO in the
 414             # name, and the unpacked directory to have -SUMO too. The easiest
 415             # way to do this is to patch self.distribution and override the
 416             # get_fullname() method. (an alternative is to modify
 417             # self.distribution.metadata.version, but that also affects the
 418             # contents of PKG-INFO).
 419             fullname = self.distribution.get_fullname()
 420             def get_fullname():
 421                 return fullname + "-SUMO"
 422             self.distribution.get_fullname = get_fullname
 423
 424         try:
 425             old_mask = os.umask(int("022", 8))
 426             return sdist.sdist.make_distribution(self)
 427         finally:
 428             os.umask(old_mask)
 429
 430
 431 setup_args = {}
 432 if version:
 433     setup_args["version"] = version
 434
 435 setup(name=APPNAME,
 436       description='secure, decentralized, fault-tolerant filesystem',
 437       long_description=open('README.rst', 'rU').read(),
 438       author='the Tahoe-LAFS project',
 439       author_email='tahoe-dev@tahoe-lafs.org',
 440       url='https://tahoe-lafs.org/',
 441       license='GNU GPL', # see README.rst -- there is an alternative licence
 442       cmdclass={"trial": Trial,
 443                 "make_executable": MakeExecutable,
 444                 "update_version": UpdateVersion,
 445                 "sdist": MySdist,
 446                 },
 447       package_dir = {'':'src'},
 448       packages=['allmydata',
 449                 'allmydata.frontends',
 450                 'allmydata.immutable',
 451                 'allmydata.immutable.downloader',
 452                 'allmydata.introducer',
 453                 'allmydata.mutable',
 454                 'allmydata.scripts',
 455                 'allmydata.storage',
 456                 'allmydata.test',
 457                 'allmydata.util',
 458                 'allmydata.web',
 459                 'allmydata.windows',
 460                 'buildtest'],
 461       classifiers=trove_classifiers,
 462       test_suite="allmydata.test",
 463       install_requires=install_requires,
 464       tests_require=tests_require,
 465       package_data={"allmydata.web": ["*.xhtml",
 466                                       "static/*.js", "static/*.png", "static/*.css",
 467                                       "static/img/*.png",
 468                                       "static/css/*.css",
 469                                       ]
 470                     },
 471       setup_requires=setup_requires,
 472       entry_points = { 'console_scripts': [ 'tahoe = allmydata.scripts.runner:run' ] },
 473       zip_safe=False, # We prefer unzipped for easier access.
 474       **setup_args
 475       )