]> git.rkrishnan.org Git - tahoe-lafs/tahoe-lafs.git/blob - setup.py
Include allmydata/web/static/css/*.css files in install.
[tahoe-lafs/tahoe-lafs.git] / 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 # trialcoverage is required if you want the "trial" unit test runner to have a
137 # "--reporter=bwverbose-coverage" option which produces code-coverage results.
138 # The required version is 0.3.3, because that is the latest version that only
139 # depends on a version of pycoverage for which binary packages are available.
140 if "--reporter=bwverbose-coverage" in sys.argv:
141     setup_requires.append('trialcoverage >= 0.3.3')
142
143 # stdeb is required to produce Debian files with the "sdist_dsc" command.
144 if "sdist_dsc" in sys.argv:
145     setup_requires.append('stdeb >= 0.3')
146
147 # We no longer have any requirements specific to tests.
148 tests_require=[]
149
150
151 class Trial(Command):
152     description = "run trial (use 'bin%stahoe debug trial' for the full set of trial options)" % (os.sep,)
153     # This is just a subset of the most useful options, for compatibility.
154     user_options = [ ("no-rterrors", None, "Don't print out tracebacks as they occur."),
155                      ("rterrors", "e", "Print out tracebacks as they occur (default, so ignored)."),
156                      ("until-failure", "u", "Repeat a test (specified by -s) until it fails."),
157                      ("reporter=", None, "The reporter to use for this test run."),
158                      ("suite=", "s", "Specify the test suite."),
159                      ("quiet", None, "Don't display version numbers and paths of Tahoe dependencies."),
160                    ]
161
162     def initialize_options(self):
163         self.rterrors = False
164         self.no_rterrors = False
165         self.until_failure = False
166         self.reporter = None
167         self.suite = "allmydata"
168         self.quiet = False
169
170     def finalize_options(self):
171         pass
172
173     def run(self):
174         args = [sys.executable, os.path.join('bin', 'tahoe')]
175         if not self.quiet:
176             args.append('--version-and-path')
177         args += ['debug', 'trial']
178         if self.rterrors and self.no_rterrors:
179             raise AssertionError("--rterrors and --no-rterrors conflict.")
180         if not self.no_rterrors:
181             args.append('--rterrors')
182         if self.until_failure:
183             args.append('--until-failure')
184         if self.reporter:
185             args.append('--reporter=' + self.reporter)
186         if self.suite:
187             args.append(self.suite)
188         rc = subprocess.call(args)
189         sys.exit(rc)
190
191
192 class MakeExecutable(Command):
193     description = "make the 'bin%stahoe' scripts" % (os.sep,)
194     user_options = []
195
196     def initialize_options(self):
197         pass
198     def finalize_options(self):
199         pass
200     def run(self):
201         bin_tahoe_template = os.path.join("bin", "tahoe-script.template")
202
203         # tahoe.pyscript is really only necessary for Windows, but we also
204         # create it on Unix for consistency.
205         script_names = ["tahoe.pyscript", "tahoe"]
206
207         # Create the tahoe script file under the 'bin' directory. This
208         # file is exactly the same as the 'tahoe-script.template' script
209         # except that the shebang line is rewritten to use our sys.executable
210         # for the interpreter.
211         f = open(bin_tahoe_template, "rU")
212         script_lines = f.readlines()
213         f.close()
214         script_lines[0] = '#!%s\n' % (sys.executable,)
215         for script_name in script_names:
216             tahoe_script = os.path.join("bin", script_name)
217             try:
218                 os.remove(tahoe_script)
219             except Exception:
220                 if os.path.exists(tahoe_script):
221                    raise
222             f = open(tahoe_script, "wb")
223             for line in script_lines:
224                 f.write(line)
225             f.close()
226
227         # chmod +x
228         unix_script = os.path.join("bin", "tahoe")
229         old_mode = stat.S_IMODE(os.stat(unix_script)[stat.ST_MODE])
230         new_mode = old_mode | (stat.S_IXUSR | stat.S_IRUSR |
231                                stat.S_IXGRP | stat.S_IRGRP |
232                                stat.S_IXOTH | stat.S_IROTH )
233         os.chmod(unix_script, new_mode)
234
235         old_tahoe_exe = os.path.join("bin", "tahoe.exe")
236         try:
237             os.remove(old_tahoe_exe)
238         except Exception:
239             if os.path.exists(old_tahoe_exe):
240                 raise
241
242
243 GIT_VERSION_BODY = '''
244 # This _version.py is generated from git metadata by the tahoe setup.py.
245
246 __pkgname__ = "%(pkgname)s"
247 real_version = "%(version)s"
248 full_version = "%(full)s"
249 verstr = "%(normalized)s"
250 __version__ = verstr
251 '''
252
253 def run_command(args, cwd=None, verbose=False):
254     try:
255         # remember shell=False, so use git.cmd on windows, not just git
256         p = subprocess.Popen(args, stdout=subprocess.PIPE, cwd=cwd)
257     except EnvironmentError as e:  # if this gives a SyntaxError, note that Tahoe-LAFS requires Python 2.6+
258         if verbose:
259             print("unable to run %s" % args[0])
260             print(e)
261         return None
262     stdout = p.communicate()[0].strip()
263     if p.returncode != 0:
264         if verbose:
265             print("unable to run %s (error)" % args[0])
266         return None
267     return stdout
268
269
270 def versions_from_git(tag_prefix, verbose=False):
271     # this runs 'git' from the directory that contains this file. That either
272     # means someone ran a setup.py command (and this code is in
273     # versioneer.py, thus the containing directory is the root of the source
274     # tree), or someone ran a project-specific entry point (and this code is
275     # in _version.py, thus the containing directory is somewhere deeper in
276     # the source tree). This only gets called if the git-archive 'subst'
277     # variables were *not* expanded, and _version.py hasn't already been
278     # rewritten with a short version string, meaning we're inside a checked
279     # out source tree.
280
281     # versions_from_git (as copied from python-versioneer) returns strings
282     # like "1.9.0-25-gb73aba9-dirty", which means we're in a tree with
283     # uncommited changes (-dirty), the latest checkin is revision b73aba9,
284     # the most recent tag was 1.9.0, and b73aba9 has 25 commits that weren't
285     # in 1.9.0 . The narrow-minded NormalizedVersion parser that takes our
286     # output (meant to enable sorting of version strings) refuses most of
287     # that. Tahoe uses a function named suggest_normalized_version() that can
288     # handle "1.9.0.post25", so dumb down our output to match.
289
290     try:
291         source_dir = os.path.dirname(os.path.abspath(__file__))
292     except NameError:
293         # some py2exe/bbfreeze/non-CPython implementations don't do __file__
294         return {} # not always correct
295     GIT = "git"
296     if sys.platform == "win32":
297         GIT = "git.cmd"
298     stdout = run_command([GIT, "describe", "--tags", "--dirty", "--always"],
299                          cwd=source_dir)
300     if stdout is None:
301         return {}
302     if not stdout.startswith(tag_prefix):
303         if verbose:
304             print("tag '%s' doesn't start with prefix '%s'" % (stdout, tag_prefix))
305         return {}
306     version = stdout[len(tag_prefix):]
307     pieces = version.split("-")
308     if len(pieces) == 1:
309         normalized_version = pieces[0]
310     else:
311         normalized_version = "%s.post%s" % (pieces[0], pieces[1])
312     stdout = run_command([GIT, "rev-parse", "HEAD"], cwd=source_dir)
313     if stdout is None:
314         return {}
315     full = stdout.strip()
316     if version.endswith("-dirty"):
317         full += "-dirty"
318         normalized_version += ".dev0"
319     return {"version": version, "normalized": normalized_version, "full": full}
320
321 # setup.cfg has an [aliases] section which runs "update_version" before many
322 # commands (like "build" and "sdist") that need to know our package version
323 # ahead of time. If you add different commands (or if we forgot some), you
324 # may need to add it to setup.cfg and configure it to run update_version
325 # before your command.
326
327 class UpdateVersion(Command):
328     description = "update _version.py from revision-control metadata"
329     user_options = []
330
331     def initialize_options(self):
332         pass
333     def finalize_options(self):
334         pass
335     def run(self):
336         if os.path.isdir(os.path.join(basedir, ".git")):
337             verstr = self.try_from_git()
338         else:
339             print("no version-control data found, leaving _version.py alone")
340             return
341         if verstr:
342             self.distribution.metadata.version = verstr
343
344     def try_from_git(self):
345         versions = versions_from_git("allmydata-tahoe-", verbose=True)
346         if versions:
347             fn = 'src/allmydata/_version.py'
348             f = open(fn, "wb")
349             f.write(GIT_VERSION_BODY %
350                     { "pkgname": self.distribution.get_name(),
351                       "version": versions["version"],
352                       "normalized": versions["normalized"],
353                       "full": versions["full"] })
354             f.close()
355             print("git-version: wrote '%s' into '%s'" % (versions["version"], fn))
356         return versions.get("normalized", None)
357
358
359 class MySdist(sdist.sdist):
360     """ A hook in the sdist command so that we can determine whether this the
361     tarball should be 'SUMO' or not, i.e. whether or not to include the
362     external dependency tarballs. Note that we always include
363     misc/dependencies/* in the tarball; --sumo controls whether tahoe-deps/*
364     is included as well.
365     """
366
367     user_options = sdist.sdist.user_options + \
368         [('sumo', 's',
369           "create a 'sumo' sdist which includes the contents of tahoe-deps/*"),
370          ]
371     boolean_options = ['sumo']
372
373     def initialize_options(self):
374         sdist.sdist.initialize_options(self)
375         self.sumo = False
376
377     def make_distribution(self):
378         # add our extra files to the list just before building the
379         # tarball/zipfile. We override make_distribution() instead of run()
380         # because setuptools.command.sdist.run() does not lend itself to
381         # easy/robust subclassing (the code we need to add goes right smack
382         # in the middle of a 12-line method). If this were the distutils
383         # version, we'd override get_file_list().
384
385         if self.sumo:
386             # If '--sumo' was specified, include tahoe-deps/* in the sdist.
387             # We assume that the user has fetched the tahoe-deps.tar.gz
388             # tarball and unpacked it already.
389             self.filelist.extend([os.path.join("tahoe-deps", fn)
390                                   for fn in os.listdir("tahoe-deps")])
391             # In addition, we want the tarball/zipfile to have -SUMO in the
392             # name, and the unpacked directory to have -SUMO too. The easiest
393             # way to do this is to patch self.distribution and override the
394             # get_fullname() method. (an alternative is to modify
395             # self.distribution.metadata.version, but that also affects the
396             # contents of PKG-INFO).
397             fullname = self.distribution.get_fullname()
398             def get_fullname():
399                 return fullname + "-SUMO"
400             self.distribution.get_fullname = get_fullname
401
402         try:
403             old_mask = os.umask(int("022", 8))
404             return sdist.sdist.make_distribution(self)
405         finally:
406             os.umask(old_mask)
407
408
409 setup_args = {}
410 if version:
411     setup_args["version"] = version
412
413 setup(name=APPNAME,
414       description='secure, decentralized, fault-tolerant filesystem',
415       long_description=open('README.txt', 'rU').read(),
416       author='the Tahoe-LAFS project',
417       author_email='tahoe-dev@tahoe-lafs.org',
418       url='https://tahoe-lafs.org/',
419       license='GNU GPL', # see README.txt -- there is an alternative licence
420       cmdclass={"trial": Trial,
421                 "make_executable": MakeExecutable,
422                 "update_version": UpdateVersion,
423                 "sdist": MySdist,
424                 },
425       package_dir = {'':'src'},
426       packages=['allmydata',
427                 'allmydata.frontends',
428                 'allmydata.immutable',
429                 'allmydata.immutable.downloader',
430                 'allmydata.introducer',
431                 'allmydata.mutable',
432                 'allmydata.scripts',
433                 'allmydata.storage',
434                 'allmydata.test',
435                 'allmydata.util',
436                 'allmydata.web',
437                 'allmydata.web.static',
438                 'allmydata.web.static.css',
439                 'allmydata.windows',
440                 'buildtest'],
441       classifiers=trove_classifiers,
442       test_suite="allmydata.test",
443       install_requires=install_requires,
444       tests_require=tests_require,
445       package_data={"allmydata.web": ["*.xhtml"],
446                     "allmydata.web.static": ["*.js", "*.png", "*.css"],
447                     "allmydata.web.static.css": ["*.css"],
448                     },
449       setup_requires=setup_requires,
450       entry_points = { 'console_scripts': [ 'tahoe = allmydata.scripts.runner:run' ] },
451       zip_safe=False, # We prefer unzipped for easier access.
452       **setup_args
453       )