#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+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."
-# Allmydata Tahoe -- secure, distributed storage grid
+# Tahoe-LAFS -- secure, distributed storage grid
#
-# Copyright (C) 2008 Allmydata, Inc.
+# Copyright © 2006-2012 The Tahoe-LAFS Software Foundation
#
-# This file is part of tahoe.
+# This file is part of Tahoe-LAFS.
#
-# See the docs/about.html file for licensing information.
+# See the docs/about.rst file for licensing information.
-import os, re, sys, stat, subprocess
+import glob, os, stat, subprocess, re
##### sys.path management
-basedir = os.path.dirname(os.path.abspath(__file__))
-pyver = "python%d.%d" % (sys.version_info[:2])
-if sys.platform == "win32":
- supportlib = os.path.join("support", "Lib", "site-packages")
-else:
- supportlib = os.path.join("support", "lib", pyver, "site-packages")
-supportlib = os.path.join(basedir, supportlib)
-
-def add_tahoe_paths():
- """Modify sys.path and PYTHONPATH to include Tahoe and supporting libraries
-
- The first step towards building Tahoe is to run::
+def pylibdir(prefixdir):
+ pyver = "python%d.%d" % (sys.version_info[:2])
+ if sys.platform == "win32":
+ return os.path.join(prefixdir, "Lib", "site-packages")
+ else:
+ return os.path.join(prefixdir, "lib", pyver, "site-packages")
- python setup.py build_tahoe
+basedir = os.path.dirname(os.path.abspath(__file__))
+supportlib = pylibdir(os.path.join(basedir, "support"))
- which is the equivalent of::
+# locate our version number
- mkdir -p $(BASEDIR)/support/lib/python2.5/site-packages
- (or cygpath equivalent)
- setup.py develop --prefix=$(BASEDIR)/support
+def read_version_py(infname):
+ try:
+ verstrline = open(infname, "rt").read()
+ except EnvironmentError:
+ return None
+ else:
+ VSRE = r"^verstr = ['\"]([^'\"]*)['\"]"
+ mo = re.search(VSRE, verstrline, re.M)
+ if mo:
+ return mo.group(1)
- This installs .eggs for any dependent libraries that aren't already
- available on the system, into support/lib/pythonN.N/site-packages (or
- support/Lib/site-packages on windows). It also adds an .egg-link for
- Tahoe itself into the same directory.
+version = read_version_py("src/allmydata/_version.py")
- We add this directory to os.environ['PYTHONPATH'], so that any child
- processes we spawn will be able to use these packages.
+APPNAME='allmydata-tahoe'
+APPNAMEFILE = os.path.join('src', 'allmydata', '_appname.py')
+APPNAMEFILESTR = "__appname__ = '%s'" % (APPNAME,)
+try:
+ curappnamefilestr = open(APPNAMEFILE, 'rU').read()
+except EnvironmentError:
+ # No file, or unreadable or something, okay then let's try to write one.
+ open(APPNAMEFILE, "w").write(APPNAMEFILESTR)
+else:
+ if curappnamefilestr.strip() != APPNAMEFILESTR:
+ 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))
+ sys.exit(-1)
- When the setuptools site.py sees that supportlib in PYTHONPATH, it scans
- through it for .egg and .egg-link entries, and adds them to sys.path .
- Since python has already processed all the site.py files by the time we
- get here, we perform this same sort of processing ourselves: this makes
- tahoe (and dependency libraries) available to code within setup.py
- itself. This is used by the 'setup.py trial' subcommand, which invokes
- trial directly rather than spawning a subprocess (this is easier than
- locating the 'trial' executable, especially when Twisted was installed as
- a dependent library).
+# setuptools/zetuptoolz looks in __main__.__requires__ for a list of
+# requirements. When running "python setup.py test", __main__ is
+# setup.py, so we put the list here so that the requirements will be
+# available for tests:
- We'll need to add these .eggs to sys.path before importing anything that
- isn't a part of stdlib. All the directories that we add this way are put
- at the start of sys.path, so they will override anything that was present
- on the system (and perhaps found lacking by the setuptools requirements
- expressed in _auto_deps.py).
- """
+# Tahoe's dependencies are managed by the find_links= entry in setup.cfg and
+# the _auto_deps.install_requires list, which is used in the call to setup()
+# below.
+adglobals = {}
+execfile('src/allmydata/_auto_deps.py', adglobals)
+install_requires = adglobals['install_requires']
- extra_syspath_items = []
- extra_pythonpath_items = []
-
- extra_syspath_items.append(supportlib)
- extra_pythonpath_items.append(supportlib)
-
- # Since we use setuptools to populate that directory, there will be a
- # number of .egg and .egg-link entries there. Add all of them to
- # sys.path, since that what the setuptools site.py would do if it
- # encountered them at process start time. Without this step, the rest of
- # this process would be unable to use the packages installed there. We
- # don't need to add them to PYTHONPATH, since the site.py present there
- # will add them when the child process starts up.
-
- if os.path.isdir(supportlib):
- for fn in os.listdir(supportlib):
- if fn.endswith(".egg"):
- extra_syspath_items.append(os.path.join(supportlib, fn))
-
- # We also add our src/ directory, since that's where all the Tahoe code
- # lives. This matches what site.py does when it sees the .egg-link file
- # that is written to the support dir by an invocation of our 'setup.py
- # develop' command.
- extra_syspath_items.append(os.path.join(basedir, "src"))
-
- # and we put an extra copy of everything from PYTHONPATH in front, so
- # that it is possible to override the packages that setuptools downloads
- # with alternate versions, by doing e.g. "PYTHONPATH=foo python setup.py
- # trial"
- oldpp = os.environ.get("PYTHONPATH", "").split(os.pathsep)
- if oldpp == [""]:
- # grr silly split() behavior
- oldpp = []
- extra_syspath_items = oldpp + extra_syspath_items
-
- sys.path = extra_syspath_items + sys.path
-
- # We also provide it to any child processes we spawn, via
- # os.environ["PYTHONPATH"]
- os.environ["PYTHONPATH"] = os.pathsep.join(oldpp + extra_pythonpath_items)
-
-# add_tahoe_paths() must be called before use_setuptools() is called. I don't
-# know why. If it isn't, then a later pkg_resources.requires(pycryptopp) call
-# fails because an old version (in /usr/lib) was already loaded.
-add_tahoe_paths()
+if len(sys.argv) > 1 and sys.argv[1] == '--fakedependency':
+ del sys.argv[1]
+ install_requires += ["fakedependency >= 1.0.0"]
-try:
- from ez_setup import use_setuptools
-except ImportError:
- pass
-else:
- # This invokes our own customized version of ez_setup.py to make sure that
- # setuptools >= v0.6c8 (a.k.a. v0.6-final) is installed.
+__requires__ = install_requires[:]
- # setuptools < v0.6c8 doesn't handle eggs which get installed into the CWD
- # as a result of being transitively depended on in a setup_requires, but
- # then are needed for the installed code to run, i.e. in an
- # install_requires.
- use_setuptools(download_delay=0, min_version="0.6c8")
+egg = os.path.realpath(glob.glob('setuptools-*.egg')[0])
+sys.path.insert(0, egg)
+import setuptools; setuptools.bootstrap_install_from = egg
-from setuptools import find_packages, setup
+from setuptools import setup
from setuptools.command import sdist
-from distutils.core import Command
-
-# Make the dependency-version-requirement, which is used by the Makefile at
-# build-time, also available to the app at runtime:
-import shutil
-shutil.copyfile("_auto_deps.py", os.path.join("src", "allmydata", "_auto_deps.py"))
+from setuptools import Command
trove_classifiers=[
"Development Status :: 5 - Production/Stable",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.4",
"Programming Language :: Python :: 2.5",
+ "Programming Language :: Python :: 2.6",
+ "Programming Language :: Python :: 2.7",
"Topic :: Utilities",
"Topic :: System :: Systems Administration",
"Topic :: System :: Filesystems",
]
-VERSIONFILE = "src/allmydata/_version.py"
-verstr = "unknown"
-try:
- verstrline = open(VERSIONFILE, "rt").read()
-except EnvironmentError:
- pass # Okay, there is no version file.
-else:
- VSRE = r"^verstr = ['\"]([^'\"]*)['\"]"
- mo = re.search(VSRE, verstrline, re.M)
- if mo:
- verstr = mo.group(1)
- else:
- print "unable to find version in %s" % (VERSIONFILE,)
- raise RuntimeError("if %s.py exists, it is required to be well-formed" % (VERSIONFILE,))
+setup_requires = []
-LONG_DESCRIPTION=\
-"""Welcome to the Tahoe project, a secure, decentralized, fault-tolerant
-filesystem. All of the source code is available under a Free Software, Open
-Source licence.
+# Nevow imports itself when building, which causes Twisted and zope.interface
+# to be imported. We need to make sure that the versions of Twisted and
+# zope.interface used at build time satisfy Nevow's requirements. If not
+# then there are two problems:
+# - prior to Nevow v0.9.33, Nevow didn't declare its dependency on Twisted
+# in a way that enabled setuptools to satisfy that requirement at
+# build time.
+# - some versions of zope.interface, e.g. v3.6.4, are incompatible with
+# Nevow, and we need to avoid those both at build and run-time.
+#
+# This only matters when compatible versions of Twisted and zope.interface
+# are not already installed. Retire this hack when
+# https://bugs.launchpad.net/nevow/+bug/812537 has been fixed.
+setup_requires += [req for req in install_requires if req.startswith('Twisted') or req.startswith('zope.interface')]
-This filesystem is encrypted and spread over multiple peers in such a way that
-it remains available even when some of the peers are unavailable,
-malfunctioning, or malicious."""
+# trialcoverage is required if you want the "trial" unit test runner to have a
+# "--reporter=bwverbose-coverage" option which produces code-coverage results.
+# The required version is 0.3.3, because that is the latest version that only
+# depends on a version of pycoverage for which binary packages are available.
+if "--reporter=bwverbose-coverage" in sys.argv:
+ setup_requires.append('trialcoverage >= 0.3.3')
+# stdeb is required to produce Debian files with the "sdist_dsc" command.
+if "sdist_dsc" in sys.argv:
+ setup_requires.append('stdeb >= 0.3')
-# Default setup_requires are pyutil for the Windows installer builder(see
-# misc/sub-ver.py) and Twisted for the tests.
-#setup_requires = ['pyutil >= 1.3.16', 'Twisted >= 2.4.0']
-setup_requires = []
+# We no longer have any requirements specific to tests.
+tests_require=[]
-# darcsver is needed only if you want "./setup.py darcsver" to write a new
-# version stamp in src/allmydata/_version.py, with a version number derived from
-# darcs history.
-# http://pypi.python.org/pypi/darcsver
-if 'darcsver' in sys.argv[1:]:
- setup_requires.append('darcsver >= 1.1.5')
-
-# setuptools_darcs is required to produce complete distributions (such as with
-# "sdist" or "bdist_egg"), unless there is a PKG-INFO file present which shows
-# that this is itself a source distribution.
-# http://pypi.python.org/pypi/setuptools_darcs
-if not os.path.exists('PKG-INFO'):
- setup_requires.append('setuptools_darcs >= 1.1.0')
-
-class ShowSupportLib(Command):
- user_options = []
- def initialize_options(self):
- pass
- def finalize_options(self):
- pass
- def run(self):
- # TODO: --quiet suppresses the 'running show_supportlib' message.
- # Find a way to do this all the time.
- print supportlib # TODO windowsy
-class ShowPythonPath(Command):
- user_options = []
- def initialize_options(self):
- pass
- def finalize_options(self):
- pass
- def run(self):
- # TODO: --quiet suppresses the 'running show_supportlib' message.
- # Find a way to do this all the time.
- print "PYTHONPATH=%s" % os.environ["PYTHONPATH"]
-
-class RunWithPythonPath(Command):
- description = "Run a subcommand with PYTHONPATH set appropriately"
-
- user_options = [ ("python", "p",
- "Treat command string as arguments to a python executable"),
- ("command=", "c", "Command to be run"),
- ("directory=", "d", "Directory to run the command in"),
- ]
- boolean_options = ["python"]
+class Trial(Command):
+ description = "run trial (use 'bin%stahoe debug trial' for the full set of trial options)" % (os.sep,)
+ # This is just a subset of the most useful options, for compatibility.
+ user_options = [ ("no-rterrors", None, "Don't print out tracebacks as they occur."),
+ ("rterrors", "e", "Print out tracebacks as they occur (default, so ignored)."),
+ ("until-failure", "u", "Repeat a test (specified by -s) until it fails."),
+ ("reporter=", None, "The reporter to use for this test run."),
+ ("suite=", "s", "Specify the test suite."),
+ ("quiet", None, "Don't display version numbers and paths of Tahoe dependencies."),
+ ]
def initialize_options(self):
- self.command = None
- self.python = False
- self.directory = None
- def finalize_options(self):
- pass
- def run(self):
- # os.environ['PYTHONPATH'] is already set by add_tahoe_paths, so we
- # just need to exec() their command. We must require the command to
- # be safe to split on whitespace, and have --python and --directory
- # to make it easier to achieve this.
- command = []
- if self.python:
- command.append(sys.executable)
- if self.command:
- command.extend(self.command.split())
- if not command:
- raise RuntimeError("The --command argument is mandatory")
- if self.directory:
- os.chdir(self.directory)
- if self.verbose:
- print "command =", " ".join(command)
- rc = subprocess.call(command)
- sys.exit(rc)
+ self.rterrors = False
+ self.no_rterrors = False
+ self.until_failure = False
+ self.reporter = None
+ self.suite = "allmydata"
+ self.quiet = False
-class CheckAutoDeps(Command):
- user_options = []
- def initialize_options(self):
- pass
def finalize_options(self):
pass
+
def run(self):
- import _auto_deps
- _auto_deps.require_auto_deps()
+ args = [sys.executable, os.path.join('bin', 'tahoe')]
+ if not self.quiet:
+ args.append('--version-and-path')
+ args += ['debug', 'trial']
+ if self.rterrors and self.no_rterrors:
+ raise AssertionError("--rterrors and --no-rterrors conflict.")
+ if not self.no_rterrors:
+ args.append('--rterrors')
+ if self.until_failure:
+ args.append('--until-failure')
+ if self.reporter:
+ args.append('--reporter=' + self.reporter)
+ if self.suite:
+ args.append(self.suite)
+ rc = subprocess.call(args)
+ sys.exit(rc)
-class BuildTahoe(Command):
+class MakeExecutable(Command):
+ description = "make the 'bin%stahoe' scripts" % (os.sep,)
user_options = []
+
def initialize_options(self):
pass
def finalize_options(self):
pass
def run(self):
- # chmod +x bin/tahoe
- bin_tahoe = os.path.join("bin", "tahoe")
- old_mode = stat.S_IMODE(os.stat(bin_tahoe)[stat.ST_MODE])
+ bin_tahoe_template = os.path.join("bin", "tahoe-script.template")
+
+ # tahoe.pyscript is really only necessary for Windows, but we also
+ # create it on Unix for consistency.
+ script_names = ["tahoe.pyscript", "tahoe"]
+
+ # Create the tahoe script file under the 'bin' directory. This
+ # file is exactly the same as the 'tahoe-script.template' script
+ # except that the shebang line is rewritten to use our sys.executable
+ # for the interpreter.
+ f = open(bin_tahoe_template, "rU")
+ script_lines = f.readlines()
+ f.close()
+ script_lines[0] = '#!%s\n' % (sys.executable,)
+ for script_name in script_names:
+ tahoe_script = os.path.join("bin", script_name)
+ try:
+ os.remove(tahoe_script)
+ except Exception:
+ if os.path.exists(tahoe_script):
+ raise
+ f = open(tahoe_script, "wb")
+ for line in script_lines:
+ f.write(line)
+ f.close()
+
+ # chmod +x
+ unix_script = os.path.join("bin", "tahoe")
+ old_mode = stat.S_IMODE(os.stat(unix_script)[stat.ST_MODE])
new_mode = old_mode | (stat.S_IXUSR | stat.S_IRUSR |
stat.S_IXGRP | stat.S_IRGRP |
stat.S_IXOTH | stat.S_IROTH )
- os.chmod(bin_tahoe, new_mode)
-
- # 'setup.py develop --prefix SUPPORT' will complain if SUPPORTLIB is
- # not on PYTHONPATH, because it thinks you are installing to a place
- # that will not be searched at runtime (which is true, except that we
- # add SUPPORTLIB to PYTHONPATH to run tests, etc). So set up
- # PYTHONPATH now, then spawn a 'setup.py develop' command. Also, we
- # have to create the directory ourselves.
- if not os.path.isdir(supportlib):
- os.makedirs(supportlib)
-
- command = [sys.executable, "setup.py", "develop", "--prefix", "support"]
- if sys.platform == "linux2":
- # workaround for tahoe #229 / setuptools #17, on debian
- command.extend(["--site-dirs", "/var/lib/python-support/" + pyver])
- elif sys.platform == "darwin":
- # this probably only applies to leopard 10.5, possibly only 10.5.5
- sd = "/System/Library/Frameworks/Python.framework/Versions/2.5/Extras/lib/python"
- command.extend(["--site-dirs", sd])
- print "Command:", " ".join(command)
- rc = subprocess.call(command)
- if rc < 0:
- print >>sys.stderr, "'setup.py develop' terminated by signal", -rc
- sys.exit(1)
- elif rc > 0:
- print >>sys.stderr, "'setup.py develop' exited with rc", rc
- sys.exit(rc)
-
-class Trial(Command):
- # Unlike 'build' and 'bdist_egg', the 'trial' subcommand cannot be run in
- # conjunction with other subcommands.
-
- # The '-a' argument is split on whitespace and passed into trial. (the
- # distutils parser does not give subcommands access to the rest of
- # sys.argv, so unfortunately we cannot just do something like:
- # setup.py trial --reporter=text allmydata.test.test_util
-
- # Examples:
- # setup.py trial # run all tests
- # setup.py trial -a allmydata.test.test_util # run some tests
- # setup.py trial -a '--reporter=text allmydata.test.test_util' #other args
-
- description = "Run unit tests via trial"
+ os.chmod(unix_script, new_mode)
+
+ old_tahoe_exe = os.path.join("bin", "tahoe.exe")
+ try:
+ os.remove(old_tahoe_exe)
+ except Exception:
+ if os.path.exists(old_tahoe_exe):
+ raise
+
+
+GIT_VERSION_BODY = '''
+# This _version.py is generated from git metadata by the tahoe setup.py.
+
+__pkgname__ = "%(pkgname)s"
+real_version = "%(version)s"
+full_version = "%(full)s"
+verstr = "%(normalized)s"
+__version__ = verstr
+'''
+
+def run_command(args, cwd=None, verbose=False):
+ try:
+ # remember shell=False, so use git.cmd on windows, not just git
+ p = subprocess.Popen(args, stdout=subprocess.PIPE, cwd=cwd)
+ except EnvironmentError as e: # if this gives a SyntaxError, note that Tahoe-LAFS requires Python 2.6+
+ if verbose:
+ print("unable to run %s" % args[0])
+ print(e)
+ return None
+ stdout = p.communicate()[0].strip()
+ if p.returncode != 0:
+ if verbose:
+ print("unable to run %s (error)" % args[0])
+ return None
+ return stdout
+
+
+def versions_from_git(tag_prefix, verbose=False):
+ # this runs 'git' from the directory that contains this file. That either
+ # means someone ran a setup.py command (and this code is in
+ # versioneer.py, thus the containing directory is the root of the source
+ # tree), or someone ran a project-specific entry point (and this code is
+ # in _version.py, thus the containing directory is somewhere deeper in
+ # the source tree). This only gets called if the git-archive 'subst'
+ # variables were *not* expanded, and _version.py hasn't already been
+ # rewritten with a short version string, meaning we're inside a checked
+ # out source tree.
+
+ # versions_from_git (as copied from python-versioneer) returns strings
+ # like "1.9.0-25-gb73aba9-dirty", which means we're in a tree with
+ # uncommited changes (-dirty), the latest checkin is revision b73aba9,
+ # the most recent tag was 1.9.0, and b73aba9 has 25 commits that weren't
+ # in 1.9.0 . The narrow-minded NormalizedVersion parser that takes our
+ # output (meant to enable sorting of version strings) refuses most of
+ # that. Tahoe uses a function named suggest_normalized_version() that can
+ # handle "1.9.0.post25", so dumb down our output to match.
+
+ try:
+ source_dir = os.path.dirname(os.path.abspath(__file__))
+ except NameError:
+ # some py2exe/bbfreeze/non-CPython implementations don't do __file__
+ return {} # not always correct
+ GIT = "git"
+ if sys.platform == "win32":
+ GIT = "git.cmd"
+ stdout = run_command([GIT, "describe", "--tags", "--dirty", "--always"],
+ cwd=source_dir)
+ if stdout is None:
+ return {}
+ if not stdout.startswith(tag_prefix):
+ if verbose:
+ print("tag '%s' doesn't start with prefix '%s'" % (stdout, tag_prefix))
+ return {}
+ version = stdout[len(tag_prefix):]
+ pieces = version.split("-")
+ if len(pieces) == 1:
+ normalized_version = pieces[0]
+ else:
+ normalized_version = "%s.post%s" % (pieces[0], pieces[1])
+ stdout = run_command([GIT, "rev-parse", "HEAD"], cwd=source_dir)
+ if stdout is None:
+ return {}
+ full = stdout.strip()
+ if version.endswith("-dirty"):
+ full += "-dirty"
+ normalized_version += ".dev0"
+ return {"version": version, "normalized": normalized_version, "full": full}
+
+# setup.cfg has an [aliases] section which runs "update_version" before many
+# commands (like "build" and "sdist") that need to know our package version
+# ahead of time. If you add different commands (or if we forgot some), you
+# may need to add it to setup.cfg and configure it to run update_version
+# before your command.
+
+class UpdateVersion(Command):
+ description = "update _version.py from revision-control metadata"
+ user_options = []
- user_options = [ ("args=", "a", "Argument string to pass to trial: setup.py trial -a allmydata.test.test_util"),
- ]
def initialize_options(self):
- self.args = "allmydata"
+ pass
def finalize_options(self):
pass
-
def run(self):
- # make sure Twisted is available (for trial itself), and both the
- # Tahoe source code and our dependent libraries are available (so
- # that trial has some test code to work with)
-
- from twisted.scripts import trial
-
- args = self.args.strip().split()
-
- # one wrinkle: we want to set the reactor here, because of bug #402
- # (twisted bug #3218). We just jam in a "--reactor poll" at the start
- # of the arglist. This does not permit the reactor to be overridden,
- # unfortunately.
- if sys.platform in ("linux2", "cygwin"):
- # poll on linux2 to avoid #402 problems with select
- # poll on cygwin since selectreactor runs out of fds
- args = ["--reactor", "poll"] + args
-
- # zooko also had os.environ["PYTHONUNBUFFERED"]="1" and
- # args.append("--rterrors")
-
- sys.argv = ["trial"] + args
- if self.verbose > 1:
- print "To run this test directly, use:"
- print "PYTHONPATH=%s %s" % (os.environ["PYTHONPATH"],
- " ".join(sys.argv))
+ if os.path.isdir(os.path.join(basedir, ".git")):
+ verstr = self.try_from_git()
else:
- print "(run setup.py with -vv for trial command-line details)"
- trial.run() # this does sys.exit
- # NEVER REACHED
+ print("no version-control data found, leaving _version.py alone")
+ return
+ if verstr:
+ self.distribution.metadata.version = verstr
+
+ def try_from_git(self):
+ versions = versions_from_git("allmydata-tahoe-", verbose=True)
+ if versions:
+ fn = 'src/allmydata/_version.py'
+ f = open(fn, "wb")
+ f.write(GIT_VERSION_BODY %
+ { "pkgname": self.distribution.get_name(),
+ "version": versions["version"],
+ "normalized": versions["normalized"],
+ "full": versions["full"] })
+ f.close()
+ print("git-version: wrote '%s' into '%s'" % (versions["version"], fn))
+ return versions.get("normalized", None)
+
class MySdist(sdist.sdist):
""" A hook in the sdist command so that we can determine whether this the
return fullname + "-SUMO"
self.distribution.get_fullname = get_fullname
- return sdist.sdist.make_distribution(self)
+ try:
+ old_mask = os.umask(int("022", 8))
+ return sdist.sdist.make_distribution(self)
+ finally:
+ os.umask(old_mask)
-# Tahoe's dependencies are managed by the find_links= entry in setup.cfg and
-# the _auto_deps.install_requires list, which is used in the call to setup()
-# at the end of this file
-from _auto_deps import install_requires
-setup(name='allmydata-tahoe',
- version=verstr,
+setup_args = {}
+if version:
+ setup_args["version"] = version
+
+setup(name=APPNAME,
description='secure, decentralized, fault-tolerant filesystem',
- long_description=LONG_DESCRIPTION,
- author='the allmydata.org Tahoe project',
- author_email='tahoe-dev@allmydata.org',
- url='http://allmydata.org/',
- license='GNU GPL',
- cmdclass={"show_supportlib": ShowSupportLib,
- "show_pythonpath": ShowPythonPath,
- "run_with_pythonpath": RunWithPythonPath,
- "check_auto_deps": CheckAutoDeps,
- "build_tahoe": BuildTahoe,
- "trial": Trial,
+ long_description=open('README.txt', 'rU').read(),
+ author='the Tahoe-LAFS project',
+ author_email='tahoe-dev@tahoe-lafs.org',
+ url='https://tahoe-lafs.org/',
+ license='GNU GPL', # see README.txt -- there is an alternative licence
+ cmdclass={"trial": Trial,
+ "make_executable": MakeExecutable,
+ "update_version": UpdateVersion,
"sdist": MySdist,
},
package_dir = {'':'src'},
- packages=find_packages("src"),
+ packages=['allmydata',
+ 'allmydata.frontends',
+ 'allmydata.immutable',
+ 'allmydata.immutable.downloader',
+ 'allmydata.introducer',
+ 'allmydata.mutable',
+ 'allmydata.scripts',
+ 'allmydata.storage',
+ 'allmydata.test',
+ 'allmydata.util',
+ 'allmydata.web',
+ 'allmydata.web.static',
+ 'allmydata.web.static.css',
+ 'allmydata.windows',
+ 'buildtest'],
classifiers=trove_classifiers,
test_suite="allmydata.test",
install_requires=install_requires,
- include_package_data=True,
+ tests_require=tests_require,
+ package_data={"allmydata.web": ["*.xhtml"],
+ "allmydata.web.static": ["*.js", "*.png", "*.css"],
+ "allmydata.web.static.css": ["*.css"],
+ },
setup_requires=setup_requires,
entry_points = { 'console_scripts': [ 'tahoe = allmydata.scripts.runner:run' ] },
zip_safe=False, # We prefer unzipped for easier access.
+ **setup_args
)
projects / tahoe-lafs / tahoe-lafs.git / blobdiff