[projects/pld-builder.new.git] / PLD_Builder / rpm_builder.py

# vi: encoding=utf-8 ts=8 sts=4 sw=4 et

import sys
import os
import atexit
import time
import datetime
import string
import urllib
import urllib2

from config import config, init_conf
from bqueue import B_Queue
import lock
import util
import loop
import path
import status
import log
import chroot
import ftp
import buildlogs
import notify
import build
import report
import install

# *HACK*HACK*HACK*HACK*HACK*HACK*HACK*HACK*HACK*HACK*HACK*HACK*HACK*HACK*HACK*
import socket

socket.myorigsocket=socket.socket

def mysocket(family=socket.AF_INET, type=socket.SOCK_STREAM, proto=0):
    s=socket.myorigsocket(family, type, proto)
    s.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
    return s

socket.socket=mysocket
# *HACK*HACK*HACK*HACK*HACK*HACK*HACK*HACK*HACK*HACK*HACK*HACK*HACK*HACK*HACK*

# this code is duplicated in srpm_builder, but we
# might want to handle some cases differently here
def pick_request(q):
    def mycmp(r1, r2):
        if r1.kind != 'group' or r2.kind != 'group':
            raise Exception, "non-group requests"
        pri_diff = cmp(r1.priority, r2.priority)
        if pri_diff == 0:
            return cmp(r1.time, r2.time)
        else:
            return pri_diff
    q.requests.sort(mycmp)
    ret = q.requests[0]
    return ret

def check_skip_build(r, b):
    src_url = config.control_url + "/srpms/" + r.id + "/skipme"
    good  = False
    b.log_line("checking if we should skip the build")
    while not good:
        try:
            headers = { 'Cache-Control': 'no-cache', 'Pragma': 'no-cache' }
            req = urllib2.Request(url=src_url, headers=headers)
            f = urllib2.urlopen(req)
            good = True
        except urllib2.HTTPError, error:
            return False
        except urllib2.URLError, error:
            # see errno.h
            try:
                errno = error.errno
            except AttributeError:
                # python 2.4
                errno = error.reason[0]

            if errno in [-3, 60, 61, 110, 111]:
                b.log_line("unable to connect... trying again")
                continue
            else:
                return False
        f.close()
        return True
    return False

def fetch_src(r, b):
    src_url = config.control_url + "/srpms/" + r.id + "/" + urllib.quote(b.src_rpm)
    b.log_line("fetching %s" % src_url)
    start = time.time()
    good = False
    while not good:
        try:
            headers = { 'Cache-Control': 'no-cache', 'Pragma': 'no-cache' }
            req = urllib2.Request(url=src_url, headers=headers)
            f = urllib2.urlopen(req)
            good = True
        except urllib2.HTTPError, error:
            # fail in a way where cron job will retry
            msg = "unable to fetch url %s, http code: %d" % (src_url, error.code)
            b.log_line(msg)
            queue_time = time.time() - r.time
            # 6 hours
            if error.code != 404 or (queue_time >= 0 and queue_time < (6 * 60 * 60)):
                raise IOError, msg
            else:
                msg = "in queue for more than 6 hours, download failing"
                b.log_line(msg)
                return False
        except urllib2.URLError, error:
            # see errno.h
            try:
                errno = error.errno
            except AttributeError:
                # python 2.4
                errno = error.reason[0]

            if errno in [-3, 60, 61, 110, 111]:
                b.log_line("unable to connect to %s... trying again" % (src_url))
                continue
            else:
                raise

    o = chroot.popen("cat > %s" % b.src_rpm, mode = "w")

    try:
        bytes = util.sendfile(f, o)
    except IOError, e:
        b.log_line("error: unable to write to `%s': %s" % (b.src_rpm, e))
        raise

    f.close()
    o.close()
    t = time.time() - start
    if t == 0:
        b.log_line("fetched %d bytes" % bytes)
    else:
        b.log_line("fetched %d bytes, %.1f K/s" % (bytes, bytes / 1024.0 / t))

def prepare_env(logfile = None):
    chroot.run("""
        test ! -f /proc/uptime && mount /proc 2>/dev/null
        test ! -c /dev/full && rm -f /dev/full && mknod -m 666 /dev/full c 1 7
        test ! -c /dev/null && rm -f /dev/null && mknod -m 666 /dev/null c 1 3
        test ! -c /dev/random && rm -f /dev/random && mknod -m 644 /dev/random c 1 8
        test ! -c /dev/urandom && rm -f /dev/urandom && mknod -m 644 /dev/urandom c 1 9
        test ! -c /dev/zero && rm -f /dev/zero && mknod -m 666 /dev/zero c 1 5

        # need entry for "/" in mtab, for diskspace() to work in rpm
        [ -z $(awk '$2 == "/" {print $1; exit}' /etc/mtab) ] && mount -f -t rootfs rootfs /

        # make neccessary files readable for builder user
        # TODO: see if they really aren't readable for builder
        for db in Packages Name Basenames Providename Pubkeys; do
            db=/var/lib/rpm/$db
            test -f $db && chmod a+r $db
        done

        # try to limit network access for builder account
        /bin/setfacl -m u:builder:--- /etc/resolv.conf
    """, 'root', logfile = logfile)

def build_rpm(r, b):
    packagename = b.get_package_name()
    if not packagename:
        # should not really get here
        b.log_line("error: No .spec not given of malformed: '%s'" % b.spec)
        res = "FAIL_INTERNAL"
        return res

    status.push("building %s (%s)" % (b.spec, packagename))
    b.log_line("request from: %s" % r.requester)

    if check_skip_build(r, b):
        b.log_line("build skipped due to src builder request")
        res = "SKIP_REQUESTED"
        return res

    b.log_line("started at: %s" % time.asctime())
    fetch_src(r, b)
    b.log_line("installing srpm: %s" % b.src_rpm)
    res = chroot.run("""
        set -ex;
        install -d %(topdir)s/{BUILD,RPMS};
        rpm -Uhv --nodeps %(rpmdefs)s %(src_rpm)s;
        rm -f %(src_rpm)s;
    """ % {
        'topdir' : b._topdir,
        'rpmdefs' : b.rpmbuild_opts(),
        'src_rpm' : b.src_rpm
    }, logfile = b.logfile)
    b.files = []

    tmpdir = b.tmpdir()
    if res:
        b.log_line("error: installing src rpm failed")
        res = "FAIL_SRPM_INSTALL"
    else:
        prepare_env()
        b.default_target(config.arch)
        # check for build arch before filling BR
        cmd = "set -ex; TMPDIR=%(tmpdir)s exec nice -n %(nice)s " \
            "rpmbuild -bp --short-circuit --nodeps %(rpmdefs)s --define 'prep exit 0' %(topdir)s/%(spec)s" % {
            'tmpdir': tmpdir,
            'nice' : config.nice,
            'topdir' : b._topdir,
            'rpmdefs' : b.rpmbuild_opts(),
            'spec': b.spec,
        }
        res = chroot.run(cmd, logfile = b.logfile)
        if res:
            res = "UNSUPP"
            b.log_line("error: build arch check (%s) failed" % cmd)

        if not res:
            if ("no-install-br" not in r.flags) and not install.uninstall_self_conflict(b):
                res = "FAIL_DEPS_UNINSTALL"
            if ("no-install-br" not in r.flags) and not install.install_br(r, b):
                res = "FAIL_DEPS_INSTALL"
            if not res:
                max_jobs = max(min(int(os.sysconf('SC_NPROCESSORS_ONLN') + 1), config.max_jobs), 1)
                if r.max_jobs > 0:
                    max_jobs = max(min(config.max_jobs, r.max_jobs), 1)
                cmd = "set -ex; : build-id: %(r_id)s; TMPDIR=%(tmpdir)s exec nice -n %(nice)s " \
                    "rpmbuild -bb --define '_smp_mflags -j%(max_jobs)d' %(rpmdefs)s %(topdir)s/%(spec)s" % {
                    'r_id' : r.id,
                    'tmpdir': tmpdir,
                    'nice' : config.nice,
                    'rpmdefs' : b.rpmbuild_opts(),
                    'topdir' : b._topdir,
                    'max_jobs' : max_jobs,
                    'spec': b.spec,
                }
                b.log_line("building RPM using: %s" % cmd)
                begin_time = time.time()
                res = chroot.run(cmd, logfile = b.logfile)
                end_time = time.time()
                b.log_line("ended at: %s, done in %s" % (time.asctime(), datetime.timedelta(0, end_time - begin_time)))
                if res:
                    res = "FAIL"
                files = util.collect_files(b.logfile, basedir = b._topdir)
                if len(files) > 0:
                    r.chroot_files.extend(files)
                else:
                    b.log_line("error: No files produced.")
                    last_section = util.find_last_section(b.logfile)
                    if last_section == None:
                        res = "FAIL"
                    else:
                        res = "FAIL_%s" % last_section.upper()
                b.files = files

    # cleanup tmp and build files
    chroot.run("""
        set -ex;
        chmod -R u+rwX %(topdir)s/BUILD;
        rm -rf %(topdir)s/{tmp,BUILD}
    """ % {
        'topdir' : b._topdir,
    }, logfile = b.logfile)

    def ll(l):
        util.append_to(b.logfile, l)

    if b.files != []:
        rpm_cache_dir = config.rpm_cache_dir
        if "test-build" not in r.flags:
            # NOTE: copying to cache dir doesn't mean that build failed, so ignore result
            b.log_line("copy rpm files to cache_dir: %s" % rpm_cache_dir)
            chroot.run(
                    "cp -f %s %s && poldek --mo=nodiff --mkidxz -s %s/" % \
                        (string.join(b.files), rpm_cache_dir, rpm_cache_dir),
                     logfile = b.logfile, user = "root"
            )
        else:
            ll("test-build: not copying to " + rpm_cache_dir)
        ll("Begin-PLD-Builder-Info")
        if "upgrade" in r.flags:
            b.upgraded = install.upgrade_from_batch(r, b)
        else:
            ll("not upgrading")
        ll("End-PLD-Builder-Info")

    for f in b.files:
        local = r.tmp_dir + os.path.basename(f)
        chroot.cp(f, outfile = local, rm = True)
        ftp.add(local)

    # cleanup all remains from this build
    chroot.run("""
        set -ex;
        rm -rf %(topdir)s;
    """ % {
        'topdir' : b._topdir,
    }, logfile = b.logfile)

    def uploadinfo(b):
        c="file:SRPMS:%s\n" % b.src_rpm
        for f in b.files:
            c=c + "file:ARCH:%s\n" % os.path.basename(f)
        c=c + "END\n"
        return c

    if config.gen_upinfo and b.files != [] and 'test-build' not in r.flags:
        fname = r.tmp_dir + b.src_rpm + ".uploadinfo"
        f = open(fname, "w")
        f.write(uploadinfo(b))
        f.close()
        ftp.add(fname, "uploadinfo")

    status.pop()

    return res

def handle_request(r):
    ftp.init(r)
    buildlogs.init(r)
    build.build_all(r, build_rpm)
    report.send_report(r, is_src = False)
    ftp.flush()
    notify.send(r)

def check_load():
    do_exit = 0
    try:
        f = open("/proc/loadavg")
        if float(string.split(f.readline())[2]) > config.max_load:
            do_exit = 1
    except:
        pass
    if do_exit:
        sys.exit(0)

def main_for(builder):
    msg = ""

    init_conf(builder)

    q = B_Queue(path.queue_file + "-" + config.builder)
    q.lock(0)
    q.read()
    if q.requests == []:
        q.unlock()
        return
    req = pick_request(q)
    q.unlock()

    # high priority tasks have priority < 0, normal tasks >= 0
    if req.priority >= 0:

        # allow only one build in given builder at once
        if not lock.lock("building-rpm-for-%s" % config.builder, non_block = 1):
            return
        # don't kill server
        check_load()
        # not more then job_slots builds at once
        locked = 0
        for slot in range(config.job_slots):
            if lock.lock("building-rpm-slot-%d" % slot, non_block = 1):
                locked = 1
                break
        if not locked:
            return

        # record fact that we got lock for this builder, load balancer
        # will use it for fair-queuing
        l = lock.lock("got-lock")
        f = open(path.got_lock_file, "a")
        f.write(config.builder + "\n")
        f.close()
        l.close()
    else:
        msg = "HIGH PRIORITY: "

    msg += "handling request %s (%d) for %s from %s, priority %s" \
            % (req.id, req.no, config.builder, req.requester, req.priority)
    log.notice(msg)
    status.push(msg)
    handle_request(req)
    status.pop()

    def otherreqs(r):
        if r.no==req.no:
            return False
        else:
            return True

    q = B_Queue(path.queue_file + "-" + config.builder)
    q.lock(0)
    q.read()
    previouslen=len(q.requests)
    q.requests=filter(otherreqs, q.requests)
    if len(q.requests)<previouslen:
        q.write()
    q.unlock()

def main():
    if len(sys.argv) < 2:
        raise Exception, "fatal: need to have builder name as first arg"
    return main_for(sys.argv[1])

if __name__ == '__main__':
    loop.run_loop(main)
Commit	Line	Data
dfff8bd5 MM	1	# vi: encoding=utf-8 ts=8 sts=4 sw=4 et
dfff8bd5 MM	2
3ea4b156 MM	3	import sys
	4	import os
	5	import atexit
	6	import time
8152253f	7	import datetime
deda9a51	8	import string
3458d3ee	9	import urllib
10764658	10	import urllib2
3ea4b156 MM	11
	12	from config import config, init_conf
	13	from bqueue import B_Queue
3ea4b156 MM	14	import lock
3ea4b156 MM	15	import util
3f446d8f	16	import loop
3ea4b156 MM	17	import path
	18	import status
	19	import log
	20	import chroot
	21	import ftp
e2cad913	22	import buildlogs
59ce7cd6	23	import notify
17f23d66 MM	24	import build
17f23d66 MM	25	import report
73bdb36b	26	import install
3ea4b156	27
53989cf3 MM	28	# HACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACK
	29	import socket
	30
	31	socket.myorigsocket=socket.socket
	32
	33	def mysocket(family=socket.AF_INET, type=socket.SOCK_STREAM, proto=0):
dfff8bd5 MM	34	s=socket.myorigsocket(family, type, proto)
	35	s.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
	36	return s
53989cf3 MM	37
	38	socket.socket=mysocket
	39	# HACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACKHACK
	40
3ea4b156 MM	41	# this code is duplicated in srpm_builder, but we
	42	# might want to handle some cases differently here
	43	def pick_request(q):
dfff8bd5 MM	44	def mycmp(r1, r2):
dfff8bd5 MM	45	if r1.kind != 'group' or r2.kind != 'group':
939af6d7	46	raise Exception, "non-group requests"
dfff8bd5 MM	47	pri_diff = cmp(r1.priority, r2.priority)
	48	if pri_diff == 0:
	49	return cmp(r1.time, r2.time)
	50	else:
bbed4c4d	51	return pri_diff
dfff8bd5 MM	52	q.requests.sort(mycmp)
	53	ret = q.requests[0]
	54	return ret
3ea4b156	55
5c91097f	56	def check_skip_build(r, b):
6ce49c66	57	src_url = config.control_url + "/srpms/" + r.id + "/skipme"
79141e52	58	good = False
9143deab	59	b.log_line("checking if we should skip the build")
6ce49c66 AM	60	while not good:
6ce49c66 AM	61	try:
aa90a502 AM	62	headers = { 'Cache-Control': 'no-cache', 'Pragma': 'no-cache' }
	63	req = urllib2.Request(url=src_url, headers=headers)
	64	f = urllib2.urlopen(req)
29526c54	65	good = True
f1d6a788	66	except urllib2.HTTPError, error:
70f0fc62	67	return False
10764658 AM	68	except urllib2.URLError, error:
10764658 AM	69	# see errno.h
70f0fc62 ER	70	try:
	71	errno = error.errno
	72	except AttributeError:
	73	# python 2.4
	74	errno = error.reason[0]
	75
	76	if errno in [-3, 60, 61, 110, 111]:
6ce49c66 AM	77	b.log_line("unable to connect... trying again")
	78	continue
	79	else:
	80	return False
29526c54	81	f.close()
b8acd415	82	return True
6ce49c66 AM	83	return False
6ce49c66 AM	84
17f23d66	85	def fetch_src(r, b):
3458d3ee	86	src_url = config.control_url + "/srpms/" + r.id + "/" + urllib.quote(b.src_rpm)
dfff8bd5 MM	87	b.log_line("fetching %s" % src_url)
dfff8bd5 MM	88	start = time.time()
29526c54	89	good = False
dfff8bd5 MM	90	while not good:
dfff8bd5 MM	91	try:
aa90a502 AM	92	headers = { 'Cache-Control': 'no-cache', 'Pragma': 'no-cache' }
	93	req = urllib2.Request(url=src_url, headers=headers)
	94	f = urllib2.urlopen(req)
29526c54	95	good = True
f1d6a788 AM	96	except urllib2.HTTPError, error:
f1d6a788 AM	97	# fail in a way where cron job will retry
deddea65	98	msg = "unable to fetch url %s, http code: %d" % (src_url, error.code)
f1d6a788	99	b.log_line(msg)
2a7e772f AM	100	queue_time = time.time() - r.time
2a7e772f AM	101	# 6 hours
02bb30ae	102	if error.code != 404 or (queue_time >= 0 and queue_time < (6 * 60 * 60)):
2a7e772f AM	103	raise IOError, msg
2a7e772f AM	104	else:
ec3ee349	105	msg = "in queue for more than 6 hours, download failing"
2a7e772f AM	106	b.log_line(msg)
2a7e772f AM	107	return False
10764658 AM	108	except urllib2.URLError, error:
10764658 AM	109	# see errno.h
70f0fc62 ER	110	try:
	111	errno = error.errno
	112	except AttributeError:
	113	# python 2.4
	114	errno = error.reason[0]
	115
	116	if errno in [-3, 60, 61, 110, 111]:
deddea65	117	b.log_line("unable to connect to %s... trying again" % (src_url))
e0226a74	118	continue
dfff8bd5	119	else:
85d03545	120	raise
dfff8bd5 MM	121
dfff8bd5 MM	122	o = chroot.popen("cat > %s" % b.src_rpm, mode = "w")
9e89ce60 AM	123
	124	try:
	125	bytes = util.sendfile(f, o)
	126	except IOError, e:
00a1db68	127	b.log_line("error: unable to write to `%s': %s" % (b.src_rpm, e))
9e89ce60 AM	128	raise
9e89ce60 AM	129
dfff8bd5 MM	130	f.close()
	131	o.close()
	132	t = time.time() - start
	133	if t == 0:
	134	b.log_line("fetched %d bytes" % bytes)
	135	else:
	136	b.log_line("fetched %d bytes, %.1f K/s" % (bytes, bytes / 1024.0 / t))
3ea4b156	137
266325ca	138	def prepare_env(logfile = None):
3cf6c853	139	chroot.run("""
efb9c5f7	140	test ! -f /proc/uptime && mount /proc 2>/dev/null
3cf6c853 ER	141	test ! -c /dev/full && rm -f /dev/full && mknod -m 666 /dev/full c 1 7
	142	test ! -c /dev/null && rm -f /dev/null && mknod -m 666 /dev/null c 1 3
	143	test ! -c /dev/random && rm -f /dev/random && mknod -m 644 /dev/random c 1 8
	144	test ! -c /dev/urandom && rm -f /dev/urandom && mknod -m 644 /dev/urandom c 1 9
	145	test ! -c /dev/zero && rm -f /dev/zero && mknod -m 666 /dev/zero c 1 5
	146
cfbb8475	147	# need entry for "/" in mtab, for diskspace() to work in rpm
4a8b119a	148	[ -z $(awk '$2 == "/" {print $1; exit}' /etc/mtab) ] && mount -f -t rootfs rootfs /
cfbb8475	149
3cf6c853 ER	150	# make neccessary files readable for builder user
	151	# TODO: see if they really aren't readable for builder
	152	for db in Packages Name Basenames Providename Pubkeys; do
	153	db=/var/lib/rpm/$db
	154	test -f $db && chmod a+r $db
	155	done
	156
	157	# try to limit network access for builder account
	158	/bin/setfacl -m u:builder:--- /etc/resolv.conf
266325ca	159	""", 'root', logfile = logfile)
84c6175b	160
17f23d66	161	def build_rpm(r, b):
266325ca ER	162	packagename = b.get_package_name()
266325ca ER	163	if not packagename:
4e14a9bc ER	164	# should not really get here
	165	b.log_line("error: No .spec not given of malformed: '%s'" % b.spec)
	166	res = "FAIL_INTERNAL"
	167	return res
	168
4e14a9bc	169	status.push("building %s (%s)" % (b.spec, packagename))
dfff8bd5	170	b.log_line("request from: %s" % r.requester)
6ce49c66	171
5c91097f	172	if check_skip_build(r, b):
6ce49c66 AM	173	b.log_line("build skipped due to src builder request")
	174	res = "SKIP_REQUESTED"
	175	return res
	176
dfff8bd5 MM	177	b.log_line("started at: %s" % time.asctime())
	178	fetch_src(r, b)
	179	b.log_line("installing srpm: %s" % b.src_rpm)
ffc633c5	180	res = chroot.run("""
4e14a9bc	181	set -ex;
266325ca	182	install -d %(topdir)s/{BUILD,RPMS};
242d917b	183	rpm -Uhv --nodeps %(rpmdefs)s %(src_rpm)s;
4e14a9bc ER	184	rm -f %(src_rpm)s;
4e14a9bc ER	185	""" % {
266325ca	186	'topdir' : b._topdir,
4e14a9bc ER	187	'rpmdefs' : b.rpmbuild_opts(),
	188	'src_rpm' : b.src_rpm
	189	}, logfile = b.logfile)
dfff8bd5	190	b.files = []
508a95ef	191
266325ca	192	tmpdir = b.tmpdir()
dfff8bd5 MM	193	if res:
dfff8bd5 MM	194	b.log_line("error: installing src rpm failed")
511ece79	195	res = "FAIL_SRPM_INSTALL"
deda9a51	196	else:
84c6175b	197	prepare_env()
be264f26	198	b.default_target(config.arch)
81c135f6	199	# check for build arch before filling BR
4e14a9bc	200	cmd = "set -ex; TMPDIR=%(tmpdir)s exec nice -n %(nice)s " \
266325ca	201	"rpmbuild -bp --short-circuit --nodeps %(rpmdefs)s --define 'prep exit 0' %(topdir)s/%(spec)s" % {
4e14a9bc ER	202	'tmpdir': tmpdir,
4e14a9bc ER	203	'nice' : config.nice,
266325ca	204	'topdir' : b._topdir,
4e14a9bc	205	'rpmdefs' : b.rpmbuild_opts(),
4e14a9bc ER	206	'spec': b.spec,
4e14a9bc ER	207	}
81c135f6	208	res = chroot.run(cmd, logfile = b.logfile)
4f2d26fb	209	if res:
511ece79	210	res = "UNSUPP"
a957e64f	211	b.log_line("error: build arch check (%s) failed" % cmd)
81c135f6 ER	212
81c135f6 ER	213	if not res:
feb26777	214	if ("no-install-br" not in r.flags) and not install.uninstall_self_conflict(b):
511ece79	215	res = "FAIL_DEPS_UNINSTALL"
feb26777	216	if ("no-install-br" not in r.flags) and not install.install_br(r, b):
511ece79	217	res = "FAIL_DEPS_INSTALL"
73bdb36b	218	if not res:
1de1342f	219	max_jobs = max(min(int(os.sysconf('SC_NPROCESSORS_ONLN') + 1), config.max_jobs), 1)
85303822	220	if r.max_jobs > 0:
a1b28a50	221	max_jobs = max(min(config.max_jobs, r.max_jobs), 1)
4e14a9bc	222	cmd = "set -ex; : build-id: %(r_id)s; TMPDIR=%(tmpdir)s exec nice -n %(nice)s " \
266325ca	223	"rpmbuild -bb --define '_smp_mflags -j%(max_jobs)d' %(rpmdefs)s %(topdir)s/%(spec)s" % {
4e14a9bc ER	224	'r_id' : r.id,
	225	'tmpdir': tmpdir,
	226	'nice' : config.nice,
	227	'rpmdefs' : b.rpmbuild_opts(),
266325ca	228	'topdir' : b._topdir,
4e14a9bc ER	229	'max_jobs' : max_jobs,
	230	'spec': b.spec,
	231	}
81c135f6	232	b.log_line("building RPM using: %s" % cmd)
efb3621d	233	begin_time = time.time()
81c135f6	234	res = chroot.run(cmd, logfile = b.logfile)
efb3621d	235	end_time = time.time()
8152253f	236	b.log_line("ended at: %s, done in %s" % (time.asctime(), datetime.timedelta(0, end_time - begin_time)))
4f2d26fb AM	237	if res:
4f2d26fb AM	238	res = "FAIL"
a73fab54	239	files = util.collect_files(b.logfile, basedir = b._topdir)
81c135f6 ER	240	if len(files) > 0:
	241	r.chroot_files.extend(files)
	242	else:
	243	b.log_line("error: No files produced.")
2b9e7381 AM	244	last_section = util.find_last_section(b.logfile)
	245	if last_section == None:
	246	res = "FAIL"
	247	else:
	248	res = "FAIL_%s" % last_section.upper()
81c135f6 ER	249	b.files = files
81c135f6 ER	250
b9b4ac17	251	# cleanup tmp and build files
4e14a9bc ER	252	chroot.run("""
4e14a9bc ER	253	set -ex;
266325ca	254	chmod -R u+rwX %(topdir)s/BUILD;
b9b4ac17	255	rm -rf %(topdir)s/{tmp,BUILD}
266325ca	256	""" % {
266325ca	257	'topdir' : b._topdir,
266325ca	258	}, logfile = b.logfile)
dfff8bd5 MM	259
	260	def ll(l):
	261	util.append_to(b.logfile, l)
e6376553	262
dfff8bd5	263	if b.files != []:
fd499dc1	264	rpm_cache_dir = config.rpm_cache_dir
e936beda	265	if "test-build" not in r.flags:
adc1235e	266	# NOTE: copying to cache dir doesn't mean that build failed, so ignore result
90d9480e	267	b.log_line("copy rpm files to cache_dir: %s" % rpm_cache_dir)
adc1235e	268	chroot.run(
fd499dc1 ER	269	"cp -f %s %s && poldek --mo=nodiff --mkidxz -s %s/" % \
	270	(string.join(b.files), rpm_cache_dir, rpm_cache_dir),
	271	logfile = b.logfile, user = "root"
	272	)
e936beda	273	else:
fd499dc1	274	ll("test-build: not copying to " + rpm_cache_dir)
dfff8bd5 MM	275	ll("Begin-PLD-Builder-Info")
dfff8bd5 MM	276	if "upgrade" in r.flags:
73bdb36b	277	b.upgraded = install.upgrade_from_batch(r, b)
dfff8bd5 MM	278	else:
	279	ll("not upgrading")
	280	ll("End-PLD-Builder-Info")
deda9a51	281
1051562e	282	for f in b.files:
dfff8bd5	283	local = r.tmp_dir + os.path.basename(f)
3e689257	284	chroot.cp(f, outfile = local, rm = True)
dfff8bd5	285	ftp.add(local)
1051562e	286
b9b4ac17 ER	287	# cleanup all remains from this build
	288	chroot.run("""
	289	set -ex;
	290	rm -rf %(topdir)s;
	291	""" % {
	292	'topdir' : b._topdir,
	293	}, logfile = b.logfile)
	294
dfff8bd5 MM	295	def uploadinfo(b):
	296	c="file:SRPMS:%s\n" % b.src_rpm
	297	for f in b.files:
	298	c=c + "file:ARCH:%s\n" % os.path.basename(f)
	299	c=c + "END\n"
	300	return c
3ea4b156	301
71a06b82	302	if config.gen_upinfo and b.files != [] and 'test-build' not in r.flags:
dfff8bd5 MM	303	fname = r.tmp_dir + b.src_rpm + ".uploadinfo"
	304	f = open(fname, "w")
	305	f.write(uploadinfo(b))
	306	f.close()
	307	ftp.add(fname, "uploadinfo")
	308
	309	status.pop()
	310
	311	return res
3ea4b156	312
17f23d66	313	def handle_request(r):
dfff8bd5 MM	314	ftp.init(r)
	315	buildlogs.init(r)
	316	build.build_all(r, build_rpm)
	317	report.send_report(r, is_src = False)
	318	ftp.flush()
63319e0a	319	notify.send(r)
3ea4b156 MM	320
3ea4b156 MM	321	def check_load():
dfff8bd5 MM	322	do_exit = 0
	323	try:
	324	f = open("/proc/loadavg")
	325	if float(string.split(f.readline())[2]) > config.max_load:
	326	do_exit = 1
	327	except:
	328	pass
	329	if do_exit:
	330	sys.exit(0)
3ea4b156	331
e8ee9db8	332	def main_for(builder):
b8ec18af AM	333	msg = ""
b8ec18af AM	334
dfff8bd5	335	init_conf(builder)
dfff8bd5	336
dfff8bd5 MM	337	q = B_Queue(path.queue_file + "-" + config.builder)
	338	q.lock(0)
	339	q.read()
	340	if q.requests == []:
	341	q.unlock()
	342	return
	343	req = pick_request(q)
7b16924c	344	q.unlock()
dfff8bd5	345
91112237 AM	346	# high priority tasks have priority < 0, normal tasks >= 0
91112237 AM	347	if req.priority >= 0:
b8ec18af AM	348
	349	# allow only one build in given builder at once
	350	if not lock.lock("building-rpm-for-%s" % config.builder, non_block = 1):
	351	return
	352	# don't kill server
	353	check_load()
	354	# not more then job_slots builds at once
	355	locked = 0
	356	for slot in range(config.job_slots):
	357	if lock.lock("building-rpm-slot-%d" % slot, non_block = 1):
	358	locked = 1
	359	break
	360	if not locked:
	361	return
	362
	363	# record fact that we got lock for this builder, load balancer
	364	# will use it for fair-queuing
	365	l = lock.lock("got-lock")
	366	f = open(path.got_lock_file, "a")
	367	f.write(config.builder + "\n")
	368	f.close()
	369	l.close()
	370	else:
	371	msg = "HIGH PRIORITY: "
e6376553	372
b8ec18af AM	373	msg += "handling request %s (%d) for %s from %s, priority %s" \
b8ec18af AM	374	% (req.id, req.no, config.builder, req.requester, req.priority)
dfff8bd5 MM	375	log.notice(msg)
	376	status.push(msg)
	377	handle_request(req)
	378	status.pop()
	379
	380	def otherreqs(r):
	381	if r.no==req.no:
	382	return False
	383	else:
	384	return True
	385
	386	q = B_Queue(path.queue_file + "-" + config.builder)
	387	q.lock(0)
	388	q.read()
	389	previouslen=len(q.requests)
	390	q.requests=filter(otherreqs, q.requests)
	391	if len(q.requests)<previouslen:
	392	q.write()
	393	q.unlock()
e6376553	394
e8ee9db8	395	def main():
dfff8bd5	396	if len(sys.argv) < 2:
939af6d7	397	raise Exception, "fatal: need to have builder name as first arg"
dfff8bd5	398	return main_for(sys.argv[1])
e6376553	399
e8ee9db8	400	if __name__ == '__main__':
dfff8bd5	401	loop.run_loop(main)