Ticket #688: pkg_xpra.py

#!/usr/bin/env python

import os
import glob
import platform
import re
import subprocess
import shutil
import sys

# CHANGE TO REFLECT YOUR PATHS
BUILD_DIR = '/home/pyther/xpra_build'
SRPM_DIR = os.path.join(BUILD_DIR, 'rpmbuild/SRPMS')

# DO NOT CHANGE
REPO_DIR = os.path.join(BUILD_DIR, 'repos')
MOCK_DIR = os.path.join(BUILD_DIR, 'mock')
MOCK_CONFIG_DIR = os.path.join(BUILD_DIR, 'mock_config')

d = {}

d['f20'] = {'name':'fedora', 'version':'20', 'build_pkgs':[], 'pkgs':[]}
d['f19'] = {'name':'fedora', 'version':'19', 'build_pkgs':[], 'pkgs':[]}
#d['el5'] = {'name':'el', 'version':'5', 'build_pkgs':[], 'pkgs':[]}
d['el6'] = {'name':'el', 'version':'6', 'build_pkgs':[], 'pkgs':[]}

#d['el5']['build_pkgs'] = ['yasm', 'Cython']
d['el6']['build_pkgs'] = ['yasm', 'Cython']


# el6 packages
d['el6']['pkgs'].append('x264-xpra')
d['el6']['pkgs'].append('libvpx-xpra')
d['el6']['pkgs'].append('libwebp-xpra')
d['el6']['pkgs'].append('ffmpeg-xpra')
d['el6']['pkgs'].append('libfakeXinerama')
d['el6']['pkgs'].append(('xorg-x11-drv-dummy', '0.3.6-2*el6'))
d['el6']['pkgs'].append('PyOpenGL')
d['el6']['pkgs'].append('PyOpenGL-accelerate')
d['el6']['pkgs'].append('python-lz4')
d['el6']['pkgs'].append('python-pillow')
d['el6']['pkgs'].append('python-netifaces')
d['el6']['pkgs'].append('python-crypto')
#d['el6']['pkgs'].append('python-pycuda')
d['el6']['pkgs'].append('xpra')

# f19 packages
d['f19']['pkgs'].append('x264-xpra')
d['f19']['pkgs'].append('ffmpeg-xpra')
d['f19']['pkgs'].append('libfakeXinerama')
d['f19']['pkgs'].append(('xorg-x11-drv-dummy', '0.3.6-10*f19'))
d['f19']['pkgs'].append('PyOpenGL')
d['f19']['pkgs'].append('PyOpenGL-accelerate')
d['f19']['pkgs'].append('python-lz4')
d['f19']['pkgs'].append('python-pillow')
d['f19']['pkgs'].append('python-netifaces')
#d['f19']['pkgs'].append('python-pycuda')
d['f19']['pkgs'].append('xpra')

# f20 packages
d['f20']['pkgs'].append('x264-xpra')
d['f20']['pkgs'].append('ffmpeg-xpra')
d['f20']['pkgs'].append('libfakeXinerama')
d['f20']['pkgs'].append(('xorg-x11-drv-dummy', '0.3.6-11*fc20'))
d['f20']['pkgs'].append('PyOpenGL')
d['f20']['pkgs'].append('PyOpenGL-accelerate')
d['f20']['pkgs'].append('python-lz4')
d['f20']['pkgs'].append('python-pillow')
d['f20']['pkgs'].append('python-netifaces')
#d['f20']['pkgs'].append('python-pycuda')
d['f20']['pkgs'].append('xpra')


def prepare_build_root():
    # create build dir
    if not os.path.isdir(BUILD_DIR):
        try:
            os.makedirs(BUILD_DIR)
        except OSError:
            return 1

    # create repo dir
    if not os.path.isdir(REPO_DIR):
        try:
            os.makedirs(REPO_DIR)
        except OSError:
            return 1

    # create mock dir
    if not os.path.isdir(MOCK_DIR):
        try:
            os.makedirs(MOCK_DIR)
        except OSError:
            return 1

    # create mock config dir
    if not os.path.isdir(MOCK_CONFIG_DIR):
        try:
            os.mkdir(MOCK_CONFIG_DIR)
        except OSError:
            return 1

        # default config files need for mock
        if not os.path.isfile(os.path.join(MOCK_CONFIG_DIR, 'logging.ini')):
            shutil.copy('/etc/mock/logging.ini', MOCK_CONFIG_DIR)

        if not os.path.isfile(os.path.join(MOCK_CONFIG_DIR, 'site-defaults.cfg')):
            shutil.copy('/etc/mock/site-defaults.cfg', MOCK_CONFIG_DIR)

    return

def createrepodata(dir):
    p = subprocess.Popen(['/usr/bin/createrepo', dir], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    rc = p.wait()
    return

def prepare_distro_build(dist, arch):
    build_repo = os.path.join(REPO_DIR, dist, 'build')
    repo = os.path.join(REPO_DIR, dist, 'main')
    mock = os.path.join(MOCK_DIR, dist)

    if not os.path.isdir(build_repo):
        os.makedirs(build_repo)
        os.makedirs(os.path.join(build_repo, 'srpm'))
        os.makedirs(os.path.join(build_repo, arch))

        # createrepo data
        createrepodata(os.path.join(build_repo, 'srpm'))
        createrepodata(os.path.join(build_repo, arch))

    if not os.path.isdir(repo):
        os.makedirs(repo)
        os.makedirs(os.path.join(repo, 'srpm'))
        os.makedirs(os.path.join(repo, arch))

        # createrepo data
        createrepodata(os.path.join(repo, 'srpm'))
        createrepodata(os.path.join(repo, arch))

    if not os.path.isdir(mock):
        os.makedirs(mock)

    return (build_repo, repo, mock)

def create_mock_config(dist, arch, build_repo, repo):
    """
    generate a mock configuration that contains our local repos

    takes a base configuration from /etc/mock/ and applies
    our local (xpra, xpra-build) repos
    """

    name = d[dist]['name']
    version = d[dist]['version']

    # mock config for rhel/centos is named epel
    if name == 'el':
        name = 'epel'

    chroot = '{0}-{1}-{2}'.format(name, version, arch)
    etc_cfg = os.path.join('/etc/mock', '{0}.cfg'.format(chroot))

    # mock configuration is missing
    if not os.path.isfile(etc_cfg):
        raise NameError('no such file: {0}'.format(etc_cfg))

    cfg = open(etc_cfg, 'r').read()

    # append our stuff
    xpra_repos = """
[xpra-build]
name=xpra-build
baseurl=file://{1}/{0}
gpgcheck=0

[xpra]
name=xpra
baseurl=file://{2}/{0}
gpgcheck=0
\"\"\"
""".format(arch, build_repo, repo)

    cfg = re.sub('"""$', xpra_repos, cfg)

    # write cfg to file
    mock_cfg = os.path.join(MOCK_CONFIG_DIR, '{0}.cfg'.format(chroot))
    with open(mock_cfg, 'w') as mock_cfg_file:
        mock_cfg_file.write(cfg)

    return chroot

def build_pkg(pkg, chroot, result_dir, repo):
    """ takes in a pkg name, find the srpm, builds it using mock, and moves
    built package(s) to repo """

    # we only expect one srpm to be found
    # but if we are working with a dirty buildroot, we may find newer and older
    # versions of a srpm.
    if type(pkg) == tuple:
        srpms = glob.glob('{0}/{1}-{2}*.src.rpm'.format(SRPM_DIR, pkg[0], pkg[1]))
    else:
        srpms = glob.glob('{0}/{1}-[0-9]*.src.rpm'.format(SRPM_DIR, pkg))

    if len(srpms) < 1:
        print 'no source rpms found for {0}'.format(pkg)
        raise NameError('no source rpms found for {0}'.format(pkg))
    for srpm in srpms:
        cmd = ['/usr/bin/mock', '--configdir={0}'.format(MOCK_CONFIG_DIR), '--rebuild', srpm, '-r', chroot, '--resultdir={0}'.format(result_dir)]
        print 'building {0}'.format(os.path.basename(srpm))
        p_mock = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        rc = p_mock.wait()

        if rc != 0:
            raise NameError('failed to build {0}'.format(os.path.basename(srpm)))

        arch = platform.uname()[4]
        # move packages to repo
        for rpm in glob.glob(os.path.join(result_dir, '*.rpm')):
            if re.match(r'.*\.src\.rpm$', rpm):
                shutil.copy(rpm, os.path.join(repo, 'srpm'))
            else:
                shutil.copy(rpm, os.path.join(repo, arch))

            os.remove(rpm)

        # generate repodata
        createrepodata(os.path.join(repo, arch))
    return

def main():
    prepare_build_root()

    for key, distro in d.iteritems():
        print '==== building packages for {0} {1} ===='.format(distro['name'], distro['version'])
        arch = platform.uname()[4]

        # create necessary sub-directories and do other prep work
        build_repo, repo, mock_root = prepare_distro_build(key, arch)

        try:
            mock_chroot = create_mock_config(key, arch, build_repo, repo)
        except NameError:
            print 'fatal error: unable to create mock config for {1}'.format(key)
            return 1

        # TODO check to see user is part of the mock group, mock doesn't work well

        # build packages
        failed_pkgs = []
        for pkg in distro['build_pkgs']:
            try:
                build_pkg(pkg, mock_chroot, mock_root, build_repo)
            except NameError:
                failed_pkgs.append(pkg)

        for pkg in distro['pkgs']:
            try:
                build_pkg(pkg, mock_chroot, mock_root, repo)
            except NameError:
                failed_pkgs.append(pkg)

        # we failed to build packages
        if len(failed_pkgs) > 0:
            print 'WARNING: FAILED TO BUILD PACKAGES!!'
            for pkg in failed_pkgs:
                print '  {0}'.format(pkg)

        print '==== finished building packages for {0} {1}'.format(distro['name'], distro['version'])


if "__main__" in __name__:
    sys.exit(main())