com/scalagent/joram/mom/dest/mail/JavaMailQueueImpl.java

/*
 * JORAM: Java(TM) Open Reliable Asynchronous Messaging
 * Copyright (C) 2003 - 2008 ScalAgent Distributed Technologies
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA.
 *
 * Initial developer(s): ScalAgent Distributed Technologies
 * Contributor(s): 
 */
package com.scalagent.joram.mom.dest.mail;

import java.util.Enumeration;
import java.util.Properties;
import java.util.Vector;

import org.objectweb.joram.mom.dest.Queue;
import org.objectweb.joram.mom.dest.QueueImpl;
import org.objectweb.joram.mom.notifications.ClientMessages;
import org.objectweb.joram.mom.notifications.SpecialAdminRequest;
import org.objectweb.joram.mom.util.DMQManager;
import org.objectweb.joram.shared.MessageErrorConstants;
import org.objectweb.joram.shared.admin.SpecialAdmin;
import org.objectweb.joram.shared.excepts.RequestException;
import org.objectweb.joram.shared.messages.Message;
import org.objectweb.joram.shared.selectors.Selector;
import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;

import fr.dyade.aaa.agent.AgentId;
import fr.dyade.aaa.util.Debug;

public class JavaMailQueueImpl extends QueueImpl implements JavaMailQueueImplMBean {
  private static final long serialVersionUID = 1L;

  public static Logger logger = Debug.getLogger(JavaMailQueueImpl.class.getName());

  private String smtpServer = null;

  private String to = null;
  private String cc = null;
  private String bcc = null;
  private String from = null;
  private String subject = null;
  private String selector = null;

  private long popPeriod = -1;
  private String popServer = null;
  private String popUser = null;
  private String popPassword = null;
  private boolean expunge = false;

  private Vector senderInfos = null;

  private transient JavaMailUtil javaMailUtil = null;

  public JavaMailQueueImpl(AgentId adminId, Properties prop) {
    super(adminId, prop);
    setProperties(prop);

    if (logger.isLoggable(BasicLevel.DEBUG))
      logger.log(BasicLevel.DEBUG, 
                 "--- " + this + " JavaMailQueueImpl.<init>: " +
                 "\nsenderInfos=" + senderInfos +
                 "\npopServer=" + popServer +
                 "\npopUser=" + popUser +
                 "\npopPeriod=" + popPeriod +
                 "\nexpunge=" + expunge);
  }

  public void setProperties(Properties prop) {
    smtpServer = prop.getProperty("smtpServer", smtpServer);
    to = prop.getProperty("to", to);
    cc = prop.getProperty("cc", cc);
    bcc = prop.getProperty("bcc", bcc);
    from = prop.getProperty("from", from);
    subject = prop.getProperty("subject", subject);
    selector = prop.getProperty("selector", selector);

    // to send mail
    senderInfos = new Vector();
    senderInfos.add(new SenderInfo(smtpServer,
                                   to, cc, bcc, from, subject,
                                   selector));

    try {
      popPeriod = Long.valueOf(prop.getProperty("popPeriod")).longValue();
    } catch (NumberFormatException exc) {
      popPeriod = -1;
    }
    popServer = prop.getProperty("popServer", popServer);
    popUser = prop.getProperty("popUser", popUser);
    popPassword = prop.getProperty("popPassword", popPassword);
    expunge = Boolean.valueOf(prop.getProperty("expunge")).booleanValue();
  }
  
  public void initialize(boolean firstTime) {
    if (logger.isLoggable(BasicLevel.DEBUG))
      logger.log(BasicLevel.DEBUG, "initialize(" + firstTime + ')');
    
    super.initialize(firstTime);

    if (logger.isLoggable(BasicLevel.DEBUG))
      logger.log(BasicLevel.DEBUG, 
                 "--- " + this + " JavaMailQueueImpl.initialize: " +
                 "\nsenderInfos=" + senderInfos +
                 "\npopServer=" + popServer +
                 "\npopUser=" + popUser +
                 "\npopPeriod=" + popPeriod +
                 "\nexpunge=" + expunge);

    javaMailUtil = new JavaMailUtil();
  }

  // ==================================================
  // MBean interface
  // ==================================================
  public String getSMTPServer() {
    return smtpServer;
  }

  public void setSMTPServer(String smtpServer) {
    this.smtpServer = smtpServer;
  }

  public String getDefaultTo() {
    return to;
  }

  public void setDefaultTo(String to) {
    this.to = to;
  }

  public String getDefaultCC() {
    return cc;
  }

  public void setDefaultCC(String cc) {
    this.cc = cc;
  }

  public String getDefaultBcc() {
    return bcc;
  }

  public void setDefaultBcc(String bcc) {
    this.bcc = bcc;
  }

  public String getDefaultFrom() {
    return from;
  }

  public void setDefaultFrom(String from) {
    this.from = from;
  }

  public String getDefaultSubject() {
    return subject;
  }

  public void setDefaultSubject(String subject) {
    this.subject = subject;
  }

  public String getDefaultSelector() {
    return selector;
  }

  public void setDefaultSelector(String selector) {
    this.selector = selector;
  }

  public long getPopPeriod() {
    return popPeriod;
  }

  public void setPopPeriod(long period) {
    popPeriod = period;
  }

  public String getPopServer() {
    return popServer;
  }

  public void setPopServer(String server) {
    this.popServer = server;
  }

  public String getPopUser() {
    return popUser;
  }

  public void setPopUser(String user) {
    this.popUser = user;
  }

  public String getPopPassword() {
    return popPassword;
  }

  public void setPopPassword(String pass) {
    this.popPassword = pass;
  }

  public boolean getExpunge() {
    return expunge;
  }

  public void setExpunge(boolean expunge) {
    this.expunge = expunge;
  }

  // ==================================================

  public String toString() {
    return "JavaMailQueueImpl:" + getId().toString();
  }

  protected Object specialAdminProcess(SpecialAdminRequest not) 
    throws RequestException {

    try {
      SpecialAdmin req = not.getRequest();
      
      if (logger.isLoggable(BasicLevel.DEBUG))
        logger.log(BasicLevel.DEBUG, 
                   "--- " + this + " specialAdminProcess : " + req);
      if (req instanceof AddSenderInfo)
        addSenderInfo(((AddSenderInfo) req).si,
                      ((AddSenderInfo) req).index);
      else if (req instanceof RemoveSenderInfo) {
        if (((RemoveSenderInfo) req).index > -1)
          removeSenderInfo(((RemoveSenderInfo) req).index);
        else 
          removeSenderInfo(((RemoveSenderInfo) req).si);
      }  else if (req instanceof UpdateSenderInfo)
        updateSenderInfo(((UpdateSenderInfo) req).oldSi,
                         ((UpdateSenderInfo) req).newSi);
      
      if (logger.isLoggable(BasicLevel.DEBUG))
        logger.log(BasicLevel.DEBUG, 
                   "--- " + this + " specialAdminProcess senderInfos=" + senderInfos);
    } catch (Exception exc) {
      if (logger.isLoggable(BasicLevel.WARN))
        logger.log(BasicLevel.WARN, 
                   "--- " + this + " specialAdminProcess", exc);
      throw new RequestException(exc.getMessage());
    }
    return "done";
  }
    
  protected void addSenderInfo(SenderInfo si, int index) 
    throws ArrayIndexOutOfBoundsException {
    if (index > -1)
      senderInfos.add(index,si);
    else
      senderInfos.add(si);
  }

  protected SenderInfo removeSenderInfo(int index)
    throws ArrayIndexOutOfBoundsException {
    return (SenderInfo) senderInfos.remove(index);
  }

  protected boolean removeSenderInfo(SenderInfo si) {
    return senderInfos.remove(si);
  }

  protected boolean updateSenderInfo(SenderInfo oldSi, SenderInfo newSi)
    throws ArrayIndexOutOfBoundsException {
    int index = senderInfos.indexOf(oldSi);
    if (index > -1) return false;
    senderInfos.set(index,newSi);
    return true;
  }

  public ClientMessages preProcess(AgentId from, ClientMessages not) {
    DMQManager dmqManager = null;
    for (Enumeration msgs = not.getMessages().elements(); msgs.hasMoreElements();) {
      Message msg = (Message) msgs.nextElement();
      SenderInfo si = match(msg);

      if (logger.isLoggable(BasicLevel.DEBUG))
        logger.log(BasicLevel.DEBUG, "--- " + this + " match=" + (si != null));
      if (si != null) {
        try {
          javaMailUtil.sendJavaMail(si, new MailMessage(msg));
        } catch (Exception exc) {
          if (dmqManager == null) {
            dmqManager = new DMQManager(not.getDMQId(), dmqId, getId());
          }
          nbMsgsSentToDMQSinceCreation++;
          dmqManager.addDeadMessage(msg, MessageErrorConstants.UNEXPECTED_ERROR);
          logger.log(BasicLevel.WARN, "JavaMailQueueImpl.sendJavaMail", exc);
        }
        not.getMessages().remove(msg);
      }
    }
    if (dmqManager != null) {
      dmqManager.sendToDMQ();
    }
    if (not.getMessages().size() > 0) {
      return not;
    }
    return null;
  }
  
  protected SenderInfo match(Message msg) {
    for (Enumeration e = senderInfos.elements(); e.hasMoreElements(); ) {
      SenderInfo si = (SenderInfo) e.nextElement();
      if (si.selector == null) return si;
      if (Selector.matches(msg,si.selector))
        return si;
    }
    return null;
  }

  public void doPop() {
    long count = 0;
    Vector toExpunge = new Vector();
    javax.mail.Message[] msgs = javaMailUtil.popMail(popServer,
                                                     popUser,
                                                     popPassword,
                                                     expunge);            
    if (msgs != null) {
      for (int i = 0; i < msgs.length; i++) {
        if (logger.isLoggable(BasicLevel.DEBUG))
          logger.log(BasicLevel.DEBUG, 
                     "--- " + this + " doPop : msgs[" + i + "] = " + msgs[i]);
        try {
          count++;
          Properties prop = javaMailUtil.getMOMProperties(msgs[i]);
          MailMessage m = 
            javaMailUtil.createMessage(prop,
                                       getId().toString()+"mail_"+count,
                                       Queue.getDestinationType(),
                                       getId().toString(),
                                       Queue.getDestinationType());
          storeMessage(new org.objectweb.joram.mom.messages.Message(m.getSharedMessage()));

          if (logger.isLoggable(BasicLevel.DEBUG))
            logger.log(BasicLevel.DEBUG, 
                       "--- " + this + " doPop : storeMessage m = " + m);
          if (expunge)
            toExpunge.add(msgs[i]);
        } catch (Exception exc) {
          if (logger.isLoggable(BasicLevel.DEBUG))
            logger.log(BasicLevel.DEBUG, 
                       "--- " + this + " doPop", exc);
          continue;
        }
      }
      deliverMessages(0);
    }

    javaMailUtil.closeFolder(toExpunge,expunge);
    toExpunge.clear();
  }
}

---