wip ownsource, now getting there

[hippotat] / hippotatlib / ownsource.py

# Automatic source code provision (AGPL compliance)

import os
import sys
import fnmatch
import stat
import subprocess

class SourceShipmentPreparer():
  def __init__(s, destdir):
    # caller may modify, and should read after calling generate()
    s.output_name = 'srcbomb.tar.gz'
    # defaults, caller can modify after creation
    s.src_filter = s.src_filter_glob
    s.src_filter_globs = ['/usr/local/*', '!/usr*', '!/etc/*']
    s.src_likeparent = s.src_likeparent_git
    s.cwd = os.getcwd()
    s.find_rune_base = "find -type f -perm -004 \! -path '*/tmp/*'"
    s.excludes = ['*~', '*.bak', '*.tmp', '#*#',
                  '[0-9][0-9][0-9][0-9]-src.cpio']
    s.rune_shell = ['/bin/bash', '-ec']
    s.show_pathnames = True
    s.rune_cpio = r'''
            set -o pipefail
	    (
	     %s
             # ^ by default, is find ... -print0
	    ) | (
	     cpio -Hustar -o --quiet -0 -R 1000:1000 || \
             cpio -Hustar -o --quiet -0
            )
    '''
    s.rune_portmanteau = r'''
            outfile=$1; shift
            rm -f "$outfile"
            GZIP=-9 tar zcf "$outfile" "$@"'
    '''
    s.manifest_name='0000-MANIFEST.txt'
    # private
    s._destdir = destdir
    s._outcounter = 0
    s._manifest = []

  def src_filter_glob(s, src): # default s.src_filter
    for pat in s.src_filter_globs:
      negate = pat.startswith('!')
      if negate: pat = pat[1:]
      if fnmatch.fnmatch(src, pat):
        return not negate
    return negate

  def src_likeparent_git(s, src):
    try:
      os.stat(os.path.join(src, '.git/.'))
    except FileNotFoundError:
      return False
    else:
      return True

  def src_parentfinder(s, src, infol): # callers may monkey-patch away
    for deref in (False,True):
      xinfo = []

      search = src
      if deref:
        search = os.path.realpath(search)

      def ascend():
        nonlocal search
        xinfo.append(os.path.basename(search))
        search = os.path.dirname(search)

      try:
        stab = os.lstat(search)
      except FileNotFoundError:
        return
      if stat.S_ISREG(stab.st_mode):
        ascend()

      while not os.path.ismount(search):
        if s.src_likeparent(search):
          xinfo.reverse()
          if len(xinfo): infol.append('want=' + os.path.join(*xinfo))
          return search

        ascend()

    # no .git found anywhere
    return src

  def src_prenormaliser(s, d, infol): # callers may monkey-patch away
    return os.path.join(s.cwd, os.path.abspath(d))

  def src_find_rune(s, d):
    script = s.find_rune_base
    for excl in s.excludes + [s.output_name, s.manifest_name]:
      assert("'" not in excl)
      script += r" \! -name '%s'" % excl
    script += ' -print0'
    return script

  def new_output_name(s, nametail, infol):
    s._outcounter += 1
    name = '%04d-%s' % (s._outcounter, nametail)
    s._manifest.append((name, ' '.join(infol)))
    return name

  def new_output_fh(s, nametail, infol):
    name = s.new_output_name(nametail, infol)
    return s.open_output_fh(name, 'wb')

  def open_output_fh(s, name, mode):
    return open(os.path.join(s._destdir, name), mode)

  def mk_from_dir(s, d, infol):
    if s.show_pathnames: infol.append(d)
    find_rune = s.src_find_rune(d)
    total_rune = s.rune_cpio % find_rune
    fh = s.new_output_fh('src.cpio', infol)
    subprocess.run(s.rune_shell + [total_rune],
                   cwd=d,
                   stdin=subprocess.DEVNULL,
                   stdout=fh,
                   restore_signals=True,
                   check=True)
    fh.close()

  def mk_from_src(s, d, infol):
    d = s.src_prenormaliser(d, infol)
    if not s.src_filter(d): return
    d = s.src_parentfinder(d, infol)
    s.mk_from_dir(d, infol)

  def mk_from_srcs(s, dirs=sys.path):
    s.mk_from_src(sys.argv[0], ['argv[0]'])
    for d in sys.path:
      s.mk_from_src(d, ['sys.path'])

  def mk_portmanteau(s):
    cmdl = s.rune_shell + [ s.rune_portmanteau, 'x',
                            s.output_name, s.manifest_name ]
    mfh = s.open_output_fh(s.manifest_name,'w')
    for (name, info) in s._manifest:
      cmdl.append(name)
      print('%s\t%s' % (name,info), file=mfh)
    mfh.close()
    subprocess.run(s.rune_shell + cmdl,
                   cwd=s._destdir,
                   stdin=subprocess.DEVNULL,
                   stdout=sys.stderr,
                   restore_signals=True,
                   check=True)

  def generate(s):
    s.mk_from_srcs()
    s.mk_portmanteau()