config: Create a temporary directory

[pbs.git] / src / buildservice / config.py

#!/usr/bin/python3

import asyncio
import collections
import configparser
import io
import logging
import logging.handlers
import pakfire

from . import base

# Setup logging
log = logging.getLogger("pbs.config")

class PakfireConfig(base.Object):
	def init(self, distro=None, repos=None, vendor=None, contact=None,
			arch=None, include_source=False, mirrored=True, build=None, logger=None):
		self.distro = distro
		self.repos = set()

		# Overwritten for user repositories
		self.vendor = vendor
		self.contact = contact

		# Architecture
		self.arch = arch

		# Should the configuration include the source repositories?
		self.include_source = include_source

		# Should the repositories use any mirrors?
		self.mirrored = mirrored

		# Is this for a build?
		self.build = build

		# Log messages to here
		self.logger = logger

		# Add all repositories belonging to the distribution
		if self.distro:
			for repo in self.distro.repos:
				self.add_repo(repo)

		# Add any repositories
		if repos:
			for repo in repos:
				self.add_repo(repo)

	def __str__(self):
		config = self._make_config()

		return self._to_string(config)

	def _to_string(self, config):
		buffer = io.StringIO()
		config.write(buffer)

		return buffer.getvalue()

	def _log(self, level, message):
		# Remove any trailing newline (but only one)
		if message:
			message = message.removesuffix("\n")

		# Log to the logger if configured
		if self.logger:
			return self.logger(level, message)

		return log.log(level, message)

	# Repositories

	def add_repo(self, repo):
		"""
			Adds a repository to this configuration
		"""
		self.repos.add(repo)

		# Add any sibling repositories
		self.repos.update(repo.parents)

	# Context

	async def __aenter__(self):
		f = io.StringIO()

		# Make configuration
		config = self._make_config(local=True)

		# Write the configuration to the buffer
		config.write(f)
		f.seek(0)

		log.debug("Launching Pakfire with configuration:\n%s", f.getvalue())

		# Launch a new Pakfire instance (in a separate thread)
		async with self.backend.tempdir() as d:
			return await asyncio.to_thread(pakfire.Pakfire, path=d, arch=self.arch,
				conf=f, logger=self._log, offline=False)

	async def __aexit__(self, type, value, traceback):
		pass

	def _make_config(self, local=False):
		"""
			Generates the configuration file
		"""
		config = configparser.ConfigParser(interpolation=None,
			default_section="general")

		# Apply some general settings
		if local:
			config["general"] = {
				"cache_path" : self.backend.path(".cache"),
			}

		# Add the distro configuration
		if self.distro:
			self.distro.write_config(config, local=local,
				vendor=self.vendor, contact=self.contact)

		# Add the repository configurations
		for repo in self.repos:
			repo.write_config(config, local=local, include_source=self.include_source,
				mirrored=self.mirrored, build=self.build)

		return config


class PakfireLogger(object):
	"""
		This is a simple logger instance which collects all log
		messages which can in the end be exported to for example being stored in the database.
	"""
	id = 0

	class QueueHandler(logging.handlers.QueueHandler):
		"""
			This calls overwrites the enqueue() method so that
			we can use an alternative queue which allows us to
			iterate over its data without removing anything.
		"""
		def enqueue(self, record):
			self.queue.append(record)

	def __init__(self, level=logging.DEBUG):
		# Create a new child logger
		self.log = log.getChild("logger-%s" % self.id)
		self.log.setLevel(level)

		# Increment the ID
		self.id += 1

		# Propagate messages to the parent logger
		self.log.propagate = True

		# Create a new queue to buffer any messages
		self.queue = collections.deque()

		# Create a log formatter
		formatter = logging.Formatter(
			"%(asctime)s %(levelname)-8s %(message)s"
		)

		# Create a queue handler
		handler = self.QueueHandler(self.queue)
		handler.setFormatter(formatter)

		# Register the queue with the logger
		self.log.addHandler(handler)

	def __call__(self, *args, **kwargs):
		"""
			Logs a message
		"""
		return self.log.log(*args, **kwargs)

	def __str__(self):
		"""
			Returns the entire log as a string
		"""
		return "\n".join((record.getMessage() for record in self.queue))