MailServiceImpl.java

package org.objectweb.jonas.mail;


import java.io.FileNotFoundException;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.List;
import java.util.Properties;
import java.util.StringTokenizer;
import java.util.Vector;

import javax.management.JMException;
import javax.management.MBeanServer;
import javax.management.ObjectName;
import javax.management.modelmbean.ModelMBean;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

import org.apache.commons.modeler.ManagedBean;
import org.apache.commons.modeler.Registry;
import org.objectweb.jonas.common.JModule;
import org.objectweb.jonas.common.JProp;
import org.objectweb.jonas.common.Log;
import org.objectweb.jonas.common.PropDump;
import org.objectweb.jonas.jmx.J2eeObjectName;
import org.objectweb.jonas.jmx.JmxService;
import org.objectweb.jonas.jmx.JonasObjectName;
import org.objectweb.jonas.mail.factory.JavaMail;
import org.objectweb.jonas.mail.factory.JavaMailMimePartDS;
import org.objectweb.jonas.mail.factory.JavaMailMimePartDSResource;
import org.objectweb.jonas.mail.factory.JavaMailSession;
import org.objectweb.jonas.mail.factory.JavaMailSessionResource;
import org.objectweb.jonas.management.JonasMBeanTools;
import org.objectweb.jonas.service.AbsServiceImpl;
import org.objectweb.jonas.service.ServiceException;
import org.objectweb.jonas.service.ServiceManager;
import org.objectweb.util.monolog.api.BasicLevel;
import org.objectweb.util.monolog.api.Logger;
public class MailServiceImpl extends AbsServiceImpl
    implements MailService, MailServiceImplMBean {

    private Vector mailSessionList = null;

    private Vector mailMimePartDSList = null;

    private MBeanServer mbeanServer = null;

    private Context ictx = null;

    // the name of the JOnAS server that is administerd by the MBeanServer
    // the current management domain's name
    protected String serverName = null;
    protected String domainName = null;

    private static Logger logger = null;

    private Vector factoryNames = new Vector();

    private Hashtable jMailSessionFactories = new Hashtable();

    private Hashtable jMailMimePartDSFactories = new Hashtable();

    private Hashtable bindedFactories = new Hashtable();

    private static final int JAVAX_MAIL_SESSION_FACTORY = 1;

    private static final int JAVAX_MAIL_INTERNET_MIMEPARTDATASOURCE = 2;

    public static final String PROPERTY_NAME = "mail.factory.name";

    public static final String PROPERTY_TYPE = "mail.factory.type";

    public static final String SESSION_PROPERTY_TYPE = "javax.mail.Session";
    public static final String MIMEPART_PROPERTY_TYPE = "javax.mail.internet.MimePartDataSource";

    public static final String FACTORIES = "jonas.service.mail.factories";

    public static final String CLASS = "jonas.service.mail.class";

    protected void doInit(Context ctx) throws ServiceException {

        // get logger for this service
        logger = Log.getLogger(Log.JONAS_MAIL_PREFIX);
        // the logger for reconfig management
        super.initLogger(Log.getLogger(Log.JONAS_MANAGEMENT_PREFIX));

        //Get the inital Context
        try {
            ictx = new InitialContext();
        } catch (NamingException e) {
            logger.log(BasicLevel.ERROR, "Cannot create initial context during the mail service initializing");
            throw new ServiceException("Cannot create initial context during the mail service initializing", e);
        }

        // Get the current server and domain names
        try {
            serverName = (String) ctx.lookup(JProp.JONAS_NAME);
            domainName = (String) ctx.lookup(JProp.DOMAIN_NAME);
        } catch (NamingException ne) {
            logger.log(BasicLevel.DEBUG, "Cannot initialize the Mail service " + ne);
            throw new ServiceException("Cannot initialize the Mail service", ne);
        }

        // Get the JMX Server via JMX Service
        try {
            mbeanServer =
                ((JmxService) ServiceManager.getInstance().getJmxService()).getJmxServer();
        } catch (Exception e) {
            // the JMX service may not be started
            mbeanServer = null;
        }

        // Get the list of the factory names
        String factories = null;
        try {
            factories = (String) ctx.lookup(FACTORIES);
        } catch (NamingException e) {
            ; // No problem if there is no value for 'factories'
        }
        if (factories != null) {
            StringTokenizer st = new StringTokenizer(factories, ",");
            while (st.hasMoreTokens()) {
                factoryNames.add(st.nextToken().trim());
            }
        }
        logger.log(BasicLevel.DEBUG, "Mail service initialized");

    }

    protected void doStart() throws ServiceException {

        // creates each factory
        String factoryName = null;
        for (int i = 0; i < factoryNames.size(); i++) {
            factoryName = (String) factoryNames.elementAt(i);
            try {
                JProp prop = JProp.getInstance(factoryName);
                if (logger.isLoggable(BasicLevel.DEBUG)) {
                    logger.log(BasicLevel.DEBUG, "Creating mail factory " + factoryName);
                }
                createMailFactory(factoryName, prop.getConfigFileEnv());
            } catch (Exception e) {
                if (logger.isLoggable(BasicLevel.ERROR)) {
                    logger.log(BasicLevel.ERROR, "JOnAS: Cannot create mail factory " + factoryName + " : " + e);
                    logger.log(BasicLevel.ERROR, "Please check the " + factoryName + ".properties file");
                }
            }
        }

        try {
            // Register MailService MBean : MailServiceImplMBean
            if (mbeanServer != null) {
                mbeanServer.registerMBean(this, JonasObjectName.mailService());
            }
        } catch (JMException e) {
            throw new ServiceException("Cannot start the MailService: " , e);
        }

    }

    protected void doStop() throws ServiceException {

        try {
            unbindMailFactories();
        } catch (MailServiceException e) {
            logger.log(BasicLevel.ERROR, "Cannot unbind mail factories " + e);
            throw new ServiceException("Cannot unbind mail factories ", e);
        }

        if (mbeanServer != null) {
            try {
                mbeanServer.unregisterMBean(JonasObjectName.mailService());
                // unregister all mail factories
            } catch (Exception e) {
                logger.log(BasicLevel.ERROR, "Cannot stop the Mail Service (JMX): " + e.getMessage());
                throw new ServiceException("Cannot stop the mail service (JMX).", e);
            }
        }
        logger.log(BasicLevel.DEBUG, "mail service stopped");
    }

    public void recreateJavaMailFactory(JavaMail factory) throws MailServiceException {
        String jndiName = factory.getName();
        // Rebind the factory object in the naming context
        try {
            ictx.rebind(jndiName, factory);
        } catch (NamingException e) {
            logger.log(BasicLevel.ERROR, "Cannot bind mail factory '" + jndiName + "'  :" + e.getMessage());
            throw new MailServiceException("Cannot bind mail factory " + jndiName + ".", e);
        }
    }

    public void renameJavaMailFactory(String oldName, JavaMail factory) throws MailServiceException {

        logger.log(BasicLevel.DEBUG, "In renameMailFactory, old name = " + oldName);
        try {
            ictx.unbind(oldName);
            logger.log(BasicLevel.DEBUG, oldName + " unbound");
        } catch (Exception e) {
            logger.log(BasicLevel.DEBUG, "Warning: cannot unbind mail factory object named " + oldName);
        }
        String jndiName = factory.getName();
        // Rebind the factory object in the naming context
        try {
            ictx.rebind(jndiName, factory);
            logger.log(BasicLevel.DEBUG, "factory rebound under the name " + jndiName);
        } catch (NamingException e) {
            logger.log(BasicLevel.ERROR, "Cannot bind mail factory '" + jndiName + "'  :" + e.getMessage());
            throw new MailServiceException("Cannot bind mail factory " + jndiName + ".", e);
        }
        bindedFactories.put(jndiName, factory.getFactoryName());
        bindedFactories.remove(oldName);
    }

    public void createMailFactory(String factoryName, Properties props)
        throws MailServiceException {

        PropDump.print("These are the properties from which the MailService picks to construct Mail Factories", props, logger, BasicLevel.DEBUG);

        Object factory = null;

        //Factory type/jndi name must be non null
        String factoryType = props.getProperty(PROPERTY_TYPE);
        String jndiName = props.getProperty(PROPERTY_NAME);

        if (jndiName == null) {
            logger.log(BasicLevel.ERROR, "The property 'mail.factory.name' is a required property.");
            throw new MailServiceException("The property 'mail.factory.name' is a required property for this factory.");
        }

        if (factoryType == null) {
            logger.log(BasicLevel.ERROR, "The property 'mail.factory.type' is a required property.");
            throw new MailServiceException("The property 'mail.factory.type' is a required property for this factory.");
        }

        // Verify that jndi name not already used
        if (bindedFactories.containsKey(jndiName)) {
            logger.log(BasicLevel.ERROR, "There is already a factory bound with the name " + jndiName);
            throw new MailServiceException("There is already a factory bound with the name '" + jndiName +  "', please correct the provided configuration properties");
        }

        //Define the type of our factory
        int typeOfFactory;
        if (factoryType.equalsIgnoreCase("javax.mail.Session")) {
            typeOfFactory = JAVAX_MAIL_SESSION_FACTORY;
        } else if (factoryType.equalsIgnoreCase("javax.mail.internet.MimePartDataSource")) {
            typeOfFactory = JAVAX_MAIL_INTERNET_MIMEPARTDATASOURCE;
        } else {
            typeOfFactory = 0;
        }

        // Create the factory object and register it in the internal data structure
        switch (typeOfFactory) {

        case JAVAX_MAIL_SESSION_FACTORY :
            JavaMailSession sessionFactory = new JavaMailSession(factoryName, jndiName, props);
            jMailSessionFactories.put(factoryName, sessionFactory);
            factory = sessionFactory;
            break;

        case JAVAX_MAIL_INTERNET_MIMEPARTDATASOURCE :
            JavaMailMimePartDS mimeFactory = new JavaMailMimePartDS(factoryName, jndiName, props);
            jMailMimePartDSFactories.put(factoryName, mimeFactory);
            factory = mimeFactory;
            break;

        default :
            throw new MailServiceException("Can not create a factory of the type '" + factoryType + "'. This type is incorrect.");
        }

        // Bind the factory object in the naming context
        try {
            ictx.rebind(jndiName, factory);
            bindedFactories.put(jndiName, factoryName);
        } catch (NamingException e) {
            logger.log(BasicLevel.ERROR, "Cannot bind mail factory '" + jndiName + "'  :" + e.getMessage());
            throw new MailServiceException("Cannot bind mail factory " + jndiName + ".", e);
        }

        logger.log(BasicLevel.INFO, "Mapping Mail Factory " + factoryType + " on " + jndiName);

        // Register the factory object as an MBean with the jmx server
        // Get the MBean register (and load mbeans-descriptors)
        Registry oRegistry = JonasMBeanTools.getRegistry();

        // Register the factory object as an MBean with the jmx server
        try {
            if (mbeanServer != null) {
                ObjectName on = null;
                switch (typeOfFactory) {
                case JAVAX_MAIL_SESSION_FACTORY :
                    // J2EEManagement

                    on = J2eeObjectName.JavaMailResource(domainName, factoryName, serverName, SESSION_PROPERTY_TYPE);
                    JavaMailSessionResource javaMailSessionResource = new JavaMailSessionResource(on.toString(), false, false, false, (JavaMailSession) factory);
                    // JSR77
                    ManagedBean oManaged = oRegistry.findManagedBean("JavaMailSessionResource");
                    ModelMBean oMBean = oManaged.createMBean(javaMailSessionResource);
                    mbeanServer.registerMBean(oMBean, on);
                    //mbeanServer.registerMBean(s_mbean, on);
                    if (logger.isLoggable(BasicLevel.DEBUG)) {
                        logger.log(BasicLevel.DEBUG, "Register session mail factory with name " + factoryName);
                    }
                    break;
                case JAVAX_MAIL_INTERNET_MIMEPARTDATASOURCE :
                    // J2EEManagement
                    on = J2eeObjectName.JavaMailResource(domainName, factoryName, serverName, MIMEPART_PROPERTY_TYPE);
                    JavaMailMimePartDSResource javaMailMimePartDSResource = new JavaMailMimePartDSResource(on.toString(), false, false, false, (JavaMailMimePartDS) factory);
                    // JSR77
                    oManaged = oRegistry.findManagedBean("JavaMailMimePartDSResource");
                    oMBean = oManaged.createMBean(javaMailMimePartDSResource);
                    mbeanServer.registerMBean(oMBean, on);
                    if (logger.isLoggable(BasicLevel.DEBUG)) {
                        logger.log(BasicLevel.DEBUG, "Register mime mail factory with name " + factoryName);
                    }
                }
            }
        } catch (JMException me) {
            throw new MailServiceException("Cannot register mail factory '" + factoryName + "' in JMX server", me);
        } catch (Exception e) {
            logger.log(BasicLevel.WARN, "Could not register JavaMailResource MBean");
        }


    }

    public void createMailFactoryMBean(String name, Properties props, Boolean loadFromFile)
        throws MailServiceException {

        boolean fromFile = loadFromFile.booleanValue();
        if (!fromFile) {
            try {
                logger.log(BasicLevel.DEBUG, "Call getInstance on JProp in order to create the properties file");
                JProp.getInstance(name, props);
            } catch (Exception e) {
                logger.log(BasicLevel.ERROR, "Cannot create mail factory " + name + " as cannot create properties file : " + e.toString());
                throw new ServiceException("MailService: Cannot create mail factory " + name + ",\n" + e.toString());
            }
        }
        //call the internal proc
        try {
            createMailFactory(name, props);
        } catch (Exception e) {
            logger.log(BasicLevel.ERROR, "Cannot create mail factory: " + name);
            throw new ServiceException("MailService: Cannot create mail factory: " + name + ",\n" + e.toString());
        }
    }

    public void unbindMailFactories() throws MailServiceException {
        //Unbind all factories
        for (Enumeration e = jMailSessionFactories.keys(); e.hasMoreElements();) {
            unbindMailFactoryMBean((String) e.nextElement());
        }
        for (Enumeration e = jMailMimePartDSFactories.keys(); e.hasMoreElements();) {
            unbindMailFactoryMBean((String) e.nextElement());
        }
    }

    public void unbindMailFactoryMBean(String factoryName)
        throws MailServiceException {

        // determine the type of the factory and the jndi name
        String name = null;
        int typeOfFactory;
        JavaMailSession jmailSession = (JavaMailSession) jMailSessionFactories.get(factoryName);
        JavaMailMimePartDS jMailMimePartDS = (JavaMailMimePartDS) jMailMimePartDSFactories.get(factoryName);
        if (jmailSession != null) {
            name = jmailSession.getName();
            typeOfFactory = JAVAX_MAIL_SESSION_FACTORY;
        } else if (jMailMimePartDS != null) {
            name = jMailMimePartDS.getName();
            typeOfFactory = JAVAX_MAIL_INTERNET_MIMEPARTDATASOURCE;
        } else {
            throw new MailServiceException("Can not unload the mail factory '" + factoryName + "' (this is not a known factory name");
        }

        // unbind the factory
        try {
            ictx.unbind(name);
            bindedFactories.remove(name);
        } catch (NamingException e) {
            throw new MailServiceException("Can not unbind the factory '" + name + "'.", e);
        }

        // De-register the factory object from the jmx server and remove the factory from the internal data structure
        try {
            if (mbeanServer != null) {
                ObjectName on = null;
                switch (typeOfFactory) {
                case JAVAX_MAIL_SESSION_FACTORY :
                    // J2EEManagement
                    on = J2eeObjectName.JavaMailResource(domainName, factoryName, serverName, SESSION_PROPERTY_TYPE);
                    mbeanServer.unregisterMBean(on);
                    if (logger.isLoggable(BasicLevel.DEBUG)) {
                        logger.log(BasicLevel.DEBUG, "Unregister session mail factory with name " + factoryName);
                    }
                    jMailSessionFactories.remove(factoryName);
                    break;
                case JAVAX_MAIL_INTERNET_MIMEPARTDATASOURCE :
                    // J2EEManagement
                    on = J2eeObjectName.JavaMailResource(domainName, factoryName, serverName, MIMEPART_PROPERTY_TYPE);
                    mbeanServer.unregisterMBean(on);
                    if (logger.isLoggable(BasicLevel.DEBUG)) {
                        logger.log(BasicLevel.DEBUG, "Unregister mime mail factory with name " + factoryName);
                    }
                    jMailMimePartDSFactories.remove(factoryName);
                }
            }
        } catch (JMException me) {
            throw new MailServiceException("Cannot unregister mail factory '" + factoryName + "' from the JMX server", me);
        }


    }

    public String getFactoryName(String jndiName) {
        return (String) bindedFactories.get(jndiName);
    }

    public Integer getCurrentNumberOfMailFactories() {
        return new Integer(jMailSessionFactories.size() + jMailMimePartDSFactories.size());
    }

    public Integer getCurrentNumberOfSessionMailFactories() {
        return new Integer(jMailSessionFactories.size());
    }

    public Integer getCurrentNumberOfMimeMailFactories() {
        return new Integer(jMailMimePartDSFactories.size());
    }

    public Properties getMailFactoryPropertiesFile(String configFile) throws Exception {
        try {
            return JProp.getInstance(configFile).getConfigFileEnv();
        } catch (Exception e) {
            if (e instanceof FileNotFoundException) {
                logger.log(BasicLevel.ERROR, "Please check if " + configFile + ".properties is available in JONAS_ROOT/config, HOME, or .");
            } else {
                logger.log(BasicLevel.ERROR, "Error occured when reading file " + configFile);
            }
            throw e;
        }
    }

    public List getMailFactoryPropertiesFiles() throws Exception {
        return JModule.getMailFactoryPropsInDir();
    }
    public List getMimePartMailFactoryPropertiesFiles() throws Exception {
        return JModule.getMailFactoryPropsInDir(MIMEPART_PROPERTY_TYPE);
    }
    public List getSessionMailFactoryPropertiesFiles() throws Exception {
        return JModule.getMailFactoryPropsInDir(SESSION_PROPERTY_TYPE);
    }
}

---