Merge lp:~jml/pkgme/upload-to-ppa into lp:pkgme

[Jonathan Lange]

This branch makes pkgme upload to a PPA if the PPA is provided as an argument to 'pkgme'.

 * It doesn't do any validation of the argument. It lets 'dput' do all of that.
 * 'dput' is in a module all by its own. I don't know where else to put it.

[James Westby (james-w)]

review: Approve

=== modified file 'pkgme/bin/main.py'
--- pkgme/bin/main.py	2011-08-01 09:00:08 +0000
+++ pkgme/bin/main.py	2011-08-01 16:13:58 +0000
@@ -6,23 +6,26 @@
 
 from pkgme import __version__, write_packaging
 from pkgme.debuild import build_source_package
+from pkgme.dput import dput
 from pkgme.errors import PkgmeError
 from pkgme import trace
 
 
-def build_package(target_dir, interactive):
+def build_package(target_dir, interactive, ppa=None):
     """Where the magic happens."""
     trace.debug("Building packaging for %s" % (target_dir,))
     write_packaging(target_dir)
     trace.debug("Built packaging for %s" % (target_dir,))
     trace.debug("Building source package for %s" % (target_dir,))
-    build_source_package(target_dir, sign=interactive)
+    changes_file = build_source_package(target_dir, sign=interactive)
     trace.debug("Built source package for %s" % (target_dir,))
-
-
-def main(argv=None, target_dir=None, interactive=True):
-    if argv is None:
-        argv = sys.argv[1:]
+    if ppa:
+        trace.debug('Uploading to PPA: %s => %s' % (changes_file, ppa))
+        dput(ppa, changes_file)
+        trace.debug('Uploaded to PPA: %s => %s' % (changes_file, ppa))
+
+
+def make_arg_parser():
     parser = argparse.ArgumentParser(
         description='pkgme - A Debian packaging generation framework.')
     parser.add_argument(
@@ -30,13 +33,23 @@
         action='version', version='pkgme {0}'.format(__version__),
         help='Print this version string and exit')
     parser.add_argument('-D', '--debug', action='store_true')
+    parser.add_argument(
+        'ppa', nargs='?', metavar='PPA',
+        help='A PPA to upload to. e.g. ppa:user/ppa-name')
+    return parser
+
+
+def main(argv=None, target_dir=None, interactive=True):
+    if argv is None:
+        argv = sys.argv[1:]
+    parser = make_arg_parser()
     options = parser.parse_args(args=argv)
     if options.debug:
         trace.set_debug()
     if target_dir is None:
         target_dir = os.getcwd()
     try:
-        build_package(target_dir, interactive=interactive)
+        build_package(target_dir, interactive=interactive, ppa=options.ppa)
     except PkgmeError, e:
         if options.debug:
             raise

=== modified file 'pkgme/debuild.py'
--- pkgme/debuild.py	2011-07-29 17:14:50 +0000
+++ pkgme/debuild.py	2011-08-01 16:13:58 +0000
@@ -1,34 +1,22 @@
-import subprocess
-
-from pkgme.errors import PkgmeError
-from pkgme import trace
-
-
-class DebuildError(PkgmeError):
-
-    def __init__(self, command, retcode, output_lines):
-        super(DebuildError, self).__init__(
-            "%s failed with %s. Output:\n%s" % (
-                ' '.join(command),
-                retcode,
-                ''.join(' | %s' % (line,) for line in output_lines if line)))
+import os
+import re
+
+from pkgme.run_script import run_subprocess
+
+
+def find_changes_file(output_lines,
+                      _changes_file_re=re.compile(r' dpkg-genchanges -S >(.*)')):
+    for line in output_lines:
+        match = _changes_file_re.match(line)
+        if match:
+            return match.group(1)
+    raise ValueError("Could not find changes filename")
 
 
 def build_source_package(directory, sign=True):
     cmd = ['debuild', '--no-lintian', '-S']
     if not sign:
         cmd.extend(['-uc', '-us'])
-    trace.debug("Running %s" % ' '.join(cmd))
-    proc = subprocess.Popen(
-        cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=directory)
-    output = []
-    while True:
-        stdout = proc.stdout.readline()
-        output.append(stdout)
-        if stdout:
-            trace.debug('D: %s' % (stdout.rstrip('\n'),))
-        else:
-            break
-    retcode = proc.wait()
-    if retcode != 0:
-        raise DebuildError(cmd, retcode, output)
+    output = run_subprocess(cmd, cwd=directory)
+    changes_file = find_changes_file(output)
+    return os.path.abspath(os.path.join(directory, changes_file))

=== added file 'pkgme/dput.py'
--- pkgme/dput.py	1970-01-01 00:00:00 +0000
+++ pkgme/dput.py	2011-08-01 16:13:58 +0000
@@ -0,0 +1,7 @@
+from pkgme.run_script import run_subprocess
+
+
+def dput(ppa_name, changes_file):
+    """Use 'dput' to upload to a PPA."""
+    # XXX: This won't raise an error if the PPA doesn't exist.
+    return run_subprocess(['dput', ppa_name, changes_file])

=== modified file 'pkgme/run_script.py'
--- pkgme/run_script.py	2011-07-29 14:55:52 +0000
+++ pkgme/run_script.py	2011-08-01 16:13:58 +0000
@@ -2,12 +2,14 @@
 import os
 import subprocess
 
+from pkgme.errors import PkgmeError
 from pkgme import trace
 
 
-class ScriptProblem(Exception):
+class ScriptProblem(PkgmeError):
 
     def __init__(self, script_path):
+        super(ScriptProblem, self).__init__()
         self.script_path = script_path
 
 
@@ -22,15 +24,45 @@
 
 class ScriptFailed(ScriptProblem):
 
-    def __init__(self, script_path, returncode, output):
-        super(ScriptFailed, self).__init__(script_path)
+    def __init__(self, command, returncode, output_lines):
+        super(ScriptFailed, self).__init__(command[0])
+        self.command = command
         self.returncode = returncode
-        self.output = output
+        self.output_lines = output_lines
 
     def __str__(self):
-        return (
-            "%s failed with returncode %d, output was %s"
-            % (self.script_path, self.returncode, self.output))
+        return "%s failed with returncode %s. Output:\n%s" % (
+            ' '.join(self.command),
+            self.returncode,
+            ''.join(' | %s' % (line,)
+                    for line in self.output_lines if line))
+
+
+def run_subprocess(cmd, cwd=None, env=None, to_write=None):
+    trace.debug("Running %s" % ' '.join(cmd))
+    try:
+        proc = subprocess.Popen(
+            cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT, cwd=cwd, env=env)
+    except OSError as e:
+        if e.errno == errno.ENOENT:
+            raise ScriptMissing(cmd[0])
+        raise
+    output = []
+    if to_write:
+        proc.stdin.write(to_write)
+    proc.stdin.close()
+    while True:
+        stdout = proc.stdout.readline()
+        output.append(stdout)
+        if stdout:
+            trace.debug('D: %s' % (stdout.rstrip('\n'),))
+        else:
+            break
+    retcode = proc.wait()
+    if retcode != 0:
+        raise ScriptFailed(cmd, retcode, output)
+    return output
 
 
 def run_script(basepath, script_name, cwd, to_write=None):
@@ -43,17 +75,5 @@
             env['PATH'] = os.pathsep.join([env['PATH'], helperpath])
         else:
             env['PATH'] = helperpath
-    try:
-        trace.debug("Running script %s..." % (script_path,))
-        proc = subprocess.Popen(
-            [script_path], stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT, stdin=subprocess.PIPE,
-            cwd=cwd, env=env)
-    except OSError as e:
-        if e.errno == errno.ENOENT:
-            raise ScriptMissing(script_path)
-        raise
-    out, ignore = proc.communicate(to_write)
-    if proc.returncode != 0:
-        raise ScriptFailed(script_path, proc.returncode, out)
-    return out
+    output = run_subprocess([script_path], cwd=cwd, env=env, to_write=to_write)
+    return ''.join(output)