wip ownsource system stuff

[hippotat.git] / hippotatlib / ownsource.py

diff --git a/hippotatlib/ownsource.py b/hippotatlib/ownsource.py
index be7bdcd620f4349e64a7c1a2e40e8ee8cab128dc..4f1db677aa16fcc6b9ac19c4f4f522f139e99ab0 100644 (file)
--- a/hippotatlib/ownsource.py
+++ b/hippotatlib/ownsource.py
@@ -1,7 +1,10 @@
 # Automatic source code provision (AGPL compliance)
 
+import os
 import sys
 import fnmatch
+import stat
+import subprocess
 
 class SourceShipmentPreparer():
   def __init__(s, destdir):
@@ -12,9 +15,12 @@ class SourceShipmentPreparer():
     s.src_filter_globs = ['/usr/local/*', '!/usr*', '!/etc/*']
     s.src_likeparent = s.src_likeparent_git
     s.cwd = os.getcwd()
-    s.excludes = ['*~', '*.bak', '*.tmp', '#*#']
+    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.rune_cpio = r''''
+    s.show_pathnames = True
+    s.rune_cpio = r'''
             set -o pipefail
            (
             %s
@@ -27,13 +33,14 @@ class SourceShipmentPreparer():
     s.rune_portmanteau = r'''
             outfile=$1; shift
             rm -f "$outfile"
-            GZIP=-9 tar zcf "$outfile" "$@"'
+            GZIP=-1 tar zcf "$outfile" "$@"
     '''
     s.manifest_name='0000-MANIFEST.txt'
     # private
     s._destdir = destdir
-    s._outcounter = 1
+    s._outcounter = 0
     s._manifest = []
+    s._dirmap = { }
 
   def src_filter_glob(s, src): # default s.src_filter
     for pat in s.src_filter_globs:
@@ -45,7 +52,7 @@ class SourceShipmentPreparer():
 
   def src_likeparent_git(s, src):
     try:
-      stat(os.path.join(d, '.git/.'))
+      os.stat(os.path.join(src, '.git/.'))
     except FileNotFoundError:
       return False
     else:
@@ -60,11 +67,12 @@ class SourceShipmentPreparer():
         search = os.path.realpath(search)
 
       def ascend():
+        nonlocal search
         xinfo.append(os.path.basename(search))
         search = os.path.dirname(search)
 
       try:
-        stab = lstat(search)
+        stab = os.lstat(search)
       except FileNotFoundError:
         return
       if stat.S_ISREG(stab.st_mode):
@@ -73,45 +81,58 @@ class SourceShipmentPreparer():
       while not os.path.ismount(search):
         if s.src_likeparent(search):
           xinfo.reverse()
-          infol.append(os.path.join(*xinfo))
+          if len(xinfo): infol.append('want=' + os.path.join(*xinfo))
           return search
 
         ascend()
 
     # no .git found anywhere
-    return d
+    return src
 
-  def src_prenormaliser(s, d): # callers may monkey-patch away
+  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 = 'find -type f -perm +004'
-    for excl in s.excludes:
+    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 manifest_append(s, name, infol):
+    s._manifest.append((name, ' '.join(infol)))
 
   def new_output_name(s, nametail, infol):
-    name = '%04d-%s' % (s._outcounter++, nametail)
-    s._manifest.append((name, infol.join(' '))
+    s._outcounter += 1
+    name = '%04d-%s' % (s._outcounter, nametail)
+    s.manifest_append(name, infol)
     return name
 
   def open_output_fh(s, name, mode):
     return open(os.path.join(s._destdir, name), mode)
 
-  def new_output_fh(s, nametail, infol):
-    name = new_output_name(s, nametail, infol)
-    return open_output_fh(name, 'wb')
+  def mk_from_dir(s, d, infol):
+    try: name = s._dirmap[d]
+    except KeyError: pass
+    else:
+      s.manifest_append(name, infol)
+      return
 
-  def mk_from_dir(s, d):
-    find_rune = s.src_find_rune(s, d)
+    if s.show_pathnames: infol.append(d)
+    find_rune = s.src_find_rune(d)
     total_rune = s.rune_cpio % find_rune
-    fh = new_output_fh('src.cpio')
+
+    name = s.new_output_name('src.cpio', infol)
+    s._dirmap[d] = name
+    fh = s.open_output_fh(name, 'wb')
+
     subprocess.run(s.rune_shell + [total_rune],
-                   cwd=s._destdir,
+                   cwd=d,
                    stdin=subprocess.DEVNULL,
                    stdout=fh,
-                   restore_signals=True)
+                   restore_signals=True,
+                   check=True)
     fh.close()
 
   def mk_from_src(s, d, infol):
@@ -120,25 +141,36 @@ class SourceShipmentPreparer():
     d = s.src_parentfinder(d, infol)
     s.mk_from_dir(d, infol)
 
+  def mk_from_module(s, m, infol):
+    try: file = m.__file__
+    except AttributeError: return
+    infol.append(m.__name__)
+    s.mk_from_src(file, infol)
+    s.manifest_append(None, ['spong',file])
+    #s.report_from_package(file, 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'])
+    for m in sys.modules.values():
+      s.mk_from_module(m, ['sys.modules'])
 
-  def mk_portmanteau(s):]
+  def mk_portmanteau(s):
     cmdl = s.rune_shell + [ s.rune_portmanteau, 'x',
                             s.output_name, s.manifest_name ]
-    mfh = open_output_fh(s.manifest_name,'w')
+    mfh = s.open_output_fh(s.manifest_name,'w')
     for (name, info) in s._manifest:
-      cmdl.append(name)
-      print('%s\t%s\n' % (name,info), file=mfh)
+      if name is not None: cmdl.append(name)
+      print('%s\t%s' % (name,info), file=mfh)
     mfh.close()
-    subprocess.run(s.rune_shell + cmdl,
-                   cmd=s._destdir,
+    subprocess.run(cmdl,
+                   cwd=s._destdir,
                    stdin=subprocess.DEVNULL,
                    stdout=sys.stderr,
-                   restore_signals=True)
+                   restore_signals=True,
+                   check=True)
 
   def generate(s):
-    s.mk_from_srcdirs()
+    s.mk_from_srcs()
     s.mk_portmanteau()