| #!/usr/bin/python |
| import os, re, md5 |
| |
| valid_users = r'(apw|mbligh|andyw|korgtest)' |
| build_stock = re.compile('build generic stock (2\.\S+)') |
| build_url = re.compile('build generic url \S*/linux-(2\.\d\.\d+(\.\d+)?(-rc\d+)?).tar') |
| valid_kernel= re.compile('2\.\d\.\d+(\.\d+)?(-rc\d+)?(-(git|bk))\d+') |
| |
| statuses = ['NOSTATUS', 'ERROR', 'ABORT', 'FAIL', 'WARN', 'GOOD'] |
| status_num = {} |
| for x in range(0, len(statuses)): |
| status_num[statuses[x]] = x |
| |
| |
| def shorten_patch(long): |
| short = os.path.basename(long) |
| short = re.sub(r'^patch-', '', short) |
| short = re.sub(r'\.(bz2|gz)$', '', short) |
| short = re.sub(r'\.patch$', '', short) |
| short = re.sub(r'\+', '_', short) |
| return short |
| |
| |
| class job: |
| def __init__(self, dir, type): |
| self.dir = dir |
| self.type = type |
| self.control = os.path.join(dir, "control") |
| self.status = os.path.join(dir, "status") |
| self.machine = '' |
| self.variables = {} |
| self.tests = [] |
| self.kernel = None |
| |
| self.grope_status() |
| |
| |
| def grope_status(self): |
| # HACK. we don't have proper build tags in the status file yet |
| # so we hardcode build/ and do it at the start of the job |
| build = os.path.join(self.dir, 'build') |
| if os.path.exists(build): |
| self.kernel = kernel(build) |
| |
| if not os.path.exists(self.status): |
| return |
| |
| for line in open(self.status, 'r').readlines(): |
| (status, testname, reason) = line.rstrip().split(' ', 2) |
| |
| self.tests.append(test(testname, status, reason, self.kernel)) |
| |
| |
| class kernel: |
| def __init__(self, builddir): |
| self.base = None |
| self.patches = [] |
| |
| log = os.path.join(builddir, 'debug/build_log') |
| if not os.path.exists(log): |
| return |
| patch_hashes = [] |
| for line in open(log, 'r'): |
| print line |
| (type, rest) = line.split(': ', 1) |
| words = rest.split() |
| if type == 'BUILD VERSION': |
| self.base = words[0] |
| if type == 'PATCH': |
| print words |
| self.patches.append(patch(*words[0:])) |
| # patch_hashes.append(words[2]) |
| self.kernel_hash = self.get_kver_hash(self.base, patch_hashes) |
| |
| |
| def get_kver_hash(self, base, patch_hashes): |
| """\ |
| Calculate a hash representing the unique combination of |
| the kernel base version plus |
| """ |
| key_string = ','.join([base] + patch_hashes) |
| return md5.new(key_string).hexdigest() |
| |
| |
| class patch: |
| def __init__(self, spec, reference=None, hash=None): |
| # NEITHER OF THE ABOVE SHOULD HAVE DEFAULTS!!!! HACK HACK |
| if not reference: |
| reference = spec |
| print 'PATCH::%s %s %s' % (spec, reference, hash) |
| self.spec = spec |
| self.reference = reference |
| self.hash = hash |
| |
| |
| class test: |
| def __init__(self, dir, status, reason, kernel): |
| self.dir = dir |
| self.status = status |
| self.reason = reason |
| self.keyval = os.path.join(dir, 'results/keyval') |
| self.iterations = [] |
| self.testname = re.sub(r'\..*', '', self.dir) |
| self.kernel = kernel |
| |
| if not os.path.exists(self.keyval): |
| self.keyval = None |
| return |
| count = 1 |
| lines = [] |
| for line in open(self.keyval, 'r').readlines(): |
| if not re.search('\S'): # blank line |
| self.iterations.append(iteration(count, lines)) |
| lines = [] |
| count += 1 |
| next |
| else: |
| lines.append(line) |
| if lines: |
| self.iterations.append(iteration(count, lines)) |
| |
| |
| class iteration: |
| def __init__(self, index, lines): |
| self.index = index |
| self.keyval = {} |
| |
| for line in lines: |
| (key, value) = line.split('=', 1) |
| self.keyval[key] = value |