mdw@git.distorted.org.uk Git - chopwood/blob - agpl.py

   1 ### -*-python-*-
   2 ###
   3 ### GNU Affero General Public License compliance
   4 ###
   5 ### (c) 2013 Mark Wooding
   6 ###
   7
   8 ###----- Licensing notice ---------------------------------------------------
   9 ###
  10 ### This file is part of Chopwood: a password-changing service.
  11 ###
  12 ### Chopwood is free software; you can redistribute it and/or modify
  13 ### it under the terms of the GNU Affero General Public License as
  14 ### published by the Free Software Foundation; either version 3 of the
  15 ### License, or (at your option) any later version.
  16 ###
  17 ### Chopwood is distributed in the hope that it will be useful,
  18 ### but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ### GNU Affero General Public License for more details.
  21 ###
  22 ### You should have received a copy of the GNU Affero General Public
  23 ### License along with Chopwood; if not, see
  24 ### <http://www.gnu.org/licenses/>.
  25
  26 from __future__ import with_statement
  27
  28 import contextlib as CTX
  29 import grp as GR
  30 import os as OS
  31 import pwd as PW
  32 import shlex as SL
  33 import shutil as SH
  34 import subprocess as SUB
  35 import sys as SYS
  36 import tarfile as TAR
  37 import tempfile as TF
  38 import time as T
  39
  40 from cStringIO import StringIO
  41
  42 from auto import PACKAGE, VERSION
  43 import util as U
  44
  45 ###--------------------------------------------------------------------------
  46 ### Initial utilities.
  47
  48 @CTX.contextmanager
  49 def tempdir():
  50   """
  51   Context manager: create and return the name of a temporary directory.
  52
  53   The directory will be deleted automatically on exit from the body.
  54   """
  55   d = TF.mkdtemp()
  56   try: yield d
  57   finally: SH.rmtree(d, ignore_errors = True)
  58
  59 ###--------------------------------------------------------------------------
  60 ### Determining which files to include.
  61
  62 def dirs_to_dump():
  63   """
  64   Return a list of directories containing used Python modules.
  65
  66   Directories under `/usr/' but outside `/usr/local/' are excluded, since
  67   they are assumed to be covered by the AGPL exception for parts of the
  68   operating system.
  69   """
  70
  71   ## Collect a set of directories.
  72   dirs = set()
  73
  74   ## Work through the list of known modules, adding them to the list.
  75   for m in SYS.modules.itervalues():
  76     try: f = m.__file__
  77     except AttributeError: continue
  78     d = OS.path.realpath(OS.path.dirname(f))
  79     if d.startswith('/usr/') and not d.startswith('/usr/local/'): continue
  80     dirs.add(d)
  81
  82   ## Now go through the directories again, and remove any which are wholly
  83   ## included within other entries.
  84   dirs = sorted(dirs)
  85   last = '!'
  86   dump = []
  87   for d in dirs:
  88     if d.startswith(last): continue
  89     dump.append(d)
  90     last = d
  91
  92   ## We're done: return the filtered list.
  93   return dump
  94
  95 ### The `DUMPERS' list consists of (PREDICATE, LISTERS) pairs.  The PREDICATE
  96 ### is a function of one argument -- a directory name -- which returns true
  97 ### if the LISTERS should be used to enumerate that directory.  The LISTERS
  98 ### are a list of functions of one argument -- again, the directory name --
  99 ### which should return an iterable of files within that directory, relative
 100 ### to its top-level.  Lister functions should not return the root directory,
 101 ### because it should obviously only be included once.  Instead, the root is
 102 ### handled separately by `dump_dir'.
 103
 104 def exists_subdir(subdir):
 105   """
 106   Predicate for `DUMPERS': match if the directory has a subdirectory SUBDIR.
 107
 108   This is mainly useful for detecting working trees subject to version
 109   control.
 110   """
 111   return lambda dir: OS.path.isdir(OS.path.join(dir, subdir))
 112
 113 def filez(cmd):
 114   """
 115   Lister for `DUMPERS': generate the null-terminated items output by CMD.
 116
 117   Run CMD, a string containing words with shell-like quoting (expected to be
 118   a literal in the code, so security concerns don't arise) in the directory
 119   of interest, yielding the invidual null-terminated strings which the
 120   command writes to its standard output.
 121   """
 122   def _(dir):
 123
 124     ## Start the command,
 125     kid = SUB.Popen(SL.split(cmd), stdout = SUB.PIPE, cwd = dir)
 126
 127     ## Collect and return the null-terminated items.  Strip off any leading
 128     ## `./' and exclude the root directory because that gets handled
 129     ## separately.
 130     left = ''
 131     while True:
 132
 133       ## Read a new bufferload of stuff.  If there's nothing left then we're
 134       ## done.
 135       buf = kid.stdout.read(16384)
 136       if not buf: break
 137
 138       ## Tack whatever was left over from last time on the front, and carve
 139       ## into null-terminated pieces.
 140       buf = left + buf
 141       i = 0
 142       while True:
 143         z = buf.find('\0', i)
 144         if z < 0: break
 145         f = buf[i:z]
 146         i = z + 1
 147         if f.rstrip('/') == '.': continue
 148         if f.startswith('./'): f = f[2:]
 149         yield f
 150
 151       ## Whatever's left over will be dealt with next time through.
 152       left = buf[i:]
 153
 154     ## Make sure the command actually completed successfully.
 155     if kid.wait():
 156       rc = kid.returncode
 157       raise U.ExpectedError, \
 158           (500, "lister command `%s' failed (%s) in `%s'" % (
 159             cmd,
 160             (rc & 0xff00) and 'rc = %d' % (rc >> 8) or 'signal %d' % rc,
 161             dir))
 162
 163     ## If there's trailing junk left over then we should complain.
 164     if left:
 165       raise U.ExpectedError, \
 166             (500, "trailing junk from `%s' in `%s'" % (cmd, dir))
 167
 168   ## Return the listing function.
 169   return _
 170
 171 ## The list of predicates and listers.
 172 DUMPERS = [
 173   (exists_subdir('.git'), [filez('git ls-files -coz --exclude-standard'),
 174                            filez('find .git -print0')]),
 175   (lambda d: True, [filez('find . ( ! -perm +004 -prune ) -o -print0')])]
 176
 177 ###--------------------------------------------------------------------------
 178 ### Actually dumping files.
 179
 180 def dump_dir(name, dir, dirmap, tf, root):
 181   """
 182   Add the contents of directory DIR to the tarfile TF, under the given NAME.
 183
 184   The ROOT names the toplevel of the tarball (we're not in the business of
 185   making tarbombs here).  The DIRMAP is a list of all of the (DIR, NAME)
 186   pairs being dumped, used for fixing up symbolic links between directories.
 187   """
 188
 189   ## Find an appropriate `DUMPERS' list entry.
 190   for test, listers in DUMPERS:
 191     if test(dir): break
 192   else:
 193     raise U.ExpectedError, (500, "no dumper for `%s'" % dir)
 194
 195   ## Write a tarfile entry for the toplevel.
 196   tf.add(dir, OS.path.join(root, name), recursive = False)
 197
 198   ## Work through all of the listers.
 199   for lister in listers:
 200
 201     ## Work through each file.
 202     for file in lister(dir):
 203       with U.Escape() as skip:
 204         full = OS.path.join(dir, file)
 205         tarname = OS.path.join(root, name, file)
 206
 207         ## Check for symbolic links.  If we find one that points to another
 208         ## directory we're going to dump separately then fiddle it so that it
 209         ## works in the directory tree we're going to make.
 210         if OS.path.islink(full):
 211           dest = OS.path.realpath(full)
 212           for d, local in dirmap:
 213             if dest.startswith(d):
 214               fix = OS.path.relpath(OS.path.join('/', local, dest[len(d):]),
 215                                     OS.path.join('/', name,
 216                                                  OS.path.dirname(file)))
 217               st = OS.stat(full)
 218               ti = tf.gettarinfo(full, tarname)
 219               ti.linkname = fix
 220               tf.addfile(ti)
 221               skip()
 222
 223         ## Nothing special, so just dump the file.  Or whatever it is.
 224         tf.add(full, tarname, recursive = False)
 225
 226 def source(out):
 227   """
 228   Write a tarball for the program's source code to OUT.
 229
 230   This function automatically dumps all of the program's dependencies except
 231   for those covered by the operating-system exemption.
 232   """
 233
 234   ## Make a tarfile writer.  There's an annoying incompatibility to bodge
 235   ## around.
 236   if SYS.version_info >= (2, 6):
 237     tf = TAR.open(fileobj = out, mode = 'w|gz', format = TAR.USTAR_FORMAT)
 238   else:
 239     tf = TAR.open(fileobj = out, mode = 'w|gz')
 240     tf.posix = True
 241
 242   ## First of all, find out what needs to be dumped, and assign names to all
 243   ## of the various directories.
 244   root = '%s-%s' % (PACKAGE, VERSION)
 245   seen = set()
 246   dirmap = []
 247   festout = StringIO()
 248   for dir in dirs_to_dump():
 249     dir = dir.rstrip('/')
 250     base = OS.path.basename(dir)
 251     if base not in seen:
 252       name = base
 253     else:
 254       for i in I.count():
 255         name = '%s.%d' % (base, i)
 256         if name not in seen: break
 257     dirmap.append((dir + '/', name))
 258     festout.write('%s = %s\n' % (name, dir))
 259
 260   ## Write a map of where things were in the filesystem.  This may help a
 261   ## user figure out how to deploy the thing.
 262   fest = festout.getvalue()
 263   ti = TAR.TarInfo(OS.path.join(root, 'MANIFEST'))
 264   ti.size = len(fest)
 265   ti.mtime = T.time()
 266   ti.mode = 0664
 267   ti.type = TAR.REGTYPE
 268   uid = OS.getuid(); ti.uid, ti.uname = uid, PW.getpwuid(uid).pw_name
 269   gid = OS.getgid(); ti.gid, ti.gname = gid, GR.getgrgid(gid).gr_name
 270   tf.addfile(ti, fileobj = StringIO(fest))
 271
 272   ## Now actually dump all of the individual directories.
 273   for dir, name in dirmap:
 274     dump_dir(name, dir, dirmap, tf, root)
 275
 276   ## We're done.
 277   tf.close()
 278
 279 ###----- That's all, folks --------------------------------------------------