/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at legal-notices/CDDLv1_0.txt
* or http://forgerock.org/license/CDDLv1.0.html.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at legal-notices/CDDLv1_0.txt.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information:
* Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*
*
* Copyright 2008 Sun Microsystems, Inc.
* Portions Copyright 2014-2015 ForgeRock AS
* Portions copyright 2015 Edan Idzerda
*/
package org.opends.server.extensions;
import static org.opends.messages.ExtensionMessages.*;
import static org.opends.server.util.StaticUtils.*;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Properties;
import java.util.Set;
import org.forgerock.i18n.LocalizableMessage;
import org.forgerock.i18n.LocalizableMessageBuilder;
import org.forgerock.i18n.slf4j.LocalizedLogger;
import org.forgerock.opendj.config.server.ConfigException;
import org.forgerock.opendj.ldap.ByteString;
import org.forgerock.opendj.ldap.ResultCode;
import org.forgerock.util.Utils;
import org.opends.server.admin.server.ConfigurationChangeListener;
import org.opends.server.admin.std.server.AccountStatusNotificationHandlerCfg;
import org.opends.server.admin.std.server.SMTPAccountStatusNotificationHandlerCfg;
import org.opends.server.api.AccountStatusNotificationHandler;
import org.opends.server.core.DirectoryServer;
import org.opends.server.types.AccountStatusNotification;
import org.opends.server.types.AccountStatusNotificationProperty;
import org.opends.server.types.AccountStatusNotificationType;
import org.opends.server.types.Attribute;
import org.opends.server.types.AttributeType;
import org.forgerock.opendj.config.server.ConfigChangeResult;
import org.opends.server.types.Entry;
import org.opends.server.types.InitializationException;
import org.opends.server.util.EMailMessage;
/**
* This class provides an implementation of an account status notification
* handler that can send e-mail messages via SMTP to end users and/or
* administrators whenever an account status notification occurs. The e-mail
* messages will be generated from template files, which contain the information
* to use to create the message body. The template files may contain plain
* text, in addition to the following tokens:
* <UL>
* <LI>%%notification-type%% -- Will be replaced with the name of the
* account status notification type for the notification.</LI>
* <LI>%%notification-message%% -- Will be replaced with the message for the
* account status notification.</LI>
* <LI>%%notification-user-dn%% -- Will be replaced with the string
* representation of the DN for the user that is the target of the
* account status notification.</LI>
* <LI>%%notification-user-attr:attrname%% -- Will be replaced with the value
* of the attribute specified by attrname from the user's entry. If the
* specified attribute has multiple values, then the first value
* encountered will be used. If the specified attribute does not have any
* values, then it will be replaced with an emtpy string.</LI>
* <LI>%%notification-property:propname%% -- Will be replaced with the value
* of the specified notification property from the account status
* notification. If the specified property has multiple values, then the
* first value encountered will be used. If the specified property does
* not have any values, then it will be replaced with an emtpy
* string.</LI>
* </UL>
*/
public class SMTPAccountStatusNotificationHandler
extends AccountStatusNotificationHandler
<SMTPAccountStatusNotificationHandlerCfg>
implements ConfigurationChangeListener
<SMTPAccountStatusNotificationHandlerCfg>
{
private static final LocalizedLogger logger = LocalizedLogger.getLoggerForThisClass();
/** A mapping between the notification types and the message template. */
private HashMap<AccountStatusNotificationType,
List<NotificationMessageTemplateElement>> templateMap;
/** A mapping between the notification types and the message subject. */
private HashMap<AccountStatusNotificationType,String> subjectMap;
/** The current configuration for this account status notification handler. */
private SMTPAccountStatusNotificationHandlerCfg currentConfig;
/**
* Creates a new, uninitialized instance of this account status notification
* handler.
*/
public SMTPAccountStatusNotificationHandler()
{
super();
}
/** {@inheritDoc} */
@Override
public void initializeStatusNotificationHandler(
SMTPAccountStatusNotificationHandlerCfg configuration)
throws ConfigException, InitializationException
{
currentConfig = configuration;
currentConfig.addSMTPChangeListener(this);
subjectMap = parseSubjects(configuration);
templateMap = parseTemplates(configuration);
// Make sure that the Directory Server is configured with information about
// one or more mail servers.
List<Properties> propList = DirectoryServer.getMailServerPropertySets();
if (propList == null || propList.isEmpty())
{
throw new ConfigException(ERR_SMTP_ASNH_NO_MAIL_SERVERS_CONFIGURED.get(configuration.dn()));
}
// Make sure that either an explicit recipient list or a set of email
// address attributes were provided.
Set<AttributeType> mailAttrs = configuration.getEmailAddressAttributeType();
Set<String> recipients = configuration.getRecipientAddress();
if ((mailAttrs == null || mailAttrs.isEmpty()) &&
(recipients == null || recipients.isEmpty()))
{
throw new ConfigException(ERR_SMTP_ASNH_NO_RECIPIENTS.get(configuration.dn()));
}
}
/**
* Examines the provided configuration and parses the message subject
* information from it.
*
* @param configuration The configuration to be examined.
*
* @return A mapping between the account status notification type and the
* subject that should be used for messages generated for
* notifications with that type.
*
* @throws ConfigException If a problem occurs while parsing the subject
* configuration.
*/
private HashMap<AccountStatusNotificationType,String> parseSubjects(
SMTPAccountStatusNotificationHandlerCfg configuration)
throws ConfigException
{
HashMap<AccountStatusNotificationType,String> map = new HashMap<>();
for (String s : configuration.getMessageSubject())
{
int colonPos = s.indexOf(':');
if (colonPos < 0)
{
throw new ConfigException(ERR_SMTP_ASNH_SUBJECT_NO_COLON.get(s, configuration.dn()));
}
String notificationTypeName = s.substring(0, colonPos).trim();
AccountStatusNotificationType t =
AccountStatusNotificationType.typeForName(notificationTypeName);
if (t == null)
{
throw new ConfigException(ERR_SMTP_ASNH_SUBJECT_INVALID_NOTIFICATION_TYPE.get(
s, configuration.dn(), notificationTypeName));
}
else if (map.containsKey(t))
{
throw new ConfigException(ERR_SMTP_ASNH_SUBJECT_DUPLICATE_TYPE.get(
configuration.dn(), notificationTypeName));
}
map.put(t, s.substring(colonPos+1).trim());
if (logger.isTraceEnabled())
{
logger.trace("Subject for notification type " + t.getName() +
": " + map.get(t));
}
}
return map;
}
/**
* Examines the provided configuration and parses the message template
* information from it.
*
* @param configuration The configuration to be examined.
*
* @return A mapping between the account status notification type and the
* template that should be used to generate messages for
* notifications with that type.
*
* @throws ConfigException If a problem occurs while parsing the template
* configuration.
*/
private HashMap<AccountStatusNotificationType,
List<NotificationMessageTemplateElement>> parseTemplates(
SMTPAccountStatusNotificationHandlerCfg configuration)
throws ConfigException
{
HashMap<AccountStatusNotificationType,
List<NotificationMessageTemplateElement>> map = new HashMap<>();
for (String s : configuration.getMessageTemplateFile())
{
int colonPos = s.indexOf(':');
if (colonPos < 0)
{
throw new ConfigException(ERR_SMTP_ASNH_TEMPLATE_NO_COLON.get(s, configuration.dn()));
}
String notificationTypeName = s.substring(0, colonPos).trim();
AccountStatusNotificationType t =
AccountStatusNotificationType.typeForName(notificationTypeName);
if (t == null)
{
throw new ConfigException(ERR_SMTP_ASNH_TEMPLATE_INVALID_NOTIFICATION_TYPE.get(
s, configuration.dn(), notificationTypeName));
}
else if (map.containsKey(t))
{
throw new ConfigException(ERR_SMTP_ASNH_TEMPLATE_DUPLICATE_TYPE.get(
configuration.dn(), notificationTypeName));
}
String path = s.substring(colonPos+1).trim();
File f = new File(path);
if (! f.isAbsolute() )
{
f = new File(DirectoryServer.getInstanceRoot() + File.separator +
path);
}
if (! f.exists())
{
throw new ConfigException(ERR_SMTP_ASNH_TEMPLATE_NO_SUCH_FILE.get(
path, configuration.dn()));
}
map.put(t, parseTemplateFile(f));
if (logger.isTraceEnabled())
{
logger.trace("Decoded template elment list for type " +
t.getName());
}
}
return map;
}
/**
* Parses the specified template file into a list of notification message
* template elements.
*
* @param f A reference to the template file to be parsed.
*
* @return A list of notification message template elements parsed from the
* specified file.
*
* @throws ConfigException If error occurs while attempting to parse the
* template file.
*/
private List<NotificationMessageTemplateElement> parseTemplateFile(File f)
throws ConfigException
{
LinkedList<NotificationMessageTemplateElement> elementList = new LinkedList<>();
BufferedReader reader = null;
try
{
reader = new BufferedReader(new FileReader(f));
int lineNumber = 0;
while (true)
{
String line = reader.readLine();
if (line == null)
{
break;
}
if (logger.isTraceEnabled())
{
logger.trace("Read message template line " + line);
}
lineNumber++;
int startPos = 0;
while (startPos < line.length())
{
int delimPos = line.indexOf("%%", startPos);
if (delimPos < 0)
{
if (logger.isTraceEnabled())
{
logger.trace("No more tokens -- adding text " +
line.substring(startPos));
}
elementList.add(new TextNotificationMessageTemplateElement(
line.substring(startPos)));
break;
}
else
{
if (delimPos > startPos)
{
if (logger.isTraceEnabled())
{
logger.trace("Adding text before token " +
line.substring(startPos));
}
elementList.add(new TextNotificationMessageTemplateElement(
line.substring(startPos, delimPos)));
}
int closeDelimPos = line.indexOf("%%", delimPos+1);
if (closeDelimPos < 0)
{
// There was an opening %% but not a closing one.
throw new ConfigException(
ERR_SMTP_ASNH_TEMPLATE_UNCLOSED_TOKEN.get(
delimPos, lineNumber));
}
else
{
String tokenStr = line.substring(delimPos+2, closeDelimPos);
String lowerTokenStr = toLowerCase(tokenStr);
if (lowerTokenStr.equals("notification-type"))
{
if (logger.isTraceEnabled())
{
logger.trace("Found a notification type token " +
tokenStr);
}
elementList.add(
new NotificationTypeNotificationMessageTemplateElement());
}
else if (lowerTokenStr.equals("notification-message"))
{
if (logger.isTraceEnabled())
{
logger.trace("Found a notification message token " +
tokenStr);
}
elementList.add(
new NotificationMessageNotificationMessageTemplateElement());
}
else if (lowerTokenStr.equals("notification-user-dn"))
{
if (logger.isTraceEnabled())
{
logger.trace("Found a notification user DN token " +
tokenStr);
}
elementList.add(
new UserDNNotificationMessageTemplateElement());
}
else if (lowerTokenStr.startsWith("notification-user-attr:"))
{
String attrName = lowerTokenStr.substring(23);
AttributeType attrType = DirectoryServer.getAttributeTypeOrNull(attrName);
if (attrType == null)
{
throw new ConfigException(
ERR_SMTP_ASNH_TEMPLATE_UNDEFINED_ATTR_TYPE.get(
delimPos, lineNumber, attrName));
}
else
{
if (logger.isTraceEnabled())
{
logger.trace("Found a user attribute token for " +
attrType.getNameOrOID() + " -- " +
tokenStr);
}
elementList.add(
new UserAttributeNotificationMessageTemplateElement(
attrType));
}
}
else if (lowerTokenStr.startsWith("notification-property:"))
{
String propertyName = lowerTokenStr.substring(22);
AccountStatusNotificationProperty property =
AccountStatusNotificationProperty.forName(propertyName);
if (property == null)
{
throw new ConfigException(
ERR_SMTP_ASNH_TEMPLATE_UNDEFINED_PROPERTY.get(
delimPos, lineNumber, propertyName));
}
else
{
if (logger.isTraceEnabled())
{
logger.trace("Found a notification property token " +
"for " + propertyName + " -- " + tokenStr);
}
elementList.add(
new NotificationPropertyNotificationMessageTemplateElement(
property));
}
}
else
{
throw new ConfigException(
ERR_SMTP_ASNH_TEMPLATE_UNRECOGNIZED_TOKEN.get(
tokenStr, delimPos, lineNumber));
}
startPos = closeDelimPos + 2;
}
}
}
// We need to put a CRLF at the end of the line, as per the SMTP spec.
elementList.add(new TextNotificationMessageTemplateElement("\r\n"));
}
return elementList;
}
catch (Exception e)
{
logger.traceException(e);
throw new ConfigException(ERR_SMTP_ASNH_TEMPLATE_CANNOT_PARSE.get(
f.getAbsolutePath(), currentConfig.dn(), getExceptionMessage(e)));
}
finally
{
Utils.closeSilently(reader);
}
}
/** {@inheritDoc} */
@Override
public boolean isConfigurationAcceptable(
AccountStatusNotificationHandlerCfg
configuration,
List<LocalizableMessage> unacceptableReasons)
{
SMTPAccountStatusNotificationHandlerCfg config =
(SMTPAccountStatusNotificationHandlerCfg) configuration;
return isConfigurationChangeAcceptable(config, unacceptableReasons);
}
/** {@inheritDoc} */
@Override
public void handleStatusNotification(AccountStatusNotification notification)
{
SMTPAccountStatusNotificationHandlerCfg config = currentConfig;
HashMap<AccountStatusNotificationType,String> subjects = subjectMap;
HashMap<AccountStatusNotificationType,
List<NotificationMessageTemplateElement>> templates = templateMap;
// First, see if the notification type is one that we handle. If not, then
// return without doing anything.
AccountStatusNotificationType notificationType =
notification.getNotificationType();
List<NotificationMessageTemplateElement> templateElements =
templates.get(notificationType);
if (templateElements == null)
{
if (logger.isTraceEnabled())
{
logger.trace("No message template for notification type " +
notificationType.getName());
}
return;
}
// It is a notification that should be handled, so we can start generating
// the e-mail message. First, check to see if there are any mail attributes
// that would cause us to send a message to the end user.
LinkedList<String> recipients = new LinkedList<>();
Set<AttributeType> addressAttrs = config.getEmailAddressAttributeType();
Set<String> recipientAddrs = config.getRecipientAddress();
if (addressAttrs != null && !addressAttrs.isEmpty())
{
Entry userEntry = notification.getUserEntry();
for (AttributeType t : addressAttrs)
{
List<Attribute> attrList = userEntry.getAttribute(t);
if (attrList != null)
{
for (Attribute a : attrList)
{
for (ByteString v : a)
{
if (logger.isTraceEnabled())
{
logger.trace("Adding end user recipient %s from attr %s",
v, a.getNameWithOptions());
}
recipients.add(v.toString());
}
}
}
}
if (recipients.isEmpty())
{
if (recipientAddrs == null || recipientAddrs.isEmpty())
{
// There are no recipients at all, so there's no point in generating
// the message. Return without doing anything.
if (logger.isTraceEnabled())
{
logger.trace("No end user recipients, and no explicit " +
"recipients");
}
return;
}
else
{
if (! config.isSendMessageWithoutEndUserAddress())
{
// We can't send the message to the end user, and the handler is
// configured to not send only to administrators, so we shouln't
// do anything.
if (logger.isTraceEnabled())
{
logger.trace("No end user recipients, and shouldn't send " +
"without end user recipients");
}
return;
}
}
}
}
// Next, add any explicitly-defined recipients.
if (recipientAddrs != null)
{
if (logger.isTraceEnabled())
{
for (String s : recipientAddrs)
{
logger.trace("Adding explicit recipient " + s);
}
}
recipients.addAll(recipientAddrs);
}
// Get the message subject to use. If none is defined, then use a generic
// subject.
String subject = subjects.get(notificationType);
if (subject == null)
{
subject = INFO_SMTP_ASNH_DEFAULT_SUBJECT.get().toString();
if (logger.isTraceEnabled())
{
logger.trace("Using default subject of " + subject);
}
}
else if (logger.isTraceEnabled())
{
logger.trace("Using per-type subject of " + subject);
}
// Generate the message body.
LocalizableMessageBuilder messageBody = new LocalizableMessageBuilder();
for (NotificationMessageTemplateElement e : templateElements)
{
e.generateValue(messageBody, notification);
}
// Create and send the e-mail message.
EMailMessage message = new EMailMessage(config.getSenderAddress(),
recipients, subject);
message.setBody(messageBody);
if (config.isSendEmailAsHtml())
{
message.setBodyMIMEType("text/html");
}
if (logger.isTraceEnabled())
{
logger.trace("Set message body of " + messageBody);
}
try
{
message.send();
if (logger.isTraceEnabled())
{
logger.trace("Successfully sent the message");
}
}
catch (Exception e)
{
logger.traceException(e);
logger.error(ERR_SMTP_ASNH_CANNOT_SEND_MESSAGE,
notificationType.getName(), notification.getUserDN(), getExceptionMessage(e));
}
}
/** {@inheritDoc} */
@Override
public boolean isConfigurationChangeAcceptable(
SMTPAccountStatusNotificationHandlerCfg configuration,
List<LocalizableMessage> unacceptableReasons)
{
boolean configAcceptable = true;
// Make sure that the Directory Server is configured with information about
// one or more mail servers.
List<Properties> propList = DirectoryServer.getMailServerPropertySets();
if (propList == null || propList.isEmpty())
{
unacceptableReasons.add(ERR_SMTP_ASNH_NO_MAIL_SERVERS_CONFIGURED.get(configuration.dn()));
configAcceptable = false;
}
// Make sure that either an explicit recipient list or a set of email
// address attributes were provided.
Set<AttributeType> mailAttrs = configuration.getEmailAddressAttributeType();
Set<String> recipients = configuration.getRecipientAddress();
if ((mailAttrs == null || mailAttrs.isEmpty()) &&
(recipients == null || recipients.isEmpty()))
{
unacceptableReasons.add(ERR_SMTP_ASNH_NO_RECIPIENTS.get(configuration.dn()));
configAcceptable = false;
}
try
{
parseSubjects(configuration);
}
catch (ConfigException ce)
{
logger.traceException(ce);
unacceptableReasons.add(ce.getMessageObject());
configAcceptable = false;
}
try
{
parseTemplates(configuration);
}
catch (ConfigException ce)
{
logger.traceException(ce);
unacceptableReasons.add(ce.getMessageObject());
configAcceptable = false;
}
return configAcceptable;
}
/** {@inheritDoc} */
@Override
public ConfigChangeResult applyConfigurationChange(
SMTPAccountStatusNotificationHandlerCfg configuration)
{
final ConfigChangeResult ccr = new ConfigChangeResult();
try
{
HashMap<AccountStatusNotificationType,String> subjects =
parseSubjects(configuration);
HashMap<AccountStatusNotificationType,
List<NotificationMessageTemplateElement>> templates =
parseTemplates(configuration);
currentConfig = configuration;
subjectMap = subjects;
templateMap = templates;
}
catch (ConfigException ce)
{
logger.traceException(ce);
ccr.setResultCode(ResultCode.UNWILLING_TO_PERFORM);
ccr.addMessage(ce.getMessageObject());
}
return ccr;
}
}