#!/usr/bin/env python3 # -*- coding: utf-8 -*- import subprocess import logging, logging.handlers from time import time, sleep import re from threading import Thread, Lock from pathlib import Path import os import sys import traceback from config import PKG_COMPRESSION, SHELL_ARCH_ARM64, SHELL_ARCH_X64, \ SHELL_ARM64_ADDITIONAL, SHELL_TRAP, \ CONTAINER_BUILDBOT_ROOT, ARCHS logger = logging.getLogger(f'buildbot.{__name__}') def background(func): def wrapped(*args, **kwargs): tr = Thread(target=func, args=args, kwargs=kwargs) tr.daemon = True tr.start() return tr return wrapped def bash(cmdline, **kwargs): assert type(cmdline) is str logger.info(f'bash: {cmdline}, kwargs: {kwargs}') return(run_cmd(['/bin/bash', '-x', '-e', '-c', cmdline], **kwargs)) def mon_bash(cmdline, seconds=60*30, **kwargs): assert type(seconds) is int and seconds >= 1 return bash(cmdline, keepalive=True, KEEPALIVE_TIMEOUT=60, RUN_CMD_TIMEOUT=seconds, **kwargs) def nspawn_shell(arch, cmdline, cwd=None, **kwargs): root = Path(CONTAINER_BUILDBOT_ROOT) if cwd: cwd = root / cwd else: cwd = root logger.info(f'bash_{arch}: {cmdline}, cwd: {cwd}, kwargs: {kwargs}') if arch in ('aarch64', 'arm64'): command=f'{SHELL_ARM64_ADDITIONAL}; {SHELL_TRAP}; cd \'{cwd}\'; {cmdline}' ret = run_cmd(SHELL_ARCH_ARM64 + [command,], **kwargs) elif arch in ('x64', 'x86', 'x86_64'): command=f'{SHELL_TRAP}; cd \'{cwd}\'; {cmdline}' ret = run_cmd(SHELL_ARCH_X64 + [command,], **kwargs) else: raise TypeError('nspawn_shell: wrong arch') if not ret.endswith('++ exit 0\n'): raise subprocess.CalledProcessError(1, cmdline, ret) return ret def mon_nspawn_shell(arch, cmdline, cwd, seconds=60*30, **kwargs): assert type(seconds) is int and seconds >= 1 return nspawn_shell(arch, cmdline, cwd=cwd, keepalive=True, KEEPALIVE_TIMEOUT=60, RUN_CMD_TIMEOUT=seconds, **kwargs) def run_cmd(cmd, cwd=None, keepalive=False, KEEPALIVE_TIMEOUT=30, RUN_CMD_TIMEOUT=60, logfile=None, short_return=False): logger.debug('run_cmd: %s', cmd) RUN_CMD_LOOP_TIME = KEEPALIVE_TIMEOUT - 1 if KEEPALIVE_TIMEOUT >= 10 else 5 stopped = False last_read = [int(time()), ""] class Output(list): def __init__(self, logfile=None, short_return=False): super().__init__() self.__short_return = short_return if logfile: assert issubclass(type(logfile), os.PathLike) self.__file = open(logfile, 'w') else: self.__file = None def append(self, mystring): if self.__short_return and super().__len__() >= 20: super().pop(0) super().append(mystring) if self.__file and type(mystring) is str: self.__file.write(mystring) def __enter__(self): return self def __exit__(self, type, value, traceback): if self.__file: self.__file.close() stdout_lock = Lock() with Output(logfile=logfile, short_return=short_return) as output: @background def check_stdout(stdout): nonlocal stopped, last_read, output stdout_lock.acquire() last_read_time = int(time()) while stopped is False: line = stdout.readline(4096) if line is '': sleep(0.05) continue line.replace('\x0f', '\n') last_read_time = int(time()) output.append(line) last_read[0] = last_read_time last_read[1] = line stdout_lock.release() p = subprocess.Popen(cmd, cwd=cwd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, encoding='utf-8') check_stdout(p.stdout) process_start = int(time()) while True: try: p.wait(timeout=RUN_CMD_LOOP_TIME) except subprocess.TimeoutExpired: time_passed = int(time()) - last_read[0] if time_passed >= KEEPALIVE_TIMEOUT*2: logger.info('Timeout expired. No action.') output.append('+ Buildbot: Timeout expired. No action.\n') elif time_passed >= KEEPALIVE_TIMEOUT: if keepalive: logger.info('Timeout expired, writing nl') output.append('+ Buildbot: Timeout expired, writing nl\n') p.stdin.write('\n') p.stdin.flush() else: logger.info('Timeout expired, not writing nl') output.append('+ Buildbot: Timeout expired, not writing nl\n') if int(time()) - process_start >= RUN_CMD_TIMEOUT: stopped = True logger.error('Process timeout expired, terminating.') output.append('+ Buildbot: Process timeout expired, terminating.\n') p.terminate() try: p.wait(timeout=10) except subprocess.TimeoutExpired: logger.error('Cannot terminate, killing.') output.append('+ Buildbot: Cannot terminate, killing.\n') p.kill() break else: # sometimes the process ended too quickly and stdout is not captured sleep(0.1) stopped = True break code = p.returncode stdout_lock.acquire(10) outstr = ''.join(output) if code != 0: raise subprocess.CalledProcessError(code, cmd, outstr) return outstr # pyalpm is an alternative # due to lack of documentation i'll consider this later. def vercmp(ver1, ver2): ''' compare ver1 and ver2, return 1, -1, 0 see https://www.archlinux.org/pacman/vercmp.8.html ''' res = run_cmd(['vercmp', str(ver1), str(ver2)]) res = res.strip() if res in ('-1', '0', '1'): return int(res) class Pkg: def __init__(self, pkgname, pkgver, pkgrel, arch, fname): self.pkgname = pkgname self.pkgver = pkgver self.pkgrel = pkgrel self.arch = arch self.fname = fname self.ver = f'{self.pkgver}-{self.pkgrel}' def __eq__(self, ver2): if vercmp(self.ver, ver2.ver) == 0: return True else: return False def __ge__(self, ver2): return self > ver2 or self == ver2 def __gt__(self, ver2): if vercmp(self.ver, ver2.ver) == 1: return True else: return False def __le__(self, ver2): return self < ver2 or self == ver2 def __lt__(self, ver2): if vercmp(self.ver, ver2.ver) == -1: return True else: return False def __repr__(self): return f'Pkg({self.pkgname}, {self.ver}, {self.arch})' def get_pkg_details_from_name(name): assert type(name) is str if name.endswith(f'pkg.tar.{PKG_COMPRESSION}'): m = re.match(r'(.+)-([^-]+)-([^-]+)-([^-]+)\.pkg\.tar\.\w+', name) assert m and m.groups() and len(m.groups()) == 4 (pkgname, pkgver, pkgrel, arch) = m.groups() return Pkg(pkgname, pkgver, pkgrel, arch, name) def get_arch_from_pkgbuild(fpath): assert issubclass(type(fpath), os.PathLike) with open(fpath, 'r') as f: for line in f.read().split('\n'): if line.startswith('arch='): matches = re.findall('[\'\"]([^\'\"]+)[\'\"]', line) if not matches: raise TypeError('Unexpected PKGBUILD format') assert not [None for match in matches if match not in ARCHS] return matches raise TypeError('Unexpected PKGBUILD') def print_exc_plus(): logger.log(49, format_exc_plus()) def format_exc_plus(): """ Print the usual traceback information, followed by a listing of all the local variables in each frame. from Python Cookbook by David Ascher, Alex Martelli """ ret = str() tb = sys.exc_info()[2] while True: if not tb.tb_next: break tb = tb.tb_next stack = [] f = tb.tb_frame while f: stack.append(f) f = f.f_back stack.reverse() ret += traceback.format_exc() ret += "\nLocals by frame, innermost last\n" for frame in stack: ret += "Frame %s in %s at line %s\n" % (frame.f_code.co_name, frame.f_code.co_filename, frame.f_lineno) for key, value in frame.f_locals.items( ): ret += "\t%20s = " % key # We have to be VERY careful not to cause a new error in our error # printer! Calling str( ) on an unknown object could cause an # error we don't want, so we must use try/except to catch it -- # we can't stop it from happening, but we can and should # stop it from propagating if it does happen! try: ret += str(value) except: ret += "" ret += '\n' return ret def configure_logger(logger, format='%(asctime)s - %(name)-18s - %(levelname)s - %(message)s', level=logging.INFO, logfile=None, flevel=logging.INFO, rotate_size=None): class ExceptionFormatter(logging.Formatter): def format(self, record): if record.levelno == 49: record.msg = 'Exception caught.\nPrinting stack traceback\n' + record.msg return super().format(record) logger.setLevel(level) formatter = ExceptionFormatter(fmt=format) logging.addLevelName(49, 'Exception') # create file handler if logfile: assert type(logfile) is str if rotate_size and type(rotate_size) is int and rotate_size >= 1000: fh = logging.handlers.RotatingFileHandler(logfile, mode='a', maxBytes=rotate_size, backupCount=8) else: fh = logging.FileHandler(logfile) fh.setLevel(flevel) fh.setFormatter(formatter) logger.addHandler(fh) # create console handler ch = logging.StreamHandler() ch.setLevel(level) ch.setFormatter(formatter) logger.addHandler(ch)