Quadcap Embeddable Server

com/quadcap/pop3/client/Pop3Service.java

Go to the documentation of this file.

package com.quadcap.pop3.client;

/* Copyright 1997 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

import com.quadcap.util.text.Text;

import com.quadcap.server.ServiceImpl;
import com.quadcap.server.ServiceContainer;

import com.quadcap.util.Debug;

/**
 * Service wrapper for quadcap POP3 client fetcher
 *
 * @author Stan Bailes
 */
public class Pop3Service extends ServiceImpl {
    Thread                      thread;
    boolean                     terminate = false;
    Properties                  props;
    Object                      lock = new Object();
    
    public void init(ServiceContainer c, Properties p)
        throws Exception
    {
        super.init(c, p);
        props = getProperties();
        final long sleepMs = 1000L *
            Integer.parseInt(props.getProperty("interval", "60"));
        terminate = false;
        thread = new Thread() {
                public void run() {
                    while (!terminate) {
                        try {
                            runAgent();
                        } catch (Throwable t) {
                            Debug.print(t);
                        }
                        try { Thread.sleep(sleepMs); } catch (Throwable t) {}
                    }
                }
            };
        thread.start();
    }

    static ArrayList getTuples(File tf) throws Exception {
        ArrayList a = new ArrayList();
        FileInputStream fi = new FileInputStream(tf);
        HashMap object = null;
        try {
            InputStreamReader isr = new InputStreamReader(fi);
            BufferedReader r = new BufferedReader(isr);
            StringBuffer buf = new StringBuffer();
            String line;
            boolean haveBuffer = false;
            while ((line = r.readLine()) != null) {
                if (line.length() > 0) {
                    if (!haveBuffer) {
                        buf.replace(0, buf.length(), line.trim());
                        haveBuffer = true;
                    } else {
                        if (Character.isWhitespace(line.charAt(0))) {
                            buf.append(' ');
                            buf.append(line.trim());
                        } else {
                            object = addAttr(object, buf.toString());
                            buf.replace(0, buf.length(), line.trim());
                        }
                    }
                } else {
                    if (object != null) {
                        if (haveBuffer) {
                            object = addAttr(object, buf.toString());
                            haveBuffer = false;
                        }
                        a.add(object);
                        object = null;
                    }
                }
            }
            if (haveBuffer) {
                object = addAttr(object, buf.toString());
            }
            if (object != null) a.add(object);
            return a;
        } finally {
            fi.close();
        }
    }

    static final HashMap addAttr(HashMap h, String s) {
        if (h == null) h = new HashMap();
        String[] sv = Text.extractN(s, "*:*");
        if (sv == null || sv.length != 2 || sv[0] == null || sv[1] == null) {
            //msg("Bad attribute: " + s);
        } else {
            h.put(sv[0].trim(), sv[1].trim());
        }
        return h;
    }

    public void stop() {
        terminate = true;
        synchronized (lock) {
            try { thread.interrupt(); } catch (Throwable t) {}
        }
    }

    public void runAgent() throws Exception {
        synchronized (lock) {
            File accountsFile = new File(props.getProperty("accounts"));
            ArrayList agents = getTuples(accountsFile);
            String hooker = props.getProperty("hook");
            Class hookerClass = Class.forName(hooker);
            MessageHook hook = (MessageHook)hookerClass.newInstance();
            hook.init(props);
            for (int i = 0; i < agents.size(); i++) {
                Map ai = (Map)agents.get(i);
                Pop3Agent agent = readAgent(ai);
                if (agent != null) {
                    Properties p = new Properties();
                    p.putAll(props);
                    p.putAll(ai);
                    agent.run(p, hook);
                    writeAgent(ai, agent);
                }
            }
        }
    }

    public Pop3Agent readAgent(Map ai) {
        try {
            String name = ai.get("name").toString();
            String fileName = props.getProperty("savefile", "pop3." +
                                                name + ".save");
            File file = new File(fileName);
            Pop3Agent agent = new Pop3Agent();
            if (file.exists()) {
                FileInputStream fis = new FileInputStream(fileName);
                try {
                    BufferedInputStream bis = new BufferedInputStream(fis);
                    agent.read(bis);
                } finally {
                    fis.close();
                }
            }
            return agent;
        } catch (Throwable t) {
            Debug.print(t);
            return null;
        }
    }

    public void writeAgent(Map ai, Pop3Agent agent) {
        FileOutputStream fos = null;
        try {
            String name = ai.get("name").toString();
            String fileName = props.getProperty("savefile", "pop3." +
                                                name + ".save");
            fos = new FileOutputStream(fileName);
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            agent.write(bos);
            bos.flush();
        } catch (Throwable t) {
            Debug.print(t);
        } finally {
            if (fos != null) {
                try { fos.close(); } catch (Throwable t) {}
            }
        }
    }
}