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."
5 # Tahoe-LAFS -- secure, distributed storage grid
7 # Copyright © 2006-2012 The Tahoe-LAFS Software Foundation
9 # This file is part of Tahoe-LAFS.
11 # See the docs/about.rst file for licensing information.
13 import glob, os, stat, subprocess, re
15 ##### sys.path management
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")
22 return os.path.join(prefixdir, "lib", pyver, "site-packages")
24 basedir = os.path.dirname(os.path.abspath(__file__))
25 supportlib = pylibdir(os.path.join(basedir, "support"))
27 # locate our version number
29 def read_version_py(infname):
31 verstrline = open(infname, "rt").read()
32 except EnvironmentError:
35 VSRE = r"^verstr = ['\"]([^'\"]*)['\"]"
36 mo = re.search(VSRE, verstrline, re.M)
40 version = read_version_py("src/allmydata/_version.py")
42 APPNAME='allmydata-tahoe'
43 APPNAMEFILE = os.path.join('src', 'allmydata', '_appname.py')
44 APPNAMEFILESTR = "__appname__ = '%s'" % (APPNAME,)
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)
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))
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:
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()
64 execfile('src/allmydata/_auto_deps.py', adglobals)
65 install_requires = adglobals['install_requires']
67 if len(sys.argv) > 1 and sys.argv[1] == '--fakedependency':
69 install_requires += ["fakedependency >= 1.0.0"]
71 __requires__ = install_requires[:]
73 egg = os.path.realpath(glob.glob('setuptools-*.egg')[0])
74 sys.path.insert(0, egg)
75 import setuptools; setuptools.bootstrap_install_from = egg
77 from setuptools import setup
78 from setuptools.command import sdist
79 from setuptools import Command
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",
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
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.
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')]
136 # We no longer have any requirements specific to tests.
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."),
152 def initialize_options(self):
153 self.rterrors = False
154 self.no_rterrors = False
155 self.until_failure = False
157 self.suite = "allmydata"
159 self.coverage = False
161 def finalize_options(self):
165 args = [sys.executable, os.path.join('bin', 'tahoe')]
168 from errno import ENOENT
169 coverage_cmd = 'coverage'
171 subprocess.call([coverage_cmd, 'help'])
173 if e.errno != ENOENT:
175 coverage_cmd = 'python-coverage'
177 rc = subprocess.call([coverage_cmd, 'help'])
179 if e.errno != ENOENT:
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'."
186 args += ['@' + coverage_cmd, 'run', '--branch', '--source=src/allmydata', '@tahoe']
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')
198 args.append('--reporter=' + self.reporter)
200 args.append(self.suite)
201 rc = subprocess.call(args)
205 class MakeExecutable(Command):
206 description = "make the 'bin%stahoe' scripts" % (os.sep,)
209 def initialize_options(self):
211 def finalize_options(self):
214 bin_tahoe_template = os.path.join("bin", "tahoe-script.template")
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"]
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()
227 script_lines[0] = '#!%s\n' % (sys.executable,)
228 for script_name in script_names:
229 tahoe_script = os.path.join("bin", script_name)
231 os.remove(tahoe_script)
233 if os.path.exists(tahoe_script):
235 f = open(tahoe_script, "wb")
236 for line in script_lines:
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)
248 old_tahoe_exe = os.path.join("bin", "tahoe.exe")
250 os.remove(old_tahoe_exe)
252 if os.path.exists(old_tahoe_exe):
256 GIT_VERSION_BODY = '''
257 # This _version.py is generated from git metadata by the tahoe setup.py.
259 __pkgname__ = %(pkgname)r
260 real_version = %(version)r
261 full_version = %(full)r
263 verstr = %(normalized)r
267 def run_command(args, cwd=None, verbose=False):
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+
273 print("unable to run %s" % args[0])
276 stdout = p.communicate()[0].strip()
277 if p.returncode != 0:
279 print("unable to run %s (error)" % args[0])
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
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.
305 source_dir = os.path.dirname(os.path.abspath(__file__))
307 # some py2exe/bbfreeze/non-CPython implementations don't do __file__
308 return {} # not always correct
310 if sys.platform == "win32":
312 stdout = run_command([GIT, "describe", "--tags", "--dirty", "--always"],
316 if not stdout.startswith(tag_prefix):
318 print("tag '%s' doesn't start with prefix '%s'" % (stdout, tag_prefix))
320 version = stdout[len(tag_prefix):]
321 pieces = version.split("-")
323 normalized_version = pieces[0]
325 normalized_version = "%s.post%s" % (pieces[0], pieces[1])
327 stdout = run_command([GIT, "rev-parse", "HEAD"], cwd=source_dir)
330 full = stdout.strip()
331 if version.endswith("-dirty"):
333 normalized_version += ".dev0"
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()
339 return {"version": version, "normalized": normalized_version, "full": full, "branch": branch}
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.
347 class UpdateVersion(Command):
348 description = "update _version.py from revision-control metadata"
351 def initialize_options(self):
353 def finalize_options(self):
356 if os.path.isdir(os.path.join(basedir, ".git")):
357 verstr = self.try_from_git()
359 print("no version-control data found, leaving _version.py alone")
362 self.distribution.metadata.version = verstr
364 def try_from_git(self):
365 versions = versions_from_git("allmydata-tahoe-", verbose=True)
367 fn = 'src/allmydata/_version.py'
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"],
377 print("git-version: wrote '%s' into '%s'" % (versions["version"], fn))
378 return versions.get("normalized", None)
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/*
389 user_options = sdist.sdist.user_options + \
391 "create a 'sumo' sdist which includes the contents of tahoe-deps/*"),
393 boolean_options = ['sumo']
395 def initialize_options(self):
396 sdist.sdist.initialize_options(self)
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().
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()
421 return fullname + "-SUMO"
422 self.distribution.get_fullname = get_fullname
425 old_mask = os.umask(int("022", 8))
426 return sdist.sdist.make_distribution(self)
433 setup_args["version"] = version
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,
447 package_dir = {'':'src'},
448 packages=['allmydata',
449 'allmydata.frontends',
450 'allmydata.immutable',
451 'allmydata.immutable.downloader',
452 'allmydata.introducer',
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",
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.