From 4fc1cfc6549a5f2850d16ea39d185dc17b2c70ec Mon Sep 17 00:00:00 2001
From: Jesse Keating <jkeating@redhat.com>
Date: Mon, 4 Jan 2010 11:04:15 -0800
Subject: Add fedpkg module and script

fedpkg is a replacement for the Make system used in dist-cvs.
---
 src/fedpkg/__init__.py | 229 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 229 insertions(+)
 create mode 100644 src/fedpkg/__init__.py

(limited to 'src/fedpkg')

diff --git a/src/fedpkg/__init__.py b/src/fedpkg/__init__.py
new file mode 100644
index 0000000..750bea3
--- /dev/null
+++ b/src/fedpkg/__init__.py
@@ -0,0 +1,229 @@
+# fedpkg - a Python library for Fedora Packagers
+#
+# Copyright (C) 2009 Red Hat Inc.
+# Author(s): Jesse Keating <jkeating@redhat.com>
+# 
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the
+# Free Software Foundation; either version 2 of the License, or (at your
+# option) any later version.  See http://www.gnu.org/copyleft/gpl.html for
+# the full text of the license.
+
+import os
+#import pycurl
+import subprocess
+import hashlib
+
+# Define some global variables, put them here to make it easy to change
+LOOKASIDE = 'http://cvs.fedoraproject.org/repo/pkgs'
+LOOKASIDEHASH = 'md5'
+GITBASEURL = 'ssh://%(user)s@pkgs.stg.fedoraproject.org/%(module)s'
+
+# Define some helper functions, they start with _
+def _hash_file(file, hashtype):
+    """Return the hash of a file given a hash type"""
+
+    try:
+        sum = hashlib.new(hashtype)
+    except ValueError:
+        print("Invalid hash type: 0%s" % hashtype)
+        return False
+
+    input = open(file, 'rb')
+    # Loop through the file reading chunks at a time as to not
+    # put the entire file in memory.  That would suck for DVDs
+    while True:
+        chunk = input.read(8192) # magic number!  Taking suggestions
+        if not chunk:
+            break # we're done with the file
+        sum.update(chunk)
+    input.close()
+    return sum.hexdigest()
+
+def _verify_file(file, hash, hashtype):
+    """Given a file, a hash of that file, and a hashtype, verify.
+
+    Returns True if the file verifies, False otherwise
+
+    """
+
+    # get the hash
+    sum = _hash_file(file, hashtype)
+    # now do the comparison
+    if sum == hash:
+        return True
+    return False
+
+def clone(module, user, branch=None):
+    """Clone a repo, optionally check out a specific branch.
+
+    module is the name of the module to clone
+
+    branch is the name of a branch to checkout instead of origin/master
+
+    gitargs is an optional list of arguments to git clone
+
+    """
+
+    # not implemented yet
+    # construct the git url
+    giturl = GITBASEURL % {'user': user, 'module': module}
+    cmd = ['git', 'clone']
+    if branch:
+        cmd.extend(['--branch', branch])
+    cmd.append(giturl)
+    print('Would have ran %s' % subprocess.list2cmdline(cmd))
+    return
+
+def clone_with_dirs(module, user):
+    """Clone a repo old style with subdirs for each branch.
+
+    module is the name of the module to clone
+
+    gitargs is an option list of arguments to git clone
+
+    """
+
+    # not implemented yet
+    print('would have cloned %s with dirs as user %s' % 
+          (module, user))
+    return
+
+# Create a class for package module
+class PackageModule:
+    def _findbranch(self):
+        """Find the branch we're on"""
+        if not os.path.exists(os.path.join(self.path, 'branch')):
+            return 'devel'
+        branch = open(os.path.join(self.path, 'branch'), 'r').read().strip()
+        return branch
+
+    def __init__(self, path=os.curdir):
+        # Initiate a PackageModule object in a given path
+        # Set some global variables used throughout
+        self.path = path
+        self.lookaside = LOOKASIDE
+        self.lookasidehash = LOOKASIDEHASH
+        self.spec = self.gimmespec()
+        self.module = self.spec.split('.spec')[0]
+        # Find the branch and set things based from that
+        # Still requires a 'branch' file in each branch
+        self.branch = self._findbranch()
+        if self.branch.startswith('F-'):
+            self.distval = self.branch.split('-')[1]
+            self.distvar = 'fedora'
+            self.dist = '.fc%s' % self.distval
+        elif self.branch.startswith('EL-'):
+            self.distval = self.branch.split('-')[1]
+            self.distvar = 'epel'
+            self.dist = '.el%s' % self.distval
+        elif self.branch.startswith('OLPC-'):
+            self.distval = self.branch.split('-')[1]
+            self.distvar = 'olpc'
+            self.dist = '.olpc%s' % self.distval
+        # Need to do something about no branch here
+        elif self.branch == 'devel':
+            self.distval = '13' # this is hardset for now, which is bad
+            self.distvar = 'fedora'
+            self.dist = '.fc%s' % self.distval
+        self.rpmdefines = ['--define', '_sourcedir %s' % path,
+                           '--define', '_specdir %s' % path,
+                           '--define', '_builddir %s' % path,
+                           '--define', '_srcrpmdir %s' % path,
+                           '--define', '_rpmdir %s' % path,
+                           '--define', 'dist %s' % self.dist,
+                           '--define', '%s %s' % (self.distvar, self.distval),
+                           '--define', '%s 1' % self.distvar]
+
+    def gimmespec(self):
+        """Print the name of a specfile within a package module"""
+    
+        # Get a list of files in the path we're looking at
+        files = os.listdir(self.path)
+        # Search the files for the first one that ends with ".spec"
+        for f in files:
+            if f.endswith('.spec'):
+                return f
+        return None
+
+    def new_sources(self, files):
+        """Replace source file(s) in the lookaside cache"""
+    
+        # Not fully implimented yet
+        for file in files:
+            hash = _hash_file(file, self.lookasidehash)
+            print "Would upload %s:%s" % (hash, file)
+        return
+               
+    def sources(self, outdir=None):
+        """Download source files"""
+    
+        archives = open(os.path.join(self.path, 'sources'),
+                        'r').readlines()
+        # Default to putting the files where the module is
+        if not outdir:
+            outdir = self.path
+        for archive in archives:
+            csum, file = archive.split()
+            # See if we already have a valid copy downloaded
+            outfile = os.path.join(outdir, file)
+            if os.path.exists(outfile):
+                if _verify_file(outfile, csum, self.lookasidehash):
+                    continue
+            url = '%s/%s/%s/%s/%s' % (self.lookaside, self.module, file, csum,
+                                      file)
+            # There is some code here for using pycurl, but for now,
+            # just use subprocess
+            #output = open(file, 'wb')
+            #curl = pycurl.Curl()
+            #curl.setopt(pycurl.URL, url)
+            #curl.setopt(pycurl.FOLLOWLOCATION, 1)
+            #curl.setopt(pycurl.MAXREDIRS, 5)
+            #curl.setopt(pycurl.CONNECTTIMEOUT, 30)
+            #curl.setopt(pycurl.TIMEOUT, 300)
+            #curl.setopt(pycurl.WRITEDATA, output)
+            #try:
+            #    curl.perform()
+            #except:
+            #    print "Problems downloading %s" % url
+            #    curl.close()
+            #    output.close()
+            #    return 1
+            #curl.close()
+            #output.close()
+            # These options came from Makefile.common.
+            # Probably need to support wget too
+            command = ['curl', '-H',  'Pragma:', '-O', '-R', '-S',  '--fail',
+                       '--show-error', url]
+            try:
+                subprocess.check_call(command, cwd=outdir)
+            except subprocess.CalledProcessError, e:
+                print "Could not download %s: %s" % (url, e)
+                return 1
+            if not _verify_file(outfile, csum, self.lookasidehash):
+                print "%s failed checksum" % file
+                return 1
+        return
+
+    def srpm(self, hashtype='sha256'):
+        """Create an srpm using hashtype from content in the module
+    
+        Requires sources already downloaded.
+    
+        """
+    
+        cmd = ['rpmbuild']
+        cmd.extend(self.rpmdefines)
+        # This may need to get updated if we ever change our checksum default
+        if not hashtype == 'sha256':
+            cmd.extend(['--define',
+                        '_source_filedigest_algorithm %s' % hashtype,
+                        '--define',
+                        '_binary_filedigest_algorithm %s' % hashtype])
+        cmd.extend(['--nodeps', '-bs', os.path.join(self.path, self.spec)])
+        try:
+            subprocess.check_call(cmd)
+        except subprocess.CalledProcessError, e:
+            print "Could not build %s: %s" % (self.module, e)
+            return 1
+        return
\ No newline at end of file
-- 
cgit 


From 8da0910f372a68bbef0315a2a7c427bd69f2d8ab Mon Sep 17 00:00:00 2001
From: Jesse Keating <jkeating@redhat.com>
Date: Mon, 4 Jan 2010 11:53:07 -0800
Subject: Add getver and getrel

Useful for getting the verrel
---
 src/fedpkg/__init__.py | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

(limited to 'src/fedpkg')

diff --git a/src/fedpkg/__init__.py b/src/fedpkg/__init__.py
index 750bea3..b84a85a 100644
--- a/src/fedpkg/__init__.py
+++ b/src/fedpkg/__init__.py
@@ -134,6 +134,38 @@ class PackageModule:
                            '--define', 'dist %s' % self.dist,
                            '--define', '%s %s' % (self.distvar, self.distval),
                            '--define', '%s 1' % self.distvar]
+        self.ver = self.getver()
+        self.rel = self.getrel()
+
+    def getver(self):
+        """Return the version-release of a package module."""
+
+        cmd = ['rpm']
+        cmd.extend(self.rpmdefines)
+        cmd.extend(['-q', '--qf', '%{VERSION}', '--specfile',
+                    os.path.join(self.path, self.spec)])
+        try:
+            output = subprocess.Popen(cmd,
+                                      stdout=subprocess.PIPE).communicate()
+        except subprocess.CalledProcessError, e:
+            print("Could not get version-release of %s: %s" % (self.module, e))
+            return 1
+        return output[0]
+
+    def getrel(self):
+        """Return the version-release of a package module."""
+
+        cmd = ['rpm']
+        cmd.extend(self.rpmdefines)
+        cmd.extend(['-q', '--qf', '%{RELEASE}', '--specfile',
+                    os.path.join(self.path, self.spec)])
+        try:
+            output = subprocess.Popen(cmd,
+                                      stdout=subprocess.PIPE).communicate()
+        except subprocess.CalledProcessError, e:
+            print("Could not get version-release of %s: %s" % (self.module, e))
+            return 1
+        return output[0]
 
     def gimmespec(self):
         """Print the name of a specfile within a package module"""
-- 
cgit 


From 14cc21fc32e8e44d4278aaeaa5136e2b1bb66b1c Mon Sep 17 00:00:00 2001
From: Jesse Keating <jkeating@redhat.com>
Date: Mon, 4 Jan 2010 14:10:37 -0800
Subject: Add a lint function.

Needs better error handling, will add a custom error class
---
 src/fedpkg/__init__.py | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

(limited to 'src/fedpkg')

diff --git a/src/fedpkg/__init__.py b/src/fedpkg/__init__.py
index b84a85a..ceffbbc 100644
--- a/src/fedpkg/__init__.py
+++ b/src/fedpkg/__init__.py
@@ -178,6 +178,22 @@ class PackageModule:
                 return f
         return None
 
+    def lint(self):
+        """Run rpmlint over a built srpm"""
+
+        # Make sure we have a srpm to run on
+        srpm = "%s-%s-%s.src.rpm" % (self.module, self.ver, self.rel)
+        rpm = "%s-%s-%s.%s.rpm" % (self.module, self.ver, self.rel,
+                                   os.uname()[4])
+        if not os.path.exists(os.path.join(self.path, srpm)) and not \
+          os.path.exists(os.path.join(self.path, rpm)):
+            return "Need to build srpm and rpm first"
+        cmd = ['rpmlint', os.path.join(self.path, srpm),
+               os.path.join(self.path, rpm)]
+        output = subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate()
+        return output[0]
+        
+
     def new_sources(self, files):
         """Replace source file(s) in the lookaside cache"""
     
-- 
cgit 


From 76cb0035e4928cf7f6c32e239cd35515c0a92161 Mon Sep 17 00:00:00 2001
From: Jesse Keating <jkeating@redhat.com>
Date: Mon, 4 Jan 2010 14:17:45 -0800
Subject: Add a custom error class

This makes it easier to catch errors in the calling tools.
They won't have to know about the internals of the library,
just catch the custom error and deal with it.
---
 src/fedpkg/__init__.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'src/fedpkg')

diff --git a/src/fedpkg/__init__.py b/src/fedpkg/__init__.py
index ceffbbc..17ea192 100644
--- a/src/fedpkg/__init__.py
+++ b/src/fedpkg/__init__.py
@@ -19,6 +19,10 @@ LOOKASIDE = 'http://cvs.fedoraproject.org/repo/pkgs'
 LOOKASIDEHASH = 'md5'
 GITBASEURL = 'ssh://%(user)s@pkgs.stg.fedoraproject.org/%(module)s'
 
+# Define our own error class
+class FedpkgError(Exception):
+    pass
+
 # Define some helper functions, they start with _
 def _hash_file(file, hashtype):
     """Return the hash of a file given a hash type"""
@@ -187,7 +191,7 @@ class PackageModule:
                                    os.uname()[4])
         if not os.path.exists(os.path.join(self.path, srpm)) and not \
           os.path.exists(os.path.join(self.path, rpm)):
-            return "Need to build srpm and rpm first"
+            raise FedpkgError("Need to build srpm and rpm first")
         cmd = ['rpmlint', os.path.join(self.path, srpm),
                os.path.join(self.path, rpm)]
         output = subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate()
-- 
cgit 


From e71b6bebab3df14e75f12990f7914bc8b36f5347 Mon Sep 17 00:00:00 2001
From: Jesse Keating <jkeating@redhat.com>
Date: Mon, 4 Jan 2010 14:30:34 -0800
Subject: Catch subprocess errors and re-raise our error

---
 src/fedpkg/__init__.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'src/fedpkg')

diff --git a/src/fedpkg/__init__.py b/src/fedpkg/__init__.py
index 17ea192..0e668b9 100644
--- a/src/fedpkg/__init__.py
+++ b/src/fedpkg/__init__.py
@@ -194,7 +194,10 @@ class PackageModule:
             raise FedpkgError("Need to build srpm and rpm first")
         cmd = ['rpmlint', os.path.join(self.path, srpm),
                os.path.join(self.path, rpm)]
-        output = subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate()
+        try:
+            output = subprocess.Popen(cmd, stdout=subprocess.PIPE).communicate()
+        except subprocess.CalledProcessError, e:
+            raise FedpkgError(e)
         return output[0]
         
 
-- 
cgit 


From 7d0c07c2170c16b4b4502cafee38f56fcede80b3 Mon Sep 17 00:00:00 2001
From: Jesse Keating <jkeating@redhat.com>
Date: Mon, 4 Jan 2010 14:39:24 -0800
Subject: Use FedpkgError for error checking

---
 src/fedpkg/__init__.py | 22 ++++++++--------------
 1 file changed, 8 insertions(+), 14 deletions(-)

(limited to 'src/fedpkg')

diff --git a/src/fedpkg/__init__.py b/src/fedpkg/__init__.py
index 0e668b9..05d83ff 100644
--- a/src/fedpkg/__init__.py
+++ b/src/fedpkg/__init__.py
@@ -30,8 +30,7 @@ def _hash_file(file, hashtype):
     try:
         sum = hashlib.new(hashtype)
     except ValueError:
-        print("Invalid hash type: 0%s" % hashtype)
-        return False
+        raise FedpkgError('Invalid hash type: %s' % hashtype)
 
     input = open(file, 'rb')
     # Loop through the file reading chunks at a time as to not
@@ -152,8 +151,7 @@ class PackageModule:
             output = subprocess.Popen(cmd,
                                       stdout=subprocess.PIPE).communicate()
         except subprocess.CalledProcessError, e:
-            print("Could not get version-release of %s: %s" % (self.module, e))
-            return 1
+            raise FedpkgError('Could not get version-release of %s: %s' % (self.module, e))
         return output[0]
 
     def getrel(self):
@@ -167,8 +165,7 @@ class PackageModule:
             output = subprocess.Popen(cmd,
                                       stdout=subprocess.PIPE).communicate()
         except subprocess.CalledProcessError, e:
-            print("Could not get version-release of %s: %s" % (self.module, e))
-            return 1
+            raise FedpkgError('Could not get version-release of %s: %s' % (self.module, e))
         return output[0]
 
     def gimmespec(self):
@@ -180,7 +177,7 @@ class PackageModule:
         for f in files:
             if f.endswith('.spec'):
                 return f
-        return None
+        raise FedpkgError('No spec file found.')
 
     def lint(self):
         """Run rpmlint over a built srpm"""
@@ -191,7 +188,7 @@ class PackageModule:
                                    os.uname()[4])
         if not os.path.exists(os.path.join(self.path, srpm)) and not \
           os.path.exists(os.path.join(self.path, rpm)):
-            raise FedpkgError("Need to build srpm and rpm first")
+            raise FedpkgError('Need to build srpm and rpm first')
         cmd = ['rpmlint', os.path.join(self.path, srpm),
                os.path.join(self.path, rpm)]
         try:
@@ -253,11 +250,9 @@ class PackageModule:
             try:
                 subprocess.check_call(command, cwd=outdir)
             except subprocess.CalledProcessError, e:
-                print "Could not download %s: %s" % (url, e)
-                return 1
+                raise FedpkgError('Could not download %s: %s' % (url, e))
             if not _verify_file(outfile, csum, self.lookasidehash):
-                print "%s failed checksum" % file
-                return 1
+                raise FedpkgError('%s failed checksum' % file)
         return
 
     def srpm(self, hashtype='sha256'):
@@ -279,6 +274,5 @@ class PackageModule:
         try:
             subprocess.check_call(cmd)
         except subprocess.CalledProcessError, e:
-            print "Could not build %s: %s" % (self.module, e)
-            return 1
+            raise FedpkgError('Could not build %s: %s' % (self.module, e))
         return
\ No newline at end of file
-- 
cgit 


From 8ff2ad2b965e0ab027f4bb397f8b03ccc3f2c7a0 Mon Sep 17 00:00:00 2001
From: Jesse Keating <jkeating@redhat.com>
Date: Mon, 4 Jan 2010 14:40:14 -0800
Subject: Fix the error messages to match the functions

---
 src/fedpkg/__init__.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'src/fedpkg')

diff --git a/src/fedpkg/__init__.py b/src/fedpkg/__init__.py
index 05d83ff..296e343 100644
--- a/src/fedpkg/__init__.py
+++ b/src/fedpkg/__init__.py
@@ -151,7 +151,7 @@ class PackageModule:
             output = subprocess.Popen(cmd,
                                       stdout=subprocess.PIPE).communicate()
         except subprocess.CalledProcessError, e:
-            raise FedpkgError('Could not get version-release of %s: %s' % (self.module, e))
+            raise FedpkgError('Could not get version of %s: %s' % (self.module, e))
         return output[0]
 
     def getrel(self):
@@ -165,7 +165,7 @@ class PackageModule:
             output = subprocess.Popen(cmd,
                                       stdout=subprocess.PIPE).communicate()
         except subprocess.CalledProcessError, e:
-            raise FedpkgError('Could not get version-release of %s: %s' % (self.module, e))
+            raise FedpkgError('Could not get release of %s: %s' % (self.module, e))
         return output[0]
 
     def gimmespec(self):
-- 
cgit 


From 76a0095c50ac1ef170d33b744123c4aa123d7ae8 Mon Sep 17 00:00:00 2001
From: Jesse Keating <jkeating@redhat.com>
Date: Mon, 4 Jan 2010 14:51:46 -0800
Subject: Whitespace clean up

---
 src/fedpkg/__init__.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'src/fedpkg')

diff --git a/src/fedpkg/__init__.py b/src/fedpkg/__init__.py
index 296e343..f3a3a40 100644
--- a/src/fedpkg/__init__.py
+++ b/src/fedpkg/__init__.py
@@ -96,6 +96,7 @@ def clone_with_dirs(module, user):
 class PackageModule:
     def _findbranch(self):
         """Find the branch we're on"""
+
         if not os.path.exists(os.path.join(self.path, 'branch')):
             return 'devel'
         branch = open(os.path.join(self.path, 'branch'), 'r').read().strip()
@@ -261,7 +262,7 @@ class PackageModule:
         Requires sources already downloaded.
     
         """
-    
+
         cmd = ['rpmbuild']
         cmd.extend(self.rpmdefines)
         # This may need to get updated if we ever change our checksum default
-- 
cgit 


From a52412f0975f2c2b192e8a56f9654e45f4087116 Mon Sep 17 00:00:00 2001
From: Jesse Keating <jkeating@redhat.com>
Date: Mon, 4 Jan 2010 15:08:38 -0800
Subject: Make localarch a module attribute

---
 src/fedpkg/__init__.py | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

(limited to 'src/fedpkg')

diff --git a/src/fedpkg/__init__.py b/src/fedpkg/__init__.py
index f3a3a40..4f5e559 100644
--- a/src/fedpkg/__init__.py
+++ b/src/fedpkg/__init__.py
@@ -102,6 +102,12 @@ class PackageModule:
         branch = open(os.path.join(self.path, 'branch'), 'r').read().strip()
         return branch
 
+    def _getlocalarch(self):
+        """Get the local arch as defined by rpm"""
+        
+        return subprocess.Popen(['rpm', '--eval', '%{_arch}'],
+                                stdout=subprocess.PIPE).communicate()[0]
+
     def __init__(self, path=os.curdir):
         # Initiate a PackageModule object in a given path
         # Set some global variables used throughout
@@ -140,6 +146,7 @@ class PackageModule:
                            '--define', '%s 1' % self.distvar]
         self.ver = self.getver()
         self.rel = self.getrel()
+        self.localarch = self._getlocalarch()
 
     def getver(self):
         """Return the version-release of a package module."""
@@ -186,7 +193,7 @@ class PackageModule:
         # Make sure we have a srpm to run on
         srpm = "%s-%s-%s.src.rpm" % (self.module, self.ver, self.rel)
         rpm = "%s-%s-%s.%s.rpm" % (self.module, self.ver, self.rel,
-                                   os.uname()[4])
+                                   self.localarch)
         if not os.path.exists(os.path.join(self.path, srpm)) and not \
           os.path.exists(os.path.join(self.path, rpm)):
             raise FedpkgError('Need to build srpm and rpm first')
-- 
cgit 


From 5c0a9bef181a3380921b90aafaf985ab0fe07ba1 Mon Sep 17 00:00:00 2001
From: Jesse Keating <jkeating@redhat.com>
Date: Mon, 4 Jan 2010 15:59:41 -0800
Subject: Add a local target to build locally

This still has some errors, and I think I need to run the rpm stuff in a real
shell, which would require re-working the rpm defines and editing the other
functions that use them.  What fun!
---
 src/fedpkg/__init__.py | 43 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 42 insertions(+), 1 deletion(-)

(limited to 'src/fedpkg')

diff --git a/src/fedpkg/__init__.py b/src/fedpkg/__init__.py
index 4f5e559..696338f 100644
--- a/src/fedpkg/__init__.py
+++ b/src/fedpkg/__init__.py
@@ -204,7 +204,48 @@ class PackageModule:
         except subprocess.CalledProcessError, e:
             raise FedpkgError(e)
         return output[0]
-        
+
+    def local(self, arch=None, hashtype='sha256'):
+        """rpmbuild locally for given arch.
+
+        Takes arch to build for, and hashtype to build with.
+
+        Writes output to a log file and returns output from build.
+
+        """
+
+        # Get the sources
+        self.sources()
+        # Determine arch to build for
+        if not arch:
+            arch = self.localarch
+        # build up the rpm command
+        cmd = ['rpmbuild']
+        cmd.extend(self.rpmdefines)
+        # This may need to get updated if we ever change our checksum default
+        if not hashtype == 'sha256':
+            cmd.extend(['--define',
+                        '_source_filedigest_algorithm %s' % hashtype,
+                        '--define',
+                        '_binary_filedigest_algorithm %s' % hashtype])
+        cmd.extend(['--target', arch, '-ba',
+                    os.path.join(self.path, self.spec)])
+        try:
+            proc = subprocess.Popen(cmd, stderr=subprocess.STDOUT,
+                                    stdout=subprocess.PIPE)
+            output = proc.communicate()
+        except OSError, e:
+            raise FedpkgError(e)
+        outfile = open(os.path.join(self.path, '.build-%s-%s.log' % (self.ver,
+                       self.rel)), 'w')
+        outfile.writelines(output[0])
+        outfile.close()
+        # See if we had a good return or not, raise accordingly
+        if proc.returncode:
+            raise FedpkgError('%s returned %s: %s' %
+                              (subprocess.list2cmdline(cmd),
+                               proc.returncode, output[0]))
+        return output[0]
 
     def new_sources(self, files):
         """Replace source file(s) in the lookaside cache"""
-- 
cgit 


From 8b511db3667b9a50601984af4b0a5668f99f9a9f Mon Sep 17 00:00:00 2001
From: Jesse Keating <jkeating@redhat.com>
Date: Mon, 4 Jan 2010 16:57:04 -0800
Subject: Make all rpm calls use shell=True

I think this is necessary or some spec junk won't work out right.
---
 src/fedpkg/__init__.py | 42 +++++++++++++++++++-----------------------
 1 file changed, 19 insertions(+), 23 deletions(-)

(limited to 'src/fedpkg')

diff --git a/src/fedpkg/__init__.py b/src/fedpkg/__init__.py
index 696338f..b4940e9 100644
--- a/src/fedpkg/__init__.py
+++ b/src/fedpkg/__init__.py
@@ -105,8 +105,8 @@ class PackageModule:
     def _getlocalarch(self):
         """Get the local arch as defined by rpm"""
         
-        return subprocess.Popen(['rpm', '--eval', '%{_arch}'],
-                                stdout=subprocess.PIPE).communicate()[0]
+        return subprocess.Popen(['rpm --eval %{_arch}'], shell=True,
+                        stdout=subprocess.PIPE).communicate()[0].strip('\n')
 
     def __init__(self, path=os.curdir):
         # Initiate a PackageModule object in a given path
@@ -136,14 +136,14 @@ class PackageModule:
             self.distval = '13' # this is hardset for now, which is bad
             self.distvar = 'fedora'
             self.dist = '.fc%s' % self.distval
-        self.rpmdefines = ['--define', '_sourcedir %s' % path,
-                           '--define', '_specdir %s' % path,
-                           '--define', '_builddir %s' % path,
-                           '--define', '_srcrpmdir %s' % path,
-                           '--define', '_rpmdir %s' % path,
-                           '--define', 'dist %s' % self.dist,
-                           '--define', '%s %s' % (self.distvar, self.distval),
-                           '--define', '%s 1' % self.distvar]
+        self.rpmdefines = ["--define '_sourcedir %s'" % path,
+                           "--define '_specdir %s'" % path,
+                           "--define '_builddir %s'" % path,
+                           "--define '_srcrpmdir %s'" % path,
+                           "--define '_rpmdir %s'" % path,
+                           "--define 'dist %s'" % self.dist,
+                           "--define '%s %s'" % (self.distvar, self.distval),
+                           "--define '%s 1'" % self.distvar]
         self.ver = self.getver()
         self.rel = self.getrel()
         self.localarch = self._getlocalarch()
@@ -156,7 +156,7 @@ class PackageModule:
         cmd.extend(['-q', '--qf', '%{VERSION}', '--specfile',
                     os.path.join(self.path, self.spec)])
         try:
-            output = subprocess.Popen(cmd,
+            output = subprocess.Popen(' '.join(cmd), shell=True,
                                       stdout=subprocess.PIPE).communicate()
         except subprocess.CalledProcessError, e:
             raise FedpkgError('Could not get version of %s: %s' % (self.module, e))
@@ -170,7 +170,7 @@ class PackageModule:
         cmd.extend(['-q', '--qf', '%{RELEASE}', '--specfile',
                     os.path.join(self.path, self.spec)])
         try:
-            output = subprocess.Popen(cmd,
+            output = subprocess.Popen(' '.join(cmd), shell=True,
                                       stdout=subprocess.PIPE).communicate()
         except subprocess.CalledProcessError, e:
             raise FedpkgError('Could not get release of %s: %s' % (self.module, e))
@@ -224,15 +224,13 @@ class PackageModule:
         cmd.extend(self.rpmdefines)
         # This may need to get updated if we ever change our checksum default
         if not hashtype == 'sha256':
-            cmd.extend(['--define',
-                        '_source_filedigest_algorithm %s' % hashtype,
-                        '--define',
-                        '_binary_filedigest_algorithm %s' % hashtype])
+            cmd.extend(["--define '_source_filedigest_algorithm %s'" % hashtype,
+                        "--define '_binary_filedigest_algorithm %s'" % hashtype])
         cmd.extend(['--target', arch, '-ba',
                     os.path.join(self.path, self.spec)])
         try:
-            proc = subprocess.Popen(cmd, stderr=subprocess.STDOUT,
-                                    stdout=subprocess.PIPE)
+            proc = subprocess.Popen(' '.join(cmd), stderr=subprocess.STDOUT,
+                                    stdout=subprocess.PIPE, shell=True)
             output = proc.communicate()
         except OSError, e:
             raise FedpkgError(e)
@@ -315,13 +313,11 @@ class PackageModule:
         cmd.extend(self.rpmdefines)
         # This may need to get updated if we ever change our checksum default
         if not hashtype == 'sha256':
-            cmd.extend(['--define',
-                        '_source_filedigest_algorithm %s' % hashtype,
-                        '--define',
-                        '_binary_filedigest_algorithm %s' % hashtype])
+            cmd.extend(["--define '_source_filedigest_algorithm %s'" % hashtype,
+                    "--define '_binary_filedigest_algorithm %s'" % hashtype])
         cmd.extend(['--nodeps', '-bs', os.path.join(self.path, self.spec)])
         try:
-            subprocess.check_call(cmd)
+            subprocess.check_call(' '.join(cmd), shell=True)
         except subprocess.CalledProcessError, e:
             raise FedpkgError('Could not build %s: %s' % (self.module, e))
         return
\ No newline at end of file
-- 
cgit