aboutsummaryrefslogtreecommitdiffstats
path: root/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/listener/MailLogger.java
diff options
context:
space:
mode:
Diffstat (limited to 'framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/listener/MailLogger.java')
-rw-r--r--framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/listener/MailLogger.java440
1 files changed, 440 insertions, 0 deletions
diff --git a/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/listener/MailLogger.java b/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/listener/MailLogger.java
new file mode 100644
index 00000000..4b50547f
--- /dev/null
+++ b/framework/src/ant/apache-ant-1.9.6/src/main/org/apache/tools/ant/listener/MailLogger.java
@@ -0,0 +1,440 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+package org.apache.tools.ant.listener;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.util.Enumeration;
+import java.util.Hashtable;
+import java.util.Properties;
+import java.util.StringTokenizer;
+import java.util.Vector;
+
+import org.apache.tools.ant.BuildEvent;
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.DefaultLogger;
+import org.apache.tools.ant.Project;
+import org.apache.tools.ant.taskdefs.email.EmailAddress;
+import org.apache.tools.ant.taskdefs.email.Header;
+import org.apache.tools.ant.taskdefs.email.Mailer;
+import org.apache.tools.ant.taskdefs.email.Message;
+import org.apache.tools.ant.util.ClasspathUtils;
+import org.apache.tools.ant.util.DateUtils;
+import org.apache.tools.ant.util.FileUtils;
+import org.apache.tools.ant.util.StringUtils;
+import org.apache.tools.mail.MailMessage;
+
+/**
+ * Buffers log messages from DefaultLogger, and sends an e-mail with the
+ * results. The following Project properties are used to send the mail.
+ * <ul>
+ * <li> MailLogger.mailhost [default: localhost] - Mail server to use</li>
+ * <li> MailLogger.port [default: 25] - Default port for SMTP </li>
+ * <li> Maillogger.user [no default] - user name for SMTP auth
+ * (requires JavaMail)</li>
+ * <li> Maillogger.password [no default] - password for SMTP auth
+ * (requires JavaMail)</li>
+ * <li> Maillogger.ssl [default: false] - on or true if ssl is
+ * needed (requires JavaMail)</li>
+ * <li> MailLogger.from [required] - Mail "from" address</li>
+ * <li> MailLogger.from [no default] - Mail "replyto" address(es),
+ * comma-separated</li>
+ * <li> MailLogger.failure.notify [default: true] - Send build failure
+ * e-mails?</li>
+ * <li> MailLogger.success.notify [default: true] - Send build success
+ * e-mails?</li>
+ * <li> MailLogger.failure.to [required if failure mail to be sent] - Address
+ * to send failure messages to</li>
+ * <li> MailLogger.success.to [required if success mail to be sent] - Address
+ * to send success messages to</li>
+ * <li> MailLogger.failure.cc [no default] - Address
+ * to send failure messages to carbon copy (cc)</li>
+ * <li> MailLogger.success.to [no default] - Address
+ * to send success messages to carbon copy (cc)</li>
+ * <li> MailLogger.failure.bcc [no default] - Address
+ * to send failure messages to blind carbon copy (bcc)</li>
+ * <li> MailLogger.success.bcc [no default] - Address
+ * to send success messages to blind carbon copy (bcc)</li>
+ * <li> MailLogger.failure.subject [default: "Build Failure"] - Subject of
+ * failed build</li>
+ * <li> MailLogger.success.subject [default: "Build Success"] - Subject of
+ * successful build</li>
+ * <li> MailLogger.failure.body [default: none] - fixed text of
+ * mail body for a failed build, default is to send the logfile</li>
+ * <li> MailLogger.success.body [default: none] - fixed text of
+ * mail body for a successful build, default is to send the logfile</li>
+ * <li> MailLogger.mimeType [default: text/plain] - MIME-Type of email</li>
+ * <li> MailLogger.charset [no default] - character set of email</li>
+ * <li> Maillogger.starttls.enable [default: false] - on or true if
+ * STARTTLS should be supported (requires JavaMail)</li>
+ * <li> MailLogger.properties.file [no default] - Filename of
+ * properties file that will override other values.</li>
+ * </ul>
+ * These properties are set using standard Ant property setting mechanisms
+ * (&lt;property&gt;, command-line -D, etc). Ant properties can be overridden
+ * by specifying the filename of a properties file in the <i>
+ * MailLogger.properties.file property</i> . Any properties defined in that
+ * file will override Ant properties.
+ *
+ */
+public class MailLogger extends DefaultLogger {
+ /** Buffer in which the message is constructed prior to sending */
+ private StringBuffer buffer = new StringBuffer();
+
+ private static final String DEFAULT_MIME_TYPE = "text/plain";
+
+ /**
+ * Sends an e-mail with the log results.
+ *
+ * @param event the build finished event
+ */
+ public void buildFinished(BuildEvent event) {
+ super.buildFinished(event);
+
+ Project project = event.getProject();
+ Hashtable<String, Object> properties = project.getProperties();
+
+ // overlay specified properties file (if any), which overrides project
+ // settings
+ Properties fileProperties = new Properties();
+ String filename = (String) properties.get("MailLogger.properties.file");
+ if (filename != null) {
+ InputStream is = null;
+ try {
+ is = new FileInputStream(filename);
+ fileProperties.load(is);
+ } catch (IOException ioe) {
+ // ignore because properties file is not required
+ } finally {
+ FileUtils.close(is);
+ }
+ }
+
+ for (Enumeration<?> e = fileProperties.keys(); e.hasMoreElements();) {
+ String key = (String) e.nextElement();
+ String value = fileProperties.getProperty(key);
+ properties.put(key, project.replaceProperties(value));
+ }
+
+ boolean success = (event.getException() == null);
+ String prefix = success ? "success" : "failure";
+
+ try {
+ boolean notify = Project.toBoolean(getValue(properties,
+ prefix + ".notify", "on"));
+
+ if (!notify) {
+ return;
+ }
+ Values values = new Values()
+ .mailhost(getValue(properties, "mailhost", "localhost"))
+ .port(Integer.parseInt(
+ getValue(
+ properties, "port",
+ String.valueOf(MailMessage.DEFAULT_PORT))))
+ .user(getValue(properties, "user", ""))
+ .password(getValue(properties, "password", ""))
+ .ssl(Project.toBoolean(getValue(properties,
+ "ssl", "off")))
+ .starttls(Project.toBoolean(getValue(properties,
+ "starttls.enable", "off")))
+ .from(getValue(properties, "from", null))
+ .replytoList(getValue(properties, "replyto", ""))
+ .toList(getValue(properties, prefix + ".to", null))
+ .toCcList(getValue(properties, prefix + ".cc", ""))
+ .toBccList(getValue(properties, prefix + ".bcc", ""))
+ .mimeType(getValue(properties, "mimeType", DEFAULT_MIME_TYPE))
+ .charset(getValue(properties, "charset", ""))
+ .body(getValue(properties, prefix + ".body", ""))
+ .subject(getValue(
+ properties, prefix + ".subject",
+ (success) ? "Build Success" : "Build Failure"));
+ if (values.user().equals("")
+ && values.password().equals("")
+ && !values.ssl() && !values.starttls()) {
+ sendMail(values, buffer.substring(0));
+ } else {
+ sendMimeMail(
+ event.getProject(), values, buffer.substring(0));
+ }
+ } catch (Exception e) {
+ System.out.println("MailLogger failed to send e-mail!");
+ e.printStackTrace(System.err);
+ }
+ }
+
+ private static class Values {
+ private String mailhost;
+ public String mailhost() {
+ return mailhost;
+ }
+ public Values mailhost(String mailhost) {
+ this.mailhost = mailhost;
+ return this;
+ }
+ private int port;
+ public int port() {
+ return port;
+ }
+ public Values port(int port) {
+ this.port = port;
+ return this;
+ }
+ private String user;
+ public String user() {
+ return user;
+ }
+ public Values user(String user) {
+ this.user = user;
+ return this;
+ }
+ private String password;
+ public String password() {
+ return password;
+ }
+ public Values password(String password) {
+ this.password = password;
+ return this;
+ }
+ private boolean ssl;
+ public boolean ssl() {
+ return ssl;
+ }
+ public Values ssl(boolean ssl) {
+ this.ssl = ssl;
+ return this;
+ }
+ private String from;
+ public String from() {
+ return from;
+ }
+ public Values from(String from) {
+ this.from = from;
+ return this;
+ }
+ private String replytoList;
+ public String replytoList() {
+ return replytoList;
+ }
+ public Values replytoList(String replytoList) {
+ this.replytoList = replytoList;
+ return this;
+ }
+ private String toList;
+ public String toList() {
+ return toList;
+ }
+ public Values toList(String toList) {
+ this.toList = toList;
+ return this;
+ }
+ private String toCcList;
+ public String toCcList() {
+ return toCcList;
+ }
+ public Values toCcList(String toCcList) {
+ this.toCcList = toCcList;
+ return this;
+ }
+ private String toBccList;
+ public String toBccList() {
+ return toBccList;
+ }
+ public Values toBccList(String toBccList) {
+ this.toBccList = toBccList;
+ return this;
+ }
+ private String subject;
+ public String subject() {
+ return subject;
+ }
+ public Values subject(String subject) {
+ this.subject = subject;
+ return this;
+ }
+ private String charset;
+ public String charset() {
+ return charset;
+ }
+ public Values charset(String charset) {
+ this.charset = charset;
+ return this;
+ }
+ private String mimeType;
+ public String mimeType() {
+ return mimeType;
+ }
+ public Values mimeType(String mimeType) {
+ this.mimeType = mimeType;
+ return this;
+ }
+ private String body;
+ public String body() {
+ return body;
+ }
+ public Values body(String body) {
+ this.body = body;
+ return this;
+ }
+ private boolean starttls;
+ public boolean starttls() {
+ return starttls;
+ }
+ public Values starttls(boolean starttls) {
+ this.starttls = starttls;
+ return this;
+ }
+ }
+
+ /**
+ * Receives and buffers log messages.
+ *
+ * @param message the message being logger
+ */
+ protected void log(String message) {
+ buffer.append(message).append(StringUtils.LINE_SEP);
+ }
+
+
+ /**
+ * Gets the value of a property.
+ *
+ * @param properties Properties to obtain value from
+ * @param name suffix of property name. "MailLogger." will be
+ * prepended internally.
+ * @param defaultValue value returned if not present in the properties.
+ * Set to null to make required.
+ * @return The value of the property, or default value.
+ * @exception Exception thrown if no default value is specified and the
+ * property is not present in properties.
+ */
+ private String getValue(Hashtable<String, Object> properties, String name,
+ String defaultValue) throws Exception {
+ String propertyName = "MailLogger." + name;
+ String value = (String) properties.get(propertyName);
+
+ if (value == null) {
+ value = defaultValue;
+ }
+
+ if (value == null) {
+ throw new Exception("Missing required parameter: " + propertyName);
+ }
+
+ return value;
+ }
+
+
+ /**
+ * Send the mail
+ * @param values the various values.
+ * @param message mail body
+ * @exception IOException thrown if sending message fails
+ */
+ private void sendMail(Values values, String message) throws IOException {
+ MailMessage mailMessage = new MailMessage(
+ values.mailhost(), values.port());
+ mailMessage.setHeader("Date", DateUtils.getDateForHeader());
+
+ mailMessage.from(values.from());
+ if (!values.replytoList().equals("")) {
+ StringTokenizer t = new StringTokenizer(
+ values.replytoList(), ", ", false);
+ while (t.hasMoreTokens()) {
+ mailMessage.replyto(t.nextToken());
+ }
+ }
+ StringTokenizer t = new StringTokenizer(values.toList(), ", ", false);
+ while (t.hasMoreTokens()) {
+ mailMessage.to(t.nextToken());
+ }
+
+ mailMessage.setSubject(values.subject());
+
+ if (values.charset().length() > 0) {
+ mailMessage.setHeader("Content-Type", values.mimeType()
+ + "; charset=\"" + values.charset() + "\"");
+ } else {
+ mailMessage.setHeader("Content-Type", values.mimeType());
+ }
+
+ PrintStream ps = mailMessage.getPrintStream();
+ ps.println(values.body().length() > 0 ? values.body() : message);
+
+ mailMessage.sendAndClose();
+ }
+ /**
+ * Send the mail (MimeMail)
+ * @param project current ant project
+ * @param values various values
+ * @param message mail body
+ */
+ private void sendMimeMail(Project project, Values values, String message) {
+ Mailer mailer = null;
+ try {
+ mailer = (Mailer) ClasspathUtils.newInstance(
+ "org.apache.tools.ant.taskdefs.email.MimeMailer",
+ MailLogger.class.getClassLoader(), Mailer.class);
+ } catch (BuildException e) {
+ Throwable t = e.getCause() == null ? e : e.getCause();
+ log("Failed to initialise MIME mail: " + t.getMessage());
+ return;
+ }
+ // convert the replyTo string into a vector of emailaddresses
+ Vector<EmailAddress> replyToList = vectorizeEmailAddresses(values.replytoList());
+ mailer.setHost(values.mailhost());
+ mailer.setPort(values.port());
+ mailer.setUser(values.user());
+ mailer.setPassword(values.password());
+ mailer.setSSL(values.ssl());
+ mailer.setEnableStartTLS(values.starttls());
+ Message mymessage =
+ new Message(values.body().length() > 0 ? values.body() : message);
+ mymessage.setProject(project);
+ mymessage.setMimeType(values.mimeType());
+ if (values.charset().length() > 0) {
+ mymessage.setCharset(values.charset());
+ }
+ mailer.setMessage(mymessage);
+ mailer.setFrom(new EmailAddress(values.from()));
+ mailer.setReplyToList(replyToList);
+ Vector<EmailAddress> toList = vectorizeEmailAddresses(values.toList());
+ mailer.setToList(toList);
+ Vector<EmailAddress> toCcList = vectorizeEmailAddresses(values.toCcList());
+ mailer.setCcList(toCcList);
+ Vector<EmailAddress> toBccList = vectorizeEmailAddresses(values.toBccList());
+ mailer.setBccList(toBccList);
+ mailer.setFiles(new Vector<File>());
+ mailer.setSubject(values.subject());
+ mailer.setHeaders(new Vector<Header>());
+ mailer.send();
+ }
+ private Vector<EmailAddress> vectorizeEmailAddresses(String listString) {
+ Vector<EmailAddress> emailList = new Vector<EmailAddress>();
+ StringTokenizer tokens = new StringTokenizer(listString, ",");
+ while (tokens.hasMoreTokens()) {
+ emailList.addElement(new EmailAddress(tokens.nextToken()));
+ }
+ return emailList;
+ }
+}
+
+