users: Refactor fetching any user data from LDAP

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

#!/usr/bin/python3

import datetime
import email.utils
import ldap
import logging
import pytz
import time

import tornado.locale

from . import base

from .decorators import *

# Setup logging
log = logging.getLogger("pakfire.builservice.users")

# A list of LDAP attributes that we fetch
LDAP_ATTRS = (
	# UID
	"uid",

	# Common Name
	"cn",

	# First & Last Name
	"givenName", "sn"

	# Email Addresses
	"mail",
	"mailAlternateAddress",
)

class Users(base.Object):
	#def init(self):
	#	self.ldap = ldap.LDAP(self.backend)

	@lazy_property
	def ldap(self):
		ldap_uri = self.backend.config.get("ldap", "uri")

		log.debug("Connecting to %s..." % ldap_uri)

		# Establish LDAP connection
		return ldap.initialize(ldap_uri)

	def _get_user(self, query, *args):
		res = self.db.get(query, *args)

		if res:
			return User(self.backend, res.id, data=res)

	def _get_users(self, query, *args):
		res = self.db.query(query, *args)

		for row in res:
			yield User(self.backend, row.id, data=row)

	def __iter__(self):
		users = self._get_users("""
			SELECT
				*
			FROM
				users
			WHERE
				deleted IS FALSE
			ORDER BY
				name
			""",
		)

		return iter(users)

	def __len__(self):
		res = self.db.get("""
			SELECT
				COUNT(*) AS count
			FROM
				users
			WHERE
				deleted IS FALSE
			""",
		)

		return res.count

	def _ldap_query(self, query, attrlist=None, limit=0, search_base=None):
		search_base = self.backend.config.get("ldap", "base")

		log.debug("Performing LDAP query (%s): %s" % (search_base, query))

		t = time.time()

		# Ask for up to 512 results being returned at a time
		page_control = ldap.controls.SimplePagedResultsControl(True, size=512, cookie="")

		results = []
		pages = 0

		# Perform the search
		while True:
			response = self.ldap.search_ext(search_base,
				ldap.SCOPE_SUBTREE, query, attrlist=attrlist, sizelimit=limit,
				serverctrls=[page_control],
			)

			# Fetch all results
			type, data, rmsgid, serverctrls = self.ldap.result3(response)

			# Append to local copy
			results += data
			pages += 1

			controls = [c for c in serverctrls
				if c.controlType == ldap.controls.SimplePagedResultsControl.controlType]

			if not controls:
				break

			# Set the cookie for more results
			page_control.cookie = controls[0].cookie

			# There are no more results
			if not page_control.cookie:
				break

			# Log time it took to perform the query
			log.debug("Query took %.2fms (%s page(s))" % ((time.time() - t) * 1000.0, pages))

		# Return all attributes (without the DN)
		return [attrs for dn, attrs in results]

	def _ldap_get(self, *args, **kwargs):
		results = self._ldap_query(*args, **kwargs)

		# No result
		if not results:
			return {}

		# Too many results?
		elif len(results) > 1:
			raise RuntimeException("Too many results returned for ldap_get()")

		return results[0]

	def create(self, name, notify=False, _attrs=None):
		"""
			Creates a new user
		"""
		user = self._get_user("""
			INSERT INTO
				users(
					name,
					_attrs
				)
			VALUES
				(%s, %s)
			RETURNING
				*
			""", name, _attrs,
		)

		log.debug("Created user %s" % user)

		# Send a welcome email
		if notify:
			user._send_welcome_email()

		return user

	def get_by_id(self, id):
		return self._get_user("SELECT * FROM users \
			WHERE id = %s", id)

	def get_by_name(self, name):
		"""
			Fetch a user by its username
		"""
		# Try to find a local user
		user = self._get_user("""
			SELECT
				*
			FROM
				users
			WHERE
				deleted IS FALSE
			AND
				name = %s
			""", name,
		)
		if user:
			return user

		# Search in LDAP
		res = self._ldap_get(
			"(&"
				"(objectClass=person)"
				"(uid=%s)"
			")" % name,
			attrlist=("uid",),
		)
		if not res:
			return

		# Fetch the UID
		uid = res.get("uid")[0].decode()

		# Create a new user
		return self.create(uid)

	def get_by_email(self, email):
		# Search in LDAP
		res = self._ldap_get(
			"(&"
				"(objectClass=person)"
				"(|"
					"(mail=%s)"
					"(mailAlternateAddress=%s)"
				")"
			")" % (email, email),
			attrlist=("uid",),
		)

		# No results
		if not res:
			return

		# Fetch the UID
		uid = res.get("uid")[0].decode()

		return self.get_by_name(uid)

	def search(self, q, limit=None):
		res = self._ldap_query(
			"(&"
				"(objectClass=person)"
				"(|"
					"(uid=%s)"
					"(cn=*%s*)"
					"(mail=%s)"
					"(mailAlternateAddress=%s)"
				")"
			")" % (q, q, q, q),
			attrlist=("uid",),
			limit=limit,
		)

		# Fetch users
		users = self._get_users("""
			SELECT
				*
			FROM
				users
			WHERE
				deleted IS FALSE
			AND
				name = ANY(%s)
			""", [row.get("uid")[0].decode() for row in res],
		)

		return sorted(users)


class User(base.DataObject):
	table = "users"

	def __repr__(self):
		return "<%s %s>" % (self.__class__.__name__, self.realname)

	def __str__(self):
		return self.realname

	def __hash__(self):
		return hash(self.id)

	def __lt__(self, other):
		if isinstance(other, self.__class__):
			return self.name < other.name

		elif isinstance(other, str):
			return self.name < other

		return NotImplemented

	@property
	def name(self):
		return self.data.name

	def delete(self):
		self._set_attribute("deleted", True)

		# Destroy all sessions
		for session in self.sessions:
			session.destroy()

	# Fetch any attributes from LDAP

	@lazy_property
	def attrs(self):
		return self.backend.users._ldap_get("(uid=%s)" % self.name, attrlist=LDAP_ATTRS)

	def _get_attrs(self, key):
		return [v.decode() for v in self.attrs.get(key, [])]

	def _get_attr(self, key):
		for value in self._get_attrs(key):
			return value

	# Realname

	@property
	def realname(self):
		return self._get_attr("cn") or ""

	@property
	def email(self):
		"""
			The primary email address
		"""
		return self._get_attr("email")

	@property
	def email_to(self):
		"""
			The name/email address of the user in MIME format
		"""
		return email.utils.formataddr((self.name, self.email))

	def send_email(self, *args, **kwargs):
		return self.backend.messages.send_template(
			*args,
			recipient=self,
			locale=self.locale,
			**kwargs,
		)

	def _send_welcome_email(self):
		"""
			Sends a welcome email to the user
		"""
		self.send_email("users/messages/welcome.txt")

	def is_admin(self):
		return self.data.admin is True

	# Locale

	@property
	def locale(self):
		return tornado.locale.get()

	# Timezone

	@property
	def timezone(self, tz=None):
		if tz is None:
			tz = self.data.timezone or ""

		try:
			tz = pytz.timezone(tz)
		except pytz.UnknownTimeZoneError:
			tz = pytz.timezone("UTC")

		return tz

	@property
	def deleted(self):
		return self.data.deleted

	# Avatar

	def avatar(self, size=512):
		"""
			Returns a URL to the avatar the user has uploaded
		"""
		return "https://people.ipfire.org/users/%s.jpg?size=%s" % (self.name, size)

	# Permissions

	def get_perms(self):
		return self.data.perms

	def set_perms(self, perms):
		self._set_attribute("perms", perms or [])

	perms = property(get_perms, set_perms)

	def has_perm(self, user):
		"""
			Check, if the given user has the right to perform administrative
			operations on this user.
		"""
		# Anonymous people have no permission
		if user is None:
			return False

		# Admins always have permission
		if user.is_admin():
			return True

		# Users can edit themselves
		if user == self:
			return True

		# No permission
		return False

	@property
	def sessions(self):
		sessions = self.backend.sessions._get_sessions("""
			SELECT
				*
			FROM
				sessions
			WHERE
				user_id = %s
			AND
				valid_until >= NOW()
			ORDER BY
				created_at
			""", self.id,
		)

		return list(sessions)

	# Quota

	def get_quota(self):
		return self.data.quota

	def set_quota(self, quota):
		self._set_attribute("quota", quota)

	quota = property(get_quota, set_quota)

	def has_exceeded_quota(self, size=None):
		"""
			Returns True if this user has exceeded their quota
		"""
		# Skip quota check if this user has no quota
		if not self.quota:
			return

		return self.disk_usage + (size or 0) >= self.quota

	def check_quota(self, size=None):
		"""
			Determines the user's disk usage
			and raises an exception when the user is over quota.
		"""
		# Raise QuotaExceededError if this user is over quota
		if self.has_exceeded_quota(size=size):
			raise QuotaExceededError

	@lazy_property
	def disk_usage(self):
		"""
			Returns the total disk usage of this user
		"""
		res = self.db.get("""
			SELECT
				disk_usage
			FROM
				user_disk_usages
			WHERE
				user_id = %s""",
			self.id,
		)

		if res:
			return res.disk_usage

		return 0

	# Custom repositories

	@property
	def repos(self):
		"""
			Returns all custom repositories
		"""
		repos = self.backend.repos._get_repositories("""
			SELECT
				*
			FROM
				repositories
			WHERE
				deleted IS FALSE
			AND
				owner_id = %s
			ORDER BY
				name""",
			self.id,
		)

		distros = {}

		# Group by distro
		for repo in repos:
			try:
				distros[repo.distro].append(repo)
			except KeyError:
				distros[repo.distro] = [repo]

		return distros

	def get_repo(self, distro, slug):
		return self.backend.repos._get_repository("""
			SELECT
				*
			FROM
				repositories
			WHERE
				deleted IS FALSE
			AND
				owner_id = %s
			AND
				distro_id = %s
			AND
				slug = %s""",
			self.id,
			distro,
			slug,
		)


class QuotaExceededError(Exception):
	pass