Don't iterate over deleted repositories

[people/jschlag/pbs.git] / src / buildservice / __init__.py

#!/usr/bin/python

from __future__ import absolute_import

import ConfigParser
import logging
import os
import pakfire

from . import arches
from . import bugtracker
from . import builders
from . import builds
from . import cache
from . import database
from . import distribution
from . import geoip
from . import jobqueue
from . import keys
from . import logs
from . import messages
from . import mirrors
from . import packages
from . import repository
from . import settings
from . import sessions
from . import sources
from . import updates
from . import uploads
from . import users

log = logging.getLogger("backend")
log.propagate = 1

# Import version
from .__version__ import VERSION as __version__

from .decorators import *
from .constants import *

class Backend(object):
	def __init__(self, config_file=None):
		# Read configuration file.
		self.config = self.read_config(config_file)

		# Global pakfire settings (from database).
		self.settings = settings.Settings(self)

		self.arches      = arches.Arches(self)
		self.builds      = builds.Builds(self)
		self.cache       = cache.Cache(self)
		self.geoip       = geoip.GeoIP(self)
		self.jobs        = builds.Jobs(self)
		self.builders    = builders.Builders(self)
		self.distros     = distribution.Distributions(self)
		self.jobqueue    = jobqueue.JobQueue(self)
		self.keys        = keys.Keys(self)
		self.messages    = messages.Messages(self)
		self.mirrors     = mirrors.Mirrors(self)
		self.packages    = packages.Packages(self)
		self.repos       = repository.Repositories(self)
		self.sessions    = sessions.Sessions(self)
		self.sources     = sources.Sources(self)
		self.updates     = updates.Updates(self)
		self.uploads     = uploads.Uploads(self)
		self.users       = users.Users(self)

		# Open a connection to bugzilla.
		self.bugzilla    = bugtracker.Bugzilla(self)

		# A pool to store strings (for comparison).
		self.pool        = pakfire.satsolver.Pool("dummy")

	def read_config(self, path):
		c = ConfigParser.SafeConfigParser()

		# Load default configuration file first
		paths = [
			os.path.join(CONFIGSDIR, "pbs.conf"),
		]

		if path:
			paths.append(path)

		# Load all configuration files
		for path in paths:
			log.debug("Loading configuration from %s" % path)
			c.read(path)

		return c

	@lazy_property
	def db(self):
		name     = self.config.get("database", "name")
		hostname = self.config.get("database", "hostname")
		user     = self.config.get("database", "user")
		password = self.config.get("database", "password")

		log.debug("Connecting to database %s @ %s" % (name, hostname))

		return database.Connection(hostname, name, user=user, password=password)

	def cleanup_files(self):
		query = self.db.query("SELECT * FROM queue_delete")

		for row in query:
			if not row.path:
				continue

			path = os.path.join(PACKAGES_DIR, row.path)

			try:
				logging.debug("Removing %s..." % path)
				os.unlink(path)
			except OSError, e:
				logging.error("Could not remove %s: %s" % (path, e))

			while True:			
				path = os.path.dirname(path)

				# Stop if we are running outside of the tree.
				if not path.startswith(PACKAGES_DIR):
					break

				# If the directory is not empty, we cannot remove it.
				if os.path.exists(path) and os.listdir(path):
					break

				try:
					logging.debug("Removing %s..." % path)
					os.rmdir(path)
				except OSError, e:
					logging.error("Could not remove %s: %s" % (path, e))
					break

			self.db.execute("DELETE FROM queue_delete WHERE id = %s", row.id)