messages: Fix wrong variable name

[ipfire.org.git] / src / backend / messages.py

#!/usr/bin/python3

import email
import email.mime.multipart
import email.mime.text
import email.utils
import logging
import random
import subprocess
import tornado.locale
import tornado.template

from . import accounts
from . import misc
from . import util
from .decorators import *

class Messages(misc.Object):
	@lazy_property
	def queue(self):
		return Queue(self.backend)

	@lazy_property
	def template_loader(self):
		"""
			Creates a new template loader
		"""
		templates_dir = self.backend.config.get("global", "templates_dir")
		assert templates_dir

		return tornado.template.Loader(templates_dir, autoescape=None)

	def make_recipient(self, recipient):
		# Use the contact instead of the account
		if isinstance(recipient, accounts.Account):
			recipient = recipient.email_to

		# Fall back to pass on strings
		return recipient

	def make_msgid(self):
		return email.utils.make_msgid("ipfire", domain="ipfire.org")

	@property
	def bounce_email_address(self):
		return self.settings.get("bounce_email_address")

	def _send(self, recipients, message, sender=None, priority=0):
		if not recipients:
			raise ValueError("Empty list of recipients")

		# Format recipients
		recipients = [self.make_recipient(r) for r in recipients]

		res = self.db.get("INSERT INTO messages(message, priority, envelope_recipients) \
			VALUES(%s, %s, %s) RETURNING id", message, priority, recipients)

		logging.debug("Message queued with ID %s" % res.id)

	def send(self, recipients, message, priority=0, headers={}):
		# Convert message from string
		if not isinstance(message, email.message.Message):
			message = email.message_from_string(message)

		# Add a message ID if non exsist
		if not "Message-Id" in message and not "Message-ID" in message:
			message.add_header("Message-Id", self.make_msgid())

		# Add any headers
		for k, v in headers:
			try:
				message.replace_header(k, v)
			except KeyError:
				message.add_header(k, v)

		# Read recipients from To: header
		if not recipients:
			recipients = message.get("To").split(", ")

		# Add date if the message doesn't have one already
		if "Date" not in message:
			message.add_header("Date", email.utils.formatdate())

		# Send any errors to the bounce address
		if self.bounce_email_address:
			message.add_header("Errors-To", "<%s>" % self.bounce_email_address)

		# Send the message
		self._send(recipients, message.as_string(), priority=priority)

	def send_template(self, template_name, recipients=[],
			sender=None, priority=0, headers={}, **kwargs):
		"""
			Send a message based on the given template
		"""
		locale = tornado.locale.get("en_US")

		# Create the required namespace to render the message
		namespace = {
			# Generic Stuff
			"backend" : self.backend,

			# Locale
			"locale"  : locale,
			"_"       : locale.translate,
		}
		namespace.update(kwargs)

		# Create an alternating multipart message to show HTML or text
		message = email.mime.multipart.MIMEMultipart("alternative")

		for extension, mimetype in (("txt", "plain"), ("html", "html")):
			try:
				t = self.template_loader.load("%s.%s" % (template_name, extension))
			except IOError as e:
				# Ignore if the HTML template does not exist
				if extension == "html":
					continue

				# Raise all other exceptions
				raise e

			# Render the message
			try:
				message_part = t.generate(**namespace)

			# Reset the rendered template when it could not be rendered
			except:
				self.template_loader.reset()
				raise

			# Parse the message and extract the header
			message_part = email.message_from_string(message_part.decode())

			for header in message_part:
				try:
					message.replace_header(header, message_part[header])
				except KeyError:
					message.add_header(header, message_part[header])

			# Create a MIMEText object out of it
			message_part = email.mime.text.MIMEText(
				message_part.get_payload(), mimetype)

			# Attach the parts to the mime container.
			# According to RFC2046, the last part of a multipart message
			# is preferred.
			message.attach(message_part)

		# Send the message
		self.send(recipients, message, priority=priority, headers=headers)

		# In debug mode, re-compile the templates with every request
		if self.backend.debug:
			self.template_loader.reset()

	async def send_cli(self, template, recipient):
		"""
			Send a test message from the CLI
		"""
		account = self.backend.accounts.get_by_mail(recipient)

		posts = list(self.backend.blog.get_newest(limit=5))

		kwargs = {
			"account"    : account,
			"first_name" : account.first_name,
			"last_name"  : account.last_name,
			"uid"        : account.uid,
			"email"      : account.email,

			# Random activation/reset codes
			"activation_code" : util.random_string(36),
			"reset_code"      : util.random_string(64),

			# The latest blog post
			"post" : random.choice(posts),
		}

		return self.send_template(template, recipients=[recipient,], **kwargs)


class Queue(misc.Object):
	@property
	def messages(self):
		return self.db.query("SELECT * FROM messages \
			WHERE time_sent IS NULL \
				ORDER BY priority DESC, time_created ASC")

	async def send_all(self):
		# Sends all messages
		for message in self.messages:
			self._sendmail(message)

		logging.debug("All messages sent")

	def _sendmail(self, message):
		"""
			Delivers the given message to sendmail.
		"""
		try:
			# Parse the message from what is in the database
			msg = email.message_from_string(message.message)

			logging.debug("Sending a message %s to: %s" % (
				msg.get("Subject"), ", ".join(message.envelope_recipients)
			))

			# Make sendmail command line
			cmd = [
				"/usr/sbin/sendmail",

				# Don't treat a single line with . as end of input
				"-oi",

				# Envelope Sender
				"-f", msg.get("From") or "no-reply@ipfire.org",
			]

			# Envelope Recipients
			cmd += message.envelope_recipients

			# Run sendmail and pipe the email in
			p = subprocess.Popen(cmd, bufsize=0, close_fds=True,
				stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)

			stdout, stderr = p.communicate(message.message.encode("utf-8"))

			# Wait until sendmail has finished
			p.wait()

			if p.returncode:
				self.db.execute("UPDATE messages SET error_message = %s \
					WHERE id = %s", stdout, message.id)

				logging.error("Could not send mail: %s" % stdout)

		# Raise all exceptions
		except:
			raise

		else:
			# After the email has been successfully sent, we mark it as such
			self.db.execute("UPDATE messages SET time_sent = NOW() \
				WHERE id = %s", message.id)

	def cleanup(self):
		logging.debug("Cleaning up message queue")

		self.db.execute("DELETE FROM messages \
			WHERE time_sent IS NOT NULL AND time_sent <= NOW() - '30 day'::interval")