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

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

import re
import gzip
import time
import StringIO
import os
import fcntl
import string
import tempfile

# PLD_Builder:
import gpg
import request
import util
import log

class B_Queue:
    def __init__(self, filename):
        self.name = filename
        self.requests = []
        self.fd = None

    def dump(self, fname):
        (fdno, tmpfname) = tempfile.mkstemp(dir=os.path.dirname(fname))
        f = os.fdopen(fdno, "w")
        self.requests.reverse()
        for r in self.requests:
            r.dump(f)
        self.requests.reverse()
        f.flush()
        os.fsync(f.fileno())
        f.close()
        os.chmod(tmpfname, 0644)
        os.rename(tmpfname, fname)

    def dump_html(self, fname):
        (fdno, tmpfname) = tempfile.mkstemp(dir=os.path.dirname(fname))
        f = os.fdopen(fdno, "w")
        f.write("""
<html>
    <head>
    <link rel="Shortcut Icon" href="http://www.pld-linux.org/favicon.ico"/>
        <title>PLD builder queue</title>
        <link rel="stylesheet" type="text/css" charset="utf-8" media="all" href="style.css">
        <script type="text/javascript" src="script.js"></script>
    </head>
<body>\n"""
        )
        self.requests.reverse()
        for r in self.requests:
            r.dump_html(f)
        self.requests.reverse()
        f.write("</body></html>\n")
        f.flush()
        os.fsync(f.fileno())
        f.close()
        os.chmod(tmpfname, 0644)
        os.rename(tmpfname, fname)

    # read possibly compressed, signed queue
    def read_signed(self):
        if re.search(r"\.gz$", self.name):
            f = gzip.open(self.name)
        else:
            f = open(self.name)
        (signers, body) = gpg.verify_sig(f.read())
        self.signers = signers
        self.requests = request.parse_requests(body)

    def _open(self):
        if self.fd == None:
            if os.access(self.name, os.F_OK):
                self.fd = open(self.name, "r+")
            else:
                self.fd = open(self.name, "w+")
        
    def read(self):
        self._open()
        self.signers = []
        body = self.fd.read()
        if string.strip(body) == "":
            # empty file, don't choke
            self.requests = []
            return
        try:
            self.requests = request.parse_requests(body)
        except Exception, e:
            log.panic("error parsing %s: %s" % (self.name, e))
            pass

    def _write_to(self, f):
        f.write("<queue>\n")
        for r in self.requests:
            r.write_to(f)
        f.write("</queue>\n")

    def write(self):
        self._open()
        self.fd.seek(0)
        self.fd.truncate(0)
        self._write_to(self.fd)
        self.fd.flush()

    def lock(self, no_block):
        self._open()
        op = fcntl.LOCK_EX
        if no_block:
            op = op + fcntl.LOCK_NB
        try:
            fcntl.flock(self.fd, op)
            return 1
        except IOError:
            return 0
    
    def unlock(self):
        fcntl.flock(self.fd, fcntl.LOCK_UN)

    def write_signed(self, name):
        sio = StringIO.StringIO()
        self._write_to(sio)
        sio.seek(0)
        sio.write(gpg.sign(sio.read()))
        sio.seek(0)
        (fdno, tmpname) = tempfile.mkstemp(dir=os.path.dirname(name))
        f = os.fdopen(fdno, "w")
        if re.search(r"\.gz$", name):
            fgz = gzip.GzipFile(filename=name, mode="w", compresslevel=6, fileobj=f)
            util.sendfile(sio, fgz)
            fgz.close()
        else:
            util.sendfile(sio, f)
        f.flush()
        os.fsync(f.fileno())
        f.close()
        os.chmod(tmpname, 0644)
        os.rename(tmpname, name)

    def add(self, req):
        self.requests.append(req)

    def value(self):
        return self.requests
Commit	Line	Data
dfff8bd5 MM	1	# vi: encoding=utf-8 ts=8 sts=4 sw=4 et
dfff8bd5 MM	2
cf1741af MM	3	import re
	4	import gzip
	5	import time
	6	import StringIO
	7	import os
	8	import fcntl
41f786ac	9	import string
8d15cbfe	10	import tempfile
cf1741af MM	11
	12	# PLD_Builder:
	13	import gpg
	14	import request
4d9b6f71	15	import util
f50e2253	16	import log
cf1741af MM	17
cf1741af MM	18	class B_Queue:
dfff8bd5 MM	19	def __init__(self, filename):
	20	self.name = filename
	21	self.requests = []
	22	self.fd = None
cf1741af	23
8d15cbfe	24	def dump(self, fname):
d1e5eeef	25	(fdno, tmpfname) = tempfile.mkstemp(dir=os.path.dirname(fname))
1ac7da2a	26	f = os.fdopen(fdno, "w")
dfff8bd5	27	self.requests.reverse()
a82562d3 AM	28	for r in self.requests:
a82562d3 AM	29	r.dump(f)
dfff8bd5	30	self.requests.reverse()
8d15cbfe AM	31	f.flush()
	32	os.fsync(f.fileno())
	33	f.close()
	34	os.chmod(tmpfname, 0644)
	35	os.rename(tmpfname, fname)
	36
3c00bb2c	37	def dump_html(self, fname):
d1e5eeef	38	(fdno, tmpfname) = tempfile.mkstemp(dir=os.path.dirname(fname))
1ac7da2a	39	f = os.fdopen(fdno, "w")
a0877b58	40	f.write("""
6d31e66e ER	41	<html>
	42	<head>
	43	<link rel="Shortcut Icon" href="http://www.pld-linux.org/favicon.ico"/>
	44	<title>PLD builder queue</title>
	45	<link rel="stylesheet" type="text/css" charset="utf-8" media="all" href="style.css">
04ce7f54	46	<script type="text/javascript" src="script.js"></script>
6d31e66e ER	47	</head>
	48	<body>\n"""
	49	)
dfff8bd5 MM	50	self.requests.reverse()
dfff8bd5 MM	51	for r in self.requests:
3c00bb2c	52	r.dump_html(f)
dfff8bd5 MM	53	self.requests.reverse()
dfff8bd5 MM	54	f.write("</body></html>\n")
3c00bb2c AM	55	f.flush()
	56	os.fsync(f.fileno())
	57	f.close()
	58	os.chmod(tmpfname, 0644)
	59	os.rename(tmpfname, fname)
04ce7f54	60
dfff8bd5 MM	61	# read possibly compressed, signed queue
	62	def read_signed(self):
	63	if re.search(r"\.gz$", self.name):
	64	f = gzip.open(self.name)
	65	else:
	66	f = open(self.name)
24a365b4	67	(signers, body) = gpg.verify_sig(f.read())
dfff8bd5 MM	68	self.signers = signers
dfff8bd5 MM	69	self.requests = request.parse_requests(body)
cf1741af	70
dfff8bd5 MM	71	def _open(self):
	72	if self.fd == None:
	73	if os.access(self.name, os.F_OK):
	74	self.fd = open(self.name, "r+")
	75	else:
	76	self.fd = open(self.name, "w+")
	77
	78	def read(self):
	79	self._open()
	80	self.signers = []
5180bf1f AM	81	body = self.fd.read()
5180bf1f AM	82	if string.strip(body) == "":
dfff8bd5 MM	83	# empty file, don't choke
	84	self.requests = []
	85	return
798d3c8e ER	86	try:
	87	self.requests = request.parse_requests(body)
	88	except Exception, e:
	89	log.panic("error parsing %s: %s" % (self.name, e))
	90	pass
cf1741af	91
dfff8bd5 MM	92	def _write_to(self, f):
	93	f.write("<queue>\n")
	94	for r in self.requests:
	95	r.write_to(f)
	96	f.write("</queue>\n")
cf1741af	97
dfff8bd5 MM	98	def write(self):
	99	self._open()
	100	self.fd.seek(0)
	101	self.fd.truncate(0)
	102	self._write_to(self.fd)
	103	self.fd.flush()
	104
	105	def lock(self, no_block):
	106	self._open()
	107	op = fcntl.LOCK_EX
	108	if no_block:
	109	op = op + fcntl.LOCK_NB
	110	try:
	111	fcntl.flock(self.fd, op)
	112	return 1
	113	except IOError:
	114	return 0
	115
	116	def unlock(self):
	117	fcntl.flock(self.fd, fcntl.LOCK_UN)
cf1741af	118
dfff8bd5 MM	119	def write_signed(self, name):
	120	sio = StringIO.StringIO()
	121	self._write_to(sio)
	122	sio.seek(0)
3c505749	123	sio.write(gpg.sign(sio.read()))
8d15cbfe	124	sio.seek(0)
d1e5eeef	125	(fdno, tmpname) = tempfile.mkstemp(dir=os.path.dirname(name))
1ac7da2a	126	f = os.fdopen(fdno, "w")
dfff8bd5	127	if re.search(r"\.gz$", name):
8d15cbfe AM	128	fgz = gzip.GzipFile(filename=name, mode="w", compresslevel=6, fileobj=f)
	129	util.sendfile(sio, fgz)
	130	fgz.close()
dfff8bd5	131	else:
8d15cbfe AM	132	util.sendfile(sio, f)
	133	f.flush()
	134	os.fsync(f.fileno())
dfff8bd5	135	f.close()
8d15cbfe	136	os.chmod(tmpname, 0644)
567a1858	137	os.rename(tmpname, name)
cf1741af	138
dfff8bd5 MM	139	def add(self, req):
dfff8bd5 MM	140	self.requests.append(req)
cf1741af	141
dfff8bd5 MM	142	def value(self):
dfff8bd5 MM	143	return self.requests